1 (binary file text/x-python, hash: 6aebfc5e174a423ddbc5b3a8b9440383e321e18e)

     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 docutils 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     loc = wx.Locale(langid)

    94     __builtin__.__dict__['loc'] = loc

    95 # Define location for searching translation files

    96 loc.AddCatalogLookupPathPrefix(localedir)

    97 # Define locale domain

    98 loc.AddCatalog(domain)

    99 

   100 if __name__ == '__main__':

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

   102 

   103 from SFCViewer import *

   104 from LDViewer import *

   105 from Viewer import *

   106 from TextViewer import *

   107 from GraphicViewer import *

   108 from RessourceEditor import *

   109 from DataTypeEditor import *

   110 from PLCControler import *

   111 from VariablePanel import VariablePanel

   112 

   113 # Define PLCOpenEditor controls id

   114 [ID_PLCOPENEDITOR, ID_PLCOPENEDITORLEFTNOTEBOOK, 

   115  ID_PLCOPENEDITORBOTTOMNOTEBOOK, ID_PLCOPENEDITORRIGHTNOTEBOOK, 

   116  ID_PLCOPENEDITORTYPESTREE, ID_PLCOPENEDITORINSTANCESTREE, 

   117  ID_PLCOPENEDITORMAINSPLITTER, ID_PLCOPENEDITORSECONDSPLITTER, 

   118  ID_PLCOPENEDITORTHIRDSPLITTER, ID_PLCOPENEDITORLIBRARYPANEL, 

   119  ID_PLCOPENEDITORLIBRARYTREE, ID_PLCOPENEDITORLIBRARYCOMMENT, 

   120  ID_PLCOPENEDITORTABSOPENED, ID_PLCOPENEDITORTABSOPENED,

   121  ID_PLCOPENEDITORTOOLBAR, ID_PLCOPENEDITORDEFAULTTOOLBAR, 

   122  ID_PLCOPENEDITORSFCTOOLBAR, ID_PLCOPENEDITORFBDTOOLBAR, 

   123  ID_PLCOPENEDITORLDTOOLBAR,

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

   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 ] = [wx.NewId() for _init_coll_EditMenu_Items in range(6)]

   135 

   136 

   137 #-------------------------------------------------------------------------------

   138 #                            ToolBars definitions

   139 #-------------------------------------------------------------------------------

   140 

   141 # Define PLCOpenEditor Toolbar items id

   142 [ID_PLCOPENEDITORTOOLBARSELECTION, ID_PLCOPENEDITORTOOLBARCOMMENT,

   143  ID_PLCOPENEDITORTOOLBARVARIABLE, ID_PLCOPENEDITORTOOLBARBLOCK,

   144  ID_PLCOPENEDITORTOOLBARCONNECTION, ID_PLCOPENEDITORTOOLBARWIRE,

   145  ID_PLCOPENEDITORTOOLBARPOWERRAIL, ID_PLCOPENEDITORTOOLBARRUNG,

   146  ID_PLCOPENEDITORTOOLBARCOIL, ID_PLCOPENEDITORTOOLBARCONTACT,

   147  ID_PLCOPENEDITORTOOLBARBRANCH, ID_PLCOPENEDITORTOOLBARINITIALSTEP,

   148  ID_PLCOPENEDITORTOOLBARSTEP, ID_PLCOPENEDITORTOOLBARTRANSITION,

   149  ID_PLCOPENEDITORTOOLBARACTIONBLOCK, ID_PLCOPENEDITORTOOLBARDIVERGENCE,

   150  ID_PLCOPENEDITORTOOLBARJUMP,

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

   152 

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

   154 # Informations meaning are in this order:

   155 #  - Item is toggled

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

   157 #  - Item id

   158 #  - Item callback function name

   159 #  - Item icon filename

   160 #  - Item tooltip text

   161 ToolBarItems = {

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

   163               ID_PLCOPENEDITORTOOLBARCOMMENT, "OnCommentTool",

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

   165              (True, FREEDRAWING_MODE|DRIVENDRAWING_MODE,

   166               ID_PLCOPENEDITORTOOLBARVARIABLE, "OnVariableTool",

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

   168              (True, FREEDRAWING_MODE|DRIVENDRAWING_MODE,

   169               ID_PLCOPENEDITORTOOLBARBLOCK, "OnBlockTool",

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

   171              (True, FREEDRAWING_MODE|DRIVENDRAWING_MODE, 

   172               ID_PLCOPENEDITORTOOLBARCONNECTION, "OnConnectionTool", 

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

   174     "LD"  : [(True, FREEDRAWING_MODE, 

   175               ID_PLCOPENEDITORTOOLBARCOMMENT, "OnCommentTool", 

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

   177              (True, FREEDRAWING_MODE, 

   178               ID_PLCOPENEDITORTOOLBARPOWERRAIL, "OnPowerRailTool", 

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

   180              (False, DRIVENDRAWING_MODE, 

   181               ID_PLCOPENEDITORTOOLBARRUNG, "OnRungTool", 

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

   183              (True, FREEDRAWING_MODE, 

   184               ID_PLCOPENEDITORTOOLBARCOIL, "OnCoilTool", 

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

   186              (False, FREEDRAWING_MODE|DRIVENDRAWING_MODE, 

   187               ID_PLCOPENEDITORTOOLBARCONTACT, "OnContactTool", 

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

   189              (False, DRIVENDRAWING_MODE, 

   190               ID_PLCOPENEDITORTOOLBARBRANCH, "OnBranchTool", 

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

   192              (True, FREEDRAWING_MODE, 

   193               ID_PLCOPENEDITORTOOLBARVARIABLE, "OnVariableTool", 

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

   195              (False, FREEDRAWING_MODE|DRIVENDRAWING_MODE, 

   196               ID_PLCOPENEDITORTOOLBARBLOCK, "OnBlockTool", 

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

   198              (True, FREEDRAWING_MODE, 

   199               ID_PLCOPENEDITORTOOLBARCONNECTION, "OnConnectionTool", 

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

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

   202               ID_PLCOPENEDITORTOOLBARCOMMENT, "OnCommentTool", 

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

   204              (True, FREEDRAWING_MODE|DRIVENDRAWING_MODE, 

   205               ID_PLCOPENEDITORTOOLBARINITIALSTEP, "OnInitialStepTool", 

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

   207              (False, FREEDRAWING_MODE|DRIVENDRAWING_MODE, 

   208               ID_PLCOPENEDITORTOOLBARSTEP, "OnStepTool", 

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

   210              (True, FREEDRAWING_MODE, 

   211               ID_PLCOPENEDITORTOOLBARTRANSITION, "OnTransitionTool", 

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

   213              (False, FREEDRAWING_MODE|DRIVENDRAWING_MODE, 

   214               ID_PLCOPENEDITORTOOLBARACTIONBLOCK, "OnActionBlockTool", 

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

   216              (False, FREEDRAWING_MODE|DRIVENDRAWING_MODE, 

   217               ID_PLCOPENEDITORTOOLBARDIVERGENCE, "OnDivergenceTool", 

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

   219              (False, FREEDRAWING_MODE|DRIVENDRAWING_MODE, 

   220               ID_PLCOPENEDITORTOOLBARJUMP, "OnJumpTool", 

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

   222              (True, FREEDRAWING_MODE, 

   223               ID_PLCOPENEDITORTOOLBARVARIABLE, "OnVariableTool", 

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

   225              (True, FREEDRAWING_MODE, 

   226               ID_PLCOPENEDITORTOOLBARBLOCK, "OnBlockTool", 

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

   228              (True, FREEDRAWING_MODE, 

   229               ID_PLCOPENEDITORTOOLBARCONNECTION, "OnConnectionTool", 

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

   231              (True, FREEDRAWING_MODE, 

   232               ID_PLCOPENEDITORTOOLBARPOWERRAIL, "OnPowerRailTool", 

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

   234              (True, FREEDRAWING_MODE, 

   235               ID_PLCOPENEDITORTOOLBARCONTACT, "OnContactTool", 

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

   237     "ST"  : [],

   238     "IL"  : []

   239 }

   240 

   241 #-------------------------------------------------------------------------------

   242 #                               Helper Functions

   243 #-------------------------------------------------------------------------------

   244 

   245 # Compatibility function for wx versions < 2.6

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

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

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

   249     else:

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

   251 

   252 [TITLE, TOOLBAR, FILEMENU, EDITMENU, DISPLAYMENU, TYPESTREE, 

   253  INSTANCESTREE, LIBRARYTREE, SCALING

   254 ] = range(9)

   255 

   256 def GetShortcutKeyCallbackFunction(viewer_function):

   257     def ShortcutKeyFunction(self, event):

   258         control = self.FindFocus()

   259         if isinstance(control, (Viewer, TextViewer)):

   260             getattr(control, viewer_function)()

   261         elif isinstance(control, wx.TextCtrl):

   262             control.ProcessEvent(event)

   263     return ShortcutKeyFunction

   264 

   265 def GetParentName(tree, item, parent_type):

   266     parent_item = tree.GetItemParent(item)

   267     parent_item_type = tree.GetPyData(parent_item)

   268     while parent_item_type != parent_type:

   269         parent_item = tree.GetItemParent(parent_item)

   270         parent_item_type = tree.GetPyData(parent_item)

   271     return tree.GetItemText(parent_item)

   272 

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

   274     def DeleteElementFunction(self, selected):

   275         name = self.TypesTree.GetItemText(selected)

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

   277             if parent_type is not None:

   278                 parent_name = GetParentName(self.TypesTree, selected, parent_type)

   279                 remove_function(self.Controler, parent_name, name)

   280             else:

   281                 remove_function(self.Controler, name)

   282         else:

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

   284     return DeleteElementFunction

   285 

   286 

   287 #-------------------------------------------------------------------------------

   288 #                              IDEFrame Base Class

   289 #-------------------------------------------------------------------------------

   290 

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

   292 

   293 class IDEFrame(wx.Frame):

   294     

   295     # Compatibility function for wx versions < 2.6

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

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

   298             if id is not None:

   299                 event(self, id, function)

   300             else:

   301                 event(self, function)

   302     

   303     def _init_coll_MenuBar_Menus(self, parent):

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

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

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

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

   308 

   309     def _init_coll_FileMenu_Items(self, parent):

   310         pass

   311     

   312     def _init_coll_EditMenu_Items(self, parent):

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

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

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

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

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

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

   319         parent.AppendSeparator()

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

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

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

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

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

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

   326         parent.AppendSeparator()

   327         addmenu = wx.Menu(title='')

   328         parent.AppendMenu(wx.ID_ADD, _("Add Element"), addmenu)

   329         AppendMenu(addmenu, help='', id=ID_PLCOPENEDITOREDITMENUADDDATATYPE,

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

   331         AppendMenu(addmenu, help='', id=ID_PLCOPENEDITOREDITMENUADDFUNCTION,

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

   333         AppendMenu(addmenu, help='', id=ID_PLCOPENEDITOREDITMENUADDFUNCTIONBLOCK,

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

   335         AppendMenu(addmenu, help='', id=ID_PLCOPENEDITOREDITMENUADDPROGRAM,

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

   337         AppendMenu(addmenu, help='', id=ID_PLCOPENEDITOREDITMENUADDCONFIGURATION,

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

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

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

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

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

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

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

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

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

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

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

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

   350               id=ID_PLCOPENEDITOREDITMENUADDDATATYPE)

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

   352               id=ID_PLCOPENEDITOREDITMENUADDFUNCTION)

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

   354               id=ID_PLCOPENEDITOREDITMENUADDFUNCTIONBLOCK)

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

   356               id=ID_PLCOPENEDITOREDITMENUADDPROGRAM)

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

   358               id=ID_PLCOPENEDITOREDITMENUADDCONFIGURATION)

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

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

   361 

   362     def _init_coll_DisplayMenu_Items(self, parent):

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

   364               kind=wx.ITEM_NORMAL, text=_(u'Refresh\tF5'))

   365         if self.EnableDebug:

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

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

   368         parent.AppendSeparator()

   369         zoommenu = wx.Menu(title='')

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

   371         for idx, value in enumerate(ZOOM_FACTORS):

   372             new_id = wx.NewId()

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

   374                   kind=wx.ITEM_RADIO, text=str(int(round(value * 100))) + "%")

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

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

   377         if self.EnableDebug:

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

   379 

   380     def _init_coll_HelpMenu_Items(self, parent):

   381         pass

   382 

   383     def _init_utils(self):

   384         self.MenuBar = wx.MenuBar()

   385 

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

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

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

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

   390         

   391         self._init_coll_MenuBar_Menus(self.MenuBar)

   392         self._init_coll_FileMenu_Items(self.FileMenu)

   393         self._init_coll_EditMenu_Items(self.EditMenu)

   394         self._init_coll_DisplayMenu_Items(self.DisplayMenu)

   395         self._init_coll_HelpMenu_Items(self.HelpMenu)

   396 

   397     def _init_coll_MainLibrarySizer_Items(self, parent):

   398         parent.AddWindow(self.LibraryTree, 0, border=0, flag=wx.GROW)

   399         parent.AddSizer(self.LibraryComment, 0, border=0, flag=wx.GROW)

   400 

   401     def _init_coll_MainLibrarySizer_Growables(self, parent):

   402         parent.AddGrowableCol(0)

   403         parent.AddGrowableRow(0)

   404 

   405     def _init_sizers(self):

   406         self.MainLibrarySizer = wx.FlexGridSizer(cols=1, hgap=0, rows=2, vgap=0)

   407         

   408         self._init_coll_MainLibrarySizer_Growables(self.MainLibrarySizer)

   409         self._init_coll_MainLibrarySizer_Items(self.MainLibrarySizer)

   410         

   411         self.LibraryPanel.SetSizer(self.MainLibrarySizer)

   412         

   413     def _init_ctrls(self, prnt):

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

   415               parent=prnt, pos=wx.DefaultPosition, size=wx.Size(1000, 600),

   416               style=wx.DEFAULT_FRAME_STYLE)

   417         self._init_utils()

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

   419         self.SetMenuBar(self.MenuBar)

   420         

   421         self.TabsImageList = wx.ImageList(31, 16)

   422         self.TabsImageListIndexes = {}

   423         

   424         #-----------------------------------------------------------------------

   425         #                          Creating main structure

   426         #-----------------------------------------------------------------------

   427         

   428         if USE_AUI:

   429             self.AUIManager = wx.aui.AuiManager(self)

   430             self.AUIManager.SetDockSizeConstraint(0.5, 0.5)

   431             self.Panes = {}

   432             

   433             self.LeftNoteBook = wx.aui.AuiNotebook(self, ID_PLCOPENEDITORLEFTNOTEBOOK,

   434                   style=wx.aui.AUI_NB_TOP|wx.aui.AUI_NB_TAB_SPLIT|wx.aui.AUI_NB_TAB_MOVE|

   435                         wx.aui.AUI_NB_SCROLL_BUTTONS|wx.aui.AUI_NB_TAB_EXTERNAL_MOVE)

   436             self.AUIManager.AddPane(self.LeftNoteBook, 

   437                   wx.aui.AuiPaneInfo().Caption(_("Project")).Left().Layer(1).

   438                   BestSize(wx.Size(300, 500)).CloseButton(False))

   439         

   440             self.BottomNoteBook = wx.aui.AuiNotebook(self, ID_PLCOPENEDITORBOTTOMNOTEBOOK,

   441                   style=wx.aui.AUI_NB_TOP|wx.aui.AUI_NB_TAB_SPLIT|wx.aui.AUI_NB_TAB_MOVE|

   442                         wx.aui.AUI_NB_SCROLL_BUTTONS|wx.aui.AUI_NB_TAB_EXTERNAL_MOVE)

   443             self.AUIManager.AddPane(self.BottomNoteBook, 

   444                   wx.aui.AuiPaneInfo().Bottom().Layer(0).

   445                   BestSize(wx.Size(800, 300)).CloseButton(False))

   446             

   447             self.RightNoteBook = wx.aui.AuiNotebook(self, ID_PLCOPENEDITORRIGHTNOTEBOOK,

   448                   style=wx.aui.AUI_NB_TOP|wx.aui.AUI_NB_TAB_SPLIT|wx.aui.AUI_NB_TAB_MOVE|

   449                         wx.aui.AUI_NB_SCROLL_BUTTONS|wx.aui.AUI_NB_TAB_EXTERNAL_MOVE)

   450             self.AUIManager.AddPane(self.RightNoteBook, 

   451                   wx.aui.AuiPaneInfo().Right().Layer(0).

   452                   BestSize(wx.Size(250, 400)).CloseButton(False))

   453         

   454             self.TabsOpened = wx.aui.AuiNotebook(self, ID_PLCOPENEDITORTABSOPENED, 

   455                   style=wx.aui.AUI_NB_DEFAULT_STYLE|wx.aui.AUI_NB_WINDOWLIST_BUTTON)

   456             self.TabsOpened.Bind(wx.aui.EVT_AUINOTEBOOK_PAGE_CHANGED,

   457                     self.OnPouSelectedChanged)

   458             self.TabsOpened.Bind(wx.aui.EVT_AUINOTEBOOK_PAGE_CLOSE,

   459                     self.OnPageClose)

   460             self.TabsOpened.Bind(wx.aui.EVT_AUINOTEBOOK_END_DRAG,

   461                     self.OnPageDragged)

   462             self.AUIManager.AddPane(self.TabsOpened, wx.aui.AuiPaneInfo().CentrePane())

   463         

   464         else:

   465             self.MainSplitter = wx.SplitterWindow(id=ID_PLCOPENEDITORMAINSPLITTER,

   466                   name='MainSplitter', parent=self, point=wx.Point(0, 0),

   467                   size=wx.Size(0, 0), style=wx.SP_3D)

   468             self.MainSplitter.SetNeedUpdating(True)

   469             self.MainSplitter.SetMinimumPaneSize(1)

   470             

   471             self.LeftNoteBook = wx.Notebook(id=ID_PLCOPENEDITORLEFTNOTEBOOK,

   472                   name='LeftNoteBook', parent=self.MainSplitter, pos=wx.Point(0,

   473                   0), size=wx.Size(0, 0), style=0)

   474         

   475             self.SecondSplitter = wx.SplitterWindow(id=ID_PLCOPENEDITORSECONDSPLITTER,

   476                   name='SecondSplitter', parent=self.MainSplitter, point=wx.Point(0, 0),

   477                   size=wx.Size(0, 0), style=wx.SP_3D)

   478             self.SecondSplitter.SetMinimumPaneSize(1)

   479                 

   480             self.MainSplitter.SplitVertically(self.LeftNoteBook, self.SecondSplitter, 200)

   481             

   482             self.ThirdSplitter = wx.SplitterWindow(id=ID_PLCOPENEDITORTHIRDSPLITTER,

   483                   name='ThirdSplitter', parent=self.SecondSplitter, point=wx.Point(0, 0),

   484                   size=wx.Size(0, 0), style=wx.SP_3D)

   485             self.ThirdSplitter.SetMinimumPaneSize(1)

   486             

   487             self.BottomNoteBook = wx.Notebook(id=ID_PLCOPENEDITORBOTTOMNOTEBOOK,

   488                   name='BottomNoteBook', parent=self.SecondSplitter, pos=wx.Point(0,

   489                   0), size=wx.Size(0, 0), style=0)

   490             

   491             self.SecondSplitter.SplitHorizontally(self.ThirdSplitter, self.BottomNoteBook, -200)

   492             

   493             self.TabsOpened = wx.Notebook(id=ID_PLCOPENEDITORTABSOPENED,

   494                   name='TabsOpened', parent=self.ThirdSplitter, pos=wx.Point(0,

   495                   0), size=wx.Size(0, 0), style=0)

   496             self.TabsOpened.SetImageList(self.TabsImageList)

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

   498                 self.TabsOpened.Bind(wx.EVT_NOTEBOOK_PAGE_CHANGED,

   499                     self.OnPouSelectedChanged, id=ID_PLCOPENEDITORTABSOPENED)

   500             else:

   501                 wx.EVT_NOTEBOOK_PAGE_CHANGED(self.TabsOpened, ID_PLCOPENEDITORTABSOPENED,

   502                     self.OnPouSelectedChanged)

   503             

   504             self.RightNoteBook = wx.Notebook(id=ID_PLCOPENEDITORRIGHTNOTEBOOK,

   505                   name='RightNoteBook', parent=self.ThirdSplitter, pos=wx.Point(0,

   506                   0), size=wx.Size(0, 0), style=0)

   507             

   508             self.ThirdSplitter.SplitVertically(self.TabsOpened, self.RightNoteBook, -250)

   509         

   510         #-----------------------------------------------------------------------

   511         #                       Creating PLCopen Project tree

   512         #-----------------------------------------------------------------------

   513         

   514         self.TypesTree = wx.TreeCtrl(id=ID_PLCOPENEDITORTYPESTREE,

   515                   name='TypesTree', parent=self.LeftNoteBook, 

   516                   pos=wx.Point(0, 0), size=wx.Size(0, 0),

   517                   style=wx.TR_HAS_BUTTONS|wx.TR_SINGLE|wx.SUNKEN_BORDER|wx.TR_EDIT_LABELS)

   518         if wx.Platform == '__WXMSW__':

   519             self.Bind(wx.EVT_TREE_ITEM_RIGHT_CLICK, self.OnTypesTreeRightUp,

   520                   id=ID_PLCOPENEDITORTYPESTREE)

   521             self.Bind(wx.EVT_TREE_SEL_CHANGED, self.OnTypesTreeItemSelected,

   522                   id=ID_PLCOPENEDITORTYPESTREE)

   523         else:

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

   525                 self.TypesTree.Bind(wx.EVT_RIGHT_UP, self.OnTypesTreeRightUp)

   526                 self.TypesTree.Bind(wx.EVT_LEFT_UP, self.OnTypesTreeLeftUp)

   527             else:

   528                 wx.EVT_RIGHT_UP(self.TypesTree, self.OnTypesTreeRightUp)

   529                 wx.EVT_LEFT_UP(self.TypesTree, self.OnTypesTreeLeftUp)

   530             self.Bind(wx.EVT_TREE_SEL_CHANGING, self.OnTypesTreeItemChanging,

   531                   id=ID_PLCOPENEDITORTYPESTREE)

   532         self.Bind(wx.EVT_TREE_BEGIN_DRAG, self.OnTypesTreeBeginDrag,

   533               id=ID_PLCOPENEDITORTYPESTREE)

   534         self.Bind(wx.EVT_TREE_BEGIN_LABEL_EDIT, self.OnTypesTreeItemBeginEdit,

   535               id=ID_PLCOPENEDITORTYPESTREE)

   536         self.Bind(wx.EVT_TREE_END_LABEL_EDIT, self.OnTypesTreeItemEndEdit,

   537               id=ID_PLCOPENEDITORTYPESTREE)

   538         self.Bind(wx.EVT_TREE_ITEM_ACTIVATED, self.OnTypesTreeItemActivated,

   539               id=ID_PLCOPENEDITORTYPESTREE)

   540         self.LeftNoteBook.AddPage(self.TypesTree, _("Types"))

   541 

   542         #-----------------------------------------------------------------------

   543         #                       Creating PLCopen Project tree

   544         #-----------------------------------------------------------------------

   545         

   546         self.InstancesTree = wx.TreeCtrl(id=ID_PLCOPENEDITORINSTANCESTREE,

   547                   name='InstancesTree', parent=self.LeftNoteBook, 

   548                   pos=wx.Point(0, 0), size=wx.Size(0, 0),

   549                   style=wx.TR_HAS_BUTTONS|wx.TR_SINGLE|wx.SUNKEN_BORDER)

   550         if self.EnableDebug:

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

   552                 self.InstancesTree.Bind(wx.EVT_RIGHT_UP, self.OnInstancesTreeRightUp)

   553             else:

   554                 wx.EVT_RIGHT_UP(self.InstancesTree, self.OnInstancesTreeRightUp)

   555             self.Bind(wx.EVT_TREE_BEGIN_DRAG, self.OnInstancesTreeBeginDrag,

   556                   id=ID_PLCOPENEDITORINSTANCESTREE)

   557             self.Bind(wx.EVT_TREE_ITEM_ACTIVATED, self.OnInstancesTreeItemActivated,

   558                   id=ID_PLCOPENEDITORINSTANCESTREE)

   559         self.LeftNoteBook.AddPage(self.InstancesTree, _("Instances"))

   560         

   561         #-----------------------------------------------------------------------

   562         #                            Creating Tool Bar

   563         #-----------------------------------------------------------------------

   564 

   565         if USE_AUI:

   566             ToolBar = wx.ToolBar(self, ID_PLCOPENEDITORTOOLBAR, wx.DefaultPosition, wx.DefaultSize,

   567                     wx.TB_FLAT | wx.TB_NODIVIDER | wx.NO_BORDER)

   568             ToolBar.SetToolBitmapSize(wx.Size(25, 25))

   569             ToolBar.AddRadioTool(ID_PLCOPENEDITORTOOLBARSELECTION, 

   570                   wx.Bitmap(os.path.join(CWD, 'Images', 'select.png')), wx.NullBitmap, _("Select an object"))

   571             ToolBar.Realize()

   572             self.Panes["ToolBar"] = ToolBar

   573             self.AUIManager.AddPane(ToolBar, wx.aui.AuiPaneInfo().

   574                       Name("ToolBar").Caption(_("Toolbar")).

   575                       ToolbarPane().Top().

   576                       LeftDockable(False).RightDockable(False))

   577         else:

   578             self.ToolBar = self.CreateToolBar(wx.TB_HORIZONTAL|wx.TB_FLAT|wx.NO_BORDER, 

   579                   ID_PLCOPENEDITORTOOLBAR, 'ToolBar')

   580             self.ToolBar.SetToolBitmapSize(wx.Size(25, 25))

   581             self.ToolBar.AddRadioTool(ID_PLCOPENEDITORTOOLBARSELECTION, 

   582                   wx.Bitmap(os.path.join(CWD, 'Images', 'select.png')), wx.NullBitmap, _("Select an object"))

   583             self.ToolBar.Realize()

   584             

   585             self.Bind(wx.EVT_TOOL, self.OnSelectionTool, 

   586                   id=ID_PLCOPENEDITORTOOLBARSELECTION)

   587         

   588         self.VariablePanelIndexer = VariablePanelIndexer(self.BottomNoteBook, self)

   589         self.BottomNoteBook.AddPage(self.VariablePanelIndexer, _("Variables"))

   590 

   591         self.LibraryPanel = wx.Panel(id=ID_PLCOPENEDITORLIBRARYPANEL,

   592               name='LibraryPanel', parent=self.RightNoteBook, pos=wx.Point(0,

   593               0), size=wx.Size(0, 0), style=0)

   594         self.RightNoteBook.AddPage(self.LibraryPanel, _("Library"))

   595         

   596         if wx.Platform == '__WXMSW__':

   597             librarytreestyle = wx.TR_HAS_BUTTONS|wx.TR_SINGLE|wx.SUNKEN_BORDER

   598         else:

   599             librarytreestyle = wx.TR_HAS_BUTTONS|wx.TR_HIDE_ROOT|wx.TR_SINGLE|wx.SUNKEN_BORDER

   600         self.LibraryTree = wx.TreeCtrl(id=ID_PLCOPENEDITORLIBRARYTREE,

   601                   name='LibraryTree', parent=self.LibraryPanel, 

   602                   pos=wx.Point(0, 0), size=wx.Size(0, 0),

   603                   style=librarytreestyle)

   604         self.Bind(wx.EVT_TREE_SEL_CHANGED, self.OnLibraryTreeItemSelected,

   605               id=ID_PLCOPENEDITORLIBRARYTREE)

   606         self.Bind(wx.EVT_TREE_BEGIN_DRAG, self.OnLibraryTreeBeginDrag,

   607               id=ID_PLCOPENEDITORLIBRARYTREE)

   608         

   609         self.LibraryComment = wx.TextCtrl(id=ID_PLCOPENEDITORLIBRARYCOMMENT,

   610                   name='LibraryComment', parent=self.LibraryPanel, 

   611                   pos=wx.Point(0, 0), size=wx.Size(0, 60), 

   612                   style=wx.TE_READONLY|wx.TE_MULTILINE)

   613         

   614         self._init_sizers()

   615         

   616         if self.EnableDebug:

   617             self.DebugVariablePanel = DebugVariablePanel(self.RightNoteBook, self.Controler)

   618             self.RightNoteBook.AddPage(self.DebugVariablePanel, _("Debugger"))

   619         

   620         if USE_AUI:

   621             self.AUIManager.Update()

   622     

   623     ## Constructor of the PLCOpenEditor class.

   624     #  @param parent The parent window.

   625     #  @param controler The controler been used by PLCOpenEditor (default: None).

   626     #  @param fileOpen The filepath to open if no controler defined (default: None).

   627     #  @param debug The filepath to open if no controler defined (default: False).

   628     def __init__(self, parent, enable_debug = False):

   629         self.Controler = None

   630         self.EnableDebug = enable_debug

   631         

   632         self._init_ctrls(parent)

   633         

   634         # Define Tree item icon list

   635         self.TreeImageList = wx.ImageList(16, 16)

   636         self.TreeImageDict = {}

   637         

   638         # Icons for languages

   639         for language in LANGUAGES:

   640             self.TreeImageDict[language]=self.TreeImageList.Add(wx.Bitmap(os.path.join(CWD, 'Images', '%s.png'%language)))

   641             

   642         # Icons for other items

   643         for imgname, itemtype in [

   644             #editables

   645             ("PROJECT",        ITEM_PROJECT),

   646             #("POU",            ITEM_POU),

   647             #("VARIABLE",       ITEM_VARIABLE),

   648             ("TRANSITION",     ITEM_TRANSITION),

   649             ("ACTION",         ITEM_ACTION),

   650             ("CONFIGURATION",  ITEM_CONFIGURATION),

   651             ("RESOURCE",       ITEM_RESOURCE),

   652             ("DATATYPE",       ITEM_DATATYPE),

   653             # uneditables

   654             ("DATATYPES",      ITEM_DATATYPES),

   655             ("FUNCTION",       ITEM_FUNCTION),

   656             ("FUNCTIONBLOCK",  ITEM_FUNCTIONBLOCK),

   657             ("PROGRAM",        ITEM_PROGRAM),

   658             ("VAR_LOCAL",      ITEM_VAR_LOCAL),

   659             ("VAR_LOCAL",      ITEM_VAR_GLOBAL),

   660             ("VAR_LOCAL",      ITEM_VAR_EXTERNAL),

   661             ("VAR_LOCAL",      ITEM_VAR_TEMP),

   662             ("VAR_INPUT",      ITEM_VAR_INPUT),

   663             ("VAR_OUTPUT",     ITEM_VAR_OUTPUT),

   664             ("VAR_INOUT",      ITEM_VAR_INOUT),

   665             ("TRANSITIONS",    ITEM_TRANSITIONS),

   666             ("ACTIONS",        ITEM_ACTIONS),

   667             ("CONFIGURATIONS", ITEM_CONFIGURATIONS),

   668             ("RESOURCES",      ITEM_RESOURCES),

   669             ("PROPERTIES",     ITEM_PROPERTIES)]:

   670             self.TreeImageDict[itemtype]=self.TreeImageList.Add(wx.Bitmap(os.path.join(CWD, 'Images', '%s.png'%imgname)))

   671         

   672         # Assign icon list to TreeCtrls

   673         self.TypesTree.SetImageList(self.TreeImageList)

   674         self.InstancesTree.SetImageList(self.TreeImageList)

   675         

   676         self.CurrentToolBar = []

   677         self.CurrentLanguage = ""

   678         self.SelectedItem = None

   679         self.Errors = []

   680         self.DrawingMode = FREEDRAWING_MODE

   681         #self.DrawingMode = DRIVENDRAWING_MODE

   682         if USE_AUI:

   683             self.AuiTabCtrl = []

   684         

   685         # Initialize Printing configuring elements

   686         self.PrintData = wx.PrintData()

   687         self.PrintData.SetPaperId(wx.PAPER_A4)

   688         self.PrintData.SetPrintMode(wx.PRINT_MODE_PRINTER)

   689         self.PageSetupData = wx.PageSetupDialogData(self.PrintData)

   690         self.PageSetupData.SetMarginTopLeft(wx.Point(10, 15))

   691         self.PageSetupData.SetMarginBottomRight(wx.Point(10, 20))

   692         

   693         self.SetRefreshFunctions()

   694         

   695         self.Maximize()

   696         

   697 

   698 #-------------------------------------------------------------------------------

   699 #                               General Functions

   700 #-------------------------------------------------------------------------------

   701 

   702     def SetRefreshFunctions(self):

   703         self.RefreshFunctions = {

   704             TITLE : self.RefreshTitle,

   705             TOOLBAR : self.RefreshToolBar,

   706             FILEMENU : self.RefreshFileMenu,

   707             EDITMENU : self.RefreshEditMenu,

   708             DISPLAYMENU : self.RefreshDisplayMenu,

   709             TYPESTREE : self.RefreshTypesTree,

   710             INSTANCESTREE : self.RefreshInstancesTree, 

   711             LIBRARYTREE : self.RefreshLibraryTree,

   712             SCALING : self.RefreshScaling}

   713 

   714     ## Call PLCOpenEditor refresh functions.

   715     #  @param elements List of elements to refresh.

   716     def _Refresh(self, *elements):

   717         for element in elements:

   718             self.RefreshFunctions[element]()

   719 

   720     ## Callback function when AUINotebook Page closed with CloseButton

   721     #  @param event AUINotebook Event.

   722     def OnPageClose(self, event):

   723         # Get Selected Tab

   724         selected = event.GetSelection()

   725         if selected >= 0:

   726             # Remove corresponding VariablePanel

   727             window = self.TabsOpened.GetPage(selected)

   728             if not window.IsDebugging():

   729                 self.VariablePanelIndexer.RemoveVariablePanel(window.GetTagName())

   730             # Refresh Tab selection

   731             if self.TabsOpened.GetPageCount() > 0:

   732                 new_index = min(selected, self.TabsOpened.GetPageCount() - 1)

   733                 self.TabsOpened.SetSelection(new_index)

   734                 window = self.TabsOpened.GetPage(selected)

   735                 if not window.IsDebugging():

   736                     self.VariablePanelIndexer.ChangeVariablePanel(window.GetTagName())

   737             # Refresh all window elements that have changed

   738             self._Refresh(TITLE, TOOLBAR, FILEMENU, EDITMENU, DISPLAYMENU)

   739         wx.CallAfter(self.RefreshTabCtrlEvent)

   740         event.Skip()

   741 

   742     def GetCopyBuffer(self):

   743         data = None

   744         if wx.TheClipboard.IsOpened() or wx.TheClipboard.Open():

   745             dataobj = wx.TextDataObject()

   746             if wx.TheClipboard.GetData(dataobj):

   747                 data = dataobj.GetText()

   748         if wx.TheClipboard.IsOpened():

   749             wx.TheClipboard.Close()

   750         return data

   751         

   752     def SetCopyBuffer(self, text):

   753         if wx.TheClipboard.IsOpened() or wx.TheClipboard.Open():

   754             data = wx.TextDataObject()

   755             data.SetText(text)

   756             wx.TheClipboard.SetData(data)

   757             wx.TheClipboard.Flush()

   758         if wx.TheClipboard.IsOpened():

   759             wx.TheClipboard.Close()

   760         self.RefreshEditMenu()

   761 

   762     def GetDrawingMode(self):

   763         return self.DrawingMode

   764 

   765     def RefreshScaling(self):

   766         for i in xrange(self.TabsOpened.GetPageCount()):

   767             editor = self.TabsOpened.GetPage(i)

   768             editor.RefreshScaling()

   769 

   770     def ShowProperties(self):

   771         old_values = self.Controler.GetProjectProperties()

   772         dialog = ProjectDialog(self)

   773         dialog.SetValues(old_values)

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

   775             new_values = dialog.GetValues()

   776             new_values["creationDateTime"] = old_values["creationDateTime"]

   777             if new_values != old_values:

   778                 self.Controler.SetProjectProperties(None, new_values)

   779                 self._Refresh(TITLE, TOOLBAR, FILEMENU, EDITMENU, DISPLAYMENU, 

   780                               TYPESTREE, INSTANCESTREE, SCALING)

   781         dialog.Destroy()

   782 

   783 #-------------------------------------------------------------------------------

   784 #                            Notebook Unified Functions

   785 #-------------------------------------------------------------------------------

   786 

   787     ## Function that generate bitmap for

   788     # for wx.aui.AUINotebook.

   789     #  @param window Panel to display in tab.

   790     #  @param text title for the tab ctrl.

   791     def GenerateBitmap(self, icon1_name, icon2_name = None):

   792         # Find index of bitmap if already created

   793         index = self.TabsImageListIndexes.get((icon1_name, icon2_name), None)

   794         # Return index or bitmap if found

   795         if index is not None:

   796             if USE_AUI:

   797                 return self.TabsImageList.GetBitmap(index)

   798             else:

   799                 return index

   800         if icon2_name is None:

   801             # Bitmap with only one icon

   802             bitmap = wx.Bitmap(os.path.join(CWD, 'Images', '%s.png'%icon1_name))

   803         else:

   804             # Bitmap with two icon

   805             icon1 = wx.Bitmap(os.path.join(CWD, 'Images', '%s.png'%icon1_name))

   806             icon2 = wx.Bitmap(os.path.join(CWD, 'Images', '%s.png'%icon2_name))

   807             

   808             # Calculate bitmap size

   809             width = icon1.GetWidth() + icon2.GetWidth() - 1

   810             height = max(icon1.GetHeight(), icon2.GetHeight())

   811             # Create bitmap with both icons

   812             bitmap = wx.EmptyBitmap(width, height)

   813             dc = wx.MemoryDC()

   814             dc.SelectObject(bitmap)

   815             dc.Clear()

   816             dc.DrawBitmap(icon1, 0, 0)

   817             dc.DrawBitmap(icon2, icon1.GetWidth() - 1, 0)

   818             dc.Destroy()

   819             

   820             # Store bitmap in ImageList

   821             index = self.TabsImageList.Add(bitmap)

   822             # Save bitmap index in ImageList in dictionary

   823             self.TabsImageListIndexes[(icon1_name, icon2_name)] = index

   824         if USE_AUI:

   825             return bitmap

   826         else:

   827             return index

   828     

   829     ## Function that add a tab in Notebook, calling refresh for tab DClick event

   830     # for wx.aui.AUINotebook.

   831     #  @param window Panel to display in tab.

   832     #  @param text title for the tab ctrl.

   833     def AddPage(self, window, text):

   834         self.TabsOpened.AddPage(window, text)

   835         self.RefreshTabCtrlEvent()

   836     

   837     ## Function that fix difference in deleting all tabs between 

   838     # wx.Notebook and wx.aui.AUINotebook.

   839     def DeleteAllPages(self):

   840         if USE_AUI:

   841             for idx in xrange(self.TabsOpened.GetPageCount()):

   842                 self.TabsOpened.DeletePage(0)

   843         else:

   844             self.TabsOpened.DeleteAllPages()

   845         self.RefreshTabCtrlEvent()

   846 

   847     ## Function that fix difference in setting picture on tab between 

   848     # wx.Notebook and wx.aui.AUINotebook.

   849     #  @param idx Tab index.

   850     #  @param bitmap wx.Bitmap to define on tab.

   851     #  @return True if operation succeeded

   852     def SetPageBitmap(self, idx, bitmap):

   853         if USE_AUI:

   854             return self.TabsOpened.SetPageBitmap(idx, bitmap)

   855         else:

   856             return self.TabsOpened.SetPageImage(idx, bitmap)

   857 

   858 #-------------------------------------------------------------------------------

   859 #                         Dialog Message Functions

   860 #-------------------------------------------------------------------------------

   861 

   862     ## Function displaying an Error dialog in PLCOpenEditor.

   863     #  @param message The message to display.

   864     def ShowErrorMessage(self, message):

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

   866         dialog.ShowModal()

   867         dialog.Destroy()

   868 

   869     ## Function displaying an Error dialog in PLCOpenEditor.

   870     #  @return False if closing cancelled.

   871     def CheckSaveBeforeClosing(self, title=_("Close Project")):

   872         if not self.Controler.ProjectIsSaved():

   873             dialog = wx.MessageDialog(self, _("There are changes, do you want to save?"), title, wx.YES_NO|wx.CANCEL|wx.ICON_QUESTION)

   874             answer = dialog.ShowModal()

   875             dialog.Destroy()

   876             if answer == wx.ID_YES:

   877                 self.SaveProject()

   878             elif answer == wx.ID_CANCEL:

   879                 return False

   880         return True

   881 

   882 #-------------------------------------------------------------------------------

   883 #                            File Menu Functions

   884 #-------------------------------------------------------------------------------

   885 

   886     def RefreshFileMenu(self):

   887         pass

   888 

   889     def ResetView(self):

   890         self.DeleteAllPages()

   891         self.VariablePanelIndexer.RemoveAllPanels()

   892         self.TypesTree.DeleteAllItems()

   893         self.InstancesTree.DeleteAllItems()

   894         self.LibraryTree.DeleteAllItems()

   895         self.Controler = None

   896 

   897     def OnCloseTabMenu(self, event):

   898         selected = self.TabsOpened.GetSelection()

   899         if selected >= 0:

   900             window = self.TabsOpened.GetPage(selected)

   901             if not window.IsDebugging():

   902                 self.VariablePanelIndexer.RemoveVariablePanel(window.GetTagName())

   903             self.TabsOpened.DeletePage(selected)

   904             if self.TabsOpened.GetPageCount() > 0:

   905                 new_index = min(selected, self.TabsOpened.GetPageCount() - 1)

   906                 self.TabsOpened.SetSelection(new_index)

   907                 window = self.TabsOpened.GetPage(new_index)

   908                 if not window.IsDebugging():

   909                     self.VariablePanelIndexer.ChangeVariablePanel(window.GetTagName())

   910             self._Refresh(TOOLBAR, FILEMENU, EDITMENU)

   911 

   912     def OnPageSetupMenu(self, event):

   913         dialog = wx.PageSetupDialog(self, self.PageSetupData)

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

   915             self.PageSetupData = wx.PageSetupDialogData(dialog.GetPageSetupData())

   916             self.PrintData = wx.PrintData(self.PageSetupData.GetPrintData())

   917         dialog.Destroy()

   918 

   919     def OnPreviewMenu(self, event):

   920         selected = self.TabsOpened.GetSelection()        

   921         if selected != -1:

   922             window = self.TabsOpened.GetPage(selected)

   923             data = wx.PrintDialogData(self.PrintData)

   924             properties = self.Controler.GetProjectProperties(window.IsDebugging())

   925             page_size = map(int, properties["pageSize"])

   926             margins = (self.PageSetupData.GetMarginTopLeft(), self.PageSetupData.GetMarginBottomRight())

   927             printout = GraphicPrintout(window, page_size, margins, True)

   928             printout2 = GraphicPrintout(window, page_size, margins, True)

   929             preview = wx.PrintPreview(printout, printout2, data)

   930 

   931             if preview.Ok():

   932                 preview_frame = wx.PreviewFrame(preview, self, _("Print preview"))

   933 

   934                 preview_frame.Initialize()

   935                 

   936                 preview_frame.Show(True)

   937 

   938     def OnPrintMenu(self, event):

   939         selected = self.TabsOpened.GetSelection()        

   940         if selected != -1:

   941             window = self.TabsOpened.GetPage(selected)

   942             dialog_data = wx.PrintDialogData(self.PrintData)

   943             dialog_data.SetToPage(1)

   944             properties = self.Controler.GetProjectProperties(window.IsDebugging())

   945             page_size = map(int, properties["pageSize"])

   946             margins = (self.PageSetupData.GetMarginTopLeft(), self.PageSetupData.GetMarginBottomRight())

   947             printer = wx.Printer(dialog_data)

   948             printout = GraphicPrintout(window, page_size, margins)

   949             

   950             if not printer.Print(self, printout, True):

   951                 self.ShowErrorMessage(_("There was a problem printing.\nPerhaps your current printer is not set correctly?"))

   952             printout.Destroy()

   953 

   954     def OnPropertiesMenu(self, event):

   955         self.ShowProperties()

   956 

   957     def OnQuitMenu(self, event):

   958         self.Close()

   959 

   960 #-------------------------------------------------------------------------------

   961 #                            Edit Menu Functions

   962 #-------------------------------------------------------------------------------

   963 

   964     def RefreshEditMenu(self):

   965         if self.Controler is not None:

   966             undo, redo = self.Controler.GetBufferState()

   967             self.EditMenu.Enable(wx.ID_UNDO, undo)

   968             self.EditMenu.Enable(wx.ID_REDO, redo)

   969             self.EditMenu.Enable(ID_PLCOPENEDITOREDITMENUENABLEUNDOREDO, True)

   970             self.EditMenu.Check(ID_PLCOPENEDITOREDITMENUENABLEUNDOREDO, 

   971                             self.Controler.IsProjectBufferEnabled())

   972             self.EditMenu.Enable(wx.ID_ADD, True)

   973             self.EditMenu.Enable(wx.ID_DELETE, True)

   974             if self.TabsOpened.GetPageCount() > 0:

   975                 self.EditMenu.Enable(wx.ID_CUT, True)

   976                 self.EditMenu.Enable(wx.ID_COPY, True)

   977                 if self.GetCopyBuffer() is not None:

   978                     self.EditMenu.Enable(wx.ID_PASTE, True)

   979                 else:

   980                     self.EditMenu.Enable(wx.ID_PASTE, False)

   981                 self.EditMenu.Enable(wx.ID_SELECTALL, True)

   982             else:

   983                 self.EditMenu.Enable(wx.ID_CUT, False)

   984                 self.EditMenu.Enable(wx.ID_COPY, False)

   985                 self.EditMenu.Enable(wx.ID_PASTE, False)

   986                 self.EditMenu.Enable(wx.ID_SELECTALL, False)

   987         else:

   988             self.EditMenu.Enable(wx.ID_UNDO, False)

   989             self.EditMenu.Enable(wx.ID_REDO, False)

   990             self.EditMenu.Enable(ID_PLCOPENEDITOREDITMENUENABLEUNDOREDO, False)

   991             self.EditMenu.Enable(ID_PLCOPENEDITOREDITMENUENABLEUNDOREDO, False)

   992             self.EditMenu.Enable(wx.ID_CUT, False)

   993             self.EditMenu.Enable(wx.ID_COPY, False)

   994             self.EditMenu.Enable(wx.ID_PASTE, False)

   995             self.EditMenu.Enable(wx.ID_SELECTALL, False)

   996             self.EditMenu.Enable(wx.ID_ADD, False)

   997             self.EditMenu.Enable(wx.ID_DELETE, False)

   998     

   999     def CloseTabsWithoutModel(self):

  1000         idxs = range(self.TabsOpened.GetPageCount())

  1001         idxs.reverse()

  1002         for idx in idxs:

  1003             window = self.TabsOpened.GetPage(idx)

  1004             if not window.IsDebugging():

  1005                 tagname = window.GetTagName()

  1006                 if self.Controler.GetEditedElement(tagname) is None:

  1007                     self.VariablePanelIndexer.RemoveVariablePanel(tagname)

  1008                     self.TabsOpened.DeletePage(idx)

  1009 

  1010     def CloseDebugTabs(self):

  1011         if self.EnableDebug:

  1012             idxs = range(self.TabsOpened.GetPageCount())

  1013             idxs.reverse()

  1014             for idx in idxs:

  1015                 window = self.TabsOpened.GetPage(idx)

  1016                 if window.IsDebugging():

  1017                     self.TabsOpened.DeletePage(idx)

  1018             self.DebugVariablePanel.ResetGrid()

  1019 

  1020     def OnUndoMenu(self, event):

  1021         self.Controler.LoadPrevious()

  1022         self.CloseTabsWithoutModel()

  1023         self.RefreshEditor()

  1024         self._Refresh(TITLE, EDITMENU, TYPESTREE, INSTANCESTREE, LIBRARYTREE, 

  1025                       SCALING)

  1026     

  1027     def OnRedoMenu(self, event):

  1028         self.Controler.LoadNext()

  1029         self.CloseTabsWithoutModel()

  1030         self.RefreshEditor()

  1031         self._Refresh(TITLE, EDITMENU, TYPESTREE, INSTANCESTREE, LIBRARYTREE, 

  1032                       SCALING)

  1033     

  1034     def OnEnableUndoRedoMenu(self, event):

  1035         self.Controler.EnableProjectBuffer(event.IsChecked())

  1036         self.RefreshEditMenu()

  1037 

  1038     OnCutMenu = GetShortcutKeyCallbackFunction("Cut")

  1039     OnCopyMenu = GetShortcutKeyCallbackFunction("Copy")

  1040     OnPasteMenu = GetShortcutKeyCallbackFunction("Paste")

  1041 

  1042     def OnSelectAllMenu(self, event):

  1043         control = self.FindFocus()

  1044         if isinstance(control, (Viewer, TextViewer)):

  1045             control.SelectAll()

  1046         elif isinstance(control, wx.TextCtrl):

  1047             control.SetSelection(0, control.GetLastPosition())

  1048         elif isinstance(control, wx.ComboBox):

  1049             control.SetMark(0, control.GetLastPosition() + 1)

  1050     

  1051     DeleteFunctions = {

  1052         ITEM_DATATYPE: GetDeleteElementFunction(PLCControler.ProjectRemoveDataType, check_function=PLCControler.DataTypeIsUsed),

  1053         ITEM_POU: GetDeleteElementFunction(PLCControler.ProjectRemovePou, check_function=PLCControler.PouIsUsed),

  1054         ITEM_TRANSITION: GetDeleteElementFunction(PLCControler.ProjectRemovePouTransition, ITEM_POU),

  1055         ITEM_ACTION: GetDeleteElementFunction(PLCControler.ProjectRemovePouAction, ITEM_POU),

  1056         ITEM_CONFIGURATION: GetDeleteElementFunction(PLCControler.ProjectRemoveConfiguration),

  1057         ITEM_RESOURCE: GetDeleteElementFunction(PLCControler.ProjectRemoveConfigurationResource, ITEM_CONFIGURATION)

  1058     }

  1059     

  1060     def OnDeleteMenu(self, event):

  1061         window = self.FindFocus()

  1062         if window == self.TypesTree or window is None:

  1063             selected = self.TypesTree.GetSelection()

  1064             if selected.IsOk():

  1065                 type = self.TypesTree.GetPyData(selected)

  1066                 function = self.DeleteFunctions.get(type, None)

  1067                 if function is not None:

  1068                     function(self, selected)

  1069                     self.CloseTabsWithoutModel()

  1070                     self._Refresh(TITLE, TOOLBAR, EDITMENU, TYPESTREE, 

  1071                                   INSTANCESTREE, LIBRARYTREE)

  1072         elif isinstance(window, (Viewer, TextViewer)):

  1073             event = wx.KeyEvent(wx.EVT_CHAR._getEvtType())

  1074             event.m_keyCode = wx.WXK_DELETE

  1075             window.ProcessEvent(event)

  1076 

  1077 

  1078 #-------------------------------------------------------------------------------

  1079 #                             Display Menu Functions

  1080 #-------------------------------------------------------------------------------

  1081 

  1082     def RefreshDisplayMenu(self):

  1083         if self.Controler is not None:

  1084             if self.TabsOpened.GetPageCount() > 0:

  1085                 self.DisplayMenu.Enable(wx.ID_REFRESH, True)

  1086                 selected = self.TabsOpened.GetSelection()

  1087                 if selected != -1:

  1088                     window = self.TabsOpened.GetPage(selected)

  1089                     if isinstance(window, Viewer):

  1090                         self.DisplayMenu.Enable(wx.ID_ZOOM_FIT, True)

  1091                         zoommenu = self.DisplayMenu.FindItemById(wx.ID_ZOOM_FIT).GetSubMenu()

  1092                         zoomitem = zoommenu.FindItemByPosition(window.GetScale())

  1093                         zoomitem.Check(True)

  1094                     else:

  1095                         self.DisplayMenu.Enable(wx.ID_ZOOM_FIT, False)

  1096                 else:

  1097                     self.DisplayMenu.Enable(wx.ID_ZOOM_FIT, False)

  1098             else:

  1099                 self.DisplayMenu.Enable(wx.ID_REFRESH, False)

  1100                 self.DisplayMenu.Enable(wx.ID_ZOOM_FIT, False)

  1101             if self.EnableDebug:

  1102                 self.DisplayMenu.Enable(wx.ID_CLEAR, True)

  1103         else:

  1104             self.DisplayMenu.Enable(wx.ID_REFRESH, False)

  1105             if self.EnableDebug:

  1106                 self.DisplayMenu.Enable(wx.ID_CLEAR, False)

  1107             self.DisplayMenu.Enable(wx.ID_ZOOM_FIT, False)

  1108         

  1109     def OnRefreshMenu(self, event):

  1110         self.RefreshEditor()

  1111 

  1112     def OnClearErrorsMenu(self, event):

  1113         self.ClearErrors()

  1114 

  1115     def GenerateZoomFunction(self, idx):

  1116         def ZoomFunction(event):

  1117             selected = self.TabsOpened.GetSelection()

  1118             if selected != -1:

  1119                 window = self.TabsOpened.GetPage(selected)

  1120                 window.SetScale(idx)

  1121                 window.RefreshVisibleElements()

  1122                 window.RefreshScrollBars()

  1123             event.Skip()

  1124         return ZoomFunction

  1125 

  1126 

  1127 #-------------------------------------------------------------------------------

  1128 #                      Project Editor Panels Management Functions

  1129 #-------------------------------------------------------------------------------

  1130     

  1131     def OnPageDragged(self, event):

  1132         wx.CallAfter(self.RefreshTabCtrlEvent)

  1133         event.Skip()

  1134     

  1135     def RefreshTabCtrlEvent(self):