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 editors.DebugViewer import DebugViewer

    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["executionOrder"])

    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

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

   109

                 (False, "rising"): CONTACT_RISING,

   110

                 (False, "falling"): CONTACT_FALLING}

   111

   112

def contactCreationFunction(viewer, id, specific_values):

   113

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

   114

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

   115

                                     CONTACT_NORMAL)

   116

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

   117

   118

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

   119

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

   120

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

   121

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

   122

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

   123

   124

def coilCreationFunction(viewer, id, specific_values):

   125

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

   126

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

   127

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

   128

                               COIL_NORMAL)

   129

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

   130

   131

def stepCreationFunction(viewer, id, specific_values):

   132

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

   133

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

   134

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

   135

        step.AddAction()

   136

        connector = step.GetActionConnector()

   137

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

   138

    return step

   139

   140

def transitionCreationFunction(viewer, id, specific_values):

   141

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

   142

                                        specific_values.get("condition", None), 

   143

                                        specific_values["priority"], id)

   144

    return transition

   145

   146

def GetDivergenceCreationFunction(divergence_type):

   147

    def divergenceCreationFunction(viewer, id, specific_values):

   148

        return SFC_Divergence(viewer, divergence_type, 

   149

                                      specific_values["connectors"], id)

   150

    return divergenceCreationFunction

   151

   152

def jumpCreationFunction(viewer, id, specific_values):

   153

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

   154

   155

def actionBlockCreationFunction(viewer, id, specific_values):

   156

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

   157

   158

ElementCreationFunctions = {

   159

    "input": GetVariableCreationFunction(INPUT),

   160

    "output": GetVariableCreationFunction(OUTPUT),

   161

    "inout": GetVariableCreationFunction(INOUT),

   162

    "connector": GetConnectorCreationFunction(CONNECTOR),

   163

    "continuation": GetConnectorCreationFunction(CONTINUATION),

   164

    "comment": commentCreationFunction,

   165

    "leftPowerRail": GetPowerRailCreationFunction(LEFTRAIL),

   166

    "rightPowerRail": GetPowerRailCreationFunction(RIGHTRAIL),

   167

    "contact": contactCreationFunction,

   168

    "coil": coilCreationFunction,

   169

    "step": stepCreationFunction, 

   170

    "transition": transitionCreationFunction,

   171

    "selectionDivergence": GetDivergenceCreationFunction(SELECTION_DIVERGENCE), 

   172

    "selectionConvergence": GetDivergenceCreationFunction(SELECTION_CONVERGENCE), 

   173

    "simultaneousDivergence": GetDivergenceCreationFunction(SIMULTANEOUS_DIVERGENCE), 

   174

    "simultaneousConvergence": GetDivergenceCreationFunction(SIMULTANEOUS_CONVERGENCE), 

   175

    "jump": jumpCreationFunction,

   176

    "actionBlock": actionBlockCreationFunction,

   177

}

   178

   179

def sort_blocks(block_infos1, block_infos2):

   180

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

   181

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

   182

    if y1 == y2:

   183

        return cmp(x1, x2)

   184

    else:

   185

        return cmp(y1, y2)

   186

   187

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

   188

#                       Graphic elements Viewer base class

   189

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

   190

   191

# ID Constants for alignment menu items

   192

[ID_VIEWERALIGNMENTMENUITEMS0, ID_VIEWERALIGNMENTMENUITEMS1,

   193

 ID_VIEWERALIGNMENTMENUITEMS2, ID_VIEWERALIGNMENTMENUITEMS4,

   194

 ID_VIEWERALIGNMENTMENUITEMS5, ID_VIEWERALIGNMENTMENUITEMS6,

   195

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

   196

   197

# ID Constants for contextual menu items

   198

[ID_VIEWERCONTEXTUALMENUITEMS0, ID_VIEWERCONTEXTUALMENUITEMS1,

   199

 ID_VIEWERCONTEXTUALMENUITEMS2, ID_VIEWERCONTEXTUALMENUITEMS3,

   200

 ID_VIEWERCONTEXTUALMENUITEMS5, ID_VIEWERCONTEXTUALMENUITEMS6,

   201

 ID_VIEWERCONTEXTUALMENUITEMS8, ID_VIEWERCONTEXTUALMENUITEMS9,

   202

 ID_VIEWERCONTEXTUALMENUITEMS11, ID_VIEWERCONTEXTUALMENUITEMS12,

   203

 ID_VIEWERCONTEXTUALMENUITEMS14, ID_VIEWERCONTEXTUALMENUITEMS16,

   204

 ID_VIEWERCONTEXTUALMENUITEMS17,

   205

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

   206

   207

   208

class ViewerDropTarget(wx.TextDropTarget):

   209

   210

    def __init__(self, parent):

   211

        wx.TextDropTarget.__init__(self)

   212

        self.ParentWindow = parent

   213

   214

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

   215

        self.ParentWindow.Select()

   216

        tagname = self.ParentWindow.GetTagName()

   217

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

   218

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

   219

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

   220

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

   221

        scaling = self.ParentWindow.Scaling

   222

        message = None

   223

        try:

   224

            values = eval(data)

   225

        except:

   226

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

   227

            values = None

   228

        if not isinstance(values, TupleType):

   229

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

   230

            values = None

   231

        if values is not None:

   232

            if values[1] == "debug":

   233

                pass

   234

            elif values[1] == "program":

   235

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

   236

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

   237

                words = tagname.split("::")

   238

                if pou_name == values[0]:

   239

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

   240

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

   241

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

   242

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

   243

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

   244

                else:

   245

                    blockname = values[2]

   246

                    if len(values) > 3:

   247

                        blockinputs = values[3]

   248

                    else:

   249

                        blockinputs = None

   250

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

   251

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

   252

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

   253

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

   254

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

   255

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

   256

                    else:

   257

                        id = self.ParentWindow.GetNewId()

   258

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

   259

                        width, height = block.GetMinSize()

   260

                        if scaling is not None:

   261

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

   262

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

   263

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

   264

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

   265

                        block.SetPosition(x, y)

   266

                        block.SetSize(width, height)

   267

                        self.ParentWindow.AddBlock(block)

   268

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

   269

                        self.ParentWindow.RefreshBlockModel(block)

   270

                        self.ParentWindow.RefreshBuffer()

   271

                        self.ParentWindow.RefreshScrollBars()

   272

                        self.ParentWindow.RefreshVisibleElements()

   273

                        self.ParentWindow.RefreshVariablePanel()

   274

                        self.ParentWindow.Refresh(False)

   275

            elif values[1] == "location":

   276

                if pou_type == "program":

   277

                    location = values[0]

   278

                    if not location.startswith("%"):

   279

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

   280

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

   281

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

   282

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

   283

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

   284

                            selected = dialog.GetSelection()

   285

                        else:

   286

                            selected = None

   287

                        dialog.Destroy()

   288

                        if selected is None:

   289

                            return

   290

                        if selected == 0:

   291

                            location = "%I" + location

   292

                        elif selected == 1:

   293

                            location = "%Q" + location

   294

                        else:

   295

                            location = "%M" + location

   296

                    var_name = values[3]

   297

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

   298

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

   299

                    else:

   300

                        if location[1] == "Q":

   301

                            var_class = OUTPUT

   302

                        else:

   303

                            var_class = INPUT

   304

                        if values[2] is not None:

   305

                            var_type = values[2]

   306

                        else:

   307

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

   308

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

   309

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

   310

                            self.ParentWindow.RefreshVariablePanel()

   311

                            self.ParentWindow.ParentWindow.RefreshPouInstanceVariablesPanel()

   312

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

   313

            elif values[1] == "Global":

   314

                var_name = values[0]

   315

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

   316

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

   317

                else:

   318

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

   319

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

   320

                        self.ParentWindow.RefreshVariablePanel()

   321

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

   322

            elif values[1] == "Constant":

   323

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

   324

            elif values[3] == tagname:

   325

                if values[1] == "Output":

   326

                    var_class = OUTPUT

   327

                elif values[1] == "InOut":

   328

                    var_class = INPUT

   329

                else:

   330

                    var_class = INPUT

   331

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

   332

                if tree is not None:

   333

                    if len(tree[0]) > 0:

   334

                        menu = wx.Menu(title='')

   335

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

   336

                        self.ParentWindow.PopupMenuXY(menu)

   337

                    else:

   338

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

   339

                else:

   340

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

   341

            else:

   342

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

   343

        if message is not None:

   344

            wx.CallAfter(self.ShowMessage, message)

   345

   346

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

   347

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

   348

            if base_path:

   349

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

   350

            else:

   351

                child_path = child_name

   352

            if len(child_dimensions) > 0:

   353

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

   354

                child_name += "[]"

   355

            new_id = wx.NewId()

   356

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

   357

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

   358

            if len(child_tree) > 0:

   359

                new_id = wx.NewId()

   360

                child_menu = wx.Menu(title='')

   361

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

   362

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

   363

   364

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

   365

        def AddVariableFunction(event):

   366

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

   367

        return AddVariableFunction

   368

   369

    def ShowMessage(self, message):

   370

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

   371

        message.ShowModal()

   372

        message.Destroy()

   373

   374

"""

   375

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

   376

manipulating graphic elements

   377

"""

   378

   379

class Viewer(EditorPanel, DebugViewer):

   380

   381

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

   382

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

   383

            if id is not None:

   384

                event(self, id, function)

   385

            else:

   386

                event(self, function)

   387

   388

    # Add list of menu items to the given menu

   389

    def AddMenuItems(self, menu, items):

   390

        for item in items:

   391

            if item is None:

   392

                menu.AppendSeparator()

   393

            else:

   394

                id, kind, text, help, callback = item

   395

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

   396

                # Link menu event to corresponding called functions

   397

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

   398

   399

    # Add Block Pin Menu items to the given menu

   400

    def AddBlockPinMenuItems(self, menu, connector):

   401

        [ID_NO_MODIFIER, ID_NEGATED, ID_RISING_EDGE, 

   402

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

   403

   404

        # Create menu items

   405

        self.AddMenuItems(menu, [

   406

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

   407

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

   408

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

   409

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

   410

   411

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

   412

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

   413

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

   414

   415

        if connector.IsNegated():

   416

            menu.Check(ID_NEGATED, True)

   417

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

   418

            menu.Check(ID_RISING_EDGE, True)

   419

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

   420

            menu.Check(ID_FALLING_EDGE, True)

   421

        else:

   422

            menu.Check(ID_NO_MODIFIER, True)

   423

   424

    # Add Alignment Menu items to the given menu

   425

    def AddAlignmentMenuItems(self, menu):

   426

        [ID_ALIGN_LEFT, ID_ALIGN_CENTER, ID_ALIGN_RIGHT,

   427

         ID_ALIGN_TOP, ID_ALIGN_MIDDLE, ID_ALIGN_BOTTOM,

   428

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

   429

   430

        # Create menu items

   431

        self.AddMenuItems(menu, [

   432

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

   433

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

   434

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

   435

            None,

   436

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

   437

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

   438

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

   439

   440

    # Add Wire Menu items to the given menu

   441

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

   442

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

   443

   444

        # Create menu items

   445

        self.AddMenuItems(menu, [

   446

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

   447

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

   448

   449

        menu.Enable(ID_DELETE_SEGMENT, delete)

   450

   451

    # Add Divergence Menu items to the given menu

   452

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

   453

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

   454

   455

        # Create menu items

   456

        self.AddMenuItems(menu, [

   457

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

   458

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

   459

   460

        menu.Enable(ID_DELETE_BRANCH, delete)

   461

   462

    # Add Add Menu items to the given menu

   463

    def AddAddMenuItems(self, menu):

   464

        [ID_ADD_BLOCK, ID_ADD_VARIABLE, ID_ADD_CONNECTION,

   465

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

   466

   467

        # Create menu items

   468

        self.AddMenuItems(menu, [

   469

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

   470

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

   471

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

   472

            None])

   473

   474

        if self.CurrentLanguage != "FBD":

   475

            [ID_ADD_POWER_RAIL, ID_ADD_CONTACT, ID_ADD_COIL,

   476

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

   477

   478

            # Create menu items

   479

            self.AddMenuItems(menu, [

   480

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

   481

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

   482

   483

            if self.CurrentLanguage != "SFC":

   484

                self.AddMenuItems(menu, [

   485

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

   486

   487

            menu.AppendSeparator()

   488

   489

        if self.CurrentLanguage == "SFC":

   490

            [ID_ADD_INITIAL_STEP, ID_ADD_STEP, ID_ADD_TRANSITION, 

   491

             ID_ADD_ACTION_BLOCK, ID_ADD_DIVERGENCE, ID_ADD_JUMP,

   492

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

   493

   494

            # Create menu items

   495

            self.AddMenuItems(menu, [

   496

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

   497

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

   498

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

   499

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

   500

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

   501

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

   502

                None])

   503

   504

        self.AddMenuItems(menu, [

   505

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

   506

   507

    # Add Default Menu items to the given menu

   508

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

   509

        if block:

   510

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

   511

   512

            # Create menu items

   513

            self.AddMenuItems(menu, [

   514

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

   515

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

   516

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

   517

   518

            menu.Enable(ID_EDIT_BLOCK, edit)

   519

   520

        else:

   521

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

   522

   523

            # Create menu items

   524

            self.AddMenuItems(menu, [

   525

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

   526

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

   527

   528

            menu.AppendSeparator()