plcopeneditor_history: comparison LDViewer.py

equal deleted inserted replaced

-:b0d6819119c3
+:cfa295862d55
 #You should have received a copy of the GNU General Public
 #License along with this library; if not, write to the Free Software
 #Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 import wx
+import time
 from types import *
 from Viewer import *
 def ExtractNextBlocks(block, block_list):
 rung = Graphic_Group(self)
 rung.SelectElement(element)
 self.Rungs.append(rung)
 elif instance["type"] == "rightPowerRail":
 rungs = []
-for connector in instance["connectors"]:
+for connector in instance["inputs"]:
 for link in connector["links"]:
 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"]
 element = self.FindElementById(instance["id"])
+element_connectors = element.GetConnectors()
 self.Rungs[rungs[0]].SelectElement(element)
-for connector in element.GetConnectors():
+for connector in element_connectors["inputs"]:
 for wire, num in connector.GetWires():
 self.Rungs[rungs[0]].SelectElement(wire)
-self.RefreshPosition(element)
+wx.CallAfter(self.RefreshPosition, element)
 elif instance["type"] in ["contact", "coil"]:
 rungs = []
-for link in instance["connectors"]["input"]["links"]:
+for link in instance["inputs"][0]["links"]:
 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"]
 element = self.FindElementById(instance["id"])
+element_connectors = element.GetConnectors()
 self.Rungs[rungs[0]].SelectElement(element)
-for wire, num in element.GetConnectors()["input"].GetWires():
+for wire, num in element_connectors["inputs"][0].GetWires():
 self.Rungs[rungs[0]].SelectElement(wire)
-self.RefreshPosition(element)
+wx.CallAfter(self.RefreshPosition, element)
 elif instance["type"] == "comment":
 element = self.FindElementById(instance["id"])
 pos = element.GetPosition()
 i = 0
 inserted = False
 self.RungComments.insert(i, element)
 inserted = True
 i += 1
 if not inserted:
 self.RungComments.append(element)
 #-------------------------------------------------------------------------------
 #                          Search Element functions
 #-------------------------------------------------------------------------------
 def FindRung(self, element):
 def FindElement(self, pos, exclude_group = False):
 if self.GetDrawingMode() == FREEDRAWING_MODE:
 return Viewer.FindElement(self, pos, exclude_group)
-if self.SelectedElement and not (exclude_group and isinstance(self.SelectedElement, Graphic_Group)):
+if self.SelectedElement and not isinstance(self.SelectedElement, (Graphic_Group, Wire)):
 if self.SelectedElement.HitTest(pos) or self.SelectedElement.TestHandle(pos) != (0, 0):
 return self.SelectedElement
 elements = []
 for element in self.GetElements(sort_wires=True):
 if element.HitTest(pos) or element.TestHandle(pos) != (0, 0):
 group.SelectElement(element)
 return group
 return None
 def SearchElements(self, bbox):
-if self.GetDrawingMode() == FREEDRAWING_MODE:
-return Viewer.SearchElements(self, bbox)
 elements = []
-for element in self.Blocks:
+for element in self.Blocks.values() + self.Comments.values():
 if element.IsInSelection(bbox):
 elements.append(element)
 return elements
 #-------------------------------------------------------------------------------
 else:
 self.SelectedElement.SetSelected(True)
 self.SelectedElement.OnRightUp(event, dc, self.Scaling)
 self.SelectedElement.Refresh()
 wx.CallAfter(self.SetCurrentCursor, 0)
-event.Skip()
-def OnViewerLeftDClick(self, event):
-if self.GetDrawingMode() == FREEDRAWING_MODE:
-Viewer.OnViewerLeftDClick(self, event)
-elif self.Mode == MODE_SELECTION and self.SelectedElement:
-self.SelectedElement.OnLeftDClick(event, self.GetLogicalDC(), self.Scaling)
-self.SelectedElement.Refresh()
-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
 #-------------------------------------------------------------------------------
 #-------------------------------------------------------------------------------
 #                          Adding element functions
 #-------------------------------------------------------------------------------
 def AddLadderRung(self):
-dialog = LDElementDialog(self.ParentWindow, "coil")
+dialog = LDElementDialog(self.ParentWindow, self.Controler, "coil")
 dialog.SetPreviewFont(self.GetFont())
 varlist = []
 vars = self.Controler.GetEditedElementInterfaceVars(self.TagName, self.Debug)
 if vars:
 for var in vars:
 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.GetConnectors()["input"]
+start_connector = coil_connectors["inputs"][0]
-end_connector = leftpowerrail.GetConnectors()[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.GetConnectors()[0]
+start_connector = rightpowerrail_connectors["inputs"][0]
-end_connector = coil.GetConnectors()["output"]
+end_connector = coil_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)
 self.RefreshPosition(coil)
 self.Rungs.append(rung)
 self.RefreshBuffer()
 self.RefreshScrollBars()
+self.RefreshVisibleElements()
 self.Refresh(False)
 def AddLadderContact(self):
 wires = []
 if self.IsWire(self.SelectedElement):
 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, "contact")
+dialog = LDElementDialog(self.ParentWindow, self.Controler, "contact")
 dialog.SetPreviewFont(self.GetFont())
 varlist = []
 vars = self.Controler.GetEditedElementInterfaceVars(self.TagName, self.Debug)
 if vars:
 for var in vars:
 wires = []
 right_wires = []
 for i, left_element in enumerate(left_elements):
 wire = Wire(self)
 wires.append(wire)
-connectors["input"].Connect((wire, 0), False)
+connectors["inputs"][0].Connect((wire, 0), False)
 left_element.InsertConnect(left_index[i], (wire, -1), False)
-wire.ConnectStartPoint(None, connectors["input"])
+wire.ConnectStartPoint(None, connectors["inputs"][0])
 wire.ConnectEndPoint(None, left_element)
 for i, right_element in enumerate(right_elements):
 wire = Wire(self)
 wires.append(wire)
 right_wires.append(wire)
 right_element.InsertConnect(right_index[i], (wire, 0), False)
-connectors["output"].Connect((wire, -1), False)
+connectors["outputs"][0].Connect((wire, -1), False)
 wire.ConnectStartPoint(None, right_element)
-wire.ConnectEndPoint(None, connectors["output"])
+wire.ConnectEndPoint(None, connectors["outputs"][0])
 right_wires.reverse()
 for wire in wires:
 self.AddWire(wire)
 rung.SelectElement(wire)
 self.RefreshPosition(contact)
 rung.RefreshBoundingBox()
 new_bbox = rung.GetBoundingBox()
 self.RefreshRungs(new_bbox.height - old_bbox.height, rungindex + 1)
 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.ShowModal()
 message.Destroy()
 left_index = []
 right_elements = []
 right_index = []
 for block in blocks:
 connectors = block.GetConnectors()
-block_infos = {"inputs":[],"outputs":[],"lefts":[],"rights":[]}
+block_infos = {"lefts":[],"rights":[]}
-if "inputs" in connectors:
+block_infos.update(connectors)
-block_infos["inputs"] = connectors["inputs"]
-if "outputs" in connectors:
-block_infos["outputs"] = connectors["outputs"]
-if "input" in connectors:
-block_infos["inputs"] = [connectors["input"]]
-if "output" in connectors:
-block_infos["outputs"] = [connectors["output"]]
 for connector in block_infos["inputs"]:
 for wire, handle in connector.GetWires():
 found = False
 for infos in blocks_infos:
 if wire.EndConnected in infos["outputs"]:
 if left_powerrail:
 powerrail = left_elements[0].GetParentBlock()
 index = 0
 for left_element in left_elements:
 index = max(index, powerrail.GetConnectorIndex(left_element))
-if powerrail.IsNullConnector(index + 1):
-powerrail.DeleteConnector(index + 1)
 powerrail.InsertConnector(index + 1)
 powerrail.RefreshModel()
 connectors = powerrail.GetConnectors()
 right_elements.reverse()
 for i, right_element in enumerate(right_elements):
 new_wire = Wire(self)
 wires.append(new_wire)
 right_element.InsertConnect(right_index[i] + 1, (new_wire, 0), False)
-connectors[index + 1].Connect((new_wire, -1), False)
+connectors["outputs"][index + 1].Connect((new_wire, -1), False)
 new_wire.ConnectStartPoint(None, right_element)
-new_wire.ConnectEndPoint(None, connectors[index + 1])
+new_wire.ConnectEndPoint(None, connectors["outputs"][index + 1])
 right_elements.reverse()
 elif right_powerrail:
-dialog = LDElementDialog(self.ParentWindow, "coil")
+dialog = LDElementDialog(self.ParentWindow, self.Controleur, "coil")
 dialog.SetPreviewFont(self.GetFont())
 varlist = []
 vars = self.Controler.GetEditedElementInterfaceVars(self.TagName, self.Debug)
 if vars:
 for var in vars:
 values = dialog.GetValues()
 powerrail = right_elements[0].GetParentBlock()
 index = 0
 for right_element in right_elements:
 index = max(index, powerrail.GetConnectorIndex(right_element))
-if powerrail.IsNullConnector(index + 1):
-powerrail.DeleteConnector(index + 1)
 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[index + 1].Connect((wire, 0), False)
+connectors["inputs"][index + 1].Connect((wire, 0), False)
-coil_connectors["output"].Connect((wire, -1), False)
+coil_connectors["outputs"][0].Connect((wire, -1), False)
-wire.ConnectStartPoint(None, connectors[index + 1])
+wire.ConnectStartPoint(None, connectors["inputs"][index + 1])
-wire.ConnectEndPoint(None, coil_connectors["output"])
+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["input"].Connect((new_wire, 0), False)
+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["input"])
+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):
 rung.RefreshBoundingBox()
 new_bbox = rung.GetBoundingBox()
 self.RefreshRungs(new_bbox.height - old_bbox.height, rungindex + 1)
 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.ShowModal()
 message.Destroy()
 def DeleteContact(self, contact):
 if self.GetDrawingMode() == FREEDRAWING_MODE:
 Viewer.DeleteContact(self, contact)
 else:
+print "Delete"
 rungindex = self.FindRung(contact)
 rung = self.Rungs[rungindex]
 old_bbox = rung.GetBoundingBox()
 connectors = contact.GetConnectors()
-input_wires = [wire for wire, handle in connectors["input"].GetWires()]
+input_wires = [wire for wire, handle in connectors["inputs"][0].GetWires()]
-output_wires = [wire for wire, handle in connectors["output"].GetWires()]
+output_wires = [wire for wire, handle in connectors["outputs"][0].GetWires()]
 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.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()]
+input_wires = [wire for wire, handle in connectors["inputs"][0].GetWires()]
 left_elements = [wire.EndConnected for wire in input_wires]
 rung.SelectElement(element)
 element.Clean()
 for wire in input_wires:
 wire.Clean()
 for element in rung.GetElements():
 if isinstance(element, LD_Coil):
 nbcoils += 1
 if nbcoils > 1:
 connectors = coil.GetConnectors()
-output_wires = [wire for wire, handle in connectors["output"].GetWires()]
+output_wires = [wire for wire, handle in connectors["outputs"][0].GetWires()]
 right_elements = [wire.StartConnected for wire in output_wires]
 for wire in output_wires:
 wire.Clean()
 self.Wires.remove(wire)
 self.Elements.remove(wire)
 if isinstance(right_block, LD_PowerRail):
 if len(right_element.GetWires()) == 0:
 index = right_block.GetConnectorIndex(right_element)
 right_block.DeleteConnector(index)
 powerrail_connectors = right_block.GetConnectors()
-for connector in powerrail_connectors:
+for connector in powerrail_connectors["inputs"]:
 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)
 if len(left_element.GetWires()) == 0:
 index = left_block.GetConnectorIndex(left_element)
 left_block.DeleteConnector(index)
 else:
 connectors = left_block.GetConnectors()
-output_connectors = []
+for connector in connectors["outputs"]:
-if "outputs" in connectors:
-output_connectors = connectors["outputs"]
-if "output" in connectors:
-output_connectors = [connectors["output"]]
-for connector in output_connectors:
 for wire, handle in connector.GetWires():
 self.RefreshPosition(wire.StartConnected.GetParentBlock())
 for right_element in right_elements:
 self.RefreshPosition(right_element.GetParentBlock())
 rung.RefreshBoundingBox()
 #-------------------------------------------------------------------------------
 #                        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()
-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"]
-if "input" in connectors:
-input_connectors = [connectors["input"]]
-if "output" in connectors:
-output_connectors = [connectors["output"]]
 position = element.GetPosition()
-minx = 0
+maxx = 0
 onlyone = []
-for connector in input_connectors:
+for connector in connectors["inputs"]:
 onlyone.append(len(connector.GetWires()) == 1)
 for wire, handle in connector.GetWires():
 onlyone[-1] &= len(wire.EndConnected.GetWires()) == 1
 leftblock = wire.EndConnected.GetParentBlock()
 pos = leftblock.GetPosition()
 size = leftblock.GetSize()
-minx = max(minx, pos[0] + size[0])
+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 = minx + interval - position[0]
+movex = maxx + interval - position[0]
 element.Move(movex, 0)
 position = element.GetPosition()
+# Extract blocks connected to inputs
 blocks = []
-for i, connector in enumerate(input_connectors):
+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(input_connectors):
+for i, connector in enumerate(connectors["inputs"]):
 startpoint = connector.GetPosition(False)
 previous_blocks = []
 block_list = []
 start_offset = 0
 if not onlyone[i]:
-middlepoint = minx + LD_WIRE_SIZE
+middlepoint = maxx + 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()
 wx.Point(endmiddlepoint, startpoint.y + offset),
 wx.Point(endmiddlepoint, endpoint.y), endpoint]
 else:
 if startpoint.y + offset != endpoint.y:
 if isinstance(element, LD_PowerRail):
-diff = (startpoint.y - endpoint.y) / LD_LINE_SIZE
+element.MoveConnector(i, startpoint.y - endpoint.y)
-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
+block.MoveConnector(index, startpoint.y - endpoint.y)
-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, False)
 endpoint = wire.EndConnected.GetPosition(False)
 if not onlyone[i]:
 points = [startpoint, wx.Point(middlepoint, startpoint.y),
 wx.Point(middlepoint, endpoint.y), endpoint]
 else:
 points = [startpoint, endpoint]
-wire.SetPoints(points)
+wire.SetPoints(points, False)
 previous_blocks.append(block)
 blocks.remove(block)
 ExtractNextBlocks(block, block_list)
 element.RefreshModel(False)
 if recursive:
-for connector in output_connectors:
+for connector in connectors["outputs"]:
 for wire, handle in connector.GetWires():
 self.RefreshPosition(wire.StartConnected.GetParentBlock())
 def RefreshRungs(self, movey, fromidx):
 if movey != 0:
 #-------------------------------------------------------------------------------
 #                          Edit element content functions
 #-------------------------------------------------------------------------------
-def EditContactContent(self, contact):
-if self.GetDrawingMode() == FREEDRAWING_MODE:
-Viewer.EditContactContent(self, contact)
-else:
-dialog = LDElementDialog(self.ParentWindow, "contact")
-dialog.SetPreviewFont(self.GetFont())
-varlist = []
-vars = self.Controler.GetEditedElementInterfaceVars(self.TagName, self.Debug)
-if vars:
-for var in vars:
-if var["Class"] != "Output" and var["Type"] == "BOOL":
-varlist.append(var["Name"])
-dialog.SetVariables(varlist)
-dialog.SetValues({"name":contact.GetName(),"type":contact.GetType()})
-if dialog.ShowModal() == wx.ID_OK:
-values = dialog.GetValues()
-contact.SetName(values["name"])
-contact.SetType(values["type"])
-contact.RefreshModel(False)
-self.RefreshBuffer()
-self.RefreshScrollBars()
-contact.Refresh()
-dialog.Destroy()
-def EditCoilContent(self, coil):
-if self.GetDrawingMode() == FREEDRAWING_MODE:
-Viewer.EditCoilContent(self, coil)
-else:
-dialog = LDElementDialog(self.ParentWindow, "coil")
-dialog.SetPreviewFont(self.GetFont())
-varlist = []
-vars = self.Controler.GetEditedElementInterfaceVars(self.TagName, self.Debug)
-if vars:
-for var in vars:
-if var["Class"] != "Input" and var["Type"] == "BOOL":
-varlist.append(var["Name"])
-returntype = self.Controler.GetEditedElementInterfaceReturnType(self.TagName, self.Debug)
-if returntype == "BOOL":
-varlist.append(self.Controler.GetEditedElementName(self.TagName))
-dialog.SetVariables(varlist)
-dialog.SetValues({"name":coil.GetName(),"type":coil.GetType()})
-if dialog.ShowModal() == wx.ID_OK:
-values = dialog.GetValues()
-coil.SetName(values["name"])
-coil.SetType(values["type"])
-coil.RefreshModel(False)
-self.RefreshBuffer()
-self.RefreshScrollBars()
-coil.Refresh()
-dialog.Destroy()
 def EditPowerRailContent(self, powerrail):
 if self.GetDrawingMode() == FREEDRAWING_MODE:
 Viewer.EditPowerRailContent(self, powerrail)
-#-------------------------------------------------------------------------------
-#                          Model update functions
-#-------------------------------------------------------------------------------
-def RefreshBlockModel(self, block):
-blockid = block.GetId()
-infos = {}
-infos["type"] = block.GetType()
-infos["name"] = block.GetName()
-infos["x"], infos["y"] = block.GetPosition()
-infos["width"], infos["height"] = block.GetSize()
-infos["connectors"] = block.GetConnectors()
-self.Controler.SetEditedElementBlockInfos(self.TagName, blockid, infos)

changeset 550	cfa295862d55
parent 510	e7327ea490b4
child 554	08c26c62f5a7