beremiz: comparison editors/LDViewer.py

equal deleted inserted replaced

-:31e63e25b4cc
+:64beb9e9c749
 import wx
 import time
 from types import *
 from Viewer import *
 def ExtractNextBlocks(block, block_list):
 current_list = [block]
 while len(current_list) > 0:
 next_list = []
 next = wire.EndConnected.GetParentBlock()
 if not isinstance(next, LD_PowerRail) and next not in block_list:
 block_list.append(next)
 next_list.append(next)
 current_list = next_list
 def CalcBranchSize(elements, stops):
 branch_size = 0
 stop_list = stops
 for stop in stops:
 ExtractNextBlocks(stop, stop_list)
 element_tree = {}
 for element in elements:
 if element not in element_tree:
-element_tree[element] = {"parents":["start"], "children":[], "weight":None}
+element_tree[element] = {"parents": ["start"], "children": [], "weight": None}
 GenerateTree(element, element_tree, stop_list)
 elif element_tree[element]:
 element_tree[element]["parents"].append("start")
-remove_stops = {"start":[], "stop":[]}
+remove_stops = {"start": [], "stop": []}
 for element, values in element_tree.items():
 if "stop" in values["children"]:
 removed = []
 for child in values["children"]:
 if child != "stop":
-##                    if child in elements:
+# if child in elements:
-##                        RemoveElement(child, element_tree)
+#     RemoveElement(child, element_tree)
-##                        removed.append(child)
+#     removed.append(child)
 if "start" in element_tree[child]["parents"]:
 if element not in remove_stops["stop"]:
 remove_stops["stop"].append(element)
 if child not in remove_stops["start"]:
 remove_stops["start"].append(child)
 CalcWeight(element, element_tree)
 if values["weight"]:
 branch_size += values["weight"]
 else:
 return 1
-#print branch_size
 return branch_size
 def RemoveElement(remove, element_tree):
 if remove in element_tree and element_tree[remove]:
 for child in element_tree[remove]["children"]:
 if child != "stop":
 RemoveElement(child, element_tree)
 element_tree.pop(remove)
-##        element_tree[remove] = None
+#        element_tree[remove] = None
 def GenerateTree(element, element_tree, stop_list):
 if element in element_tree:
 connectors = element.GetConnectors()
 input_connectors = []
 input_connectors = [connectors["input"]]
 for connector in input_connectors:
 for wire, handle in connector.GetWires():
 next = wire.EndConnected.GetParentBlock()
 if isinstance(next, LD_PowerRail) and next.GetType() == LEFTRAIL or next in stop_list:
-##                    for remove in element_tree[element]["children"]:
+# for remove in element_tree[element]["children"]:
-##                        RemoveElement(remove, element_tree)
+#     RemoveElement(remove, element_tree)
-##                    element_tree[element]["children"] = ["stop"]
+# element_tree[element]["children"] = ["stop"]
 element_tree[element]["children"].append("stop")
-##                elif element_tree[element]["children"] == ["stop"]:
+# elif element_tree[element]["children"] == ["stop"]:
-##                    element_tree[next] = None
+#     element_tree[next] = None
 elif next not in element_tree or element_tree[next]:
 element_tree[element]["children"].append(next)
 if next in element_tree:
 element_tree[next]["parents"].append(element)
 else:
-element_tree[next] = {"parents":[element], "children":[], "weight":None}
+element_tree[next] = {"parents": [element], "children": [], "weight": None}
 GenerateTree(next, element_tree, stop_list)
 def CalcWeight(element, element_tree):
 weight = 0
 parts = None
 if element in element_tree:
 if not parts:
 parts = 1
 element_tree[element]["weight"] = max(1, weight / parts)
-#-------------------------------------------------------------------------------
+# -------------------------------------------------------------------------------
 #                     Ladder Diagram Graphic elements Viewer class
-#-------------------------------------------------------------------------------
+# -------------------------------------------------------------------------------
-"""
-Class derived from Viewer class that implements a Viewer of Ladder Diagram
-"""
 class LD_Viewer(Viewer):
+"""
-def __init__(self, parent, tagname, window, controler, debug = False, instancepath = ""):
+Class derived from Viewer class that implements a Viewer of Ladder Diagram
+"""
+def __init__(self, parent, tagname, window, controler, debug=False, instancepath=""):
 Viewer.__init__(self, parent, tagname, window, controler, debug, instancepath)
 self.Rungs = []
 self.RungComments = []
 self.CurrentLanguage = "LD"
-#-------------------------------------------------------------------------------
+# -------------------------------------------------------------------------------
 #                          Refresh functions
-#-------------------------------------------------------------------------------
+# -------------------------------------------------------------------------------
 def ResetView(self):
 self.Rungs = []
 self.RungComments = []
 Viewer.ResetView(self)
 pos = self.RungComments[i].GetPosition()
 if pos[1] > bbox.y:
 self.RungComments.insert(i, None)
 else:
 self.RungComments.insert(i, None)
 def loadInstance(self, instance, ids, selection):
 Viewer.loadInstance(self, instance, ids, selection)
 if self.GetDrawingMode() != FREEDRAWING_MODE:
 if instance["type"] == "leftPowerRail":
 element = self.FindElementById(instance["id"])
 connected = self.FindElementById(link["refLocalId"])
 rung = self.FindRung(connected)
 if rung not in rungs:
 rungs.append(rung)
 if len(rungs) > 1:
-raise ValueError, _("Ladder element with id %d is on more than one rung.")%instance["id"]
+raise ValueError(
+_("Ladder element with id %d is on more than one rung.")
+% instance["id"])
 element = self.FindElementById(instance["id"])
 element_connectors = element.GetConnectors()
 self.Rungs[rungs[0]].SelectElement(element)
 for connector in element_connectors["inputs"]:
 for wire, num in connector.GetWires():
 connected = self.FindElementById(link["refLocalId"])
 rung = self.FindRung(connected)
 if rung not in rungs:
 rungs.append(rung)
 if len(rungs) > 1:
-raise ValueError, _("Ladder element with id %d is on more than one rung.")%instance["id"]
+raise ValueError(
+_("Ladder element with id %d is on more than one rung.")
+% instance["id"])
 element = self.FindElementById(instance["id"])
 element_connectors = element.GetConnectors()
 self.Rungs[rungs[0]].SelectElement(element)
 for wire, num in element_connectors["inputs"][0].GetWires():
 self.Rungs[rungs[0]].SelectElement(wire)
 wx.CallAfter(self.RefreshPosition, element)
 elif instance["type"] == "comment":
 element = self.FindElementById(instance["id"])
 pos = element.GetPosition()
 i = 0
 inserted = False
 while i < len(self.RungComments) and not inserted:
 ipos = self.RungComments[i].GetPosition()
 if pos[1] < ipos[1]:
 self.RungComments.insert(i, element)
 inserted = True
 i += 1
 if not inserted:
 self.RungComments.append(element)
-#-------------------------------------------------------------------------------
+# -------------------------------------------------------------------------------
 #                          Search Element functions
-#-------------------------------------------------------------------------------
+# -------------------------------------------------------------------------------
 def FindRung(self, element):
 for i, rung in enumerate(self.Rungs):
 if rung.IsElementIn(element):
 return i
 return None
-def FindElement(self, event, exclude_group = False, connectors = True):
+def FindElement(self, event, exclude_group=False, connectors=True):
 if self.GetDrawingMode() == FREEDRAWING_MODE:
 return Viewer.FindElement(self, event, exclude_group, connectors)
 dc = self.GetLogicalDC()
 pos = event.GetLogicalPosition(dc)
 if self.SelectedElement and not isinstance(self.SelectedElement, (Graphic_Group, Wire)):
 if self.SelectedElement.HitTest(pos, connectors) or self.SelectedElement.TestHandle(pos) != (0, 0):
 return self.SelectedElement
 return None
 def SearchElements(self, bbox):
 if self.GetDrawingMode() == FREEDRAWING_MODE:
 return Viewer.SearchElements(self, bbox)
 elements = []
 for element in self.Blocks.values() + self.Comments.values():
 if element.IsInSelection(bbox):
 elements.append(element)
 return elements
-#-------------------------------------------------------------------------------
+# -------------------------------------------------------------------------------
 #                          Mouse event functions
-#-------------------------------------------------------------------------------
+# -------------------------------------------------------------------------------
 def OnViewerLeftDown(self, event):
 if self.GetDrawingMode() == FREEDRAWING_MODE:
 Viewer.OnViewerLeftDown(self, event)
 elif self.Mode == MODE_SELECTION:
 if len(elements) > 0:
 self.SelectedElement = Graphic_Group(self)
 self.SelectedElement.SetElements(elements)
 self.SelectedElement.SetSelected(True)
 elif self.Mode == MODE_SELECTION and self.SelectedElement:
 dc = self.GetLogicalDC()
 if not isinstance(self.SelectedElement, Graphic_Group):
 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])
 self.SelectedElement.OnRightUp(event, self.GetLogicalDC(), self.Scaling)
 self.SelectedElement.Refresh()
 wx.CallAfter(self.SetCurrentCursor, 0)
 event.Skip()
-#-------------------------------------------------------------------------------
+# -------------------------------------------------------------------------------
 #                          Keyboard event functions
-#-------------------------------------------------------------------------------
+# -------------------------------------------------------------------------------
 def OnChar(self, event):
 if self.GetDrawingMode() == FREEDRAWING_MODE:
 Viewer.OnChar(self, event)
 else:
 elif event.ControlDown():
 self.Scroll(xpos, min(ypos + 1, ymax))
 else:
 event.Skip()
-#-------------------------------------------------------------------------------
+# -------------------------------------------------------------------------------
 #                  Model adding functions from Drop Target
-#-------------------------------------------------------------------------------
+# -------------------------------------------------------------------------------
 def AddVariableBlock(self, x, y, scaling, var_class, var_name, var_type):
 if var_type == "BOOL":
 id = self.GetNewId()
 if var_class == INPUT:
 self.RefreshVisibleElements()
 self.Refresh(False)
 else:
 Viewer.AddVariableBlock(self, x, y, scaling, var_class, var_name, var_type)
-#-------------------------------------------------------------------------------
+# -------------------------------------------------------------------------------
 #                          Adding element functions
-#-------------------------------------------------------------------------------
+# -------------------------------------------------------------------------------
 def AddLadderRung(self):
 dialog = LDElementDialog(self.ParentWindow, self.Controler, "coil")
 dialog.SetPreviewFont(self.GetFont())
 varlist = []
 varlist.append(var.Name)
 returntype = self.Controler.GetEditedElementInterfaceReturnType(self.TagName, debug=self.Debug)
 if returntype == "BOOL":
 varlist.append(self.Controler.GetEditedElementName(self.TagName))
 dialog.SetVariables(varlist)
-dialog.SetValues({"name":"","type":COIL_NORMAL})
+dialog.SetValues({"name": "", "type": COIL_NORMAL})
 if dialog.ShowModal() == wx.ID_OK:
 values = dialog.GetValues()
 startx, starty = LD_OFFSET[0], 0
 if len(self.Rungs) > 0:
 bbox = self.Rungs[-1].GetBoundingBox()
 starty = bbox.y + bbox.height
 starty += LD_OFFSET[1]
 rung = Graphic_Group(self)
 # Create comment
 id = self.GetNewId()
 comment = Comment(self, _("Comment"), id)
 comment.SetPosition(startx, starty)
 comment.SetSize(LD_COMMENT_DEFAULTSIZE[0], LD_COMMENT_DEFAULTSIZE[1])
 self.AddComment(comment)
 self.RungComments.append(comment)
 self.Controler.AddEditedElementComment(self.TagName, 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)
 leftpowerrail_connectors = leftpowerrail.GetConnectors()
 self.AddBlock(leftpowerrail)
 rung.SelectElement(leftpowerrail)
 self.Controler.AddEditedElementPowerRail(self.TagName, 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)
 coil_connectors = coil.GetConnectors()
 self.AddBlock(coil)
 rung.SelectElement(coil)
 self.Controler.AddEditedElementCoil(self.TagName, id)
 # Create Wire between LeftPowerRail and Coil
 wire = Wire(self)
 start_connector = coil_connectors["inputs"][0]
 end_connector = leftpowerrail_connectors["outputs"][0]
 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)
 rung.SelectElement(wire)
 # Create RightPowerRail
 id = self.GetNewId()
 rightpowerrail = LD_PowerRail(self, RIGHTRAIL, id)
 rightpowerrail.SetPosition(startx, starty)
 rightpowerrail_connectors = rightpowerrail.GetConnectors()
 self.AddBlock(rightpowerrail)
 rung.SelectElement(rightpowerrail)
 self.Controler.AddEditedElementPowerRail(self.TagName, id, RIGHTRAIL)
 # Create Wire between LeftPowerRail and Coil
 wire = Wire(self)
 start_connector = rightpowerrail_connectors["inputs"][0]
 end_connector = coil_connectors["outputs"][0]
 start_connector.Connect((wire, 0), False)
 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 isinstance(self.SelectedElement,Graphic_Group):
+elif self.SelectedElement and isinstance(self.SelectedElement, Graphic_Group):
 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.ParentWindow, self.Controler, "contact")
 if vars:
 for var in vars:
 if var.Class != "Output" and var.Type == "BOOL":
 varlist.append(var.Name)
 dialog.SetVariables(varlist)
-dialog.SetValues({"name":"","type":CONTACT_NORMAL})
+dialog.SetValues({"name": "", "type": CONTACT_NORMAL})
 if dialog.ShowModal() == wx.ID_OK:
 values = dialog.GetValues()
 points = wires[0].GetSelectedSegmentPoints()
 id = self.GetNewId()
 contact = LD_Contact(self, values["type"], values["name"], id)
 self.RefreshBuffer()
 self.RefreshScrollBars()
 self.RefreshVisibleElements()
 self.Refresh(False)
 else:
-message = wx.MessageDialog(self, _("You must select the wire where a contact should be added!"), _("Error"), wx.OK|wx.ICON_ERROR)
+message = wx.MessageDialog(self, _("You must select the wire where a contact should be added!"), _("Error"), wx.OK | wx.ICON_ERROR)
 message.ShowModal()
 message.Destroy()
 def AddLadderBranch(self):
 blocks = []
 left_index = []
 right_elements = []
 right_index = []
 for block in blocks:
 connectors = block.GetConnectors()
-block_infos = {"lefts":[],"rights":[]}
+block_infos = {"lefts": [], "rights": []}
 block_infos.update(connectors)
 for connector in block_infos["inputs"]:
 for wire, handle in connector.GetWires():
 found = False
 for infos in blocks_infos:
 if not left_powerrail or not right_powerrail:
 wires = []
 if left_powerrail:
 powerrail = left_elements[0].GetParentBlock()
 index = 0
 for left_element in left_elements:
 index = max(index, powerrail.GetConnectorIndex(left_element))
 powerrail.InsertConnector(index + 1)
 powerrail.RefreshModel()
 connectors = powerrail.GetConnectors()
 right_elements.reverse()
 varlist.append(var.Name)
 returntype = self.Controler.GetEditedElementInterfaceReturnType(self.TagName, debug=self.Debug)
 if returntype == "BOOL":
 varlist.append(self.Controler.GetEditedElementName(self.TagName))
 dialog.SetVariables(varlist)
-dialog.SetValues({"name":"","type":COIL_NORMAL})
+dialog.SetValues({"name": "", "type": COIL_NORMAL})
 if dialog.ShowModal() == wx.ID_OK:
 values = dialog.GetValues()
 powerrail = right_elements[0].GetParentBlock()
 index = 0
 for right_element in right_elements:
 index = max(index, powerrail.GetConnectorIndex(right_element))
 powerrail.InsertConnector(index + 1)
 powerrail.RefreshModel()
 connectors = powerrail.GetConnectors()
 # 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.AddBlock(coil)
 rung.SelectElement(coil)
 self.Controler.AddEditedElementCoil(self.TagName, id)
 coil_connectors = coil.GetConnectors()
 # Create Wire between LeftPowerRail and Coil
 wire = Wire(self)
 connectors["inputs"][index + 1].Connect((wire, 0), False)
 coil_connectors["outputs"][0].Connect((wire, -1), False)
 wire.ConnectStartPoint(None, connectors["inputs"][index + 1])
 wire.ConnectEndPoint(None, coil_connectors["outputs"][0])
 self.AddWire(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)
 wires.append(new_wire)
 coil_connectors["inputs"][0].Connect((new_wire, 0), False)
 left_element.InsertConnect(left_index[i] + 1, (new_wire, -1), False)
 new_wire.ConnectStartPoint(None, coil_connectors["inputs"][0])
 new_wire.ConnectEndPoint(None, left_element)
 self.RefreshPosition(coil)
 else:
 left_elements.reverse()
 right_elements.reverse()
 for i, left_element in enumerate(left_elements):
 self.RefreshBuffer()
 self.RefreshScrollBars()
 self.RefreshVisibleElements()
 self.Refresh(False)
 else:
-message = wx.MessageDialog(self, _("The group of block must be coherent!"), _("Error"), wx.OK|wx.ICON_ERROR)
+message = wx.MessageDialog(self, _("The group of block must be coherent!"), _("Error"), wx.OK | wx.ICON_ERROR)
 message.ShowModal()
 message.Destroy()
 else:
-message = wx.MessageDialog(self, _("You must select the block or group of blocks around which a branch should be added!"), _("Error"), wx.OK|wx.ICON_ERROR)
+message = wx.MessageDialog(self, _("You must select the block or group of blocks around which a branch should be added!"), _("Error"), wx.OK | wx.ICON_ERROR)
 message.ShowModal()
 message.Destroy()
 def AddLadderBlock(self):
-message = wx.MessageDialog(self, _("This option isn't available yet!"), _("Warning"), wx.OK|wx.ICON_EXCLAMATION)
+message = wx.MessageDialog(self, _("This option isn't available yet!"), _("Warning"), wx.OK | wx.ICON_EXCLAMATION)
 message.ShowModal()
 message.Destroy()
-#-------------------------------------------------------------------------------
+# -------------------------------------------------------------------------------
 #                          Delete element functions
-#-------------------------------------------------------------------------------
+# -------------------------------------------------------------------------------
 def DeleteContact(self, contact):
 if self.GetDrawingMode() == FREEDRAWING_MODE:
 Viewer.DeleteContact(self, contact)
 else:
 rung.RefreshBoundingBox()
 new_bbox = rung.GetBoundingBox()
 self.RefreshRungs(new_bbox.height - old_bbox.height, rungindex + 1)
 self.SelectedElement = None
-#-------------------------------------------------------------------------------
+# -------------------------------------------------------------------------------
 #                        Refresh element position functions
-#-------------------------------------------------------------------------------
+# -------------------------------------------------------------------------------
 def RefreshPosition(self, element, recursive=True):
 # If element is LeftPowerRail, no need to update position
 if isinstance(element, LD_PowerRail) and element.GetType() == LEFTRAIL:
 element.RefreshModel()
 return
 # Extract max position of the elements connected to input
 connectors = element.GetConnectors()
 position = element.GetPosition()
 maxx = 0
 onlyone = []
 onlyone[-1] &= len(wire.EndConnected.GetWires()) == 1
 leftblock = wire.EndConnected.GetParentBlock()
 pos = leftblock.GetPosition()
 size = leftblock.GetSize()
 maxx = max(maxx, pos[0] + size[0])
 # Refresh position of element
 if isinstance(element, LD_Coil):
 interval = LD_WIRECOIL_SIZE
 else:
 interval = LD_WIRE_SIZE
 if False in onlyone:
 interval += LD_WIRE_SIZE
 movex = maxx + interval - position[0]
 element.Move(movex, 0)
 position = element.GetPosition()
 # Extract blocks connected to inputs
 blocks = []
 for i, connector in enumerate(connectors["inputs"]):
 for j, (wire, handle) in enumerate(connector.GetWires()):
 blocks.append(wire.EndConnected.GetParentBlock())
 for i, connector in enumerate(connectors["inputs"]):
 startpoint = connector.GetPosition(False)
 previous_blocks = []
 block_list = []
 start_offset = 0
 points = [startpoint, endpoint]
 wire.SetPoints(points, False)
 previous_blocks.append(block)
 blocks.remove(block)
 ExtractNextBlocks(block, block_list)
 element.RefreshModel(False)
 if recursive:
 for connector in connectors["outputs"]:
 for wire, handle in connector.GetWires():
 self.RefreshPosition(wire.StartConnected.GetParentBlock())
 def RefreshRungs(self, movey, fromidx):
 if movey != 0:
 for i in xrange(fromidx, len(self.Rungs)):
 self.RungComments[i].Move(0, movey)
 self.RungComments[i].RefreshModel()
 self.Rungs[i].Move(0, movey)
 for element in self.Rungs[i].GetElements():
 if self.IsBlock(element):
 self.RefreshPosition(element)
-#-------------------------------------------------------------------------------
+# -------------------------------------------------------------------------------
 #                          Edit element content functions
-#-------------------------------------------------------------------------------
+# -------------------------------------------------------------------------------
 def EditPowerRailContent(self, powerrail):
 if self.GetDrawingMode() == FREEDRAWING_MODE:
 Viewer.EditPowerRailContent(self, powerrail)

changeset 1784	64beb9e9c749
parent 1782	5b6ad7a7fd9d
child 1832	0f1081928d65