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):

   211

        tagname = self.ParentWindow.GetTagName()

   212

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

   213

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

   214

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

   215

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

   216

        scaling = self.ParentWindow.Scaling

   217

        message = None

   218

        try:

   219

            values = eval(data)

   220

        except:

   221

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

   222

            values = None

   223

        if not isinstance(values, TupleType):

   224

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

   225

            values = None

   226

        if values is not None:

   227

            if values[1] == "debug":

   228

                pass

   229

            elif values[1] == "program":

   230

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

   231

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

   232

                words = tagname.split("::")

   233

                if pou_name == values[0]:

   234

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

   235

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

   236

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

   237

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

   238

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

   239

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

   240

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

   241

                else:

   242

                    blockname = values[2]

   243

                    if len(values) > 3:

   244

                        blockinputs = values[3]

   245

                    else:

   246

                        blockinputs = None

   247

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

   248

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

   249

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

   250

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

   251

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

   252

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

   253

                    else:

   254

                        id = self.ParentWindow.GetNewId()

   255

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

   256

                        width, height = block.GetMinSize()

   257

                        if scaling is not None:

   258

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

   259

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

   260

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

   261

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

   262

                        block.SetPosition(x, y)

   263

                        block.SetSize(width, height)

   264

                        self.ParentWindow.AddBlock(block)

   265

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

   266

                        self.ParentWindow.RefreshBlockModel(block)

   267

                        self.ParentWindow.RefreshBuffer()

   268

                        self.ParentWindow.RefreshScrollBars()

   269

                        self.ParentWindow.RefreshVisibleElements()

   270

                        self.ParentWindow.RefreshVariablePanel()

   271

                        self.ParentWindow.Refresh(False)

   272

            elif values[1] == "location":

   273

                if pou_type == "program":

   274

                    location = values[0]

   275

                    if not location.startswith("%"):

   277

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

   278

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

   279

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

   280

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

   281

                            selected = dialog.GetSelection()

   282

                        else:

   283

                            selected = None

   284

                        dialog.Destroy()

   285

                        if selected is None:

   286

                            return

   287

                        if selected == 0:

   288

                            location = "%I" + location

   289

                        elif selected == 1:

   290

                            location = "%Q" + location

   291

                        else:

   292

                            location = "%M" + location

   293

                    var_name = values[3]

   294

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

   295

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

   296

                    else:

   297

                        if location[1] == "Q":

   298

                            var_class = OUTPUT

   299

                        else:

   300

                            var_class = INPUT

   301

                        if values[2] is not None:

   302

                            var_type = values[2]

   303

                        else:

   304

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

   305

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

   306

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

   307

                            self.ParentWindow.RefreshVariablePanel()

   308

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

   309

            elif values[1] == "Global":

   310

                var_name = values[0]

   311

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

   312

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

   313

                else:

   314

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

   315

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

   316

                        self.ParentWindow.RefreshVariablePanel()

   317

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

   318

            elif values[1] == "Constant":

   319

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

   320

            elif values[3] == tagname:

   321

                if values[1] == "Output":

   322

                    var_class = OUTPUT

   323

                elif values[1] == "InOut":

   324

                    var_class = INPUT

   325

                else:

   326

                    var_class = INPUT

   327

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

   328

                if tree is not None:

   329

                    if len(tree[0]) > 0:

   330

                        menu = wx.Menu(title='')

   331

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

   332

                        self.ParentWindow.PopupMenuXY(menu)

   333

                    else:

   334

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

   335

                else:

   336

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

   337

            else:

   338

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

   339

        if message is not None:

   340

            wx.CallAfter(self.ShowMessage, message)

   341

   342

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

   343

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

   344

            if base_path:

   345

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

   346

            else:

   347

                child_path = child_name

   348

            if len(child_dimensions) > 0:

   349

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

   350

                child_name += "[]"

   351

            new_id = wx.NewId()

   352

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

   353

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

   354

            if len(child_tree) > 0:

   355

                new_id = wx.NewId()

   356

                child_menu = wx.Menu(title='')

   357

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

   358

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

   359

   360

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

   361

        def AddVariableFunction(event):

   362

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

   363

        return AddVariableFunction

   364

   365

    def ShowMessage(self, message):

   366

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

   367

        message.ShowModal()

   368

        message.Destroy()

   369

   370

"""

   371

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

   372

manipulating graphic elements

   373

"""

   374

   375

class Viewer(EditorPanel, DebugViewer):

   376

   377

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

   378

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

   379

            if id is not None:

   380

                event(self, id, function)

   381

            else:

   382

                event(self, function)

   383

   384

    # Add list of menu items to the given menu

   385

    def AddMenuItems(self, menu, items):

   386

        for item in items:

   387

            if item is None:

   388

                menu.AppendSeparator()

   389

            else:

   390

                id, kind, text, help, callback = item

   391

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

   392

                # Link menu event to corresponding called functions

   393

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

   394

   395

    # Add Block Pin Menu items to the given menu

   396

    def AddBlockPinMenuItems(self, menu, connector):

   397

        [ID_NO_MODIFIER, ID_NEGATED, ID_RISING_EDGE, 

   398

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

   399

   400

        # Create menu items

   401

        self.AddMenuItems(menu, [

   402

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

   403

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

   404

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

   405

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

   406

   407

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

   408

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

   409

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

   410

   411

        if connector.IsNegated():

   412

            menu.Check(ID_NEGATED, True)

   413

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

   414

            menu.Check(ID_RISING_EDGE, True)

   415

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

   416

            menu.Check(ID_FALLING_EDGE, True)

   417

        else:

   418

            menu.Check(ID_NO_MODIFIER, True)

   419

   420

    # Add Alignment Menu items to the given menu

   421

    def AddAlignmentMenuItems(self, menu):

   422

        [ID_ALIGN_LEFT, ID_ALIGN_CENTER, ID_ALIGN_RIGHT,

   423

         ID_ALIGN_TOP, ID_ALIGN_MIDDLE, ID_ALIGN_BOTTOM,

   424

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

   425

   426

        # Create menu items

   427

        self.AddMenuItems(menu, [

   428

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

   429

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

   430

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

   431

            None,

   432

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

   433

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

   434

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

   435

   436

    # Add Wire Menu items to the given menu

   437

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

   438

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

   439

   440

        # Create menu items

   441

        self.AddMenuItems(menu, [

   442

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

   443

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

   444

   445

        menu.Enable(ID_DELETE_SEGMENT, delete)

   446

   447

    # Add Divergence Menu items to the given menu

   448

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

   449

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

   450

   451

        # Create menu items

   452

        self.AddMenuItems(menu, [

   453

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

   454

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

   455

   456

        menu.Enable(ID_DELETE_BRANCH, delete)

   457

   458

    # Add Add Menu items to the given menu

   459

    def AddAddMenuItems(self, menu):

   460

        [ID_ADD_BLOCK, ID_ADD_VARIABLE, ID_ADD_CONNECTION,

   461

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

   462

   463

        # Create menu items

   464

        self.AddMenuItems(menu, [

   465

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

   466

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

   467

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

   468

            None])

   469

   470

        if self.CurrentLanguage != "FBD":

   471

            [ID_ADD_POWER_RAIL, ID_ADD_CONTACT, ID_ADD_COIL,

   472

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

   473

   474

            # Create menu items

   475

            self.AddMenuItems(menu, [

   476

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

   477

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

   478

   479

            if self.CurrentLanguage != "SFC":

   480

                self.AddMenuItems(menu, [

   481

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

   482

   483

            menu.AppendSeparator()

   484

   485

        if self.CurrentLanguage == "SFC":

   486

            [ID_ADD_INITIAL_STEP, ID_ADD_STEP, ID_ADD_TRANSITION, 

   487

             ID_ADD_ACTION_BLOCK, ID_ADD_DIVERGENCE, ID_ADD_JUMP,

   488

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

   489

   490

            # Create menu items

   491

            self.AddMenuItems(menu, [

   492