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

import wx.aui

    28

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

    29

import cPickle

    30

    31

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

    32

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

    33

sys.path.append(base_folder)

    34

from docutil import *

    35

    36

from types import TupleType

    37

    38

__version__ = "$Revision: 1.130 $"

    39

    40

if __name__ == '__main__':

    41

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

    42

    # command line

    43

    def usage():

    44

        print "\nUsage of PLCOpenEditor.py :"

    45

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

    46

    47

    # Parse options given to PLCOpenEditor in command line

    48

    try:

    49

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

    50

    except getopt.GetoptError:

    51

        # print help information and exit:

    52

        usage()

    53

        sys.exit(2)

    54

    55

    # Extract if help has been requested

    56

    for o, a in opts:

    57

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

    58

            usage()

    59

            sys.exit()

    60

    61

    # Extract the optional filename to open

    62

    fileOpen = None

    63

    if len(args) > 1:

    64

        usage()

    65

        sys.exit()

    66

    elif len(args) == 1:

    67

        fileOpen = args[0]

    68

    69

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

    70

    # Windows) 

    71

    app = wx.PySimpleApp()

    72

    73

# Import module for internationalization

    74

import gettext

    75

import __builtin__

    76

    77

# Get folder containing translation files

    78

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

    79

# Get the default language

    80

langid = wx.LANGUAGE_DEFAULT

    81

# Define translation domain (name of translation files)

    82

domain = "PLCOpenEditor"

    83

    84

# Define locale for wx

    85

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

    86

if loc is None:

    87

    test_loc = wx.Locale(langid)

    88

    test_loc.AddCatalogLookupPathPrefix(localedir)

    89

    if test_loc.AddCatalog(domain):

    90

        loc = wx.Locale(langid)

    91

    else:

    92

        loc = wx.Locale(wx.LANGUAGE_ENGLISH)

    93

    __builtin__.__dict__['loc'] = loc

    94

# Define location for searching translation files

    95

loc.AddCatalogLookupPathPrefix(localedir)

    96

# Define locale domain

    97

loc.AddCatalog(domain)

    98

    99

if __name__ == '__main__':

   100

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

   101

   102

from SFCViewer import *

   103

from LDViewer import *

   104

from Viewer import *

   105

from TextViewer import *

   106

from GraphicViewer import *

   107

from RessourceEditor import *

   108

from DataTypeEditor import *

   109

from PLCControler import *

   110

from SearchResultPanel import SearchResultPanel

   111

from controls import CustomGrid, CustomTable, CustomTree, LibraryPanel, PouInstanceVariablesPanel

   113

   114

# Define PLCOpenEditor controls id

   115

[ID_PLCOPENEDITOR, ID_PLCOPENEDITORLEFTNOTEBOOK, 

   116

 ID_PLCOPENEDITORBOTTOMNOTEBOOK, ID_PLCOPENEDITORRIGHTNOTEBOOK, 

   117

 ID_PLCOPENEDITORPROJECTTREE, ID_PLCOPENEDITORMAINSPLITTER, 

   118

 ID_PLCOPENEDITORSECONDSPLITTER, ID_PLCOPENEDITORTHIRDSPLITTER, 

   119

 ID_PLCOPENEDITORLIBRARYPANEL, ID_PLCOPENEDITORLIBRARYSEARCHCTRL, 

   120

 ID_PLCOPENEDITORLIBRARYTREE, ID_PLCOPENEDITORLIBRARYCOMMENT, 

   121

 ID_PLCOPENEDITORTABSOPENED, ID_PLCOPENEDITORTABSOPENED, 

   122

 ID_PLCOPENEDITOREDITORMENUTOOLBAR, ID_PLCOPENEDITOREDITORTOOLBAR, 

   123

 ID_PLCOPENEDITORPROJECTPANEL, 

   124

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

   125

   126

# Define PLCOpenEditor FileMenu extra items id

   127

[ID_PLCOPENEDITORFILEMENUGENERATE, 

   128

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

   129

   130

# Define PLCOpenEditor EditMenu extra items id

   131

[ID_PLCOPENEDITOREDITMENUENABLEUNDOREDO, ID_PLCOPENEDITOREDITMENUADDDATATYPE, 

   132

 ID_PLCOPENEDITOREDITMENUADDFUNCTION, ID_PLCOPENEDITOREDITMENUADDFUNCTIONBLOCK, 

   133

 ID_PLCOPENEDITOREDITMENUADDPROGRAM, ID_PLCOPENEDITOREDITMENUADDCONFIGURATION,

   134

 ID_PLCOPENEDITOREDITMENUSEARCHINPROJECT, 

   135

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

   136

   137

# Define PLCOpenEditor DisplayMenu extra items id

   138

[ID_PLCOPENEDITORDISPLAYMENURESETPERSPECTIVE, 

   139

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

   140

   141

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

   142

#                            EditorToolBar definitions

   143

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

   144

   145

# Define PLCOpenEditor Toolbar items id

   146

[ID_PLCOPENEDITOREDITORTOOLBARSELECTION, ID_PLCOPENEDITOREDITORTOOLBARCOMMENT,

   147

 ID_PLCOPENEDITOREDITORTOOLBARVARIABLE, ID_PLCOPENEDITOREDITORTOOLBARBLOCK,

   148

 ID_PLCOPENEDITOREDITORTOOLBARCONNECTION, ID_PLCOPENEDITOREDITORTOOLBARWIRE,

   149

 ID_PLCOPENEDITOREDITORTOOLBARPOWERRAIL, ID_PLCOPENEDITOREDITORTOOLBARRUNG,

   150

 ID_PLCOPENEDITOREDITORTOOLBARCOIL, ID_PLCOPENEDITOREDITORTOOLBARCONTACT,

   151

 ID_PLCOPENEDITOREDITORTOOLBARBRANCH, ID_PLCOPENEDITOREDITORTOOLBARINITIALSTEP,

   152

 ID_PLCOPENEDITOREDITORTOOLBARSTEP, ID_PLCOPENEDITOREDITORTOOLBARTRANSITION,

   153

 ID_PLCOPENEDITOREDITORTOOLBARACTIONBLOCK, ID_PLCOPENEDITOREDITORTOOLBARDIVERGENCE,

   154

 ID_PLCOPENEDITOREDITORTOOLBARJUMP, ID_PLCOPENEDITOREDITORTOOLBARMOTION, 

   155

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

   156

   157

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

   158

# Informations meaning are in this order:

   159

#  - Item is toggled

   160

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

   161

#  - Item id

   162

#  - Item callback function name

   163

#  - Item icon filename

   164

#  - Item tooltip text

   165

EditorToolBarItems = {

   166

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

   167

              ID_PLCOPENEDITOREDITORTOOLBARMOTION, "OnMotionTool",

   168

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

   169

             (True, FREEDRAWING_MODE|DRIVENDRAWING_MODE,

   170

              ID_PLCOPENEDITOREDITORTOOLBARCOMMENT, "OnCommentTool",

   171

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

   172

             (True, FREEDRAWING_MODE|DRIVENDRAWING_MODE,

   173

              ID_PLCOPENEDITOREDITORTOOLBARVARIABLE, "OnVariableTool",

   174

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

   175

             (True, FREEDRAWING_MODE|DRIVENDRAWING_MODE,

   176

              ID_PLCOPENEDITOREDITORTOOLBARBLOCK, "OnBlockTool",

   177

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

   178

             (True, FREEDRAWING_MODE|DRIVENDRAWING_MODE, 

   179

              ID_PLCOPENEDITOREDITORTOOLBARCONNECTION, "OnConnectionTool", 

   180

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

   181

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

   182

              ID_PLCOPENEDITOREDITORTOOLBARMOTION, "OnMotionTool",

   183

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

   184

             (True, FREEDRAWING_MODE, 

   185

              ID_PLCOPENEDITOREDITORTOOLBARCOMMENT, "OnCommentTool", 

   186

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

   187

             (True, FREEDRAWING_MODE, 

   188

              ID_PLCOPENEDITOREDITORTOOLBARPOWERRAIL, "OnPowerRailTool", 

   189

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

   190

             (False, DRIVENDRAWING_MODE, 

   191

              ID_PLCOPENEDITOREDITORTOOLBARRUNG, "OnRungTool", 

   192

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

   193

             (True, FREEDRAWING_MODE, 

   194

              ID_PLCOPENEDITOREDITORTOOLBARCOIL, "OnCoilTool", 

   195

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

   196

             (False, FREEDRAWING_MODE|DRIVENDRAWING_MODE, 

   197

              ID_PLCOPENEDITOREDITORTOOLBARCONTACT, "OnContactTool", 

   198

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

   199

             (False, DRIVENDRAWING_MODE, 

   200

              ID_PLCOPENEDITOREDITORTOOLBARBRANCH, "OnBranchTool", 

   201

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

   202

             (True, FREEDRAWING_MODE, 

   203

              ID_PLCOPENEDITOREDITORTOOLBARVARIABLE, "OnVariableTool", 

   204

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

   205

             (False, FREEDRAWING_MODE|DRIVENDRAWING_MODE, 

   206

              ID_PLCOPENEDITOREDITORTOOLBARBLOCK, "OnBlockTool", 

   207

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

   208

             (True, FREEDRAWING_MODE, 

   209

              ID_PLCOPENEDITOREDITORTOOLBARCONNECTION, "OnConnectionTool", 

   210

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

   211

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

   212

              ID_PLCOPENEDITOREDITORTOOLBARMOTION, "OnMotionTool",

   213

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

   214

             (True, FREEDRAWING_MODE|DRIVENDRAWING_MODE, 

   215

              ID_PLCOPENEDITOREDITORTOOLBARCOMMENT, "OnCommentTool", 

   216

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

   217

             (True, FREEDRAWING_MODE|DRIVENDRAWING_MODE, 

   218

              ID_PLCOPENEDITOREDITORTOOLBARINITIALSTEP, "OnInitialStepTool", 

   219

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

   220

             (False, FREEDRAWING_MODE|DRIVENDRAWING_MODE, 

   221

              ID_PLCOPENEDITOREDITORTOOLBARSTEP, "OnStepTool", 

   222

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

   223

             (True, FREEDRAWING_MODE, 

   224

              ID_PLCOPENEDITOREDITORTOOLBARTRANSITION, "OnTransitionTool", 

   225

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

   226

             (False, FREEDRAWING_MODE|DRIVENDRAWING_MODE, 

   227

              ID_PLCOPENEDITOREDITORTOOLBARACTIONBLOCK, "OnActionBlockTool", 

   228

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

   229

             (False, FREEDRAWING_MODE|DRIVENDRAWING_MODE, 

   230

              ID_PLCOPENEDITOREDITORTOOLBARDIVERGENCE, "OnDivergenceTool", 

   231

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

   232

             (False, FREEDRAWING_MODE|DRIVENDRAWING_MODE, 

   233

              ID_PLCOPENEDITOREDITORTOOLBARJUMP, "OnJumpTool", 

   234

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

   235

             (True, FREEDRAWING_MODE, 

   236

              ID_PLCOPENEDITOREDITORTOOLBARVARIABLE, "OnVariableTool", 

   237

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

   238

             (True, FREEDRAWING_MODE, 

   239

              ID_PLCOPENEDITOREDITORTOOLBARBLOCK, "OnBlockTool", 

   240

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

   241

             (True, FREEDRAWING_MODE, 

   242

              ID_PLCOPENEDITOREDITORTOOLBARCONNECTION, "OnConnectionTool", 

   243

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

   244

             (True, FREEDRAWING_MODE, 

   245

              ID_PLCOPENEDITOREDITORTOOLBARPOWERRAIL, "OnPowerRailTool", 

   246

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

   247

             (True, FREEDRAWING_MODE, 

   248

              ID_PLCOPENEDITOREDITORTOOLBARCONTACT, "OnContactTool", 

   249

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

   250

    "ST"  : [],

   251

    "IL"  : [],

   252

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

   253

              ID_PLCOPENEDITOREDITORTOOLBARMOTION, "OnMotionTool",

   254

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

   255

}

   256

   257

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

   258

#                               Helper Functions

   259

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

   260

   261

# Compatibility function for wx versions < 2.6

   262

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

   263

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

   264

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

   265

    else:

   266

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

   267

   268

[TITLE, EDITORTOOLBAR, FILEMENU, EDITMENU, DISPLAYMENU, PROJECTTREE, 

   269

 POUINSTANCEVARIABLESPANEL, LIBRARYTREE, SCALING, PAGETITLES

   270

] = range(10)

   271

   272

def GetShortcutKeyCallbackFunction(viewer_function):

   273

    def ShortcutKeyFunction(self, event):

   274

        control = self.FindFocus()

   275

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

   276

            getattr(control.ParentWindow, viewer_function)()

   277

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

   278

            getattr(control, viewer_function)()

   279

        elif isinstance(control, wx.TextCtrl):

   280

            control.ProcessEvent(event)

   281

    return ShortcutKeyFunction

   282

   283

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

   284

    def DeleteElementFunction(self, selected):

   285

        name = self.ProjectTree.GetItemText(selected)

   286

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

   287

            if parent_type is not None:

   288

                item_infos = self.ProjectTree.GetPyData(selected)

   289

                parent_name = item_infos["tagname"].split("::")[1]

   290

                remove_function(self.Controler, parent_name, name)

   291

            else:

   292

                remove_function(self.Controler, name)

   293

        else:

   294

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

   295

    return DeleteElementFunction

   296

   297

if wx.Platform == '__WXMSW__':

   298

    TAB_BORDER = 6

   299

    NOTEBOOK_BORDER = 6

   300

else:

   301

    TAB_BORDER = 7

   302

    NOTEBOOK_BORDER = 2

   303

   304

def SimplifyTabLayout(tabs, rect):

   305

    for tab in tabs:

   306

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

   307

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

   308

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

   309

            for other in others:

   310

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

   311

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

   312

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

   313

   314

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

   315

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

   316

                    tabs.remove(other)

   317

   318

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

   319

                        return True

   320

   321

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

   322

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

   323

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

   324

            for other in others:

   325

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

   326

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

   327

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

   328

   329

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

   330

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

   331

                    tabs.remove(other)

   332

   333

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

   334

                        return True

   335

    return False

   336

   337

def ComputeTabsLayout(tabs, rect):

   338

    if len(tabs) == 0:

   339

        return tabs

   340

    if len(tabs) == 1:

   341

        return tabs[0]

   342

    split = None

   343

    for idx, tab in enumerate(tabs):

   344

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

   345

        	raise "Not possible"

   346

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

   347

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

   348

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

   349

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

   350

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

   351

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

   352

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

   353

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

   354

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

   355

            break

   356

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

   357

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

   358

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

   359

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

   360

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

   361

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

   362

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

   363

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

   364

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

   365

            break

   366

    if split != None:

   367

        split_tab = tabs.pop(idx)

   368

        return {"split": split,

   369

                "tab": split_tab, 

   370

                "others": ComputeTabsLayout(tabs, split_rect)}

   371

    else:

   372

        if SimplifyTabLayout(tabs, rect):

   373

            return ComputeTabsLayout(tabs, rect)

   374

    return tabs

   375

   376

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

   377

#                              IDEFrame Base Class

   378

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

   379

   380

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

   381

   382

class IDEFrame(wx.Frame):

   383

   384

    Starting = False

   385

   386

    # Compatibility function for wx versions < 2.6

   387

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

   388

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

   389

            if id is not None:

   390

                event(self, id, function)

   391

            else:

   392

                event(self, function)

   393

   394

    def _init_coll_MenuBar_Menus(self, parent):

   395

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

   396

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

   397

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

   398

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

   399

   400

    def _init_coll_FileMenu_Items(self, parent):

   401

        pass

   402

   403

    def _init_coll_AddMenu_Items(self, parent, add_config=True):

   404

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

   405

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

   406

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

   407

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

   408

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

   409

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

   410

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

   411

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

   412

        if add_config:

   413

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

   414

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

   415

   416

    def _init_coll_EditMenu_Items(self, parent):

   417

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

   418

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

   419

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

   420

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

   421

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

   422

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

   423

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

   424

        parent.AppendSeparator()

   425

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

   426

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

   427

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

   428

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

   429

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

   430

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

   431

        parent.AppendSeparator()

   432

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

   433

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

   434

        parent.AppendSeparator()

   435

        add_menu = wx.Menu(title='')

   436

        self._init_coll_AddMenu_Items(add_menu)

   437

        parent.AppendMenu(wx.ID_ADD, _(u"&Add Element"), add_menu)

   438

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

   439

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

   440

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

   441

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

   442

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

   443

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

   444

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

   445

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

   446

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

   447

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

   448

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

   449

              id=ID_PLCOPENEDITOREDITMENUSEARCHINPROJECT)

   450

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

   451

              id=ID_PLCOPENEDITOREDITMENUADDDATATYPE)

   452

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

   453

              id=ID_PLCOPENEDITOREDITMENUADDFUNCTION)

   454

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

   455

              id=ID_PLCOPENEDITOREDITMENUADDFUNCTIONBLOCK)

   456

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

   457

              id=ID_PLCOPENEDITOREDITMENUADDPROGRAM)

   458

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

   459

              id=ID_PLCOPENEDITOREDITMENUADDCONFIGURATION)

   460

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

   461

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

   462

   463

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

   464

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

   465

                               None,

   466

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

   467

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

   468

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

   469

                               None,

   470

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

   471

   472

    def _init_coll_DisplayMenu_Items(self, parent):

   473

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

   474

              kind=wx.ITEM_NORMAL, text=_(u'Refresh\tCTRL+R'))

   475

        if self.EnableDebug:

   476

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

   477

                  kind=wx.ITEM_NORMAL, text=_(u'Clear Errors\tCTRL+K'))

   478

        parent.AppendSeparator()

   479

        zoommenu = wx.Menu(title='')

   480

        parent.AppendMenu(wx.ID_ZOOM_FIT, _("Zoom"), zoommenu)

   481

        for idx, value in enumerate(ZOOM_FACTORS):

   482

            new_id = wx.NewId()

   483

            AppendMenu(zoommenu, help='', id=new_id,