1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

# This file is part of Beremiz, a Integrated Development Environment for

     5

# programming IEC 61131-3 automates supporting plcopen standard and CanFestival.

     6

#

     7

# Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD

     8

#

     9

# See COPYING file for copyrights details.

    10

#

    11

# This program is free software; you can redistribute it and/or

    12

# modify it under the terms of the GNU General Public License

    13

# as published by the Free Software Foundation; either version 2

    14

# of the License, or (at your option) any later version.

    15

#

    16

# This program 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

    19

# GNU General Public License for more details.

    20

#

    21

# You should have received a copy of the GNU General Public License

    22

# along with this program; if not, write to the Free Software

    23

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

    24

    25

import os

    26

import sys

    27

import cPickle

    28

from types import TupleType

    29

    30

import wx

    31

import wx.grid

    32

import wx.aui

    33

    34

from editors.EditorPanel import EditorPanel

    35

from editors.SFCViewer import SFC_Viewer

    36

from editors.LDViewer import LD_Viewer

    37

from editors.TextViewer import TextViewer

    38

from editors.Viewer import Viewer, ZOOM_FACTORS

    39

from editors.ResourceEditor import ConfigurationEditor, ResourceEditor

    40

from editors.DataTypeEditor import DataTypeEditor

    41

from PLCControler import *

    42

from controls import CustomTree, LibraryPanel, PouInstanceVariablesPanel, SearchResultPanel

    43

from controls.DebugVariablePanel import DebugVariablePanel

    44

from dialogs import ProjectDialog, PouDialog, PouTransitionDialog, PouActionDialog, FindInPouDialog, SearchInProjectDialog

    45

from util.BitmapLibrary import GetBitmap

    46

    47

# Define PLCOpenEditor controls id

    48

[ID_PLCOPENEDITOR, ID_PLCOPENEDITORLEFTNOTEBOOK,

    49

 ID_PLCOPENEDITORBOTTOMNOTEBOOK, ID_PLCOPENEDITORRIGHTNOTEBOOK,

    50

 ID_PLCOPENEDITORPROJECTTREE, ID_PLCOPENEDITORMAINSPLITTER,

    51

 ID_PLCOPENEDITORSECONDSPLITTER, ID_PLCOPENEDITORTHIRDSPLITTER,

    52

 ID_PLCOPENEDITORLIBRARYPANEL, ID_PLCOPENEDITORLIBRARYSEARCHCTRL,

    53

 ID_PLCOPENEDITORLIBRARYTREE, ID_PLCOPENEDITORLIBRARYCOMMENT,

    54

 ID_PLCOPENEDITORTABSOPENED, ID_PLCOPENEDITORTABSOPENED,

    55

 ID_PLCOPENEDITOREDITORMENUTOOLBAR, ID_PLCOPENEDITOREDITORTOOLBAR,

    56

 ID_PLCOPENEDITORPROJECTPANEL,

    57

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

    58

    59

# Define PLCOpenEditor EditMenu extra items id

    60

[ID_PLCOPENEDITOREDITMENUENABLEUNDOREDO, ID_PLCOPENEDITOREDITMENUADDDATATYPE,

    61

 ID_PLCOPENEDITOREDITMENUADDFUNCTION, ID_PLCOPENEDITOREDITMENUADDFUNCTIONBLOCK,

    62

 ID_PLCOPENEDITOREDITMENUADDPROGRAM, ID_PLCOPENEDITOREDITMENUADDCONFIGURATION,

    63

 ID_PLCOPENEDITOREDITMENUFINDNEXT, ID_PLCOPENEDITOREDITMENUFINDPREVIOUS,

    64

 ID_PLCOPENEDITOREDITMENUSEARCHINPROJECT, ID_PLCOPENEDITOREDITMENUADDRESOURCE

    65

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

    66

    67

# Define PLCOpenEditor DisplayMenu extra items id

    68

[ID_PLCOPENEDITORDISPLAYMENURESETPERSPECTIVE,

    69

 ID_PLCOPENEDITORDISPLAYMENUSWITCHPERSPECTIVE,

    70

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

    71

    72

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

    73

#                            EditorToolBar definitions

    74

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

    75

    76

# Define PLCOpenEditor Toolbar items id

    77

[ID_PLCOPENEDITOREDITORTOOLBARSELECTION, ID_PLCOPENEDITOREDITORTOOLBARCOMMENT,

    78

 ID_PLCOPENEDITOREDITORTOOLBARVARIABLE, ID_PLCOPENEDITOREDITORTOOLBARBLOCK,

    79

 ID_PLCOPENEDITOREDITORTOOLBARCONNECTION, ID_PLCOPENEDITOREDITORTOOLBARWIRE,

    80

 ID_PLCOPENEDITOREDITORTOOLBARPOWERRAIL, ID_PLCOPENEDITOREDITORTOOLBARRUNG,

    81

 ID_PLCOPENEDITOREDITORTOOLBARCOIL, ID_PLCOPENEDITOREDITORTOOLBARCONTACT,

    82

 ID_PLCOPENEDITOREDITORTOOLBARBRANCH, ID_PLCOPENEDITOREDITORTOOLBARINITIALSTEP,

    83

 ID_PLCOPENEDITOREDITORTOOLBARSTEP, ID_PLCOPENEDITOREDITORTOOLBARTRANSITION,

    84

 ID_PLCOPENEDITOREDITORTOOLBARACTIONBLOCK, ID_PLCOPENEDITOREDITORTOOLBARDIVERGENCE,

    85

 ID_PLCOPENEDITOREDITORTOOLBARJUMP, ID_PLCOPENEDITOREDITORTOOLBARMOTION,

    86

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

    87

    88

    89

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

    90

# Informations meaning are in this order:

    91

#  - Item is toggled

    92

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

    93

#  - Item id

    94

#  - Item callback function name

    95

#  - Item icon filename

    96

#  - Item tooltip text

    97

EditorToolBarItems = {

    98

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

    99

               ID_PLCOPENEDITOREDITORTOOLBARMOTION, "OnMotionTool",

   100

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

   101

              (True, FREEDRAWING_MODE | DRIVENDRAWING_MODE,

   102

               ID_PLCOPENEDITOREDITORTOOLBARCOMMENT, "OnCommentTool",

   103

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

   104

              (True, FREEDRAWING_MODE | DRIVENDRAWING_MODE,

   105

               ID_PLCOPENEDITOREDITORTOOLBARVARIABLE, "OnVariableTool",

   106

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

   107

              (True, FREEDRAWING_MODE | DRIVENDRAWING_MODE,

   108

               ID_PLCOPENEDITOREDITORTOOLBARBLOCK, "OnBlockTool",

   109

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

   110

              (True, FREEDRAWING_MODE | DRIVENDRAWING_MODE,

   111

               ID_PLCOPENEDITOREDITORTOOLBARCONNECTION, "OnConnectionTool",

   112

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

   113

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

   114

               ID_PLCOPENEDITOREDITORTOOLBARMOTION, "OnMotionTool",

   115

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

   116

              (True, FREEDRAWING_MODE,

   117

               ID_PLCOPENEDITOREDITORTOOLBARCOMMENT, "OnCommentTool",

   118

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

   119

              (True, FREEDRAWING_MODE,

   120

               ID_PLCOPENEDITOREDITORTOOLBARPOWERRAIL, "OnPowerRailTool",

   121

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

   122

              (False, DRIVENDRAWING_MODE,

   123

               ID_PLCOPENEDITOREDITORTOOLBARRUNG, "OnRungTool",

   124

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

   125

              (True, FREEDRAWING_MODE,

   126

               ID_PLCOPENEDITOREDITORTOOLBARCOIL, "OnCoilTool",

   127

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

   128

              (False, FREEDRAWING_MODE | DRIVENDRAWING_MODE,

   129

               ID_PLCOPENEDITOREDITORTOOLBARCONTACT, "OnContactTool",

   130

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

   131

              (False, DRIVENDRAWING_MODE,

   132

               ID_PLCOPENEDITOREDITORTOOLBARBRANCH, "OnBranchTool",

   133

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

   134

              (True, FREEDRAWING_MODE,

   135

               ID_PLCOPENEDITOREDITORTOOLBARVARIABLE, "OnVariableTool",

   136

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

   137

              (False, FREEDRAWING_MODE | DRIVENDRAWING_MODE,

   138

               ID_PLCOPENEDITOREDITORTOOLBARBLOCK, "OnBlockTool",

   139

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

   140

              (True, FREEDRAWING_MODE,

   141

               ID_PLCOPENEDITOREDITORTOOLBARCONNECTION, "OnConnectionTool",

   142

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

   143

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

   144

               ID_PLCOPENEDITOREDITORTOOLBARMOTION, "OnMotionTool",

   145

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

   146

              (True, FREEDRAWING_MODE | DRIVENDRAWING_MODE,

   147

               ID_PLCOPENEDITOREDITORTOOLBARCOMMENT, "OnCommentTool",

   148

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

   149

              (True, FREEDRAWING_MODE | DRIVENDRAWING_MODE,

   150

               ID_PLCOPENEDITOREDITORTOOLBARINITIALSTEP, "OnInitialStepTool",

   151

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

   152

              (False, FREEDRAWING_MODE | DRIVENDRAWING_MODE,

   153

               ID_PLCOPENEDITOREDITORTOOLBARSTEP, "OnStepTool",

   154

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

   155

              (True, FREEDRAWING_MODE,

   156

               ID_PLCOPENEDITOREDITORTOOLBARTRANSITION, "OnTransitionTool",

   157

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

   158

              (False, FREEDRAWING_MODE | DRIVENDRAWING_MODE,

   159

               ID_PLCOPENEDITOREDITORTOOLBARACTIONBLOCK, "OnActionBlockTool",

   160

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

   161

              (False, FREEDRAWING_MODE | DRIVENDRAWING_MODE,

   162

               ID_PLCOPENEDITOREDITORTOOLBARDIVERGENCE, "OnDivergenceTool",

   163

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

   164

              (False, FREEDRAWING_MODE | DRIVENDRAWING_MODE,

   165

               ID_PLCOPENEDITOREDITORTOOLBARJUMP, "OnJumpTool",

   166

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

   167

              (True, FREEDRAWING_MODE,

   168

               ID_PLCOPENEDITOREDITORTOOLBARVARIABLE, "OnVariableTool",

   169

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

   170

              (True, FREEDRAWING_MODE,

   171

               ID_PLCOPENEDITOREDITORTOOLBARBLOCK, "OnBlockTool",

   172

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

   173

              (True, FREEDRAWING_MODE,

   174

               ID_PLCOPENEDITOREDITORTOOLBARCONNECTION, "OnConnectionTool",

   175

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

   176

              (True, FREEDRAWING_MODE,

   177

               ID_PLCOPENEDITOREDITORTOOLBARPOWERRAIL, "OnPowerRailTool",

   178

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

   179

              (True, FREEDRAWING_MODE,

   180

               ID_PLCOPENEDITOREDITORTOOLBARCONTACT, "OnContactTool",

   181

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

   182

    "ST":    [],

   183

    "IL":    [],

   184

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

   185

               ID_PLCOPENEDITOREDITORTOOLBARMOTION, "OnMotionTool",

   186

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

   187

}

   188

   189

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

   190

#                               Helper Functions

   191

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

   192

   193

import base64

   194

   195

   196

def EncodeFileSystemPath(path, use_base64=True):

   197

    path = path.encode(sys.getfilesystemencoding())

   198

    if use_base64:

   199

        return base64.encodestring(path)

   200

    return path

   201

   202

   203

def DecodeFileSystemPath(path, is_base64=True):

   204

    if is_base64:

   205

        path = base64.decodestring(path)

   206

    return unicode(path, sys.getfilesystemencoding())

   207

   208

   209

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

   210

    """

   211

    Compatibility function for wx versions < 2.6

   212

    """

   213

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

   214

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

   215

    else:

   216

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

   217

   218

   219

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

   220

 POUINSTANCEVARIABLESPANEL, LIBRARYTREE, SCALING, PAGETITLES

   221

] = range(10)

   222

   223

   224

def GetShortcutKeyCallbackFunction(viewer_function):

   225

    def ShortcutKeyFunction(self, event):

   226

        control = self.FindFocus()

   227

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

   228

            getattr(control.ParentWindow, viewer_function)()

   229

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

   230

            getattr(control, viewer_function)()

   231

        elif isinstance(control, wx.TextCtrl):

   232

            control.ProcessEvent(event)

   233

    return ShortcutKeyFunction

   234

   235

   236

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

   237

    def DeleteElementFunction(self, selected):

   238

        name = self.ProjectTree.GetItemText(selected)

   239

        if check_function is None or check_function(name):

   240

            if parent_type is not None:

   241

                item_infos = self.ProjectTree.GetPyData(selected)

   242

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

   243

                remove_function(self.Controler, parent_name, name)

   244

            else:

   245

                remove_function(self.Controler, name)

   246

    return DeleteElementFunction

   247

   248

   249

if wx.Platform == '__WXMSW__':

   250

    TAB_BORDER = 6

   251

    NOTEBOOK_BORDER = 6

   252

else:

   253

    TAB_BORDER = 7

   254

    NOTEBOOK_BORDER = 2

   255

   256

   257

def SimplifyTabLayout(tabs, rect):

   258

    for tab in tabs:

   259

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

   260

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

   261

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

   262

            for other in others:

   263

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

   264

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

   265

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

   266

   267

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

   268

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

   269

                    tabs.remove(other)

   270

   271

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

   272

                        return True

   273

   274

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

   275

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

   276

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

   277

            for other in others:

   278

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

   279

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

   280

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

   281

   282

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

   283

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

   284

                    tabs.remove(other)

   285

   286

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

   287

                        return True

   288

    return False

   289

   290

   291

def ComputeTabsLayout(tabs, rect):

   292

    if len(tabs) == 0:

   293

        return tabs

   294

    if len(tabs) == 1:

   295

        return tabs[0]

   296

    split = None

   297

    for idx, tab in enumerate(tabs):

   298

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

   299

            raise ValueError("Not possible")

   300

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

   301

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

   302

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

   303

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

   304

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

   305

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

   306

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

   307

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

   308

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

   309

            break

   310

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

   311

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

   312

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

   313

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

   314

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

   315

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

   316

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

   317

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

   318

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

   319

            break

   320

    if split is not None:

   321

        split_tab = tabs.pop(idx)

   322

        return {"split": split,

   323

                "tab": split_tab,

   324

                "others": ComputeTabsLayout(tabs, split_rect)}

   325

    else:

   326

        if SimplifyTabLayout(tabs, rect):

   327

            return ComputeTabsLayout(tabs, rect)

   328

    return tabs

   329

   330

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

   331

#                              IDEFrame Base Class

   332

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

   333

   334

   335

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

   336

   337

   338

class IDEFrame(wx.Frame):

   339

   340

    # Compatibility function for wx versions < 2.6

   341

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

   342

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

   343

            if id is not None:

   344

                event(self, id, function)

   345

            else:

   346

                event(self, function)

   347

   348

    def _init_coll_MenuBar_Menus(self, parent):

   349

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

   350

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

   351

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

   352

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

   353

   354

    def _init_coll_FileMenu_Items(self, parent):

   355

        pass

   356

   357

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

   358

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

   360

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

   362

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

   364

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

   366

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

   368

        if add_config:

   369

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

   371

   372

    def _init_coll_EditMenu_Items(self, parent):

   373

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

   375

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

   377

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

   378

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

   379

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

   380

        parent.AppendSeparator()

   381

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

   383

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

   385

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

   387

        parent.AppendSeparator()

   388

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

   390

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

   392

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

   394

        parent.AppendSeparator()

   395

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

   397

        parent.AppendSeparator()

   398

        add_menu = wx.Menu(title='')

   399

        self._init_coll_AddMenu_Items(add_menu)

   400

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

   401

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

   403

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

   405

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

   406

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

   407

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

   408

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

   409

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

   410

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

   411

        self.Bind(wx.EVT_MENU, self.OnFindMenu, id=wx.ID_FIND)

   412

        self.Bind(wx.EVT_MENU, self.OnFindNextMenu,

   414

        self.Bind(wx.EVT_MENU, self.OnFindPreviousMenu,

   416

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

   418

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

   420

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

   422

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

   424

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

   426

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

   428

        self.Bind(wx.EVT_MENU, self.AddResourceMenu,

   430

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

   432

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

   433

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

   434

   435

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

   436

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

   437

                               None,

   438

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

   439

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

   440

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

   441

                               None,

   442

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

   443

   444

    def _init_coll_DisplayMenu_Items(self, parent):

   445

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

   447

        if self.EnableDebug:

   448

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

   450

        parent.AppendSeparator()

   451

        zoommenu = wx.Menu(title='')

   452

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

   453

        for idx, value in enumerate(ZOOM_FACTORS):

   454

            new_id = wx.NewId()

   455

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

   457

            self.Bind(wx.EVT_MENU, self.GenerateZoomFunction(idx), id=new_id)

   458

   459

        parent.AppendSeparator()

   460

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

   461

                   kind=wx.ITEM_NORMAL, text=_(u'Switch perspective') + '\tF12')

   462

        self.Bind(wx.EVT_MENU, self.SwitchFullScrMode, id=ID_PLCOPENEDITORDISPLAYMENUSWITCHPERSPECTIVE)

   463

   464

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

   466

        self.Bind(wx.EVT_MENU, self.OnResetPerspective, id=ID_PLCOPENEDITORDISPLAYMENURESETPERSPECTIVE)

   467

   468

        self.Bind(wx.EVT_MENU, self.OnRefreshMenu, id=wx.ID_REFRESH)

   469

        if self.EnableDebug:

   470

            self.Bind(wx.EVT_MENU, self.OnClearErrorsMenu, id=wx.ID_CLEAR)

   471

   472

    def _init_coll_HelpMenu_Items(self, parent):

   473

        pass

   474

   475

    def _init_utils(self):

   476

        self.MenuBar = wx.MenuBar()

   477

   478

        self.FileMenu = wx.Menu(title='')

   479

        self.EditMenu = wx.Menu(title='')

   480

        self.DisplayMenu = wx.Menu(title='')

   481

        self.HelpMenu = wx.Menu(title='')

   482

   483

        self._init_coll_MenuBar_Menus(self.MenuBar)

   484

        self._init_coll_FileMenu_Items(self.FileMenu)

   485

        self._init_coll_EditMenu_Items(self.EditMenu)

   486

        self._init_coll_DisplayMenu_Items(self.DisplayMenu)

   487

        self._init_coll_HelpMenu_Items(self.HelpMenu)

   488

   489

    def _init_icon(self, parent):

   490

        if self.icon:

   491

            self.SetIcon(self.icon)

   492

        elif parent and parent.icon:

   493

            self.SetIcon(parent.icon)

   494

   495

    def _init_ctrls(self, prnt):

   496

        wx.Frame.__init__(self, id=ID_PLCOPENEDITOR, name='IDEFrame',

   499

        self._init_icon(prnt)

   500

        self.SetClientSize(wx.Size(1000, 600))