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["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.ParentWindow.RefreshPouInstanceVariablesPanel()

   275

                        self.ParentWindow.Refresh(False)

   276

            elif values[1] == "location":

   277

                if pou_type == "program":

   278

                    location = values[0]

   279

                    if not location.startswith("%"):

   280

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

   281

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

   282

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

   283

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

   284

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

   285

                            selected = dialog.GetSelection()

   286

                        else:

   287

                            selected = None

   288

                        dialog.Destroy()

   289

                        if selected is None:

   290

                            return

   291

                        if selected == 0:

   292

                            location = "%I" + location

   293

                        elif selected == 1:

   294

                            location = "%Q" + location

   295

                        else:

   296

                            location = "%M" + location

   297

                    var_name = values[3]

   298

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

   299

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

   300

                    else:

   301

                        if location[1] == "Q":

   302

                            var_class = OUTPUT

   303

                        else:

   304

                            var_class = INPUT

   305

                        if values[2] is not None:

   306

                            var_type = values[2]

   307

                        else:

   308

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

   309

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

   310

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

   311

                            self.ParentWindow.RefreshVariablePanel()

   312

                            self.ParentWindow.ParentWindow.RefreshPouInstanceVariablesPanel()

   313

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

   314

            elif values[1] == "Global":

   315

                var_name = values[0]

   316

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

   317

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

   318

                else:

   319

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

   320

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

   321

                        self.ParentWindow.RefreshVariablePanel()

   322

                        self.ParentWindow.ParentWindow.RefreshPouInstanceVariablesPanel()

   323

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

   324

            elif values[1] == "Constant":

   325

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

   326

            elif values[3] == tagname:

   327

                if values[1] == "Output":

   328

                    var_class = OUTPUT

   329

                elif values[1] == "InOut":

   330

                    var_class = INPUT

   331

                else:

   332

                    var_class = INPUT

   333

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

   334

                if tree is not None:

   335

                    if len(tree[0]) > 0:

   336

                        menu = wx.Menu(title='')

   337

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

   338

                        self.ParentWindow.PopupMenuXY(menu)

   339

                    else:

   340

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

   341

                else:

   342

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

   343

            else:

   344

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

   345

        if message is not None:

   346

            wx.CallAfter(self.ShowMessage, message)

   347

   348

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

   349

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

   350

            if base_path:

   351

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

   352

            else:

   353

                child_path = child_name

   354

            if len(child_dimensions) > 0:

   355

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

   356

                child_name += "[]"

   357

            new_id = wx.NewId()

   358

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

   359

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

   360

            if len(child_tree) > 0:

   361

                new_id = wx.NewId()

   362

                child_menu = wx.Menu(title='')

   363

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

   364

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

   365

   366

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

   367

        def AddVariableFunction(event):

   368

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

   369

        return AddVariableFunction

   370

   371

    def ShowMessage(self, message):

   372

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

   373

        message.ShowModal()

   374

        message.Destroy()

   375

   376

"""

   377

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

   378

manipulating graphic elements

   379

"""

   380

   381

class Viewer(EditorPanel, DebugViewer):

   382

   383

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

   384

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

   385

            if id is not None:

   386

                event(self, id, function)

   387

            else:

   388

                event(self, function)

   389

   390

    # Add list of menu items to the given menu

   391

    def AddMenuItems(self, menu, items):

   392

        for item in items:

   393

            if item is None:

   394

                menu.AppendSeparator()

   395

            else:

   396

                id, kind, text, help, callback = item

   397

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

   398

                # Link menu event to corresponding called functions

   399

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

   400

   401

    # Add Block Pin Menu items to the given menu

   402

    def AddBlockPinMenuItems(self, menu, connector):

   403

        [ID_NO_MODIFIER, ID_NEGATED, ID_RISING_EDGE, 

   404

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

   405

   406

        # Create menu items

   407

        self.AddMenuItems(menu, [

   408

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

   409

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

   410

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

   411

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

   412

   413

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

   414

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

   415

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

   416

   417

        if connector.IsNegated():

   418

            menu.Check(ID_NEGATED, True)

   419

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

   420

            menu.Check(ID_RISING_EDGE, True)

   421

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

   422

            menu.Check(ID_FALLING_EDGE, True)

   423

        else:

   424

            menu.Check(ID_NO_MODIFIER, True)

   425

   426

    # Add Alignment Menu items to the given menu

   427

    def AddAlignmentMenuItems(self, menu):

   428

        [ID_ALIGN_LEFT, ID_ALIGN_CENTER, ID_ALIGN_RIGHT,

   429

         ID_ALIGN_TOP, ID_ALIGN_MIDDLE, ID_ALIGN_BOTTOM,

   430

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

   431

   432

        # Create menu items

   433

        self.AddMenuItems(menu, [

   434

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

   435

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

   436

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

   437

            None,

   438

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

   439

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

   440

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

   441

   442

    # Add Wire Menu items to the given menu

   443

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

   444

        [ID_ADD_SEGMENT, ID_DELETE_SEGMENT, ID_REPLACE_WIRE,

   445

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

   446

   447

        # Create menu items

   448

        self.AddMenuItems(menu, [

   449

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

   450

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

   451

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

   452

   453

        menu.Enable(ID_DELETE_SEGMENT, delete)

   454

        menu.Enable(ID_REPLACE_WIRE, replace)

   455

   456

    # Add Divergence Menu items to the given menu

   457

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

   458

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

   459

   460

        # Create menu items

   461

        self.AddMenuItems(menu, [

   462

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

   463

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

   464

   465

        menu.Enable(ID_DELETE_BRANCH, delete)

   466

   467

    # Add Add Menu items to the given menu

   468

    def AddAddMenuItems(self, menu):

   469

        [ID_ADD_BLOCK, ID_ADD_VARIABLE, ID_ADD_CONNECTION,

   470

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

   471

   472

        # Create menu items

   473

        self.AddMenuItems(menu, [

   474

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

   475

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

   476

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

   477

            None])

   478

   479

        if self.CurrentLanguage != "FBD":

   480

            [ID_ADD_POWER_RAIL, ID_ADD_CONTACT, ID_ADD_COIL,

   481

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

   482

   483

            # Create menu items

   484

            self.AddMenuItems(menu, [

   485

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

   486

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

   487

   488

            if self.CurrentLanguage != "SFC":

   489

                self.AddMenuItems(menu, [

   490

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

   491

   492

            menu.AppendSeparator()

   493

   494

        if self.CurrentLanguage == "SFC":

   495

            [ID_ADD_INITIAL_STEP, ID_ADD_STEP, ID_ADD_TRANSITION, 

   496

             ID_ADD_ACTION_BLOCK, ID_ADD_DIVERGENCE, ID_ADD_JUMP,

   497

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

   498

   499

            # Create menu items

   500

            self.AddMenuItems(menu, [

   501

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

   502

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

   503

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

   504

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

   505

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

   506

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

   507

                None])

   508

   509

        self.AddMenuItems(menu, [

   510

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

   511

   512

    # Add Default Menu items to the given menu

   513

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

   514

        if block:

   515

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

   516

   517

            # Create menu items

   518

            self.AddMenuItems(menu, [

   519

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

   520

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

   521

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

   522

   523

            menu.Enable(ID_EDIT_BLOCK, edit)

   524

   525

        else:

   526

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