1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

# This file is part of Beremiz, a Integrated Development Environment for

     5

# programming IEC 61131-3 automates supporting plcopen standard and CanFestival.

     6

#

     7

# Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD

     8

#

     9

# See COPYING file for copyrights details.

    10

#

    11

# This program is free software; you can redistribute it and/or

    12

# modify it under the terms of the GNU General Public License

    13

# as published by the Free Software Foundation; either version 2

    14

# of the License, or (at your option) any later version.

    15

#

    16

# This program is distributed in the hope that it will be useful,

    17

# but WITHOUT ANY WARRANTY; without even the implied warranty of

    18

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    19

# GNU General Public License for more details.

    20

#

    21

# You should have received a copy of the GNU General Public License

    22

# along with this program; if not, write to the Free Software

    23

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

    24

    25

import re

    26

import math

    27

from time import time as gettime

    28

from types import TupleType

    29

from threading import Lock

    30

    31

import wx

    32

    33

from plcopen.structures import *

    34

from PLCControler import ITEM_VAR_LOCAL, ITEM_POU, ITEM_PROGRAM, ITEM_FUNCTIONBLOCK

    35

    36

from dialogs import *

    37

from graphics import *

    38

from editors.DebugViewer import DebugViewer, REFRESH_PERIOD

    39

from EditorPanel import EditorPanel

    40

    41

SCROLLBAR_UNIT = 10

    42

WINDOW_BORDER = 10

    43

SCROLL_ZONE = 10

    44

    45

CURSORS = None

    47

    48

def ResetCursors():

    49

    global CURSORS

    50

    if CURSORS == None:

    51

        CURSORS = [wx.NullCursor,

    52

                   wx.StockCursor(wx.CURSOR_HAND),

    53

                   wx.StockCursor(wx.CURSOR_SIZENWSE),

    54

                   wx.StockCursor(wx.CURSOR_SIZENESW),

    55

                   wx.StockCursor(wx.CURSOR_SIZEWE),

    56

                   wx.StockCursor(wx.CURSOR_SIZENS)]

    57

    58

def AppendMenu(parent, help, id, kind, text):

    59

    if wx.VERSION >= (2, 6, 0):

    60

        parent.Append(help=help, id=id, kind=kind, text=text)

    61

    else:

    62

        parent.Append(helpString=help, id=id, kind=kind, item=text)

    63

    64

if wx.Platform == '__WXMSW__':

    65

    faces = { 'times': 'Times New Roman',

    66

              'mono' : 'Courier New',

    67

              'helv' : 'Arial',

    68

              'other': 'Comic Sans MS',

    69

              'size' : 10,

    70

             }

    71

else:

    72

    faces = { 'times': 'Times',

    73

              'mono' : 'Courier',

    74

              'helv' : 'Helvetica',

    75

              'other': 'new century schoolbook',

    76

              'size' : 12,

    77

             }

    78

    79

if wx.Platform == '__WXMSW__':

    80

    MAX_ZOOMIN = 4

    81

else:

    82

    MAX_ZOOMIN = 7

    83

ZOOM_FACTORS = [math.sqrt(2) ** x for x in xrange(-6, MAX_ZOOMIN)]

    84

    85

def GetVariableCreationFunction(variable_type):

    86

    def variableCreationFunction(viewer, id, specific_values):

    87

        return FBD_Variable(viewer, variable_type,

    88

                                    specific_values.name,

    89

                                    specific_values.value_type,

    90

                                    id,

    91

                                    specific_values.execution_order)

    92

    return variableCreationFunction

    93

    94

def GetConnectorCreationFunction(connector_type):

    95

    def connectorCreationFunction(viewer, id, specific_values):

    96

        return FBD_Connector(viewer, connector_type,

    97

                                     specific_values.name, id)

    98

    return connectorCreationFunction

    99

   100

def commentCreationFunction(viewer, id, specific_values):

   101

    return Comment(viewer, specific_values.content, id)

   102

   103

def GetPowerRailCreationFunction(powerrail_type):

   104

    def powerRailCreationFunction(viewer, id, specific_values):

   105

        return LD_PowerRail(viewer, powerrail_type, id,

   106

                                    specific_values.connectors)

   107

    return powerRailCreationFunction

   108

   109

NEGATED_VALUE = lambda x: x if x is not None else False

   110

MODIFIER_VALUE = lambda x: x if x is not None else 'none'

   111

   112

CONTACT_TYPES = {(True, "none"): CONTACT_REVERSE,

   113

                 (False, "rising"): CONTACT_RISING,

   114

                 (False, "falling"): CONTACT_FALLING}

   115

   116

def contactCreationFunction(viewer, id, specific_values):

   117

    contact_type = CONTACT_TYPES.get((NEGATED_VALUE(specific_values.negated),

   118

                                      MODIFIER_VALUE(specific_values.edge)),

   119

                                     CONTACT_NORMAL)

   120

    return LD_Contact(viewer, contact_type, specific_values.name, id)

   121

   122

COIL_TYPES = {(True, "none", "none"): COIL_REVERSE,

   123

              (False, "none", "set"): COIL_SET,

   124

              (False, "none", "reset"): COIL_RESET,

   125

              (False, "rising", "none"): COIL_RISING,

   126

              (False, "falling", "none"): COIL_FALLING}

   127

   128

def coilCreationFunction(viewer, id, specific_values):

   129

    coil_type = COIL_TYPES.get((NEGATED_VALUE(specific_values.negated),

   130

                                MODIFIER_VALUE(specific_values.edge),

   131

                                MODIFIER_VALUE(specific_values.storage)),

   132

                               COIL_NORMAL)

   133

    return LD_Coil(viewer, coil_type, specific_values.name, id)

   134

   135

def stepCreationFunction(viewer, id, specific_values):

   136

    step = SFC_Step(viewer, specific_values.name,

   137

                            specific_values.initial, id)

   138

    if specific_values.action is not None:

   139

        step.AddAction()

   140

        connector = step.GetActionConnector()

   141

        connector.SetPosition(wx.Point(*specific_values.action.position))

   142

    return step

   143

   144

def transitionCreationFunction(viewer, id, specific_values):

   145

    transition = SFC_Transition(viewer, specific_values.condition_type,

   146

                                        specific_values.condition,

   147

                                        specific_values.priority, id)

   148

    return transition

   149

   153

def GetDivergenceCreationFunction(divergence_type):

   154

    def divergenceCreationFunction(viewer, id, specific_values):

   155

        return SFC_Divergence(viewer, divergence_type,

   156

                                      specific_values.connectors, id)

   157

    return divergenceCreationFunction

   158

   159

def jumpCreationFunction(viewer, id, specific_values):

   160

    return SFC_Jump(viewer, specific_values.target, id)

   161

   162

def actionBlockCreationFunction(viewer, id, specific_values):

   163

    return SFC_ActionBlock(viewer, specific_values.actions, id)

   164

   165

ElementCreationFunctions = {

   166

    "input": GetVariableCreationFunction(INPUT),

   167

    "output": GetVariableCreationFunction(OUTPUT),

   168

    "inout": GetVariableCreationFunction(INOUT),

   169

    "connector": GetConnectorCreationFunction(CONNECTOR),

   170

    "continuation": GetConnectorCreationFunction(CONTINUATION),

   171

    "comment": commentCreationFunction,

   172

    "leftPowerRail": GetPowerRailCreationFunction(LEFTRAIL),

   173

    "rightPowerRail": GetPowerRailCreationFunction(RIGHTRAIL),

   174

    "contact": contactCreationFunction,

   175

    "coil": coilCreationFunction,

   176

    "step": stepCreationFunction,

   177

    "transition": transitionCreationFunction,

   178

    "selectionDivergence": GetDivergenceCreationFunction(SELECTION_DIVERGENCE),

   179

    "selectionConvergence": GetDivergenceCreationFunction(SELECTION_CONVERGENCE),

   180

    "simultaneousDivergence": GetDivergenceCreationFunction(SIMULTANEOUS_DIVERGENCE),

   181

    "simultaneousConvergence": GetDivergenceCreationFunction(SIMULTANEOUS_CONVERGENCE),

   182

    "jump": jumpCreationFunction,

   183

    "actionBlock": actionBlockCreationFunction,

   184

}

   185

   186

def sort_blocks(block_infos1, block_infos2):

   187

    x1, y1 = block_infos1[0].GetPosition()

   188

    x2, y2 = block_infos2[0].GetPosition()

   189

    if y1 == y2:

   190

        return cmp(x1, x2)

   191

    else:

   192

        return cmp(y1, y2)

   193

   194

#-------------------------------------------------------------------------------

   195

#                       Graphic elements Viewer base class

   196

#-------------------------------------------------------------------------------

   197

   198

# ID Constants for alignment menu items

   199

[ID_VIEWERALIGNMENTMENUITEMS0, ID_VIEWERALIGNMENTMENUITEMS1,

   200

 ID_VIEWERALIGNMENTMENUITEMS2, ID_VIEWERALIGNMENTMENUITEMS4,

   201

 ID_VIEWERALIGNMENTMENUITEMS5, ID_VIEWERALIGNMENTMENUITEMS6,

   202

] = [wx.NewId() for _init_coll_AlignmentMenu_Items in range(6)]

   203

   204

# ID Constants for contextual menu items

   205

[ID_VIEWERCONTEXTUALMENUITEMS0, ID_VIEWERCONTEXTUALMENUITEMS1,

   206

 ID_VIEWERCONTEXTUALMENUITEMS2, ID_VIEWERCONTEXTUALMENUITEMS3,

   207

 ID_VIEWERCONTEXTUALMENUITEMS5, ID_VIEWERCONTEXTUALMENUITEMS6,

   208

 ID_VIEWERCONTEXTUALMENUITEMS8, ID_VIEWERCONTEXTUALMENUITEMS9,

   209

 ID_VIEWERCONTEXTUALMENUITEMS11, ID_VIEWERCONTEXTUALMENUITEMS12,

   210

 ID_VIEWERCONTEXTUALMENUITEMS14, ID_VIEWERCONTEXTUALMENUITEMS16,

   211

 ID_VIEWERCONTEXTUALMENUITEMS17,

   212

] = [wx.NewId() for _init_coll_ContextualMenu_Items in range(13)]

   213

   214

   215

class ViewerDropTarget(wx.TextDropTarget):

   216

   217

    def __init__(self, parent):

   218

        wx.TextDropTarget.__init__(self)

   219

        self.ParentWindow = parent

   220

   221

    def OnDropText(self, x, y, data):

   222

        self.ParentWindow.Select()

   223

        tagname = self.ParentWindow.GetTagName()

   224

        pou_name, pou_type = self.ParentWindow.Controler.GetEditedElementType(tagname, self.ParentWindow.Debug)

   225

        x, y = self.ParentWindow.CalcUnscrolledPosition(x, y)

   226

        x = int(x / self.ParentWindow.ViewScale[0])

   227

        y = int(y / self.ParentWindow.ViewScale[1])

   228

        scaling = self.ParentWindow.Scaling

   229

        message = None

   230

        try:

   231

            values = eval(data)

   232

        except:

   233

            message = _("Invalid value \"%s\" for viewer block")%data

   234

            values = None

   235

        if not isinstance(values, TupleType):

   236

            message = _("Invalid value \"%s\" for viewer block")%data

   237

            values = None

   238

        if values is not None:

   239

            if values[1] == "debug":

   240

                pass

   241

            elif values[1] == "program":

   242

                message = _("Programs can't be used by other POUs!")

   243

            elif values[1] in ["function", "functionBlock"]:

   244

                words = tagname.split("::")

   245

                if pou_name == values[0]:

   246

                    message = _("\"%s\" can't use itself!")%pou_name

   247

                elif pou_type == "function" and values[1] != "function":

   248

                    message = _("Function Blocks can't be used in Functions!")

   249

                elif self.ParentWindow.Controler.PouIsUsedBy(pou_name, values[0], self.ParentWindow.Debug):

   250

                    message = _("\"{a1}\" is already used by \"{a2}\"!").format(a1 = pou_name, a2 = values[0])

   251

                else:

   252

                    blockname = values[2]

   253

                    if len(values) > 3:

   254

                        blockinputs = values[3]

   255

                    else:

   256

                        blockinputs = None

   257

                    if values[1] != "function" and blockname == "":

   258

                        blockname = self.ParentWindow.GenerateNewName(blocktype=values[0])

   259

                    if blockname.upper() in [name.upper() for name in self.ParentWindow.Controler.GetProjectPouNames(self.ParentWindow.Debug)]:

   260

                        message = _("\"%s\" pou already exists!")%blockname

   261

                    elif blockname.upper() in [name.upper() for name in self.ParentWindow.Controler.GetEditedElementVariables(tagname, self.ParentWindow.Debug)]:

   262

                        message = _("\"%s\" element for this pou already exists!")%blockname

   263

                    else:

   264

                        id = self.ParentWindow.GetNewId()

   265

                        block = FBD_Block(self.ParentWindow, values[0], blockname, id, inputs = blockinputs)

   266

                        width, height = block.GetMinSize()

   267

                        if scaling is not None:

   268

                            x = round(float(x) / float(scaling[0])) * scaling[0]

   269

                            y = round(float(y) / float(scaling[1])) * scaling[1]

   270

                            width = round(float(width) / float(scaling[0]) + 0.5) * scaling[0]

   271

                            height = round(float(height) / float(scaling[1]) + 0.5) * scaling[1]

   272

                        block.SetPosition(x, y)

   273

                        block.SetSize(width, height)

   274

                        self.ParentWindow.AddBlock(block)

   275

                        self.ParentWindow.Controler.AddEditedElementBlock(tagname, id, values[0], blockname)

   276

                        self.ParentWindow.RefreshBlockModel(block)

   277

                        self.ParentWindow.RefreshBuffer()

   278

                        self.ParentWindow.RefreshScrollBars()

   279

                        self.ParentWindow.RefreshVisibleElements()

   280

                        self.ParentWindow.RefreshVariablePanel()

   281

                        self.ParentWindow.ParentWindow.RefreshPouInstanceVariablesPanel()

   282

                        self.ParentWindow.Refresh(False)

   283

            elif values[1] == "location":

   284

                if pou_type == "program":

   285

                    location = values[0]

   286

                    if not location.startswith("%"):

   287

                        dialog = wx.SingleChoiceDialog(self.ParentWindow.ParentWindow,

   288

                              _("Select a variable class:"), _("Variable class"),

   289

                              [_("Input"), _("Output"), _("Memory")],

   290

                              wx.DEFAULT_DIALOG_STYLE|wx.OK|wx.CANCEL)

   291

                        if dialog.ShowModal() == wx.ID_OK:

   292

                            selected = dialog.GetSelection()

   293

                        else:

   294

                            selected = None

   295

                        dialog.Destroy()

   296

                        if selected is None:

   297

                            return

   298

                        if selected == 0:

   299

                            location = "%I" + location

   300

                        elif selected == 1:

   301

                            location = "%Q" + location

   302

                        else:

   303

                            location = "%M" + location

   304

                    var_name = values[3]

   305

                    dlg = wx.TextEntryDialog(

   306

                        self.ParentWindow.ParentWindow,

   307

                        _("Confirm or change variable name"),

   308

                        _('Variable Drop'), var_name)

   309

                    dlg.SetValue(var_name)

   310

                    var_name = dlg.GetValue() if dlg.ShowModal() == wx.ID_OK else None

   311

                    dlg.Destroy()

   312

                    if var_name is None:

   313

                        return

   314

                    elif var_name.upper() in [name.upper() for name in self.ParentWindow.Controler.GetProjectPouNames(self.ParentWindow.Debug)]:

   315

                        message = _("\"%s\" pou already exists!")%var_name

   316

                    elif not var_name.upper() in [name.upper() for name in self.ParentWindow.Controler.GetEditedElementVariables(tagname, self.ParentWindow.Debug)]:

   317

                        if location[1] == "Q":

   318

                            var_class = OUTPUT

   319

                        else:

   320

                            var_class = INPUT

   321

                        if values[2] is not None:

   322

                            var_type = values[2]

   323

                        else:

   324

                            var_type = LOCATIONDATATYPES.get(location[2], ["BOOL"])[0]

   325

                        self.ParentWindow.Controler.AddEditedElementPouVar(tagname, var_type, var_name, location=location, description=values[4])

   326

                        self.ParentWindow.RefreshVariablePanel()

   327

                        self.ParentWindow.ParentWindow.RefreshPouInstanceVariablesPanel()

   328

                        self.ParentWindow.AddVariableBlock(x, y, scaling, var_class, var_name, var_type)

   329

                    else:

   330

                        message = _("\"%s\" element for this pou already exists!")%var_name

   331

            elif values[1] == "NamedConstant":

   332

                if pou_type == "program":

   333

                    initval = values[0]

   334

                    var_name = values[3]

   335

                    dlg = wx.TextEntryDialog(

   336

                        self.ParentWindow.ParentWindow,

   337

                        _("Confirm or change variable name"),

   338

                        _('Variable Drop'), var_name)

   339

                    dlg.SetValue(var_name)

   340

                    var_name = dlg.GetValue() if dlg.ShowModal() == wx.ID_OK else None

   341

                    dlg.Destroy()

   342

                    if var_name is None:

   343

                        return

   344

                    elif var_name.upper() in [name.upper() for name in self.ParentWindow.Controler.GetProjectPouNames(self.ParentWindow.Debug)]:

   345

                        message = _("\"%s\" pou already exists!")%var_name

   346

                    elif not var_name.upper() in [name.upper() for name in self.ParentWindow.Controler.GetEditedElementVariables(tagname, self.ParentWindow.Debug)]:

   347

                        var_class = INPUT

   348

                        var_type = values[2]

   349

                        self.ParentWindow.Controler.AddEditedElementPouVar(tagname, var_type, var_name, description=values[4], initval=initval)

   350

                        self.ParentWindow.RefreshVariablePanel()

   351

                        self.ParentWindow.ParentWindow.RefreshPouInstanceVariablesPanel()

   352

                        self.ParentWindow.AddVariableBlock(x, y, scaling, var_class, var_name, var_type)

   353

                    else:

   354

                        message = _("\"%s\" element for this pou already exists!")%var_name

   355

            elif values[1] == "Global":

   356

                var_name = values[0]

   357

                dlg = wx.TextEntryDialog(

   358

                    self.ParentWindow.ParentWindow,

   359

                    _("Confirm or change variable name"),

   360

                    _('Variable Drop'), var_name)

   361

                dlg.SetValue(var_name)

   362

                var_name = dlg.GetValue() if dlg.ShowModal() == wx.ID_OK else None

   363

                dlg.Destroy()

   364

                if var_name is None:

   365

                    return

   366

                elif var_name.upper() in [name.upper() for name in self.ParentWindow.Controler.GetProjectPouNames(self.ParentWindow.Debug)]:

   367

                    message = _("\"%s\" pou already exists!")%var_name

   368

                elif not var_name.upper() in [name.upper() for name in self.ParentWindow.Controler.GetEditedElementVariables(tagname, self.ParentWindow.Debug)]:

   369

                    self.ParentWindow.Controler.AddEditedElementPouExternalVar(tagname, values[2], var_name)

   370

                    self.ParentWindow.RefreshVariablePanel()

   371

                    self.ParentWindow.ParentWindow.RefreshPouInstanceVariablesPanel()

   372

                    self.ParentWindow.AddVariableBlock(x, y, scaling, INPUT, var_name, values[2])

   373

                else:

   374

                    message = _("\"%s\" element for this pou already exists!")%var_name

   375

            elif values[1] == "Constant":

   376

                self.ParentWindow.AddVariableBlock(x, y, scaling, INPUT, values[0], None)

   377

            elif values[3] == tagname:

   378

                if values[1] == "Output":

   379

                    var_class = OUTPUT

   380

                elif values[1] == "InOut":

   381

                    var_class = INPUT

   382

                else:

   383

                    var_class = INPUT

   384

                tree = dict([(var.Name, var.Tree) for var in self.ParentWindow.Controler.GetEditedElementInterfaceVars(tagname, True, self.ParentWindow.Debug)]).get(values[0], None)

   385

                if tree is not None:

   386

                    if len(tree[0]) > 0:

   387

                        menu = wx.Menu(title='')

   388

                        self.GenerateTreeMenu(x, y, scaling, menu, "", var_class, [(values[0], values[2], tree)])

   389

                        self.ParentWindow.PopupMenuXY(menu)

   390

                    else:

   391

                        self.ParentWindow.AddVariableBlock(x, y, scaling, var_class, values[0], values[2])

   392

                else:

   393

                    message = _("Unknown variable \"%s\" for this POU!") % values[0]

   394

            else:

   395

                message = _("Variable don't belong to this POU!")

   396

        if message is not None:

   397

            wx.CallAfter(self.ShowMessage, message)

   398

   399

    def GenerateTreeMenu(self, x, y, scaling, menu, base_path, var_class, tree):

   400

        for child_name, child_type, (child_tree, child_dimensions) in tree:

   401

            if base_path:

   402

                child_path = "%s.%s" % (base_path, child_name)

   403

            else:

   404

                child_path = child_name

   405

            if len(child_dimensions) > 0:

   406

                child_path += "[%s]" % ",".join([str(dimension[0]) for dimension in child_dimensions])

   407

                child_name += "[]"

   408

            new_id = wx.NewId()

   409

            AppendMenu(menu, help='', id=new_id, kind=wx.ITEM_NORMAL, text=child_name)

   410

            self.ParentWindow.Bind(wx.EVT_MENU, self.GetAddVariableBlockFunction(x, y, scaling, var_class, child_path, child_type), id=new_id)

   411

            if len(child_tree) > 0:

   412

                new_id = wx.NewId()

   413

                child_menu = wx.Menu(title='')

   414

                self.GenerateTreeMenu(x, y, scaling, child_menu, child_path, var_class, child_tree)

   415

                menu.AppendMenu(new_id, "%s." % child_name, child_menu)

   416

   417

    def GetAddVariableBlockFunction(self, x, y, scaling, var_class, var_name, var_type):

   418

        def AddVariableFunction(event):

   419

            self.ParentWindow.AddVariableBlock(x, y, scaling, var_class, var_name, var_type)

   420

        return AddVariableFunction

   421

   422

    def ShowMessage(self, message):

   423

        message = wx.MessageDialog(self.ParentWindow, message, _("Error"), wx.OK|wx.ICON_ERROR)

   424

        message.ShowModal()

   425

        message.Destroy()

   426

   427

"""

   428

Class that implements a Viewer based on a wx.ScrolledWindow for drawing and

   429

manipulating graphic elements

   430

"""

   431

   432

class Viewer(EditorPanel, DebugViewer):

   433

   434

    if wx.VERSION < (2, 6, 0):

   435

        def Bind(self, event, function, id = None):

   436

            if id is not None:

   437

                event(self, id, function)

   438

            else:

   439

                event(self, function)

   440

   441

    # Add list of menu items to the given menu

   442

    def AddMenuItems(self, menu, items):

   443

        for item in items:

   444

            if item is None:

   445

                menu.AppendSeparator()

   446

            else:

   447

                id, kind, text, help, callback = item

   448

                AppendMenu(menu, help=help, id=id, kind=kind, text=text)

   449

                # Link menu event to corresponding called functions

   450

                self.Bind(wx.EVT_MENU, callback, id=id)

   451

   452

    # Add Block Pin Menu items to the given menu

   453

    def AddBlockPinMenuItems(self, menu, connector):

   454

        [ID_NO_MODIFIER, ID_NEGATED, ID_RISING_EDGE,

   455

         ID_FALLING_EDGE] = [wx.NewId() for i in xrange(4)]

   456

   457

        # Create menu items

   458

        self.AddMenuItems(menu, [

   459

            (ID_NO_MODIFIER, wx.ITEM_RADIO, _(u'No Modifier'), '', self.OnNoModifierMenu),

   460

            (ID_NEGATED, wx.ITEM_RADIO, _(u'Negated'), '', self.OnNegatedMenu),

   461

            (ID_RISING_EDGE, wx.ITEM_RADIO, _(u'Rising Edge'), '', self.OnRisingEdgeMenu),

   462

            (ID_FALLING_EDGE, wx.ITEM_RADIO, _(u'Falling Edge'), '', self.OnFallingEdgeMenu)])

   463

   464

        type = self.Controler.GetEditedElementType(self.TagName, self.Debug)

   465

        menu.Enable(ID_RISING_EDGE, type != "function")

   466

        menu.Enable(ID_FALLING_EDGE, type != "function")

   467

   468

        if connector.IsNegated():

   469

            menu.Check(ID_NEGATED, True)

   470

        elif connector.GetEdge() == "rising":

   471

            menu.Check(ID_RISING_EDGE, True)

   472

        elif connector.GetEdge() == "falling":

   473

            menu.Check(ID_FALLING_EDGE, True)

   474

        else:

   475

            menu.Check(ID_NO_MODIFIER, True)

   476

   477

    # Add Alignment Menu items to the given menu

   478

    def AddAlignmentMenuItems(self, menu):

   479

        [ID_ALIGN_LEFT, ID_ALIGN_CENTER, ID_ALIGN_RIGHT,

   480

         ID_ALIGN_TOP, ID_ALIGN_MIDDLE, ID_ALIGN_BOTTOM,

   481

        ] = [wx.NewId() for i in xrange(6)]

   482

   483

        # Create menu items

   484

        self.AddMenuItems(menu, [

   485

            (ID_ALIGN_LEFT, wx.ITEM_NORMAL, _(u'Left'), '', self.OnAlignLeftMenu),

   486

            (ID_ALIGN_CENTER, wx.ITEM_NORMAL, _(u'Center'), '', self.OnAlignCenterMenu),

   487

            (ID_ALIGN_RIGHT, wx.ITEM_NORMAL, _(u'Right'), '', self.OnAlignRightMenu),

   488

            None,

   489

            (ID_ALIGN_TOP, wx.ITEM_NORMAL, _(u'Top'), '', self.OnAlignTopMenu),

   490

            (ID_ALIGN_MIDDLE, wx.ITEM_NORMAL, _(u'Middle'), '', self.OnAlignMiddleMenu),

   491

            (ID_ALIGN_BOTTOM, wx.ITEM_NORMAL, _(u'Bottom'), '', self.OnAlignBottomMenu)])

   492

   493

    # Add Wire Menu items to the given menu

   494

    def AddWireMenuItems(self, menu, delete=False, replace=False):

   495

        [ID_ADD_SEGMENT, ID_DELETE_SEGMENT, ID_REPLACE_WIRE,

   496

         ] = [wx.NewId() for i in xrange(3)]

   497

   498

        # Create menu items

   499

        self.AddMenuItems(menu, [

   500

            (ID_ADD_SEGMENT, wx.ITEM_NORMAL, _(u'Add Wire Segment'), '', self.OnAddSegmentMenu),

   501

            (ID_DELETE_SEGMENT, wx.ITEM_NORMAL, _(u'Delete Wire Segment'), '', self.OnDeleteSegmentMenu),

   502

            (ID_REPLACE_WIRE, wx.ITEM_NORMAL, _(u'Replace Wire by connections'), '', self.OnReplaceWireMenu)])

   503

   504

        menu.Enable(ID_DELETE_SEGMENT, delete)

   505

        menu.Enable(ID_REPLACE_WIRE, replace)

   506

   507

    # Add Divergence Menu items to the given menu

   508

    def AddDivergenceMenuItems(self, menu, delete=False):

   509

        [ID_ADD_BRANCH, ID_DELETE_BRANCH] = [wx.NewId() for i in xrange(2)]