plcopeneditor_history: comparison LDViewer.py

equal deleted inserted replaced

-:0688db995ddf
+:4a8400732001
 class LD_Viewer(Viewer):
 def __init__(self, parent, window, controler):
 Viewer.__init__(self, parent, window, controler)
 self.Rungs = []
-self.Comments = []
+self.RungComments = []
 #-------------------------------------------------------------------------------
 #                          Refresh functions
 #-------------------------------------------------------------------------------
 def RefreshView(self):
 Viewer.RefreshView(self)
 for i, rung in enumerate(self.Rungs):
 bbox = rung.GetBoundingBox()
-if i < len(self.Comments):
+if i < len(self.RungComments):
-pos = self.Comments[i].GetPosition()
+pos = self.RungComments[i].GetPosition()
 if pos[1] > bbox.y:
-self.Comment.insert(i, None)
+self.RungComments.insert(i, None)
 else:
-self.Comment.insert(i, None)
+self.RungComments.insert(i, None)
 def loadInstance(self, instance, ids):
 Viewer.loadInstance(self, instance, ids)
 if instance["type"] == "leftPowerRail":
 element = self.FindElementById(instance["id"])
 elif instance["type"] == "comment":
 element = self.FindElementById(instance["id"])
 pos = element.GetPosition()
 i = 0
 inserted = False
-while i < len(self.Comments) and not inserted:
+while i < len(self.RungComments) and not inserted:
-ipos = self.Comments[i].GetPosition()
+ipos = self.RungComments[i].GetPosition()
 if pos[1] < ipos[1]:
-self.Comments.insert(i, element)
+self.RungComments.insert(i, element)
 inserted = True
 i += 1
 if not inserted:
-self.Comments.append(element)
+self.RungComments.append(element)
 #-------------------------------------------------------------------------------
 #                          Search Element functions
 #-------------------------------------------------------------------------------
 def FindElement(self, pos):
 if self.GetDrawingMode() == FREEDRAWING_MODE:
 return Viewer.FindElement(self, pos)
 elements = []
-for element in self.Elements:
+for element in self.GetElements(sort_wires=True):
 if element.HitTest(pos) or element.TestHandle(pos) != (0, 0):
 elements.append(element)
 if len(elements) == 1:
 return elements[0]
 elif len(elements) > 1:
 group = Graphic_Group(self)
 for element in elements:
-if element in self.Blocks:
+if self.IsBlock(element):
 return element
 group.SelectElement(element)
 return group
 return None
 if self.GetDrawingMode() == FREEDRAWING_MODE:
 return Viewer.SearchElements(self, bbox)
 elements = []
 for element in self.Blocks:
-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
 #-------------------------------------------------------------------------------
 #                          Mouse event functions
 elif self.Mode == MODE_SELECTION:
 dc = self.GetLogicalDC()
 pos = event.GetLogicalPosition(dc)
 element = self.FindElement(pos)
 if self.SelectedElement:
-if self.SelectedElement in self.Elements:
+if not isinstance(self.SelectedElement, Graphic_Group):
 if self.SelectedElement != element:
-if self.SelectedElement in self.Wires:
+if self.IsWire(self.SelectedElement):
 self.SelectedElement.SetSelectedSegment(None)
 else:
 self.SelectedElement.SetSelected(False)
 else:
 self.SelectedElement = None
-elif element and element not in self.Elements:
+elif element and isinstance(element, Graphic_Group):
 if self.SelectedElement.GetElements() != element.GetElements():
 for elt in self.SelectedElement.GetElements():
-if elt in self.Wires:
+if self.IsWire(elt):
 elt.SetSelectedSegment(None)
 self.SelectedElement.SetSelected(False)
 self.SelectedElement = None
 else:
 for elt in self.SelectedElement.GetElements():
-if elt in self.Wires:
+if self.IsWire(elt):
 elt.SetSelectedSegment(None)
 self.SelectedElement.SetSelected(False)
 self.SelectedElement = None
 self.Refresh()
 if element:
 self.SelectedElement.SetElements(elements)
 self.SelectedElement.SetSelected(True)
 self.Refresh()
 elif self.Mode == MODE_SELECTION and self.SelectedElement:
 dc = self.GetLogicalDC()
-if self.SelectedElement in self.Elements:
+if not isinstance(self.SelectedElement, Graphic_Group):
-if self.SelectedElement in self.Wires:
+if self.IsWire(self.SelectedElement):
 result = self.SelectedElement.TestSegment(event.GetLogicalPosition(dc), True)
 if result and result[1] in [EAST, WEST]:
 self.SelectedElement.SetSelectedSegment(result[0])
 else:
 self.SelectedElement.OnLeftUp(event, dc, self.Scaling)
 else:
 for element in self.SelectedElement.GetElements():
-if element in self.Wires:
+if self.IsWire(element):
 result = element.TestSegment(event.GetLogicalPosition(dc), True)
 if result and result[1] in [EAST, WEST]:
 element.SetSelectedSegment(result[0])
 else:
 element.OnLeftUp(event, dc, self.Scaling)
 element = self.FindElement(pos)
 if element:
 if self.SelectedElement and self.SelectedElement != element:
 self.SelectedElement.SetSelected(False)
 self.SelectedElement = element
-if self.SelectedElement in self.Wires:
+if self.IsWire(self.SelectedElement):
 self.SelectedElement.SetSelectedSegment(0)
 else:
 self.SelectedElement.SetSelected(True)
 self.SelectedElement.OnRightUp(event, dc, self.Scaling)
 wxCallAfter(self.SetCursor, wxNullCursor)
 event.Skip()
 def OnViewerMotion(self, event):
 if self.GetDrawingMode() == FREEDRAWING_MODE:
 Viewer.OnViewerMotion(self, event)
+elif self.rubberBand.IsShown():
+self.rubberBand.OnMotion(event, self.GetLogicalDC(), self.Scaling)
 event.Skip()
 #-------------------------------------------------------------------------------
 #                          Keyboard event functions
 #-------------------------------------------------------------------------------
 if self.GetDrawingMode() == FREEDRAWING_MODE:
 Viewer.OnChar(self, event)
 else:
 keycode = event.GetKeyCode()
 if keycode == WXK_DELETE and self.SelectedElement:
-if self.SelectedElement in self.Blocks:
+if self.IsBlock(self.SelectedElement):
 self.SelectedElement.Delete()
-elif self.SelectedElement in self.Wires:
+elif self.IsWire(self.SelectedElement):
 self.DeleteWire(self.SelectedElement)
-elif self.SelectedElement not in self.Elements:
+elif isinstance(self.SelectedElement, Graphic_Group):
 all_wires = True
 for element in self.SelectedElement.GetElements():
-all_wires &= element in self.Wires
+all_wires &= self.IsWire(element)
 if all_wires:
 self.DeleteWire(self.SelectedElement)
 else:
 self.SelectedElement.Delete()
 self.Refresh()
 #-------------------------------------------------------------------------------
 #                          Adding element functions
 #-------------------------------------------------------------------------------
-def AddRung(self):
+def AddLadderRung(self):
 dialog = LDElementDialog(self.Parent, "coil")
 varlist = []
 vars = self.Controler.GetCurrentElementEditingInterfaceVars()
 if vars:
 for var in vars:
 # Create comment
 id = self.GetNewId()
 comment = Comment(self, "Commentaire", id)
 comment.SetPosition(startx, starty)
 comment.SetSize(LD_COMMENT_DEFAULTSIZE[0], LD_COMMENT_DEFAULTSIZE[1])
-self.Elements.append(comment)
+self.AddComment(comment)
-self.Comments.append(comment)
+self.RungComments.append(comment)
 self.Controler.AddCurrentElementEditingComment(id)
 self.RefreshCommentModel(comment)
 starty += LD_COMMENT_DEFAULTSIZE[1] + LD_OFFSET[1]
 # Create LeftPowerRail
 id = self.GetNewId()
 leftpowerrail = LD_PowerRail(self, LEFTRAIL, id)
 leftpowerrail.SetPosition(startx, starty)
-self.Elements.append(leftpowerrail)
+self.AddBlock(leftpowerrail)
-self.Blocks.append(leftpowerrail)
 rung.SelectElement(leftpowerrail)
 self.Controler.AddCurrentElementEditingPowerRail(id, LEFTRAIL)
 self.RefreshPowerRailModel(leftpowerrail)
 # Create Coil
 id = self.GetNewId()
 coil = LD_Coil(self, values["type"], values["name"], id)
 coil.SetPosition(startx, starty + (LD_LINE_SIZE - LD_ELEMENT_SIZE[1]) / 2)
-self.Elements.append(coil)
+self.AddBlock(coil)
-self.Blocks.append(coil)
 rung.SelectElement(coil)
 self.Controler.AddCurrentElementEditingCoil(id)
 # Create Wire between LeftPowerRail and Coil
 wire = Wire(self)
 start_connector = coil.GetConnectors()["input"]
 end_connector = leftpowerrail.GetConnectors()[0]
 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.AddWires(wire)
-self.Elements.append(wire)
 rung.SelectElement(wire)
 # Create RightPowerRail
 id = self.GetNewId()
 rightpowerrail = LD_PowerRail(self, RIGHTRAIL, id)
 rightpowerrail.SetPosition(startx, starty)
-self.Elements.append(rightpowerrail)
+self.AddBlock(rightpowerrail)
-self.Blocks.append(rightpowerrail)
 rung.SelectElement(rightpowerrail)
 self.Controler.AddCurrentElementEditingPowerRail(id, RIGHTRAIL)
 # Create Wire between LeftPowerRail and Coil
 wire = Wire(self)
 start_connector = rightpowerrail.GetConnectors()[0]
 end_connector = coil.GetConnectors()["output"]
 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.AddWires(wire)
-self.Elements.append(wire)
 rung.SelectElement(wire)
 self.RefreshPosition(coil)
 self.Rungs.append(rung)
 self.Refresh()
-def AddContact(self):
+def AddLadderContact(self):
 wires = []
-if self.SelectedElement in self.Wires:
+if self.IsWire(self.SelectedElement):
 left_element = self.SelectedElement.EndConnected
 if not isinstance(left_element.GetParentBlock(), LD_Coil):
 wires.append(self.SelectedElement)
-elif self.SelectedElement and self.SelectedElement not in self.Elements:
+elif self.SelectedElement and isinstance(self.SelectedElement,Graphic_Group):
-if False not in [element in self.Wires for element in self.SelectedElement.GetElements()]:
+if False not in [self.IsWire(element) for element in self.SelectedElement.GetElements()]:
 for element in self.SelectedElement.GetElements():
 wires.append(element)
 if len(wires) > 0:
 dialog = LDElementDialog(self.Parent, "contact")
 varlist = []
 values = dialog.GetValues()
 points = wires[0].GetSelectedSegmentPoints()
 id = self.GetNewId()
 contact = LD_Contact(self, values["type"], values["name"], id)
 contact.SetPosition(0, points[0].y - (LD_ELEMENT_SIZE[1] + 1) / 2)
-self.Elements.append(contact)
+self.AddBlock(contact)
-self.Blocks.append(contact)
 self.Controler.AddCurrentElementEditingContact(id)
 rungindex = self.FindRung(wires[0])
 rung = self.Rungs[rungindex]
 old_bbox = rung.GetBoundingBox()
 rung.SelectElement(contact)
 idx = right_elements.index(wire.StartConnected)
 right_index[idx] = min(right_index[idx], wire.StartConnected.GetWireIndex(wire))
 wire.SetSelectedSegment(None)
 wire.Clean()
 rung.SelectElement(wire)
-self.Wires.remove(wire)
+self.RemoveWire(wire)
-self.Elements.remove(wire)
 wires = []
 right_wires = []
 for i, left_element in enumerate(left_elements):
 wire = Wire(self)
 wires.append(wire)
 connectors["output"].Connect((wire, -1), False)
 wire.ConnectStartPoint(None, right_element)
 wire.ConnectEndPoint(None, connectors["output"])
 right_wires.reverse()
 for wire in wires:
-self.Wires.append(wire)
+self.AddWire(wire)
-self.Elements.append(wire)
 rung.SelectElement(wire)
 self.RefreshPosition(contact)
 if len(right_wires) > 1:
 group = Graphic_Group(self)
 group.SetSelected(False)
 else:
 message = wxMessageDialog(self, "You must select the wire where a contact should be added!", "Error", wxOK|wxICON_ERROR)
 message.ShowModal()
 message.Destroy()
-def AddBranch(self):
+def AddLadderBranch(self):
 blocks = []
-if self.SelectedElement in self.Blocks:
+if self.IsBlock(self.SelectedElement):
 blocks = [self.SelectedElement]
-elif self.SelectedElement not in self.Elements:
+elif isinstance(self.SelectedElement, Graphic_Group):
 elements = self.SelectedElement.GetElements()
 for element in elements:
 blocks.append(element)
 if len(blocks) > 0:
 blocks_infos = []
 # Create Coil
 id = self.GetNewId()
 coil = LD_Coil(self, values["type"], values["name"], id)
 pos = blocks[0].GetPosition()
 coil.SetPosition(pos[0], pos[1] + LD_LINE_SIZE)
-self.Elements.append(coil)
+self.AddBlock(coil)
-self.Blocks.append(coil)
 rung.SelectElement(coil)
 self.Controler.AddCurrentElementEditingCoil(id)
 coil_connectors = coil.GetConnectors()
 # Create Wire between LeftPowerRail and Coil
 wire = Wire(self)
 connectors[index + 1].Connect((wire, 0), False)
 coil_connectors["output"].Connect((wire, -1), False)
 wire.ConnectStartPoint(None, connectors[index + 1])
 wire.ConnectEndPoint(None, coil_connectors["output"])
-self.Wires.append(wire)
+self.AddWire(wire)
-self.Elements.append(wire)
 rung.SelectElement(wire)
 left_elements.reverse()
 for i, left_element in enumerate(left_elements):
 # Create Wire between LeftPowerRail and Coil
 new_wire = Wire(self)
 left_element.InsertConnect(left_index[i] + 1, (new_wire, -1), False)
 new_wire.ConnectStartPoint(None, right_element)
 new_wire.ConnectEndPoint(None, left_element)
 wires.reverse()
 for wire in wires:
-self.Wires.append(wire)
+self.AddWire(wire)
-self.Elements.append(wire)
 rung.SelectElement(wire)
 right_elements.reverse()
 for block in blocks:
 self.RefreshPosition(block)
 for right_element in right_elements:
 else:
 message = wxMessageDialog(self, "You must select the block or group of blocks around which a branch should be added!", "Error", wxOK|wxICON_ERROR)
 message.ShowModal()
 message.Destroy()
-def AddBlock(self):
+def AddLadderBlock(self):
 message = wxMessageDialog(self, "This option isn't available yet!", "Warning", wxOK|wxICON_EXCLAMATION)
 message.ShowModal()
 message.Destroy()
 #-------------------------------------------------------------------------------
 left_elements = [(wire.EndConnected, wire.EndConnected.GetWireIndex(wire)) for wire in input_wires]
 right_elements = [(wire.StartConnected, wire.StartConnected.GetWireIndex(wire)) for wire in output_wires]
 for wire in input_wires:
 wire.Clean()
 rung.SelectElement(wire)
-self.Wires.remove(wire)
+self.RemoveWire(wire)
-self.Elements.remove(wire)
 for wire in output_wires:
 wire.Clean()
 rung.SelectElement(wire)
-self.Wires.remove(wire)
+self.RemoveWire(wire)
-self.Elements.remove(wire)
 rung.SelectElement(contact)
 contact.Clean()
 left_elements.reverse()
 right_elements.reverse()
 powerrail = len(left_elements) == 1 and isinstance(left_elements[0][0].GetParentBlock(), LD_PowerRail)
 index = left_powerrail.GetConnectorIndex(wire.EndConnected)
 left_powerrail.DeleteConnector(index)
 wire_removed.append(wire)
 for wire in wire_removed:
 wire.Clean()
-self.Wires.remove(wire)
+self.RemoveWire(wire)
-self.Elements.remove(wire)
 rung.SelectElement(wire)
 wires = []
 for left_element, left_index in left_elements:
 for right_element, right_index in right_elements:
 wire = Wire(self)
 left_element.InsertConnect(left_index, (wire, -1), False)
 wire.ConnectStartPoint(None, right_element)
 wire.ConnectEndPoint(None, left_element)
 wires.reverse()
 for wire in wires:
-self.Wires.append(wire)
+self.RemoveWire(wire)
-self.Elements.append(wire)
 rung.SelectElement(wire)
 right_elements.reverse()
 for right_element, right_index in right_elements:
 self.RefreshPosition(right_element.GetParentBlock())
-self.Blocks.remove(contact)
+self.RemoveBlock(contact)
-self.Elements.remove(contact)
 self.Controler.RemoveCurrentElementEditingInstance(contact.GetId())
 rung.RefreshBoundingBox()
 new_bbox = rung.GetBoundingBox()
 self.RefreshRungs(new_bbox.height - old_bbox.height, rungindex + 1)
 self.SelectedElement = None
 left_elements = [wire.EndConnected for wire in input_wires]
 rung.SelectElement(element)
 element.Clean()
 for wire in input_wires:
 wire.Clean()
-self.Wires.remove(wire)
+self.RemoveWire(wire)
-self.Elements.remove(wire)
 rung.SelectElement(wire)
-self.Blocks.remove(element)
+self.RemoveBlock(element)
-self.Elements.remove(element)
 self.Controler.RemoveCurrentElementEditingInstance(element.GetId())
 for left_element in left_elements:
 block = left_element.GetParentBlock()
 if len(left_element.GetWires()) == 0:
 self.RecursiveDeletion(block, rung)
 block.Move(0, startpoint.y - endpoint.y)
 self.RefreshPosition(block)
 self.RecursiveDeletion(coil, rung)
 else:
 for element in rung.GetElements():
-if element in self.Wires:
+if self.IsWire(element):
 element.Clean()
-self.Wires.remove(element)
+self.RemoveWire(element)
-self.Elements.remove(element)
 for element in rung.GetElements():
-if element in self.Blocks:
+if self.IsBlock(element):
 self.Controler.RemoveCurrentElementEditingInstance(element.GetId())
-self.Blocks.remove(element)
+self.RemoveBlock(element)
-self.Elements.remove(element)
 self.Controler.RemoveCurrentElementEditingInstance(self.Comments[rungindex].GetId())
-self.Elements.remove(self.Comments[rungindex])
+self.RemoveComment(self.RungComments[rungindex])
-self.Comments.pop(rungindex)
+self.RungComments.pop(rungindex)
 self.Rungs.pop(rungindex)
 if rungindex < len(self.Rungs):
 next_bbox = self.Rungs[rungindex].GetBoundingBox()
 self.RefreshRungs(old_bbox.y - next_bbox.y, rungindex)
 self.SelectedElement = None
 Viewer.DeleteWire(self, wire)
 else:
 wires = []
 left_elements = []
 right_elements = []
-if wire in self.Wires:
+if self.IsWire(wire):
 wires = [wire]
-elif wire not in self.Elements:
+elif isinstance(wire, Graphic_Group):
 for element in wire.GetElements():
-if element in self.Wires:
+if self.IsWire(element):
 wires.append(element)
 else:
 wires = []
 break
 if len(wires) > 0:
 left_elements.append(wire.EndConnected)
 if wire.StartConnected not in right_elements:
 right_elements.append(wire.StartConnected)
 if connections == (False, False) or connections == (False, True) and isinstance(left_block, LD_PowerRail):
 wire.Clean()
-self.Wires.remove(wire)
+self.RemoveWire(wire)
-self.Elements.remove(wire)
 rung.SelectElement(wire)
 for left_element in left_elements:
 left_block = left_element.GetParentBlock()
 if isinstance(left_block, LD_PowerRail):
 if len(left_element.GetWires()) == 0:
 self.RefreshPosition(wire.StartConnected.GetParentBlock())
 def RefreshRungs(self, movey, fromidx):
 if movey != 0:
 for i in xrange(fromidx, len(self.Rungs)):
-self.Comments[i].Move(0, movey)
+self.RungComments[i].Move(0, movey)
-self.Comments[i].RefreshModel()
+self.RungComments[i].RefreshModel()
 self.Rungs[i].Move(0, movey)
 for element in self.Rungs[i].GetElements():
-if element in self.Blocks:
+if self.IsBlock(element):
 self.RefreshPosition(element)
 #-------------------------------------------------------------------------------
 #                          Edit element content functions
 #-------------------------------------------------------------------------------

changeset 42	4a8400732001
parent 28	fc23e1f415d8
child 45	42637f721b5b