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 EditorPanel 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

        self.ParentWindow.Select()

   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 self.ParentWindow.Controler.PouIsUsedBy(pou_name, values[0], self.ParentWindow.Debug):

   238

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

   239

                else:

   240

                    blockname = values[2]

   241

                    if len(values) > 3:

   242

                        blockinputs = values[3]

   243

                    else:

   244

                        blockinputs = None

   245

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

   246

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

   247

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

   248

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

   249

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

   250

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

   251

                    else:

   252

                        id = self.ParentWindow.GetNewId()

   253

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

   254

                        width, height = block.GetMinSize()

   255

                        if scaling is not None:

   256

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

   257

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

   258

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

   259

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

   260

                        block.SetPosition(x, y)

   261

                        block.SetSize(width, height)

   262

                        self.ParentWindow.AddBlock(block)

   263

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

   264

                        self.ParentWindow.RefreshBlockModel(block)

   265

                        self.ParentWindow.RefreshBuffer()

   266

                        self.ParentWindow.RefreshScrollBars()

   267

                        self.ParentWindow.RefreshVisibleElements()

   268

                        self.ParentWindow.RefreshVariablePanel()

   269

                        self.ParentWindow.Refresh(False)

   270

            elif values[1] == "location":

   271

                if pou_type == "program":

   272

                    location = values[0]

   273

                    if not location.startswith("%"):

   274

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

   275

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

   276

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

   277

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

   278

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

   279

                            selected = dialog.GetSelection()

   280

                        else:

   281

                            selected = None

   282

                        dialog.Destroy()

   283

                        if selected is None:

   284

                            return

   285

                        if selected == 0:

   286

                            location = "%I" + location

   287

                        elif selected == 1:

   288

                            location = "%Q" + location

   289

                        else:

   290

                            location = "%M" + location

   291

                    var_name = values[3]

   292

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

   293

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

   294

                    else:

   295

                        if location[1] == "Q":

   296

                            var_class = OUTPUT

   297

                        else:

   298

                            var_class = INPUT

   299

                        if values[2] is not None:

   300

                            var_type = values[2]

   301

                        else:

   302

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

   303

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

   304

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

   305

                            self.ParentWindow.RefreshVariablePanel()

   306

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

   307

            elif values[1] == "Global":

   308

                var_name = values[0]

   309

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

   310

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

   311

                else:

   312

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

   313

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

   314

                        self.ParentWindow.RefreshVariablePanel()

   315

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

   316

            elif values[1] == "Constant":

   317

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

   318

            elif values[3] == tagname:

   319

                if values[1] == "Output":

   320

                    var_class = OUTPUT

   321

                elif values[1] == "InOut":

   322

                    var_class = INPUT

   323

                else:

   324

                    var_class = INPUT

   325

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

   326

                if tree is not None:

   327

                    if len(tree[0]) > 0:

   328

                        menu = wx.Menu(title='')

   329

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

   330

                        self.ParentWindow.PopupMenuXY(menu)

   331

                    else:

   332

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

   333

                else:

   334

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

   335

            else:

   336

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

   337

        if message is not None:

   338

            wx.CallAfter(self.ShowMessage, message)

   339

   340

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

   341

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

   342

            if base_path:

   343

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

   344

            else:

   345

                child_path = child_name

   346

            if len(child_dimensions) > 0:

   347

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

   348

                child_name += "[]"

   349

            new_id = wx.NewId()

   350

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

   351

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

   352

            if len(child_tree) > 0:

   353

                new_id = wx.NewId()

   354

                child_menu = wx.Menu(title='')

   355

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

   356

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

   357

   358

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

   359

        def AddVariableFunction(event):

   360

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

   361

        return AddVariableFunction

   362

   363

    def ShowMessage(self, message):

   364

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

   365

        message.ShowModal()

   366

        message.Destroy()

   367

   368

"""

   369

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

   370

manipulating graphic elements

   371

"""

   372

   373

class Viewer(EditorPanel, DebugViewer):

   374

   375

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

   376

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

   377

            if id is not None:

   378

                event(self, id, function)

   379

            else:

   380

                event(self, function)

   381

   382

    # Add list of menu items to the given menu

   383

    def AddMenuItems(self, menu, items):

   384

        for item in items:

   385

            if item is None:

   386

                menu.AppendSeparator()

   387

            else:

   388

                id, kind, text, help, callback = item

   389

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

   390

                # Link menu event to corresponding called functions

   391

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

   392

   393

    # Add Block Pin Menu items to the given menu

   394

    def AddBlockPinMenuItems(self, menu, connector):

   395

        [ID_NO_MODIFIER, ID_NEGATED, ID_RISING_EDGE, 

   396

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

   397

   398

        # Create menu items

   399

        self.AddMenuItems(menu, [

   400

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

   401

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

   402

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

   403

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

   404

   405

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

   406

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

   407

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

   408

   409

        if connector.IsNegated():

   410

            menu.Check(ID_NEGATED, True)

   411

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

   412

            menu.Check(ID_RISING_EDGE, True)

   413

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

   414

            menu.Check(ID_FALLING_EDGE, True)

   415

        else:

   416

            menu.Check(ID_NO_MODIFIER, True)

   417

   418

    # Add Alignment Menu items to the given menu

   419

    def AddAlignmentMenuItems(self, menu):

   420

        [ID_ALIGN_LEFT, ID_ALIGN_CENTER, ID_ALIGN_RIGHT,

   421

         ID_ALIGN_TOP, ID_ALIGN_MIDDLE, ID_ALIGN_BOTTOM,

   422

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

   423

   424

        # Create menu items

   425

        self.AddMenuItems(menu, [

   426

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

   427

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

   428

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

   429

            None,

   430

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

   431

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

   432

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

   433

   434

    # Add Wire Menu items to the given menu

   435

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

   436

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

   437

   438

        # Create menu items

   439

        self.AddMenuItems(menu, [

   440

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

   441

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

   442

   443

        menu.Enable(ID_DELETE_SEGMENT, delete)

   444

   445

    # Add Divergence Menu items to the given menu

   446

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

   447

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

   448

   449

        # Create menu items

   450

        self.AddMenuItems(menu, [

   451

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

   452

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

   453

   454

        menu.Enable(ID_DELETE_BRANCH, delete)

   455

   456

    # Add Add Menu items to the given menu

   457

    def AddAddMenuItems(self, menu):

   458

        [ID_ADD_BLOCK, ID_ADD_VARIABLE, ID_ADD_CONNECTION,

   459

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

   460

   461

        # Create menu items

   462

        self.AddMenuItems(menu, [

   463

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

   464

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

   465

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

   466

            None])

   467

   468

        if self.CurrentLanguage != "FBD":

   469

            [ID_ADD_POWER_RAIL, ID_ADD_CONTACT, ID_ADD_COIL,

   470

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

   471

   472

            # Create menu items

   473

            self.AddMenuItems(menu, [

   474

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

   475

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

   476

   477

            if self.CurrentLanguage != "SFC":

   478

                self.AddMenuItems(menu, [

   479

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

   480

   481

            menu.AppendSeparator()

   482

   483

        if self.CurrentLanguage == "SFC":

   484

            [ID_ADD_INITIAL_STEP, ID_ADD_STEP, ID_ADD_TRANSITION, 

   485

             ID_ADD_ACTION_BLOCK, ID_ADD_DIVERGENCE, ID_ADD_JUMP,

   486

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

   487

   488

            # Create menu items

   489

            self.AddMenuItems(menu, [

   490

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

   491

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

   492

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

   493

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

   494

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

   495

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

   496

                None])

   497

   498

        self.AddMenuItems(menu, [

   499

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

   500

   501

    # Add Default Menu items to the given menu

   502

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

   503

        if block:

   504

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

   505

   506

            # Create menu items

   507

            self.AddMenuItems(menu, [

   508

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

   509

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

   510

   511

            menu.Enable(ID_EDIT_BLOCK, edit)

   512

   513

        else:

   514

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

   515

   516

            # Create menu items

   517

            self.AddMenuItems(menu, [

   518

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

   519

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

   520

   521

            menu.AppendSeparator()

   522

   523

            add_menu = wx.Menu(title='')

   524

            self.AddAddMenuItems(add_menu)

   525

            menu.AppendMenu(-1, _(u'Add'), add_menu)

   526

   527

        menu.AppendSeparator()

   528

   529

        [ID_CUT, ID_COPY, ID_PASTE] = [wx.NewId() for i in xrange(3)]

   530