1 #!/usr/bin/env python

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

     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):

   872         if not self.Controler.ProjectIsSaved():

   873             dialog = wx.MessageDialog(self, _("There are changes, do you want to save?"), _("Close Application"), 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         event.Skip()

   912 

   913     def OnPageSetupMenu(self, event):

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

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

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

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

   918         dialog.Destroy()

   919         event.Skip()

   920 

   921     def OnPreviewMenu(self, event):

   922         selected = self.TabsOpened.GetSelection()        

   923         if selected != -1:

   924             window = self.TabsOpened.GetPage(selected)

   925             data = wx.PrintDialogData(self.PrintData)

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

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

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

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

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

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

   932 

   933             if preview.Ok():

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

   935 

   936                 preview_frame.Initialize()

   937                 

   938                 preview_frame.Show(True)

   939         event.Skip()

   940 

   941     def OnPrintMenu(self, event):

   942         selected = self.TabsOpened.GetSelection()        

   943         if selected != -1:

   944             window = self.TabsOpened.GetPage(selected)

   945             dialog_data = wx.PrintDialogData(self.PrintData)

   946             dialog_data.SetToPage(1)

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

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

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

   950             printer = wx.Printer(dialog_data)

   951             printout = GraphicPrintout(window, page_size, margins)

   952             

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

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

   955             printout.Destroy()

   956         event.Skip()

   957 

   958     def OnPropertiesMenu(self, event):

   959         self.ShowProperties()

   960         event.Skip()

   961 

   962     def OnQuitMenu(self, event):

   963         self.Close()

   964         # don't call event.Skip() here or it will attempt to close the

   965         # frame twice for some reason

   966 

   967 #-------------------------------------------------------------------------------

   968 #                            Edit Menu Functions

   969 #-------------------------------------------------------------------------------

   970 

   971     def RefreshEditMenu(self):

   972         if self.Controler is not None:

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

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

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

   976             self.EditMenu.Enable(ID_PLCOPENEDITOREDITMENUENABLEUNDOREDO, True)

   977             self.EditMenu.Check(ID_PLCOPENEDITOREDITMENUENABLEUNDOREDO, 

   978                             self.Controler.IsProjectBufferEnabled())

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

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

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

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

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

   984                 if self.GetCopyBuffer() is not None:

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

   986                 else:

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

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

   989             else:

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

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

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

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

   994         else:

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

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

   997             self.EditMenu.Enable(ID_PLCOPENEDITOREDITMENUENABLEUNDOREDO, False)

   998             self.EditMenu.Enable(ID_PLCOPENEDITOREDITMENUENABLEUNDOREDO, False)

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

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

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

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

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

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

  1005     

  1006     def CloseTabsWithoutModel(self):

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

  1008         idxs.reverse()

  1009         for idx in idxs:

  1010             window = self.TabsOpened.GetPage(idx)

  1011             if not window.IsDebugging():

  1012                 tagname = window.GetTagName()

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

  1014                     self.VariablePanelIndexer.RemoveVariablePanel(tagname)

  1015                     self.TabsOpened.DeletePage(idx)

  1016 

  1017     def CloseDebugTabs(self):

  1018         if self.EnableDebug:

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

  1020             idxs.reverse()

  1021             for idx in idxs:

  1022                 window = self.TabsOpened.GetPage(idx)

  1023                 if window.IsDebugging():

  1024                     self.TabsOpened.DeletePage(idx)

  1025             self.DebugVariablePanel.ResetGrid()

  1026 

  1027     def OnUndoMenu(self, event):

  1028         self.Controler.LoadPrevious()

  1029         self.CloseTabsWithoutModel()

  1030         self.RefreshEditor()

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

  1032                       SCALING)

  1033         event.Skip()

  1034     

  1035     def OnRedoMenu(self, event):

  1036         self.Controler.LoadNext()

  1037         self.CloseTabsWithoutModel()

  1038         self.RefreshEditor()

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

  1040                       SCALING)

  1041         event.Skip()

  1042     

  1043     def OnEnableUndoRedoMenu(self, event):

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

  1045         self.RefreshEditMenu()

  1046         event.Skip()

  1047 

  1048     OnCutMenu = GetShortcutKeyCallbackFunction("Cut")

  1049     OnCopyMenu = GetShortcutKeyCallbackFunction("Copy")

  1050     OnPasteMenu = GetShortcutKeyCallbackFunction("Paste")

  1051 

  1052     def OnSelectAllMenu(self, event):

  1053         control = self.FindFocus()

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

  1055             control.SelectAll()

  1056         elif isinstance(control, wx.TextCtrl):

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

  1058         elif isinstance(control, wx.ComboBox):

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

  1060         event.Skip()

  1061     

  1062     DeleteFunctions = {

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

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

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

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

  1067         ITEM_CONFIGURATION: GetDeleteElementFunction(PLCControler.ProjectRemoveConfiguration),

  1068         ITEM_RESOURCE: GetDeleteElementFunction(PLCControler.ProjectRemoveConfigurationResource, ITEM_CONFIGURATION)

  1069     }

  1070     

  1071     def OnDeleteMenu(self, event):

  1072         window = self.FindFocus()

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

  1074             selected = self.TypesTree.GetSelection()

  1075             if selected.IsOk():

  1076                 type = self.TypesTree.GetPyData(selected)

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

  1078                 if function is not None:

  1079                     function(self, selected)

  1080                     self.CloseTabsWithoutModel()

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

  1082                                   INSTANCESTREE, LIBRARYTREE)

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

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

  1085             event.m_keyCode = wx.WXK_DELETE

  1086             window.ProcessEvent(event)

  1087         event.Skip()

  1088 

  1089 

  1090 #-------------------------------------------------------------------------------

  1091 #                             Display Menu Functions

  1092 #-------------------------------------------------------------------------------

  1093 

  1094     def RefreshDisplayMenu(self):

  1095         if self.Controler is not None:

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

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

  1098                 selected = self.TabsOpened.GetSelection()

  1099                 if selected != -1:

  1100                     window = self.TabsOpened.GetPage(selected)

  1101                     if isinstance(window, Viewer):

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

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

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

  1105                         zoomitem.Check(True)

  1106                     else:

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

  1108                 else:

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

  1110             else:

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

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

  1113             if self.EnableDebug:

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

  1115         else:

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

  1117             if self.EnableDebug:

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

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

  1120         

  1121     def OnRefreshMenu(self, event):

  1122         self.RefreshEditor()

  1123         event.Skip()

  1124 

  1125     def OnClearErrorsMenu(self, event):

  1126         self.ClearErrors()

  1127         event.Skip()

  1128 

  1129     def GenerateZoomFunction(self, idx):

  1130         def ZoomFunction(event):

  1131             selected = self.TabsOpened.GetSelection()

  1132             if selected != -1:

  1133                 window = self.TabsOpened.GetPage(selected)

  1134                 window.SetScale(idx)

  1135                 window.RefreshVisibleElements()