Mercurial Mercurial > plcopeneditor_history / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Viewer.py
changeset 90 2245e8776086
parent 80 c798a68c5560
child 91 e8e9ddeed76c
equal deleted inserted replaced
89:a6ff2b3fcc25 90:2245e8776086 
    47 
    47 
    48 class ViewerDropTarget(wx.TextDropTarget):
 
    48 class ViewerDropTarget(wx.TextDropTarget):
 
    49     
    49     
    50     def __init__(self, parent):
 
    50     def __init__(self, parent):
 
    51         wx.TextDropTarget.__init__(self)
 
    51         wx.TextDropTarget.__init__(self)
 
    52         self.Parent = parent
 
    52         self.ParentWindow = parent
 
    53     
    53     
    54     def OnDropText(self, x, y, data):
 
    54     def OnDropText(self, x, y, data):
 
    55         values = eval(data)
 
    55         values = eval(data)
 
    56         if values[1] in ["function", "functionBlock", "program"]:
 
    56         if values[1] in ["function", "functionBlock", "program"]:
 
    57             id = self.Parent.GetNewId()
 
    57             id = self.ParentWindow.GetNewId()
 
    58             block = FBD_Block(self.Parent, values[0], values[2], id)
 
    58             block = FBD_Block(self.ParentWindow, values[0], values[2], id)
 
    59             block.SetPosition(x, y)
 
    59             block.SetPosition(x, y)
 
    60             width, height = block.GetMinSize()
 
    60             width, height = block.GetMinSize()
 
    61             block.SetSize(width, height)
 
    61             block.SetSize(width, height)
 
    62             self.Parent.AddBlock(block)
 
    62             self.ParentWindow.AddBlock(block)
 
    63             self.Parent.Controler.AddCurrentElementEditingBlock(id)
 
    63             self.ParentWindow.Controler.AddCurrentElementEditingBlock(id)
 
    64             self.Parent.RefreshBlockModel(block)
 
    64             self.ParentWindow.RefreshBlockModel(block)
 
    65             self.Parent.RefreshScrollBars()
 
    65             self.ParentWindow.RefreshScrollBars()
 
    66             self.Parent.Refresh()
 
    66             self.ParentWindow.Update()
 
    67         elif values[1] != "location":
 
    67         elif values[1] != "location":
 
    68             id = self.Parent.GetNewId()
 
    68             id = self.ParentWindow.GetNewId()
 
    69             if values[1] == "Output":
 
    69             if values[1] == "Output":
 
    70                 var_type = OUTPUT
 
    70                 var_type = OUTPUT
 
    71             elif values[1] == "InOut":
 
    71             elif values[1] == "InOut":
 
    72                 var_type = INPUT
 
    72                 var_type = INPUT
 
    73             else:
 
    73             else:
 
    74                 var_type = INPUT
 
    74                 var_type = INPUT
 
    75             variable = FBD_Variable(self.Parent, var_type, values[0], values[2], id)
 
    75             variable = FBD_Variable(self.ParentWindow, var_type, values[0], values[2], id)
 
    76             variable.SetPosition(x, y)
 
    76             variable.SetPosition(x, y)
 
    77             width, height = variable.GetMinSize()
 
    77             width, height = variable.GetMinSize()
 
    78             variable.SetSize(width, height)
 
    78             variable.SetSize(width, height)
 
    79             self.Parent.AddBlock(variable)
 
    79             self.ParentWindow.AddBlock(variable)
 
    80             self.Parent.Controler.AddCurrentElementEditingVariable(id, var_type)
 
    80             self.ParentWindow.Controler.AddCurrentElementEditingVariable(id, var_type)
 
    81             self.Parent.RefreshVariableModel(variable)
 
    81             self.ParentWindow.RefreshVariableModel(variable)
 
    82             self.Parent.RefreshScrollBars()
 
    82             self.ParentWindow.RefreshScrollBars()
 
    83             self.Parent.Refresh()
 
    83             self.ParentWindow.Update()
 
    84             
    84             
    85 
    85 
    86 """
 
    86 """
 
    87 Class that implements a Viewer based on a wx.ScrolledWindow for drawing and 
    87 Class that implements a Viewer based on a wx.ScrolledWindow for drawing and 
    88 manipulating graphic elements
 
    88 manipulating graphic elements
 
   159         
   159         
   160         # Initialize Viewer mode to Selection mode
 
   160         # Initialize Viewer mode to Selection mode
 
   161         self.Mode = MODE_SELECTION
 
   161         self.Mode = MODE_SELECTION
 
   162         self.SavedMode = False
 
   162         self.SavedMode = False
 
   163         
   163         
   164         self.Parent = window
 
   164         self.ParentWindow = window
 
   165         self.Controler = controler
 
   165         self.Controler = controler
 
   166         
   166         
   167         self.SetDropTarget(ViewerDropTarget(self))
 
   167         self.SetDropTarget(ViewerDropTarget(self))
 
   168         
   168         
   169         # Link Viewer event to corresponding methods
 
   169         # Link Viewer event to corresponding methods
 
   172         self.Bind(wx.EVT_LEFT_UP, self.OnViewerLeftUp)
 
   172         self.Bind(wx.EVT_LEFT_UP, self.OnViewerLeftUp)
 
   173         self.Bind(wx.EVT_LEFT_DCLICK, self.OnViewerLeftDClick)
 
   173         self.Bind(wx.EVT_LEFT_DCLICK, self.OnViewerLeftDClick)
 
   174         self.Bind(wx.EVT_RIGHT_UP, self.OnViewerRightUp)
 
   174         self.Bind(wx.EVT_RIGHT_UP, self.OnViewerRightUp)
 
   175         self.Bind(wx.EVT_MOTION, self.OnViewerMotion)
 
   175         self.Bind(wx.EVT_MOTION, self.OnViewerMotion)
 
   176         self.Bind(wx.EVT_CHAR, self.OnChar)
 
   176         self.Bind(wx.EVT_CHAR, self.OnChar)
 
   177         self.Bind(wx.EVT_SCROLLWIN, self.OnMoveWindow)
 
   177         if wx.VERSION < (2, 7, 0):
 
   178         self.Bind(wx.EVT_SIZE, self.OnMoveWindow)
 
   178             self.Bind(wx.EVT_SCROLLWIN, self.OnMoveWindow)
 
       
   179             self.Bind(wx.EVT_SIZE, self.OnMoveWindow)
 
   179     
   180     
   180     # Returns a new id
 
   181     # Returns a new id
 
   181     def GetNewId(self):
 
   182     def GetNewId(self):
 
   182         self.current_id += 1
 
   183         self.current_id += 1
 
   183         return self.current_id
 
   184         return self.current_id
 
   184     
   185     
   185     # Destructor
 
   186     # Destructor
 
   186     def __del__(self):
 
   187     def __del__(self):
 
   187         self.ResetView()
 
   188         self.ResetView()
 
   188 
   189 
   189     def GetLogicalDC(self):
 
   190     def GetLogicalDC(self, buffered=False):
 
   190         dc = wx.ClientDC(self)
 
   191         if buffered:
 
       
   192             dc = wx.BufferedPaintDC(self)
 
       
   193         else:
 
       
   194             dc = wx.ClientDC(self)
 
       
   195         dc.SetFont(wx.NORMAL_FONT)
 
   191         self.DoPrepareDC(dc)
 
   196         self.DoPrepareDC(dc)
 
   192         return dc
 
   197         return dc
 
   193 
   198 
   194 #-------------------------------------------------------------------------------
 
   199 #-------------------------------------------------------------------------------
 
   195 #                         Element management functions
 
   200 #                         Element management functions
 
   263             self.SavedMode = True
 
   268             self.SavedMode = True
 
   264         # Reset selection
 
   269         # Reset selection
 
   265         if self.Mode != MODE_SELECTION and self.SelectedElement:
 
   270         if self.Mode != MODE_SELECTION and self.SelectedElement:
 
   266             self.SelectedElement.SetSelected(False)
 
   271             self.SelectedElement.SetSelected(False)
 
   267             self.SelectedElement = None
 
   272             self.SelectedElement = None
 
   268             self.Refresh()
 
   273             self.Refresh(False)
 
   269     
   274     
   270     # Return current drawing mode
 
   275     # Return current drawing mode
 
   271     def GetDrawingMode(self):
 
   276     def GetDrawingMode(self):
 
   272         return self.Parent.GetDrawingMode()
 
   277         return self.ParentWindow.GetDrawingMode()
 
   273     
   278     
   274     # Buffer the last model state
 
   279     # Buffer the last model state
 
   275     def RefreshBuffer(self):
 
   280     def RefreshBuffer(self):
 
   276         self.Controler.BufferProject()
 
   281         self.Controler.BufferProject()
 
   277         self.Parent.RefreshTitle()
 
   282         self.ParentWindow.RefreshTitle()
 
   278         self.Parent.RefreshEditMenu()
 
   283         self.ParentWindow.RefreshEditMenu()
 
   279 
   284 
   280 #-------------------------------------------------------------------------------
 
   285 #-------------------------------------------------------------------------------
 
   281 #                          Refresh functions
 
   286 #                          Refresh functions
 
   282 #-------------------------------------------------------------------------------
 
   287 #-------------------------------------------------------------------------------
 
   283 
   288 
   296         while instance:
 
   301         while instance:
 
   297             instance = self.Controler.GetCurrentElementEditingInstanceInfos(exclude=ids)
 
   302             instance = self.Controler.GetCurrentElementEditingInstanceInfos(exclude=ids)
 
   298             if instance:
 
   303             if instance:
 
   299                 self.loadInstance(instance, ids)
 
   304                 self.loadInstance(instance, ids)
 
   300         self.RefreshScrollBars()
 
   305         self.RefreshScrollBars()
 
   301         self.Refresh()
 
   306         self.Refresh(False)
 
   302     
   307     
   303     def RefreshScrollBars(self):
 
   308     def RefreshScrollBars(self):
 
   304         xstart, ystart = self.GetViewStart()
 
   309         xstart, ystart = self.GetViewStart()
 
   305         window_size = self.GetClientSize()
 
   310         window_size = self.GetClientSize()
 
   306         maxx = maxy = 0
 
   311         maxx = maxy = 0
 
   516             self.AddBlock(actionBlock)
 
   521             self.AddBlock(actionBlock)
 
   517             connector = actionBlock.GetConnector()
 
   522             connector = actionBlock.GetConnector()
 
   518             connector.SetPosition(wx.Point(*instance["connector"]["position"]))
 
   523             connector.SetPosition(wx.Point(*instance["connector"]["position"]))
 
   519             self.CreateWires(connector, instance["connector"]["links"], ids)
 
   524             self.CreateWires(connector, instance["connector"]["links"], ids)
 
   520         else:
 
   525         else:
 
       
   526             connectors = {"inputs" : [], "outputs" : []}
 
       
   527             for input in instance["connectors"]["inputs"]:
 
       
   528                 if input["negated"]:
 
       
   529                     connectors["inputs"].append((input["name"], None, "negated"))
 
       
   530                 elif input["edge"]:
 
       
   531                     connectors["inputs"].append((input["name"], None, input["edge"]))
 
       
   532                 else:
 
       
   533                     connectors["inputs"].append((input["name"], None, "none"))
 
       
   534             for output in instance["connectors"]["outputs"]:
 
       
   535                 if output["negated"]:
 
       
   536                     connectors["outputs"].append((output["name"], None, "negated"))
 
       
   537                 elif output["edge"]:
 
       
   538                     connectors["outputs"].append((output["name"], None, output["edge"]))
 
       
   539                 else:
 
       
   540                     connectors["outputs"].append((output["name"], None, "none"))
 
   521             if instance["name"] != None:
 
   541             if instance["name"] != None:
 
   522                 block = FBD_Block(self, instance["type"], instance["name"], instance["id"], len(instance["connectors"]["inputs"]))
 
   542                 block = FBD_Block(self, instance["type"], instance["name"], instance["id"], len(instance["connectors"]["inputs"]), connectors=connectors)
 
   523             else:
 
   543             else:
 
   524                 block = FBD_Block(self, instance["type"], "", instance["id"], len(instance["connectors"]["inputs"]))
 
   544                 block = FBD_Block(self, instance["type"], "", instance["id"], len(instance["connectors"]["inputs"]), connectors=connectors)
 
   525             block.SetPosition(instance["x"], instance["y"])
 
   545             block.SetPosition(instance["x"], instance["y"])
 
   526             block.SetSize(instance["width"], instance["height"])
 
   546             block.SetSize(instance["width"], instance["height"])
 
   527             self.AddBlock(block)
 
   547             self.AddBlock(block)
 
   528             connectors = block.GetConnectors()
 
   548             connectors = block.GetConnectors()
 
   529             for i, input_connector in enumerate(instance["connectors"]["inputs"]):
 
   549             for i, input_connector in enumerate(instance["connectors"]["inputs"]):
 
   682         self.ContextualMenu.FindItemByPosition(5).Enable(False)
 
   702         self.ContextualMenu.FindItemByPosition(5).Enable(False)
 
   683         self.ContextualMenu.FindItemByPosition(6).Enable(False)
 
   703         self.ContextualMenu.FindItemByPosition(6).Enable(False)
 
   684         self.ContextualMenu.FindItemByPosition(8).Enable(False)
 
   704         self.ContextualMenu.FindItemByPosition(8).Enable(False)
 
   685         self.ContextualMenu.FindItemByPosition(9).Enable(False)
 
   705         self.ContextualMenu.FindItemByPosition(9).Enable(False)
 
   686         self.PopupMenu(self.ContextualMenu)
 
   706         self.PopupMenu(self.ContextualMenu)
 
   687 
       
   688     def EditCommentContent(self, comment):
 
       
   689         dialog = wx.TextEntryDialog(self.Parent, "Edit comment", "Please enter comment text", comment.GetContent(), wx.OK|wx.CANCEL|wx.TE_MULTILINE)
 
       
   690         if dialog.ShowModal() == wx.ID_OK:
 
       
   691             value = dialog.GetValue()
 
       
   692             comment.SetContent(value)
 
       
   693             infos = {"content" : value}
 
       
   694             infos["width"], infos["height"] = comment.GetSize()
 
       
   695             self.Controler.SetCurrentElementEditingCommentInfos(comment.GetId(), infos)
 
       
   696             self.Refresh()
 
       
   697         dialog.Destroy()
 
       
   698 
   707 
   699 #-------------------------------------------------------------------------------
 
   708 #-------------------------------------------------------------------------------
 
   700 #                            Menu items functions
 
   709 #                            Menu items functions
 
   701 #-------------------------------------------------------------------------------
 
   710 #-------------------------------------------------------------------------------
 
   702 
   711 
   781             else:
 
   790             else:
 
   782                 element = self.FindElement(pos)
 
   791                 element = self.FindElement(pos)
 
   783                 if self.SelectedElement and self.SelectedElement != element:
 
   792                 if self.SelectedElement and self.SelectedElement != element:
 
   784                     self.SelectedElement.SetSelected(False)
 
   793                     self.SelectedElement.SetSelected(False)
 
   785                     self.SelectedElement = None
 
   794                     self.SelectedElement = None
 
   786                     self.Refresh()
 
   795                     self.Refresh(False)
 
   787                 if element:
 
   796                 if element:
 
   788                     self.SelectedElement = element
 
   797                     self.SelectedElement = element
 
   789                     self.SelectedElement.OnLeftDown(event, dc, self.Scaling)
 
   798                     self.SelectedElement.OnLeftDown(event, dc, self.Scaling)
 
   790                     self.Refresh()
 
   799                     self.Refresh(False)
 
   791                 else:
 
   800                 else:
 
   792                     self.rubberBand.Reset()
 
   801                     self.rubberBand.Reset()
 
   793                     self.rubberBand.OnLeftDown(event, dc, self.Scaling)
 
   802                     self.rubberBand.OnLeftDown(event, dc, self.Scaling)
 
   794         elif self.Mode in [MODE_BLOCK, MODE_VARIABLE, MODE_CONNECTION, MODE_COMMENT, 
   803         elif self.Mode in [MODE_BLOCK, MODE_VARIABLE, MODE_CONNECTION, MODE_COMMENT, 
   795                            MODE_CONTACT, MODE_COIL, MODE_POWERRAIL, MODE_INITIALSTEP, 
   804                            MODE_CONTACT, MODE_COIL, MODE_POWERRAIL, MODE_INITIALSTEP, 
   813                     self.SelectedElement.SetSelected(False)
 
   822                     self.SelectedElement.SetSelected(False)
 
   814                 self.SelectedElement = wire
 
   823                 self.SelectedElement = wire
 
   815             elif self.SelectedElement:
 
   824             elif self.SelectedElement:
 
   816                 self.SelectedElement.SetSelected(False)
 
   825                 self.SelectedElement.SetSelected(False)
 
   817                 self.SelectedElement = None
 
   826                 self.SelectedElement = None
 
   818             self.Refresh()
 
   827             self.Refresh(False)
 
   819         event.Skip()
 
   828         event.Skip()
 
   820 
   829 
   821     def OnViewerLeftUp(self, event):
 
   830     def OnViewerLeftUp(self, event):
 
   822         if self.rubberBand.IsShown():
 
   831         if self.rubberBand.IsShown():
 
   823             if self.Mode == MODE_SELECTION:
 
   832             if self.Mode == MODE_SELECTION:
 
   824                 elements = self.SearchElements(self.rubberBand.GetCurrentExtent())
 
   833                 elements = self.SearchElements(self.rubberBand.GetCurrentExtent())
 
   825                 self.rubberBand.OnLeftUp(event, self.GetLogicalDC(), self.Scaling)
 
   834                 self.rubberBand.OnLeftUp(event, self.GetLogicalDC(), self.Scaling)
 
   826                 if len(elements) == 1:
 
   835                 if len(elements) == 1:
 
   827                     self.SelectedElement = elements[0]
 
   836                     self.SelectedElement = elements[0]
 
   828                     self.SelectedElement.SetSelected(True)
 
   837                     self.SelectedElement.SetSelected(True)
 
   829                     self.Refresh()
 
   838                     self.Refresh(False)
 
   830                 elif len(elements) > 1:
 
   839                 elif len(elements) > 1:
 
   831                     self.SelectedElement = Graphic_Group(self)
 
   840                     self.SelectedElement = Graphic_Group(self)
 
   832                     self.SelectedElement.SetElements(elements)
 
   841                     self.SelectedElement.SetElements(elements)
 
   833                     self.SelectedElement.SetSelected(True)
 
   842                     self.SelectedElement.SetSelected(True)
 
   834                     self.Refresh()
 
   843                     self.Refresh(False)
 
   835             else:
 
   844             else:
 
   836                 bbox = self.rubberBand.GetCurrentExtent()
 
   845                 bbox = self.rubberBand.GetCurrentExtent()
 
   837                 self.rubberBand.OnLeftUp(event, self.GetLogicalDC(), self.Scaling)                
   846                 self.rubberBand.OnLeftUp(event, self.GetLogicalDC(), self.Scaling)                
   838                 if self.Mode == MODE_BLOCK:
 
   847                 if self.Mode == MODE_BLOCK:
 
   839                     wx.CallAfter(self.AddNewBlock, bbox)
 
   848                     wx.CallAfter(self.AddNewBlock, bbox)
 
   862                 elif self.Mode == MODE_ACTION:
 
   871                 elif self.Mode == MODE_ACTION:
 
   863                     wx.CallAfter(self.AddNewActionBlock, bbox)
 
   872                     wx.CallAfter(self.AddNewActionBlock, bbox)
 
   864         elif self.Mode == MODE_SELECTION and self.SelectedElement:
 
   873         elif self.Mode == MODE_SELECTION and self.SelectedElement:
 
   865             self.SelectedElement.OnLeftUp(event, self.GetLogicalDC(), self.Scaling)
 
   874             self.SelectedElement.OnLeftUp(event, self.GetLogicalDC(), self.Scaling)
 
   866             wx.CallAfter(self.SetCursor, wx.NullCursor)
 
   875             wx.CallAfter(self.SetCursor, wx.NullCursor)
 
   867             self.ReleaseMouse()
 
   876             self.Refresh(False)
 
   868             self.Refresh()
 
       
   869         elif self.Mode == MODE_WIRE and self.SelectedElement:
 
   877         elif self.Mode == MODE_WIRE and self.SelectedElement:
 
   870             if self.SelectedElement.EndConnected != None:
 
   878             if self.SelectedElement.EndConnected != None:
 
   871                 self.SelectedElement.ResetPoints()
 
   879                 self.SelectedElement.ResetPoints()
 
   872                 self.SelectedElement.OnMotion(event, self.GetLogicalDC(), self.Scaling)
 
   880                 self.SelectedElement.OnMotion(event, self.GetLogicalDC(), self.Scaling)
 
   873                 self.SelectedElement.GeneratePoints()
 
   881                 self.SelectedElement.GeneratePoints()
 
   875                 self.SelectedElement.SetSelected(True)
 
   883                 self.SelectedElement.SetSelected(True)
 
   876                 self.RefreshBuffer()
 
   884                 self.RefreshBuffer()
 
   877             else:
 
   885             else:
 
   878                 self.SelectedElement.Delete()
 
   886                 self.SelectedElement.Delete()
 
   879                 self.SelectedElement = None
 
   887                 self.SelectedElement = None
 
   880             self.Refresh()
 
   888             self.Refresh(False)
 
   881         if not self.SavedMode:
 
   889         if not self.SavedMode:
 
   882             wx.CallAfter(self.Parent.ResetCurrentMode)
 
   890             wx.CallAfter(self.ParentWindow.ResetCurrentMode)
 
   883         event.Skip()
 
   891         event.Skip()
 
   884     
   892     
   885     def OnViewerRightUp(self, event):
 
   893     def OnViewerRightUp(self, event):
 
   886         dc = self.GetLogicalDC()
 
   894         dc = self.GetLogicalDC()
 
   887         pos = event.GetLogicalPosition(dc)
 
   895         pos = event.GetLogicalPosition(dc)
 
   892             self.SelectedElement = element
 
   900             self.SelectedElement = element
 
   893             self.SelectedElement.SetSelected(True)
 
   901             self.SelectedElement.SetSelected(True)
 
   894             self.SelectedElement.OnRightUp(event, self.GetLogicalDC(), self.Scaling)
 
   902             self.SelectedElement.OnRightUp(event, self.GetLogicalDC(), self.Scaling)
 
   895             wx.CallAfter(self.SetCursor, wx.NullCursor)
 
   903             wx.CallAfter(self.SetCursor, wx.NullCursor)
 
   896             self.ReleaseMouse()
 
   904             self.ReleaseMouse()
 
   897             self.Refresh()
 
   905             self.Refresh(False)
 
   898         event.Skip()
 
   906         event.Skip()
 
   899     
   907     
   900     def OnViewerLeftDClick(self, event):
 
   908     def OnViewerLeftDClick(self, event):
 
   901         if self.Mode == MODE_SELECTION and self.SelectedElement:
 
   909         if self.Mode == MODE_SELECTION and self.SelectedElement:
 
   902             self.SelectedElement.OnLeftDClick(event, self.GetLogicalDC(), self.Scaling)
 
   910             self.SelectedElement.OnLeftDClick(event, self.GetLogicalDC(), self.Scaling)
 
   903             self.Refresh()
 
   911             self.Refresh(False)
 
   904         event.Skip()
 
   912         event.Skip()
 
   905     
   913     
   906     def OnViewerMotion(self, event):
 
   914     def OnViewerMotion(self, event):
 
   907         if self.rubberBand.IsShown():
 
   915         if self.rubberBand.IsShown():
 
   908             self.rubberBand.OnMotion(event, self.GetLogicalDC(), self.Scaling)
 
   916             self.rubberBand.OnMotion(event, self.GetLogicalDC(), self.Scaling)
 
   909         elif self.Mode == MODE_SELECTION and self.SelectedElement:
 
   917         elif self.Mode == MODE_SELECTION and self.SelectedElement:
 
   910             self.SelectedElement.OnMotion(event, self.GetLogicalDC(), self.Scaling)
 
   918             if self.SelectedElement.OnMotion(event, self.GetLogicalDC(), self.Scaling):
 
   911             self.Refresh()
 
   919                 self.Refresh(False)
 
   912         elif self.Mode == MODE_WIRE and self.SelectedElement:
 
   920         elif self.Mode == MODE_WIRE and self.SelectedElement:
 
   913             dc = self.GetLogicalDC()
 
   921             dc = self.GetLogicalDC()
 
   914             pos = GetScaledEventPosition(event, dc, self.Scaling)
 
   922             pos = GetScaledEventPosition(event, dc, self.Scaling)
 
   915             connector = self.FindBlockConnector(pos, False)
 
   923             connector = self.FindBlockConnector(pos, False)
 
   916             if not connector or self.SelectedElement.EndConnected == None:
 
   924             if not connector or self.SelectedElement.EndConnected == None:
 
   917                 self.SelectedElement.ResetPoints()
 
   925                 self.SelectedElement.ResetPoints()
 
   918                 self.SelectedElement.OnMotion(event, dc, self.Scaling)
 
   926                 self.SelectedElement.OnMotion(event, dc, self.Scaling)
 
   919                 self.SelectedElement.GeneratePoints()
 
   927                 self.SelectedElement.GeneratePoints()
 
   920                 self.Refresh()
 
   928                 self.Refresh(False)
 
   921         event.Skip()
 
   929         event.Skip()
 
   922 
   930 
   923     def UpdateScrollPos(self, event):
 
   931     def UpdateScrollPos(self, event):
 
   924         if (event.Dragging() and self.SelectedElement) or self.rubberBand.IsShown():
 
   932         if (event.Dragging() and self.SelectedElement) or self.rubberBand.IsShown():
 
   925             position = event.GetPosition()
 
   933             position = event.GetPosition()
 
   955             self.SelectedElement.Clean()
 
   963             self.SelectedElement.Clean()
 
   956             self.SelectedElement.Delete()
 
   964             self.SelectedElement.Delete()
 
   957             self.SelectedElement = None
 
   965             self.SelectedElement = None
 
   958             self.RefreshBuffer()
 
   966             self.RefreshBuffer()
 
   959             self.RefreshScrollBars()
 
   967             self.RefreshScrollBars()
 
   960             self.Refresh()
 
   968             self.Refresh(False)
 
   961         elif keycode == wx.WXK_LEFT:
 
   969         elif keycode == wx.WXK_LEFT:
 
   962             if event.ControlDown() and event.ShiftDown():
 
   970             if event.ControlDown() and event.ShiftDown():
 
   963                 self.Scroll(0, ypos)
 
   971                 self.Scroll(0, ypos)
 
   964             elif event.ControlDown():
 
   972             elif event.ControlDown():
 
   965                 self.Scroll(max(0, xpos - 1), ypos)
 
   973                 self.Scroll(max(0, xpos - 1), ypos)
 
   966             elif self.SelectedElement:
 
   974             elif self.SelectedElement:
 
   967                 self.SelectedElement.Move(-scaling[0], 0)
 
   975                 self.SelectedElement.Move(-scaling[0], 0)
 
   968                 self.SelectedElement.RefreshModel()
 
   976                 self.SelectedElement.RefreshModel()
 
   969                 self.RefreshBuffer()
 
   977                 self.RefreshBuffer()
 
   970                 self.RefreshScrollBars()
 
   978                 self.RefreshScrollBars()
 
   971                 self.Refresh()
 
   979                 self.Refresh(False)
 
   972         elif keycode == wx.WXK_RIGHT:
 
   980         elif keycode == wx.WXK_RIGHT:
 
   973             if event.ControlDown() and event.ShiftDown():
 
   981             if event.ControlDown() and event.ShiftDown():
 
   974                 self.Scroll(xmax, ypos)
 
   982                 self.Scroll(xmax, ypos)
 
   975             elif event.ControlDown():
 
   983             elif event.ControlDown():
 
   976                 self.Scroll(min(xpos + 1, xmax), ypos)
 
   984                 self.Scroll(min(xpos + 1, xmax), ypos)
 
   977             elif self.SelectedElement:
 
   985             elif self.SelectedElement:
 
   978                 self.SelectedElement.Move(scaling[0], 0)
 
   986                 self.SelectedElement.Move(scaling[0], 0)
 
   979                 self.SelectedElement.RefreshModel()
 
   987                 self.SelectedElement.RefreshModel()
 
   980                 self.RefreshBuffer()
 
   988                 self.RefreshBuffer()
 
   981                 self.RefreshScrollBars()
 
   989                 self.RefreshScrollBars()
 
   982                 self.Refresh()
 
   990                 self.Refresh(False)
 
   983         elif keycode == wx.WXK_UP:
 
   991         elif keycode == wx.WXK_UP:
 
   984             if event.ControlDown() and event.ShiftDown():
 
   992             if event.ControlDown() and event.ShiftDown():
 
   985                 self.Scroll(xpos, 0)
 
   993                 self.Scroll(xpos, 0)
 
   986             elif event.ControlDown():
 
   994             elif event.ControlDown():
 
   987                 self.Scroll(xpos, max(0, ypos - 1))
 
   995                 self.Scroll(xpos, max(0, ypos - 1))
 
   988             elif self.SelectedElement:
 
   996             elif self.SelectedElement:
 
   989                 self.SelectedElement.Move(0, -scaling[1])
 
   997                 self.SelectedElement.Move(0, -scaling[1])
 
   990                 self.SelectedElement.RefreshModel()
 
   998                 self.SelectedElement.RefreshModel()
 
   991                 self.RefreshBuffer()
 
   999                 self.RefreshBuffer()
 
   992                 self.RefreshScrollBars()
 
  1000                 self.RefreshScrollBars()
 
   993                 self.Refresh()
 
  1001                 self.Refresh(False)
 
   994         elif keycode == wx.WXK_DOWN:
 
  1002         elif keycode == wx.WXK_DOWN:
 
   995             if event.ControlDown() and event.ShiftDown():
 
  1003             if event.ControlDown() and event.ShiftDown():
 
   996                 self.Scroll(xpos, ymax)
 
  1004                 self.Scroll(xpos, ymax)
 
   997             elif event.ControlDown():
 
  1005             elif event.ControlDown():
 
   998                 self.Scroll(xpos, min(ypos + 1, ymax))
 
  1006                 self.Scroll(xpos, min(ypos + 1, ymax))
 
   999             elif self.SelectedElement:
 
  1007             elif self.SelectedElement:
 
  1000                 self.SelectedElement.Move(0, scaling[1])
 
  1008                 self.SelectedElement.Move(0, scaling[1])
 
  1001                 self.SelectedElement.RefreshModel()
 
  1009                 self.SelectedElement.RefreshModel()
 
  1002                 self.RefreshBuffer()
 
  1010                 self.RefreshBuffer()
 
  1003                 self.RefreshScrollBars()
 
  1011                 self.RefreshScrollBars()
 
  1004                 self.Refresh()
 
  1012                 self.Refresh(False)
 
  1005 
  1013 
  1006 #-------------------------------------------------------------------------------
 
  1014 #-------------------------------------------------------------------------------
 
  1007 #                          Model adding functions
 
  1015 #                          Model adding functions
 
  1008 #-------------------------------------------------------------------------------
 
  1016 #-------------------------------------------------------------------------------
 
  1009 
  1017 
  1010     def AddNewBlock(self, bbox):
 
  1018     def AddNewBlock(self, bbox):
 
  1011         dialog = BlockPropertiesDialog(self.Parent)
 
  1019         dialog = BlockPropertiesDialog(self.ParentWindow)
 
  1012         dialog.SetBlockList(self.Controler.GetBlockTypes())
 
  1020         dialog.SetBlockList(self.Controler.GetBlockTypes())
 
  1013         dialog.SetPouNames(self.Controler.GetProjectPouNames())
 
  1021         dialog.SetPouNames(self.Controler.GetProjectPouNames())
 
  1014         dialog.SetPouElementNames(self.Controler.GetCurrentElementEditingVariables())
 
  1022         dialog.SetPouElementNames(self.Controler.GetCurrentElementEditingVariables())
 
  1015         dialog.SetMinBlockSize((bbox.width, bbox.height))
 
  1023         dialog.SetMinBlockSize((bbox.width, bbox.height))
 
  1016         if dialog.ShowModal() == wx.ID_OK:
 
  1024         if dialog.ShowModal() == wx.ID_OK:
 
  1025             self.AddBlock(block)
 
  1033             self.AddBlock(block)
 
  1026             self.Controler.AddCurrentElementEditingBlock(id, values["type"], values.get("name", None))
 
  1034             self.Controler.AddCurrentElementEditingBlock(id, values["type"], values.get("name", None))
 
  1027             self.RefreshBlockModel(block)
 
  1035             self.RefreshBlockModel(block)
 
  1028             self.RefreshBuffer()
 
  1036             self.RefreshBuffer()
 
  1029             self.RefreshScrollBars()
 
  1037             self.RefreshScrollBars()
 
  1030             self.Parent.RefreshEditor()
 
  1038             self.ParentWindow.RefreshEditor()
 
  1031             self.Refresh()
 
  1039             self.Refresh(False)
 
  1032         dialog.Destroy()
 
  1040         dialog.Destroy()
 
  1033     
  1041     
  1034     def AddNewVariable(self, bbox):
 
  1042     def AddNewVariable(self, bbox):
 
  1035         dialog = VariablePropertiesDialog(self.Parent)
 
  1043         dialog = VariablePropertiesDialog(self.ParentWindow)
 
  1036         dialog.SetMinVariableSize((bbox.width, bbox.height))
 
  1044         dialog.SetMinVariableSize((bbox.width, bbox.height))
 
  1037         varlist = []
 
  1045         varlist = []
 
  1038         vars = self.Controler.GetCurrentElementEditingInterfaceVars()
 
  1046         vars = self.Controler.GetCurrentElementEditingInterfaceVars()
 
  1039         if vars:
 
  1047         if vars:
 
  1040             for var in vars:
 
  1048             for var in vars:
 
  1053             self.AddBlock(variable)
 
  1061             self.AddBlock(variable)
 
  1054             self.Controler.AddCurrentElementEditingVariable(id, values["type"])
 
  1062             self.Controler.AddCurrentElementEditingVariable(id, values["type"])
 
  1055             self.RefreshVariableModel(variable)
 
  1063             self.RefreshVariableModel(variable)
 
  1056             self.RefreshBuffer()
 
  1064             self.RefreshBuffer()
 
  1057             self.RefreshScrollBars()
 
  1065             self.RefreshScrollBars()
 
  1058             self.Refresh()
 
  1066             self.Refresh(False)
 
  1059         dialog.Destroy()
 
  1067         dialog.Destroy()
 
  1060 
  1068 
  1061     def AddNewConnection(self, bbox):
 
  1069     def AddNewConnection(self, bbox):
 
  1062         dialog = ConnectionPropertiesDialog(self.Parent)
 
  1070         dialog = ConnectionPropertiesDialog(self.ParentWindow)
 
  1063         dialog.SetMinConnectionSize((bbox.width, bbox.height))
 
  1071         dialog.SetMinConnectionSize((bbox.width, bbox.height))
 
  1064         if dialog.ShowModal() == wx.ID_OK:
 
  1072         if dialog.ShowModal() == wx.ID_OK:
 
  1065             id = self.GetNewId()
 
  1073             id = self.GetNewId()
 
  1066             values = dialog.GetValues()
 
  1074             values = dialog.GetValues()
 
  1067             connection = FBD_Connector(self, values["type"], values["name"], id)
 
  1075             connection = FBD_Connector(self, values["type"], values["name"], id)
 
  1070             self.AddBlock(connection)
 
  1078             self.AddBlock(connection)
 
  1071             self.Controler.AddCurrentElementEditingConnection(id, values["type"])
 
  1079             self.Controler.AddCurrentElementEditingConnection(id, values["type"])
 
  1072             self.RefreshConnectionModel(connection)
 
  1080             self.RefreshConnectionModel(connection)
 
  1073             self.RefreshBuffer()
 
  1081             self.RefreshBuffer()
 
  1074             self.RefreshScrollBars()
 
  1082             self.RefreshScrollBars()
 
  1075             self.Refresh()
 
  1083             self.Refresh(False)
 
  1076         dialog.Destroy()
 
  1084         dialog.Destroy()
 
  1077 
  1085 
  1078     def AddNewComment(self, bbox):
 
  1086     def AddNewComment(self, bbox):
 
  1079         dialog = wx.TextEntryDialog(self.Parent, "Add a new comment", "Please enter comment text", "", wx.OK|wx.CANCEL|wx.TE_MULTILINE)
 
  1087         dialog = wx.TextEntryDialog(self.ParentWindow, "Add a new comment", "Please enter comment text", "", wx.OK|wx.CANCEL|wx.TE_MULTILINE)
 
  1080         if dialog.ShowModal() == wx.ID_OK:
 
  1088         if dialog.ShowModal() == wx.ID_OK:
 
  1081             value = dialog.GetValue()
 
  1089             value = dialog.GetValue()
 
  1082             id = self.GetNewId()
 
  1090             id = self.GetNewId()
 
  1083             comment = Comment(self, value, id)
 
  1091             comment = Comment(self, value, id)
 
  1084             comment.SetPosition(bbox.x, bbox.y)
 
  1092             comment.SetPosition(bbox.x, bbox.y)
 
  1087             self.AddComment(comment)
 
  1095             self.AddComment(comment)
 
  1088             self.Controler.AddCurrentElementEditingComment(id)
 
  1096             self.Controler.AddCurrentElementEditingComment(id)
 
  1089             self.RefreshCommentModel(comment)
 
  1097             self.RefreshCommentModel(comment)
 
  1090             self.RefreshBuffer()
 
  1098             self.RefreshBuffer()
 
  1091             self.RefreshScrollBars()
 
  1099             self.RefreshScrollBars()
 
  1092             self.Refresh()
 
  1100             self.Refresh(False)
 
  1093         dialog.Destroy()
 
  1101         dialog.Destroy()
 
  1094 
  1102 
  1095     def AddNewContact(self, bbox):
 
  1103     def AddNewContact(self, bbox):
 
  1096         dialog = LDElementDialog(self.Parent, "contact")
 
  1104         dialog = LDElementDialog(self.ParentWindow, "contact")
 
  1097         varlist = []
 
  1105         varlist = []
 
  1098         vars = self.Controler.GetCurrentElementEditingInterfaceVars()
 
  1106         vars = self.Controler.GetCurrentElementEditingInterfaceVars()
 
  1099         if vars:
 
  1107         if vars:
 
  1100             for var in vars:
 
  1108             for var in vars:
 
  1101                 if var["Class"] != "Output" and var["Type"] == "BOOL":
 
  1109                 if var["Class"] != "Output" and var["Type"] == "BOOL":
 
  1112             self.AddBlock(contact)
 
  1120             self.AddBlock(contact)
 
  1113             self.Controler.AddCurrentElementEditingContact(id)
 
  1121             self.Controler.AddCurrentElementEditingContact(id)
 
  1114             self.RefreshContactModel(contact)
 
  1122             self.RefreshContactModel(contact)
 
  1115             self.RefreshBuffer()
 
  1123             self.RefreshBuffer()
 
  1116             self.RefreshScrollBars()
 
  1124             self.RefreshScrollBars()
 
  1117             self.Refresh()
 
  1125             self.Refresh(False)
 
  1118         dialog.Destroy()
 
  1126         dialog.Destroy()
 
  1119 
  1127 
  1120     def AddNewCoil(self, bbox):
 
  1128     def AddNewCoil(self, bbox):
 
  1121         dialog = LDElementDialog(self.Parent, "coil")
 
  1129         dialog = LDElementDialog(self.ParentWindow, "coil")
 
  1122         varlist = []
 
  1130         varlist = []
 
  1123         vars = self.Controler.GetCurrentElementEditingInterfaceVars()
 
  1131         vars = self.Controler.GetCurrentElementEditingInterfaceVars()
 
  1124         if vars:
 
  1132         if vars:
 
  1125             for var in vars:
 
  1133             for var in vars:
 
  1126                 if var["Class"] != "Input" and var["Type"] == "BOOL":
 
  1134                 if var["Class"] != "Input" and var["Type"] == "BOOL":
 
  1140             self.AddBlock(coil)
 
  1148             self.AddBlock(coil)
 
  1141             self.Controler.AddCurrentElementEditingCoil(id)
 
  1149             self.Controler.AddCurrentElementEditingCoil(id)
 
  1142             self.RefreshCoilModel(coil)
 
  1150             self.RefreshCoilModel(coil)
 
  1143             self.RefreshBuffer()
 
  1151             self.RefreshBuffer()
 
  1144             self.RefreshScrollBars()
 
  1152             self.RefreshScrollBars()
 
  1145             self.Refresh()
 
  1153             self.Refresh(False)
 
  1146         dialog.Destroy()
 
  1154         dialog.Destroy()
 
  1147 
  1155 
  1148     def AddNewPowerRail(self, bbox):
 
  1156     def AddNewPowerRail(self, bbox):
 
  1149         dialog = LDPowerRailDialog(self.Parent)
 
  1157         dialog = LDPowerRailDialog(self.ParentWindow)
 
  1150         dialog.SetMinSize((bbox.width, bbox.height))
 
  1158         dialog.SetMinSize((bbox.width, bbox.height))
 
  1151         if dialog.ShowModal() == wx.ID_OK:
 
  1159         if dialog.ShowModal() == wx.ID_OK:
 
  1152             id = self.GetNewId()
 
  1160             id = self.GetNewId()
 
  1153             values = dialog.GetValues()
 
  1161             values = dialog.GetValues()
 
  1154             powerrail = LD_PowerRail(self, values["type"], id, [True for i in xrange(values["number"])])
 
  1162             powerrail = LD_PowerRail(self, values["type"], id, [True for i in xrange(values["number"])])
 
  1157             self.AddBlock(powerrail)
 
  1165             self.AddBlock(powerrail)
 
  1158             self.Controler.AddCurrentElementEditingPowerRail(id, values["type"])
 
  1166             self.Controler.AddCurrentElementEditingPowerRail(id, values["type"])
 
  1159             self.RefreshPowerRailModel(powerrail)
 
  1167             self.RefreshPowerRailModel(powerrail)
 
  1160             self.RefreshBuffer()
 
  1168             self.RefreshBuffer()
 
  1161             self.RefreshScrollBars()
 
  1169             self.RefreshScrollBars()
 
  1162             self.Refresh()
 
  1170             self.Refresh(False)
 
  1163         dialog.Destroy()
 
  1171         dialog.Destroy()
 
  1164 
  1172 
  1165     def AddNewStep(self, bbox, initial = False):
 
  1173     def AddNewStep(self, bbox, initial = False):
 
  1166         dialog = StepContentDialog(self.Parent, initial)
 
  1174         dialog = StepContentDialog(self.ParentWindow, initial)
 
  1167         dialog.SetPouNames(self.Controler.GetProjectPouNames())
 
  1175         dialog.SetPouNames(self.Controler.GetProjectPouNames())
 
  1168         dialog.SetVariables(self.Controler.GetCurrentElementEditingInterfaceVars())
 
  1176         dialog.SetVariables(self.Controler.GetCurrentElementEditingInterfaceVars())
 
  1169         dialog.SetStepNames([block.GetName() for block in self.Blocks if isinstance(block, SFC_Step)])
 
  1177         dialog.SetStepNames([block.GetName() for block in self.Blocks if isinstance(block, SFC_Step)])
 
  1170         dialog.SetMinStepSize((bbox.width, bbox.height))
 
  1178         dialog.SetMinStepSize((bbox.width, bbox.height))
 
  1171         if dialog.ShowModal() == wx.ID_OK:
 
  1179         if dialog.ShowModal() == wx.ID_OK:
 
  1190             self.AddBlock(step)
 
  1198             self.AddBlock(step)
 
  1191             self.Controler.AddCurrentElementEditingStep(id)
 
  1199             self.Controler.AddCurrentElementEditingStep(id)
 
  1192             self.RefreshStepModel(step)
 
  1200             self.RefreshStepModel(step)
 
  1193             self.RefreshBuffer()
 
  1201             self.RefreshBuffer()
 
  1194             self.RefreshScrollBars()
 
  1202             self.RefreshScrollBars()
 
  1195             self.Refresh()
 
  1203             self.Refresh(False)
 
  1196         dialog.Destroy()
 
  1204         dialog.Destroy()
 
  1197 
  1205 
  1198     def AddNewTransition(self, bbox):
 
  1206     def AddNewTransition(self, bbox):
 
  1199         dialog = TransitionContentDialog(self.Parent, self.GetDrawingMode() == FREEDRAWING_MODE)
 
  1207         dialog = TransitionContentDialog(self.ParentWindow, self.GetDrawingMode() == FREEDRAWING_MODE)
 
  1200         dialog.SetTransitions(self.Controler.GetCurrentElementEditingTransitions())
 
  1208         dialog.SetTransitions(self.Controler.GetCurrentElementEditingTransitions())
 
  1201         if dialog.ShowModal() == wx.ID_OK:
 
  1209         if dialog.ShowModal() == wx.ID_OK:
 
  1202             id = self.GetNewId()
 
  1210             id = self.GetNewId()
 
  1203             values = dialog.GetValues()
 
  1211             values = dialog.GetValues()
 
  1204             transition = SFC_Transition(self, values["type"], values["value"], values["priority"], id)
 
  1212             transition = SFC_Transition(self, values["type"], values["value"], values["priority"], id)
 
  1208             self.AddBlock(transition)
 
  1216             self.AddBlock(transition)
 
  1209             self.Controler.AddCurrentElementEditingTransition(id)
 
  1217             self.Controler.AddCurrentElementEditingTransition(id)
 
  1210             self.RefreshTransitionModel(transition)
 
  1218             self.RefreshTransitionModel(transition)
 
  1211             self.RefreshBuffer()
 
  1219             self.RefreshBuffer()
 
  1212             self.RefreshScrollBars()
 
  1220             self.RefreshScrollBars()
 
  1213             self.Refresh()
 
  1221             self.Refresh(False)
 
  1214         dialog.Destroy()
 
  1222         dialog.Destroy()
 
  1215 
  1223 
  1216     def AddNewDivergence(self, bbox):
 
  1224     def AddNewDivergence(self, bbox):
 
  1217         dialog = DivergenceCreateDialog(self.Parent)
 
  1225         dialog = DivergenceCreateDialog(self.ParentWindow)
 
  1218         dialog.SetMinSize((bbox.width, bbox.height))
 
  1226         dialog.SetMinSize((bbox.width, bbox.height))
 
  1219         if dialog.ShowModal() == wx.ID_OK:
 
  1227         if dialog.ShowModal() == wx.ID_OK:
 
  1220             id = self.GetNewId()
 
  1228             id = self.GetNewId()
 
  1221             values = dialog.GetValues()
 
  1229             values = dialog.GetValues()
 
  1222             divergence = SFC_Divergence(self, values["type"], values["number"], id)
 
  1230             divergence = SFC_Divergence(self, values["type"], values["number"], id)
 
  1226             self.AddBlock(divergence)
 
  1234             self.AddBlock(divergence)
 
  1227             self.Controler.AddCurrentElementEditingDivergence(id, values["type"])
 
  1235             self.Controler.AddCurrentElementEditingDivergence(id, values["type"])
 
  1228             self.RefreshDivergenceModel(divergence)
 
  1236             self.RefreshDivergenceModel(divergence)
 
  1229             self.RefreshBuffer()
 
  1237             self.RefreshBuffer()
 
  1230             self.RefreshScrollBars()
 
  1238             self.RefreshScrollBars()
 
  1231             self.Refresh()
 
  1239             self.Refresh(False)
 
  1232         dialog.Destroy()
 
  1240         dialog.Destroy()
 
  1233 
  1241 
  1234 
  1242 
  1235 #-------------------------------------------------------------------------------
 
  1243 #-------------------------------------------------------------------------------
 
  1236 #                          Edit element content functions
 
  1244 #                          Edit element content functions
 
  1237 #-------------------------------------------------------------------------------
 
  1245 #-------------------------------------------------------------------------------
 
  1238 
  1246 
  1239     def EditBlockContent(self, block):
 
  1247     def EditBlockContent(self, block):
 
  1240         dialog = BlockPropertiesDialog(self.Parent)
 
  1248         dialog = BlockPropertiesDialog(self.ParentWindow)
 
  1241         dialog.SetBlockList(self.Controler.GetBlockTypes())
 
  1249         dialog.SetBlockList(self.Controler.GetBlockTypes())
 
  1242         dialog.SetPouNames(self.Controler.GetProjectPouNames())
 
  1250         dialog.SetPouNames(self.Controler.GetProjectPouNames())
 
  1243         dialog.SetPouElementNames(self.Controler.GetCurrentElementEditingVariables())
 
  1251         dialog.SetPouElementNames(self.Controler.GetCurrentElementEditingVariables())
 
  1244         dialog.SetMinBlockSize(block.GetSize())
 
  1252         dialog.SetMinBlockSize(block.GetSize())
 
  1245         values = {"name" : block.GetName(), "type" : block.GetType(), "inputs" : block.GetInputTypes()}
 
  1253         values = {"name" : block.GetName(), "type" : block.GetType(), "inputs" : block.GetInputTypes()}
 
  1252             block.SetSize(values["width"], values["height"])
 
  1260             block.SetSize(values["width"], values["height"])
 
  1253             block.SetType(values["type"], values["extension"])
 
  1261             block.SetType(values["type"], values["extension"])
 
  1254             self.RefreshBlockModel(block)
 
  1262             self.RefreshBlockModel(block)
 
  1255             self.RefreshBuffer()
 
  1263             self.RefreshBuffer()
 
  1256             self.RefreshScrollBars()
 
  1264             self.RefreshScrollBars()
 
  1257             self.Refresh()
 
  1265             self.Refresh(False)
 
  1258         dialog.Destroy()
 
  1266         dialog.Destroy()
 
  1259 
  1267 
  1260     def EditVariableContent(self, variable):
 
  1268     def EditVariableContent(self, variable):
 
  1261         dialog = VariablePropertiesDialog(self.Parent)
 
  1269         dialog = VariablePropertiesDialog(self.ParentWindow)
 
  1262         dialog.SetMinVariableSize(variable.GetSize())
 
  1270         dialog.SetMinVariableSize(variable.GetSize())
 
  1263         varlist = []
 
  1271         varlist = []
 
  1264         vars = self.Controler.GetCurrentElementEditingInterfaceVars()
 
  1272         vars = self.Controler.GetCurrentElementEditingInterfaceVars()
 
  1265         if vars:
 
  1273         if vars:
 
  1266             for var in vars:
 
  1274             for var in vars:
 
  1283                 self.Controler.RemoveCurrentElementEditingInstance(id)
 
  1291                 self.Controler.RemoveCurrentElementEditingInstance(id)
 
  1284                 self.Controler.AddCurrentElementEditingVariable(id, values["type"])
 
  1292                 self.Controler.AddCurrentElementEditingVariable(id, values["type"])
 
  1285             self.RefreshVariableModel(variable)
 
  1293             self.RefreshVariableModel(variable)
 
  1286             self.RefreshBuffer()
 
  1294             self.RefreshBuffer()
 
  1287             self.RefreshScrollBars()
 
  1295             self.RefreshScrollBars()
 
  1288             self.Refresh()
 
  1296             self.Refresh(False)
 
  1289         dialog.Destroy()
 
  1297         dialog.Destroy()
 
  1290 
  1298 
  1291     def EditConnectionContent(self, connection):
 
  1299     def EditConnectionContent(self, connection):
 
  1292         dialog = ConnectionPropertiesDialog(self.Parent)
 
  1300         dialog = ConnectionPropertiesDialog(self.ParentWindow)
 
  1293         dialog.SetMinConnectionSize(connection.GetSize())
 
  1301         dialog.SetMinConnectionSize(connection.GetSize())
 
  1294         values = {"name" : connection.GetName(), "type" : connection.GetType()}
 
  1302         values = {"name" : connection.GetName(), "type" : connection.GetType()}
 
  1295         dialog.SetValues(values)
 
  1303         dialog.SetValues(values)
 
  1296         if dialog.ShowModal() == wx.ID_OK:
 
  1304         if dialog.ShowModal() == wx.ID_OK:
 
  1297             old_type = connection.GetType()
 
  1305             old_type = connection.GetType()
 
  1304                 self.Controler.RemoveCurrentElementEditingInstance(id)
 
  1312                 self.Controler.RemoveCurrentElementEditingInstance(id)
 
  1305                 self.Controler.AddCurrentElementEditingConnection(id, values["type"])
 
  1313                 self.Controler.AddCurrentElementEditingConnection(id, values["type"])
 
  1306             self.RefreshConnectionModel(connection)
 
  1314             self.RefreshConnectionModel(connection)
 
  1307             self.RefreshBuffer()
 
  1315             self.RefreshBuffer()
 
  1308             self.RefreshScrollBars()
 
  1316             self.RefreshScrollBars()
 
  1309             self.Refresh()
 
  1317             self.Refresh(False)
 
  1310         dialog.Destroy()
 
  1318         dialog.Destroy()
 
  1311 
  1319 
  1312     def EditContactContent(self, contact):
 
  1320     def EditContactContent(self, contact):
 
  1313         dialog = LDElementDialog(self.Parent, "contact")
 
  1321         dialog = LDElementDialog(self.ParentWindow, "contact")
 
  1314         varlist = []
 
  1322         varlist = []
 
  1315         vars = self.Controler.GetCurrentElementEditingInterfaceVars()
 
  1323         vars = self.Controler.GetCurrentElementEditingInterfaceVars()
 
  1316         if vars:
 
  1324         if vars:
 
  1317             for var in vars:
 
  1325             for var in vars:
 
  1318                 if var["Class"] != "Output" and var["Type"] == "BOOL":
 
  1326                 if var["Class"] != "Output" and var["Type"] == "BOOL":
 
  1327             contact.SetType(values["type"])
 
  1335             contact.SetType(values["type"])
 
  1328             contact.SetSize(values["width"], values["height"])
 
  1336             contact.SetSize(values["width"], values["height"])
 
  1329             self.RefreshContactModel(contact)
 
  1337             self.RefreshContactModel(contact)
 
  1330             self.RefreshBuffer()
 
  1338             self.RefreshBuffer()
 
  1331             self.RefreshScrollBars()
 
  1339             self.RefreshScrollBars()
 
  1332             self.Refresh()
 
  1340             self.Refresh(False)
 
  1333         dialog.Destroy()
 
  1341         dialog.Destroy()
 
  1334 
  1342 
  1335     def EditCoilContent(self, coil):
 
  1343     def EditCoilContent(self, coil):
 
  1336         dialog = LDElementDialog(self.Parent, "coil")
 
  1344         dialog = LDElementDialog(self.ParentWindow, "coil")
 
  1337         varlist = []
 
  1345         varlist = []
 
  1338         vars = self.Controler.GetCurrentElementEditingInterfaceVars()
 
  1346         vars = self.Controler.GetCurrentElementEditingInterfaceVars()
 
  1339         if vars:
 
  1347         if vars:
 
  1340             for var in vars:
 
  1348             for var in vars:
 
  1341                 if var["Class"] != "Input" and var["Type"] == "BOOL":
 
  1349                 if var["Class"] != "Input" and var["Type"] == "BOOL":
 
  1353             coil.SetType(values["type"])
 
  1361             coil.SetType(values["type"])
 
  1354             coil.SetSize(values["width"], values["height"])
 
  1362             coil.SetSize(values["width"], values["height"])
 
  1355             self.RefreshCoilModel(coil)
 
  1363             self.RefreshCoilModel(coil)
 
  1356             self.RefreshBuffer()
 
  1364             self.RefreshBuffer()
 
  1357             self.RefreshScrollBars()
 
  1365             self.RefreshScrollBars()
 
  1358             self.Refresh()
 
  1366             self.Refresh(False)
 
  1359         dialog.Destroy()
 
  1367         dialog.Destroy()
 
  1360 
  1368 
  1361     def EditPowerRailContent(self, powerrail):
 
  1369     def EditPowerRailContent(self, powerrail):
 
  1362         dialog = LDPowerRailDialog(self.Parent, powerrail.GetType(), len(powerrail.GetConnectors()))
 
  1370         dialog = LDPowerRailDialog(self.ParentWindow, powerrail.GetType(), len(powerrail.GetConnectors()))
 
  1363         dialog.SetMinSize(powerrail.GetSize())
 
  1371         dialog.SetMinSize(powerrail.GetSize())
 
  1364         if dialog.ShowModal() == wx.ID_OK:
 
  1372         if dialog.ShowModal() == wx.ID_OK:
 
  1365             old_type = powerrail.GetType()
 
  1373             old_type = powerrail.GetType()
 
  1366             values = dialog.GetValues()
 
  1374             values = dialog.GetValues()
 
  1367             powerrail.SetType(values["type"], [True for i in xrange(values["number"])])
 
  1375             powerrail.SetType(values["type"], [True for i in xrange(values["number"])])
 
  1371                 self.Controler.RemoveCurrentElementEditingInstance(id)
 
  1379                 self.Controler.RemoveCurrentElementEditingInstance(id)
 
  1372                 self.Controler.AddCurrentElementEditingPowerRail(id, values["type"])
 
  1380                 self.Controler.AddCurrentElementEditingPowerRail(id, values["type"])
 
  1373             self.RefreshPowerRailModel(powerrail)
 
  1381             self.RefreshPowerRailModel(powerrail)
 
  1374             self.RefreshBuffer()
 
  1382             self.RefreshBuffer()
 
  1375             self.RefreshScrollBars()
 
  1383             self.RefreshScrollBars()
 
  1376             self.Refresh()
 
  1384             self.Refresh(False)
 
  1377         dialog.Destroy()
 
  1385         dialog.Destroy()
 
  1378 
  1386 
  1379     def EditStepContent(self, step):
 
  1387     def EditStepContent(self, step):
 
  1380         dialog = StepContentDialog(self.Parent, step.GetInitial())
 
  1388         dialog = StepContentDialog(self.ParentWindow, step.GetInitial())
 
  1381         dialog.SetPouNames(self.Controler.GetProjectPouNames())
 
  1389         dialog.SetPouNames(self.Controler.GetProjectPouNames())
 
  1382         dialog.SetVariables(self.Controler.GetCurrentElementEditingInterfaceVars())
 
  1390         dialog.SetVariables(self.Controler.GetCurrentElementEditingInterfaceVars())
 
  1383         dialog.SetStepNames([block.GetName() for block in self.Blocks if isinstance(block, SFC_Step) and block.GetName() != step.GetName()])
 
  1391         dialog.SetStepNames([block.GetName() for block in self.Blocks if isinstance(block, SFC_Step) and block.GetName() != step.GetName()])
 
  1384         dialog.SetMinStepSize(step.GetSize())
 
  1392         dialog.SetMinStepSize(step.GetSize())
 
  1385         values = {"name" : step.GetName()}
 
  1393         values = {"name" : step.GetName()}
 
  1405                 step.RemoveAction()
 
  1413                 step.RemoveAction()
 
  1406             step.UpdateSize(values["width"], values["height"])
 
  1414             step.UpdateSize(values["width"], values["height"])
 
  1407             step.RefreshModel()
 
  1415             step.RefreshModel()
 
  1408             self.RefreshBuffer()
 
  1416             self.RefreshBuffer()
 
  1409             self.RefreshScrollBars()
 
  1417             self.RefreshScrollBars()
 
  1410             self.Refresh()
 
  1418             self.Refresh(False)
 
  1411         
  1419         
  1412     def EditTransitionContent(self, transition):
 
  1420     def EditTransitionContent(self, transition):
 
  1413         dialog = TransitionContentDialog(self.Parent, self.GetDrawingMode() == FREEDRAWING_MODE)
 
  1421         dialog = TransitionContentDialog(self.ParentWindow, self.GetDrawingMode() == FREEDRAWING_MODE)
 
  1414         dialog.SetTransitions(self.Controler.GetCurrentElementEditingTransitions())
 
  1422         dialog.SetTransitions(self.Controler.GetCurrentElementEditingTransitions())
 
  1415         dialog.SetValues({"type":transition.GetType(),"value":transition.GetCondition(), "priority":transition.GetPriority()})
 
  1423         dialog.SetValues({"type":transition.GetType(),"value":transition.GetCondition(), "priority":transition.GetPriority()})
 
  1416         dialog.SetElementSize(transition.GetSize())
 
  1424         dialog.SetElementSize(transition.GetSize())
 
  1417         if dialog.ShowModal() == wx.ID_OK:
 
  1425         if dialog.ShowModal() == wx.ID_OK:
 
  1418             values = dialog.GetValues()
 
  1426             values = dialog.GetValues()
 
  1419             transition.SetType(values["type"],values["value"])
 
  1427             transition.SetType(values["type"],values["value"])
 
  1420             transition.SetPriority(values["priority"])
 
  1428             transition.SetPriority(values["priority"])
 
  1421             transition.RefreshModel()
 
  1429             transition.RefreshModel()
 
  1422             self.RefreshBuffer()
 
  1430             self.RefreshBuffer()
 
  1423             self.RefreshScrollBars()
 
  1431             self.RefreshScrollBars()
 
  1424             self.Refresh()
 
  1432             self.Refresh(False)
 
  1425         dialog.Destroy()
 
  1433         dialog.Destroy()
 
  1426 
  1434 
  1427     def EditJumpContent(self, jump):
 
  1435     def EditJumpContent(self, jump):
 
  1428         choices = []
 
  1436         choices = []
 
  1429         for block in self.Blocks:
 
  1437         for block in self.Blocks:
 
  1430             if isinstance(block, SFC_Step):
 
  1438             if isinstance(block, SFC_Step):
 
  1431                 choices.append(block.GetName())
 
  1439                 choices.append(block.GetName())
 
  1432         dialog = wx.SingleChoiceDialog(self.Parent, "Edit jump target", "Please choose a target", choices, wx.OK|wx.CANCEL)
 
  1440         dialog = wx.SingleChoiceDialog(self.ParentWindow, "Edit jump target", "Please choose a target", choices, wx.OK|wx.CANCEL)
 
  1433         dialog.SetSelection(choices.index(jump.GetTarget()))
 
  1441         dialog.SetSelection(choices.index(jump.GetTarget()))
 
  1434         if dialog.ShowModal() == wx.ID_OK:
 
  1442         if dialog.ShowModal() == wx.ID_OK:
 
  1435             value = dialog.GetStringSelection()
 
  1443             value = dialog.GetStringSelection()
 
  1436             jump.SetTarget(value)
 
  1444             jump.SetTarget(value)
 
  1437             jump.RefreshModel()
 
  1445             jump.RefreshModel()
 
  1438             self.RefreshBuffer()
 
  1446             self.RefreshBuffer()
 
  1439             self.RefreshScrollBars()
 
  1447             self.RefreshScrollBars()
 
  1440             self.Refresh()
 
  1448             self.Refresh(False)
 
  1441         dialog.Destroy()
 
  1449         dialog.Destroy()
 
  1442 
  1450 
  1443     def EditActionBlockContent(self, actionblock):
 
  1451     def EditActionBlockContent(self, actionblock):
 
  1444         dialog = ActionBlockDialog(self.Parent)
 
  1452         dialog = ActionBlockDialog(self.ParentWindow)
 
  1445         dialog.SetQualifierList(self.Controler.GetQualifierTypes())
 
  1453         dialog.SetQualifierList(self.Controler.GetQualifierTypes())
 
  1446         dialog.SetActionList(self.Controler.GetCurrentElementEditingActions())
 
  1454         dialog.SetActionList(self.Controler.GetCurrentElementEditingActions())
 
  1447         dialog.SetVariableList(self.Controler.GetCurrentElementEditingInterfaceVars())
 
  1455         dialog.SetVariableList(self.Controler.GetCurrentElementEditingInterfaceVars())
 
  1448         dialog.SetValues(actionblock.GetActions())
 
  1456         dialog.SetValues(actionblock.GetActions())
 
  1449         if dialog.ShowModal() == wx.ID_OK:
 
  1457         if dialog.ShowModal() == wx.ID_OK:
 
  1450             actions = dialog.GetValues()
 
  1458             actions = dialog.GetValues()
 
  1451             actionblock.SetActions(actions)
 
  1459             actionblock.SetActions(actions)
 
  1452             actionblock.RefreshModel()
 
  1460             actionblock.RefreshModel()
 
  1453             self.RefreshBuffer()
 
  1461             self.RefreshBuffer()
 
  1454             self.RefreshScrollBars()
 
  1462             self.RefreshScrollBars()
 
  1455             self.Refresh()
 
  1463             self.Refresh(False)
 
       
  1464         dialog.Destroy()
 
       
  1465 
       
  1466     def EditCommentContent(self, comment):
 
       
  1467         dialog = wx.TextEntryDialog(self.ParentWindow, "Edit comment", "Please enter comment text", comment.GetContent(), wx.OK|wx.CANCEL|wx.TE_MULTILINE)
 
       
  1468         if dialog.ShowModal() == wx.ID_OK:
 
       
  1469             value = dialog.GetValue()
 
       
  1470             comment.SetContent(value)
 
       
  1471             comment.RefreshModel()
 
       
  1472             self.RefreshBuffer()
 
       
  1473             self.RefreshScrollBars()
 
       
  1474             self.Refresh(False)
 
  1456         dialog.Destroy()
 
  1475         dialog.Destroy()
 
  1457 
  1476 
  1458 #-------------------------------------------------------------------------------
 
  1477 #-------------------------------------------------------------------------------
 
  1459 #                          Model update functions
 
  1478 #                          Model update functions
 
  1460 #-------------------------------------------------------------------------------
 
  1479 #-------------------------------------------------------------------------------
 
  1585         block.Clean()
 
  1604         block.Clean()
 
  1586         self.RemoveBlock(block)
 
  1605         self.RemoveBlock(block)
 
  1587         self.Controler.RemoveCurrentElementEditingInstance(block.GetId())
 
  1606         self.Controler.RemoveCurrentElementEditingInstance(block.GetId())
 
  1588         for element in elements:
 
  1607         for element in elements:
 
  1589             element.RefreshModel()
 
  1608             element.RefreshModel()
 
  1590         wx.CallAfter(self.Parent.RefreshEditor)
 
  1609         wx.CallAfter(self.ParentWindow.RefreshEditor)
 
  1591 
  1610 
  1592     def DeleteVariable(self, variable):
 
  1611     def DeleteVariable(self, variable):
 
  1593         connectors = variable.GetConnectors()
 
  1612         connectors = variable.GetConnectors()
 
  1594         if connectors["output"]:
 
  1613         if connectors["output"]:
 
  1595             elements = connectors["output"].GetConnectedBlocks()
 
  1614             elements = connectors["output"].GetConnectedBlocks()
 
  1730         self.GetBestSize()
 
  1749         self.GetBestSize()
 
  1731         self.RefreshScrollBars()
 
  1750         self.RefreshScrollBars()
 
  1732         event.Skip()
 
  1751         event.Skip()
 
  1733 
  1752 
  1734     def OnPaint(self, event):
 
  1753     def OnPaint(self, event):
 
  1735         dc = self.GetLogicalDC()
 
  1754         dc = self.GetLogicalDC(True)
 
  1736         dc.Clear()
 
  1755         dc.Clear()
 
  1737         dc.SetPen(wx.Pen(wx.Colour(230, 230, 230)))
 
  1756         dc.SetPen(wx.Pen(wx.Colour(230, 230, 230)))
 
       
  1757         dc.BeginDrawing()
 
  1738         if self.Scaling and self.DrawGrid:
 
  1758         if self.Scaling and self.DrawGrid:
 
  1739             width, height = dc.GetSize()
 
  1759             width, height = dc.GetSize()
 
  1740             for i in xrange(1, width / self.Scaling[0] + 1):
 
  1760             for i in xrange(1, width / self.Scaling[0] + 1):
 
  1741                 dc.DrawLine(i * self.Scaling[0], 0, i * self.Scaling[0], height)
 
  1761                 dc.DrawLine(i * self.Scaling[0], 0, i * self.Scaling[0], height)
 
  1742             for i in xrange(1, height / self.Scaling[1] + 1):
 
  1762             for i in xrange(1, height / self.Scaling[1] + 1):
 
  1751             if block != self.SelectedElement:
 
  1771             if block != self.SelectedElement:
 
  1752                 block.Draw(dc)
 
  1772                 block.Draw(dc)
 
  1753         if self.SelectedElement:
 
  1773         if self.SelectedElement:
 
  1754             self.SelectedElement.Draw(dc)
 
  1774             self.SelectedElement.Draw(dc)
 
  1755         if self.rubberBand.IsShown():
 
  1775         if self.rubberBand.IsShown():
 
  1756             self.rubberBand.Draw()
 
  1776             self.rubberBand.Draw(dc)
 
       
  1777         dc.EndDrawing()
 
  1757         event.Skip()
 
  1778         event.Skip()
 
  1758 
  1779 
  1759 
  1780
plcopeneditor_history