plcopeneditor_history: comparison Viewer.py

equal deleted inserted replaced

-:0688db995ddf
+:4a8400732001
 self.Scaling = None
 #self.Scaling = (8, 8)
 self.DrawGrid = True
 self.current_id = 0
+# Initialize Block, Wire and Comment numbers
+self.block_id = self.wire_id = self.comment_id = 0
 # Initialize Viewer mode to Selection mode
 self.Mode = MODE_SELECTION
 self.SavedMode = False
 self.Parent = window
 dc = wxClientDC(self)
 self.DoPrepareDC(dc)
 return dc
 #-------------------------------------------------------------------------------
+#                         Element management functions
+#-------------------------------------------------------------------------------
+def AddBlock(self, block):
+self.block_id += 1
+self.Blocks[block] = self.block_id
+def AddWire(self, wire):
+self.wire_id += 1
+self.Wires[wire] = self.wire_id
+def AddComment(self, comment):
+self.comment_id += 1
+self.Comments[comment] = self.comment_id
+def IsBlock(self, block):
+return self.Blocks.get(block, False)
+def IsWire(self, wire):
+return self.Wires.get(wire, False)
+def IsComment(self, comment):
+return self.Comments.get(comment, False)
+def RemoveBlock(self, block):
+self.Blocks.pop(block)
+def RemoveWire(self, wire):
+self.Wires.pop(wire)
+def RemoveComment(self, comment):
+self.Comments.pop(comment)
+def GetElements(self, sort_blocks=False, sort_wires=False, sort_comments=False):
+blocks = self.Blocks.keys()
+wires = self.Wires.keys()
+comments = self.Comments.keys()
+if sort_blocks:
+blocks.sort(lambda x,y:self.Blocks[x].__cmp__(self.Blocks[y]))
+if sort_wires:
+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
+#-------------------------------------------------------------------------------
 #                              Reset functions
 #-------------------------------------------------------------------------------
 # Resets Viewer lists
 def ResetView(self):
-self.Blocks = []
+self.Blocks = {}
-self.Wires = []
+self.Wires = {}
-self.Elements = []
+self.Comments = {}
 self.SelectedElement = None
 # Changes Viewer mode
 def SetMode(self, mode):
 if self.Mode != mode or mode == MODE_SELECTION:
 # Load Blocks until they are all loaded
 while instance:
 instance = self.Controler.GetCurrentElementEditingInstanceInfos(exclude=ids)
 if instance:
 self.loadInstance(instance, ids)
-self.RefreshScrollBar()
+self.RefreshScrollBars()
 self.Refresh()
-def RefreshScrollBar(self):
+def RefreshScrollBars(self):
 xstart, ystart = self.GetViewStart()
 window_size = self.GetClientSize()
 maxx = maxy = 0
-for element in self.Elements:
+for element in self.GetElements():
 posx, posy = element.GetPosition()
 width, height = element.GetSize()
 maxx = max(maxx, posx + width)
 maxy = max(maxy, posy + height)
 maxx = max(maxx + WINDOW_BORDER, xstart * SCROLLBAR_UNIT + window_size[0])
 self.current_id = max(self.current_id, instance["id"])
 if instance["type"] == "input":
 variable = FBD_Variable(self, INPUT, instance["name"], instance["value_type"], instance["id"])
 variable.SetPosition(instance["x"], instance["y"])
 variable.SetSize(instance["width"], instance["height"])
-self.Blocks.append(variable)
+self.AddBlock(variable)
-self.Elements.append(variable)
 connectors = variable.GetConnectors()
 connectors["output"].SetPosition(wxPoint(*instance["connector"]["position"]))
 if instance["connector"]["negated"]:
 connectors["output"].SetNegated(True)
 if instance["connector"]["edge"]:
 connectors["output"].SetEdge(instance["connector"]["edge"])
 elif instance["type"] == "output":
 variable = FBD_Variable(self, OUTPUT, instance["name"], instance["value_type"], instance["id"])
 variable.SetPosition(instance["x"], instance["y"])
 variable.SetSize(instance["width"], instance["height"])
-self.Blocks.append(variable)
+self.AddBlock(variable)
-self.Elements.append(variable)
 connectors = variable.GetConnectors()
 connectors["input"].SetPosition(wxPoint(*instance["connector"]["position"]))
 if instance["connector"]["negated"]:
 connectors["input"].SetNegated(True)
 if instance["connector"]["edge"]:
 self.CreateWires(connectors["input"], instance["connector"]["links"], ids)
 elif instance["type"] == "inout":
 variable = FBD_Variable(self, INOUT, instance["name"], instance["value_type"], instance["id"])
 variable.SetPosition(instance["x"], instance["y"])
 variable.SetSize(instance["width"], instance["height"])
-self.Blocks.append(variable)
+self.AddBlock(variable)
-self.Elements.append(variable)
 connectors = variable.GetConnectors()
 connectors["output"].SetPosition(wxPoint(*instance["connectors"]["output"]["position"]))
 connectors["input"].SetPosition(wxPoint(*instance["connectors"]["input"]["position"]))
 if instance["connectors"]["output"]["negated"]:
 connectors["output"].SetNegated(True)
 self.CreateWires(connectors["input"], instance["connectors"]["input"]["links"], ids)
 elif instance["type"] == "continuation":
 connection = FBD_Connector(self, CONTINUATION, instance["name"], instance["id"])
 connection.SetPosition(instance["x"], instance["y"])
 connection.SetSize(instance["width"], instance["height"])
-self.Blocks.append(connection)
+self.AddBlock(connection)
-self.Elements.append(connection)
 connector = connection.GetConnector()
 connector.SetPosition(wxPoint(*instance["connector"]["position"]))
 elif instance["type"] == "connection":
 connection = FBD_Connector(self, CONNECTOR, instance["name"], instance["id"])
 connection.SetPosition(instance["x"], instance["y"])
 connection.SetSize(instance["width"], instance["height"])
-self.Blocks.append(connection)
+self.AddBlock(connection)
-self.Elements.append(connection)
 connector = connection.GetConnector()
 connector.SetPosition(wxPoint(*instance["connector"]["position"]))
 self.CreateWires(connector, instance["connector"]["links"], ids)
 elif instance["type"] == "comment":
 comment = Comment(self, instance["content"], instance["id"])
 comment.SetPosition(instance["x"], instance["y"])
 comment.SetSize(instance["width"], instance["height"])
-self.Elements.append(comment)
+self.AddComment(comment)
 elif instance["type"] == "leftPowerRail":
 leftpowerrail = LD_PowerRail(self, LEFTRAIL, instance["id"], [True for i in range(len(instance["connectors"]))])
 leftpowerrail.SetPosition(instance["x"], instance["y"])
-self.Blocks.append(leftpowerrail)
+self.AddBlock(leftpowerrail)
-self.Elements.append(leftpowerrail)
 connectors = leftpowerrail.GetConnectors()
 for i, connector in enumerate(instance["connectors"]):
 connectors[i].SetPosition(wxPoint(*connector["position"]))
 elif instance["type"] == "rightPowerRail":
 rightpowerrail = LD_PowerRail(self, RIGHTRAIL, instance["id"], [True for i in range(len(instance["connectors"]))])
 rightpowerrail.SetPosition(instance["x"], instance["y"])
-self.Blocks.append(rightpowerrail)
+self.AddBlock(rightpowerrail)
-self.Elements.append(rightpowerrail)
 connectors = rightpowerrail.GetConnectors()
 for i, connector in enumerate(instance["connectors"]):
 connectors[i].SetPosition(wxPoint(*connector["position"]))
 self.CreateWires(connectors[i], connector["links"], ids)
 elif instance["type"] == "contact":
 contact_type = CONTACT_FALLING
 else:
 contact_type = CONTACT_NORMAL
 contact = LD_Contact(self, contact_type, instance["name"], instance["id"])
 contact.SetPosition(instance["x"], instance["y"])
-self.Blocks.append(contact)
+self.AddBlock(contact)
-self.Elements.append(contact)
 connectors = contact.GetConnectors()
 connectors["input"].SetPosition(wxPoint(*instance["connectors"]["input"]["position"]))
 self.CreateWires(connectors["input"], instance["connectors"]["input"]["links"], ids)
 connectors["output"].SetPosition(wxPoint(*instance["connectors"]["output"]["position"]))
 elif instance["type"] == "coil":
 coil_type = COIL_RESET
 else:
 coil_type = COIL_NORMAL
 coil = LD_Coil(self, coil_type, instance["name"], instance["id"])
 coil.SetPosition(instance["x"], instance["y"])
-self.Blocks.append(coil)
+self.AddBlock(coil)
-self.Elements.append(coil)
 connectors = coil.GetConnectors()
 connectors["input"].SetPosition(wxPoint(*instance["connectors"]["input"]["position"]))
 self.CreateWires(connectors["input"], instance["connectors"]["input"]["links"], ids)
 connectors["output"].SetPosition(wxPoint(*instance["connectors"]["output"]["position"]))
 elif instance["type"] == "step":
 else:
 initial = False
 step = SFC_Step(self, instance["name"], initial, instance["id"])
 step.SetPosition(instance["x"], instance["y"])
 step.SetSize(instance["width"], instance["height"])
-self.Blocks.append(step)
+self.AddBlock(step)
-self.Elements.append(step)
 if "output" in instance["connectors"]:
 step.AddOutput()
 if "action" in instance["connectors"]:
 step.AddAction()
 connectors = step.GetConnectors()
 if connectors["action"]:
 connectors["action"].SetPosition(wxPoint(*instance["connectors"]["action"]["position"]))
 elif instance["type"] == "transition":
 transition = SFC_Transition(self, instance["condition_type"], instance["condition"], instance["id"])
 transition.SetPosition(instance["x"], instance["y"])
-self.Blocks.append(transition)
+self.AddBlock(transition)
-self.Elements.append(transition)
 connectors = transition.GetConnectors()
 connectors["input"].SetPosition(wxPoint(*instance["connectors"]["input"]["position"]))
 self.CreateWires(connectors["input"], instance["connectors"]["input"]["links"], ids)
 connectors["output"].SetPosition(wxPoint(*instance["connectors"]["output"]["position"]))
 elif instance["type"] in ["selectionDivergence", "selectionConvergence", "simultaneousDivergence", "simultaneousConvergence"]:
 else:
 divergence = SFC_Divergence(self, SIMULTANEOUS_CONVERGENCE,
 len(instance["connectors"]["inputs"]), instance["id"])
 divergence.SetPosition(instance["x"], instance["y"])
 divergence.SetSize(instance["width"], instance["height"])
-self.Blocks.append(divergence)
+self.AddBlock(divergence)
-self.Elements.append(divergence)
 connectors = divergence.GetConnectors()
 for i, input_connector in enumerate(instance["connectors"]["inputs"]):
 connector = connectors["inputs"][i]
 connector.SetPosition(wxPoint(*input_connector["position"]))
 self.CreateWires(connector, input_connector["links"], ids)
 connector = connectors["outputs"][i]
 connector.SetPosition(wxPoint(*output_connector["position"]))
 elif instance["type"] == "jump":
 jump = SFC_Jump(self, instance["target"], instance["id"])
 jump.SetPosition(instance["x"], instance["y"])
-self.Blocks.append(jump)
+self.AddBlock(jump)
-self.Elements.append(jump)
 connector = jump.GetConnector()
 connector.SetPosition(wxPoint(*instance["connector"]["position"]))
 self.CreateWires(connector, instance["connector"]["links"], ids)
 elif instance["type"] == "actionBlock":
 actionBlock = SFC_ActionBlock(self, instance["actions"], instance["id"])
 actionBlock.SetPosition(instance["x"], instance["y"])
 actionBlock.SetSize(instance["width"], instance["height"])
-self.Blocks.append(actionBlock)
+self.AddBlock(actionBlock)
-self.Elements.append(actionBlock)
 connector = actionBlock.GetConnector()
 connector.SetPosition(wxPoint(*instance["connector"]["position"]))
 self.CreateWires(connector, instance["connector"]["links"], ids)
 else:
 if instance["name"] != None:
 block = FBD_Block(self, instance["type"], instance["name"], instance["id"], len(instance["connectors"]["inputs"]))
 else:
 block = FBD_Block(self, instance["type"], "", instance["id"], len(instance["connectors"]["inputs"]))
 block.SetPosition(instance["x"], instance["y"])
 block.SetSize(instance["width"], instance["height"])
-self.Blocks.append(block)
+self.AddBlock(block)
-self.Elements.append(block)
 connectors = block.GetConnectors()
 for i, input_connector in enumerate(instance["connectors"]["inputs"]):
 connector = connectors["inputs"][i]
 connector.SetPosition(wxPoint(*input_connector["position"]))
 if input_connector["negated"]:
 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.Wires.append(wire)
+self.AddWire(wire)
-self.Elements.append(wire)
 #-------------------------------------------------------------------------------
 #                          Search Element functions
 #-------------------------------------------------------------------------------
 def FindElement(self, pos, exclude_group = False):
 if self.SelectedElement and not (exclude_group and isinstance(self.SelectedElement, Graphic_Group)):
 if self.SelectedElement.HitTest(pos) or self.SelectedElement.TestHandle(pos) != (0, 0):
 return self.SelectedElement
-for element in self.Elements:
+for element in self.GetElements():
 if element.HitTest(pos) or element.TestHandle(pos) != (0, 0):
 return element
 return None
 def FindBlockConnector(self, pos, exclude = True):
 if result:
 return result
 return None
 def FindElementById(self, id):
-for element in self.Elements:
+for element in self.Blocks:
+if element.GetId() == id:
+return element
+for element in self.Comments:
 if element.GetId() == id:
 return element
 return None
 def SearchElements(self, bbox):
 elements = []
-for element in self.Elements:
+for element in self.GetElements():
-element_bbox = element.GetBoundingBox()
+if element.IsInSelection(bbox):
-if element_bbox.x >= bbox.x and element_bbox.y >= bbox.y and element_bbox.x + element_bbox.width <= bbox.x + bbox.width and element_bbox.y + element_bbox.height <= bbox.y + bbox.height:
 elements.append(element)
 return elements
 #-------------------------------------------------------------------------------
 #                           Popup menu functions
 #-------------------------------------------------------------------------------
 #                            Menu items functions
 #-------------------------------------------------------------------------------
 def OnNoModifierMenu(self, event):
-if self.SelectedElement and self.SelectedElement in self.Blocks:
+if self.SelectedElement and self.IsBlock(self.SelectedElement):
 self.SelectedElement.SetConnectorNegated(False)
 event.Skip()
 def OnNegatedMenu(self, event):
-if self.SelectedElement and self.SelectedElement in self.Blocks:
+if self.SelectedElement and self.IsBlock(self.SelectedElement):
 self.SelectedElement.SetConnectorNegated(True)
 event.Skip()
 def OnRisingEdgeMenu(self, event):
-if self.SelectedElement and self.SelectedElement in self.Blocks:
+if self.SelectedElement and self.IsBlock(self.SelectedElement):
 self.SelectedElement.SetConnectorEdge("rising")
 event.Skip()
 def OnFallingEdgeMenu(self, event):
-if self.SelectedElement and self.SelectedElement in self.Blocks:
+if self.SelectedElement and self.IsBlock(self.SelectedElement):
 self.SelectedElement.SetConnectorEdge("falling")
 event.Skip()
 def OnAddSegmentMenu(self, event):
-if self.SelectedElement and self.SelectedElement in self.Wires:
+if self.SelectedElement and self.IsBlock(self.SelectedElement):
 self.SelectedElement.AddSegment()
 event.Skip()
 def OnDeleteSegmentMenu(self, event):
-if self.SelectedElement and self.SelectedElement in self.Wires:
+if self.SelectedElement and self.IsBlock(self.SelectedElement):
 self.SelectedElement.DeleteSegment()
 event.Skip()
 def OnAddBranchMenu(self, event):
-if self.SelectedElement and self.SelectedElement in self.Blocks:
+if self.SelectedElement and self.IsBlock(self.SelectedElement):
 self.AddDivergenceBranch(self.SelectedElement)
 event.Skip()
 def OnDeleteBranchMenu(self, event):
-if self.SelectedElement and self.SelectedElement in self.Blocks:
+if self.SelectedElement and self.IsBlock(self.SelectedElement):
 self.RemoveDivergenceBranch(self.SelectedElement)
 event.Skip()
 def OnDeleteMenu(self, event):
 if self.SelectedElement:
 wire = Wire(self, [wxPoint(pos.x, pos.y), WEST], [wxPoint(pos.x, pos.y), EAST])
 wire.oldPos = pos
 wire.Handle = (HANDLE_POINT, 0)
 wire.ProcessDragging(0, 0)
 wire.Handle = (HANDLE_POINT, 1)
-self.Wires.append(wire)
+self.AddWire(wire)
-self.Elements.append(wire)
 if self.SelectedElement:
 self.SelectedElement.SetSelected(False)
 self.SelectedElement = wire
 elif self.SelectedElement:
 self.SelectedElement.SetSelected(False)
 self.SelectedElement.OnLeftUp(event, self.GetLogicalDC(), self.Scaling)
 wxCallAfter(self.SetCursor, wxNullCursor)
 self.ReleaseMouse()
 self.Refresh()
 elif self.Mode == MODE_WIRE and self.SelectedElement:
-dc = self.GetLogicalDC()
+if self.SelectedElement.EndConnected != None:
-pos = GetScaledEventPosition(event, dc, self.Scaling)
-connector = self.FindBlockConnector(pos, False)
-if connector and connector != self.SelectedElement.StartConnected:
 self.SelectedElement.ResetPoints()
 self.SelectedElement.OnMotion(event, dc, self.Scaling)
 self.SelectedElement.GeneratePoints()
 self.SelectedElement.RefreshModel()
 self.SelectedElement.SetSelected(True)
 move_window.y = -1
 elif position.y > window_size[1] - SCROLL_ZONE:
 move_window.y = 1
 if move_window.x != 0 or move_window.y != 0:
 self.Scroll(xstart + move_window.x, ystart + move_window.y)
-self.RefreshScrollBar()
+self.RefreshScrollBars()
 event.Skip()
 #-------------------------------------------------------------------------------
 #                          Keyboard event functions
 #-------------------------------------------------------------------------------
 def OnChar(self, event):
+xpos, ypos = self.GetScrollPos(wxHORIZONTAL), self.GetScrollPos(wxVERTICAL)
+xmax = self.GetScrollRange(wxHORIZONTAL) - self.GetScrollThumb(wxHORIZONTAL)
+ymax = self.GetScrollRange(wxVERTICAL) - self.GetScrollThumb(wxVERTICAL)
 keycode = event.GetKeyCode()
 if self.Scaling:
 scaling = self.Scaling
 else:
 scaling = (8, 8)
 if keycode == WXK_DELETE and self.SelectedElement:
 self.SelectedElement.Clean()
 self.SelectedElement.Delete()
 self.SelectedElement = None
-elif keycode == WXK_LEFT and self.SelectedElement:
+elif keycode == WXK_LEFT:
-self.SelectedElement.Move(-scaling[0], 0)
+if event.ControlDown() and event.ShiftDown():
-elif keycode == WXK_RIGHT and self.SelectedElement:
+self.Scroll(0, ypos)
-self.SelectedElement.Move(scaling[0], 0)
+elif event.ControlDown():
-elif keycode == WXK_UP and self.SelectedElement:
+self.Scroll(max(0, xpos - 1), ypos)
-self.SelectedElement.Move(0, -scaling[1])
+elif self.SelectedElement:
-elif keycode == WXK_DOWN and self.SelectedElement:
+self.SelectedElement.Move(-scaling[0], 0)
-self.SelectedElement.Move(0, scaling[1])
+elif keycode == WXK_RIGHT:
+if event.ControlDown() and event.ShiftDown():
+self.Scroll(xmax, ypos)
+elif event.ControlDown():
+self.Scroll(min(xpos + 1, xmax), ypos)
+elif self.SelectedElement:
+self.SelectedElement.Move(scaling[0], 0)
+elif keycode == WXK_UP:
+if event.ControlDown() and event.ShiftDown():
+self.Scroll(xpos, 0)
+elif event.ControlDown():
+self.Scroll(xpos, max(0, ypos - 1))
+elif self.SelectedElement:
+self.SelectedElement.Move(0, -scaling[1])
+elif keycode == WXK_DOWN:
+if event.ControlDown() and event.ShiftDown():
+self.Scroll(xpos, ymax)
+elif event.ControlDown():
+self.Scroll(xpos, min(ypos + 1, ymax))
+elif self.SelectedElement:
+self.SelectedElement.Move(0, scaling[1])
 self.Refresh()
-event.Skip()
 #-------------------------------------------------------------------------------
 #                          Model adding functions
 #-------------------------------------------------------------------------------
 block = FBD_Block(self, values["type"], values["name"], id, values["extension"], values["inputs"])
 else:
 block = FBD_Block(self, values["type"], "", id, values["extension"], values["inputs"])
 block.SetPosition(bbox.x, bbox.y)
 block.SetSize(values["width"], values["height"])
-self.Blocks.append(block)
+self.AddBlock(block)
-self.Elements.append(block)
 self.Controler.AddCurrentElementEditingBlock(id)
 self.RefreshBlockModel(block)
+self.RefreshScrollBars()
 self.Refresh()
 dialog.Destroy()
 def AddNewVariable(self, bbox):
 dialog = VariablePropertiesDialog(self.Parent)
 id = self.GetNewId()
 values = dialog.GetValues()
 variable = FBD_Variable(self, values["type"], values["name"], values["value_type"], id)
 variable.SetPosition(bbox.x, bbox.y)
 variable.SetSize(values["width"], values["height"])
-self.Blocks.append(variable)
+self.AddBlock(variable)
-self.Elements.append(variable)
 self.Controler.AddCurrentElementEditingVariable(id, values["type"])
 self.RefreshVariableModel(variable)
+self.RefreshScrollBars()
 self.Refresh()
 dialog.Destroy()
 def AddNewConnection(self, bbox):
 dialog = ConnectionPropertiesDialog(self.Parent)
 id = self.GetNewId()
 values = dialog.GetValues()
 connection = FBD_Connector(self, values["type"], values["name"], id)
 connection.SetPosition(bbox.x, bbox.y)
 connection.SetSize(values["width"], values["height"])
-self.Blocks.append(connection)
+self.AddBlock(connection)
-self.Elements.append(connection)
 self.Controler.AddCurrentElementEditingConnection(id, values["type"])
 self.RefreshConnectionModel(connection)
+self.RefreshScrollBars()
 self.Refresh()
 dialog.Destroy()
 def AddNewComment(self, bbox):
 dialog = wxTextEntryDialog(self.Parent, "Add a new comment", "Please enter comment text", "", wxOK|wxCANCEL|wxTE_MULTILINE)
 id = self.GetNewId()
 comment = Comment(self, value, id)
 comment.SetPosition(bbox.x, bbox.y)
 min_width, min_height = comment.GetMinSize()
 comment.SetSize(max(min_width,bbox.width),max(min_height,bbox.height))
-self.Elements.append(comment)
+self.AddComment(comment)
 self.Controler.AddCurrentElementEditingComment(id)
 self.RefreshCommentModel(comment)
+self.RefreshScrollBars()
 self.Refresh()
 dialog.Destroy()
 def AddNewContact(self, bbox):
 dialog = LDElementDialog(self.Parent, "contact")
 id = self.GetNewId()
 values = dialog.GetValues()
 contact = LD_Contact(self, values["type"], values["name"], id)
 contact.SetPosition(bbox.x, bbox.y)
 contact.SetSize(values["width"], values["height"])
-self.Blocks.append(contact)
+self.AddBlock(contact)
-self.Elements.append(contact)
 self.Controler.AddCurrentElementEditingContact(id)
 self.RefreshContactModel(contact)
+self.RefreshScrollBars()
 self.Refresh()
 dialog.Destroy()
 def AddNewCoil(self, bbox):
 dialog = LDElementDialog(self.Parent, "coil")
 id = self.GetNewId()
 values = dialog.GetValues()
 coil = LD_Coil(self, values["type"], values["name"], id)
 coil.SetPosition(bbox.x, bbox.y)
 coil.SetSize(values["width"], values["height"])
-self.Blocks.append(coil)
+self.AddBlock(coil)
-self.Elements.append(coil)
 self.Controler.AddCurrentElementEditingCoil(id)
 self.RefreshCoilModel(contact)
+self.RefreshScrollBars()
 self.Refresh()
 dialog.Destroy()
 def AddNewPowerRail(self, bbox):
 dialog = LDPowerRailDialog(self.Parent)
 id = self.GetNewId()
 values = dialog.GetValues()
 powerrail = LD_PowerRail(self, values["type"], id, [True for i in xrange(values["number"])])
 powerrail.SetPosition(bbox.x, bbox.y)
 powerrail.SetSize(values["width"], values["height"])
-self.Blocks.append(powerrail)
+self.AddBlock(powerrail)
-self.Elements.append(powerrail)
 self.Controler.AddCurrentElementEditingPowerRail(id, values["type"])
 self.RefreshPowerRailModel(powerrail)
+self.RefreshScrollBars()
 self.Refresh()
 dialog.Destroy()
 def AddNewTransition(self, bbox):
 dialog = TransitionContentDialog(self.Parent)
 values = dialog.GetValues()
 transition = SFC_Transition(self, values["type"], values["value"], id)
 transition.SetPosition(bbox.x, bbox.y)
 min_width, min_height = transition.GetMinSize()
 transition.SetSize(max(bbox.width, min_width), max(bbox.height, min_height))
-self.Blocks.append(transition)
+self.AddBlock(transition)
-self.Elements.append(transition)
 self.Controler.AddCurrentElementEditingTransition(id)
 self.RefreshTransitionModel(transition)
+self.RefreshScrollBars()
 self.Refresh()
 dialog.Destroy()
 def AddNewDivergence(self, bbox):
 dialog = DivergenceCreateDialog(self.Parent)
 values = dialog.GetValues()
 divergence = SFC_Divergence(self, values["type"], values["number"], id)
 divergence.SetPosition(bbox.x, bbox.y)
 min_width, min_height = divergence.GetMinSize()
 divergence.SetSize(max(bbox.width, min_width), max(bbox.height, min_height))
-self.Blocks.append(divergence)
+self.AddBlock(divergence)
-self.Elements.append(divergence)
 self.Controler.AddCurrentElementEditingDivergence(id, values["type"])
 self.RefreshDivergenceModel(divergence)
+self.RefreshScrollBars()
 self.Refresh()
 dialog.Destroy()
 #-------------------------------------------------------------------------------
 if "name" in values:
 block.SetName(values["name"])
 block.SetSize(values["width"], values["height"])
 block.SetType(values["type"], values["extension"])
 self.RefreshBlockModel(block)
+self.RefreshScrollBars()
 self.Refresh()
 dialog.Destroy()
 def EditVariableContent(self, variable):
 dialog = VariablePropertiesDialog(self.Parent)
 if old_type != values["type"]:
 id = variable.GetId()
 self.Controler.RemoveCurrentElementEditingInstance(id)
 self.Controler.AddCurrentElementEditingVariable(id, values["type"])
 self.RefreshVariableModel(variable)
+self.RefreshScrollBars()
 self.Refresh()
 dialog.Destroy()
 def EditConnectionContent(self, connection):
 dialog = ConnectionPropertiesDialog(self.Parent)
 if old_type != values["type"]:
 id = connection.GetId()
 self.Controler.RemoveCurrentElementEditingInstance(id)
 self.Controler.AddCurrentElementEditingConnection(id, values["type"])
 self.RefreshConnectionModel(connection)
+self.RefreshScrollBars()
 self.Refresh()
 dialog.Destroy()
 def EditContactContent(self, contact):
 dialog = LDElementDialog(self.Parent, "contact")
 values = dialog.GetValues()
 contact.SetName(values["name"])
 contact.SetType(values["type"])
 contact.SetSize(values["width"], values["height"])
 self.RefreshContactModel(contact)
+self.RefreshScrollBars()
 self.Refresh()
 dialog.Destroy()
 def EditCoilContent(self, coil):
 dialog = LDElementDialog(self.Parent, "coil")
 values = dialog.GetValues()
 coil.SetName(values["name"])
 coil.SetType(values["type"])
 coil.SetSize(values["width"], values["height"])
 self.RefreshContactModel(coil)
+self.RefreshScrollBars()
 self.Refresh()
 dialog.Destroy()
 def EditPowerRailContent(self, powerrail):
 dialog = LDPowerRailDialog(self.Parent, powerrail.GetType(), len(powerrail.GetConnectors()))
 if old_type != values["type"]:
 id = powerrail.GetId()
 self.Controler.RemoveCurrentElementEditingInstance(id)
 self.Controler.AddCurrentElementEditingPowerRail(id, values["type"])
 self.RefreshPowerRailModel(powerrail)
+self.RefreshScrollBars()
 self.Refresh()
 dialog.Destroy()
+##
+##
-def AddNewTransition(self, bbox):
+##    def AddNewTransition(self, bbox):
-dialog = TransitionContentDialog(self.Parent)
+##        dialog = TransitionContentDialog(self.Parent)
-dialog.SetTransitions(self.Controler.GetCurrentElementEditingTransitions())
+##        dialog.SetTransitions(self.Controler.GetCurrentElementEditingTransitions())
-if dialog.ShowModal() == wxID_OK:
+##        if dialog.ShowModal() == wxID_OK:
-id = self.GetNewId()
+##            id = self.GetNewId()
-values = dialog.GetValues()
+##            values = dialog.GetValues()
-transition = SFC_Transition(self, values["type"], values["value"], id)
+##            transition = SFC_Transition(self, values["type"], values["value"], id)
-transition.SetPosition(bbox.x, bbox.y)
+##            transition.SetPosition(bbox.x, bbox.y)
-min_width, min_height = transition.GetMinSize()
+##            min_width, min_height = transition.GetMinSize()
-transition.SetSize(max(bbox.width, min_width), max(bbox.height, min_height))
+##            transition.SetSize(max(bbox.width, min_width), max(bbox.height, min_height))
-self.Blocks.append(transition)
+##            self.Blocks.append(transition)
-self.Elements.append(transition)
+##            self.Elements.append(transition)
-self.Controler.AddCurrentElementEditingTransition(id)
+##            self.Controler.AddCurrentElementEditingTransition(id)
-self.RefreshTransitionModel(transition)
+##            self.RefreshTransitionModel(transition)
-self.Refresh()
+##            self.RefreshScrollBars()
-dialog.Destroy()
+##            self.Refresh()
+##        dialog.Destroy()
-def AddNewDivergence(self, bbox):
+##
-dialog = DivergenceCreateDialog(self.Parent)
+##    def AddNewDivergence(self, bbox):
-dialog.SetMinSize((bbox.width, bbox.height))
+##        dialog = DivergenceCreateDialog(self.Parent)
-if dialog.ShowModal() == wxID_OK:
+##        dialog.SetMinSize((bbox.width, bbox.height))
-id = self.GetNewId()
+##        if dialog.ShowModal() == wxID_OK:
-values = dialog.GetValues()
+##            id = self.GetNewId()
-divergence = SFC_Divergence(self, values["type"], values["number"], id)
+##            values = dialog.GetValues()
-divergence.SetPosition(bbox.x, bbox.y)
+##            divergence = SFC_Divergence(self, values["type"], values["number"], id)
-min_width, min_height = divergence.GetMinSize()
+##            divergence.SetPosition(bbox.x, bbox.y)
-divergence.SetSize(max(bbox.width, min_width), max(bbox.height, min_height))
+##            min_width, min_height = divergence.GetMinSize()
-self.Blocks.append(divergence)
+##            divergence.SetSize(max(bbox.width, min_width), max(bbox.height, min_height))
-self.Elements.append(divergence)
+##            self.Blocks.append(divergence)
-self.Controler.AddCurrentElementEditingDivergence(id, values["type"])
+##            self.Elements.append(divergence)
-self.RefreshDivergenceModel(divergence)
+##            self.Controler.AddCurrentElementEditingDivergence(id, values["type"])
-self.Refresh()
+##            self.RefreshDivergenceModel(divergence)
-dialog.Destroy()
+##            self.RefreshScrollBars()
+##            self.Refresh()
+##        dialog.Destroy()
 #-------------------------------------------------------------------------------
 #                          Model update functions
 #-------------------------------------------------------------------------------
 for output in block.GetConnectors()["outputs"]:
 for element in output.GetConnectedBlocks():
 if element not in elements:
 elements.append(element)
 block.Clean()
-self.Blocks.remove(block)
+self.RemoveBlock(block)
-self.Elements.remove(block)
 self.Controler.RemoveCurrentElementEditingInstance(block.GetId())
 for element in elements:
 element.RefreshModel()
 def DeleteVariable(self, variable):
 if connectors["output"]:
 elements = connectors["output"].GetConnectedBlocks()
 else:
 elements = []
 variable.Clean()
-self.Blocks.remove(variable)
+self.RemoveBlock(variable)
-self.Elements.remove(variable)
 self.Controler.RemoveCurrentElementEditingInstance(variable.GetId())
 for element in elements:
 element.RefreshModel()
 def DeleteConnection(self, connection):
 if connection.GetType() == CONTINUATION:
 elements = connection.GetConnector().GetConnectedBlocks()
 else:
 elements = []
 connection.Clean()
-self.Blocks.remove(connection)
+self.RemoveBlock(connection)
-self.Elements.remove(connection)
 self.Controler.RemoveCurrentElementEditingInstance(connection.GetId())
 for element in elements:
 element.RefreshModel()
 def DeleteComment(self, comment):
-self.Elements.remove(comment)
+self.RemoveComment(comment)
 self.Controler.RemoveCurrentElementEditingInstance(comment.GetId())
 def DeleteWire(self, wire):
 if wire in self.Wires:
 connected = wire.GetConnected()
 wire.Clean()
-self.Wires.remove(wire)
+self.RemoveWire(wire)
-self.Elements.remove(wire)
 for connector in connected:
 connector.RefreshParentBlock()
 def DeleteContact(self, contact):
 connectors = contact.GetConnectors()
 elements = connectors["output"].GetConnectedBlocks()
 contact.Clean()
-self.Blocks.remove(contact)
+self.RemoveBlock(contact)
-self.Elements.remove(contact)
 self.Controler.RemoveCurrentElementEditingInstance(contact.GetId())
 for element in elements:
 element.RefreshModel()
 def DeleteCoil(self, coil):
 connectors = coil.GetConnectors()
 elements = connectors["output"].GetConnectedBlocks()
 coil.Clean()
-self.Blocks.remove(coil)
+self.RemoveBlock(coil)
-self.Elements.remove(coil)
 self.Controler.RemoveCurrentElementEditingInstance(coil.GetId())
 for element in elements:
 element.RefreshModel()
 def DeletePowerRail(self, powerrail):
 for connector in powerrail.GetConnectors():
 for element in connector.GetConnectedBlocks():
 if element not in elements:
 elements.append(element)
 powerrrail.Clean()
-self.Blocks.remove(powerrrail)
+self.RemoveBlock(powerrrail)
-self.Elements.remove(powerrrail)
 self.Controler.RemoveCurrentElementEditingInstance(powerrrail.GetId())
 for element in elements:
 element.RefreshModel()
 def DeleteStep(self, step):
 if connectors["action"]:
 for element in connectors["action"].GetConnectedBlocks():
 if element not in elements:
 elements.append(element)
 step.Clean()
-self.Blocks.remove(step)
+self.RemoveBlock(step)
-self.Elements.remove(step)
 self.Controler.RemoveCurrentElementEditingInstance(step.GetId())
 for element in elements:
 element.RefreshModel()
 def DeleteTransition(self, transition):
 if connectors["output"]:
 for element in connectors["output"].GetConnectedBlocks():
 if element not in elements:
 elements.append(element)
 transition.Clean()
-self.Blocks.remove(transition)
+self.RemoveBlock(transition)
-self.Elements.remove(transition)
 self.Controler.RemoveCurrentElementEditingInstance(transition.GetId())
 for element in elements:
 element.RefreshModel()
 def DeleteDivergence(self, divergence):
 for output in connectors["outputs"]:
 for element in output.GetConnectedBlocks():
 if element not in elements:
 elements.append(element)
 divergence.Clean()
-self.Blocks.remove(divergence)
+self.RemoveBlock(divergence)
-self.Elements.remove(divergence)
 self.Controler.RemoveCurrentElementEditingInstance(divergence.GetId())
 for element in elements:
 element.RefreshModel()
 def DeleteJump(self, jump):
 jump.Clean()
-self.Blocks.remove(jump)
+self.RemoveBlock(jump)
-self.Elements.remove(jump)
 self.Controler.RemoveCurrentElementEditingInstance(jump.GetId())
 def DeleteActionBlock(self, actionblock):
 actionblock.Clean()
-self.Blocks.remove(actionblock)
+self.RemoveBlock(actionblock)
-self.Elements.remove(actionblock)
 self.Controler.RemoveCurrentElementEditingInstance(actionblock.GetId())
 #-------------------------------------------------------------------------------
 #                            Editing functions
 #-------------------------------------------------------------------------------
 #                            Drawing functions
 #-------------------------------------------------------------------------------
 def OnMoveWindow(self, event):
-self.RefreshScrollBar()
+self.RefreshScrollBars()
 event.Skip()
 def OnPaint(self, event):
 dc = self.GetLogicalDC()
 dc.Clear()
 width, height = dc.GetSize()
 for i in xrange(1, width / self.Scaling[0] + 1):
 dc.DrawLine(i * self.Scaling[0], 0, i * self.Scaling[0], height)
 for i in xrange(1, height / self.Scaling[1] + 1):
 dc.DrawLine(0, i * self.Scaling[1], width, i * self.Scaling[1])
+for comment in self.Comments:
+if comment != self.SelectedElement:
+comment.Draw(dc)
 for wire in self.Wires:
 if wire != self.SelectedElement:
 wire.Draw(dc)
-for element in self.Elements:
+for block in self.Blocks:
-if element not in self.Wires and element != self.SelectedElement:
+if block != self.SelectedElement:
-element.Draw(dc)
+block.Draw(dc)
 if self.SelectedElement:
 self.SelectedElement.Draw(dc)
 if self.rubberBand.IsShown():
 self.rubberBand.Draw()
 event.Skip()

changeset 42	4a8400732001
parent 28	fc23e1f415d8
child 45	42637f721b5b