graphics/SFC_Objects.py
author Surkov Sergey <surkovsv93@gmail.com>
Tue, 27 Jun 2017 19:21:09 +0300
changeset 1710 953ceea2573e
parent 1653 d98cc9d19a5c
child 1730 64d8f52bc8c8
permissions -rw-r--r--
fix bug with TextViewer instance in debug mode, appears after transferring new program on PLC
TextViewer isn't able to display debug values, so calling for this class SubscribeAllDataConsumers method causes error
#!/usr/bin/env python
# -*- coding: utf-8 -*-

# This file is part of Beremiz, a Integrated Development Environment for
# programming IEC 61131-3 automates supporting plcopen standard and CanFestival.
#
# Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD
#
# See COPYING file for copyrights details.
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

import wx

from graphics.GraphicCommons import *
from graphics.DebugDataConsumer import DebugDataConsumer
from plcopen.structures import *

def GetWireSize(block):
    if isinstance(block, SFC_Step):
        return SFC_WIRE_MIN_SIZE + block.GetActionExtraLineNumber() * SFC_ACTION_MIN_SIZE[1]
    else:
        return SFC_WIRE_MIN_SIZE

#-------------------------------------------------------------------------------
#                         Sequencial Function Chart Step
#-------------------------------------------------------------------------------

"""
Class that implements the graphic representation of a step
"""

class SFC_Step(Graphic_Element, DebugDataConsumer):
    
    # Create a new step
    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
        self.Highlights = []
        self.Size = wx.Size(SFC_STEP_DEFAULT_SIZE[0], SFC_STEP_DEFAULT_SIZE[1])
        # Create an input and output connector
        if not self.Initial:
            self.Input = Connector(self, "", None, wx.Point(self.Size[0] / 2, 0), NORTH)
        else:
            self.Input = None
        self.Output = None
        self.Action = None
        self.PreviousValue = None
        self.PreviousSpreading = False
    
    def Flush(self):
        if self.Input is not None:
            self.Input.Flush()
            self.Input = None
        if self.Output is not None:
            self.Output.Flush()
            self.Output = None
        if self.Action is not None:
            self.Action.Flush()
            self.Action = None
    
    def SetForced(self, forced):
        if self.Forced != forced:
            self.Forced = forced
            if self.Visible:
                self.Parent.ElementNeedRefresh(self)
    
    def SetValue(self, value):
        self.PreviousValue = self.Value
        self.Value = value
        if self.Value != self.PreviousValue:
            if self.Visible:
                self.Parent.ElementNeedRefresh(self)
            self.SpreadCurrent()
    
    def SpreadCurrent(self):
        if self.Parent.Debug:
            spreading = self.Value
            if spreading and not self.PreviousSpreading:
                if self.Output is not None:
                    self.Output.SpreadCurrent(True)
                if self.Action is not None:
                    self.Action.SpreadCurrent(True)
            elif not spreading and self.PreviousSpreading:
                if self.Output is not None:
                    self.Output.SpreadCurrent(False)
                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):
        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:
            step.SetPosition(self.Pos.x, self.Pos.y)
        if self.Input:
            step.Input = self.Input.Clone(step)
        if self.Output:
            step.Output = self.Output.Clone(step)
        if self.Action:
            step.Action = self.Action.Clone(step)
        return step
    
    def GetConnectorTranslation(self, element):
        connectors = {}
        if self.Input is not None:
            connectors[self.Input] = element.Input
        if self.Output is not None:
            connectors[self.Output] = element.Output
        if self.Action is not None:
            connectors[self.Action] = element.Action
        return connectors
    
    # Returns the RedrawRect
    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))
        if self.Action:
            rect = rect.Union(self.Action.GetRedrawRect(movex, movey))
        if movex != 0 or movey != 0:
            if self.Input and self.Input.IsConnected():
                rect = rect.Union(self.Input.GetConnectedRedrawRect(movex, movey))
            if self.Output and self.Output.IsConnected():
                rect = rect.Union(self.Output.GetConnectedRedrawRect(movex, movey))
            if self.Action and self.Action.IsConnected():
                rect = rect.Union(self.Action.GetConnectedRedrawRect(movex, movey))
        return rect
    
    # Delete this step by calling the appropriate method
    def Delete(self):
        self.Parent.DeleteStep(self)
    
    # Unconnect input and output
    def Clean(self):
        if self.Input:
            self.Input.UnConnect(delete = self.Parent.GetDrawingMode() == FREEDRAWING_MODE)
        if self.Output:
            self.Output.UnConnect(delete = self.Parent.GetDrawingMode() == FREEDRAWING_MODE)
        if self.Action:
            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)
    
    # Add output connector to step
    def AddInput(self):
        if not self.Input:
            self.Input = Connector(self, "", None, wx.Point(self.Size[0] / 2, 0), NORTH)
            self.RefreshBoundingBox()
    
    # Remove output connector from step
    def RemoveInput(self):
        if self.Input:
            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.RefreshBoundingBox()
    
    # Remove output connector from step
    def RemoveOutput(self):
        if self.Output:
            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.RefreshBoundingBox()
    
    # Remove action connector from step
    def RemoveAction(self):
        if self.Action:
            self.Action.UnConnect(delete = self.Parent.GetDrawingMode() == FREEDRAWING_MODE)
            self.Action = None
            self.RefreshBoundingBox()
    
    # Refresh the step bounding box
    def RefreshBoundingBox(self):
        # Calculate the bounding box size
        if self.Action:
            bbx_width = self.Size[0] + CONNECTOR_SIZE
        else:
            bbx_width = self.Size[0]
        if self.Initial:
            bbx_y = self.Pos.y
            bbx_height = self.Size[1]
            if self.Output:
                bbx_height += CONNECTOR_SIZE
        else:
            bbx_y = self.Pos.y - CONNECTOR_SIZE
            bbx_height = self.Size[1] + CONNECTOR_SIZE
            if self.Output:
                bbx_height += CONNECTOR_SIZE
        #self.BoundingBox = wx.Rect(self.Pos.x, bbx_y, bbx_width + 1, bbx_height + 1)
        self.BoundingBox = wx.Rect(self.Pos.x, self.Pos.y, self.Size[0] + 1, self.Size[1] + 1)
        
    # Refresh the positions of the step connectors
    def RefreshConnectors(self):
        scaling = self.Parent.GetScaling()
        horizontal_pos = self.Size[0] / 2
        vertical_pos = self.Size[1] / 2
        if scaling is not None:
            horizontal_pos = round(float(self.Pos.x + horizontal_pos) / float(scaling[0])) * scaling[0] - self.Pos.x
            vertical_pos = round(float(self.Pos.y + vertical_pos) / float(scaling[1])) * scaling[1] - self.Pos.y
        # Update input position if it exists
        if self.Input:
            self.Input.SetPosition(wx.Point(horizontal_pos, 0))
        # Update output position
        if self.Output:
            self.Output.SetPosition(wx.Point(horizontal_pos, self.Size[1]))
        # Update action position if it exists
        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 = []):
        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):
        # 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 and name == self.Output.GetName():
                return self.Output
            if self.Action and name == self.Action.GetName():
                return self.Action
        connectors = []
        # Test input connector if it exists
        if self.Input:
            connectors.append(self.Input)
        # Test output connector if it exists
        if self.Output:
            connectors.append(self.Output)
        # Test action connector if it exists
        if self.Action:
            connectors.append(self.Action)
        return self.FindNearestConnector(position, connectors)
    
    # Returns action step connector 
    def GetActionConnector(self):
        return self.Action
        
    # Returns input and output step connectors 
    def GetConnectors(self):
        connectors = {"inputs": [], "outputs": []}
        if self.Input:
            connectors["inputs"].append(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):
        # 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):
            return self.Output
        # Test action connector
        if self.Action and self.Action.TestPoint(pt, direction, exclude):
            return self.Action
        return None

    # Changes the step name
    def SetName(self, name):
        self.Name = name
        self.RefreshNameSize()

    # Returns the step name
    def GetName(self):
        return self.Name

    # Returns the step initial property
    def GetInitial(self):
        return self.Initial
    
    # Returns the connector connected to input
    def GetPreviousConnector(self):
        if self.Input:
            wires = self.Input.GetWires()
            if len(wires) == 1:
                return wires[0][0].GetOtherConnected(self.Input)
        return None
    
    # Returns the connector connected to output
    def GetNextConnector(self):
        if self.Output:
            wires = self.Output.GetWires()
            if len(wires) == 1:
                return wires[0][0].GetOtherConnected(self.Output)
        return None
    
    # Returns the connector connected to action
    def GetActionConnected(self):
        if self.Action:
            wires = self.Action.GetWires()
            if len(wires) == 1:
                return wires[0][0].GetOtherConnected(self.Action)
        return None
    
    # Returns the number of action line
    def GetActionExtraLineNumber(self):
        if self.Action:
            wires = self.Action.GetWires()
            if len(wires) != 1:
                return 0
            action_block = wires[0][0].GetOtherConnected(self.Action).GetParentBlock()
            return max(0, action_block.GetLineNumber() - 1)
        return 0
    
    # Returns the step minimum size
    def GetMinSize(self):
        text_width, text_height = self.Parent.GetTextExtent(self.Name)
        if self.Initial:
            return text_width + 14, text_height + 14
        else:
            return text_width + 10, text_height + 10
    
    # Updates the step size
    def UpdateSize(self, width, height):
        diffx = self.Size.GetWidth() / 2 - width / 2
        diffy = height - self.Size.GetHeight()
        self.Move(diffx, 0)
        Graphic_Element.SetSize(self, width, height)
        if self.Parent.GetDrawingMode() == FREEDRAWING_MODE:
            self.RefreshConnected()
        else:
            self.RefreshOutputPosition((0, diffy))
    
    # Align input element with this step
    def RefreshInputPosition(self):
        if self.Input:
            current_pos = self.Input.GetPosition(False)
            input = self.GetPreviousConnector()
            if input:
                input_pos = input.GetPosition(False)
                diffx = current_pos.x - input_pos.x
                input_block = input.GetParentBlock()
                if isinstance(input_block, SFC_Divergence):
                    input_block.MoveConnector(input, diffx)
                else:
                    if isinstance(input_block, SFC_Step):
                        input_block.MoveActionBlock((diffx, 0))
                    input_block.Move(diffx, 0)
                    input_block.RefreshInputPosition()
    
    # Align output element with this step
    def RefreshOutputPosition(self, move = None):
        if self.Output:
            wires = self.Output.GetWires()
            if len(wires) != 1:
                return
            current_pos = self.Output.GetPosition(False)
            output = wires[0][0].GetOtherConnected(self.Output)
            output_pos = output.GetPosition(False)
            diffx = current_pos.x - output_pos.x
            output_block = output.GetParentBlock()
            wire_size = SFC_WIRE_MIN_SIZE + self.GetActionExtraLineNumber() * SFC_ACTION_MIN_SIZE[1]
            diffy = wire_size - output_pos.y + current_pos.y
            if diffy != 0:
                if isinstance(output_block, SFC_Step):
                    output_block.MoveActionBlock((diffx, diffy))
                wires[0][0].SetPoints([wx.Point(current_pos.x, current_pos.y + wire_size),
                    wx.Point(current_pos.x, current_pos.y)])
                if not isinstance(output_block, SFC_Divergence) or output_block.GetConnectors()["inputs"].index(output) == 0:
                    output_block.Move(diffx, diffy, self.Parent.Wires)
                    output_block.RefreshOutputPosition((diffx, diffy))
                else:
                    output_block.RefreshPosition()
            elif move:
                if isinstance(output_block, SFC_Step):
                    output_block.MoveActionBlock(move)
                wires[0][0].Move(move[0], move[1], True)
                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)
                else:
                    output_block.RefreshPosition()
            elif isinstance(output_block, SFC_Divergence):
                output_block.MoveConnector(output, diffx)
            else:
                if isinstance(output_block, SFC_Step):
                    output_block.MoveActionBlock((diffx, 0))
                output_block.Move(diffx, 0)
                output_block.RefreshOutputPosition()
    
    # Refresh action element with this step
    def MoveActionBlock(self, move):
        if self.Action:
            wires = self.Action.GetWires()
            if len(wires) != 1:
                return
            action_block = wires[0][0].GetOtherConnected(self.Action).GetParentBlock()
            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):
        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, dc, scaling):
        # Edit the step properties
        self.Parent.EditStepContent(self)
    
    # Method called when a RightUp event have been generated
    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, event, scaling):
        handle_type, handle = self.Handle
        if handle_type == HANDLE_MOVE:
            movex = max(-self.BoundingBox.x, movex)
            movey = max(-self.BoundingBox.y, movey)
            if scaling is not None:
                movex = round(float(self.Pos.x + movex) / float(scaling[0])) * scaling[0] - self.Pos.x
                movey = round(float(self.Pos.y + movey) / float(scaling[1])) * scaling[1] - self.Pos.y
            action_block = None
            if self.Parent.GetDrawingMode() == FREEDRAWING_MODE:
                self.Move(movex, movey)
                self.RefreshConnected()
                return movex, movey
            elif self.Initial:
                self.MoveActionBlock((movex, movey))
                self.Move(movex, movey, self.Parent.Wires)
                self.RefreshOutputPosition((movex, movey))
                return movex, movey
            else:
                self.MoveActionBlock((movex, 0))
                self.Move(movex, 0)
                self.RefreshInputPosition()
                self.RefreshOutputPosition()
                return movex, 0
        else:
            return Graphic_Element.ProcessDragging(self, movex, movey, event, scaling)
    
    # Refresh input element model
    def RefreshInputModel(self):
        if self.Input:
            input = self.GetPreviousConnector()
            if input:                
                input_block = input.GetParentBlock()
                input_block.RefreshModel(False)
                if not isinstance(input_block, SFC_Divergence):
                    input_block.RefreshInputModel()
    
    # Refresh output element model
    def RefreshOutputModel(self, move=False):
        if self.Output:
            output = self.GetNextConnector()
            if output:
                output_block = output.GetParentBlock()
                output_block.RefreshModel(False)
                if not isinstance(output_block, SFC_Divergence) or move:
                    output_block.RefreshOutputModel(move)
    
    # Refreshes the step model
    def RefreshModel(self, move=True):
        self.Parent.RefreshStepModel(self)
        if self.Action:
            action = self.GetActionConnected()
            if action:
                action_block = action.GetParentBlock()
                action_block.RefreshModel(False)
        # If step has moved, refresh the model of wires connected to output
        if move:
            if self.Parent.GetDrawingMode() != FREEDRAWING_MODE:
                self.RefreshInputModel()
                self.RefreshOutputModel(self.Initial)
            elif self.Output:
                self.Output.RefreshWires()
    
    # Adds an highlight to the connection
    def AddHighlight(self, infos, start, end, highlight_type):
        if infos[0] == "name" and start[0] == 0 and end[0] == 0:
            AddHighlight(self.Highlights, (start, end, highlight_type))
    
    # Removes an highlight from the connection
    def RemoveHighlight(self, infos, start, end, highlight_type):
        if infos[0] == "name":
            RemoveHighlight(self.Highlights, (start, end, highlight_type))
    
    # Removes all the highlights of one particular type from the connection
    def ClearHighlight(self, highlight_type=None):
        ClearHighlights(self.Highlights, highlight_type)
    
    # Draws step
    def Draw(self, dc):
        Graphic_Element.Draw(self, dc)
        if self.Value:
            if self.Forced:
                dc.SetPen(MiterPen(wx.CYAN))
            else:
                dc.SetPen(MiterPen(wx.GREEN))
        elif self.Forced:
            dc.SetPen(MiterPen(wx.BLUE))
        else:
            dc.SetPen(MiterPen(wx.BLACK))
        dc.SetBrush(wx.WHITE_BRUSH)
        
        if getattr(dc, "printing", False):
            name_size = dc.GetTextExtent(self.Name)
        else:
            name_size = self.NameSize
        
        # Draw two rectangles for representing the step
        dc.DrawRectangle(self.Pos.x, self.Pos.y, self.Size[0] + 1, self.Size[1] + 1)
        if self.Initial:
            dc.DrawRectangle(self.Pos.x + 2, self.Pos.y + 2, self.Size[0] - 3, self.Size[1] - 3)
        # Draw step name
        name_pos = (self.Pos.x + (self.Size[0] - name_size[0]) / 2,
                    self.Pos.y + (self.Size[1] - name_size[1]) / 2)
        dc.DrawText(self.Name, name_pos[0], name_pos[1])
        # Draw input and output connectors
        if self.Input:
            self.Input.Draw(dc)
        if self.Output:
            self.Output.Draw(dc)
        if self.Action:
            self.Action.Draw(dc)
        
        if not getattr(dc, "printing", False):
            DrawHighlightedText(dc, self.Name, self.Highlights, name_pos[0], name_pos[1])
        

#-------------------------------------------------------------------------------
#                       Sequencial Function Chart Transition
#-------------------------------------------------------------------------------

"""
Class that implements the graphic representation of a transition
"""

class SFC_Transition(Graphic_Element, DebugDataConsumer):
    
    # Create a new transition
    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.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
    
    def Flush(self):
        if self.Input is not None:
            self.Input.Flush()
            self.Input = None
        if self.Output is not None:
            self.Output.Flush()
            self.Output = None
        if self.Type == "connection" and self.Condition is not None:
            self.Condition.Flush()
            self.Condition = None
    
    def SetForced(self, forced):
        if self.Forced != forced:
            self.Forced = forced
            if self.Visible:
                self.Parent.ElementNeedRefresh(self)
        
    def SetValue(self, value):
        self.PreviousValue = self.Value
        self.Value = value
        if self.Value != self.PreviousValue:
            if self.Visible:
                self.Parent.ElementNeedRefresh(self)
            self.SpreadCurrent()
    
    def SpreadCurrent(self):
        if self.Parent.Debug:
            if self.Value is None:
                self.Value = False
            spreading = self.Input.ReceivingCurrent() & self.Value
            if spreading and not self.PreviousSpreading:
                self.Output.SpreadCurrent(True)
            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):
        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:
            transition.SetPosition(self.Pos.x, self.Pos.y)
        transition.Input = self.Input.Clone(transition)
        transition.Output = self.Output.Clone(transition)
        if self.Type == "connection":
            transition.Condition = self.Condition.Clone(transition)
        return transition
    
    def GetConnectorTranslation(self, element):
        connectors = {self.Input : element.Input, self.Output : element.Output}
        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):
        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))
        if movex != 0 or movey != 0:
            if self.Input.IsConnected():
                rect = rect.Union(self.Input.GetConnectedRedrawRect(movex, movey))
            if self.Output.IsConnected():
                rect = rect.Union(self.Output.GetConnectedRedrawRect(movex, movey))
            if self.Type == "connection" and self.Condition.IsConnected():
                rect = rect.Union(self.Condition.GetConnectedRedrawRect(movex, movey))
        return rect
    
    # Forbids to change the transition size
    def SetSize(self, width, height):
        if self.Parent.GetDrawingMode() == FREEDRAWING_MODE:
            Graphic_Element.SetSize(self, width, height)
    
    # Forbids to resize the transition
    def Resize(self, x, y, width, height):
        if self.Parent.GetDrawingMode() == FREEDRAWING_MODE:
            Graphic_Element.Resize(self, x, y, width, height)
    
    # Refresh the size of text for name
    def RefreshConditionSize(self):
        if self.Type != "connection":
            if self.Condition != "":
                self.ConditionSize = self.Parent.GetTextExtent(self.Condition)
            else:
                self.ConditionSize = self.Parent.GetTextExtent("Transition")
    
    # Refresh the size of text for name
    def RefreshPrioritySize(self):
        if self.Priority != "":
            self.PrioritySize = self.Parent.GetTextExtent(str(self.Priority))
        else:
            self.PrioritySize = None

    # Delete this transition by calling the appropriate method
    def Delete(self):
        self.Parent.DeleteTransition(self)
    
    # Unconnect input and output
    def Clean(self):
        self.Input.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)
    
    # 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
            text_width, text_height = self.ConditionSize
            text_bbx = wx.Rect(self.Pos.x + self.Size[0] + 5,
                               self.Pos.y + (self.Size[1] - text_height) / 2,
                               text_width,
                               text_height)
            test_text = text_bbx.InsideXY(pt.x, pt.y)
        else:
            test_text = False
        return test_text or Graphic_Element.HitTest(self, pt, connectors)
    
    # Refresh the transition bounding box
    def RefreshBoundingBox(self):
        bbx_x, bbx_y, bbx_width, bbx_height = self.Pos.x, self.Pos.y, self.Size[0], self.Size[1]
        if self.Priority != 0:
            bbx_y = self.Pos.y - self.PrioritySize[1] - 2
            bbx_width = max(self.Size[0], self.PrioritySize[0])
            bbx_height = self.Size[1] + self.PrioritySize[1] + 2
        if self.Type == "connection":
            bbx_x = self.Pos.x - CONNECTOR_SIZE
            bbx_width = bbx_width + CONNECTOR_SIZE
        else:
            text_width, text_height = self.ConditionSize
            # Calculate the bounding box size
            bbx_width = max(bbx_width, self.Size[0] + 5 + text_width)
            bbx_y = min(bbx_y, self.Pos.y - max(0, (text_height - self.Size[1]) / 2))
            bbx_height = max(bbx_height, self.Pos.y - bbx_y + (self.Size[1] + text_height) / 2)
        self.BoundingBox = wx.Rect(bbx_x, bbx_y, bbx_width + 1, bbx_height + 1)
        
    # Returns the connector connected to input
    def GetPreviousConnector(self):
        wires = self.Input.GetWires()
        if len(wires) == 1:
            return wires[0][0].GetOtherConnected(self.Input)
        return None
    
    # Returns the connector connected to output
    def GetNextConnector(self):
        wires = self.Output.GetWires()
        if len(wires) == 1:
            return wires[0][0].GetOtherConnected(self.Output)
        return None
    
    # Refresh the positions of the transition connectors
    def RefreshConnectors(self):
        scaling = self.Parent.GetScaling()
        horizontal_pos = self.Size[0] / 2
        vertical_pos = self.Size[1] / 2
        if scaling is not None:
            horizontal_pos = round(float(self.Pos.x + horizontal_pos) / float(scaling[0])) * scaling[0] - self.Pos.x
            vertical_pos = round(float(self.Pos.y + vertical_pos) / float(scaling[1])) * scaling[1] - self.Pos.y
        # Update input position
        self.Input.SetPosition(wx.Point(horizontal_pos, 0))
        # Update output position
        self.Output.SetPosition(wx.Point(horizontal_pos, self.Size[1]))
        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 = []):
        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):
        # if a name is given
        if name is not None:
            # Test input and output connector
            #if name == self.Input.GetName():
            #    return self.Input
            if name == self.Output.GetName():
                return self.Output
            if self.Type == "connection" and name == self.Condition.GetName():
                return self.Condition
        connectors = [self.Input, self.Output]
        if self.Type == "connection":
            connectors.append(self.Condition)
        return self.FindNearestConnector(position, connectors)
    
    # Returns the transition condition connector
    def GetConditionConnector(self):
        if self.Type == "connection":
            return self.Condition
        return None
        
    # 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):
        # Test input connector
        if self.Input.TestPoint(pt, direction, exclude):
            return self.Input
        # Test output connector
        if self.Output.TestPoint(pt, direction, exclude):
            return self.Output
        # Test condition connector
        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):
        if self.Type != type:
            if self.Type == "connection":
               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 == None:
                    condition = ""
                self.Condition = condition
                self.RefreshConditionSize()
        elif self.Type != "connection":
            if condition == None:
                condition = ""
            self.Condition = condition
            self.RefreshConditionSize()
        self.RefreshBoundingBox()
        
    # Returns the transition type
    def GetType(self):
        return self.Type

    # Changes the transition priority
    def SetPriority(self, priority):
        self.Priority = priority
        self.RefreshPrioritySize()
        self.RefreshBoundingBox()
        
    # Returns the transition type
    def GetPriority(self):
        return self.Priority

    # Returns the transition condition
    def GetCondition(self):
        if self.Type != "connection":
            return self.Condition
        return None
        
    # Returns the transition minimum size
    def GetMinSize(self):
        return SFC_TRANSITION_SIZE
    
    # Align input element with this step
    def RefreshInputPosition(self):
        wires = self.Input.GetWires()
        current_pos = self.Input.GetPosition(False)
        input = self.GetPreviousConnector()
        if input:
            input_pos = input.GetPosition(False)
            diffx = current_pos.x - input_pos.x
            input_block = input.GetParentBlock()
            if isinstance(input_block, SFC_Divergence):
                input_block.MoveConnector(input, diffx)
            else:
                if isinstance(input_block, SFC_Step):
                    input_block.MoveActionBlock((diffx, 0))
                input_block.Move(diffx, 0)
                input_block.RefreshInputPosition()
    
    # Align output element with this step
    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)
        output_pos = output.GetPosition(False)
        diffx = current_pos.x - output_pos.x
        output_block = output.GetParentBlock()
        if move:
            if isinstance(output_block, SFC_Step):
                output_block.MoveActionBlock(move)
            wires[0][0].Move(move[0], move[1], True)
            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)
            else:
                output_block.RefreshPosition()
        elif isinstance(output_block, SFC_Divergence):
            output_block.MoveConnector(output, diffx)
        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, dc, scaling):
        # Edit the transition properties
        self.Parent.EditTransitionContent(self)
    
    # Method called when a RightUp event have been generated
    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, event, scaling):
        if self.Parent.GetDrawingMode() != FREEDRAWING_MODE:
            movex = max(-self.BoundingBox.x, movex)
            if scaling is not None:
                movex = round(float(self.Pos.x + movex) / float(scaling[0])) * scaling[0] - self.Pos.x
            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)
    
    # Refresh input element model
    def RefreshInputModel(self):
        if self.Parent.GetDrawingMode() != FREEDRAWING_MODE:
            input = self.GetPreviousConnector()
            if input:
                input_block = input.GetParentBlock()
                input_block.RefreshModel(False)
                if not isinstance(input_block, SFC_Divergence):
                    input_block.RefreshInputModel()
    
    # Refresh output element model
    def RefreshOutputModel(self, move=False):
        output = self.GetNextConnector()
        if output:
            output_block = output.GetParentBlock()
            output_block.RefreshModel(False)
            if not isinstance(output_block, SFC_Divergence) or move:
                output_block.RefreshOutputModel(move)
    
    # 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:
            if self.Parent.GetDrawingMode() != FREEDRAWING_MODE:
                self.RefreshInputModel()
                self.RefreshOutputModel()
            else:
                self.Output.RefreshWires()
    
    # Adds an highlight to the block
    def AddHighlight(self, infos, start, end ,highlight_type):
        if infos[0] in ["reference", "inline", "priority"] and start[0] == 0 and end[0] == 0:
            highlights = self.Highlights.setdefault(infos[0], [])
            AddHighlight(highlights, (start, end, highlight_type))
    
    # Removes an highlight from the block
    def RemoveHighlight(self, infos, start, end, highlight_type):
        if infos[0] in ["reference", "inline", "priority"]:
            highlights = self.Highlights.get(infos[0], [])
            if RemoveHighlight(highlights, (start, end, highlight_type)) and len(highlights) == 0:
                self.Highlights.pop(infos[0])
            
    # Removes all the highlights of one particular type from the block
    def ClearHighlight(self, highlight_type=None):
        if highlight_type is None:
            self.Highlights = {}
        else:
            highlight_items = self.Highlights.items()
            for name, highlights in highlight_items:
                highlights = ClearHighlights(highlight, highlight_type)
                if len(highlights) == 0:
                    self.Highlights.pop(name)
    
    # Draws transition
    def Draw(self, dc):
        Graphic_Element.Draw(self, dc)
        if self.Value:
            if self.Forced:
                dc.SetPen(MiterPen(wx.CYAN))
                dc.SetBrush(wx.CYAN_BRUSH)
            else:
                dc.SetPen(MiterPen(wx.GREEN))
                dc.SetBrush(wx.GREEN_BRUSH)
        elif self.Forced:
            dc.SetPen(MiterPen(wx.BLUE))
            dc.SetBrush(wx.BLUE_BRUSH)
        else:
            dc.SetPen(MiterPen(wx.BLACK))
            dc.SetBrush(wx.BLACK_BRUSH)
        
        if getattr(dc, "printing", False):
            if self.Type != "connection":
                condition_size = dc.GetTextExtent(self.Condition)
            if self.Priority != 0:
                priority_size = dc.GetTextExtent(str(self.Priority))
        else:
            if self.Type != "connection":
                condition_size = self.ConditionSize
            if self.Priority != 0:
                priority_size = self.PrioritySize
        
        # Draw plain rectangle for representing the transition
        dc.DrawRectangle(self.Pos.x, 
                         self.Pos.y + (self.Size[1] - SFC_TRANSITION_SIZE[1])/2, 
                         self.Size[0] + 1,
                         SFC_TRANSITION_SIZE[1] + 1)
        vertical_line_x = self.Input.GetPosition()[0]
        dc.DrawLine(vertical_line_x, self.Pos.y, vertical_line_x, self.Pos.y + self.Size[1] + 1) 
        # Draw transition condition
        if self.Type != "connection":
            if self.Condition != "":
                condition = self.Condition
            else:
                condition = "Transition"
            condition_pos = (self.Pos.x + self.Size[0] + 5,
                             self.Pos.y + (self.Size[1] - condition_size[1]) / 2)
            dc.DrawText(condition, condition_pos[0], condition_pos[1])
        # Draw priority number
        if self.Priority != 0:
            priority_pos = (self.Pos.x, self.Pos.y - priority_size[1] - 2)
            dc.DrawText(str(self.Priority), priority_pos[0], priority_pos[1])
        # Draw input and output connectors
        self.Input.Draw(dc)
        self.Output.Draw(dc)
        if self.Type == "connection":
            self.Condition.Draw(dc)
        
        if not getattr(dc, "printing", False):
            for name, highlights in self.Highlights.iteritems():
                if name == "priority":
                    DrawHighlightedText(dc, str(self.Priority), highlights, priority_pos[0], priority_pos[1])
                else:
                    DrawHighlightedText(dc, condition, highlights, condition_pos[0], condition_pos[1])

#-------------------------------------------------------------------------------
#                Sequencial Function Chart Divergence and Convergence
#-------------------------------------------------------------------------------

"""
Class that implements the graphic representation of a divergence or convergence,
selection or simultaneous
"""

class SFC_Divergence(Graphic_Element):
    
    # Create a new divergence
    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.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))
        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.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:
            input.Flush()
        self.Inputs = []
        for output in self.Outputs:
            output.Flush()
        self.Outputs = []
    
    def SpreadCurrent(self):
        if self.Parent.Debug:
            self.PreviousValue = self.Value
            if self.Type == SELECTION_CONVERGENCE:
                self.Value = False
                for input in self.Inputs:
                    self.Value |= input.ReceivingCurrent()
            elif self.Type == SIMULTANEOUS_CONVERGENCE:
                self.Value = True
                for input in self.Inputs:
                    self.Value &= input.ReceivingCurrent()
            elif self.Type in [SELECTION_DIVERGENCE, SIMULTANEOUS_DIVERGENCE]:
                self.Value = self.Inputs[0].ReceivingCurrent()
            else:
                self.Value = False
            if self.Value and not self.PreviousValue:
                if self.Visible:
                    self.Parent.ElementNeedRefresh(self)
                for output in self.Outputs:
                    output.SpreadCurrent(True)
            elif not self.Value and self.PreviousValue:
                if self.Visible:
                    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):
        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:
            divergence.SetPosition(self.Pos.x, self.Pos.y)
        divergence.Inputs = [input.Clone(divergence) for input in self.Inputs]
        divergence.Outputs = [output.Clone(divergence) for output in self.Outputs]
        return divergence
    
    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):
        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))
            for output in self.Outputs:
                if output.IsConnected():
                    rect = rect.Union(output.GetConnectedRedrawRect(movex, movey))
        return rect
    
    # Forbids to resize the divergence
    def Resize(self, x, y, width, height):
        if self.Parent.GetDrawingMode() == FREEDRAWING_MODE:
            Graphic_Element.Resize(self, x, 0, width, self.GetMinSize()[1])
    
    # Delete this divergence by calling the appropriate method
    def Delete(self):
        self.Parent.DeleteDivergence(self)
    
    # Returns the divergence type
    def GetType(self):
        return self.Type
    
    # Unconnect input and output
    def Clean(self):
        for input in self.Inputs:
            input.UnConnect(delete = self.Parent.GetDrawingMode() == FREEDRAWING_MODE)
        for output in self.Outputs:
            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)
            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)
            self.Inputs.append(connector)
            self.MoveConnector(connector, SFC_DEFAULT_SEQUENCE_INTERVAL)
    
    # Remove a branch from the divergence
    def RemoveBranch(self, connector):
        if self.Type in [SELECTION_DIVERGENCE, SIMULTANEOUS_DIVERGENCE]:
            if connector in self.Outputs and len(self.Outputs) > 2:
                self.Outputs.remove(connector)
                self.MoveConnector(self.Outputs[0], 0)
        elif self.Type in [SELECTION_CONVERGENCE, SIMULTANEOUS_CONVERGENCE]:
            if connector in self.Inputs and len(self.Inputs) > 2:
                self.Inputs.remove(connector)
                self.MoveConnector(self.Inputs[0], 0)
    
    # Remove the handled branch from the divergence
    def RemoveHandledBranch(self):
        handle_type, handle = self.Handle
        if handle_type == HANDLE_CONNECTOR:
            handle.UnConnect(delete=True)
            self.RemoveBranch(handle)
            
    # Return the number of branches for the divergence
    def GetBranchNumber(self):
        if self.Type in [SELECTION_DIVERGENCE, SIMULTANEOUS_DIVERGENCE]:
            return len(self.Outputs)
        elif self.Type in [SELECTION_CONVERGENCE, SIMULTANEOUS_CONVERGENCE]:
            return len(self.Inputs)
    
    # Returns if the point given is in the bounding box
    def HitTest(self, pt, connectors=True):
        return self.BoundingBox.InsideXY(pt.x, pt.y) or self.TestConnector(pt, exclude=False) != None
    
    # Refresh the divergence bounding box
    def RefreshBoundingBox(self):
        if self.Type in [SELECTION_DIVERGENCE, SELECTION_CONVERGENCE]:
            self.BoundingBox = wx.Rect(self.Pos.x, self.Pos.y, 
                self.Size[0] + 1, self.Size[1] + 1)
        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 = []):
        for input in self.Inputs:
            input.MoveConnected(exclude)
        for output in self.Outputs:
            output.MoveConnected(exclude)
    
    # Moves the divergence connector given
    def MoveConnector(self, connector, movex):
        position = connector.GetRelPosition()
        connector.SetPosition(wx.Point(position.x + movex, position.y))
        minx = self.Size[0]
        maxx = 0
        for input in self.Inputs:
            input_pos = input.GetRelPosition()
            minx = min(minx, input_pos.x)
            maxx = max(maxx, input_pos.x)
        for output in self.Outputs:
            output_pos = output.GetRelPosition()
            minx = min(minx, output_pos.x)
            maxx = max(maxx, output_pos.x)
        if minx != 0:
            for input in self.Inputs:
                input_pos = input.GetRelPosition()
                input.SetPosition(wx.Point(input_pos.x - minx, input_pos.y))
            for output in self.Outputs:
                output_pos = output.GetRelPosition()
                output.SetPosition(wx.Point(output_pos.x - minx, output_pos.y))
        self.Inputs.sort(lambda x, y: cmp(x.Pos.x, y.Pos.x))
        self.Outputs.sort(lambda x, y: cmp(x.Pos.x, y.Pos.x))
        self.Pos.x += minx
        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):
        # 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():
            #        return input
            for output in self.Outputs:
                if name == output.GetName():
                    return output
        return self.FindNearestConnector(position, self.Inputs + self.Outputs)
    
    # 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):
        # Test input connector
        for input in self.Inputs:
            if input.TestPoint(pt, direction, exclude):
                return input
        # Test output connector
        for output in self.Outputs:
            if output.TestPoint(pt, direction, exclude):
                return output
        return None
    
    # Changes the divergence size
    def SetSize(self, width, height):
        height = self.GetMinSize()[1]
        for i, input in enumerate(self.Inputs):
            position = input.GetRelPosition()
            if self.RealConnectors:
                input.SetPosition(wx.Point(int(round(self.RealConnectors["Inputs"][i] * width)), 0))
            else:
                input.SetPosition(wx.Point(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(wx.Point(int(round(self.RealConnectors["Outputs"][i] * width)), height))
            else:
                output.SetPosition(wx.Point(int(round(float(position.x)*float(width)/float(self.Size[0]))), height))
            output.MoveConnected()
        self.Size = wx.Size(width, height)
        self.RefreshBoundingBox()
    
    # Returns the divergence minimum size
    def GetMinSize(self, default=False):
        width = 0
        if default:
            if self.Type in [SELECTION_DIVERGENCE, SIMULTANEOUS_DIVERGENCE]:
                width = (len(self.Outputs) - 1) * SFC_DEFAULT_SEQUENCE_INTERVAL
            elif self.Type in [SELECTION_CONVERGENCE, SIMULTANEOUS_CONVERGENCE]:
                width = (len(self.Inputs) - 1) * SFC_DEFAULT_SEQUENCE_INTERVAL
        if self.Type in [SELECTION_DIVERGENCE, SELECTION_CONVERGENCE]:
            return width, 1
        elif self.Type in [SIMULTANEOUS_DIVERGENCE, SIMULTANEOUS_CONVERGENCE]:
            return width, 3
        return 0, 0
    
    # Refresh the position of the block connected to connector
    def RefreshConnectedPosition(self, connector):
        wires = connector.GetWires()
        if len(wires) != 1:
            return
        current_pos = connector.GetPosition(False)
        next = wires[0][0].GetOtherConnected(connector)
        next_pos = next.GetPosition(False)
        diffx = current_pos.x - next_pos.x
        next_block = next.GetParentBlock()
        if isinstance(next_block, SFC_Divergence):
            next_block.MoveConnector(next, diffx)
        else:
            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 len(wires) != 1:
                return
            previous = wires[0][0].GetOtherConnected(input)
            previous_pos = previous.GetPosition(False)
            y = max(y, previous_pos.y + GetWireSize(previous.GetParentBlock()))
        diffy = y - self.Pos.y
        if diffy != 0:
            self.Move(0, diffy, self.Parent.Wires)
            self.RefreshOutputPosition((0, diffy))
        for input in self.Inputs:
            input.MoveConnected()
    
    # Align output element with this divergence
    def RefreshOutputPosition(self, move = None):
        if move:
            for output_connector in self.Outputs:
                wires = output_connector.GetWires()
                if len(wires) != 1:
                    return
                current_pos = output_connector.GetPosition(False)
                output = wires[0][0].GetOtherConnected(self.Output)
                output_pos = output.GetPosition(False)
                diffx = current_pos.x - output_pos.x
                output_block = output.GetParentBlock()
                if isinstance(output_block, SFC_Step):
                    output_block.MoveActionBlock(move)
                wires[0][0].Move(move[0], move[1], True)
                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, dc, scaling):
        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, dc, scaling)
    
    # Method called when a LeftUp event have been generated
    def OnLeftUp(self, event, dc, scaling):
        Graphic_Element.OnLeftUp(self, event, dc, scaling)
        self.RealConnectors = None
    
    # Method called when a RightDown event have been generated
    def OnRightDown(self, event, dc, scaling):
        pos = GetScaledEventPosition(event, dc, scaling)
        # Test if a connector have been handled
        connector = self.TestConnector(pos, exclude=False)
        if connector:
            self.Handle = (HANDLE_CONNECTOR, connector)
            wx.CallAfter(self.Parent.SetCurrentCursor, 1)
            self.Selected = False
            # Initializes the last position
            self.oldPos = GetScaledEventPosition(event, dc, scaling)
        else:
            Graphic_Element.OnRightDown(self, event, dc, scaling)
    
    # Method called when a RightUp event have been generated
    def OnRightUp(self, event, dc, scaling):
        pos = GetScaledEventPosition(event, dc, scaling)
        handle_type, handle = self.Handle
        if handle_type == HANDLE_CONNECTOR and self.Dragging and self.oldPos:
            wires = handle.GetWires()
            if len(wires) == 1:
                block = wires[0][0].GetOtherConnected(handle).GetParentBlock()
                block.RefreshModel(False)
                if not isinstance(block, SFC_Divergence):
                    if handle in self.Inputs:
                        block.RefreshInputModel()
                    else:
                        block.RefreshOutputModel()
            Graphic_Element.OnRightUp(self, event, dc, scaling)
        else:
            # Popup the menu with special items for a block and a connector if one is handled
            connector = self.TestConnector(pos, exclude=False)
            if connector:
                self.Handle = (HANDLE_CONNECTOR, connector)
                self.Parent.PopupDivergenceMenu(True)
            else:
                # Popup the divergence menu without delete branch
                self.Parent.PopupDivergenceMenu(False)
        
    # Refreshes the divergence state according to move defined and handle selected
    def ProcessDragging(self, movex, movey, event, scaling):
        handle_type, handle = self.Handle
        # A connector has been handled
        if handle_type == HANDLE_CONNECTOR:
            movex = max(-self.BoundingBox.x, movex)
            if scaling is not None:
                movex = round(float(self.Pos.x + movex) / float(scaling[0])) * scaling[0] - self.Pos.x
            self.MoveConnector(handle, movex)
            if self.Parent.GetDrawingMode() != FREEDRAWING_MODE:
                self.RefreshConnectedPosition(handle)
            return movex, 0
        elif self.Parent.GetDrawingMode() == FREEDRAWING_MODE:
            return Graphic_Element.ProcessDragging(self, movex, movey, event, scaling)
        return 0, 0
    
    # Refresh output element model
    def RefreshOutputModel(self, move=False):
        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].GetOtherConnected(output).GetParentBlock()
                output_block.RefreshModel(False)
                if not isinstance(output_block, SFC_Divergence) or move:
                    output_block.RefreshOutputModel(move)
    
    # 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:
            if self.Parent.GetDrawingMode() != FREEDRAWING_MODE:
                self.RefreshOutputModel()
            else:
                for output in self.Outputs:
                    output.RefreshWires()
    
    # Draws the highlightment of this element if it is highlighted
    def DrawHighlightment(self, dc):
        scalex, scaley = dc.GetUserScale()
        dc.SetUserScale(1, 1)
        dc.SetPen(MiterPen(HIGHLIGHTCOLOR))
        dc.SetBrush(wx.Brush(HIGHLIGHTCOLOR))
        dc.SetLogicalFunction(wx.AND)
        # Draw two rectangles for representing the contact
        posx = self.Pos.x
        width = self.Size[0]
        if self.Type in [SIMULTANEOUS_DIVERGENCE, SIMULTANEOUS_CONVERGENCE]:
            posx -= SFC_SIMULTANEOUS_SEQUENCE_EXTRA
            width += SFC_SIMULTANEOUS_SEQUENCE_EXTRA * 2
        dc.DrawRectangle(int(round((posx - 1) * scalex)) - 2, 
                         int(round((self.Pos.y - 1) * scaley)) - 2, 
                         int(round((width + 3) * scalex)) + 5, 
                         int(round((self.Size.height + 3) * scaley)) + 5)
        dc.SetLogicalFunction(wx.COPY)
        dc.SetUserScale(scalex, scaley)
        
    # Draws divergence
    def Draw(self, dc):
        Graphic_Element.Draw(self, dc)
        if self.Value:
            dc.SetPen(MiterPen(wx.GREEN))
            dc.SetBrush(wx.GREEN_BRUSH)
        else:
            dc.SetPen(MiterPen(wx.BLACK))
            dc.SetBrush(wx.BLACK_BRUSH)
        # Draw plain rectangle for representing the divergence
        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 + self.Size[1], 
                        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)
        

#-------------------------------------------------------------------------------
#                   Sequencial Function Chart Jump to Step
#-------------------------------------------------------------------------------

"""
Class that implements the graphic representation of a jump to step
"""

class SFC_Jump(Graphic_Element):
    
    # Create a new jump
    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.Value = None
        self.PreviousValue = None
        
    def Flush(self):
        if self.Input is not None:
            self.Input.Flush()
            self.Input = None
    
    def SpreadCurrent(self):
        if self.Parent.Debug:
            self.PreviousValue = self.Value
            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):
        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:
            jump.SetPosition(self.Pos.x, self.Pos.y)
        jump.Input = self.Input.Clone(jump)
        return jump
    
    def GetConnectorTranslation(self, element):
        return {self.Input : element.Input}
    
    # Returns the RedrawRect
    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():
                rect = rect.Union(self.Input.GetConnectedRedrawRect(movex, movey))
        return rect
    
    # Forbids to change the jump size
    def SetSize(self, width, height):
        if self.Parent.GetDrawingMode() == FREEDRAWING_MODE:
            Graphic_Element.SetSize(self, width, height)
    
    # Forbids to resize jump
    def Resize(self, x, y, width, height):
        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):
        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)
    
    # Returns if the point given is in the bounding box
    def HitTest(self, pt, connectors=True):
        # Calculate the bounding box of the condition outside the transition
        text_width, text_height = self.TargetSize
        text_bbx = wx.Rect(self.Pos.x + self.Size[0] + 2,
                           self.Pos.y + (self.Size[1] - text_height) / 2,
                           text_width,
                           text_height)
        return text_bbx.InsideXY(pt.x, pt.y) or Graphic_Element.HitTest(self, pt, connectors)
    
    # Refresh the jump bounding box
    def RefreshBoundingBox(self):
        text_width, text_height = self.Parent.GetTextExtent(self.Target)
        # Calculate the bounding box size
        bbx_width = self.Size[0] + 2 + text_width
        self.BoundingBox = wx.Rect(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):
        wires = self.Input.GetWires()
        if len(wires) == 1:
            return wires[0][0].GetOtherConnected(self.Input)
        return None
    
    # Refresh the element connectors position
    def RefreshConnectors(self):
        scaling = self.Parent.GetScaling()
        horizontal_pos = self.Size[0] / 2
        if scaling is not None:
            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 = []):
        if self.Input:
            self.Input.MoveConnected(exclude)
    
    # Returns input jump connector 
    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):
        # Test input connector
        if self.Input and self.Input.TestPoint(pt, direction, exclude):
            return self.Input
        return None
    
    # Changes the jump target
    def SetTarget(self, target):
        self.Target = target
        self.RefreshTargetSize()
        self.RefreshBoundingBox()
    
    # Returns the jump target
    def GetTarget(self):
        return self.Target
    
    # Returns the jump minimum size
    def GetMinSize(self):
        return SFC_JUMP_SIZE
    
    # Align input element with this jump
    def RefreshInputPosition(self):
        if self.Input:
            current_pos = self.Input.GetPosition(False)
            input = self.GetPreviousConnector()
            if input:
                input_pos = input.GetPosition(False)
                diffx = current_pos.x - input_pos.x
                input_block = input.GetParentBlock()
                if isinstance(input_block, SFC_Divergence):
                    input_block.MoveConnector(input, diffx)
                else:
                    if isinstance(input_block, SFC_Step):
                        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):
        pass
    
    # Method called when a LeftDClick event have been generated
    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, 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, event, scaling):
        if self.Parent.GetDrawingMode() != FREEDRAWING_MODE:
            movex = max(-self.BoundingBox.x, movex)
            if scaling is not None:
                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)
    
    # Refresh input element model
    def RefreshInputModel(self):
        if self.Parent.GetDrawingMode() != FREEDRAWING_MODE:
            input = self.GetPreviousConnector()
            if input:
                input_block = input.GetParentBlock()
                input_block.RefreshModel(False)
                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:
            if self.Parent.GetDrawingMode() != FREEDRAWING_MODE:
                self.RefreshInputModel()
    
    # Adds an highlight to the variable
    def AddHighlight(self, infos, start, end, highlight_type):
        if infos[0] == "target" and start[0] == 0 and end[0] == 0:
            AddHighlight(self.Highlights, (start, end, highlight_type))
    
    # Removes an highlight from the variable
    def RemoveHighlight(self, infos, start, end, highlight_type):
        if infos[0] == "target":
            RemoveHighlight(self.Highlights, (start, end, highlight_type))
    
    # Removes all the highlights of one particular type from the variable
    def ClearHighlight(self, highlight_type=None):
        ClearHighlights(self.Highlights, highlight_type)
    
    # Draws the highlightment of this element if it is highlighted
    def DrawHighlightment(self, dc):
        scalex, scaley = dc.GetUserScale()
        dc.SetUserScale(1, 1)
        dc.SetPen(MiterPen(HIGHLIGHTCOLOR))
        dc.SetBrush(wx.Brush(HIGHLIGHTCOLOR))
        dc.SetLogicalFunction(wx.AND)
        points = [wx.Point(int(round((self.Pos.x - 2) * scalex)) - 3, 
                           int(round((self.Pos.y - 2) * scaley)) - 2),
                  wx.Point(int(round((self.Pos.x + self.Size[0] + 2) * scalex)) + 4, 
                           int(round((self.Pos.y - 2) * scaley)) - 2),
                  wx.Point(int(round((self.Pos.x + self.Size[0] / 2) * scalex)), 
                           int(round((self.Pos.y + self.Size[1] + 3) * scaley)) + 4)]
        dc.DrawPolygon(points)
        dc.SetLogicalFunction(wx.COPY)
        dc.SetUserScale(scalex, scaley)
    
    # Draws divergence
    def Draw(self, dc):
        Graphic_Element.Draw(self, dc)
        if self.Value:
            dc.SetPen(MiterPen(wx.GREEN))
            dc.SetBrush(wx.GREEN_BRUSH)
        else:
            dc.SetPen(MiterPen(wx.BLACK))
            dc.SetBrush(wx.BLACK_BRUSH)
        
        if getattr(dc, "printing", False):
            target_size = dc.GetTextExtent(self.Target)
        else:
            target_size = self.TargetSize
        
        # Draw plain rectangle for representing the divergence
        dc.DrawLine(self.Pos.x + self.Size[0] / 2, self.Pos.y, self.Pos.x + self.Size[0] / 2, self.Pos.y + self.Size[1])
        points = [wx.Point(self.Pos.x, self.Pos.y),
                  wx.Point(self.Pos.x + self.Size[0] / 2, self.Pos.y + self.Size[1] / 3),
                  wx.Point(self.Pos.x + self.Size[0], self.Pos.y),
                  wx.Point(self.Pos.x + self.Size[0] / 2, self.Pos.y + self.Size[1])]
        dc.DrawPolygon(points)
        target_pos = (self.Pos.x + self.Size[0] + 2,
                      self.Pos.y + (self.Size[1] - target_size[1]) / 2)
        dc.DrawText(self.Target, target_pos[0], target_pos[1])
        # Draw input connector
        if self.Input:
            self.Input.Draw(dc)
            
        if not getattr(dc, "printing", False):
            DrawHighlightedText(dc, self.Target, self.Highlights, target_pos[0], target_pos[1])
        

#-------------------------------------------------------------------------------
#                   Sequencial Function Chart Action Block
#-------------------------------------------------------------------------------

"""
Class that implements the graphic representation of an action block
"""

class SFC_ActionBlock(Graphic_Element):
    
    # Create a new action block
    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.SetActions(actions)
        self.Value = None
        self.PreviousValue = None
    
    def Flush(self):
        if self.Input is not None:
            self.Input.Flush()
            self.Input = None
    
    def SpreadCurrent(self):
        if self.Parent.Debug:
            self.PreviousValue = self.Value
            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):
        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)
        else:
            action_block.SetPosition(self.Pos.x, self.Pos.y)
        action_block.Input = self.Input.Clone(action_block)
        return action_block
    
    def GetConnectorTranslation(self, element):
        return {self.Input : element.Input}
    
    # Returns the RedrawRect
    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():
                rect = rect.Union(self.Input.GetConnectedRedrawRect(movex, movey))
        return rect
    
    # Returns the number of action lines
    def GetLineNumber(self):
        return len(self.Actions)
    
    def GetLineSize(self):
        if len(self.Actions) > 0:
            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 self.Parent.GetDrawingMode() != FREEDRAWING_MODE:
            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)
    
    # Unconnect input and output
    def Clean(self):
        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 = []):
        self.Input.MoveConnected(exclude)
    
    # Returns input action block connector 
    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):
        # Test input connector
        if self.Input.TestPoint(pt, direction, exclude):
            return self.Input
        return None
    
    # Refresh the element connectors position
    def RefreshConnectors(self):
        scaling = self.Parent.GetScaling()
        vertical_pos = SFC_ACTION_MIN_SIZE[1] / 2
        if scaling is not None:
            vertical_pos = round(float(self.Pos.y + vertical_pos) / float(scaling[1])) * scaling[1] - self.Pos.y
        self.Input.SetPosition(wx.Point(0, vertical_pos))
        self.RefreshConnected()
    
    # Changes the action block actions
    def SetActions(self, actions):
        self.Actions = actions
        self.ColSize = [0, 0, 0]
        min_height = 0
        for action in self.Actions:
            width, height = self.Parent.GetTextExtent(
                action.qualifier if action.qualifier != "" else "N")
            self.ColSize[0] = max(self.ColSize[0], width + 10)
            row_height = height
            if action.duration != "":
                width, height = self.Parent.GetTextExtent(action.duration)
                row_height = max(row_height, height)
                self.ColSize[0] = max(self.ColSize[0], width + 10)
            width, height = self.Parent.GetTextExtent(action.value)
            row_height = max(row_height, height)
            self.ColSize[1] = max(self.ColSize[1], width + 10)
            if action.indicator != "":
                width, height = self.Parent.GetTextExtent(action.indicator)
                row_height = max(row_height, height)
                self.ColSize[2] = max(self.ColSize[2], width + 10)
            min_height += row_height + 5
        if self.Parent.GetDrawingMode() == FREEDRAWING_MODE:
            self.Size = wx.Size(self.ColSize[0] + self.ColSize[1] + self.ColSize[2], max(min_height, SFC_ACTION_MIN_SIZE[1], self.Size[1]))
            self.MinSize = max(self.ColSize[0] + self.ColSize[1] + self.ColSize[2],
                SFC_ACTION_MIN_SIZE[0]), max(SFC_ACTION_MIN_SIZE[1], min_height)
            self.RefreshBoundingBox()
        else:
            self.Size = wx.Size(max(self.ColSize[0] + self.ColSize[1] + self.ColSize[2],
                SFC_ACTION_MIN_SIZE[0]), len(self.Actions) * SFC_ACTION_MIN_SIZE[1])
            self.MinSize = 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 is not None:
                wires = self.Input.GetWires()
                if len(wires) == 1:
                    input_block = wires[0][0].GetOtherConnected(self.Input).GetParentBlock()
                    input_block.RefreshOutputPosition()
                    input_block.RefreshOutputModel(True)
    
    # Returns the action block actions
    def GetActions(self):
        return self.Actions
    
    # Returns the action block minimum size
    def GetMinSize(self):
        return self.MinSize
    
    # Method called when a LeftDClick event have been generated
    def OnLeftDClick(self, event, dc, scaling):
        # Edit the action block properties
        self.Parent.EditActionBlockContent(self)
    
    # Method called when a RightUp event have been generated
    def OnRightUp(self, event, dc, scaling):
        # Popup the default menu
        self.Parent.PopupDefaultMenu()
    
    # Refreshes the action block state according to move defined and handle selected
    def ProcessDragging(self, movex, movey, event, scaling):
        if self.Parent.GetDrawingMode() != FREEDRAWING_MODE:
            handle_type, handle = self.Handle
            if handle_type == HANDLE_MOVE:
                movex = max(-self.BoundingBox.x, movex)
                if scaling is not None:
                    movex = round(float(self.Pos.x + movex) / float(scaling[0])) * scaling[0] - self.Pos.x
                wires = self.Input.GetWires()
                if len(wires) == 1:
                    input_pos = wires[0][0].GetOtherConnected(self.Input).GetPosition(False)
                    if self.Pos.x - input_pos.x + movex >= SFC_WIRE_MIN_SIZE:
                        self.Move(movex, 0)
                        return movex, 0
                return 0, 0
            else:
                return Graphic_Element.ProcessDragging(self, movex, movey, event, scaling)
        else:
            return Graphic_Element.ProcessDragging(self, movex, movey, event, scaling)

    
    # Refreshes the action block model
    def RefreshModel(self, move=True):
        self.Parent.RefreshActionBlockModel(self)
    
    # Adds an highlight to the variable
    def AddHighlight(self, infos, start, end, highlight_type):
        if infos[0] == "action" and infos[1] < len(self.Actions):
            action_highlights = self.Highlights.setdefault(infos[1], {})
            attribute_highlights = action_highlights.setdefault(infos[2], [])
            AddHighlight(attribute_highlights, (start, end, highlight_type))
    
    # Removes an highlight from the block
    def RemoveHighlight(self, infos, start, end, highlight_type):
        if infos[0] == "action" and infos[1] < len(self.Actions):
            action_highlights = self.Highlights.get(infos[1], {})
            attribute_highlights = action_highlights.setdefault(infos[2], [])
            if RemoveHighlight(attribute_highlights, (start, end, highlight_type)) and len(attribute_highlights) == 0:
                action_highlights.pop(infos[2])
                if len(action_highlights) == 0:
                    self.Highlights.pop(infos[1])
    
    # Removes all the highlights of one particular type from the block
    def ClearHighlight(self, highlight_type=None):
        if highlight_type is None:
            self.Highlights = {}
        else:
            highlight_items = self.Highlights.items()
            for number, action_highlights in highlight_items:
                action_highlight_items = action_highlights.items()
                for name, attribute_highlights in action_highlights:
                    attribute_highlights = ClearHighlights(attribute_highlights, highlight_type)
                    if len(attribute_highlights) == 0:
                        action_highlights.pop(name)
                if len(action_highlights) == 0:
                    self.Highlights.pop(number)
    
    # Draws divergence
    def Draw(self, dc):
        Graphic_Element.Draw(self, dc)
        if self.Value:
            dc.SetPen(MiterPen(wx.GREEN))
        else:
            dc.SetPen(MiterPen(wx.BLACK))
        dc.SetBrush(wx.WHITE_BRUSH)
        colsize = [self.ColSize[0], self.Size[0] - self.ColSize[0] - self.ColSize[2], self.ColSize[2]]
        # Draw plain rectangle for representing the action block
        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 * line_size, 
                    self.Pos.x + self.Size[0], self.Pos.y + i * line_size)
            qualifier_size = dc.GetTextExtent(action.qualifier)
            if action.duration != "":
                qualifier_pos = (self.Pos.x + (colsize[0] - qualifier_size[0]) / 2,
                                 self.Pos.y + i * line_size + line_size / 2 - qualifier_size[1])
                duration_size = dc.GetTextExtent(action.duration)
                duration_pos = (self.Pos.x + (colsize[0] - duration_size[0]) / 2,
                                self.Pos.y + i * line_size + line_size / 2)
                dc.DrawText(action.duration, duration_pos[0], duration_pos[1])
            else:
                qualifier_pos = (self.Pos.x + (colsize[0] - qualifier_size[0]) / 2,
                                 self.Pos.y + i * line_size + (line_size - qualifier_size[1]) / 2)
            dc.DrawText(action.qualifier, qualifier_pos[0], qualifier_pos[1])
            content_size = dc.GetTextExtent(action.value)
            content_pos = (self.Pos.x + colsize[0] + (colsize[1] - content_size[0]) / 2,
                           self.Pos.y + i * line_size + (line_size - content_size[1]) / 2)
            dc.DrawText(action.value, content_pos[0], content_pos[1])
            if action.indicator != "":
                indicator_size = dc.GetTextExtent(action.indicator)
                indicator_pos = (self.Pos.x + colsize[0] + colsize[1] + (colsize[2] - indicator_size[0]) / 2,
                                 self.Pos.y + i * line_size + (line_size - indicator_size[1]) / 2)
                dc.DrawText(action.indicator, indicator_pos[0], indicator_pos[1])
            
            if not getattr(dc, "printing", False):
                action_highlights = self.Highlights.get(i, {})
                for name, attribute_highlights in action_highlights.iteritems():
                    if name == "qualifier":
                        DrawHighlightedText(dc, action.qualifier, attribute_highlights, qualifier_pos[0], qualifier_pos[1])
                    elif name == "duration":
                        DrawHighlightedText(dc, action.duration, attribute_highlights, duration_pos[0], duration_pos[1])
                    elif name in ["reference", "inline"]:
                        DrawHighlightedText(dc, action.value, attribute_highlights, content_pos[0], content_pos[1])
                    elif name == "indicator":
                        DrawHighlightedText(dc, action.indicator, attribute_highlights, indicator_pos[0], indicator_pos[1])
        
        # Draw input connector
        self.Input.Draw(dc)