beremiz: comparison editors/LDViewer.py

equal deleted inserted replaced

-:d51af006fa6b
+:64d8f52bc8c8
 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)
 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"])
 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"]
 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):
 return None
 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
 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])
 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)
 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()
 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):
 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()
 #-------------------------------------------------------------------------------
 def EditPowerRailContent(self, powerrail):
 if self.GetDrawingMode() == FREEDRAWING_MODE:
 Viewer.EditPowerRailContent(self, powerrail)

changeset 1730	64d8f52bc8c8
parent 1571	486f94a8032c
child 1733	dea107dce0c4