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

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

   302

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

   303

                    else:

   304

                        if location[1] == "Q":

   305

                            var_class = OUTPUT

   306

                        else:

   307

                            var_class = INPUT

   308

                        if values[2] is not None:

   309

                            var_type = values[2]

   310

                        else:

   311

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

   312

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

   313

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

   314

                            self.ParentWindow.RefreshVariablePanel()

   315

                            self.ParentWindow.ParentWindow.RefreshPouInstanceVariablesPanel()

   316

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

   317

            elif values[1] == "Global":

   318

                var_name = values[0]

   319

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

   320

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

   321

                else:

   322

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

   323

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

   324

                        self.ParentWindow.RefreshVariablePanel()

   325

                        self.ParentWindow.ParentWindow.RefreshPouInstanceVariablesPanel()

   326

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

   327

            elif values[1] == "Constant":

   328

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

   329

            elif values[3] == tagname:

   330

                if values[1] == "Output":

   331

                    var_class = OUTPUT

   332

                elif values[1] == "InOut":

   333

                    var_class = INPUT

   334

                else:

   335

                    var_class = INPUT

   336

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

   337

                if tree is not None:

   338

                    if len(tree[0]) > 0:

   339

                        menu = wx.Menu(title='')

   340

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

   341

                        self.ParentWindow.PopupMenuXY(menu)

   342

                    else:

   343

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

   344

                else:

   345

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

   346

            else:

   347

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

   348

        if message is not None:

   349

            wx.CallAfter(self.ShowMessage, message)

   350

   351

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

   352

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

   353

            if base_path:

   354

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

   355

            else:

   356

                child_path = child_name

   357

            if len(child_dimensions) > 0:

   358

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

   359

                child_name += "[]"

   360

            new_id = wx.NewId()

   361

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

   362

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

   363

            if len(child_tree) > 0:

   364

                new_id = wx.NewId()

   365

                child_menu = wx.Menu(title='')

   366

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

   367

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

   368

   369

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

   370

        def AddVariableFunction(event):

   371

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

   372

        return AddVariableFunction

   373

   374

    def ShowMessage(self, message):

   375

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

   376

        message.ShowModal()

   377

        message.Destroy()

   378

   379

"""

   380

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

   381

manipulating graphic elements

   382

"""

   383

   384

class Viewer(EditorPanel, DebugViewer):

   385

   386

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

   387

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

   388

            if id is not None:

   389

                event(self, id, function)

   390

            else:

   391

                event(self, function)

   392

   393

    # Add list of menu items to the given menu

   394

    def AddMenuItems(self, menu, items):

   395

        for item in items:

   396

            if item is None:

   397

                menu.AppendSeparator()

   398

            else:

   399

                id, kind, text, help, callback = item

   400

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

   401

                # Link menu event to corresponding called functions

   402

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

   403

   404

    # Add Block Pin Menu items to the given menu

   405

    def AddBlockPinMenuItems(self, menu, connector):

   406

        [ID_NO_MODIFIER, ID_NEGATED, ID_RISING_EDGE, 

   407

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

   408

   409

        # Create menu items

   410

        self.AddMenuItems(menu, [

   411

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

   412

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

   413

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

   414

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

   415

   416

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

   417

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

   418

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

   419

   420

        if connector.IsNegated():

   421

            menu.Check(ID_NEGATED, True)

   422

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

   423

            menu.Check(ID_RISING_EDGE, True)

   424

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

   425

            menu.Check(ID_FALLING_EDGE, True)

   426

        else:

   427

            menu.Check(ID_NO_MODIFIER, True)

   428

   429

    # Add Alignment Menu items to the given menu

   430

    def AddAlignmentMenuItems(self, menu):

   431

        [ID_ALIGN_LEFT, ID_ALIGN_CENTER, ID_ALIGN_RIGHT,

   432

         ID_ALIGN_TOP, ID_ALIGN_MIDDLE, ID_ALIGN_BOTTOM,

   433

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

   434

   435

        # Create menu items

   436

        self.AddMenuItems(menu, [

   437

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

   438

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

   439

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

   440

            None,

   441

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

   442

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

   443

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

   444

   445

    # Add Wire Menu items to the given menu

   446

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

   447

        [ID_ADD_SEGMENT, ID_DELETE_SEGMENT, ID_REPLACE_WIRE,

   448

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

   449

   450

        # Create menu items

   451

        self.AddMenuItems(menu, [

   452

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

   453

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

   454

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

   455

   456

        menu.Enable(ID_DELETE_SEGMENT, delete)

   457

        menu.Enable(ID_REPLACE_WIRE, replace)

   458

   459

    # Add Divergence Menu items to the given menu

   460

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

   461

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

   462

   463

        # Create menu items

   464

        self.AddMenuItems(menu, [

   465

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

   466

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

   467

   468

        menu.Enable(ID_DELETE_BRANCH, delete)

   469

   470

    # Add Add Menu items to the given menu

   471

    def AddAddMenuItems(self, menu):

   472

        [ID_ADD_BLOCK, ID_ADD_VARIABLE, ID_ADD_CONNECTION,

   473

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

   474

   475

        # Create menu items

   476

        self.AddMenuItems(menu, [

   477

            (ID_ADD_BLOCK, wx.ITEM_NORMAL, _(u'Block'), '', self.GetAddMenuCallBack(self.AddNewBlock)),

   478

            (ID_ADD_VARIABLE, wx.ITEM_NORMAL, _(u'Variable'), '', self.GetAddMenuCallBack(self.AddNewVariable)),

   479

            (ID_ADD_CONNECTION, wx.ITEM_NORMAL, _(u'Connection'), '', self.GetAddMenuCallBack(self.AddNewConnection)),

   480

            None])

   481

   482

        if self.CurrentLanguage != "FBD":

   483

            [ID_ADD_POWER_RAIL, ID_ADD_CONTACT, ID_ADD_COIL,

   484

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

   485

   486

            # Create menu items

   487

            self.AddMenuItems(menu, [

   488

                (ID_ADD_POWER_RAIL, wx.ITEM_NORMAL, _(u'Power Rail'), '', self.GetAddMenuCallBack(self.AddNewPowerRail)),

   489

                (ID_ADD_CONTACT, wx.ITEM_NORMAL, _(u'Contact'), '', self.GetAddMenuCallBack(self.AddNewContact))])

   490

   491

            if self.CurrentLanguage != "SFC":

   492

                self.AddMenuItems(menu, [

   493

                     (ID_ADD_COIL, wx.ITEM_NORMAL, _(u'Coil'), '', self.GetAddMenuCallBack(self.AddNewCoil))])

   494

   495

            menu.AppendSeparator()

   496

   497

        if self.CurrentLanguage == "SFC":

   498

            [ID_ADD_INITIAL_STEP, ID_ADD_STEP, ID_ADD_TRANSITION, 

   499

             ID_ADD_ACTION_BLOCK, ID_ADD_DIVERGENCE, ID_ADD_JUMP,

   500

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

   501

   502

            # Create menu items

   503

            self.AddMenuItems(menu, [

   504

                (ID_ADD_INITIAL_STEP, wx.ITEM_NORMAL, _(u'Initial Step'), '', self.GetAddMenuCallBack(self.AddNewStep, True)),

   505

                (ID_ADD_STEP, wx.ITEM_NORMAL, _(u'Step'), '', self.GetAddMenuCallBack(self.AddNewStep)),

   506

                (ID_ADD_TRANSITION, wx.ITEM_NORMAL, _(u'Transition'), '', self.GetAddMenuCallBack(self.AddNewTransition)),

   507

                (ID_ADD_ACTION_BLOCK, wx.ITEM_NORMAL, _(u'Action Block'), '', self.GetAddMenuCallBack(self.AddNewActionBlock)),

   508

                (ID_ADD_DIVERGENCE, wx.ITEM_NORMAL, _(u'Divergence'), '', self.GetAddMenuCallBack(self.AddNewDivergence)),

   509

                (ID_ADD_JUMP, wx.ITEM_NORMAL, _(u'Jump'), '', self.GetAddMenuCallBack(self.AddNewJump)),

   510

                None])

   511

   512

        self.AddMenuItems(menu, [

   513

             (ID_ADD_COMMENT, wx.ITEM_NORMAL, _(u'Comment'), '', self.GetAddMenuCallBack(self.AddNewComment))])

   514

   515

    # Add Default Menu items to the given menu

   516

    def AddDefaultMenuItems(self, menu, edit=False, block=False):

   517

        if block:

   518

            [ID_EDIT_BLOCK, ID_DELETE, ID_ADJUST_BLOCK_SIZE] = [wx.NewId() for i in xrange(3)]

   519

   520

            # Create menu items

   521

            self.AddMenuItems(menu, [

   522

                 (ID_EDIT_BLOCK, wx.ITEM_NORMAL, _(u'Edit Block'), '', self.OnEditBlockMenu),