plcopeneditor_history: comparison LDViewer.py

equal deleted inserted replaced

-:f1691e685c49
+:7ceec5c40d77
 if self.SelectedElement in self.Blocks:
 blocks = [self.SelectedElement]
 elif self.SelectedElement not in self.Elements:
 elements = self.SelectedElement.GetElements()
 for element in elements:
-if isinstance(element, (LD_PowerRail, LD_Coil)):
-return
 blocks.append(element)
 if len(blocks) > 0:
 blocks_infos = []
 left_elements = []
 left_index = []
 rung.RefreshBoundingBox()
 new_bbox = rung.GetBoundingBox()
 self.RefreshRungs(new_bbox.height - old_bbox.height, rungindex + 1)
 self.SelectedElement = None
+def RecursiveDeletion(self, element, rung):
+connectors = element.GetConnectors()
+input_wires = [wire for wire, handle in connectors["input"].GetWires()]
+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.Elements.remove(wire)
+rung.SelectElement(wire)
+self.Blocks.remove(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)
+else:
+self.RefreshPosition(block)
 def DeleteCoil(self, coil):
 rungindex = self.FindRung(coil)
 rung = self.Rungs[rungindex]
-bbox = rung.GetBoundingBox()
+old_bbox = rung.GetBoundingBox()
+nbcoils = 0
 for element in rung.GetElements():
-if element in self.Wires:
+if isinstance(element, LD_Coil):
-element.Clean()
+nbcoils += 1
-self.Wires.remove(element)
+if nbcoils > 1:
-self.Elements.remove(element)
+connectors = coil.GetConnectors()
-for element in rung.GetElements():
+output_wires = [wire for wire, handle in connectors["output"].GetWires()]
-if element in self.Blocks:
+right_elements = [wire.StartConnected for wire in output_wires]
-self.Controler.RemoveCurrentElementEditingInstance(element.GetId())
+for wire in output_wires:
-self.Blocks.remove(element)
+wire.Clean()
-self.Elements.remove(element)
+self.Wires.remove(wire)
-self.Controler.RemoveCurrentElementEditingInstance(self.Comments[rungindex].GetId())
+self.Elements.remove(wire)
-self.Elements.remove(self.Comments[rungindex])
+rung.SelectElement(wire)
-self.Comments.pop(rungindex)
+for right_element in right_elements:
-self.Rungs.pop(rungindex)
+right_block = right_element.GetParentBlock()
-if rungindex < len(self.Rungs):
+if isinstance(right_block, LD_PowerRail):
-next_bbox = self.Rungs[rungindex].GetBoundingBox()
+if len(right_element.GetWires()) == 0:
-self.RefreshRungs(bbox.y - next_bbox.y, rungindex)
+index = right_block.GetConnectorIndex(right_element)
+right_block.DeleteConnector(index)
+powerrail_connectors = right_block.GetConnectors()
+for connector in powerrail_connectors:
+for wire, handle in connector.GetWires():
+block = wire.EndConnected.GetParentBlock()
+endpoint = wire.EndConnected.GetPosition(False)
+startpoint = connector.GetPosition(False)
+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:
+element.Clean()
+self.Wires.remove(element)
+self.Elements.remove(element)
+for element in rung.GetElements():
+if element in self.Blocks:
+self.Controler.RemoveCurrentElementEditingInstance(element.GetId())
+self.Blocks.remove(element)
+self.Elements.remove(element)
+self.Controler.RemoveCurrentElementEditingInstance(self.Comments[rungindex].GetId())
+self.Elements.remove(self.Comments[rungindex])
+self.Comments.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
 def DeleteWire(self, wire):
 wires = []
 left_elements = []
 #-------------------------------------------------------------------------------
 #                        Refresh element position functions
 #-------------------------------------------------------------------------------
-def RefreshPosition(self, element):
+def RefreshPosition(self, element, recursive=True):
 if isinstance(element, LD_PowerRail) and element.GetType() == LEFTRAIL:
 element.RefreshModel()
 return
 connectors = element.GetConnectors()
 input_connectors = []
 output_connectors = []
 if isinstance(element, LD_PowerRail) and element.GetType() == RIGHTRAIL:
 input_connectors = connectors
+for i, connector in enumerate(input_connectors):
+for j, (wire, handle) in enumerate(connector.GetWires()):
+block = wire.EndConnected.GetParentBlock()
+self.RefreshPosition(block, False)
 else:
 if "inputs" in connectors:
 input_connectors = connectors["inputs"]
 if "outputs" in connectors:
 output_connectors = connectors["outputs"]
 interval = LD_WIRE_SIZE
 if False in onlyone:
 interval += LD_WIRE_SIZE
 movex = minx + interval - position[0]
 element.Move(movex, 0)
+position = element.GetPosition()
 for i, connector in enumerate(input_connectors):
 startpoint = connector.GetPosition(False)
 previous_blocks = []
 block_list = []
 start_offset = 0
 if not onlyone[i]:
 middlepoint = minx + LD_WIRE_SIZE
 for j, (wire, handle) in enumerate(connector.GetWires()):
 block = wire.EndConnected.GetParentBlock()
+if isinstance(element, LD_PowerRail):
+pos = block.GetPosition()
+size = leftblock.GetSize()
+movex = position[0] - LD_WIRE_SIZE - size[0] - pos[0]
+block.Move(movex, 0)
 endpoint = wire.EndConnected.GetPosition(False)
 if j == 0:
 if not onlyone[i] and wire.EndConnected.GetWireIndex(wire) > 0:
 start_offset = endpoint.y - startpoint.y
 offset = start_offset
 wxPoint(middlepoint, startpoint.y + offset),
 wxPoint(endmiddlepoint, startpoint.y + offset),
 wxPoint(endmiddlepoint, endpoint.y), endpoint]
 else:
 if startpoint.y + offset != endpoint.y:
-if isinstance(block, LD_PowerRail):
+if isinstance(element, LD_PowerRail):
+diff = (startpoint.y - endpoint.y) / LD_LINE_SIZE
+for k in xrange(abs(diff)):
+if diff < 0:
+element.DeleteConnector(i - 1 - k)
+else:
+element.InsertConnector(i + k, False)
+elif isinstance(block, LD_PowerRail):
 index = block.GetConnectorIndex(wire.EndConnected)
 if index:
 diff = (startpoint.y - endpoint.y) / LD_LINE_SIZE
 for k in xrange(abs(diff)):
 if diff < 0:
 block.DeleteConnector(index - 1 - k)
 else:
 block.InsertConnector(index + k, False)
 else:
 block.Move(0, startpoint.y + offset - endpoint.y)
-self.RefreshPosition(block)
+self.RefreshPosition(block, False)
 endpoint = wire.EndConnected.GetPosition(False)
 if not onlyone[i]:
 points = [startpoint, wxPoint(middlepoint, startpoint.y),
 wxPoint(middlepoint, endpoint.y), endpoint]
 else:
 points = [startpoint, endpoint]
 wire.SetPoints(points)
 previous_blocks.append(block)
 ExtractNextBlocks(block, block_list)
 element.RefreshModel(False)
-for connector in output_connectors:
+if recursive:
-for wire, handle in connector.GetWires():
+for connector in output_connectors:
-self.RefreshPosition(wire.StartConnected.GetParentBlock())
+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.Comments[i].Move(0, movey)

changeset 8	7ceec5c40d77
parent 7	f1691e685c49
child 9	b29105e29081