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

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

   109

   110

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

   111

                 (False, "rising"): CONTACT_RISING,

   112

                 (False, "falling"): CONTACT_FALLING}

   113

   114

def contactCreationFunction(viewer, id, specific_values):

   115

    contact_type = CONTACT_TYPES.get((specific_values.negated, 

   116

                                      MODIFIER_VALUE(specific_values.edge)),

   117

                                     CONTACT_NORMAL)

   118

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

   119

   120

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

   121

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

   122

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

   123

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

   124

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

   125

   126

def coilCreationFunction(viewer, id, specific_values):

   127

    coil_type = COIL_TYPES.get((specific_values.negated, 

   128

                                MODIFIER_VALUE(specific_values.edge),

   129

                                MODIFIER_VALUE(specific_values.storage)),

   130

                               COIL_NORMAL)

   131

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

   132

   133

def stepCreationFunction(viewer, id, specific_values):

   134

    step = SFC_Step(viewer, specific_values.name, 

   135

                            specific_values.initial, id)

   136

    if specific_values.action is not None:

   137

        step.AddAction()

   138

        connector = step.GetActionConnector()

   139

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

   140

    return step

   141

   142

def transitionCreationFunction(viewer, id, specific_values):

   143

    transition = SFC_Transition(viewer, specific_values.condition_type, 

   144

                                        specific_values.condition, 

   145

                                        specific_values.priority, id)

   146

    return transition

   147

   148

def GetDivergenceCreationFunction(divergence_type):

   149

    def divergenceCreationFunction(viewer, id, specific_values):

   150

        return SFC_Divergence(viewer, divergence_type, 

   151

                                      specific_values.connectors, id)

   152

    return divergenceCreationFunction

   153

   154

def jumpCreationFunction(viewer, id, specific_values):

   155

    return SFC_Jump(viewer, specific_values.target, id)

   156

   157

def actionBlockCreationFunction(viewer, id, specific_values):

   158

    return SFC_ActionBlock(viewer, specific_values.actions, id)

   159

   160

ElementCreationFunctions = {

   161

    "input": GetVariableCreationFunction(INPUT),

   162

    "output": GetVariableCreationFunction(OUTPUT),

   163

    "inout": GetVariableCreationFunction(INOUT),

   164

    "connector": GetConnectorCreationFunction(CONNECTOR),

   165

    "continuation": GetConnectorCreationFunction(CONTINUATION),

   166

    "comment": commentCreationFunction,

   167

    "leftPowerRail": GetPowerRailCreationFunction(LEFTRAIL),

   168

    "rightPowerRail": GetPowerRailCreationFunction(RIGHTRAIL),

   169

    "contact": contactCreationFunction,

   170

    "coil": coilCreationFunction,

   171

    "step": stepCreationFunction, 

   172

    "transition": transitionCreationFunction,

   173

    "selectionDivergence": GetDivergenceCreationFunction(SELECTION_DIVERGENCE), 

   174

    "selectionConvergence": GetDivergenceCreationFunction(SELECTION_CONVERGENCE), 

   175

    "simultaneousDivergence": GetDivergenceCreationFunction(SIMULTANEOUS_DIVERGENCE), 

   176

    "simultaneousConvergence": GetDivergenceCreationFunction(SIMULTANEOUS_CONVERGENCE), 

   177

    "jump": jumpCreationFunction,

   178

    "actionBlock": actionBlockCreationFunction,

   179

}

   180

   181

def sort_blocks(block_infos1, block_infos2):

   182

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

   183

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

   184

    if y1 == y2:

   185

        return cmp(x1, x2)

   186

    else:

   187

        return cmp(y1, y2)

   188

   189

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

   190

#                       Graphic elements Viewer base class

   191

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

   192

   193

# ID Constants for alignment menu items

   194

[ID_VIEWERALIGNMENTMENUITEMS0, ID_VIEWERALIGNMENTMENUITEMS1,

   195

 ID_VIEWERALIGNMENTMENUITEMS2, ID_VIEWERALIGNMENTMENUITEMS4,

   196

 ID_VIEWERALIGNMENTMENUITEMS5, ID_VIEWERALIGNMENTMENUITEMS6,

   197

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

   198

   199

# ID Constants for contextual menu items

   200

[ID_VIEWERCONTEXTUALMENUITEMS0, ID_VIEWERCONTEXTUALMENUITEMS1,

   201

 ID_VIEWERCONTEXTUALMENUITEMS2, ID_VIEWERCONTEXTUALMENUITEMS3,

   202

 ID_VIEWERCONTEXTUALMENUITEMS5, ID_VIEWERCONTEXTUALMENUITEMS6,

   203

 ID_VIEWERCONTEXTUALMENUITEMS8, ID_VIEWERCONTEXTUALMENUITEMS9,

   204

 ID_VIEWERCONTEXTUALMENUITEMS11, ID_VIEWERCONTEXTUALMENUITEMS12,

   205

 ID_VIEWERCONTEXTUALMENUITEMS14, ID_VIEWERCONTEXTUALMENUITEMS16,

   206

 ID_VIEWERCONTEXTUALMENUITEMS17,

   207

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

   208

   209

   210

class ViewerDropTarget(wx.TextDropTarget):

   211

   212

    def __init__(self, parent):

   213

        wx.TextDropTarget.__init__(self)

   214

        self.ParentWindow = parent

   215

   216

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

   217

        self.ParentWindow.Select()

   218

        tagname = self.ParentWindow.GetTagName()

   219

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

   220

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

   221

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

   222

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

   223

        scaling = self.ParentWindow.Scaling

   224

        message = None

   225

        try:

   226

            values = eval(data)

   227

        except:

   228

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

   229

            values = None

   230

        if not isinstance(values, TupleType):

   231

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

   232

            values = None

   233

        if values is not None:

   234

            if values[1] == "debug":

   235

                pass

   236

            elif values[1] == "program":

   237

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

   238

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

   239

                words = tagname.split("::")

   240

                if pou_name == values[0]:

   241

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

   242

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

   243

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

   244

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

   245

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

   246

                else:

   247

                    blockname = values[2]

   248

                    if len(values) > 3:

   249

                        blockinputs = values[3]

   250

                    else:

   251

                        blockinputs = None

   252

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

   253

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

   254

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

   255

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

   256

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

   257

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

   258

                    else:

   259

                        id = self.ParentWindow.GetNewId()

   260

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

   261

                        width, height = block.GetMinSize()

   262

                        if scaling is not None:

   263

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

   264

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

   265

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

   266

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

   267

                        block.SetPosition(x, y)

   268

                        block.SetSize(width, height)

   269

                        self.ParentWindow.AddBlock(block)

   270

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

   271

                        self.ParentWindow.RefreshBlockModel(block)

   272

                        self.ParentWindow.RefreshBuffer()

   273

                        self.ParentWindow.RefreshScrollBars()

   274

                        self.ParentWindow.RefreshVisibleElements()

   275

                        self.ParentWindow.RefreshVariablePanel()

   276

                        self.ParentWindow.ParentWindow.RefreshPouInstanceVariablesPanel()

   277

                        self.ParentWindow.Refresh(False)

   278

            elif values[1] == "location":

   279

                if pou_type == "program":

   280

                    location = values[0]

   281

                    if not location.startswith("%"):

   282

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

   283

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

   284

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

   285

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

   286

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

   287

                            selected = dialog.GetSelection()

   288

                        else:

   289

                            selected = None

   290

                        dialog.Destroy()

   291

                        if selected is None:

   292

                            return

   293

                        if selected == 0:

   294

                            location = "%I" + location

   295

                        elif selected == 1:

   296

                            location = "%Q" + location

   297

                        else:

   298

                            location = "%M" + location

   299

                    var_name = values[3]

   300

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

   301

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

   302

                    else:

   303

                        if location[1] == "Q":

   304

                            var_class = OUTPUT

   305

                        else:

   306

                            var_class = INPUT

   307

                        if values[2] is not None:

   308

                            var_type = values[2]

   309

                        else:

   310

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

   311

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

   312

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

   313

                            self.ParentWindow.RefreshVariablePanel()

   314

                            self.ParentWindow.ParentWindow.RefreshPouInstanceVariablesPanel()

   315

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

   316

            elif values[1] == "Global":

   317

                var_name = values[0]

   318

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

   319

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

   320

                else:

   321

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

   322

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

   323

                        self.ParentWindow.RefreshVariablePanel()

   324

                        self.ParentWindow.ParentWindow.RefreshPouInstanceVariablesPanel()

   325

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

   326

            elif values[1] == "Constant":

   327

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

   328

            elif values[3] == tagname:

   329

                if values[1] == "Output":

   330

                    var_class = OUTPUT

   331

                elif values[1] == "InOut":

   332

                    var_class = INPUT

   333

                else:

   334

                    var_class = INPUT

   335

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

   336

                if tree is not None:

   337

                    if len(tree[0]) > 0:

   338

                        menu = wx.Menu(title='')

   339

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

   340

                        self.ParentWindow.PopupMenuXY(menu)

   341

                    else:

   342

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

   343

                else:

   344

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

   345

            else:

   346

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

   347

        if message is not None:

   348

            wx.CallAfter(self.ShowMessage, message)

   349

   350

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

   351

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

   352

            if base_path:

   353

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

   354

            else:

   355

                child_path = child_name

   356

            if len(child_dimensions) > 0:

   357

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

   358

                child_name += "[]"

   359

            new_id = wx.NewId()

   360

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

   361

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

   362

            if len(child_tree) > 0:

   363

                new_id = wx.NewId()

   364

                child_menu = wx.Menu(title='')

   365

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

   366

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

   367

   368

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

   369

        def AddVariableFunction(event):

   370

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

   371

        return AddVariableFunction

   372

   373

    def ShowMessage(self, message):

   374

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

   375

        message.ShowModal()

   376

        message.Destroy()

   377

   378

"""

   379

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

   380

manipulating graphic elements

   381

"""

   382

   383

class Viewer(EditorPanel, DebugViewer):

   384

   385

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

   386

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

   387

            if id is not None:

   388

                event(self, id, function)

   389

            else:

   390

                event(self, function)

   391

   392

    # Add list of menu items to the given menu

   393

    def AddMenuItems(self, menu, items):

   394

        for item in items:

   395

            if item is None:

   396

                menu.AppendSeparator()

   397

            else:

   398

                id, kind, text, help, callback = item

   399

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

   400

                # Link menu event to corresponding called functions

   401

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

   402

   403

    # Add Block Pin Menu items to the given menu

   404

    def AddBlockPinMenuItems(self, menu, connector):

   405

        [ID_NO_MODIFIER, ID_NEGATED, ID_RISING_EDGE, 

   406

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

   407

   408

        # Create menu items

   409

        self.AddMenuItems(menu, [

   410

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

   411

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

   412

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

   413

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

   414

   415

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

   416

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

   417

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

   418

   419

        if connector.IsNegated():

   420

            menu.Check(ID_NEGATED, True)

   421

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

   422

            menu.Check(ID_RISING_EDGE, True)

   423

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

   424

            menu.Check(ID_FALLING_EDGE, True)

   425

        else:

   426

            menu.Check(ID_NO_MODIFIER, True)

   427

   428

    # Add Alignment Menu items to the given menu

   429

    def AddAlignmentMenuItems(self, menu):

   430

        [ID_ALIGN_LEFT, ID_ALIGN_CENTER, ID_ALIGN_RIGHT,

   431

         ID_ALIGN_TOP, ID_ALIGN_MIDDLE, ID_ALIGN_BOTTOM,

   432

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

   433

   434

        # Create menu items

   435

        self.AddMenuItems(menu, [

   436

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

   437

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

   438

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

   439

            None,

   440

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

   441

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

   442

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

   443

   444

    # Add Wire Menu items to the given menu

   445

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

   446

        [ID_ADD_SEGMENT, ID_DELETE_SEGMENT, ID_REPLACE_WIRE,

   447

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

   448

   449

        # Create menu items

   450

        self.AddMenuItems(menu, [

   451

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

   452

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

   453

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

   454

   455

        menu.Enable(ID_DELETE_SEGMENT, delete)

   456

        menu.Enable(ID_REPLACE_WIRE, replace)

   457

   458

    # Add Divergence Menu items to the given menu

   459

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

   460

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

   461

   462

        # Create menu items

   463

        self.AddMenuItems(menu, [

   464

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

   465

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

   466

   467

        menu.Enable(ID_DELETE_BRANCH, delete)

   468

   469

    # Add Add Menu items to the given menu

   470

    def AddAddMenuItems(self, menu):

   471

        [ID_ADD_BLOCK, ID_ADD_VARIABLE, ID_ADD_CONNECTION,

   472

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

   473

   474

        # Create menu items

   475

        self.AddMenuItems(menu, [

   476

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

   477

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

   478

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

   479

            None])

   480

   481

        if self.CurrentLanguage != "FBD":

   482

            [ID_ADD_POWER_RAIL, ID_ADD_CONTACT, ID_ADD_COIL,

   483

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

   484

   485

            # Create menu items

   486

            self.AddMenuItems(menu, [

   487

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

   488

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

   489

   490

            if self.CurrentLanguage != "SFC":

   491

                self.AddMenuItems(menu, [

   492

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

   493

   494

            menu.AppendSeparator()

   495

   496

        if self.CurrentLanguage == "SFC":

   497

            [ID_ADD_INITIAL_STEP, ID_ADD_STEP, ID_ADD_TRANSITION, 

   498

             ID_ADD_ACTION_BLOCK, ID_ADD_DIVERGENCE, ID_ADD_JUMP,

   499

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

   500

   501

            # Create menu items

   502

            self.AddMenuItems(menu, [

   503

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

   504

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

   505

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

   506

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

   507

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

   508

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

   509

                None])

   510

   511

        self.AddMenuItems(menu, [

   512

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

   513

   514

    # Add Default Menu items to the given menu

   515

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

   516

        if block:

   517

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

   518

   519

            # Create menu items

   520

            self.AddMenuItems(menu, [

   521

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

   522

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