plcopeneditor_history: comparison Viewer.py

equal deleted inserted replaced

-:f7df265edd54
+:d8425712acef
 values = None
 if not isinstance(values, TupleType):
 message = "Invalid value \"%s\" for viewer block"%data
 values = None
 if values is not None:
-if values[1] == "program":
+if values[1] == "debug":
+pass
+elif values[1] == "program":
 message = "Programs can't be used by other POUs!"
 elif values[1] in ["function", "functionBlock", "program"]:
-name, type = self.ParentWindow.Controler.GetEditedElementType(self.ParentWindow.GetTagName())
+name, type = self.ParentWindow.Controler.GetEditedElementType(self.ParentWindow.GetTagName(), self.ParentWindow.Debug)
 if name == values[0]:
 message = "\"%s\" can't use itself!"%name
 elif type == "function" and values[1] != "function":
 message = "Function Blocks can't be used by Functions!"
-elif self.ParentWindow.Controler.PouIsUsedBy(name, values[0]):
+elif self.ParentWindow.Controler.PouIsUsedBy(name, values[0], self.ParentWindow.Debug):
 message = "\"%s\" is already used by \"%s\"!"%(name, values[0])
 else:
 blockname = values[2]
 if len(values) > 3:
 blockinputs = values[3]
 if dialog.ShowModal() == wx.ID_OK:
 blockname = dialog.GetValue()
 else:
 return
 dialog.Destroy()
-if blockname.upper() in [name.upper() for name in self.ParentWindow.Controler.GetProjectPouNames()]:
+if blockname.upper() in [name.upper() for name in self.ParentWindow.Controler.GetProjectPouNames(self.ParentWindow.Debug)]:
 message = "\"%s\" pou already exists!"%blockname
-elif blockname.upper() in [name.upper() for name in self.ParentWindow.Controler.GetEditedElementVariables(self.ParentWindow.GetTagName())]:
+elif blockname.upper() in [name.upper() for name in self.ParentWindow.Controler.GetEditedElementVariables(self.ParentWindow.GetTagName(), self.ParentWindow.Debug)]:
 message = "\"%s\" element for this pou already exists!"%blockname
 else:
 id = self.ParentWindow.GetNewId()
 block = FBD_Block(self.ParentWindow, values[0], blockname, id, inputs = blockinputs)
 width, height = block.GetMinSize()
 self.ParentWindow.AddBlock(block)
 self.ParentWindow.Controler.AddEditedElementBlock(self.ParentWindow.GetTagName(), id, values[0], blockname)
 self.ParentWindow.RefreshBlockModel(block)
 self.ParentWindow.RefreshBuffer()
 self.ParentWindow.RefreshScrollBars()
+self.ParentWindow.RefreshVisibleElements()
 self.ParentWindow.ParentWindow.RefreshVariablePanel(self.ParentWindow.GetTagName())
 self.ParentWindow.Refresh(False)
 elif values[1] != "location":
 if values[3] == self.ParentWindow.GetTagName():
 id = self.ParentWindow.GetNewId()
 self.ParentWindow.AddBlock(variable)
 self.ParentWindow.Controler.AddEditedElementVariable(self.ParentWindow.GetTagName(), id, var_type)
 self.ParentWindow.RefreshVariableModel(variable)
 self.ParentWindow.RefreshBuffer()
 self.ParentWindow.RefreshScrollBars()
+self.ParentWindow.RefreshVisibleElements()
 self.ParentWindow.Refresh(False)
 else:
 message = "Variable don't belong to this POU!"
-wx.CallAfter(self.ShowMessage, message)
+if message is not None:
+wx.CallAfter(self.ShowMessage, message)
 def ShowMessage(self, message):
-if message is not None:
+message = wx.MessageDialog(self.ParentWindow, message, "Error", wx.OK|wx.ICON_ERROR)
-message = wx.MessageDialog(self.ParentWindow, message, "Error", wx.OK|wx.ICON_ERROR)
+message.ShowModal()
-message.ShowModal()
+message.Destroy()
-message.Destroy()
 """
 Class that implements a Viewer based on a wx.ScrolledWindow for drawing and
 manipulating graphic elements
 self._init_coll_AlignmentMenu_Items(self.AlignmentMenu)
 self._init_coll_ContextualMenu_Items(self.ContextualMenu)
 # Create a new Viewer
-def __init__(self, parent, tagname, window, controler):
+def __init__(self, parent, tagname, window, controler, debug = False, instancepath = ""):
 wx.ScrolledWindow.__init__(self, parent, pos=wx.Point(0, 0), size=wx.Size(0, 0),
 style=wx.HSCROLL | wx.VSCROLL)
 self._init_menus()
 # Adding a rubberband to Viewer
 self.rubberBand = RubberBand(drawingSurface=self)
 self.PagePen = wx.TRANSPARENT_PEN
 self.DrawingWire = False
 self.current_id = 0
 self.TagName = tagname
 self.Errors = []
+self.Debug = debug
+self.InstancePath = instancepath
 # Initialize Block, Wire and Comment numbers
 self.block_id = self.wire_id = self.comment_id = 0
 # Initialize Viewer mode to Selection mode
 self.CurrentLanguage = "FBD"
 self.ParentWindow = window
 self.Controler = controler
-self.SetDropTarget(ViewerDropTarget(self))
+if not self.Debug:
+self.SetDropTarget(ViewerDropTarget(self))
 dc = wx.ClientDC(self)
 font = wx.Font(faces["size"], wx.SWISS, wx.NORMAL, wx.NORMAL, faceName = faces["mono"])
 dc.SetFont(font)
 width, height = dc.GetTextExtent("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
 font = wx.Font(faces["size"], wx.SWISS, wx.NORMAL, wx.NORMAL, faceName = faces["mono"])
 dc.SetFont(font)
 width, height = dc.GetTextExtent("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
 self.SetFont(font)
+self.ResetView()
 # Link Viewer event to corresponding methods
 self.Bind(wx.EVT_PAINT, self.OnPaint)
 self.Bind(wx.EVT_LEFT_DOWN, self.OnViewerLeftDown)
 self.Bind(wx.EVT_LEFT_UP, self.OnViewerLeftUp)
 self.Bind(wx.EVT_LEFT_DCLICK, self.OnViewerLeftDClick)
 self.Bind(wx.EVT_RIGHT_DOWN, self.OnViewerRightDown)
 self.Bind(wx.EVT_RIGHT_UP, self.OnViewerRightUp)
 self.Bind(wx.EVT_LEAVE_WINDOW, self.OnLeaveViewer)
 self.Bind(wx.EVT_MOTION, self.OnViewerMotion)
 self.Bind(wx.EVT_CHAR, self.OnChar)
-#self.Bind(wx.EVT_SCROLLWIN, self.OnMoveWindow)
+self.Bind(wx.EVT_SCROLLWIN, self.OnScrollWindow)
 self.Bind(wx.EVT_SIZE, self.OnMoveWindow)
 def GetScrolledRect(self, rect):
 rect.x, rect.y = self.CalcScrolledPosition(rect.x, rect.y)
 return rect
 self.TagName = tagname
 def GetTagName(self):
 return self.TagName
+def GetInstancePath(self):
+return self.InstancePath
 def IsViewing(self, tagname):
-return self.TagName == tagname
+if self.Debug:
+return self.InstancePath == tagname
+else:
+return self.TagName == tagname
 # Returns a new id
 def GetNewId(self):
 self.current_id += 1
 return self.current_id
 # Destructor
 def __del__(self):
+self.Flush()
 self.ResetView()
 def GetLogicalDC(self, buffered=False):
 if buffered:
 dc = wx.AutoBufferedPaintDC(self)
 wires.sort(lambda x,y:self.Wires[x].__cmp__(self.Wires[y]))
 if sort_comments:
 comments.sort(lambda x,y:self.Comments[x].__cmp__(self.Comments[y]))
 return blocks + wires + comments
+def RefreshVisibleElements(self, xp = None, yp = None):
+x, y = self.CalcUnscrolledPosition(0, 0)
+if xp is not None:
+x = xp * self.GetScrollPixelsPerUnit()[0]
+if yp is not None:
+y = yp * self.GetScrollPixelsPerUnit()[1]
+width, height = self.GetClientSize()
+screen = wx.Rect(x, y, width, height)
+for comment in self.Comments:
+comment.TestVisible(screen)
+for wire in self.Wires:
+wire.TestVisible(screen)
+for block in self.Blocks:
+block.TestVisible(screen)
 #-------------------------------------------------------------------------------
 #                              Reset functions
 #-------------------------------------------------------------------------------
 # Resets Viewer lists
 def ResetView(self):
 self.Blocks = {}
 self.Wires = {}
 self.Comments = {}
+self.Subscribed = {}
 self.SelectedElement = None
 self.HighlightedElement = None
+def Flush(self):
+for block in self.Blocks:
+block.Flush()
+for element, iec_path in self.Subscribed.iteritems():
+self.Controler.UnsubscribeDebugIECVariable(iec_path, element)
 # Remove all elements
 def CleanView(self):
 for block in self.Blocks.keys():
 block.Clean()
 self.ParentWindow.RefreshTitle()
 self.ParentWindow.RefreshEditMenu()
 # Refresh the current scaling
 def RefreshScaling(self, refresh=True):
-properties = self.Controler.GetProjectProperties()
+properties = self.Controler.GetProjectProperties(self.Debug)
 scaling = properties["scaling"][self.CurrentLanguage]
 if scaling != (0, 0):
 self.Scaling = scaling
 if self.DrawGrid:
 bitmap = wx.EmptyBitmap(*scaling)
 # Refresh Viewer elements
 def RefreshView(self):
 self.current_id = 0
 # Start by reseting Viewer
+self.Flush()
 self.ResetView()
-instance = True
+instance = {}
 # List of ids of already loaded blocks
 ids = []
 # Load Blocks until they are all loaded
-while instance:
+while instance is not None:
-instance = self.Controler.GetEditedElementInstanceInfos(self.TagName, exclude=ids)
+instance = self.Controler.GetEditedElementInstanceInfos(self.TagName, exclude = ids, debug = self.Debug)
-if instance:
+if instance is not None:
 self.loadInstance(instance, ids)
 self.RefreshScrollBars()
 for wire in self.Wires:
 if not wire.IsConnectedCompatible():
 wire.MarkAsInvalid()
+if self.Debug:
+block = wire.EndConnected.GetParentBlock()
+if isinstance(block, LD_PowerRail):
+wire.SetValue(True)
+if isinstance(block, FBD_Block):
+blockname = block.GetName()
+connectorname = wire.EndConnected.GetName()
+if blockname != "":
+iec_path = "%s.%s.%s"%(self.InstancePath, block.GetName(), connectorname)
+else:
+if connectorname == "":
+connectorname = "OUT"
+iec_path = "%s.%s%d_%s"%(self.InstancePath, block.GetType(), block.GetId(), connectorname)
+self.Subscribed[wire] = iec_path.upper()
+self.Controler.SubscribeDebugIECVariable(iec_path.upper(), wire)
+if self.Debug:
+for block in self.Blocks.keys():
+if isinstance(block, (LD_Contact, LD_Coil)):
+block.SetValue(False)
+block.SpreadCurrent()
+if isinstance(block, LD_Contact):
+iec_path = "%s.%s"%(self.InstancePath, block.GetName())
+self.Subscribed[block] = iec_path.upper()
+self.Controler.SubscribeDebugIECVariable(iec_path.upper(), block)
+self.RefreshVisibleElements()
 self.ShowErrors()
 self.Refresh(False)
 def GetMaxSize(self):
 maxx = maxy = 0
 connector.SetPosition(wx.Point(*output_connector["position"]))
 def CreateWires(self, start_connector, links, ids):
 for link in links:
 refLocalId = link["refLocalId"]
-if refLocalId != None:
+if refLocalId is not None:
 if refLocalId not in ids:
-new_instance = self.Controler.GetEditedElementInstanceInfos(self.TagName, refLocalId)
+new_instance = self.Controler.GetEditedElementInstanceInfos(self.TagName, refLocalId, debug = self.Debug)
-if new_instance:
+if new_instance is not None:
 self.loadInstance(new_instance, ids)
 connected = self.FindElementById(refLocalId)
-if connected:
+if connected is not None:
 points = link["points"]
 end_connector = connected.GetConnector(wx.Point(points[-1][0], points[-1][1]), link["formalParameter"])
-if end_connector:
+if end_connector is not None:
 wire = Wire(self)
 wire.SetPoints(points)
 start_connector.Connect((wire, 0), False)
 end_connector.Connect((wire, -1), False)
 wire.ConnectStartPoint(None, start_connector)
 wire.ConnectEndPoint(None, end_connector)
 self.AddWire(wire)
 def IsOfType(self, type, reference):
-return self.Controler.IsOfType(type, reference)
+return self.Controler.IsOfType(type, reference, self.Debug)
 def IsEndType(self, type):
 return self.Controler.IsEndType(type)
 def GetBlockType(self, type, inputs = None):
-return self.Controler.GetBlockType(type, inputs)
+return self.Controler.GetBlockType(type, inputs, self.Debug)
 #-------------------------------------------------------------------------------
 #                          Search Element functions
 #-------------------------------------------------------------------------------
 for element in self.GetElements():
 if element.HitTest(pos) or element.TestHandle(pos) != (0, 0):
 return element
 return None
-def FindBlockConnector(self, pos, direction = None, exclude = True):
+def FindBlockConnector(self, pos, direction = None, exclude = None):
 for block in self.Blocks:
 result = block.TestConnector(pos, direction, exclude)
 if result:
 return result
 return None
 #                           Popup menu functions
 #-------------------------------------------------------------------------------
 def PopupBlockMenu(self, connector = None):
 if connector is not None and connector.IsCompatible("BOOL"):
-type = self.Controler.GetEditedElementType(self.TagName)
+type = self.Controler.GetEditedElementType(self.TagName, self.Debug)
 self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS0, True)
 self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS1, True)
 self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS2, type != "function")
 self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS3, type != "function")
 else:
 self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS5, False)
 self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS6, False)
 self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS8, False)
 self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS9, False)
 self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS14, False)
-self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS16, self.SelectedElement.GetType() in self.Controler.GetProjectPouNames())
+self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS16, self.SelectedElement.GetType() in self.Controler.GetProjectPouNames(self.Debug))
 self.ContextualMenu.Enable(ID_VIEWERCONTEXTUALMENUITEMS17, True)
-if connector:
+if connector is not None:
 if connector.IsNegated():
 self.ContextualMenu.Check(ID_VIEWERCONTEXTUALMENUITEMS1, True)
 elif connector.GetEdge() == "rising":
 self.ContextualMenu.Check(ID_VIEWERCONTEXTUALMENUITEMS2, True)
 elif connector.GetEdge() == "falling":
 #-------------------------------------------------------------------------------
 #                            Menu items functions
 #-------------------------------------------------------------------------------
 def OnAlignLeftMenu(self, event):
-if self.SelectedElement and isinstance(self.SelectedElement, Graphic_Group):
+if self.SelectedElement is not None and isinstance(self.SelectedElement, Graphic_Group):
 self.SelectedElement.AlignElements(ALIGN_LEFT, None)
 self.RefreshBuffer()
 self.Refresh(False)
 event.Skip()
 def OnAlignCenterMenu(self, event):
-if self.SelectedElement and isinstance(self.SelectedElement, Graphic_Group):
+if self.SelectedElement is not None and isinstance(self.SelectedElement, Graphic_Group):
 self.SelectedElement.AlignElements(ALIGN_CENTER, None)
 self.RefreshBuffer()
 self.Refresh(False)
 event.Skip()
 def OnAlignRightMenu(self, event):
-if self.SelectedElement and isinstance(self.SelectedElement, Graphic_Group):
+if self.SelectedElement is not None and isinstance(self.SelectedElement, Graphic_Group):
 self.SelectedElement.AlignElements(ALIGN_RIGHT, None)
 self.RefreshBuffer()
 self.Refresh(False)
 event.Skip()
 def OnAlignTopMenu(self, event):
-if self.SelectedElement and isinstance(self.SelectedElement, Graphic_Group):
+if self.SelectedElement is not None and isinstance(self.SelectedElement, Graphic_Group):
 self.SelectedElement.AlignElements(None, ALIGN_TOP)
 self.RefreshBuffer()
 self.Refresh(False)
 event.Skip()
 def OnAlignMiddleMenu(self, event):
-if self.SelectedElement and isinstance(self.SelectedElement, Graphic_Group):
+if self.SelectedElement is not None and isinstance(self.SelectedElement, Graphic_Group):
 self.SelectedElement.AlignElements(None, ALIGN_MIDDLE)
 self.RefreshBuffer()
 self.Refresh(False)
 event.Skip()
 def OnAlignBottomMenu(self, event):
-if self.SelectedElement and isinstance(self.SelectedElement, Graphic_Group):
+if self.SelectedElement is not None and isinstance(self.SelectedElement, Graphic_Group):
 self.SelectedElement.AlignElements(None, ALIGN_BOTTOM)
 self.RefreshBuffer()
 self.Refresh(False)
 event.Skip()
 def OnNoModifierMenu(self, event):
-if self.SelectedElement and self.IsBlock(self.SelectedElement):
+if self.SelectedElement is not None and self.IsBlock(self.SelectedElement):
 self.SelectedElement.SetConnectorNegated(False)
 self.SelectedElement.Refresh()
 self.RefreshBuffer()
 event.Skip()
 def OnNegatedMenu(self, event):
-if self.SelectedElement and self.IsBlock(self.SelectedElement):
+if self.SelectedElement is not None and self.IsBlock(self.SelectedElement):
 self.SelectedElement.SetConnectorNegated(True)
 self.SelectedElement.Refresh()
 self.RefreshBuffer()
 event.Skip()
 def OnRisingEdgeMenu(self, event):
-if self.SelectedElement and self.IsBlock(self.SelectedElement):
+if self.SelectedElement is not None and self.IsBlock(self.SelectedElement):
 self.SelectedElement.SetConnectorEdge("rising")
 self.SelectedElement.Refresh()
 self.RefreshBuffer()
 event.Skip()
 def OnFallingEdgeMenu(self, event):
-if self.SelectedElement and self.IsBlock(self.SelectedElement):
+if self.SelectedElement is not None and self.IsBlock(self.SelectedElement):
 self.SelectedElement.SetConnectorEdge("falling")
 self.SelectedElement.Refresh()
 self.RefreshBuffer()
 event.Skip()
 def OnAddSegmentMenu(self, event):
-if self.SelectedElement and self.IsWire(self.SelectedElement):
+if self.SelectedElement is not None and self.IsWire(self.SelectedElement):
 self.SelectedElement.AddSegment()
 self.SelectedElement.Refresh()
 event.Skip()
 def OnDeleteSegmentMenu(self, event):
-if self.SelectedElement and self.IsWire(self.SelectedElement):
+if self.SelectedElement is not None and self.IsWire(self.SelectedElement):
 self.SelectedElement.DeleteSegment()
 self.SelectedElement.Refresh()
 event.Skip()
 def OnAddBranchMenu(self, event):
-if self.SelectedElement and self.IsBlock(self.SelectedElement):
+if self.SelectedElement is not None and self.IsBlock(self.SelectedElement):
 self.AddDivergenceBranch(self.SelectedElement)
 self.RefreshBuffer()
 event.Skip()
 def OnDeleteBranchMenu(self, event):
-if self.SelectedElement and self.IsBlock(self.SelectedElement):
+if self.SelectedElement is not None and self.IsBlock(self.SelectedElement):
 self.RemoveDivergenceBranch(self.SelectedElement)
 self.RefreshBuffer()
 event.Skip()
 def OnEditBlockMenu(self, event):
-if self.SelectedElement:
+if self.SelectedElement is not None:
 self.ParentWindow.EditProjectElement(ITEM_POU, "P::%s"%self.SelectedElement.GetType())
 event.Skip()
 def OnDeleteMenu(self, event):
-if self.SelectedElement:
+if self.SelectedElement is not None:
 self.SelectedElement.Delete()
 self.SelectedElement = None
 self.RefreshBuffer()
 self.Refresh(False)
 event.Skip()
 def OnViewerLeftDown(self, event):
 if self.Mode == MODE_SELECTION:
 dc = self.GetLogicalDC()
 pos = event.GetLogicalPosition(dc)
-if event.ControlDown() and self.SelectedElement:
+if event.ControlDown() and self.SelectedElement is not None:
 element = self.FindElement(pos, True)
-if element:
+if element is not None:
 if isinstance(self.SelectedElement, Graphic_Group):
 self.SelectedElement.SetSelected(False)
 self.SelectedElement.SelectElement(element)
-elif self.SelectedElement:
+elif self.SelectedElement is not None:
 group = Graphic_Group(self)
 group.SelectElement(self.SelectedElement)
 group.SelectElement(element)
 self.SelectedElement = group
 elements = self.SelectedElement.GetElements()
 elif len(elements) == 1:
 self.SelectedElement = elements[0]
 self.SelectedElement.SetSelected(True)
 else:
 element = self.FindElement(pos)
-if element is None or element.TestHandle(pos) == (0, 0):
+if not self.Debug and (element is None or element.TestHandle(pos) == (0, 0)):
 connector = self.FindBlockConnector(pos)
 else:
 connector = None
-if self.DrawingWire:
+if not self.Debug and self.DrawingWire:
 self.DrawingWire = False
 if self.SelectedElement is not None:
 if element is None or element.TestHandle(pos) == (0, 0):
 connector = self.FindBlockConnector(pos, self.SelectedElement.GetConnectionDirection())
-if connector:
+if connector is not None:
 event.Dragging = lambda : True
 self.SelectedElement.OnMotion(event, self.GetLogicalDC(), self.Scaling)
 if self.SelectedElement.EndConnected is not None:
 self.SelectedElement.ResetPoints()
 self.SelectedElement.GeneratePoints()
 rect = self.SelectedElement.GetRedrawRect()
 self.SelectedElement.Delete()
 self.SelectedElement = None
 element = None
 self.RefreshRect(self.GetScrolledRect(rect), False)
-elif connector:
+elif not self.Debug and connector is not None:
 self.DrawingWire = True
 scaled_pos = GetScaledEventPosition(event, self.GetLogicalDC(), self.Scaling)
 if (connector.GetDirection() == EAST):
 wire = Wire(self, [wx.Point(pos.x, pos.y), EAST], [wx.Point(scaled_pos.x, scaled_pos.y), WEST])
 else:
 wire.oldPos = scaled_pos
 wire.Handle = (HANDLE_POINT, 0)
 wire.ProcessDragging(0, 0, False, None)
 wire.Handle = (HANDLE_POINT, 1)
 self.AddWire(wire)
-if self.SelectedElement:
+if self.SelectedElement is not None:
 self.SelectedElement.SetSelected(False)
 self.SelectedElement = wire
 self.SelectedElement.Refresh()
 else:
-if self.SelectedElement and self.SelectedElement != element:
+if self.SelectedElement is not None and self.SelectedElement != element:
 self.SelectedElement.SetSelected(False)
 self.SelectedElement = None
-if element:
+if element is not None:
 self.SelectedElement = element
-self.SelectedElement.OnLeftDown(event, dc, self.Scaling)
+if self.Debug:
+Graphic_Element.OnLeftDown(self.SelectedElement, event, dc, self.Scaling)
+else:
+self.SelectedElement.OnLeftDown(event, dc, self.Scaling)
 self.SelectedElement.Refresh()
 else:
 self.rubberBand.Reset()
 self.rubberBand.OnLeftDown(event, dc, self.Scaling)
 elif self.Mode in [MODE_BLOCK, MODE_VARIABLE, MODE_CONNECTION, MODE_COMMENT,
 wx.CallAfter(self.AddNewDivergence, bbox)
 elif self.Mode == MODE_JUMP:
 wx.CallAfter(self.AddNewJump, bbox)
 elif self.Mode == MODE_ACTION:
 wx.CallAfter(self.AddNewActionBlock, bbox)
-elif self.Mode == MODE_SELECTION and self.SelectedElement:
+elif self.Mode == MODE_SELECTION and self.SelectedElement is not None:
 dc = self.GetLogicalDC()
-if self.DrawingWire:
+if not self.Debug and self.DrawingWire:
 pos = event.GetLogicalPosition(dc)
 connector = self.FindBlockConnector(pos, self.SelectedElement.GetConnectionDirection())
 if self.SelectedElement.EndConnected is not None:
 self.DrawingWire = False
 self.SelectedElement.StartConnected.HighlightParentBlock(False)
 rect = self.SelectedElement.GetRedrawRect()
 self.SelectedElement.Delete()
 self.SelectedElement = None
 self.RefreshRect(self.GetScrolledRect(rect), False)
 else:
-self.SelectedElement.OnLeftUp(event, dc, self.Scaling)
+if self.Debug:
+Graphic_Element.OnLeftUp(self.SelectedElement, event, dc, self.Scaling)
+else:
+self.SelectedElement.OnLeftUp(event, dc, self.Scaling)
 wx.CallAfter(self.SetCursor, wx.NullCursor)
 if self.Mode != MODE_SELECTION and not self.SavedMode:
 wx.CallAfter(self.ParentWindow.ResetCurrentMode)
 event.Skip()
 def OnViewerRightDown(self, event):
 if self.Mode == MODE_SELECTION:
 dc = self.GetLogicalDC()
 pos = event.GetLogicalPosition(dc)
 element = self.FindElement(pos)
-if self.SelectedElement and self.SelectedElement != element:
+if self.SelectedElement is not None and self.SelectedElement != element:
 self.SelectedElement.SetSelected(False)
 self.SelectedElement = None
 if element:
 self.SelectedElement = element
-self.SelectedElement.OnRightDown(event, dc, self.Scaling)
+if self.Debug:
+Graphic_Element.OnRightDown(self.SelectedElement, event, dc, self.Scaling)
+else:
+self.SelectedElement.OnRightDown(event, dc, self.Scaling)
 self.SelectedElement.Refresh()
 event.Skip()
 def OnViewerRightUp(self, event):
 dc = self.GetLogicalDC()
-if self.SelectedElement:
+if self.SelectedElement is not None:
-self.SelectedElement.OnRightUp(event, dc, self.Scaling)
+if self.Debug:
+Graphic_Element.OnRightUp(self.SelectedElement, event, dc, self.Scaling)
+else:
+self.SelectedElement.OnRightUp(event, dc, self.Scaling)
 wx.CallAfter(self.SetCursor, wx.NullCursor)
-else:
+elif not self.Debug:
 self.PopupDefaultMenu(False)
 event.Skip()
 def OnViewerLeftDClick(self, event):
-if self.Mode == MODE_SELECTION and self.SelectedElement:
+if self.Mode == MODE_SELECTION and self.SelectedElement is not None:
-if event.ControlDown() and self.IsBlock(self.SelectedElement) and self.SelectedElement.GetType() in self.Controler.GetProjectPouNames():
+if self.Debug:
+Graphic_Element.OnLeftDClick(self.SelectedElement, event, self.GetLogicalDC(), self.Scaling)
+elif event.ControlDown() and self.IsBlock(self.SelectedElement) and self.SelectedElement.GetType() in self.Controler.GetProjectPouNames(self.Debug):
 self.ParentWindow.EditProjectElement(ITEM_POU, self.SelectedElement.GetType())
 else:
 self.SelectedElement.OnLeftDClick(event, self.GetLogicalDC(), self.Scaling)
 event.Skip()
 if highlighted is not None and self.HighlightedElement != highlighted:
 highlighted.SetHighlighted(True)
 self.HighlightedElement = highlighted
 if self.rubberBand.IsShown():
 self.rubberBand.OnMotion(event, dc, self.Scaling)
-elif self.Mode == MODE_SELECTION and self.SelectedElement:
+elif not self.Debug and self.Mode == MODE_SELECTION and self.SelectedElement is not None:
 if self.DrawingWire:
-connector = self.FindBlockConnector(pos, self.SelectedElement.GetConnectionDirection(), False)
+connector = self.FindBlockConnector(pos, self.SelectedElement.GetConnectionDirection(), self.SelectedElement.EndConnected)
 if not connector or self.SelectedElement.EndConnected == None:
 self.SelectedElement.ResetPoints()
 movex, movey = self.SelectedElement.OnMotion(event, dc, self.Scaling)
 self.SelectedElement.GeneratePoints()
 if movex != 0 or movey != 0:
 self.RefreshRect(self.GetScrolledRect(self.SelectedElement.GetRedrawRect(movex, movey)), False)
 self.UpdateScrollPos(event)
 event.Skip()
 def OnLeaveViewer(self, event):
-if self.SelectedElement and self.SelectedElement.GetDragging():
+if self.SelectedElement is not None and self.SelectedElement.GetDragging():
 event.Skip()
 elif self.HighlightedElement is not None:
 self.HighlightedElement.SetHighlighted(False)
 self.HighlightedElement = None
 event.Skip()
 def UpdateScrollPos(self, event):
-if (event.Dragging() and self.SelectedElement) or self.rubberBand.IsShown():
+if (event.Dragging() and self.SelectedElement is not None) or self.rubberBand.IsShown():
 position = event.GetPosition()
 move_window = wx.Point()
 window_size = self.GetClientSize()
 xstart, ystart = self.GetViewStart()
 if position.x < SCROLL_ZONE and xstart > 0:
 def OnChar(self, event):
 xpos, ypos = self.GetScrollPos(wx.HORIZONTAL), self.GetScrollPos(wx.VERTICAL)
 xmax = self.GetScrollRange(wx.HORIZONTAL) - self.GetScrollThumb(wx.HORIZONTAL)
 ymax = self.GetScrollRange(wx.VERTICAL) - self.GetScrollThumb(wx.VERTICAL)
 keycode = event.GetKeyCode()
-if self.Scaling:
+if self.Scaling is not None:
 scaling = self.Scaling
 else:
 scaling = (8, 8)
-if keycode == wx.WXK_DELETE and self.SelectedElement:
+if not self.Debug and keycode == wx.WXK_DELETE and self.SelectedElement is not None:
 rect = self.SelectedElement.GetRedrawRect(1, 1)
 self.SelectedElement.Delete()
 self.SelectedElement = None
 self.RefreshBuffer()
 self.RefreshScrollBars()
 self.SetCursor(wx.NullCursor)
 self.RefreshRect(self.GetScrolledRect(rect), False)
-elif keycode == wx.WXK_RETURN and self.SelectedElement:
+elif not self.Debug and keycode == wx.WXK_RETURN and self.SelectedElement is not None:
 self.SelectedElement.OnLeftDClick(event, self.GetLogicalDC(), self.Scaling)
 elif keycode == wx.WXK_LEFT:
 if event.ControlDown() and event.ShiftDown():
 self.Scroll(0, ypos)
 elif event.ControlDown():
 event.Skip()
-elif self.SelectedElement:
+elif not self.Debug and self.SelectedElement is not None:
 self.SelectedElement.Move(-scaling[0], 0)
 self.SelectedElement.RefreshModel()
 self.RefreshBuffer()
 self.RefreshScrollBars()
 self.RefreshRect(self.GetScrolledRect(self.SelectedElement.GetRedrawRect(-scaling[0], 0)), False)
 elif keycode == wx.WXK_RIGHT:
 if event.ControlDown() and event.ShiftDown():
 self.Scroll(xmax, ypos)
 elif event.ControlDown():
 event.Skip()
-elif self.SelectedElement:
+elif not self.Debug and self.SelectedElement is not None:
 self.SelectedElement.Move(scaling[0], 0)
 self.SelectedElement.RefreshModel()
 self.RefreshBuffer()
 self.RefreshScrollBars()
 self.RefreshRect(self.GetScrolledRect(self.SelectedElement.GetRedrawRect(scaling[0], 0)), False)
 elif keycode == wx.WXK_UP:
 if event.ControlDown() and event.ShiftDown():
 self.Scroll(xpos, 0)
 elif event.ControlDown():
 event.Skip()
-elif self.SelectedElement:
+elif not self.Debug and self.SelectedElement is not None:
 self.SelectedElement.Move(0, -scaling[1])
 self.SelectedElement.RefreshModel()
 self.RefreshBuffer()
 self.RefreshScrollBars()
 self.RefreshRect(self.GetScrolledRect(self.SelectedElement.GetRedrawRect(0, -scaling[1])), False)
 elif keycode == wx.WXK_DOWN:
 if event.ControlDown() and event.ShiftDown():
 self.Scroll(xpos, ymax)
 elif event.ControlDown():
 event.Skip()
-elif self.SelectedElement:
+elif not self.Debug and self.SelectedElement is not None:
 self.SelectedElement.Move(0, scaling[1])
 self.SelectedElement.RefreshModel()
 self.RefreshBuffer()
 self.RefreshScrollBars()
 self.RefreshRect(self.GetScrolledRect(self.SelectedElement.GetRedrawRect(0, scaling[1])), False)
-elif keycode == wx.WXK_SPACE and self.SelectedElement is not None and self.SelectedElement.Dragging:
+elif not self.Debug and keycode == wx.WXK_SPACE and self.SelectedElement is not None and self.SelectedElement.Dragging:
 if self.IsBlock(self.SelectedElement) or self.IsComment(self.SelectedElement):
 self.CopyBlock(self.SelectedElement, wx.Point(*self.SelectedElement.GetPosition()))
 self.RefreshBuffer()
 self.RefreshScrollBars()
 self.ParentWindow.RefreshVariablePanel(self.TagName)
 return width, height
 def AddNewBlock(self, bbox):
 dialog = BlockPropertiesDialog(self.ParentWindow, self.Controler)
 dialog.SetPreviewFont(self.GetFont())
-dialog.SetBlockList(self.Controler.GetBlockTypes(self.TagName))
+dialog.SetBlockList(self.Controler.GetBlockTypes(self.TagName, self.Debug))
-dialog.SetPouNames(self.Controler.GetProjectPouNames())
+dialog.SetPouNames(self.Controler.GetProjectPouNames(self.Debug))
-dialog.SetPouElementNames(self.Controler.GetEditedElementVariables(self.TagName))
+dialog.SetPouElementNames(self.Controler.GetEditedElementVariables(self.TagName, self.Debug))
 dialog.SetMinBlockSize((bbox.width, bbox.height))
 if dialog.ShowModal() == wx.ID_OK:
 id = self.GetNewId()
 values = dialog.GetValues()
 if "name" in values:
 self.AddBlock(block)
 self.Controler.AddEditedElementBlock(self.TagName, id, values["type"], values.get("name", None))
 self.RefreshBlockModel(block)
 self.RefreshBuffer()
 self.RefreshScrollBars()
+self.RefreshVisibleElements()
 self.ParentWindow.RefreshVariablePanel(self.TagName)
 self.ParentWindow.RefreshInstancesTree()
 block.Refresh()
 dialog.Destroy()
 def AddNewVariable(self, bbox):
 dialog = VariablePropertiesDialog(self.ParentWindow, self.Controler)
 dialog.SetPreviewFont(self.GetFont())
 dialog.SetMinVariableSize((bbox.width, bbox.height))
 varlist = []
-vars = self.Controler.GetEditedElementInterfaceVars(self.TagName)
+vars = self.Controler.GetEditedElementInterfaceVars(self.TagName, self.Debug)
 if vars:
 for var in vars:
 if var["Edit"]:
 varlist.append((var["Name"], var["Class"], var["Type"]))
-returntype = self.Controler.GetEditedElementInterfaceReturnType(self.TagName)
+returntype = self.Controler.GetEditedElementInterfaceReturnType(self.TagName, self.Debug)
 if returntype:
 varlist.append((self.Controler.GetEditedElementName(self.TagName), "Output", returntype))
 dialog.SetVariables(varlist)
 if dialog.ShowModal() == wx.ID_OK:
 id = self.GetNewId()
 self.AddBlock(variable)
 self.Controler.AddEditedElementVariable(self.TagName, id, values["type"])
 self.RefreshVariableModel(variable)
 self.RefreshBuffer()
 self.RefreshScrollBars()
+self.RefreshVisibleElements()
 variable.Refresh()
 dialog.Destroy()
 def AddNewConnection(self, bbox):
 dialog = ConnectionPropertiesDialog(self.ParentWindow, self.Controler)
 self.AddBlock(connection)
 self.Controler.AddEditedElementConnection(self.TagName, id, values["type"])
 self.RefreshConnectionModel(connection)
 self.RefreshBuffer()
 self.RefreshScrollBars()
+self.RefreshVisibleElements()
 connection.Refresh()
 dialog.Destroy()
 def AddNewComment(self, bbox):
 if wx.VERSION >= (2, 5, 0):
 self.AddComment(comment)
 self.Controler.AddEditedElementComment(self.TagName, id)
 self.RefreshCommentModel(comment)
 self.RefreshBuffer()
 self.RefreshScrollBars()
+self.RefreshVisibleElements()
 comment.Refresh()
 dialog.Destroy()
 def AddNewContact(self, bbox):
 dialog = LDElementDialog(self.ParentWindow, self.Controler, "contact")
 dialog.SetPreviewFont(self.GetFont())
 varlist = []
-vars = self.Controler.GetEditedElementInterfaceVars(self.TagName)
+vars = self.Controler.GetEditedElementInterfaceVars(self.TagName, self.Debug)
 if vars:
 for var in vars:
 if var["Class"] != "Output" and var["Type"] == "BOOL":
 varlist.append(var["Name"])
 dialog.SetVariables(varlist)
 self.AddBlock(contact)
 self.Controler.AddEditedElementContact(self.TagName, id)
 self.RefreshContactModel(contact)
 self.RefreshBuffer()
 self.RefreshScrollBars()
+self.RefreshVisibleElements()
 contact.Refresh()
 dialog.Destroy()
 def AddNewCoil(self, bbox):
 dialog = LDElementDialog(self.ParentWindow, self.Controler, "coil")
 dialog.SetPreviewFont(self.GetFont())
 varlist = []
-vars = self.Controler.GetEditedElementInterfaceVars(self.TagName)
+vars = self.Controler.GetEditedElementInterfaceVars(self.TagName, self.Debug)
 if vars:
 for var in vars:
 if var["Class"] != "Input" and var["Type"] == "BOOL":
 varlist.append(var["Name"])
-returntype = self.Controler.GetEditedElementInterfaceReturnType(self.TagName)
+returntype = self.Controler.GetEditedElementInterfaceReturnType(self.TagName, self.Debug)
 if returntype == "BOOL":
 varlist.append(self.Controler.GetEditedElementName(self.TagName))
 dialog.SetVariables(varlist)
 dialog.SetValues({"name":"","type":COIL_NORMAL})
 dialog.SetElementSize((bbox.width, bbox.height))
 self.AddBlock(coil)
 self.Controler.AddEditedElementCoil(self.TagName, id)
 self.RefreshCoilModel(coil)
 self.RefreshBuffer()
 self.RefreshScrollBars()
+self.RefreshVisibleElements()
 coil.Refresh()
 dialog.Destroy()
 def AddNewPowerRail(self, bbox):
 dialog = LDPowerRailDialog(self.ParentWindow, self.Controler)
 self.AddBlock(powerrail)
 self.Controler.AddEditedElementPowerRail(self.TagName, id, values["type"])
 self.RefreshPowerRailModel(powerrail)
 self.RefreshBuffer()
 self.RefreshScrollBars()
+self.RefreshVisibleElements()
 powerrail.Refresh()
 dialog.Destroy()
 def AddNewStep(self, bbox, initial = False):
 dialog = StepContentDialog(self.ParentWindow, self.Controler, initial)
 dialog.SetPreviewFont(self.GetFont())
-dialog.SetPouNames(self.Controler.GetProjectPouNames())
+dialog.SetPouNames(self.Controler.GetProjectPouNames(self.Debug))
-dialog.SetVariables(self.Controler.GetEditedElementInterfaceVars(self.TagName))
+dialog.SetVariables(self.Controler.GetEditedElementInterfaceVars(self.TagName, self.Debug))
 dialog.SetStepNames([block.GetName() for block in self.Blocks if isinstance(block, SFC_Step)])
 dialog.SetMinStepSize((bbox.width, bbox.height))
 if dialog.ShowModal() == wx.ID_OK:
 id = self.GetNewId()
 values = dialog.GetValues()
 self.AddBlock(step)
 self.Controler.AddEditedElementStep(self.TagName, id)
 self.RefreshStepModel(step)
 self.RefreshBuffer()
 self.RefreshScrollBars()
+self.RefreshVisibleElements()
 step.Refresh()
 dialog.Destroy()
 def AddNewTransition(self, bbox):
 dialog = TransitionContentDialog(self.ParentWindow, self.Controler, self.GetDrawingMode() == FREEDRAWING_MODE)
 dialog.SetPreviewFont(self.GetFont())
-dialog.SetTransitions(self.Controler.GetEditedElementTransitions(self.TagName))
+dialog.SetTransitions(self.Controler.GetEditedElementTransitions(self.TagName, self.Debug))
 if dialog.ShowModal() == wx.ID_OK:
 id = self.GetNewId()
 values = dialog.GetValues()
 transition = SFC_Transition(self, values["type"], values["value"], values["priority"], id)
 transition.SetPosition(bbox.x, bbox.y)
 self.AddBlock(transition)
 self.Controler.AddEditedElementTransition(self.TagName, id)
 self.RefreshTransitionModel(transition)
 self.RefreshBuffer()
 self.RefreshScrollBars()
+self.RefreshVisibleElements()
 transition.Refresh()
 dialog.Destroy()
 def AddNewDivergence(self, bbox):
 dialog = DivergenceCreateDialog(self.ParentWindow, self.Controler)
 self.AddBlock(divergence)
 self.Controler.AddEditedElementDivergence(self.TagName, id, values["type"])
 self.RefreshDivergenceModel(divergence)
 self.RefreshBuffer()
 self.RefreshScrollBars()
+self.RefreshVisibleElements()
 divergence.Refresh()
 dialog.Destroy()
 def AddNewJump(self, bbox):
 choices = []
 self.AddBlock(jump)
 self.Controler.AddEditedElementJump(self.TagName, id)
 self.RefreshJumpModel(jump)
 self.RefreshBuffer()
 self.RefreshScrollBars()
+self.RefreshVisibleElements()
 jump.Refresh()
 dialog.Destroy()
 def AddNewActionBlock(self, bbox):
 dialog = ActionBlockDialog(self.ParentWindow)
 dialog.SetQualifierList(self.Controler.GetQualifierTypes())
-dialog.SetActionList(self.Controler.GetEditedElementActions(self.TagName))
+dialog.SetActionList(self.Controler.GetEditedElementActions(self.TagName, self.Debug))
-dialog.SetVariableList(self.Controler.GetEditedElementInterfaceVars(self.TagName))
+dialog.SetVariableList(self.Controler.GetEditedElementInterfaceVars(self.TagName, self.Debug))
 if dialog.ShowModal() == wx.ID_OK:
 actions = dialog.GetValues()
 id = self.GetNewId()
 actionblock = SFC_ActionBlock(self, actions, id)
 actionblock.SetPosition(bbox.x, bbox.y)
 self.AddBlock(actionblock)
 self.Controler.AddEditedElementActionBlock(self.TagName, id)
 self.RefreshActionBlockModel(actionblock)
 self.RefreshBuffer()
 self.RefreshScrollBars()
+self.RefreshVisibleElements()
 actionblock.Refresh()
 dialog.Destroy()
 #-------------------------------------------------------------------------------
 #                          Edit element content functions
 #-------------------------------------------------------------------------------
 def EditBlockContent(self, block):
 dialog = BlockPropertiesDialog(self.ParentWindow, self.Controler)
 dialog.SetPreviewFont(self.GetFont())
-dialog.SetBlockList(self.Controler.GetBlockTypes(self.TagName))
+dialog.SetBlockList(self.Controler.GetBlockTypes(self.TagName, self.Debug))
-dialog.SetPouNames(self.Controler.GetProjectPouNames())
+dialog.SetPouNames(self.Controler.GetProjectPouNames(self.Debug))
-variable_names = self.Controler.GetEditedElementVariables(self.TagName)
+variable_names = self.Controler.GetEditedElementVariables(self.TagName, self.Debug)
 if block.GetName() != "":
 variable_names.remove(block.GetName())
 dialog.SetPouElementNames(variable_names)
 dialog.SetMinBlockSize(block.GetSize())
 old_values = {"name" : block.GetName(), "type" : block.GetType(), "inputs" : block.GetInputTypes(),
 self.RefreshBlockModel(block)
 if old_values["executionOrder"] != new_values["executionOrder"]:
 self.RefreshView()
 self.RefreshBuffer()
 self.RefreshScrollBars()
+self.RefreshVisibleElements()
 self.ParentWindow.RefreshVariablePanel(self.TagName)
 self.ParentWindow.RefreshInstancesTree()
 block.Refresh(rect)
 dialog.Destroy()
 def EditVariableContent(self, variable):
 dialog = VariablePropertiesDialog(self.ParentWindow, self.Controler)
 dialog.SetPreviewFont(self.GetFont())
 dialog.SetMinVariableSize(variable.GetSize())
 varlist = []
-vars = self.Controler.GetEditedElementInterfaceVars(self.TagName)
+vars = self.Controler.GetEditedElementInterfaceVars(self.TagName, self.Debug)
 if vars:
 for var in vars:
 if var["Edit"]:
 varlist.append((var["Name"], var["Class"], var["Type"]))
-returntype = self.Controler.GetEditedElementInterfaceReturnType(self.TagName)
+returntype = self.Controler.GetEditedElementInterfaceReturnType(self.TagName, self.Debug)
 if returntype:
 varlist.append((self.Controler.GetEditedElementName(self.TagName), "Output", returntype))
 dialog.SetVariables(varlist)
 old_values = {"name" : variable.GetName(), "type" : variable.GetType(),
 "executionOrder" : variable.GetExecutionOrder()}
 self.Controler.AddEditedElementVariable(self.TagName, id, new_values["type"])
 self.RefreshVariableModel(variable)
 if old_values["executionOrder"] != new_values["executionOrder"]:
 self.RefreshView()
 self.RefreshBuffer()
+self.RefreshVisibleElements()
 self.RefreshScrollBars()
 variable.Refresh(rect)
 dialog.Destroy()
 def EditConnectionContent(self, connection):
 self.Controler.RemoveEditedElementInstance(self.TagName, id)
 self.Controler.AddEditedElementConnection(self.TagName, id, values["type"])
 self.RefreshConnectionModel(connection)
 self.RefreshBuffer()
 self.RefreshScrollBars()
+self.RefreshVisibleElements()
 connection.Refresh(rect)
 dialog.Destroy()
 def EditContactContent(self, contact):
 dialog = LDElementDialog(self.ParentWindow, self.Controler, "contact")
 dialog.SetPreviewFont(self.GetFont())
 varlist = []
-vars = self.Controler.GetEditedElementInterfaceVars(self.TagName)
+vars = self.Controler.GetEditedElementInterfaceVars(self.TagName, self.Debug)
 if vars:
 for var in vars:
 if var["Class"] != "Output" and var["Type"] == "BOOL":
 varlist.append(var["Name"])
 dialog.SetVariables(varlist)
 contact.SetSize(*self.GetScaledSize(values["width"], values["height"]))
 rect = rect.Union(contact.GetRedrawRect())
 self.RefreshContactModel(contact)
 self.RefreshBuffer()
 self.RefreshScrollBars()
+self.RefreshVisibleElements()
 contact.Refresh(rect)
 dialog.Destroy()
 def EditCoilContent(self, coil):
 dialog = LDElementDialog(self.ParentWindow, self.Controler, "coil")
 dialog.SetPreviewFont(self.GetFont())
 varlist = []
-vars = self.Controler.GetEditedElementInterfaceVars(self.TagName)
+vars = self.Controler.GetEditedElementInterfaceVars(self.TagName, self.Debug)
 if vars:
 for var in vars:
 if var["Class"] != "Input" and var["Type"] == "BOOL":
 varlist.append(var["Name"])
-returntype = self.Controler.GetEditedElementInterfaceReturnType(self.TagName)
+returntype = self.Controler.GetEditedElementInterfaceReturnType(self.TagName, self.Debug)
 if returntype == "BOOL":
 varlist.append(self.Controler.GetEditedElementName(self.TagName))
 dialog.SetVariables(varlist)
 values = {"name" : coil.GetName(), "type" : coil.GetType()}
 dialog.SetValues(values)
 coil.SetSize(*self.GetScaledSize(values["width"], values["height"]))
 rect = rect.Union(coil.GetRedrawRect())
 self.RefreshCoilModel(coil)
 self.RefreshBuffer()
 self.RefreshScrollBars()
+self.RefreshVisibleElements()
 coil.Refresh(rect)
 dialog.Destroy()
 def EditPowerRailContent(self, powerrail):
 dialog = LDPowerRailDialog(self.ParentWindow, self.Controler, powerrail.GetType(), len(powerrail.GetConnectors()))
 self.Controler.RemoveEditedElementInstance(self.TagName, id)
 self.Controler.AddEditedElementPowerRail(self.TagName, id, values["type"])
 self.RefreshPowerRailModel(powerrail)
 self.RefreshBuffer()
 self.RefreshScrollBars()
+self.RefreshVisibleElements()
 powerrail.Refresh(rect)
 dialog.Destroy()
 def EditStepContent(self, step):
 dialog = StepContentDialog(self.ParentWindow, self.Controler, step.GetInitial())
 dialog.SetPreviewFont(self.GetFont())
-dialog.SetPouNames(self.Controler.GetProjectPouNames())
+dialog.SetPouNames(self.Controler.GetProjectPouNames(self.Debug))
-dialog.SetVariables(self.Controler.GetEditedElementInterfaceVars(self.TagName))
+dialog.SetVariables(self.Controler.GetEditedElementInterfaceVars(self.TagName, self.Debug))
 dialog.SetStepNames([block.GetName() for block in self.Blocks if isinstance(block, SFC_Step) and block.GetName() != step.GetName()])
 dialog.SetMinStepSize(step.GetSize())
 values = {"name" : step.GetName()}
 connectors = step.GetConnectors()
 values["input"] = connectors["input"] != None
 step.UpdateSize(*self.GetScaledSize(values["width"], values["height"]))
 rect = rect.Union(step.GetRedrawRect())
 self.RefreshStepModel(step)
 self.RefreshBuffer()
 self.RefreshScrollBars()
+self.RefreshVisibleElements()
 step.Refresh(rect)
 def EditTransitionContent(self, transition):
 dialog = TransitionContentDialog(self.ParentWindow, self.Controler, self.GetDrawingMode() == FREEDRAWING_MODE)
 dialog.SetPreviewFont(self.GetFont())
-dialog.SetTransitions(self.Controler.GetEditedElementTransitions(self.TagName))
+dialog.SetTransitions(self.Controler.GetEditedElementTransitions(self.TagName, self.Debug))
 dialog.SetValues({"type":transition.GetType(),"value":transition.GetCondition(), "priority":transition.GetPriority()})
 dialog.SetElementSize(transition.GetSize())
 if dialog.ShowModal() == wx.ID_OK:
 values = dialog.GetValues()
 rect = transition.GetRedrawRect(1, 1)
 transition.SetPriority(values["priority"])
 rect = rect.Union(transition.GetRedrawRect())
 self.RefreshTransitionModel(transition)
 self.RefreshBuffer()
 self.RefreshScrollBars()
+self.RefreshVisibleElements()
 transition.Refresh(rect)
 dialog.Destroy()
 def EditJumpContent(self, jump):
 choices = []
 jump.SetTarget(value)
 rect = rect.Union(jump.GetRedrawRect())
 self.RefreshJumpModel(jump)
 self.RefreshBuffer()
 self.RefreshScrollBars()
+self.RefreshVisibleElements()
 jump.Refresh(rect)
 dialog.Destroy()
 def EditActionBlockContent(self, actionblock):
 dialog = ActionBlockDialog(self.ParentWindow)
 dialog.SetQualifierList(self.Controler.GetQualifierTypes())
-dialog.SetActionList(self.Controler.GetEditedElementActions(self.TagName))
+dialog.SetActionList(self.Controler.GetEditedElementActions(self.TagName, self.Debug))
-dialog.SetVariableList(self.Controler.GetEditedElementInterfaceVars(self.TagName))
+dialog.SetVariableList(self.Controler.GetEditedElementInterfaceVars(self.TagName, self.Debug))
 dialog.SetValues(actionblock.GetActions())
 if dialog.ShowModal() == wx.ID_OK:
 actions = dialog.GetValues()
 rect = actionblock.GetRedrawRect(1, 1)
 actionblock.SetActions(actions)
 actionblock.SetSize(*self.GetScaledSize(*actionblock.GetSize()))
 rect = rect.Union(actionblock.GetRedrawRect())
 self.RefreshActionBlockModel(actionblock)
 self.RefreshBuffer()
 self.RefreshScrollBars()
+self.RefreshVisibleElements()
 actionblock.Refresh(rect)
 dialog.Destroy()
 def EditCommentContent(self, comment):
 if wx.VERSION >= (2, 5, 0):
 comment.SetSize(*self.GetScaledSize(*comment.GetSize()))
 rect = rect.Union(comment.GetRedrawRect())
 self.RefreshCommentModel(comment)
 self.RefreshBuffer()
 self.RefreshScrollBars()
+self.RefreshVisibleElements()
 comment.Refresh(rect)
 dialog.Destroy()
 #-------------------------------------------------------------------------------
 #                          Model update functions
 #-------------------------------------------------------------------------------
 #                            Editing functions
 #-------------------------------------------------------------------------------
 def Cut(self):
-if self.IsBlock(self.SelectedElement) or self.IsComment(self.SelectedElement):
+if not self.Debug and (self.IsBlock(self.SelectedElement) or self.IsComment(self.SelectedElement)):
 self.ParentWindow.SetCopyBuffer(self.SelectedElement.Clone(self))
 rect = self.SelectedElement.GetRedrawRect(1, 1)
 self.SelectedElement.Delete()
 self.SelectedElement = None
 self.RefreshBuffer()
 self.ParentWindow.RefreshVariablePanel(self.TagName)
 self.ParentWindow.RefreshInstancesTree()
 self.RefreshRect(self.GetScrolledRect(rect), False)
 def Copy(self):
-if self.IsBlock(self.SelectedElement) or self.IsComment(self.SelectedElement):
+if not self.Debug and (self.IsBlock(self.SelectedElement) or self.IsComment(self.SelectedElement)):
 self.ParentWindow.SetCopyBuffer(self.SelectedElement.Clone(self))
 def Paste(self):
 element = self.ParentWindow.GetCopyBuffer()
-if element is not None and self.CanAddBlock(element):
+if not self.Debug and element is not None and self.CanAddBlock(element):
 block = self.CopyBlock(element, wx.Point(*self.CalcUnscrolledPosition(30, 30)))
 if self.SelectedElement is not None:
 self.SelectedElement.SetSelected(False)
 self.SelectedElement = block
 self.SelectedElement.SetSelected(True)
 self.RefreshBuffer()
 self.RefreshScrollBars()
+self.RefreshVisibleElements()
 self.ParentWindow.RefreshVariablePanel(self.TagName)
 self.ParentWindow.RefreshInstancesTree()
 def CanAddBlock(self, block):
 if self.CurrentLanguage == "SFC":
 def CopyBlock(self, element, pos):
 id = self.GetNewId()
 if isinstance(element, FBD_Block) and element.GetName() != "" or isinstance(element, SFC_Step):
 if isinstance(element, FBD_Block):
-names = [varname.upper() for varname in self.Controler.GetEditedElementVariables(self.TagName)]
+names = [varname.upper() for varname in self.Controler.GetEditedElementVariables(self.TagName, self.Debug)]
 format = "Block%d"
 elif isinstance(element, SFC_Step):
 names = [block.GetName().upper() for block in self.Blocks if isinstance(block, SFC_Step)]
 format = "Step%d"
 i = 1
 #-------------------------------------------------------------------------------
 #                            Drawing functions
 #-------------------------------------------------------------------------------
+def OnScrollWindow(self, event):
+if event.GetOrientation() == wx.HORIZONTAL:
+self.RefreshVisibleElements(xp = event.GetPosition())
+else:
+self.RefreshVisibleElements(yp = event.GetPosition())
+event.Skip()
 def OnMoveWindow(self, event):
 self.GetBestSize()
 self.RefreshScrollBars()
+self.RefreshVisibleElements()
 event.Skip()
 def DoDrawing(self, dc, printing = False):
 if printing:
 if getattr(dc, "printing", False):
 dc.DrawLine(xstart * SCROLLBAR_UNIT, ystart * SCROLLBAR_UNIT + y + 1,
 xstart * SCROLLBAR_UNIT + window_size[0], ystart * SCROLLBAR_UNIT + y + 1)
 # Draw all elements
 for comment in self.Comments:
-if comment != self.SelectedElement:
+if comment != self.SelectedElement and (comment.IsVisible() or printing):
 comment.Draw(dc)
 for wire in self.Wires:
-if wire != self.SelectedElement:
+if wire != self.SelectedElement and (wire.IsVisible() or printing):
-wire.Draw(dc)
+if not self.Debug or wire.GetValue() != True:
+wire.Draw(dc)
+if self.Debug:
+for wire in self.Wires:
+if wire != self.SelectedElement and (wire.IsVisible() or printing) and wire.GetValue() == True:
+wire.Draw(dc)
 for block in self.Blocks:
-if block != self.SelectedElement:
+if block != self.SelectedElement and (block.IsVisible() or printing):
 block.Draw(dc)
-if self.SelectedElement:
+if self.SelectedElement is not None and (self.SelectedElement.IsVisible() or printing):
 self.SelectedElement.Draw(dc)
 if not printing:
 if self.rubberBand.IsShown():
 self.rubberBand.Draw(dc)
 dc.EndDrawing()

changeset 249	d8425712acef
parent 243	c5da8b706cde
child 253	d9391572655f