1

#!/usr/bin/env python

     2

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

     3

     4

#This file is part of PLCOpenEditor, a library implementing an IEC 61131-3 editor

     5

#based on the plcopen standard.

     6

#

     7

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

     8

#

     9

#See COPYING file for copyrights details.

    10

#

    11

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

    12

#modify it under the terms of the GNU General Public

    13

#License as published by the Free Software Foundation; either

    14

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

    15

#

    16

#This library 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 GNU

    19

#General Public License for more details.

    20

#

    21

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

    22

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

    23

#Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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

    46

    47

def ResetCursors():

    48

    global CURSORS

    49

    if CURSORS == None:

    50

        CURSORS = [wx.NullCursor,

    51

                   wx.StockCursor(wx.CURSOR_HAND),

    52

                   wx.StockCursor(wx.CURSOR_SIZENWSE),

    53

                   wx.StockCursor(wx.CURSOR_SIZENESW),

    54

                   wx.StockCursor(wx.CURSOR_SIZEWE),

    55

                   wx.StockCursor(wx.CURSOR_SIZENS)]

    56

    57

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

    58

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

    59

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

    60

    else:

    61

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

    62

    63

if wx.Platform == '__WXMSW__':

    64

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

    65

              'mono' : 'Courier New',

    66

              'helv' : 'Arial',

    67

              'other': 'Comic Sans MS',

    68

              'size' : 10,

    69

             }

    70

else:

    71

    faces = { 'times': 'Times',

    72

              'mono' : 'Courier',

    73

              'helv' : 'Helvetica',

    74

              'other': 'new century schoolbook',

    75

              'size' : 12,

    76

             }

    77

    78

if wx.Platform == '__WXMSW__':

    79

    MAX_ZOOMIN = 4

    80

else:

    81

    MAX_ZOOMIN = 7

    82

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

    83

    84

def GetVariableCreationFunction(variable_type):

    85

    def variableCreationFunction(viewer, id, specific_values):

    86

        return FBD_Variable(viewer, variable_type,

    87

                                    specific_values.name,

    88

                                    specific_values.value_type,

    89

                                    id,

    90

                                    specific_values.execution_order)

    91

    return variableCreationFunction

    92

    93

def GetConnectorCreationFunction(connector_type):

    94

    def connectorCreationFunction(viewer, id, specific_values):

    95

        return FBD_Connector(viewer, connector_type,

    96

                                     specific_values.name, id)

    97

    return connectorCreationFunction

    98

    99

def commentCreationFunction(viewer, id, specific_values):

   100

    return Comment(viewer, specific_values.content, id)

   101

   102

def GetPowerRailCreationFunction(powerrail_type):

   103

    def powerRailCreationFunction(viewer, id, specific_values):

   104

        return LD_PowerRail(viewer, powerrail_type, id,

   105

                                    specific_values.connectors)

   106

    return powerRailCreationFunction

   107

   108

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

   109

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

   110

   111

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

   112

                 (False, "rising"): CONTACT_RISING,

   113

                 (False, "falling"): CONTACT_FALLING}

   114

   115

def contactCreationFunction(viewer, id, specific_values):

   116

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

   117

                                      MODIFIER_VALUE(specific_values.edge)),

   118

                                     CONTACT_NORMAL)

   119

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

   120

   121

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

   122

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

   123

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

   124

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

   125

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

   126

   127

def coilCreationFunction(viewer, id, specific_values):

   128

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

   129

                                MODIFIER_VALUE(specific_values.edge),

   130

                                MODIFIER_VALUE(specific_values.storage)),

   131

                               COIL_NORMAL)

   132

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

   133

   134

def stepCreationFunction(viewer, id, specific_values):

   135

    step = SFC_Step(viewer, specific_values.name,

   136

                            specific_values.initial, id)

   137

    if specific_values.action is not None:

   138

        step.AddAction()

   139

        connector = step.GetActionConnector()

   140

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

   141

    return step

   142

   143

def transitionCreationFunction(viewer, id, specific_values):

   144

    transition = SFC_Transition(viewer, specific_values.condition_type,

   145

                                        specific_values.condition,

   146

                                        specific_values.priority, id)

   147

    return transition

   148

   149

def GetDivergenceCreationFunction(divergence_type):

   150

    def divergenceCreationFunction(viewer, id, specific_values):

   151

        return SFC_Divergence(viewer, divergence_type,

   152

                                      specific_values.connectors, id)

   153

    return divergenceCreationFunction

   154

   155

def jumpCreationFunction(viewer, id, specific_values):

   156

    return SFC_Jump(viewer, specific_values.target, id)

   157

   158

def actionBlockCreationFunction(viewer, id, specific_values):

   159

    return SFC_ActionBlock(viewer, specific_values.actions, id)

   160

   161

ElementCreationFunctions = {

   162

    "input": GetVariableCreationFunction(INPUT),

   163

    "output": GetVariableCreationFunction(OUTPUT),

   164

    "inout": GetVariableCreationFunction(INOUT),

   165

    "connector": GetConnectorCreationFunction(CONNECTOR),

   166

    "continuation": GetConnectorCreationFunction(CONTINUATION),

   167

    "comment": commentCreationFunction,

   168

    "leftPowerRail": GetPowerRailCreationFunction(LEFTRAIL),

   169

    "rightPowerRail": GetPowerRailCreationFunction(RIGHTRAIL),

   170

    "contact": contactCreationFunction,

   171

    "coil": coilCreationFunction,

   172

    "step": stepCreationFunction,

   173

    "transition": transitionCreationFunction,

   174

    "selectionDivergence": GetDivergenceCreationFunction(SELECTION_DIVERGENCE),

   175

    "selectionConvergence": GetDivergenceCreationFunction(SELECTION_CONVERGENCE),

   176

    "simultaneousDivergence": GetDivergenceCreationFunction(SIMULTANEOUS_DIVERGENCE),

   177

    "simultaneousConvergence": GetDivergenceCreationFunction(SIMULTANEOUS_CONVERGENCE),

   178

    "jump": jumpCreationFunction,

   179

    "actionBlock": actionBlockCreationFunction,

   180

}

   181

   182

def sort_blocks(block_infos1, block_infos2):

   183

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

   184

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

   185

    if y1 == y2:

   186

        return cmp(x1, x2)

   187

    else:

   188

        return cmp(y1, y2)

   189

   190

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

   191

#                       Graphic elements Viewer base class

   192

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

   193

   194

# ID Constants for alignment menu items

   195

[ID_VIEWERALIGNMENTMENUITEMS0, ID_VIEWERALIGNMENTMENUITEMS1,

   196

 ID_VIEWERALIGNMENTMENUITEMS2, ID_VIEWERALIGNMENTMENUITEMS4,

   197

 ID_VIEWERALIGNMENTMENUITEMS5, ID_VIEWERALIGNMENTMENUITEMS6,

   198

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

   199

   200

# ID Constants for contextual menu items

   201

[ID_VIEWERCONTEXTUALMENUITEMS0, ID_VIEWERCONTEXTUALMENUITEMS1,

   202

 ID_VIEWERCONTEXTUALMENUITEMS2, ID_VIEWERCONTEXTUALMENUITEMS3,

   203

 ID_VIEWERCONTEXTUALMENUITEMS5, ID_VIEWERCONTEXTUALMENUITEMS6,

   204

 ID_VIEWERCONTEXTUALMENUITEMS8, ID_VIEWERCONTEXTUALMENUITEMS9,

   205

 ID_VIEWERCONTEXTUALMENUITEMS11, ID_VIEWERCONTEXTUALMENUITEMS12,

   206

 ID_VIEWERCONTEXTUALMENUITEMS14, ID_VIEWERCONTEXTUALMENUITEMS16,

   207

 ID_VIEWERCONTEXTUALMENUITEMS17,

   208

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

   209

   210

   211

class ViewerDropTarget(wx.TextDropTarget):

   212

   213

    def __init__(self, parent):

   214

        wx.TextDropTarget.__init__(self)

   215

        self.ParentWindow = parent

   216

   217

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

   218

        self.ParentWindow.Select()

   219

        tagname = self.ParentWindow.GetTagName()

   220

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

   221

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

   222

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

   223

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

   224

        scaling = self.ParentWindow.Scaling

   225

        message = None

   226

        try:

   227

            values = eval(data)

   228

        except:

   229

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

   230

            values = None

   231

        if not isinstance(values, TupleType):

   232

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

   233

            values = None

   234

        if values is not None:

   235

            if values[1] == "debug":

   236

                pass

   237

            elif values[1] == "program":

   238

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

   239

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

   240

                words = tagname.split("::")

   241

                if pou_name == values[0]:

   242

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

   243

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

   244

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

   245

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

   246

                    message = _("\"%s\" is already used by \"%s\"!")%(pou_name, values[0])

   247

                else:

   248

                    blockname = values[2]

   249

                    if len(values) > 3:

   250

                        blockinputs = values[3]

   251

                    else:

   252

                        blockinputs = None

   253

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

   254

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

   255

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

   256

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

   257

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

   258

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

   259

                    else:

   260

                        id = self.ParentWindow.GetNewId()

   261

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

   262

                        width, height = block.GetMinSize()

   263

                        if scaling is not None:

   264

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

   265

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

   266

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

   267

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

   268

                        block.SetPosition(x, y)

   269

                        block.SetSize(width, height)

   270

                        self.ParentWindow.AddBlock(block)

   271

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

   272

                        self.ParentWindow.RefreshBlockModel(block)

   273

                        self.ParentWindow.RefreshBuffer()

   274

                        self.ParentWindow.RefreshScrollBars()

   275

                        self.ParentWindow.RefreshVisibleElements()

   276

                        self.ParentWindow.RefreshVariablePanel()

   277

                        self.ParentWindow.ParentWindow.RefreshPouInstanceVariablesPanel()

   278

                        self.ParentWindow.Refresh(False)

   279

            elif values[1] == "location":

   280

                if pou_type == "program":

   281

                    location = values[0]

   282

                    if not location.startswith("%"):

   283

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

   284

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

   285

                              ["Input", "Output", "Memory"],

   286

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

   287

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

   288

                            selected = dialog.GetSelection()

   289

                        else:

   290

                            selected = None

   291

                        dialog.Destroy()

   292

                        if selected is None:

   293

                            return

   294

                        if selected == 0:

   295

                            location = "%I" + location

   296

                        elif selected == 1:

   297

                            location = "%Q" + location

   298

                        else:

   299

                            location = "%M" + location

   300

                    var_name = values[3]

   301

                    dlg = wx.TextEntryDialog(

   302

                        self.ParentWindow.ParentWindow,

   303

                        _("Confirm or change variable name"),

   304

                        'Variable Drop', var_name)

   305

                    dlg.SetValue(var_name)

   306

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

   307

                    dlg.Destroy()

   308

                    if var_name is None:

   309

                        return

   310

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

   311

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

   312

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

   313

                        if location[1] == "Q":

   314

                            var_class = OUTPUT

   315

                        else:

   316

                            var_class = INPUT

   317

                        if values[2] is not None:

   318

                            var_type = values[2]

   319

                        else:

   320

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

   321

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

   322

                        self.ParentWindow.RefreshVariablePanel()

   323

                        self.ParentWindow.ParentWindow.RefreshPouInstanceVariablesPanel()

   324

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

   325

                    else:

   326

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

   327

            elif values[1] == "NamedConstant":

   328

                if pou_type == "program":

   329

                    initval = values[0]

   330

                    var_name = values[3]

   331

                    dlg = wx.TextEntryDialog(

   332

                        self.ParentWindow.ParentWindow,

   333

                        _("Confirm or change variable name"),

   334

                        'Variable Drop', var_name)

   335

                    dlg.SetValue(var_name)

   336

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

   337

                    dlg.Destroy()

   338

                    if var_name is None:

   339

                        return

   340

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

   341

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

   342

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

   343

                        var_class = INPUT

   344

                        var_type = values[2]

   345

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

   346

                        self.ParentWindow.RefreshVariablePanel()

   347

                        self.ParentWindow.ParentWindow.RefreshPouInstanceVariablesPanel()

   348

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

   349

                    else:

   350

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

   351

            elif values[1] == "Global":

   352

                var_name = values[0]

   353

                dlg = wx.TextEntryDialog(

   354

                    self.ParentWindow.ParentWindow,

   355

                    _("Confirm or change variable name"),

   356

                    'Variable Drop', var_name)

   357

                dlg.SetValue(var_name)

   358

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

   359

                dlg.Destroy()

   360

                if var_name is None:

   361

                    return

   362

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

   363

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

   364

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

   365

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

   366

                    self.ParentWindow.RefreshVariablePanel()

   367

                    self.ParentWindow.ParentWindow.RefreshPouInstanceVariablesPanel()

   368

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

   369

                else:

   370

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

   371

            elif values[1] == "Constant":

   372

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

   373

            elif values[3] == tagname:

   374

                if values[1] == "Output":

   375

                    var_class = OUTPUT

   376

                elif values[1] == "InOut":

   377

                    var_class = INPUT

   378

                else:

   379

                    var_class = INPUT

   380

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

   381

                if tree is not None:

   382

                    if len(tree[0]) > 0:

   383

                        menu = wx.Menu(title='')

   384

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

   385

                        self.ParentWindow.PopupMenuXY(menu)

   386

                    else:

   387

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

   388

                else:

   389

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

   390

            else:

   391

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

   392

        if message is not None:

   393

            wx.CallAfter(self.ShowMessage, message)

   394

   395

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

   396

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

   397

            if base_path:

   398

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

   399

            else:

   400

                child_path = child_name

   401

            if len(child_dimensions) > 0:

   402

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

   403

                child_name += "[]"

   404

            new_id = wx.NewId()

   405

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

   406

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

   407

            if len(child_tree) > 0:

   408

                new_id = wx.NewId()

   409

                child_menu = wx.Menu(title='')

   410

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

   411

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

   412

   413

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

   414

        def AddVariableFunction(event):

   415

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

   416

        return AddVariableFunction

   417

   418

    def ShowMessage(self, message):

   419

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

   420

        message.ShowModal()

   421

        message.Destroy()

   422

   423

"""

   424

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

   425

manipulating graphic elements

   426

"""

   427

   428

class Viewer(EditorPanel, DebugViewer):

   429

   430

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

   431

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

   432

            if id is not None:

   433

                event(self, id, function)

   434

            else:

   435

                event(self, function)

   436

   437

    # Add list of menu items to the given menu

   438

    def AddMenuItems(self, menu, items):

   439

        for item in items:

   440

            if item is None:

   441

                menu.AppendSeparator()

   442

            else:

   443

                id, kind, text, help, callback = item

   444

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

   445

                # Link menu event to corresponding called functions

   446

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

   447

   448

    # Add Block Pin Menu items to the given menu

   449

    def AddBlockPinMenuItems(self, menu, connector):

   450

        [ID_NO_MODIFIER, ID_NEGATED, ID_RISING_EDGE,

   451

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

   452

   453

        # Create menu items

   454

        self.AddMenuItems(menu, [

   455

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

   456

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

   457

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

   458

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

   459

   460

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

   461

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

   462

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

   463

   464

        if connector.IsNegated():

   465

            menu.Check(ID_NEGATED, True)

   466

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

   467

            menu.Check(ID_RISING_EDGE, True)

   468

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

   469

            menu.Check(ID_FALLING_EDGE, True)

   470

        else:

   471

            menu.Check(ID_NO_MODIFIER, True)

   472

   473

    # Add Alignment Menu items to the given menu

   474

    def AddAlignmentMenuItems(self, menu):

   475

        [ID_ALIGN_LEFT, ID_ALIGN_CENTER, ID_ALIGN_RIGHT,

   476

         ID_ALIGN_TOP, ID_ALIGN_MIDDLE, ID_ALIGN_BOTTOM,

   477

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

   478

   479

        # Create menu items

   480

        self.AddMenuItems(menu, [

   481

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

   482

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

   483

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

   484

            None,

   485

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

   486

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

   487

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

   488

   489

    # Add Wire Menu items to the given menu

   490

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

   491

        [ID_ADD_SEGMENT, ID_DELETE_SEGMENT, ID_REPLACE_WIRE,

   492

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

   493

   494

        # Create menu items

   495

        self.AddMenuItems(menu, [

   496

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

   497

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

   498

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

   499

   500

        menu.Enable(ID_DELETE_SEGMENT, delete)

   501

        menu.Enable(ID_REPLACE_WIRE, replace)

   502

   503

    # Add Divergence Menu items to the given menu

   504

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

   505

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

   506

   507

        # Create menu items

   508

        self.AddMenuItems(menu, [

   509

            (ID_ADD_BRANCH, wx.ITEM_NORMAL, _(u'Add Divergence Branch'), '', self.OnAddBranchMenu),

   510

            (ID_DELETE_BRANCH, wx.ITEM_NORMAL, _(u'Delete Divergence Branch'), '', self.OnDeleteBranchMenu)])

   511

   512