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

import time

    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 EditorPanel import EditorPanel

    39

    40

SCROLLBAR_UNIT = 10

    41

WINDOW_BORDER = 10

    42

SCROLL_ZONE = 10

    43

    44

CURSORS = None

    45

    46

def ResetCursors():

    47

    global CURSORS

    48

    if CURSORS == None:

    49

        CURSORS = [wx.NullCursor, 

    50

                   wx.StockCursor(wx.CURSOR_HAND),

    51

                   wx.StockCursor(wx.CURSOR_SIZENWSE),

    52

                   wx.StockCursor(wx.CURSOR_SIZENESW),

    53

                   wx.StockCursor(wx.CURSOR_SIZEWE),

    54

                   wx.StockCursor(wx.CURSOR_SIZENS)]

    55

    56

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

    57

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

    58

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

    59

    else:

    60

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

    61

    62

if wx.Platform == '__WXMSW__':

    63

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

    64

              'mono' : 'Courier New',

    65

              'helv' : 'Arial',

    66

              'other': 'Comic Sans MS',

    67

              'size' : 10,

    68

             }

    69

else:

    70

    faces = { 'times': 'Times',

    71

              'mono' : 'Courier',

    72

              'helv' : 'Helvetica',

    73

              'other': 'new century schoolbook',

    74

              'size' : 12,

    75

             }

    76

    77

if wx.Platform == '__WXMSW__':

    78

    MAX_ZOOMIN = 4

    79

else:

    80

    MAX_ZOOMIN = 7

    81

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

    82

    83

def GetVariableCreationFunction(variable_type):

    84

    def variableCreationFunction(viewer, id, specific_values):

    85

        return FBD_Variable(viewer, variable_type, 

    86

                                    specific_values["name"], 

    87

                                    specific_values["value_type"], 

    88

                                    id,

    89

                                    specific_values["executionOrder"])

    90

    return variableCreationFunction

    91

    92

def GetConnectorCreationFunction(connector_type):

    93

    def connectorCreationFunction(viewer, id, specific_values):

    94

        return FBD_Connector(viewer, connector_type, 

    95

                                     specific_values["name"], id)

    96

    return connectorCreationFunction

    97

    98

def commentCreationFunction(viewer, id, specific_values):

    99

    return Comment(viewer, specific_values["content"], id)

   100

   101

def GetPowerRailCreationFunction(powerrail_type):

   102

    def powerRailCreationFunction(viewer, id, specific_values):

   103

        return LD_PowerRail(viewer, powerrail_type, id, 

   104

                                    specific_values["connectors"])

   105

    return powerRailCreationFunction

   106

   107

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

   108

                 (False, "rising"): CONTACT_RISING,

   109

                 (False, "falling"): CONTACT_FALLING}

   110

   111

def contactCreationFunction(viewer, id, specific_values):

   112

    contact_type = CONTACT_TYPES.get((specific_values.get("negated", False), 

   113

                                      specific_values.get("edge", "none")),

   114

                                     CONTACT_NORMAL)

   115

    return LD_Contact(viewer, contact_type, specific_values["name"], id)

   116

   117

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

   118

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

   119

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

   120

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

   121

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

   122

   123

def coilCreationFunction(viewer, id, specific_values):

   124

    coil_type = COIL_TYPES.get((specific_values.get("negated", False), 

   125

                                specific_values.get("edge", "none"),

   126

                                specific_values.get("storage", "none")),

   127

                               COIL_NORMAL)

   128

    return LD_Coil(viewer, coil_type, specific_values["name"], id)

   129

   130

def stepCreationFunction(viewer, id, specific_values):

   131

    step = SFC_Step(viewer, specific_values["name"], 

   132

                            specific_values.get("initial", False), id)

   133

    if specific_values.get("action", None):

   134

        step.AddAction()

   135

        connector = step.GetActionConnector()

   136

        connector.SetPosition(wx.Point(*specific_values["action"]["position"]))

   137

    return step

   138

   139

def transitionCreationFunction(viewer, id, specific_values):

   140

    transition = SFC_Transition(viewer, specific_values["condition_type"], 

   141

                                        specific_values.get("condition", None), 

   142

                                        specific_values["priority"], id)

   143

    return transition

   144

   145

def GetDivergenceCreationFunction(divergence_type):

   146

    def divergenceCreationFunction(viewer, id, specific_values):

   147

        return SFC_Divergence(viewer, divergence_type, 

   148

                                      specific_values["connectors"], id)

   149

    return divergenceCreationFunction

   150

   151

def jumpCreationFunction(viewer, id, specific_values):

   152

    return SFC_Jump(viewer, specific_values["target"], id)

   153

   154

def actionBlockCreationFunction(viewer, id, specific_values):

   155

    return SFC_ActionBlock(viewer, specific_values["actions"], id)

   156

   157

ElementCreationFunctions = {

   158

    "input": GetVariableCreationFunction(INPUT),

   159

    "output": GetVariableCreationFunction(OUTPUT),

   160

    "inout": GetVariableCreationFunction(INOUT),

   161

    "connector": GetConnectorCreationFunction(CONNECTOR),

   162

    "continuation": GetConnectorCreationFunction(CONTINUATION),

   163

    "comment": commentCreationFunction,

   164

    "leftPowerRail": GetPowerRailCreationFunction(LEFTRAIL),

   165

    "rightPowerRail": GetPowerRailCreationFunction(RIGHTRAIL),

   166

    "contact": contactCreationFunction,

   167

    "coil": coilCreationFunction,

   168

    "step": stepCreationFunction, 

   169

    "transition": transitionCreationFunction,

   170

    "selectionDivergence": GetDivergenceCreationFunction(SELECTION_DIVERGENCE), 

   171

    "selectionConvergence": GetDivergenceCreationFunction(SELECTION_CONVERGENCE), 

   172

    "simultaneousDivergence": GetDivergenceCreationFunction(SIMULTANEOUS_DIVERGENCE), 

   173

    "simultaneousConvergence": GetDivergenceCreationFunction(SIMULTANEOUS_CONVERGENCE), 

   174

    "jump": jumpCreationFunction,

   175

    "actionBlock": actionBlockCreationFunction,

   176

}

   177

   178

def sort_blocks(block_infos1, block_infos2):

   179

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

   180

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

   181

    if y1 == y2:

   182

        return cmp(x1, x2)

   183

    else:

   184

        return cmp(y1, y2)

   185

   186

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

   187

#                       Graphic elements Viewer base class

   188

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

   189

   190

# ID Constants for alignment menu items

   191

[ID_VIEWERALIGNMENTMENUITEMS0, ID_VIEWERALIGNMENTMENUITEMS1,

   192

 ID_VIEWERALIGNMENTMENUITEMS2, ID_VIEWERALIGNMENTMENUITEMS4,

   193

 ID_VIEWERALIGNMENTMENUITEMS5, ID_VIEWERALIGNMENTMENUITEMS6,

   194

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

   195

   196

# ID Constants for contextual menu items

   197

[ID_VIEWERCONTEXTUALMENUITEMS0, ID_VIEWERCONTEXTUALMENUITEMS1,

   198

 ID_VIEWERCONTEXTUALMENUITEMS2, ID_VIEWERCONTEXTUALMENUITEMS3,

   199

 ID_VIEWERCONTEXTUALMENUITEMS5, ID_VIEWERCONTEXTUALMENUITEMS6,

   200

 ID_VIEWERCONTEXTUALMENUITEMS8, ID_VIEWERCONTEXTUALMENUITEMS9,

   201

 ID_VIEWERCONTEXTUALMENUITEMS11, ID_VIEWERCONTEXTUALMENUITEMS12,

   202

 ID_VIEWERCONTEXTUALMENUITEMS14, ID_VIEWERCONTEXTUALMENUITEMS16,

   203

 ID_VIEWERCONTEXTUALMENUITEMS17,

   204

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

   205

   206

   207

class ViewerDropTarget(wx.TextDropTarget):

   208

   209

    def __init__(self, parent):

   210

        wx.TextDropTarget.__init__(self)

   211

        self.ParentWindow = parent

   212

   213

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

   214

        self.ParentWindow.Select()

   215

        tagname = self.ParentWindow.GetTagName()

   216

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

   217

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

   218

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

   219

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

   220

        scaling = self.ParentWindow.Scaling

   221

        message = None

   222

        try:

   223

            values = eval(data)

   224

        except:

   225

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

   226

            values = None

   227

        if not isinstance(values, TupleType):

   228

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

   229

            values = None

   230

        if values is not None:

   231

            if values[1] == "debug":

   232

                pass

   233

            elif values[1] == "program":

   234

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

   235

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

   236

                words = tagname.split("::")

   237

                if pou_name == values[0]:

   238

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

   239

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

   240

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

   241

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

   242

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

   243

                else:

   244

                    blockname = values[2]

   245

                    if len(values) > 3:

   246

                        blockinputs = values[3]

   247

                    else:

   248

                        blockinputs = None

   249

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

   250

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

   251

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

   252

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

   253

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

   254

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

   255

                    else:

   256

                        id = self.ParentWindow.GetNewId()

   257

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

   258

                        width, height = block.GetMinSize()

   259

                        if scaling is not None:

   260

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

   261

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

   262

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

   263

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

   264

                        block.SetPosition(x, y)

   265

                        block.SetSize(width, height)

   266

                        self.ParentWindow.AddBlock(block)

   267

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

   268

                        self.ParentWindow.RefreshBlockModel(block)

   269

                        self.ParentWindow.RefreshBuffer()

   270

                        self.ParentWindow.RefreshScrollBars()

   271

                        self.ParentWindow.RefreshVisibleElements()

   272

                        self.ParentWindow.RefreshVariablePanel()

   273

                        self.ParentWindow.Refresh(False)

   274

            elif values[1] == "location":

   275

                if pou_type == "program":

   276

                    location = values[0]

   277

                    if not location.startswith("%"):

   278

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

   279

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

   280

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

   281

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

   282

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

   283

                            selected = dialog.GetSelection()

   284

                        else:

   285

                            selected = None

   286

                        dialog.Destroy()

   287

                        if selected is None:

   288

                            return

   289

                        if selected == 0:

   290

                            location = "%I" + location

   291

                        elif selected == 1:

   292

                            location = "%Q" + location

   293

                        else:

   294

                            location = "%M" + location

   295

                    var_name = values[3]

   296

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

   297

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

   298

                    else:

   299

                        if location[1] == "Q":

   300

                            var_class = OUTPUT

   301

                        else:

   302

                            var_class = INPUT

   303

                        if values[2] is not None:

   304

                            var_type = values[2]

   305

                        else:

   306

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

   307

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

   308

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

   309

                            self.ParentWindow.RefreshVariablePanel()

   310

                            self.ParentWindow.ParentWindow.RefreshPouInstanceVariablesPanel()

   311

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

   312

            elif values[1] == "Global":

   313

                var_name = values[0]

   314

                if 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

                else:

   317

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

   318

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

   319

                        self.ParentWindow.RefreshVariablePanel()

   320

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

   321

            elif values[1] == "Constant":

   322

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

   323

            elif values[3] == tagname:

   324

                if values[1] == "Output":

   325

                    var_class = OUTPUT

   326

                elif values[1] == "InOut":

   327

                    var_class = INPUT

   328

                else:

   329

                    var_class = INPUT

   330

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

   331

                if tree is not None:

   332

                    if len(tree[0]) > 0:

   333

                        menu = wx.Menu(title='')

   334

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

   335

                        self.ParentWindow.PopupMenuXY(menu)

   336

                    else:

   337

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

   338

                else:

   339

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

   340

            else:

   341

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

   342

        if message is not None:

   343

            wx.CallAfter(self.ShowMessage, message)

   344

   345

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

   346

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

   347

            if base_path:

   348

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

   349

            else:

   350

                child_path = child_name

   351

            if len(child_dimensions) > 0:

   352

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

   353

                child_name += "[]"

   354

            new_id = wx.NewId()

   355

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

   356

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

   357

            if len(child_tree) > 0:

   358

                new_id = wx.NewId()

   359

                child_menu = wx.Menu(title='')

   360

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

   361

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

   362

   363

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

   364

        def AddVariableFunction(event):

   365

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

   366

        return AddVariableFunction

   367

   368

    def ShowMessage(self, message):

   369

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

   370

        message.ShowModal()

   371

        message.Destroy()

   372

   373

"""

   374

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

   375

manipulating graphic elements

   376

"""

   377

   378

class Viewer(EditorPanel, DebugViewer, DebugDataConsumer):

   379

   380

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

   381

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

   382

            if id is not None:

   383

                event(self, id, function)

   384

            else:

   385

                event(self, function)

   386

   387

    # Add list of menu items to the given menu

   388

    def AddMenuItems(self, menu, items):

   389

        for item in items:

   390

            if item is None:

   391

                menu.AppendSeparator()

   392

            else:

   393

                id, kind, text, help, callback = item

   394

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

   395

                # Link menu event to corresponding called functions

   396

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

   397

   398

    # Add Block Pin Menu items to the given menu

   399

    def AddBlockPinMenuItems(self, menu, connector):

   400

        [ID_NO_MODIFIER, ID_NEGATED, ID_RISING_EDGE, 

   401

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

   402

   403

        # Create menu items

   404

        self.AddMenuItems(menu, [

   405

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

   406

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

   407

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

   408

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

   409

   410

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

   411

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

   412

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

   413

   414

        if connector.IsNegated():

   415

            menu.Check(ID_NEGATED, True)

   416

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

   417

            menu.Check(ID_RISING_EDGE, True)

   418

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

   419

            menu.Check(ID_FALLING_EDGE, True)

   420

        else:

   421

            menu.Check(ID_NO_MODIFIER, True)

   422

   423

    # Add Alignment Menu items to the given menu

   424

    def AddAlignmentMenuItems(self, menu):

   425

        [ID_ALIGN_LEFT, ID_ALIGN_CENTER, ID_ALIGN_RIGHT,

   426

         ID_ALIGN_TOP, ID_ALIGN_MIDDLE, ID_ALIGN_BOTTOM,

   427

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

   428

   429

        # Create menu items

   430

        self.AddMenuItems(menu, [

   431

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

   432

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

   433

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

   434

            None,

   435

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

   436

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

   437

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

   438

   439

    # Add Wire Menu items to the given menu

   440

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

   441

        [ID_ADD_SEGMENT, ID_DELETE_SEGMENT] = [wx.NewId() for i in xrange(2)]

   442

   443

        # Create menu items

   444

        self.AddMenuItems(menu, [

   445

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

   446

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

   447

   448

        menu.Enable(ID_DELETE_SEGMENT, delete)

   449

   450

    # Add Divergence Menu items to the given menu

   451

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

   452

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

   453

   454

        # Create menu items

   455

        self.AddMenuItems(menu, [

   456

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

   457

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

   458

   459

        menu.Enable(ID_DELETE_BRANCH, delete)

   460

   461

    # Add Add Menu items to the given menu

   462

    def AddAddMenuItems(self, menu):

   463

        [ID_ADD_BLOCK, ID_ADD_VARIABLE, ID_ADD_CONNECTION,

   464

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

   465

   466

        # Create menu items

   467

        self.AddMenuItems(menu, [

   468

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

   469

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

   470

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

   471

            None])

   472

   473

        if self.CurrentLanguage != "FBD":

   474

            [ID_ADD_POWER_RAIL, ID_ADD_CONTACT, ID_ADD_COIL,

   475

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

   476

   477

            # Create menu items

   478

            self.AddMenuItems(menu, [

   479

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

   480

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

   481

   482

            if self.CurrentLanguage != "SFC":

   483

                self.AddMenuItems(menu, [

   484

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

   485

   486

            menu.AppendSeparator()

   487

   488

        if self.CurrentLanguage == "SFC":

   489

            [ID_ADD_INITIAL_STEP, ID_ADD_STEP, ID_ADD_TRANSITION, 

   490

             ID_ADD_ACTION_BLOCK, ID_ADD_DIVERGENCE, ID_ADD_JUMP,

   491

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

   492

   493

            # Create menu items

   494

            self.AddMenuItems(menu, [

   495

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

   496

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

   497

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

   498

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

   499

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

   500

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

   501

                None])

   502

   503

        self.AddMenuItems(menu, [

   504

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

   505

   506

    # Add Default Menu items to the given menu

   507

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

   508

        if block:

   509

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

   510

   511

            # Create menu items

   512

            self.AddMenuItems(menu, [

   513

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

   514

                 (ID_ADJUST_BLOCK_SIZE, wx.ITEM_NORMAL, _(u'Adjust Block Size'), '', self.OnAdjustBlockSizeMenu),

   515

                 (ID_DELETE, wx.ITEM_NORMAL, _(u'Delete'), '', self.OnDeleteMenu)])

   516

   517

            menu.Enable(ID_EDIT_BLOCK, edit)

   518

   519

        else:

   520

            [ID_CLEAR_EXEC_ORDER, ID_RESET_EXEC_ORDER] = [wx.NewId() for i in xrange(2)]

   521

   522

            # Create menu items

   523

            self.AddMenuItems(menu, [

   524

                 (ID_CLEAR_EXEC_ORDER, wx.ITEM_NORMAL, _(u'Clear Execution Order'), '', self.OnClearExecutionOrderMenu),

   525

                 (ID_RESET_EXEC_ORDER, wx.ITEM_NORMAL, _(u'Reset Execution Order'), '', self.OnResetExecutionOrderMenu)])

   526

   527

            menu.AppendSeparator()

   528