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_POU, ITEM_PROGRAM, ITEM_FUNCTIONBLOCK

    35

    36

from dialogs import *

    37

from graphics import *

    38

from controls 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

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

    78

    79

def GetVariableCreationFunction(variable_type):

    80

    def variableCreationFunction(viewer, id, specific_values):

    81

        return FBD_Variable(viewer, variable_type, 

    82

                                    specific_values["name"], 

    83

                                    specific_values["value_type"], 

    84

                                    id,

    85

                                    specific_values["executionOrder"])

    86

    return variableCreationFunction

    87

    88

def GetConnectorCreationFunction(connector_type):

    89

    def connectorCreationFunction(viewer, id, specific_values):

    90

        return FBD_Connector(viewer, connector_type, 

    91

                                     specific_values["name"], id)

    92

    return connectorCreationFunction

    93

    94

def commentCreationFunction(viewer, id, specific_values):

    95

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

    96

    97

def GetPowerRailCreationFunction(powerrail_type):

    98

    def powerRailCreationFunction(viewer, id, specific_values):

    99

        return LD_PowerRail(viewer, powerrail_type, id, 

   100

                                    specific_values["connectors"])

   101

    return powerRailCreationFunction

   102

   103

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

   104

                 (False, "rising"): CONTACT_RISING,

   105

                 (False, "falling"): CONTACT_FALLING}

   106

   107

def contactCreationFunction(viewer, id, specific_values):

   108

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

   109

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

   110

                                     CONTACT_NORMAL)

   111

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

   112

   113

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

   114

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

   115

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

   116

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

   117

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

   118

   119

def coilCreationFunction(viewer, id, specific_values):

   120

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

   121

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

   122

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

   123

                               COIL_NORMAL)

   124

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

   125

   126

def stepCreationFunction(viewer, id, specific_values):

   127

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

   128

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

   129

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

   130

        step.AddAction()

   131

        connector = step.GetActionConnector()

   132

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

   133

    return step

   134

   135

def transitionCreationFunction(viewer, id, specific_values):

   136

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

   137

                                        specific_values.get("condition", None), 

   138

                                        specific_values["priority"], id)

   139

    return transition

   140

   141

def GetDivergenceCreationFunction(divergence_type):

   142

    def divergenceCreationFunction(viewer, id, specific_values):

   143

        return SFC_Divergence(viewer, divergence_type, 

   144

                                      specific_values["connectors"], id)

   145

    return divergenceCreationFunction

   146

   147

def jumpCreationFunction(viewer, id, specific_values):

   148

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

   149

   150

def actionBlockCreationFunction(viewer, id, specific_values):

   151

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

   152

   153

ElementCreationFunctions = {

   154

    "input": GetVariableCreationFunction(INPUT),

   155

    "output": GetVariableCreationFunction(OUTPUT),

   156

    "inout": GetVariableCreationFunction(INOUT),

   157

    "connector": GetConnectorCreationFunction(CONNECTOR),

   158

    "continuation": GetConnectorCreationFunction(CONTINUATION),

   159

    "comment": commentCreationFunction,

   160

    "leftPowerRail": GetPowerRailCreationFunction(LEFTRAIL),

   161

    "rightPowerRail": GetPowerRailCreationFunction(RIGHTRAIL),

   162

    "contact": contactCreationFunction,

   163

    "coil": coilCreationFunction,

   164

    "step": stepCreationFunction, 

   165

    "transition": transitionCreationFunction,

   166

    "selectionDivergence": GetDivergenceCreationFunction(SELECTION_DIVERGENCE), 

   167

    "selectionConvergence": GetDivergenceCreationFunction(SELECTION_CONVERGENCE), 

   168

    "simultaneousDivergence": GetDivergenceCreationFunction(SIMULTANEOUS_DIVERGENCE), 

   169

    "simultaneousConvergence": GetDivergenceCreationFunction(SIMULTANEOUS_CONVERGENCE), 

   170

    "jump": jumpCreationFunction,

   171

    "actionBlock": actionBlockCreationFunction,

   172

}

   173

   174

def sort_blocks(block_infos1, block_infos2):

   175

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

   176

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

   177

    if y1 == y2:

   178

        return cmp(x1, x2)

   179

    else:

   180

        return cmp(y1, y2)

   181

   182

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

   183

#                       Graphic elements Viewer base class

   184

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

   185

   186

# ID Constants for alignment menu items

   187

[ID_VIEWERALIGNMENTMENUITEMS0, ID_VIEWERALIGNMENTMENUITEMS1,

   188

 ID_VIEWERALIGNMENTMENUITEMS2, ID_VIEWERALIGNMENTMENUITEMS4,

   189

 ID_VIEWERALIGNMENTMENUITEMS5, ID_VIEWERALIGNMENTMENUITEMS6,

   190

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

   191

   192

# ID Constants for contextual menu items

   193

[ID_VIEWERCONTEXTUALMENUITEMS0, ID_VIEWERCONTEXTUALMENUITEMS1,

   194

 ID_VIEWERCONTEXTUALMENUITEMS2, ID_VIEWERCONTEXTUALMENUITEMS3,

   195

 ID_VIEWERCONTEXTUALMENUITEMS5, ID_VIEWERCONTEXTUALMENUITEMS6,

   196

 ID_VIEWERCONTEXTUALMENUITEMS8, ID_VIEWERCONTEXTUALMENUITEMS9,

   197

 ID_VIEWERCONTEXTUALMENUITEMS11, ID_VIEWERCONTEXTUALMENUITEMS12,

   198

 ID_VIEWERCONTEXTUALMENUITEMS14, ID_VIEWERCONTEXTUALMENUITEMS16,

   199

 ID_VIEWERCONTEXTUALMENUITEMS17,

   200

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

   201

   202

   203

class ViewerDropTarget(wx.TextDropTarget):

   204

   205

    def __init__(self, parent):

   206

        wx.TextDropTarget.__init__(self)

   207

        self.ParentWindow = parent

   208

   209

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

   210

        tagname = self.ParentWindow.GetTagName()

   211

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

   212

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

   213

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

   214

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

   215

        scaling = self.ParentWindow.Scaling

   216

        message = None

   217

        try:

   218

            values = eval(data)

   219

        except:

   220

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

   221

            values = None

   222

        if not isinstance(values, TupleType):

   223

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

   224

            values = None

   225

        if values is not None:

   226

            if values[1] == "debug":

   227

                pass

   228

            elif values[1] == "program":

   229

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

   230

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

   231

                words = tagname.split("::")

   232

                if pou_name == values[0]:

   233

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

   234

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

   235

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

   236

                elif words[0] == "T" and values[1] != "function":

   237

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

   238

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

   239

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

   240

                else:

   241

                    blockname = values[2]

   242

                    if len(values) > 3:

   243

                        blockinputs = values[3]

   244

                    else:

   245

                        blockinputs = None

   246

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

   247

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

   248

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

   249

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

   250

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

   251

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

   252

                    else:

   253

                        id = self.ParentWindow.GetNewId()

   254

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

   255

                        width, height = block.GetMinSize()

   256

                        if scaling is not None:

   257

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

   258

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

   259

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

   260

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

   261

                        block.SetPosition(x, y)

   262

                        block.SetSize(width, height)

   263

                        self.ParentWindow.AddBlock(block)

   264

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

   265

                        self.ParentWindow.RefreshBlockModel(block)

   266

                        self.ParentWindow.RefreshBuffer()

   267

                        self.ParentWindow.RefreshScrollBars()

   268

                        self.ParentWindow.RefreshVisibleElements()

   269

                        self.ParentWindow.RefreshVariablePanel()

   270

                        self.ParentWindow.Refresh(False)

   271

            elif values[1] == "location":

   272

                if pou_type == "program":

   273

                    location = values[0]

   274

                    if not location.startswith("%"):

   275

                        dialog = wx.SingleChoiceDialog(self.ParentWindow, 

   276

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

   277

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

   278

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

   279

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

   280

                            selected = dialog.GetSelection()

   281

                        else:

   282

                            selected = None

   283

                        dialog.Destroy()

   284

                        if selected is None:

   285

                            return

   286

                        if selected == 0:

   287

                            location = "%I" + location

   288

                        elif selected == 1:

   289

                            location = "%Q" + location

   290

                        else:

   291

                            location = "%M" + location

   292

                    var_name = values[3]

   293

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

   294

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

   295

                    else:

   296

                        if location[1] == "Q":

   297

                            var_class = OUTPUT

   298

                        else:

   299

                            var_class = INPUT

   300

                        if values[2] is not None:

   301

                            var_type = values[2]

   302

                        else:

   303

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

   304

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

   305

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

   306

                            self.ParentWindow.RefreshVariablePanel()

   307

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

   308

            elif values[1] == "Global":

   309

                var_name = values[0]

   310

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

   311

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

   312

                else:

   313

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

   314

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

   315

                        self.ParentWindow.RefreshVariablePanel()

   316

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

   317

            elif values[1] == "Constant":

   318

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

   319

            elif values[3] == tagname:

   320

                if values[1] == "Output":

   321

                    var_class = OUTPUT

   322

                elif values[1] == "InOut":

   323

                    var_class = INPUT

   324

                else:

   325

                    var_class = INPUT

   326

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

   327

                if tree is not None:

   328

                    if len(tree[0]) > 0:

   329

                        menu = wx.Menu(title='')

   330

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

   331

                        self.ParentWindow.PopupMenuXY(menu)

   332

                    else:

   333

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

   334

                else:

   335

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

   336

            else:

   337

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

   338

        if message is not None:

   339

            wx.CallAfter(self.ShowMessage, message)

   340

   341

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

   342

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

   343

            if base_path:

   344

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

   345

            else:

   346

                child_path = child_name

   347

            if len(child_dimensions) > 0:

   348

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

   349

                child_name += "[]"

   350

            new_id = wx.NewId()

   351

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

   352

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

   353

            if len(child_tree) > 0:

   354

                new_id = wx.NewId()

   355

                child_menu = wx.Menu(title='')

   356

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

   357

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

   358

   359

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

   360

        def AddVariableFunction(event):

   361

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

   362

        return AddVariableFunction

   363

   364

    def ShowMessage(self, message):

   365

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

   366

        message.ShowModal()

   367

        message.Destroy()

   368

   369

"""

   370

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

   371

manipulating graphic elements

   372

"""

   373

   374

class Viewer(EditorPanel, DebugViewer):

   375

   376

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

   377

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

   378

            if id is not None:

   379

                event(self, id, function)

   380

            else:

   381

                event(self, function)

   382

   383

    # Add list of menu items to the given menu

   384

    def AddMenuItems(self, menu, items):

   385

        for item in items:

   386

            if item is None:

   387

                menu.AppendSeparator()

   388

            else:

   389

                id, kind, text, help, callback = item

   390

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

   391

                # Link menu event to corresponding called functions

   392

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

   393

   394

    # Add Block Pin Menu items to the given menu

   395

    def AddBlockPinMenuItems(self, menu, connector):

   396

        [ID_NO_MODIFIER, ID_NEGATED, ID_RISING_EDGE, 

   397

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

   398

   399

        # Create menu items

   400

        self.AddMenuItems(menu, [

   401

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

   402

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

   403

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

   404

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

   405

   406

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

   407

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

   408

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

   409

   410

        if connector.IsNegated():

   411

            menu.Check(ID_NEGATED, True)

   412

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

   413

            menu.Check(ID_RISING_EDGE, True)

   414

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

   415

            menu.Check(ID_FALLING_EDGE, True)

   416

        else:

   417

            menu.Check(ID_NO_MODIFIER, True)

   418

   419

    # Add Alignment Menu items to the given menu

   420

    def AddAlignmentMenuItems(self, menu):

   421

        [ID_ALIGN_LEFT, ID_ALIGN_CENTER, ID_ALIGN_RIGHT,

   422

         ID_ALIGN_TOP, ID_ALIGN_MIDDLE, ID_ALIGN_BOTTOM,

   423

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

   424

   425

        # Create menu items

   426

        self.AddMenuItems(menu, [

   427

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

   428

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

   429

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

   430

            None,

   431

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

   432

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

   433

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

   434

   435

    # Add Wire Menu items to the given menu

   436

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

   437

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

   438

   439

        # Create menu items

   440

        self.AddMenuItems(menu, [

   441

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

   442

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

   443

   444

        menu.Enable(ID_DELETE_SEGMENT, delete)

   445

   446

    # Add Divergence Menu items to the given menu

   447

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

   448

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

   449

   450

        # Create menu items

   451

        self.AddMenuItems(menu, [

   452

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

   453

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

   454

   455

        menu.Enable(ID_DELETE_BRANCH, delete)

   456

   457

    # Add Add Menu items to the given menu

   458

    def AddAddMenuItems(self, menu):

   459

        [ID_ADD_BLOCK, ID_ADD_VARIABLE, ID_ADD_CONNECTION,

   460

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

   461

   462

        # Create menu items

   463

        self.AddMenuItems(menu, [

   464

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

   465

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

   466

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

   467

            None])

   468

   469

        if self.CurrentLanguage != "FBD":

   470

            [ID_ADD_POWER_RAIL, ID_ADD_CONTACT, ID_ADD_COIL,

   471

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

   472

   473

            # Create menu items

   474

            self.AddMenuItems(menu, [

   475

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

   476

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

   477

   478

            if self.CurrentLanguage != "SFC":

   479

                self.AddMenuItems(menu, [

   480

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

   481

   482

            menu.AppendSeparator()

   483

   484

        if self.CurrentLanguage == "SFC":

   485

            [ID_ADD_INITIAL_STEP, ID_ADD_STEP, ID_ADD_TRANSITION, 

   486

             ID_ADD_ACTION_BLOCK, ID_ADD_DIVERGENCE, ID_ADD_JUMP,

   487

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

   488

   489

            # Create menu items

   490

            self.AddMenuItems(menu, [

   491

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