plcopeneditor_history: comparison graphics/SFC

equal deleted inserted replaced

-:36d378bd852e
+:dae55dd9ee14
 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):
+def GetConnector(self, position, name = None):
+# if a name is given
+if name:
+# Test input, output and action connector if they exists
+if self.Input and name == self.Input.GetName():
+return self.Input
+if self.Output and name == self.Output.GetName():
+return self.Output
+if self.Action and name == self.Action.GetName():
+return self.Action
 # Test input connector if it exists
 if self.Input:
 input_pos = self.Input.GetRelPosition()
 if position.x == self.Pos.x + input_pos.x and position.y == self.Pos.y + input_pos.y:
 return self.Input
 action_block.Move(move[0], move[1], self.Parent.Wires)
 wires[0][0].Move(move[0], move[1], True)
 # Resize the divergence from position and size given
 def Resize(self, x, y, width, height):
-self.UpdateSize(width, height)
+if self.Parent.GetDrawingMode() != FREEDRAWING_MODE:
+self.UpdateSize(width, height)
+else:
+Graphic_Element.Resize(self, x, y, width, height)
 # Method called when a LeftDClick event have been generated
 def OnLeftDClick(self, event, scaling):
 # Edit the step properties
 self.Parent.EditStepContent(self)
 # Method called when a RightUp event have been generated
-def OnRightUp(self, event, scaling):
+def OnRightUp(self, event, dc, scaling):
 # Popup the menu with special items for a step
 self.Parent.PopupDefaultMenu()
 # Refreshes the step state according to move defined and handle selected
 def ProcessDragging(self, movex, movey):
 handle_type, handle = self.Handle
 if handle_type == HANDLE_MOVE:
 action_block = None
-if self.Initial:
+if self.Parent.GetDrawingMode() == FREEDRAWING_MODE:
+self.Move(movex, movey)
+self.RefreshConnected()
+elif self.Initial:
 self.MoveActionBlock((movex, movey))
 self.Move(movex, movey, self.Parent.Wires)
 self.RefreshOutputPosition((movex, movey))
 else:
 self.MoveActionBlock((movex, 0))
 if action:
 action_block = action.GetParentBlock()
 action_block.RefreshModel(False)
 # If step has moved, refresh the model of wires connected to output
 if move:
-self.RefreshInputModel()
+if self.Parent.GetDrawingMode() != FREEDRAWING_MODE:
-self.RefreshOutputModel(self.Initial)
+self.RefreshInputModel()
+self.RefreshOutputModel(self.Initial)
+elif self.Output:
+self.Output.RefreshWires()
 # Draws step
 def Draw(self, dc):
 dc.SetPen(wxBLACK_PEN)
 dc.SetBrush(wxWHITE_BRUSH)
 self.Input = None
 self.Output = None
 # Forbids to change the transition size
 def SetSize(self, width, height):
-pass
+if self.Parent.GetDrawingMode() == FREEDRAWING_MODE:
+Graphic_Element.SetSize(self, width, height)
 # Forbids to resize the transition
 def Resize(self, x, y, width, height):
-pass
+if self.Parent.GetDrawingMode() == FREEDRAWING_MODE:
+Graphic_Element.Resize(self, x, y, width, height)
 # Delete this transition by calling the appropriate method
 def Delete(self):
 self.Parent.DeleteTransition(self)
 def RefreshConnected(self, exclude = []):
 self.Input.MoveConnected(exclude)
 self.Output.MoveConnected(exclude)
 # Returns the transition connector that starts with the point given if it exists
-def GetConnector(self, position):
+def GetConnector(self, position, name = None):
+# if a name is given
+if name:
+# Test input and output connector
+if name == self.Input.GetName():
+return self.Input
+if name == self.Output.GetName():
+return self.Output
 # Test input connector
 input_pos = self.Input.GetRelPosition()
 if position.x == self.Pos.x + input_pos.x and position.y == self.Pos.y + input_pos.y:
 return self.Input
 # Test output connector
 else:
 if isinstance(output_block, SFC_Step):
 output_block.MoveActionBlock((diffx, 0))
 output_block.Move(diffx, 0)
 output_block.RefreshOutputPosition()
 # Method called when a LeftDClick event have been generated
-def OnLeftDClick(self, event, scaling):
+def OnLeftDClick(self, event, dc, scaling):
 # Edit the transition properties
 self.Parent.EditTransitionContent(self)
 # Method called when a RightUp event have been generated
-def OnRightUp(self, event, scaling):
+def OnRightUp(self, event, dc, scaling):
 # Popup the menu with special items for a step
 self.Parent.PopupDefaultMenu()
 # Refreshes the transition state according to move defined and handle selected
 def ProcessDragging(self, movex, movey):
-self.Move(movex, 0)
+if self.Parent.GetDrawingMode() != FREEDRAWING_MODE:
-self.RefreshInputPosition()
+self.Move(movex, 0)
-self.RefreshOutputPosition()
+self.RefreshInputPosition()
+self.RefreshOutputPosition()
+else:
+Graphic_Element.ProcessDragging(self, movex, movey)
 # Refresh input element model
 def RefreshInputModel(self):
-input = self.GetPreviousConnector()
+if self.Parent.GetDrawingMode() != FREEDRAWING_MODE:
-if input:
+input = self.GetPreviousConnector()
-input_block = input.GetParentBlock()
+if input:
-input_block.RefreshModel(False)
+input_block = input.GetParentBlock()
-if not isinstance(input_block, SFC_Divergence):
+input_block.RefreshModel(False)
-input_block.RefreshInputModel()
+if not isinstance(input_block, SFC_Divergence):
+input_block.RefreshInputModel()
 # Refresh output element model
 def RefreshOutputModel(self, move=False):
 output = self.GetNextConnector()
 if output:
 # Refreshes the transition model
 def RefreshModel(self, move=True):
 self.Parent.RefreshTransitionModel(self)
 # If transition has moved, refresh the model of wires connected to output
 if move:
-self.RefreshInputModel()
+if self.Parent.GetDrawingMode() != FREEDRAWING_MODE:
-self.RefreshOutputModel()
+self.RefreshInputModel()
+self.RefreshOutputModel()
+else:
+self.Output.RefreshWires()
 # Draws transition
 def Draw(self, dc):
 dc.SetPen(wxBLACK_PEN)
 dc.SetBrush(wxBLACK_BRUSH)
 self.Inputs = []
 self.Outputs = []
 # Forbids to resize the divergence
 def Resize(self, x, y, width, height):
-pass
+if self.Parent.GetDrawingMode() == FREEDRAWING_MODE:
+Graphic_Element.Resize(self, x, y, width, height)
 # Delete this divergence by calling the appropriate method
 def Delete(self):
 self.Parent.DeleteDivergence(self)
 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):
+def GetConnector(self, position, name = None):
+# if a name is given
+if name:
+# Test each input and output connector
+for input in self.Inputs:
+if name == input.GetName():
+return input
+for output in self.Outputs:
+if name == output.GetName():
+return output
 # Test input connector
 for input in self.Inputs:
 input_pos = input.GetPosition(False)
 if position.x == input_pos.x and position.y == input_pos.y:
 return input
 # Changes the divergence size
 def SetSize(self, width, height):
 for i, input in enumerate(self.Inputs):
 position = input.GetRelPosition()
 if self.RealConnectors:
-input.SetPosition(wxPoint(int(round(self.RealConnectors["Inputs"][i] * width)), position.y))
+input.SetPosition(wxPoint(int(round(self.RealConnectors["Inputs"][i] * width)), 0))
 else:
-input.SetPosition(wxPoint(int(round(float(position.x)*float(width)/float(self.Size[0]))), position.y))
+input.SetPosition(wxPoint(int(round(float(position.x)*float(width)/float(self.Size[0]))), 0))
 input.MoveConnected()
 for i, output in enumerate(self.Outputs):
 position = output.GetRelPosition()
 if self.RealConnectors:
-output.SetPosition(wxPoint(int(round(self.RealConnectors["Outputs"][i] * width)), position.y))
+output.SetPosition(wxPoint(int(round(self.RealConnectors["Outputs"][i] * width)), self.Size[1]))
 else:
-output.SetPosition(wxPoint(int(round(float(position.x)*float(width)/float(self.Size[0]))), position.y))
+output.SetPosition(wxPoint(int(round(float(position.x)*float(width)/float(self.Size[0]))), self.Size[1]))
 output.MoveConnected()
-self.Size = wxSize(width, self.Size[1])
+self.Size = wxSize(width, height)
 self.RefreshBoundingBox()
 # Returns the divergence minimum size
 def GetMinSize(self):
-return 0, self.Size[1]
+if self.Type in [SELECTION_DIVERGENCE, SELECTION_CONVERGENCE]:
+return 0, 1
+elif self.Type in [SIMULTANEOUS_DIVERGENCE, SIMULTANEOUS_CONVERGENCE]:
+return 0, 3
+return 0, 0
 # Refresh the position of the block connected to connector
 def RefreshConnectedPosition(self, connector):
 wires = connector.GetWires()
 if len(wires) != 1:
 next_block.Move(diffx, 0)
 if connector in self.Inputs:
 next_block.RefreshInputPosition()
 else:
 next_block.RefreshOutputPosition()
 # Refresh the position of this divergence
 def RefreshPosition(self):
 y = 0
 for input in self.Inputs:
 wires = input.GetWires()
 if not isinstance(output_block, SFC_Divergence) or output_block.GetConnectors()["inputs"].index(output) == 0:
 output_block.Move(move[0], move[1], self.Parent.Wires)
 output_block.RefreshOutputPosition(move)
 # Method called when a LeftDown event have been generated
-def OnLeftDown(self, event, scaling):
+def OnLeftDown(self, event, dc, scaling):
-pos = GetScaledEventPosition(event, scaling)
+pos = GetScaledEventPosition(event, dc, scaling)
 # Test if a connector have been handled
 connector = self.TestConnector(pos, False)
 if connector:
 self.Handle = (HANDLE_CONNECTOR, connector)
 self.Parent.SetCursor(wxStockCursor(wxCURSOR_HAND))
 self.Selected = False
 # Initializes the last position
-self.oldPos = GetScaledEventPosition(event, scaling)
+self.oldPos = GetScaledEventPosition(event, dc, scaling)
 else:
 self.RealConnectors = {"Inputs":[],"Outputs":[]}
 for input in self.Inputs:
 position = input.GetRelPosition()
 self.RealConnectors["Inputs"].append(float(position.x)/float(self.Size[0]))
 for output in self.Outputs:
 position = output.GetRelPosition()
 self.RealConnectors["Outputs"].append(float(position.x)/float(self.Size[0]))
-Graphic_Element.OnLeftDown(self, event, scaling)
+Graphic_Element.OnLeftDown(self, event, dc, scaling)
 # Method called when a LeftUp event have been generated
-def OnLeftUp(self, event, scaling):
+def OnLeftUp(self, event, dc, scaling):
 self.RealConnectors = None
 handle_type, handle = self.Handle
 if handle_type == HANDLE_CONNECTOR:
 wires = handle.GetWires()
 if len(wires) != 1:
 if not isinstance(block, SFC_Divergence):
 if handle in self.Inputs:
 block.RefreshInputModel()
 else:
 block.RefreshOutputModel()
-Graphic_Element.OnLeftUp(self, event, scaling)
+Graphic_Element.OnLeftUp(self, event, dc, scaling)
 # Method called when a RightUp event have been generated
-def OnRightUp(self, event, scaling):
+def OnRightUp(self, event, dc, scaling):
-pos = GetScaledEventPosition(event, scaling)
+pos = GetScaledEventPosition(event, dc, scaling)
 # Popup the menu with special items for a block and a connector if one is handled
 connector = self.TestConnector(pos, False)
 if connector:
 self.Handle = (HANDLE_CONNECTOR, connector)
 self.Parent.PopupDivergenceMenu(True)
 def ProcessDragging(self, movex, movey):
 handle_type, handle = self.Handle
 # A connector has been handled
 if handle_type == HANDLE_CONNECTOR:
 self.MoveConnector(handle, movex)
-self.RefreshConnectedPosition(handle)
+if self.Parent.GetDrawingMode() != FREEDRAWING_MODE:
+self.RefreshConnectedPosition(handle)
+elif self.Parent.GetDrawingMode() == FREEDRAWING_MODE:
+Graphic_Element.ProcessDragging(self, movex, movey)
 # Refresh output element model
 def RefreshOutputModel(self, move=False):
-if move:
+if move and self.Parent.GetDrawingMode() != FREEDRAWING_MODE:
 for output in self.Outputs:
 wires = output.GetWires()
 if len(wires) != 1:
 return
 output_block = wires[0][0].StartConnected.GetParentBlock()
 # Refreshes the divergence model
 def RefreshModel(self, move=True):
 self.Parent.RefreshDivergenceModel(self)
 # If divergence has moved, refresh the model of wires connected to outputs
 if move:
-self.RefreshOutputModel()
+if self.Parent.GetDrawingMode() != FREEDRAWING_MODE:
+self.RefreshOutputModel()
+else:
+for output in self.Outputs:
+output.RefreshWires()
 # Draws divergence
 def Draw(self, dc):
 dc.SetPen(wxBLACK_PEN)
 dc.SetBrush(wxBLACK_BRUSH)
 if self.Type in [SELECTION_DIVERGENCE, SELECTION_CONVERGENCE]:
 dc.DrawRectangle(self.Pos.x, self.Pos.y, self.Size[0] + 1, self.Size[1] + 1)
 elif self.Type in [SIMULTANEOUS_DIVERGENCE, SIMULTANEOUS_CONVERGENCE]:
 dc.DrawLine(self.Pos.x - SFC_SIMULTANEOUS_SEQUENCE_EXTRA, self.Pos.y,
 self.Pos.x + self.Size[0] + SFC_SIMULTANEOUS_SEQUENCE_EXTRA + 1, self.Pos.y)
-dc.DrawLine(self.Pos.x - SFC_SIMULTANEOUS_SEQUENCE_EXTRA, self.Pos.y + 3,
+dc.DrawLine(self.Pos.x - SFC_SIMULTANEOUS_SEQUENCE_EXTRA, self.Pos.y + self.Size[1],
-self.Pos.x + self.Size[0] + SFC_SIMULTANEOUS_SEQUENCE_EXTRA + 1, self.Pos.y + 3)
+self.Pos.x + self.Size[0] + SFC_SIMULTANEOUS_SEQUENCE_EXTRA + 1, self.Pos.y + self.Size[1])
 # Draw inputs and outputs connectors
 for input in self.Inputs:
 input.Draw(dc)
 for output in self.Outputs:
 output.Draw(dc)
 # Create an input and output connector
 self.Input = Connector(self, "", "ANY", wxPoint(self.Size[0] / 2, 0), NORTH)
 # Destructor
 def __del__(self):
-self.Inputs = None
+self.Input = None
 # Forbids to change the jump size
 def SetSize(self, width, height):
-pass
+if self.Parent.GetDrawingMode() == FREEDRAWING_MODE:
+Graphic_Element.SetSize(self, width, height)
 # Forbids to resize jump
 def Resize(self, x, y, width, height):
-pass
+if self.Parent.GetDrawingMode() == FREEDRAWING_MODE:
+Graphic_Element.Resize(self, x, y, width, height)
 # Delete this jump by calling the appropriate method
 def Delete(self):
 self.Parent.DeleteJump(self)
 # Unconnect input
 def Clean(self):
-if self.Input:
+self.Input.UnConnect()
-self.Input.UnConnect()
 # Refresh the jump bounding box
 def RefreshBoundingBox(self):
 dc = wxClientDC(self.Parent)
 text_width, text_height = dc.GetTextExtent(self.Target)
 self.BoundingBox = wxRect(self.Pos.x, self.Pos.y - CONNECTOR_SIZE,
 bbx_width + 1, self.Size[1] + CONNECTOR_SIZE + 1)
 # Returns the connector connected to input
 def GetPreviousConnector(self):
-if self.Input:
+wires = self.Input.GetWires()
-wires = self.Input.GetWires()
+if len(wires) == 1:
-if len(wires) == 1:
+return wires[0][0].EndConnected
-return wires[0][0].EndConnected
 return None
+# Refresh the element connectors position
+def RefreshConnectors(self):
+self.Input.SetPosition(wxPoint(self.Size[0] / 2, 0))
+self.RefreshConnected()
 # Refresh the position of wires connected to jump
 def RefreshConnected(self, exclude = []):
 if self.Input:
 self.Input.MoveConnected(exclude)
 # Returns input jump connector
-def GetConnector(self, position = None):
+def GetConnector(self, position = None, name = None):
 return self.Input
 # Test if point given is on jump input connector
 def TestConnector(self, pt, exclude = True):
 # Test input connector
 # Can't align output element, because there is no output
 def RefreshOutputPosition(self, move = None):
 pass
 # Method called when a LeftDClick event have been generated
-def OnLeftDClick(self, event, scaling):
+def OnLeftDClick(self, event, dc, scaling):
 # Edit the jump properties
 self.Parent.EditJumpContent(self)
 # Method called when a RightUp event have been generated
-def OnRightUp(self, event, scaling):
+def OnRightUp(self, event, dc, scaling):
 # Popup the default menu
 self.Parent.PopupDefaultMenu()
 # Refreshes the jump state according to move defined and handle selected
 def ProcessDragging(self, movex, movey):
-self.Move(movex, 0)
+if self.Parent.GetDrawingMode() != FREEDRAWING_MODE:
-self.RefreshInputPosition()
+self.Move(movex, 0)
+self.RefreshInputPosition()
+else:
+Graphic_Element.ProcessDragging(self, movex, movey)
 # Refresh input element model
 def RefreshInputModel(self):
-input = self.GetPreviousConnector()
+if self.Parent.GetDrawingMode() != FREEDRAWING_MODE:
-if input:
+input = self.GetPreviousConnector()
-input_block = input.GetParentBlock()
+if input:
-input_block.RefreshModel(False)
+input_block = input.GetParentBlock()
-if not isinstance(input_block, SFC_Divergence):
+input_block.RefreshModel(False)
-input_block.RefreshInputModel()
+if not isinstance(input_block, SFC_Divergence):
+input_block.RefreshInputModel()
 # Refresh output element model
 def RefreshOutputModel(self, move=False):
 pass
 # Refreshes the jump model
 def RefreshModel(self, move=True):
 self.Parent.RefreshJumpModel(self)
 if move:
-self.RefreshInputModel()
+if self.Parent.GetDrawingMode() != FREEDRAWING_MODE:
+self.RefreshInputModel()
 # Draws divergence
 def Draw(self, dc):
 dc.SetPen(wxBLACK_PEN)
 dc.SetBrush(wxBLACK_BRUSH)
 # Returns the number of action lines
 def GetLineNumber(self):
 return len(self.Actions)
+def GetLineSize(self):
+if len(self.Actions) > 1:
+return self.Size[1] / len(self.Actions)
+else:
+return SFC_ACTION_MIN_SIZE[1]
 # Forbids to resize the action block
 def Resize(self, x, y, width, height):
-if x == 0:
+if self.Parent.GetDrawingMode() != FREEDRAWING_MODE:
-self.SetSize(width, self.Size[1])
+if x == 0:
+self.SetSize(width, self.Size[1])
+else:
+Graphic_Element.Resize(self, x, y, width, height)
 # Delete this action block by calling the appropriate method
 def Delete(self):
 self.Parent.DeleteActionBlock(self)
 # Refresh the position of wires connected to action block
 def RefreshConnected(self, exclude = []):
 self.Input.MoveConnected(exclude)
 # Returns input action block connector
-def GetConnector(self, position = None):
+def GetConnector(self, position = None, name = None):
 return self.Input
 # Test if point given is on action block input connector
 def TestConnector(self, pt, exclude = True):
 # Test input connector
 width, height = dc.GetTextExtent(action["value"])
 self.ColSize[1] = max(self.ColSize[1], width + 10)
 if "indicator" in action and action["indicator"] != "":
 width, height = dc.GetTextExtent(action["indicator"])
 self.ColSize[2] = max(self.ColSize[2], width + 10)
-self.Size = wxSize(max(self.ColSize[0] + self.ColSize[1] + self.ColSize[2],
+if self.Parent.GetDrawingMode() == FREEDRAWING_MODE:
-SFC_ACTION_MIN_SIZE[0]), len(self.Actions) * SFC_ACTION_MIN_SIZE[1])
+line_size = self.GetLineSize()
+self.Size = wxSize(self.ColSize[0] + self.ColSize[1] + self.ColSize[2], len(self.Actions) * line_size)
+else:
+self.Size = wxSize(max(self.ColSize[0] + self.ColSize[1] + self.ColSize[2],
+SFC_ACTION_MIN_SIZE[0]), len(self.Actions) * SFC_ACTION_MIN_SIZE[1])
 self.RefreshBoundingBox()
 if self.Input:
 wires = self.Input.GetWires()
 if len(wires) == 1:
 input_block = wires[0][0].EndConnected.GetParentBlock()
 def GetMinSize(self):
 return max(self.ColSize[0] + self.ColSize[1] + self.ColSize[2],
 SFC_ACTION_MIN_SIZE[0]), len(self.Actions) * SFC_ACTION_MIN_SIZE[1]
 # Method called when a LeftDClick event have been generated
-def OnLeftDClick(self, event, scaling):
+def OnLeftDClick(self, event, dc, scaling):
 # Edit the action block properties
 self.Parent.EditActionBlockContent(self)
 # Refreshes the action block state according to move defined and handle selected
 def ProcessDragging(self, movex, movey):
-handle_type, handle = self.Handle
+if self.Parent.GetDrawingMode() != FREEDRAWING_MODE:
-if handle_type == HANDLE_MOVE:
+handle_type, handle = self.Handle
-wires = self.Input.GetWires()
+if handle_type == HANDLE_MOVE:
-if len(wires) == 1:
+wires = self.Input.GetWires()
-input_pos = wires[0][0].EndConnected.GetPosition(False)
+if len(wires) == 1:
-if self.Pos.x - input_pos.x + movex >= SFC_WIRE_MIN_SIZE:
+input_pos = wires[0][0].EndConnected.GetPosition(False)
-self.Move(movex, 0)
+if self.Pos.x - input_pos.x + movex >= SFC_WIRE_MIN_SIZE:
+self.Move(movex, 0)
+else:
+Graphic_Element.ProcessDragging(self, movex, movey)
 else:
 Graphic_Element.ProcessDragging(self, movex, movey)
 # Refreshes the action block model
 def RefreshModel(self, move=True):
 self.Parent.RefreshActionBlockModel(self)
 dc.DrawRectangle(self.Pos.x, self.Pos.y, self.Size[0] + 1, self.Size[1] + 1)
 dc.DrawLine(self.Pos.x + colsize[0], self.Pos.y,
 self.Pos.x + colsize[0], self.Pos.y + self.Size[1])
 dc.DrawLine(self.Pos.x + colsize[0] + colsize[1], self.Pos.y,
 self.Pos.x + colsize[0] + colsize[1], self.Pos.y + self.Size[1])
+line_size = self.GetLineSize()
 for i, action in enumerate(self.Actions):
 if i != 0:
-dc.DrawLine(self.Pos.x, self.Pos.y + i * SFC_ACTION_MIN_SIZE[1],
+dc.DrawLine(self.Pos.x, self.Pos.y + i * line_size,
-self.Pos.x + self.Size[0], self.Pos.y + i * SFC_ACTION_MIN_SIZE[1])
+self.Pos.x + self.Size[0], self.Pos.y + i * line_size)
 text_width, text_height = dc.GetTextExtent(action["qualifier"])
 if "duration" in action:
 dc.DrawText(action["qualifier"], self.Pos.x + (colsize[0] - text_width) / 2,
-self.Pos.y + i * SFC_ACTION_MIN_SIZE[1] + SFC_ACTION_MIN_SIZE[1] / 2 - text_height)
+self.Pos.y + i * line_size + line_size / 2 - text_height)
 text_width, text_height = dc.GetTextExtent(action["duration"])
 dc.DrawText(action["duration"], self.Pos.x + (colsize[0] - text_width) / 2,
-self.Pos.y + i * SFC_ACTION_MIN_SIZE[1] + SFC_ACTION_MIN_SIZE[1] / 2)
+self.Pos.y + i * line_size + line_size / 2)
 else:
 dc.DrawText(action["qualifier"], self.Pos.x + (colsize[0] - text_width) / 2,
-self.Pos.y + i * SFC_ACTION_MIN_SIZE[1] + (SFC_ACTION_MIN_SIZE[1] - text_height) / 2)
+self.Pos.y + i * line_size + (line_size - text_height) / 2)
 text_width, text_height = dc.GetTextExtent(action["value"])
 dc.DrawText(action["value"], self.Pos.x + colsize[0] + (colsize[1] - text_width) / 2,
-self.Pos.y + i * SFC_ACTION_MIN_SIZE[1] + (SFC_ACTION_MIN_SIZE[1] - text_height) / 2)
+self.Pos.y + i * line_size + (line_size - text_height) / 2)
 if "indicator" in action:
 text_width, text_height = dc.GetTextExtent(action["indicator"])
 dc.DrawText(action["indicator"], self.Pos.x + colsize[0] + colsize[1] + (colsize[2] - text_width) / 2,
-self.Pos.y + i * SFC_ACTION_MIN_SIZE[1] + (SFC_ACTION_MIN_SIZE[1] - text_height) / 2)
+self.Pos.y + i * line_size + (line_size - text_height) / 2)
 # Draw input connector
 self.Input.Draw(dc)
 Graphic_Element.Draw(self, dc)

changeset 27	dae55dd9ee14
parent 5	f8652b073e84
child 42	4a8400732001