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

from datetime import datetime

    26

import wx, wx.grid

    27

    28

if wx.VERSION >= (2, 8, 0):

    29

    import wx.aui

    30

    USE_AUI = True

    31

else:

    32

    USE_AUI = False

    33

    34

import os, re, platform, sys, time, traceback, getopt

    35

import cPickle

    36

    37

CWD = os.path.split(os.path.realpath(__file__))[0]

    38

base_folder = os.path.split(CWD)[0]

    39

sys.path.append(base_folder)

    40

from docutil import *

    41

    42

from types import TupleType

    43

    44

__version__ = "$Revision: 1.130 $"

    45

    46

if __name__ == '__main__':

    47

    # Usage message displayed when help request or when error detected in 

    48

    # command line

    49

    def usage():

    50

        print "\nUsage of PLCOpenEditor.py :"

    51

        print "\n   %s [Filepath]\n"%sys.argv[0]

    52

    53

    # Parse options given to PLCOpenEditor in command line

    54

    try:

    55

        opts, args = getopt.getopt(sys.argv[1:], "h", ["help"])

    56

    except getopt.GetoptError:

    57

        # print help information and exit:

    58

        usage()

    59

        sys.exit(2)

    60

    61

    # Extract if help has been requested

    62

    for o, a in opts:

    63

        if o in ("-h", "--help"):

    64

            usage()

    65

            sys.exit()

    66

    67

    # Extract the optional filename to open

    68

    fileOpen = None

    69

    if len(args) > 1:

    70

        usage()

    71

        sys.exit()

    72

    elif len(args) == 1:

    73

        fileOpen = args[0]

    74

    75

    # Create wxApp (Need to create App before internationalization because of

    76

    # Windows) 

    77

    app = wx.PySimpleApp()

    78

    79

# Import module for internationalization

    80

import gettext

    81

import __builtin__

    82

    83

# Get folder containing translation files

    84

localedir = os.path.join(CWD,"locale")

    85

# Get the default language

    86

langid = wx.LANGUAGE_DEFAULT

    87

# Define translation domain (name of translation files)

    88

domain = "PLCOpenEditor"

    89

    90

# Define locale for wx

    91

loc = __builtin__.__dict__.get('loc', None)

    92

if loc is None:

    93

    test_loc = wx.Locale(langid)

    94

    test_loc.AddCatalogLookupPathPrefix(localedir)

    95

    if test_loc.AddCatalog(domain):

    96

        loc = wx.Locale(langid)

    97

    else:

    98

        loc = wx.Locale(wx.LANGUAGE_ENGLISH)

    99

    __builtin__.__dict__['loc'] = loc

   100

# Define location for searching translation files

   101

loc.AddCatalogLookupPathPrefix(localedir)

   102

# Define locale domain

   103

loc.AddCatalog(domain)

   104

   105

if __name__ == '__main__':

   106

    __builtin__.__dict__['_'] = wx.GetTranslation

   107

   108

from SFCViewer import *

   109

from LDViewer import *

   110

from Viewer import *

   111

from TextViewer import *

   112

from GraphicViewer import *

   113

from RessourceEditor import *

   114

from DataTypeEditor import *

   115

from PLCControler import *

   116

from SearchResultPanel import SearchResultPanel

   118

   119

# Define PLCOpenEditor controls id

   120

[ID_PLCOPENEDITOR, ID_PLCOPENEDITORLEFTNOTEBOOK, 

   121

 ID_PLCOPENEDITORBOTTOMNOTEBOOK, ID_PLCOPENEDITORRIGHTNOTEBOOK, 

   129

] = [wx.NewId() for _init_ctrls in range(17)]

   130

   131

# Define PLCOpenEditor FileMenu extra items id

   132

[ID_PLCOPENEDITORFILEMENUGENERATE, 

   133

] = [wx.NewId() for _init_coll_FileMenu_Items in range(1)]

   134

   135

# Define PLCOpenEditor EditMenu extra items id

   136

[ID_PLCOPENEDITOREDITMENUENABLEUNDOREDO, ID_PLCOPENEDITOREDITMENUADDDATATYPE, 

   137

 ID_PLCOPENEDITOREDITMENUADDFUNCTION, ID_PLCOPENEDITOREDITMENUADDFUNCTIONBLOCK, 

   138

 ID_PLCOPENEDITOREDITMENUADDPROGRAM, ID_PLCOPENEDITOREDITMENUADDCONFIGURATION,

   139

 ID_PLCOPENEDITOREDITMENUSEARCHINPROJECT, 

   140

] = [wx.NewId() for _init_coll_EditMenu_Items in range(7)]

   141

   142

# Define PLCOpenEditor DisplayMenu extra items id

   143

[ID_PLCOPENEDITORDISPLAYMENURESETPERSPECTIVE, 

   144

] = [wx.NewId() for _init_coll_DisplayMenu_Items in range(1)]

   145

   146

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

   147

#                            EditorToolBar definitions

   148

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

   149

   150

# Define PLCOpenEditor Toolbar items id

   151

[ID_PLCOPENEDITOREDITORTOOLBARSELECTION, ID_PLCOPENEDITOREDITORTOOLBARCOMMENT,

   152

 ID_PLCOPENEDITOREDITORTOOLBARVARIABLE, ID_PLCOPENEDITOREDITORTOOLBARBLOCK,

   153

 ID_PLCOPENEDITOREDITORTOOLBARCONNECTION, ID_PLCOPENEDITOREDITORTOOLBARWIRE,

   154

 ID_PLCOPENEDITOREDITORTOOLBARPOWERRAIL, ID_PLCOPENEDITOREDITORTOOLBARRUNG,

   155

 ID_PLCOPENEDITOREDITORTOOLBARCOIL, ID_PLCOPENEDITOREDITORTOOLBARCONTACT,

   156

 ID_PLCOPENEDITOREDITORTOOLBARBRANCH, ID_PLCOPENEDITOREDITORTOOLBARINITIALSTEP,

   157

 ID_PLCOPENEDITOREDITORTOOLBARSTEP, ID_PLCOPENEDITOREDITORTOOLBARTRANSITION,

   158

 ID_PLCOPENEDITOREDITORTOOLBARACTIONBLOCK, ID_PLCOPENEDITOREDITORTOOLBARDIVERGENCE,

   159

 ID_PLCOPENEDITOREDITORTOOLBARJUMP, ID_PLCOPENEDITOREDITORTOOLBARMOTION, 

   160

] = [wx.NewId() for _init_coll_DefaultEditorToolBar_Items in range(18)]

   161

   162

# Define behaviour of each Toolbar item according to current POU body type 

   163

# Informations meaning are in this order:

   164

#  - Item is toggled

   165

#  - PLCOpenEditor mode where item is displayed (could be more then one)

   166

#  - Item id

   167

#  - Item callback function name

   168

#  - Item icon filename

   169

#  - Item tooltip text

   170

EditorToolBarItems = {

   171

    "FBD" : [(True, FREEDRAWING_MODE|DRIVENDRAWING_MODE,

   172

              ID_PLCOPENEDITOREDITORTOOLBARMOTION, "OnMotionTool",

   173

              "move.png", _("Move the view")),

   174

             (True, FREEDRAWING_MODE|DRIVENDRAWING_MODE,

   175

              ID_PLCOPENEDITOREDITORTOOLBARCOMMENT, "OnCommentTool",

   176

              "add_comment.png", _("Create a new comment")),

   177

             (True, FREEDRAWING_MODE|DRIVENDRAWING_MODE,

   178

              ID_PLCOPENEDITOREDITORTOOLBARVARIABLE, "OnVariableTool",

   179

              "add_variable.png", _("Create a new variable")),

   180

             (True, FREEDRAWING_MODE|DRIVENDRAWING_MODE,

   181

              ID_PLCOPENEDITOREDITORTOOLBARBLOCK, "OnBlockTool",

   182

              "add_block.png", _("Create a new block")),

   183

             (True, FREEDRAWING_MODE|DRIVENDRAWING_MODE, 

   184

              ID_PLCOPENEDITOREDITORTOOLBARCONNECTION, "OnConnectionTool", 

   185

              "add_connection.png", _("Create a new connection"))],

   186

    "LD"  : [(True, FREEDRAWING_MODE|DRIVENDRAWING_MODE,

   187

              ID_PLCOPENEDITOREDITORTOOLBARMOTION, "OnMotionTool",

   188

              "move.png", _("Move the view")),

   189

             (True, FREEDRAWING_MODE, 

   190

              ID_PLCOPENEDITOREDITORTOOLBARCOMMENT, "OnCommentTool", 

   191

              "add_comment.png", _("Create a new comment")),

   192

             (True, FREEDRAWING_MODE, 

   193

              ID_PLCOPENEDITOREDITORTOOLBARPOWERRAIL, "OnPowerRailTool", 

   194

              "add_powerrail.png", _("Create a new power rail")),

   195

             (False, DRIVENDRAWING_MODE, 

   196

              ID_PLCOPENEDITOREDITORTOOLBARRUNG, "OnRungTool", 

   197

              "add_rung.png", _("Create a new rung")),

   198

             (True, FREEDRAWING_MODE, 

   199

              ID_PLCOPENEDITOREDITORTOOLBARCOIL, "OnCoilTool", 

   200

              "add_coil.png", _("Create a new coil")),

   201

             (False, FREEDRAWING_MODE|DRIVENDRAWING_MODE, 

   202

              ID_PLCOPENEDITOREDITORTOOLBARCONTACT, "OnContactTool", 

   203

              "add_contact.png", _("Create a new contact")),

   204

             (False, DRIVENDRAWING_MODE, 

   205

              ID_PLCOPENEDITOREDITORTOOLBARBRANCH, "OnBranchTool", 

   206

              "add_branch.png", _("Create a new branch")),

   207

             (True, FREEDRAWING_MODE, 

   208

              ID_PLCOPENEDITOREDITORTOOLBARVARIABLE, "OnVariableTool", 

   209

              "add_variable.png", _("Create a new variable")),

   210

             (False, FREEDRAWING_MODE|DRIVENDRAWING_MODE, 

   211

              ID_PLCOPENEDITOREDITORTOOLBARBLOCK, "OnBlockTool", 

   212

              "add_block.png", _("Create a new block")),

   213

             (True, FREEDRAWING_MODE, 

   214

              ID_PLCOPENEDITOREDITORTOOLBARCONNECTION, "OnConnectionTool", 

   215

              "add_connection.png", _("Create a new connection"))],

   216

    "SFC" : [(True, FREEDRAWING_MODE|DRIVENDRAWING_MODE,

   217

              ID_PLCOPENEDITOREDITORTOOLBARMOTION, "OnMotionTool",

   218

              "move.png", _("Move the view")),

   219

             (True, FREEDRAWING_MODE|DRIVENDRAWING_MODE, 

   220

              ID_PLCOPENEDITOREDITORTOOLBARCOMMENT, "OnCommentTool", 

   221

              "add_comment.png", _("Create a new comment")),

   222

             (True, FREEDRAWING_MODE|DRIVENDRAWING_MODE, 

   223

              ID_PLCOPENEDITOREDITORTOOLBARINITIALSTEP, "OnInitialStepTool", 

   224

              "add_initial_step.png", _("Create a new initial step")),

   225

             (False, FREEDRAWING_MODE|DRIVENDRAWING_MODE, 

   226

              ID_PLCOPENEDITOREDITORTOOLBARSTEP, "OnStepTool", 

   227

              "add_step.png", _("Create a new step")),

   228

             (True, FREEDRAWING_MODE, 

   229

              ID_PLCOPENEDITOREDITORTOOLBARTRANSITION, "OnTransitionTool", 

   230

              "add_transition.png", _("Create a new transition")),

   231

             (False, FREEDRAWING_MODE|DRIVENDRAWING_MODE, 

   232

              ID_PLCOPENEDITOREDITORTOOLBARACTIONBLOCK, "OnActionBlockTool", 

   233

              "add_action.png", _("Create a new action block")),

   234

             (False, FREEDRAWING_MODE|DRIVENDRAWING_MODE, 

   235

              ID_PLCOPENEDITOREDITORTOOLBARDIVERGENCE, "OnDivergenceTool", 

   236

              "add_divergence.png", _("Create a new divergence")),

   237

             (False, FREEDRAWING_MODE|DRIVENDRAWING_MODE, 

   238

              ID_PLCOPENEDITOREDITORTOOLBARJUMP, "OnJumpTool", 

   239

              "add_jump.png", _("Create a new jump")),

   240

             (True, FREEDRAWING_MODE, 

   241

              ID_PLCOPENEDITOREDITORTOOLBARVARIABLE, "OnVariableTool", 

   242

              "add_variable.png", _("Create a new variable")),

   243

             (True, FREEDRAWING_MODE, 

   244

              ID_PLCOPENEDITOREDITORTOOLBARBLOCK, "OnBlockTool", 

   245

              "add_block.png", _("Create a new block")),

   246

             (True, FREEDRAWING_MODE, 

   247

              ID_PLCOPENEDITOREDITORTOOLBARCONNECTION, "OnConnectionTool", 

   248

              "add_connection.png", _("Create a new connection")),

   249

             (True, FREEDRAWING_MODE, 

   250

              ID_PLCOPENEDITOREDITORTOOLBARPOWERRAIL, "OnPowerRailTool", 

   251

              "add_powerrail.png", _("Create a new power rail")),

   252

             (True, FREEDRAWING_MODE, 

   253

              ID_PLCOPENEDITOREDITORTOOLBARCONTACT, "OnContactTool", 

   254

              "add_contact.png", _("Create a new contact"))],

   255

    "ST"  : [],

   256

    "IL"  : [],

   257

    "debug": [(True, FREEDRAWING_MODE|DRIVENDRAWING_MODE,

   258

              ID_PLCOPENEDITOREDITORTOOLBARMOTION, "OnMotionTool",

   259

              "move.png", _("Move the view"))],

   260

}

   261

   262

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

   263

#                               Helper Functions

   264

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

   265

   266

# Compatibility function for wx versions < 2.6

   267

def AppendMenu(parent, help, id, kind, text):

   268

    if wx.VERSION >= (2, 6, 0):

   269

        parent.Append(help=help, id=id, kind=kind, text=text)

   270

    else:

   271

        parent.Append(helpString=help, id=id, kind=kind, item=text)

   272

   275

] = range(10)

   276

   277

def GetShortcutKeyCallbackFunction(viewer_function):

   278

    def ShortcutKeyFunction(self, event):

   279

        control = self.FindFocus()

   280

        if control is not None and control.GetName() in ["Viewer", "TextViewer"]:

   281

            getattr(control.Parent, viewer_function)()

   282

        elif isinstance(control, wx.stc.StyledTextCtrl):

   283

            getattr(control, viewer_function)()

   284

        elif isinstance(control, wx.TextCtrl):

   285

            control.ProcessEvent(event)

   286

    return ShortcutKeyFunction

   287

   288

def GetParentName(tree, item, parent_type):

   289

    parent_item = tree.GetItemParent(item)

   290

    parent_item_type = tree.GetPyData(parent_item)

   291

    while parent_item_type != parent_type:

   292

        parent_item = tree.GetItemParent(parent_item)

   293

        parent_item_type = tree.GetPyData(parent_item)

   294

    return tree.GetItemText(parent_item)

   295

   296

def GetDeleteElementFunction(remove_function, parent_type=None, check_function=None):

   297

    def DeleteElementFunction(self, selected):

   299

        if check_function is None or not check_function(self.Controler, name):

   300

            if parent_type is not None:

   302

                remove_function(self.Controler, parent_name, name)

   303

            else:

   304

                remove_function(self.Controler, name)

   305

        else:

   306

            self.ShowErrorMessage(_("\"%s\" is used by one or more POUs. It can't be removed!")%name)

   307

    return DeleteElementFunction

   308

   309

if wx.Platform == '__WXMSW__':

   310

    TAB_BORDER = 6

   311

    NOTEBOOK_BORDER = 6

   312

else:

   313

    TAB_BORDER = 7

   314

    NOTEBOOK_BORDER = 2

   315

   316

def SimplifyTabOrganization(tabs, rect):

   317

    for tab in tabs:

   318

        if tab["pos"][0] == rect.x:

   319

            others = [t for t in tabs if t != tab]

   320

            others.sort(lambda x,y: cmp(x["pos"][0], y["pos"][0]))

   321

            for other in others:

   322

                if (other["pos"][1] == tab["pos"][1] and 

   323

                    other["size"][1] == tab["size"][1] and

   324

                    other["pos"][0] == tab["pos"][0] + tab["size"][0] + TAB_BORDER):

   325

   326

                    tab["size"] = (tab["size"][0] + other["size"][0] + TAB_BORDER, tab["size"][1])

   327

                    tab["pages"].extend(other["pages"])

   328

                    tabs.remove(other)

   329

   330

                    if tab["size"][0] == rect.width:

   331

                        return True

   332

   333

        elif tab["pos"][1] == rect.y:

   334

            others = [t for t in tabs if t != tab]

   335

            others.sort(lambda x,y: cmp(x["pos"][1], y["pos"][1]))

   336

            for other in others:

   337

                if (other["pos"][0] == tab["pos"][0] and 

   338

                    other["size"][0] == tab["size"][0] and

   339

                    other["pos"][1] == tab["pos"][1] + tab["size"][1] + TAB_BORDER):

   340

   341

                    tab["size"] = (tab["size"][0], tab["size"][1] + other["size"][1] + TAB_BORDER)

   342

                    tab["pages"].extend(other["pages"])

   343

                    tabs.remove(other)

   344

   345

                    if tab["size"][1] == rect.height:

   346

                        return True

   347

    return False

   348

   349

def ComputeTabsOrganization(tabs, rect):

   350

    if len(tabs) == 0:

   351

        return tabs

   352

    if len(tabs) == 1:

   353

        return tabs[0]

   354

    split = None

   355

    for idx, tab in enumerate(tabs):

   356

        if len(tab["pages"]) == 0:

   357

        	raise "Not possible"

   358

        if tab["size"][0] == rect.width:

   359

            if tab["pos"][1] == rect.y:

   360

                split = (wx.TOP, float(tab["size"][1]) / float(rect.height))

   361

                split_rect = wx.Rect(rect.x, rect.y + tab["size"][1] + TAB_BORDER, 

   362

                                     rect.width, rect.height - tab["size"][1] - TAB_BORDER)

   363

            elif tab["pos"][1] == rect.height + 1 - tab["size"][1]:

   364

                split = (wx.BOTTOM, 1.0 - float(tab["size"][1]) / float(rect.height))

   365

                split_rect = wx.Rect(rect.x, rect.y, 

   366

                                     rect.width, rect.height - tab["size"][1] - TAB_BORDER)

   367

            break

   368

        elif tab["size"][1] == rect.height:

   369

            if tab["pos"][0] == rect.x:

   370

                split = (wx.LEFT, float(tab["size"][0]) / float(rect.width))

   371

                split_rect = wx.Rect(rect.x + tab["size"][0] + TAB_BORDER, rect.y, 

   372

                                     rect.width - tab["size"][0] - TAB_BORDER, rect.height)

   373

            elif tab["pos"][0] == rect.width + 1 - tab["size"][0]:

   374

                split = (wx.RIGHT, 1.0 - float(tab["size"][0]) / float(rect.width))

   375

                split_rect = wx.Rect(rect.x, rect.y, 

   376

                                     rect.width - tab["size"][0] - TAB_BORDER, rect.height)

   377

            break

   378

    if split != None:

   379

        split_tab = tabs.pop(idx)

   380

        return {"split": split,

   381

                "tab": split_tab, 

   382

                "others": ComputeTabsOrganization(tabs, split_rect)}

   383

    else:

   384

        if SimplifyTabOrganization(tabs, rect):

   385

            return ComputeTabsOrganization(tabs, rect)

   386

    return tabs

   387

   388

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

   389

#                              IDEFrame Base Class

   390

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

   391

   392

UNEDITABLE_NAMES_DICT = dict([(_(name), name) for name in UNEDITABLE_NAMES])

   393

   394

class IDEFrame(wx.Frame):

   395

   396

    Starting = False

   397

   398

    # Compatibility function for wx versions < 2.6

   399

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

   400

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

   401

            if id is not None:

   402

                event(self, id, function)

   403

            else:

   404

                event(self, function)

   405

   406

    def _init_coll_MenuBar_Menus(self, parent):

   407

        parent.Append(menu=self.FileMenu, title=_(u'&File'))

   408

        parent.Append(menu=self.EditMenu, title=_(u'&Edit'))

   409

        parent.Append(menu=self.DisplayMenu, title=_(u'&Display'))

   410

        parent.Append(menu=self.HelpMenu, title=_(u'&Help'))

   411

   412

    def _init_coll_FileMenu_Items(self, parent):

   413

        pass

   414

   427

    def _init_coll_EditMenu_Items(self, parent):

   428

        AppendMenu(parent, help='', id=wx.ID_UNDO,

   429

              kind=wx.ITEM_NORMAL, text=_(u'Undo\tCTRL+Z'))

   430

        AppendMenu(parent, help='', id=wx.ID_REDO,

   431

              kind=wx.ITEM_NORMAL, text=_(u'Redo\tCTRL+Y'))

   432

        #AppendMenu(parent, help='', id=ID_PLCOPENEDITOREDITMENUENABLEUNDOREDO,

   433

        #      kind=wx.ITEM_CHECK, text=_(u'Enable Undo/Redo'))

   434

        enable_undo_redo = _(u'Enable Undo/Redo') # Keeping text in translations for possible menu reactivation

   435

        parent.AppendSeparator()

   436

        AppendMenu(parent, help='', id=wx.ID_CUT,

   437

              kind=wx.ITEM_NORMAL, text=_(u'Cut\tCTRL+X'))

   438

        AppendMenu(parent, help='', id=wx.ID_COPY,

   439

              kind=wx.ITEM_NORMAL, text=_(u'Copy\tCTRL+C'))

   440

        AppendMenu(parent, help='', id=wx.ID_PASTE,

   441

              kind=wx.ITEM_NORMAL, text=_(u'Paste\tCTRL+V'))

   442

        parent.AppendSeparator()

   443

        AppendMenu(parent, help='', id=ID_PLCOPENEDITOREDITMENUSEARCHINPROJECT,

   444

              kind=wx.ITEM_NORMAL, text=_(u'Search in Project\tCTRL+F'))

   445

        parent.AppendSeparator()

   449

        AppendMenu(parent, help='', id=wx.ID_SELECTALL,

   450

              kind=wx.ITEM_NORMAL, text=_(u'Select All\tCTRL+A'))

   451

        AppendMenu(parent, help='', id=wx.ID_DELETE,

   452

              kind=wx.ITEM_NORMAL, text=_(u'&Delete'))

   453

        self.Bind(wx.EVT_MENU, self.OnUndoMenu, id=wx.ID_UNDO)

   454

        self.Bind(wx.EVT_MENU, self.OnRedoMenu, id=wx.ID_REDO)

   455

        #self.Bind(wx.EVT_MENU, self.OnEnableUndoRedoMenu, id=ID_PLCOPENEDITOREDITMENUENABLEUNDOREDO)

   456

        self.Bind(wx.EVT_MENU, self.OnCutMenu, id=wx.ID_CUT)

   457

        self.Bind(wx.EVT_MENU, self.OnCopyMenu, id=wx.ID_COPY)

   458

        self.Bind(wx.EVT_MENU, self.OnPasteMenu, id=wx.ID_PASTE)

   459

        self.Bind(wx.EVT_MENU, self.OnSearchInProjectMenu, 

   460

              id=ID_PLCOPENEDITOREDITMENUSEARCHINPROJECT)

   461

        self.Bind(wx.EVT_MENU, self.OnAddDataTypeMenu,

   462

              id=ID_PLCOPENEDITOREDITMENUADDDATATYPE)

   463

        self.Bind(wx.EVT_MENU, self.GenerateAddPouFunction("function"),

   464

              id=ID_PLCOPENEDITOREDITMENUADDFUNCTION)

   465

        self.Bind(wx.EVT_MENU, self.GenerateAddPouFunction("functionBlock"),

   466

              id=ID_PLCOPENEDITOREDITMENUADDFUNCTIONBLOCK)

   467

        self.Bind(wx.EVT_MENU, self.GenerateAddPouFunction("program"),

   468

              id=ID_PLCOPENEDITOREDITMENUADDPROGRAM)

   469

        self.Bind(wx.EVT_MENU, self.OnAddConfigurationMenu,

   470

              id=ID_PLCOPENEDITOREDITMENUADDCONFIGURATION)

   471

        self.Bind(wx.EVT_MENU, self.OnSelectAllMenu, id=wx.ID_SELECTALL)

   472

        self.Bind(wx.EVT_MENU, self.OnDeleteMenu, id=wx.ID_DELETE)

   473

   474

        self.AddToMenuToolBar([(wx.ID_UNDO, "undo.png", _(u'Undo'), None),

   475

                               (wx.ID_REDO, "redo.png", _(u'Redo'), None),

   476

                               None,

   477

                               (wx.ID_CUT, "cut.png", _(u'Cut'), None),

   478

                               (wx.ID_COPY, "copy.png", _(u'Copy'), None),

   479

                               (wx.ID_PASTE, "paste.png", _(u'Paste'), None),

   480

                               None,

   481

                               (ID_PLCOPENEDITOREDITMENUSEARCHINPROJECT, "find.png", _(u'Search in Project'), None)])

   482

   483

    def _init_coll_DisplayMenu_Items(self, parent):

   484

        AppendMenu(parent, help='', id=wx.ID_REFRESH,