beremiz: comparison graphics/SFC

equal deleted inserted replaced

-:c3c3d1318130
+:69dfdb26f600
 """
 Class that implements the graphic representation of a step
 """
 # Create a new step
-def __init__(self, parent, name, initial = False, id = None):
+def __init__(self, parent, name, initial=False, id=None):
 Graphic_Element.__init__(self, parent)
 DebugDataConsumer.__init__(self)
 self.SetName(name)
 self.Initial = initial
 self.Id = id
 if self.Action is not None:
 self.Action.SpreadCurrent(False)
 self.PreviousSpreading = spreading
 # Make a clone of this SFC_Step
-def Clone(self, parent, id = None, name = "Step", pos = None):
+def Clone(self, parent, id=None, name="Step", pos=None):
 step = SFC_Step(parent, name, self.Initial, id)
 step.SetSize(self.Size[0], self.Size[1])
 if pos is not None:
 step.SetPosition(pos.x, pos.y)
 else:
 if self.Action is not None:
 connectors[self.Action] = element.Action
 return connectors
 # Returns the RedrawRect
-def GetRedrawRect(self, movex = 0, movey = 0):
+def GetRedrawRect(self, movex=0, movey=0):
 rect = Graphic_Element.GetRedrawRect(self, movex, movey)
 if self.Input:
 rect = rect.Union(self.Input.GetRedrawRect(movex, movey))
 if self.Output:
 rect = rect.Union(self.Output.GetRedrawRect(movex, movey))
 self.Parent.DeleteStep(self)
 # Unconnect input and output
 def Clean(self):
 if self.Input:
-self.Input.UnConnect(delete = self.Parent.GetDrawingMode() == FREEDRAWING_MODE)
+self.Input.UnConnect(delete=self.Parent.GetDrawingMode() == FREEDRAWING_MODE)
 if self.Output:
-self.Output.UnConnect(delete = self.Parent.GetDrawingMode() == FREEDRAWING_MODE)
+self.Output.UnConnect(delete=self.Parent.GetDrawingMode() == FREEDRAWING_MODE)
 if self.Action:
-self.Action.UnConnect(delete = self.Parent.GetDrawingMode() == FREEDRAWING_MODE)
+self.Action.UnConnect(delete=self.Parent.GetDrawingMode() == FREEDRAWING_MODE)
 # Refresh the size of text for name
 def RefreshNameSize(self):
 self.NameSize = self.Parent.GetTextExtent(self.Name)
 self.RefreshBoundingBox()
 # Remove output connector from step
 def RemoveInput(self):
 if self.Input:
-self.Input.UnConnect(delete = self.Parent.GetDrawingMode() == FREEDRAWING_MODE)
+self.Input.UnConnect(delete=self.Parent.GetDrawingMode() == FREEDRAWING_MODE)
 self.Input = None
 self.RefreshBoundingBox()
 # Add output connector to step
 def AddOutput(self):
 if not self.Output:
-self.Output = Connector(self, "", None, wx.Point(self.Size[0] / 2, self.Size[1]), SOUTH, onlyone = True)
+self.Output = Connector(self, "", None, wx.Point(self.Size[0] / 2, self.Size[1]), SOUTH, onlyone=True)
 self.RefreshBoundingBox()
 # Remove output connector from step
 def RemoveOutput(self):
 if self.Output:
-self.Output.UnConnect(delete = self.Parent.GetDrawingMode() == FREEDRAWING_MODE)
+self.Output.UnConnect(delete=self.Parent.GetDrawingMode() == FREEDRAWING_MODE)
 self.Output = None
 self.RefreshBoundingBox()
 # Add action connector to step
 def AddAction(self):
 if not self.Action:
-self.Action = Connector(self, "", None, wx.Point(self.Size[0], self.Size[1] / 2), EAST, onlyone = True)
+self.Action = Connector(self, "", None, wx.Point(self.Size[0], self.Size[1] / 2), EAST, onlyone=True)
 self.RefreshBoundingBox()
 # Remove action connector from step
 def RemoveAction(self):
 if self.Action:
-self.Action.UnConnect(delete = self.Parent.GetDrawingMode() == FREEDRAWING_MODE)
+self.Action.UnConnect(delete=self.Parent.GetDrawingMode() == FREEDRAWING_MODE)
 self.Action = None
 self.RefreshBoundingBox()
 # Refresh the step bounding box
 def RefreshBoundingBox(self):
 if self.Action:
 self.Action.SetPosition(wx.Point(self.Size[0], vertical_pos))
 self.RefreshConnected()
 # Refresh the position of wires connected to step
-def RefreshConnected(self, exclude = []):
+def RefreshConnected(self, exclude=[]):
 if self.Input:
 self.Input.MoveConnected(exclude)
 if self.Output:
 self.Output.MoveConnected(exclude)
 if self.Action:
 self.Action.MoveConnected(exclude)
 # Returns the step connector that starts with the point given if it exists
-def GetConnector(self, position, name = None):
+def GetConnector(self, position, name=None):
 # if a name is given
 if name is not None:
 # Test input, output and action connector if they exists
 #if self.Input and name == self.Input.GetName():
 #    return self.Input
 if self.Output:
 connectors["outputs"].append(self.Output)
 return connectors
 # Test if point given is on step input or output connector
-def TestConnector(self, pt, direction = None, exclude=True):
+def TestConnector(self, pt, direction=None, exclude=True):
 # Test input connector if it exists
 if self.Input and self.Input.TestPoint(pt, direction, exclude):
 return self.Input
 # Test output connector
 if self.Output and self.Output.TestPoint(pt, direction, exclude):
 input_block.MoveActionBlock((diffx, 0))
 input_block.Move(diffx, 0)
 input_block.RefreshInputPosition()
 # Align output element with this step
-def RefreshOutputPosition(self, move = None):
+def RefreshOutputPosition(self, move=None):
 if self.Output:
 wires = self.Output.GetWires()
 if len(wires) != 1:
 return
 current_pos = self.Output.GetPosition(False)
 """
 Class that implements the graphic representation of a transition
 """
 # Create a new transition
-def __init__(self, parent, type = "reference", condition = None, priority = 0, id = None):
+def __init__(self, parent, type="reference", condition=None, priority=0, id=None):
 Graphic_Element.__init__(self, parent)
 DebugDataConsumer.__init__(self)
 self.Type = None
 self.Id = id
 self.Priority = 0
 self.Size = wx.Size(SFC_TRANSITION_SIZE[0], SFC_TRANSITION_SIZE[1])
 # Create an input and output connector
-self.Input = Connector(self, "", None, wx.Point(self.Size[0] / 2, 0), NORTH, onlyone = True)
+self.Input  = Connector(self, "", None, wx.Point(self.Size[0] / 2, 0),            NORTH, onlyone=True)
-self.Output = Connector(self, "", None, wx.Point(self.Size[0] / 2, self.Size[1]), SOUTH, onlyone = True)
+self.Output = Connector(self, "", None, wx.Point(self.Size[0] / 2, self.Size[1]), SOUTH, onlyone=True)
 self.SetType(type, condition)
 self.SetPriority(priority)
 self.Highlights = {}
 self.PreviousValue = None
 self.PreviousSpreading = False
 elif not spreading and self.PreviousSpreading:
 self.Output.SpreadCurrent(False)
 self.PreviousSpreading = spreading
 # Make a clone of this SFC_Transition
-def Clone(self, parent, id = None, pos = None):
+def Clone(self, parent, id=None, pos=None):
 transition = SFC_Transition(parent, self.Type, self.Condition, self.Priority, id)
 transition.SetSize(self.Size[0], self.Size[1])
 if pos is not None:
 transition.SetPosition(pos.x, pos.y)
 else:
 if self.Type == "connection" and self.Condition is not None:
 connectors[self.Condition] = element.Condition
 return connectors
 # Returns the RedrawRect
-def GetRedrawRect(self, movex = 0, movey = 0):
+def GetRedrawRect(self, movex=0, movey=0):
 rect = Graphic_Element.GetRedrawRect(self, movex, movey)
 if self.Input:
 rect = rect.Union(self.Input.GetRedrawRect(movex, movey))
 if self.Output:
 rect = rect.Union(self.Output.GetRedrawRect(movex, movey))
 def Delete(self):
 self.Parent.DeleteTransition(self)
 # Unconnect input and output
 def Clean(self):
-self.Input.UnConnect(delete = self.Parent.GetDrawingMode() == FREEDRAWING_MODE)
+self.Input.UnConnect(delete=self.Parent.GetDrawingMode() == FREEDRAWING_MODE)
-self.Output.UnConnect(delete = self.Parent.GetDrawingMode() == FREEDRAWING_MODE)
+self.Output.UnConnect(delete=self.Parent.GetDrawingMode() == FREEDRAWING_MODE)
 if self.Type == "connection":
-self.Condition.UnConnect(delete = self.Parent.GetDrawingMode() == FREEDRAWING_MODE)
+self.Condition.UnConnect(delete=self.Parent.GetDrawingMode() == FREEDRAWING_MODE)
 # Returns if the point given is in the bounding box
 def HitTest(self, pt, connectors=True):
 if self.Type != "connection":
 # Calculate the bounding box of the condition outside the transition
 if self.Type == "connection":
 self.Condition.SetPosition(wx.Point(0, vertical_pos))
 self.RefreshConnected()
 # Refresh the position of the wires connected to transition
-def RefreshConnected(self, exclude = []):
+def RefreshConnected(self, exclude=[]):
 self.Input.MoveConnected(exclude)
 self.Output.MoveConnected(exclude)
 if self.Type == "connection":
 self.Condition.MoveConnected(exclude)
 # Returns the transition connector that starts with the point given if it exists
-def GetConnector(self, position, name = None):
+def GetConnector(self, position, name=None):
 # if a name is given
 if name is not None:
 # Test input and output connector
 #if name == self.Input.GetName():
 #    return self.Input
 # Returns input and output transition connectors
 def GetConnectors(self):
 return {"inputs": [self.Input], "outputs": [self.Output]}
 # Test if point given is on transition input or output connector
-def TestConnector(self, pt, direction = None, exclude=True):
+def TestConnector(self, pt, direction=None, exclude=True):
 # Test input connector
 if self.Input.TestPoint(pt, direction, exclude):
 return self.Input
 # Test output connector
 if self.Output.TestPoint(pt, direction, exclude):
 if self.Type == "connection" and self.Condition.TestPoint(pt, direction, exclude):
 return self.Condition
 return None
 # Changes the transition type
-def SetType(self, type, condition = None):
+def SetType(self, type, condition=None):
 if self.Type != type:
 if self.Type == "connection":
-self.Condition.UnConnect(delete = self.Parent.GetDrawingMode() == FREEDRAWING_MODE)
+self.Condition.UnConnect(delete=self.Parent.GetDrawingMode() == FREEDRAWING_MODE)
 self.Type = type
 if type == "connection":
 self.Condition = Connector(self, "", "BOOL", wx.Point(0, self.Size[1] / 2), WEST)
 else:
 if condition is None:
 input_block.MoveActionBlock((diffx, 0))
 input_block.Move(diffx, 0)
 input_block.RefreshInputPosition()
 # Align output element with this step
-def RefreshOutputPosition(self, move = None):
+def RefreshOutputPosition(self, move=None):
 wires = self.Output.GetWires()
 if len(wires) != 1:
 return
 current_pos = self.Output.GetPosition(False)
 output = wires[0][0].GetOtherConnected(self.Output)
 self.Move(movex, 0)
 self.RefreshInputPosition()
 self.RefreshOutputPosition()
 return movex, 0
 else:
-return Graphic_Element.ProcessDragging(self, movex, movey, event, scaling, width_fac = 2, height_fac = 2)
+return Graphic_Element.ProcessDragging(self, movex, movey, event, scaling, width_fac=2, height_fac=2)
 # Refresh input element model
 def RefreshInputModel(self):
 if self.Parent.GetDrawingMode() != FREEDRAWING_MODE:
 input = self.GetPreviousConnector()
 Class that implements the graphic representation of a divergence or convergence,
 selection or simultaneous
 """
 # Create a new divergence
-def __init__(self, parent, type, number = 2, id = None):
+def __init__(self, parent, type, number=2, id=None):
 Graphic_Element.__init__(self, parent)
 self.Type = type
 self.Id = id
 self.RealConnectors = None
 number = max(2, number)
 self.Size = wx.Size((number - 1) * SFC_DEFAULT_SEQUENCE_INTERVAL, self.GetMinSize()[1])
 # Create an input and output connector
 if self.Type in [SELECTION_DIVERGENCE, SIMULTANEOUS_DIVERGENCE]:
-self.Inputs = [Connector(self, "", None, wx.Point(self.Size[0] / 2, 0), NORTH, onlyone = True)]
+self.Inputs = [Connector(self, "", None, wx.Point(self.Size[0] / 2, 0), NORTH, onlyone=True)]
 self.Outputs = []
 for i in xrange(number):
-self.Outputs.append(Connector(self, "", None, wx.Point(i * SFC_DEFAULT_SEQUENCE_INTERVAL, self.Size[1]), SOUTH, onlyone = True))
+self.Outputs.append(Connector(self, "", None, wx.Point(i * SFC_DEFAULT_SEQUENCE_INTERVAL, self.Size[1]), SOUTH, onlyone=True))
 elif self.Type in [SELECTION_CONVERGENCE, SIMULTANEOUS_CONVERGENCE]:
 self.Inputs = []
 for i in xrange(number):
-self.Inputs.append(Connector(self, "", None, wx.Point(i * SFC_DEFAULT_SEQUENCE_INTERVAL, 0), NORTH, onlyone = True))
+self.Inputs.append(Connector(self, "", None, wx.Point(i * SFC_DEFAULT_SEQUENCE_INTERVAL, 0), NORTH, onlyone=True))
-self.Outputs = [Connector(self, "", None, wx.Point(self.Size[0] / 2, self.Size[1]), SOUTH, onlyone = True)]
+self.Outputs = [Connector(self, "", None, wx.Point(self.Size[0] / 2, self.Size[1]), SOUTH, onlyone=True)]
 self.Value = None
 self.PreviousValue = None
 def Flush(self):
 for input in self.Inputs:
 self.Parent.ElementNeedRefresh(self)
 for output in self.Outputs:
 output.SpreadCurrent(False)
 # Make a clone of this SFC_Divergence
-def Clone(self, parent, id = None, pos = None):
+def Clone(self, parent, id=None, pos=None):
 divergence = SFC_Divergence(parent, self.Type, max(len(self.Inputs), len(self.Outputs)), id)
 divergence.SetSize(self.Size[0], self.Size[1])
 if pos is not None:
 divergence.SetPosition(pos.x, pos.y)
 else:
 def GetConnectorTranslation(self, element):
 return dict(zip(self.Inputs + self.Outputs, element.Inputs + element.Outputs))
 # Returns the RedrawRect
-def GetRedrawRect(self, movex = 0, movey = 0):
+def GetRedrawRect(self, movex=0, movey=0):
 rect = Graphic_Element.GetRedrawRect(self, movex, movey)
 if movex != 0 or movey != 0:
 for input in self.Inputs:
 if input.IsConnected():
 rect = rect.Union(input.GetConnectedRedrawRect(movex, movey))
 return self.Type
 # Unconnect input and output
 def Clean(self):
 for input in self.Inputs:
-input.UnConnect(delete = self.Parent.GetDrawingMode() == FREEDRAWING_MODE)
+input.UnConnect(delete=self.Parent.GetDrawingMode() == FREEDRAWING_MODE)
 for output in self.Outputs:
-output.UnConnect(delete = self.Parent.GetDrawingMode() == FREEDRAWING_MODE)
+output.UnConnect(delete=self.Parent.GetDrawingMode() == FREEDRAWING_MODE)
 # Add a branch to the divergence
 def AddBranch(self):
 if self.Type in [SELECTION_DIVERGENCE, SIMULTANEOUS_DIVERGENCE]:
 maxx = 0
 for output in self.Outputs:
 pos = output.GetRelPosition()
 maxx = max(maxx, pos.x)
-connector = Connector(self, "", None, wx.Point(maxx + SFC_DEFAULT_SEQUENCE_INTERVAL, self.Size[1]), SOUTH, onlyone = True)
+connector = Connector(self, "", None, wx.Point(maxx + SFC_DEFAULT_SEQUENCE_INTERVAL, self.Size[1]), SOUTH, onlyone=True)
 self.Outputs.append(connector)
 self.MoveConnector(connector, 0)
 elif self.Type in [SELECTION_CONVERGENCE, SIMULTANEOUS_CONVERGENCE]:
 maxx = 0
 for input in self.Inputs:
 pos = input.GetRelPosition()
 maxx = max(maxx, pos.x)
-connector = Connector(self, "", None, wx.Point(maxx + SFC_DEFAULT_SEQUENCE_INTERVAL, 0), NORTH, onlyone = True)
+connector = Connector(self, "", None, wx.Point(maxx + SFC_DEFAULT_SEQUENCE_INTERVAL, 0), NORTH, onlyone=True)
 self.Inputs.append(connector)
 self.MoveConnector(connector, SFC_DEFAULT_SEQUENCE_INTERVAL)
 # Remove a branch from the divergence
 def RemoveBranch(self, connector):
 elif self.Type in [SIMULTANEOUS_DIVERGENCE, SIMULTANEOUS_CONVERGENCE]:
 self.BoundingBox = wx.Rect(self.Pos.x - SFC_SIMULTANEOUS_SEQUENCE_EXTRA, self.Pos.y,
 self.Size[0] + 2 * SFC_SIMULTANEOUS_SEQUENCE_EXTRA + 1, self.Size[1] + 1)
 # Refresh the position of wires connected to divergence
-def RefreshConnected(self, exclude = []):
+def RefreshConnected(self, exclude=[]):
 for input in self.Inputs:
 input.MoveConnected(exclude)
 for output in self.Outputs:
 output.MoveConnected(exclude)
 self.Size[0] = maxx - minx
 connector.MoveConnected()
 self.RefreshBoundingBox()
 # Returns the divergence connector that starts with the point given if it exists
-def GetConnector(self, position, name = None):
+def GetConnector(self, position, name=None):
 # if a name is given
 if name is not None:
 # Test each input and output connector
 #for input in self.Inputs:
 #    if name == input.GetName():
 # Returns input and output divergence connectors
 def GetConnectors(self):
 return {"inputs": self.Inputs, "outputs": self.Outputs}
 # Test if point given is on divergence input or output connector
-def TestConnector(self, pt, direction = None, exclude=True):
+def TestConnector(self, pt, direction=None, exclude=True):
 # Test input connector
 for input in self.Inputs:
 if input.TestPoint(pt, direction, exclude):
 return input
 # Test output connector
 self.RefreshOutputPosition((0, diffy))
 for input in self.Inputs:
 input.MoveConnected()
 # Align output element with this divergence
-def RefreshOutputPosition(self, move = None):
+def RefreshOutputPosition(self, move=None):
 if move:
 for output_connector in self.Outputs:
 wires = output_connector.GetWires()
 if len(wires) != 1:
 return
 """
 Class that implements the graphic representation of a jump to step
 """
 # Create a new jump
-def __init__(self, parent, target, id = None):
+def __init__(self, parent, target, id=None):
 Graphic_Element.__init__(self, parent)
 self.SetTarget(target)
 self.Id = id
 self.Size = wx.Size(SFC_JUMP_SIZE[0], SFC_JUMP_SIZE[1])
 self.Highlights = []
 # Create an input and output connector
-self.Input = Connector(self, "", None, wx.Point(self.Size[0] / 2, 0), NORTH, onlyone = True)
+self.Input = Connector(self, "", None, wx.Point(self.Size[0] / 2, 0), NORTH, onlyone=True)
 self.Value = None
 self.PreviousValue = None
 def Flush(self):
 if self.Input is not None:
 self.Value = self.Input.ReceivingCurrent()
 if self.Value != self.PreviousValue and self.Visible:
 self.Parent.ElementNeedRefresh(self)
 # Make a clone of this SFC_Jump
-def Clone(self, parent, id = None, pos = None):
+def Clone(self, parent, id=None, pos=None):
 jump = SFC_Jump(parent, self.Target, id)
 jump.SetSize(self.Size[0], self.Size[1])
 if pos is not None:
 jump.SetPosition(pos.x, pos.y)
 else:
 def GetConnectorTranslation(self, element):
 return {self.Input: element.Input}
 # Returns the RedrawRect
-def GetRedrawRect(self, movex = 0, movey = 0):
+def GetRedrawRect(self, movex=0, movey=0):
 rect = Graphic_Element.GetRedrawRect(self, movex, movey)
 if self.Input:
 rect = rect.Union(self.Input.GetRedrawRect(movex, movey))
 if movex != 0 or movey != 0:
 if self.Input.IsConnected():
 def Delete(self):
 self.Parent.DeleteJump(self)
 # Unconnect input
 def Clean(self):
-self.Input.UnConnect(delete = self.Parent.GetDrawingMode() == FREEDRAWING_MODE)
+self.Input.UnConnect(delete=self.Parent.GetDrawingMode() == FREEDRAWING_MODE)
 # Refresh the size of text for target
 def RefreshTargetSize(self):
 self.TargetSize = self.Parent.GetTextExtent(self.Target)
 horizontal_pos = round(float(self.Pos.x + horizontal_pos) / float(scaling[0])) * scaling[0] - self.Pos.x
 self.Input.SetPosition(wx.Point(horizontal_pos, 0))
 self.RefreshConnected()
 # Refresh the position of wires connected to jump
-def RefreshConnected(self, exclude = []):
+def RefreshConnected(self, exclude=[]):
 if self.Input:
 self.Input.MoveConnected(exclude)
 # Returns input jump connector
-def GetConnector(self, position = None, name = None):
+def GetConnector(self, position=None, name=None):
 return self.Input
 # Returns all the jump connectors
 def GetConnectors(self):
 return {"inputs": [self.Input], "outputs": []}
 # Test if point given is on jump input connector
-def TestConnector(self, pt, direction = None, exclude = True):
+def TestConnector(self, pt, direction=None, exclude=True):
 # Test input connector
 if self.Input and self.Input.TestPoint(pt, direction, exclude):
 return self.Input
 return None
 input_block.MoveActionBlock((diffx, 0))
 input_block.Move(diffx, 0)
 input_block.RefreshInputPosition()
 # Can't align output element, because there is no output
-def RefreshOutputPosition(self, move = None):
+def RefreshOutputPosition(self, move=None):
 pass
 # Method called when a LeftDClick event have been generated
 def OnLeftDClick(self, event, dc, scaling):
 # Edit the jump properties
 movex = round(float(self.Pos.x + movex) / float(scaling[0])) * scaling[0] - self.Pos.x
 self.Move(movex, 0)
 self.RefreshInputPosition()
 return movex, 0
 else:
-return Graphic_Element.ProcessDragging(self, movex, movey, event, scaling, width_fac = 2)
+return Graphic_Element.ProcessDragging(self, movex, movey, event, scaling, width_fac=2)
 # Refresh input element model
 def RefreshInputModel(self):
 if self.Parent.GetDrawingMode() != FREEDRAWING_MODE:
 input = self.GetPreviousConnector()
 """
 Class that implements the graphic representation of an action block
 """
 # Create a new action block
-def __init__(self, parent, actions = [], id = None):
+def __init__(self, parent, actions=[], id=None):
 Graphic_Element.__init__(self, parent)
 self.Id = id
 self.Size = wx.Size(SFC_ACTION_MIN_SIZE[0], SFC_ACTION_MIN_SIZE[1])
 self.MinSize = wx.Size(SFC_ACTION_MIN_SIZE[0], SFC_ACTION_MIN_SIZE[1])
 self.Highlights = {}
 # Create an input and output connector
-self.Input = Connector(self, "", None, wx.Point(0, SFC_ACTION_MIN_SIZE[1] / 2), WEST, onlyone = True)
+self.Input = Connector(self, "", None, wx.Point(0, SFC_ACTION_MIN_SIZE[1] / 2), WEST, onlyone=True)
 self.SetActions(actions)
 self.Value = None
 self.PreviousValue = None
 def Flush(self):
 self.Value = self.Input.ReceivingCurrent()
 if self.Value != self.PreviousValue and self.Visible:
 self.Parent.ElementNeedRefresh(self)
 # Make a clone of this SFC_ActionBlock
-def Clone(self, parent, id = None, pos = None):
+def Clone(self, parent, id=None, pos=None):
 actions = [action.copy() for action in self.Actions]
 action_block = SFC_ActionBlock(parent, actions, id)
 action_block.SetSize(self.Size[0], self.Size[1])
 if pos is not None:
 action_block.SetPosition(pos.x, pos.y)
 def GetConnectorTranslation(self, element):
 return {self.Input: element.Input}
 # Returns the RedrawRect
-def GetRedrawRect(self, movex = 0, movey = 0):
+def GetRedrawRect(self, movex=0, movey=0):
 rect = Graphic_Element.GetRedrawRect(self, movex, movey)
 if self.Input:
 rect = rect.Union(self.Input.GetRedrawRect(movex, movey))
 if movex != 0 or movey != 0:
 if self.Input.IsConnected():
 def Delete(self):
 self.Parent.DeleteActionBlock(self)
 # Unconnect input and output
 def Clean(self):
-self.Input.UnConnect(delete = self.Parent.GetDrawingMode() == FREEDRAWING_MODE)
+self.Input.UnConnect(delete=self.Parent.GetDrawingMode() == FREEDRAWING_MODE)
 # Refresh the action block bounding box
 def RefreshBoundingBox(self):
 self.BoundingBox = wx.Rect(self.Pos.x, self.Pos.y, self.Size[0] + 1, self.Size[1] + 1)
 # Refresh the position of wires connected to action block
-def RefreshConnected(self, exclude = []):
+def RefreshConnected(self, exclude=[]):
 self.Input.MoveConnected(exclude)
 # Returns input action block connector
-def GetConnector(self, position = None, name = None):
+def GetConnector(self, position=None, name=None):
 return self.Input
 # Returns all the action block connectors
 def GetConnectors(self):
 return {"inputs": [self.Input], "outputs": []}
 # Test if point given is on action block input connector
-def TestConnector(self, pt, direction = None, exclude = True):
+def TestConnector(self, pt, direction=None, exclude=True):
 # Test input connector
 if self.Input.TestPoint(pt, direction, exclude):
 return self.Input
 return None

changeset 1744	69dfdb26f600
parent 1743	c3c3d1318130
child 1754	63f4af6bf6d9