graphics/FBD_Objects.py
changeset 1054 ef514eaacd8c
parent 873 8737f1554494
child 1130 f96e0254f0ce
equal deleted inserted replaced
1048:b450202605ab 1054:ef514eaacd8c
   261                 inputs.insert(0, ("EN","BOOL","none"))
   261                 inputs.insert(0, ("EN","BOOL","none"))
   262                 outputs.insert(0, ("ENO","BOOL","none"))
   262                 outputs.insert(0, ("ENO","BOOL","none"))
   263             self.Pen = MiterPen(self.Colour)
   263             self.Pen = MiterPen(self.Colour)
   264             
   264             
   265             # Extract the inputs properties and create or modify the corresponding connector
   265             # Extract the inputs properties and create or modify the corresponding connector
   266             idx = 0
   266             input_connectors = []
   267             for idx, (input_name, input_type, input_modifier) in enumerate(inputs):
   267             for input_name, input_type, input_modifier in inputs:
   268                 if idx < len(self.Inputs):
   268                 connector = Connector(self, input_name, input_type, wx.Point(0, 0), WEST, onlyone = True)
   269                     connector = self.Inputs[idx]
       
   270                     connector.SetName(input_name)
       
   271                     connector.SetType(input_type)
       
   272                 else:
       
   273                     connector = Connector(self, input_name, input_type, wx.Point(0, 0), WEST, onlyone = True)
       
   274                     self.Inputs.append(connector)
       
   275                 if input_modifier == "negated":
   269                 if input_modifier == "negated":
   276                     connector.SetNegated(True)
   270                     connector.SetNegated(True)
   277                 elif input_modifier != "none":
   271                 elif input_modifier != "none":
   278                     connector.SetEdge(input_modifier)
   272                     connector.SetEdge(input_modifier)
   279             for i in xrange(idx + 1, len(self.Inputs)):
   273                 for input in self.Inputs:
   280                 self.Inputs[i].UnConnect(delete = True)
   274                     if input.GetName() == input_name:
   281             self.Inputs = self.Inputs[:idx + 1]
   275                         wires = input.GetWires()[:]
       
   276                         input.UnConnect()
       
   277                         for wire in wires:
       
   278                             connector.Connect(wire)
       
   279                         break
       
   280                 input_connectors.append(connector)
       
   281             for input in self.Inputs:
       
   282                 input.UnConnect(delete = True)
       
   283             self.Inputs = input_connectors
   282             
   284             
   283             # Extract the outputs properties and create or modify the corresponding connector
   285             # Extract the outputs properties and create or modify the corresponding connector
   284             idx = 0
   286             output_connectors = []
   285             for idx, (output_name, output_type, output_modifier) in enumerate(outputs):
   287             for output_name, output_type, output_modifier in outputs:
   286                 if idx < len(self.Outputs):
   288                 connector = Connector(self, output_name, output_type, wx.Point(0, 0), EAST)
   287                     connector = self.Outputs[idx]
       
   288                     connector.SetName(output_name)
       
   289                     connector.SetType(output_type)
       
   290                 else:
       
   291                     connector = Connector(self, output_name, output_type, wx.Point(0, 0), EAST)
       
   292                     self.Outputs.append(connector)
       
   293                 if output_modifier == "negated":
   289                 if output_modifier == "negated":
   294                     connector.SetNegated(True)
   290                     connector.SetNegated(True)
   295                 elif output_modifier != "none":
   291                 elif output_modifier != "none":
   296                     connector.SetEdge(output_modifier)
   292                     connector.SetEdge(output_modifier)
   297             for i in xrange(idx + 1, len(self.Outputs)):
   293                 for output in self.Outputs:
   298                 self.Outputs[i].UnConnect(delete = True)
   294                     if output.GetName() == output_name:
   299             self.Outputs = self.Outputs[:idx + 1]
   295                         wires = output.GetWires()[:]
       
   296                         output.UnConnect()
       
   297                         for wire in wires:
       
   298                             connector.Connect(wire)
       
   299                         break
       
   300                 output_connectors.append(connector)
       
   301             for output in self.Outputs:
       
   302                 output.UnConnect(delete = True)
       
   303             self.Outputs = output_connectors
   300                 
   304                 
   301             self.RefreshMinSize()
   305             self.RefreshMinSize()
   302             self.RefreshConnectors()
   306             self.RefreshConnectors()
       
   307             for output in self.Outputs:
       
   308                 output.RefreshWires()
   303             self.RefreshBoundingBox()
   309             self.RefreshBoundingBox()
   304     
   310     
   305     # Returns the block type
   311     # Returns the block type
   306     def GetType(self):
   312     def GetType(self):
   307         return self.Type
   313         return self.Type