1 #!/usr/bin/env python

     2 # -*- coding: utf-8 -*-

     3 

     4 #This file is part of PLCOpenEditor, a library implementing an IEC 61131-3 editor

     5 #based on the plcopen standard. 

     6 #

     7 #Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD

     8 #

     9 #See COPYING file for copyrights details.

    10 #

    11 #This library is free software; you can redistribute it and/or

    12 #modify it under the terms of the GNU General Public

    13 #License as published by the Free Software Foundation; either

    14 #version 2.1 of the License, or (at your option) any later version.

    15 #

    16 #This library is distributed in the hope that it will be useful,

    17 #but WITHOUT ANY WARRANTY; without even the implied warranty of

    18 #MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    19 #General Public License for more details.

    20 #

    21 #You should have received a copy of the GNU General Public

    22 #License along with this library; if not, write to the Free Software

    23 #Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    24 

    25 import wx

    26 

    27 from GraphicCommons import *

    28 from plcopen.structures import *

    29 

    30 def GetWireSize(block):

    31     if isinstance(block, SFC_Step):

    32         return SFC_WIRE_MIN_SIZE + block.GetActionExtraLineNumber() * SFC_ACTION_MIN_SIZE[1]

    33     else:

    34         return SFC_WIRE_MIN_SIZE

    35 

    36 #-------------------------------------------------------------------------------

    37 #                         Sequencial Function Chart Step

    38 #-------------------------------------------------------------------------------

    39 

    40 """

    41 Class that implements the graphic representation of a step

    42 """

    43 

    44 class SFC_Step(Graphic_Element, DebugDataConsumer):

    45     

    46     # Create a new step

    47     def __init__(self, parent, name, initial = False, id = None):

    48         Graphic_Element.__init__(self, parent)

    49         DebugDataConsumer.__init__(self)

    50         self.SetName(name)

    51         self.Initial = initial

    52         self.Id = id

    53         self.Highlights = []

    54         self.Size = wx.Size(SFC_STEP_DEFAULT_SIZE[0], SFC_STEP_DEFAULT_SIZE[1])

    55         # Create an input and output connector

    56         if not self.Initial:

    57             self.Input = Connector(self, "", None, wx.Point(self.Size[0] / 2, 0), NORTH)

    58         else:

    59             self.Input = None

    60         self.Output = None

    61         self.Action = None

    62         self.PreviousValue = None

    63         self.PreviousSpreading = False

    64     

    65     def Flush(self):

    66         if self.Input is not None:

    67             self.Input.Flush()

    68             self.Input = None

    69         if self.Output is not None:

    70             self.Output.Flush()

    71             self.Output = None

    72         if self.Output is not None:

    73             self.Action.Flush()

    74             self.Action = None

    75     

    76     def SetForced(self, forced):

    77         if self.Forced != forced:

    78             self.Forced = forced

    79             if self.Visible:

    80                 self.Parent.ElementNeedRefresh(self)

    81     

    82     def SetValue(self, value):

    83         self.PreviousValue = self.Value

    84         self.Value = value

    85         if self.Value != self.PreviousValue:

    86             if self.Visible:

    87                 self.Parent.ElementNeedRefresh(self)

    88             self.SpreadCurrent()

    89     

    90     def SpreadCurrent(self):

    91         if self.Parent.Debug:

    92             spreading = self.Value

    93             if spreading and not self.PreviousSpreading:

    94                 if self.Output is not None:

    95                     self.Output.SpreadCurrent(True)

    96                 if self.Action is not None:

    97                     self.Action.SpreadCurrent(True)

    98             elif not spreading and self.PreviousSpreading:

    99                 if self.Output is not None:

   100                     self.Output.SpreadCurrent(False)

   101                 if self.Action is not None:

   102                     self.Action.SpreadCurrent(False)

   103             self.PreviousSpreading = spreading

   104     

   105     # Make a clone of this SFC_Step

   106     def Clone(self, parent, id = None, name = "Step", pos = None):

   107         step = SFC_Step(parent, name, self.Initial, id)

   108         step.SetSize(self.Size[0], self.Size[1])

   109         if pos is not None:

   110             step.SetPosition(pos.x, pos.y)

   111         else:

   112             step.SetPosition(self.Pos.x, self.Pos.y)

   113         if self.Input:

   114             step.Input = self.Input.Clone(step)

   115         if self.Output:

   116             step.Output = self.Output.Clone(step)

   117         if self.Action:

   118             step.Action = self.Action.Clone(step)

   119         return step

   120     

   121     def GetConnectorTranslation(self, element):

   122         connectors = {}

   123         if self.Input is not None:

   124             connectors[self.Input] = element.Input

   125         if self.Output is not None:

   126             connectors[self.Output] = element.Output

   127         if self.Action is not None:

   128             connectors[self.Action] = element.Action

   129         return connectors

   130     

   131     # Returns the RedrawRect

   132     def GetRedrawRect(self, movex = 0, movey = 0):

   133         rect = Graphic_Element.GetRedrawRect(self, movex, movey)

   134         if self.Input:

   135             rect = rect.Union(self.Input.GetRedrawRect(movex, movey))

   136         if self.Output:

   137             rect = rect.Union(self.Output.GetRedrawRect(movex, movey))

   138         if self.Action:

   139             rect = rect.Union(self.Action.GetRedrawRect(movex, movey))

   140         if movex != 0 or movey != 0:

   141             if self.Input and self.Input.IsConnected():

   142                 rect = rect.Union(self.Input.GetConnectedRedrawRect(movex, movey))

   143             if self.Output and self.Output.IsConnected():

   144                 rect = rect.Union(self.Output.GetConnectedRedrawRect(movex, movey))

   145             if self.Action and self.Action.IsConnected():

   146                 rect = rect.Union(self.Action.GetConnectedRedrawRect(movex, movey))

   147         return rect

   148     

   149     # Delete this step by calling the appropriate method

   150     def Delete(self):

   151         self.Parent.DeleteStep(self)

   152     

   153     # Unconnect input and output

   154     def Clean(self):

   155         if self.Input:

   156             self.Input.UnConnect(delete = self.Parent.GetDrawingMode() == FREEDRAWING_MODE)

   157         if self.Output:

   158             self.Output.UnConnect(delete = self.Parent.GetDrawingMode() == FREEDRAWING_MODE)

   159         if self.Action:

   160             self.Action.UnConnect(delete = self.Parent.GetDrawingMode() == FREEDRAWING_MODE)

   161     

   162     # Refresh the size of text for name

   163     def RefreshNameSize(self):

   164         self.NameSize = self.Parent.GetTextExtent(self.Name)

   165     

   166     # Add output connector to step

   167     def AddInput(self):

   168         if not self.Input:

   169             self.Input = Connector(self, "", None, wx.Point(self.Size[0] / 2, 0), NORTH)

   170             self.RefreshBoundingBox()

   171     

   172     # Remove output connector from step

   173     def RemoveInput(self):

   174         if self.Input:

   175             self.Input.UnConnect(delete = self.Parent.GetDrawingMode() == FREEDRAWING_MODE)

   176             self.Input = None

   177             self.RefreshBoundingBox()

   178     

   179     # Add output connector to step

   180     def AddOutput(self):

   181         if not self.Output:

   182             self.Output = Connector(self, "", None, wx.Point(self.Size[0] / 2, self.Size[1]), SOUTH, onlyone = True)

   183             self.RefreshBoundingBox()

   184     

   185     # Remove output connector from step

   186     def RemoveOutput(self):

   187         if self.Output:

   188             self.Output.UnConnect(delete = self.Parent.GetDrawingMode() == FREEDRAWING_MODE)

   189             self.Output = None

   190             self.RefreshBoundingBox()

   191     

   192     # Add action connector to step

   193     def AddAction(self):

   194         if not self.Action:

   195             self.Action = Connector(self, "", None, wx.Point(self.Size[0], self.Size[1] / 2), EAST, onlyone = True)

   196             self.RefreshBoundingBox()

   197     

   198     # Remove action connector from step

   199     def RemoveAction(self):

   200         if self.Action:

   201             self.Action.UnConnect(delete = self.Parent.GetDrawingMode() == FREEDRAWING_MODE)

   202             self.Action = None

   203             self.RefreshBoundingBox()

   204     

   205     # Refresh the step bounding box

   206     def RefreshBoundingBox(self):

   207         # Calculate the bounding box size

   208         if self.Action:

   209             bbx_width = self.Size[0] + CONNECTOR_SIZE

   210         else:

   211             bbx_width = self.Size[0]

   212         if self.Initial:

   213             bbx_y = self.Pos.y

   214             bbx_height = self.Size[1]

   215             if self.Output:

   216                 bbx_height += CONNECTOR_SIZE

   217         else:

   218             bbx_y = self.Pos.y - CONNECTOR_SIZE

   219             bbx_height = self.Size[1] + CONNECTOR_SIZE

   220             if self.Output:

   221                 bbx_height += CONNECTOR_SIZE

   222         #self.BoundingBox = wx.Rect(self.Pos.x, bbx_y, bbx_width + 1, bbx_height + 1)

   223         self.BoundingBox = wx.Rect(self.Pos.x, self.Pos.y, self.Size[0] + 1, self.Size[1] + 1)

   224         

   225     # Refresh the positions of the step connectors

   226     def RefreshConnectors(self):

   227         scaling = self.Parent.GetScaling()

   228         horizontal_pos = self.Size[0] / 2

   229         vertical_pos = self.Size[1] / 2

   230         if scaling is not None:

   231             horizontal_pos = round(float(self.Pos.x + horizontal_pos) / float(scaling[0])) * scaling[0] - self.Pos.x

   232             vertical_pos = round(float(self.Pos.y + vertical_pos) / float(scaling[1])) * scaling[1] - self.Pos.y

   233         # Update input position if it exists

   234         if self.Input:

   235             self.Input.SetPosition(wx.Point(horizontal_pos, 0))

   236         # Update output position

   237         if self.Output:

   238             self.Output.SetPosition(wx.Point(horizontal_pos, self.Size[1]))

   239         # Update action position if it exists

   240         if self.Action:

   241             self.Action.SetPosition(wx.Point(self.Size[0], vertical_pos))

   242         self.RefreshConnected()

   243     

   244     # Refresh the position of wires connected to step

   245     def RefreshConnected(self, exclude = []):

   246         if self.Input:

   247             self.Input.MoveConnected(exclude)

   248         if self.Output:

   249             self.Output.MoveConnected(exclude)

   250         if self.Action:

   251             self.Action.MoveConnected(exclude)

   252     

   253     # Returns the step connector that starts with the point given if it exists 

   254     def GetConnector(self, position, name = None):

   255         # if a name is given

   256         if name is not None:

   257             # Test input, output and action connector if they exists

   258             #if self.Input and name == self.Input.GetName():

   259             #    return self.Input

   260             if self.Output and name == self.Output.GetName():

   261                 return self.Output

   262             if self.Action and name == self.Action.GetName():

   263                 return self.Action

   264         connectors = []

   265         # Test input connector if it exists

   266         if self.Input:

   267             connectors.append(self.Input)

   268         # Test output connector if it exists

   269         if self.Output:

   270             connectors.append(self.Output)

   271         # Test action connector if it exists

   272         if self.Action:

   273             connectors.append(self.Action)

   274         return self.FindNearestConnector(position, connectors)

   275     

   276     # Returns action step connector 

   277     def GetActionConnector(self):

   278         return self.Action

   279         

   280     # Returns input and output step connectors 

   281     def GetConnectors(self):

   282         connectors = {"inputs": [], "outputs": []}

   283         if self.Input:

   284             connectors["inputs"].append(self.Input)

   285         if self.Output:

   286             connectors["outputs"].append(self.Output)

   287         return connectors

   288     

   289     # Test if point given is on step input or output connector

   290     def TestConnector(self, pt, direction = None, exclude=True):

   291         # Test input connector if it exists

   292         if self.Input and self.Input.TestPoint(pt, direction, exclude):

   293             return self.Input

   294         # Test output connector

   295         if self.Output and self.Output.TestPoint(pt, direction, exclude):

   296             return self.Output

   297         # Test action connector

   298         if self.Action and self.Action.TestPoint(pt, direction, exclude):

   299             return self.Action

   300         return None

   301 

   302     # Changes the step name

   303     def SetName(self, name):

   304         self.Name = name

   305         self.RefreshNameSize()

   306 

   307     # Returns the step name

   308     def GetName(self):

   309         return self.Name

   310 

   311     # Returns the step initial property

   312     def GetInitial(self):

   313         return self.Initial

   314     

   315     # Returns the connector connected to input

   316     def GetPreviousConnector(self):

   317         if self.Input:

   318             wires = self.Input.GetWires()

   319             if len(wires) == 1:

   320                 return wires[0][0].GetOtherConnected(self.Input)

   321         return None

   322     

   323     # Returns the connector connected to output

   324     def GetNextConnector(self):

   325         if self.Output:

   326             wires = self.Output.GetWires()

   327             if len(wires) == 1:

   328                 return wires[0][0].GetOtherConnected(self.Output)

   329         return None

   330     

   331     # Returns the connector connected to action

   332     def GetActionConnected(self):

   333         if self.Action:

   334             wires = self.Action.GetWires()

   335             if len(wires) == 1:

   336                 return wires[0][0].GetOtherConnected(self.Action)

   337         return None

   338     

   339     # Returns the number of action line

   340     def GetActionExtraLineNumber(self):

   341         if self.Action:

   342             wires = self.Action.GetWires()

   343             if len(wires) != 1:

   344                 return 0

   345             action_block = wires[0][0].GetOtherConnected(self.Action).GetParentBlock()

   346             return max(0, action_block.GetLineNumber() - 1)

   347         return 0

   348     

   349     # Returns the step minimum size

   350     def GetMinSize(self):

   351         text_width, text_height = self.Parent.GetTextExtent(self.Name)

   352         if self.Initial:

   353             return text_width + 14, text_height + 14

   354         else:

   355             return text_width + 10, text_height + 10

   356     

   357     # Updates the step size

   358     def UpdateSize(self, width, height):

   359         diffx = self.Size.GetWidth() / 2 - width / 2

   360         diffy = height - self.Size.GetHeight()

   361         self.Move(diffx, 0)

   362         Graphic_Element.SetSize(self, width, height)

   363         if self.Parent.GetDrawingMode() == FREEDRAWING_MODE:

   364             self.RefreshConnected()

   365         else:

   366             self.RefreshOutputPosition((0, diffy))

   367     

   368     # Align input element with this step

   369     def RefreshInputPosition(self):

   370         if self.Input:

   371             current_pos = self.Input.GetPosition(False)

   372             input = self.GetPreviousConnector()

   373             if input:

   374                 input_pos = input.GetPosition(False)

   375                 diffx = current_pos.x - input_pos.x

   376                 input_block = input.GetParentBlock()

   377                 if isinstance(input_block, SFC_Divergence):

   378                     input_block.MoveConnector(input, diffx)

   379                 else:

   380                     if isinstance(input_block, SFC_Step):

   381                         input_block.MoveActionBlock((diffx, 0))

   382                     input_block.Move(diffx, 0)

   383                     input_block.RefreshInputPosition()

   384     

   385     # Align output element with this step

   386     def RefreshOutputPosition(self, move = None):

   387         if self.Output:

   388             wires = self.Output.GetWires()

   389             if len(wires) != 1:

   390                 return

   391             current_pos = self.Output.GetPosition(False)

   392             output = wires[0][0].GetOtherConnected(self.Output)

   393             output_pos = output.GetPosition(False)

   394             diffx = current_pos.x - output_pos.x

   395             output_block = output.GetParentBlock()

   396             wire_size = SFC_WIRE_MIN_SIZE + self.GetActionExtraLineNumber() * SFC_ACTION_MIN_SIZE[1]

   397             diffy = wire_size - output_pos.y + current_pos.y

   398             if diffy != 0:

   399                 if isinstance(output_block, SFC_Step):

   400                     output_block.MoveActionBlock((diffx, diffy))

   401                 wires[0][0].SetPoints([wx.Point(current_pos.x, current_pos.y + wire_size),

   402                     wx.Point(current_pos.x, current_pos.y)])

   403                 if not isinstance(output_block, SFC_Divergence) or output_block.GetConnectors()["inputs"].index(output) == 0:

   404                     output_block.Move(diffx, diffy, self.Parent.Wires)

   405                     output_block.RefreshOutputPosition((diffx, diffy))

   406                 else:

   407                     output_block.RefreshPosition()

   408             elif move:

   409                 if isinstance(output_block, SFC_Step):

   410                     output_block.MoveActionBlock(move)

   411                 wires[0][0].Move(move[0], move[1], True)

   412                 if not isinstance(output_block, SFC_Divergence) or output_block.GetConnectors()["inputs"].index(output) == 0:

   413                     output_block.Move(move[0], move[1], self.Parent.Wires)

   414                     output_block.RefreshOutputPosition(move)

   415                 else:

   416                     output_block.RefreshPosition()

   417             elif isinstance(output_block, SFC_Divergence):

   418                 output_block.MoveConnector(output, diffx)

   419             else:

   420                 if isinstance(output_block, SFC_Step):

   421                     output_block.MoveActionBlock((diffx, 0))

   422                 output_block.Move(diffx, 0)

   423                 output_block.RefreshOutputPosition()

   424     

   425     # Refresh action element with this step

   426     def MoveActionBlock(self, move):

   427         if self.Action:

   428             wires = self.Action.GetWires()

   429             if len(wires) != 1:

   430                 return

   431             action_block = wires[0][0].GetOtherConnected(self.Action).GetParentBlock()

   432             action_block.Move(move[0], move[1], self.Parent.Wires)

   433             wires[0][0].Move(move[0], move[1], True)

   434     

   435     # Resize the divergence from position and size given

   436     def Resize(self, x, y, width, height):

   437         if self.Parent.GetDrawingMode() != FREEDRAWING_MODE:

   438             self.UpdateSize(width, height)

   439         else:

   440             Graphic_Element.Resize(self, x, y, width, height)

   441     

   442     # Method called when a LeftDClick event have been generated

   443     def OnLeftDClick(self, event, dc, scaling):

   444         # Edit the step properties

   445         self.Parent.EditStepContent(self)

   446     

   447     # Method called when a RightUp event have been generated

   448     def OnRightUp(self, event, dc, scaling):

   449         # Popup the menu with special items for a step

   450         self.Parent.PopupDefaultMenu()

   451     

   452     # Refreshes the step state according to move defined and handle selected

   453     def ProcessDragging(self, movex, movey, event, scaling):

   454         handle_type, handle = self.Handle

   455         if handle_type == HANDLE_MOVE:

   456             movex = max(-self.BoundingBox.x, movex)

   457             movey = max(-self.BoundingBox.y, movey)

   458             if scaling is not None:

   459                 movex = round(float(self.Pos.x + movex) / float(scaling[0])) * scaling[0] - self.Pos.x

   460                 movey = round(float(self.Pos.y + movey) / float(scaling[1])) * scaling[1] - self.Pos.y

   461             action_block = None

   462             if self.Parent.GetDrawingMode() == FREEDRAWING_MODE:

   463                 self.Move(movex, movey)

   464                 self.RefreshConnected()

   465                 return movex, movey

   466             elif self.Initial:

   467                 self.MoveActionBlock((movex, movey))

   468                 self.Move(movex, movey, self.Parent.Wires)

   469                 self.RefreshOutputPosition((movex, movey))

   470                 return movex, movey

   471             else:

   472                 self.MoveActionBlock((movex, 0))

   473                 self.Move(movex, 0)

   474                 self.RefreshInputPosition()

   475                 self.RefreshOutputPosition()

   476                 return movex, 0

   477         else:

   478             return Graphic_Element.ProcessDragging(self, movex, movey, event, scaling)

   479     

   480     # Refresh input element model

   481     def RefreshInputModel(self):

   482         if self.Input:

   483             input = self.GetPreviousConnector()

   484             if input:                

   485                 input_block = input.GetParentBlock()

   486                 input_block.RefreshModel(False)

   487                 if not isinstance(input_block, SFC_Divergence):

   488                     input_block.RefreshInputModel()

   489     

   490     # Refresh output element model

   491     def RefreshOutputModel(self, move=False):

   492         if self.Output:

   493             output = self.GetNextConnector()

   494             if output:

   495                 output_block = output.GetParentBlock()

   496                 output_block.RefreshModel(False)

   497                 if not isinstance(output_block, SFC_Divergence) or move:

   498                     output_block.RefreshOutputModel(move)

   499     

   500     # Refreshes the step model

   501     def RefreshModel(self, move=True):

   502         self.Parent.RefreshStepModel(self)

   503         if self.Action:

   504             action = self.GetActionConnected()

   505             if action:

   506                 action_block = action.GetParentBlock()

   507                 action_block.RefreshModel(False)

   508         # If step has moved, refresh the model of wires connected to output

   509         if move:

   510             if self.Parent.GetDrawingMode() != FREEDRAWING_MODE:

   511                 self.RefreshInputModel()

   512                 self.RefreshOutputModel(self.Initial)

   513             elif self.Output:

   514                 self.Output.RefreshWires()

   515     

   516     # Adds an highlight to the connection

   517     def AddHighlight(self, infos, start, end, highlight_type):

   518         if infos[0] == "name" and start[0] == 0 and end[0] == 0:

   519             AddHighlight(self.Highlights, (start, end, highlight_type))

   520     

   521     # Removes an highlight from the connection

   522     def RemoveHighlight(self, infos, start, end, highlight_type):

   523         if infos[0] == "name":

   524             RemoveHighlight(self.Highlights, (start, end, highlight_type))

   525     

   526     # Removes all the highlights of one particular type from the connection

   527     def ClearHighlight(self, highlight_type=None):

   528         ClearHighlights(self.Highlights, highlight_type)

   529     

   530     # Draws step

   531     def Draw(self, dc):

   532         Graphic_Element.Draw(self, dc)

   533         if self.Value:

   534             if self.Forced:

   535                 dc.SetPen(MiterPen(wx.CYAN))

   536             else:

   537                 dc.SetPen(MiterPen(wx.GREEN))

   538         elif self.Forced:

   539             dc.SetPen(MiterPen(wx.BLUE))

   540         else:

   541             dc.SetPen(MiterPen(wx.BLACK))

   542         dc.SetBrush(wx.WHITE_BRUSH)

   543         

   544         if getattr(dc, "printing", False):

   545             name_size = dc.GetTextExtent(self.Name)

   546         else:

   547             name_size = self.NameSize

   548         

   549         # Draw two rectangles for representing the step

   550         dc.DrawRectangle(self.Pos.x, self.Pos.y, self.Size[0] + 1, self.Size[1] + 1)

   551         if self.Initial:

   552             dc.DrawRectangle(self.Pos.x + 2, self.Pos.y + 2, self.Size[0] - 3, self.Size[1] - 3)

   553         # Draw step name

   554         name_pos = (self.Pos.x + (self.Size[0] - name_size[0]) / 2,

   555                     self.Pos.y + (self.Size[1] - name_size[1]) / 2)

   556         dc.DrawText(self.Name, name_pos[0], name_pos[1])

   557         # Draw input and output connectors

   558         if self.Input:

   559             self.Input.Draw(dc)

   560         if self.Output:

   561             self.Output.Draw(dc)

   562         if self.Action:

   563             self.Action.Draw(dc)

   564         

   565         if not getattr(dc, "printing", False):

   566             DrawHighlightedText(dc, self.Name, self.Highlights, name_pos[0], name_pos[1])

   567         

   568 

   569 #-------------------------------------------------------------------------------

   570 #                       Sequencial Function Chart Transition

   571 #-------------------------------------------------------------------------------

   572 

   573 """

   574 Class that implements the graphic representation of a transition

   575 """

   576 

   577 class SFC_Transition(Graphic_Element, DebugDataConsumer):

   578     

   579     # Create a new transition

   580     def __init__(self, parent, type = "reference", condition = None, priority = 0, id = None):

   581         Graphic_Element.__init__(self, parent)

   582         DebugDataConsumer.__init__(self)

   583         self.Type = None

   584         self.Id = id

   585         self.Priority = 0

   586         self.Size = wx.Size(SFC_TRANSITION_SIZE[0], SFC_TRANSITION_SIZE[1])

   587         # Create an input and output connector

   588         self.Input = Connector(self, "", None, wx.Point(self.Size[0] / 2, 0), NORTH, onlyone = True)

   589         self.Output = Connector(self, "", None, wx.Point(self.Size[0] / 2, self.Size[1]), SOUTH, onlyone = True)

   590         self.SetType(type, condition)

   591         self.SetPriority(priority)

   592         self.Highlights = {}

   593         self.PreviousValue = None

   594         self.PreviousSpreading = False

   595     

   596     def Flush(self):

   597         if self.Input is not None:

   598             self.Input.Flush()

   599             self.Input = None

   600         if self.Output is not None:

   601             self.Output.Flush()

   602             self.Output = None

   603         if self.Type == "connection" and self.Condition is not None:

   604             self.Condition.Flush()

   605             self.Condition = None

   606     

   607     def SetForced(self, forced):

   608         if self.Forced != forced:

   609             self.Forced = forced

   610             if self.Visible:

   611                 self.Parent.ElementNeedRefresh(self)

   612         

   613     def SetValue(self, value):

   614         self.PreviousValue = self.Value

   615         self.Value = value

   616         if self.Value != self.PreviousValue:

   617             if self.Visible:

   618                 self.Parent.ElementNeedRefresh(self)

   619             self.SpreadCurrent()

   620     

   621     def SpreadCurrent(self):

   622         if self.Parent.Debug:

   623             if self.Value is None:

   624                 self.Value = False

   625             spreading = self.Input.ReceivingCurrent() & self.Value

   626             if spreading and not self.PreviousSpreading:

   627                 self.Output.SpreadCurrent(True)

   628             elif not spreading and self.PreviousSpreading:

   629                 self.Output.SpreadCurrent(False)

   630             self.PreviousSpreading = spreading

   631     

   632     # Make a clone of this SFC_Transition

   633     def Clone(self, parent, id = None, pos = None):

   634         transition = SFC_Transition(parent, self.Type, self.Condition, self.Priority, id)

   635         transition.SetSize(self.Size[0], self.Size[1])

   636         if pos is not None:

   637             transition.SetPosition(pos.x, pos.y)

   638         else:

   639             transition.SetPosition(self.Pos.x, self.Pos.y)

   640         transition.Input = self.Input.Clone(transition)

   641         transition.Output = self.Output.Clone(transition)

   642         if self.Type == "connection":

   643             transition.Condition = self.Condition.Clone(transition)

   644         return transition

   645     

   646     def GetConnectorTranslation(self, element):

   647         connectors = {self.Input : element.Input, self.Output : element.Output}

   648         if self.Type == "connection" and self.Condition is not None:

   649             connectors[self.Condition] = element.Condition

   650         return connectors

   651     

   652     # Returns the RedrawRect

   653     def GetRedrawRect(self, movex = 0, movey = 0):

   654         rect = Graphic_Element.GetRedrawRect(self, movex, movey)

   655         rect = rect.Union(self.Input.GetRedrawRect(movex, movey))

   656         rect = rect.Union(self.Output.GetRedrawRect(movex, movey))

   657         if movex != 0 or movey != 0:

   658             if self.Input.IsConnected():

   659                 rect = rect.Union(self.Input.GetConnectedRedrawRect(movex, movey))

   660             if self.Output.IsConnected():

   661                 rect = rect.Union(self.Output.GetConnectedRedrawRect(movex, movey))

   662             if self.Type == "connection" and self.Condition.IsConnected():

   663                 rect = rect.Union(self.Condition.GetConnectedRedrawRect(movex, movey))

   664         return rect

   665     

   666     # Forbids to change the transition size

   667     def SetSize(self, width, height):

   668         if self.Parent.GetDrawingMode() == FREEDRAWING_MODE:

   669             Graphic_Element.SetSize(self, width, height)

   670     

   671     # Forbids to resize the transition

   672     def Resize(self, x, y, width, height):

   673         if self.Parent.GetDrawingMode() == FREEDRAWING_MODE:

   674             Graphic_Element.Resize(self, x, y, width, height)

   675     

   676     # Refresh the size of text for name

   677     def RefreshConditionSize(self):

   678         if self.Type != "connection":

   679             if self.Condition != "":

   680                 self.ConditionSize = self.Parent.GetTextExtent(self.Condition)

   681             else:

   682                 self.ConditionSize = self.Parent.GetTextExtent("Transition")

   683     

   684     # Refresh the size of text for name

   685     def RefreshPrioritySize(self):

   686         if self.Priority != "":

   687             self.PrioritySize = self.Parent.GetTextExtent(str(self.Priority))

   688         else:

   689             self.PrioritySize = None

   690 

   691     # Delete this transition by calling the appropriate method

   692     def Delete(self):

   693         self.Parent.DeleteTransition(self)

   694     

   695     # Unconnect input and output

   696     def Clean(self):

   697         self.Input.UnConnect(delete = self.Parent.GetDrawingMode() == FREEDRAWING_MODE)

   698         self.Output.UnConnect(delete = self.Parent.GetDrawingMode() == FREEDRAWING_MODE)

   699         if self.Type == "connection":

   700             self.Condition.UnConnect(delete = self.Parent.GetDrawingMode() == FREEDRAWING_MODE)

   701     

   702     # Returns if the point given is in the bounding box

   703     def HitTest(self, pt, connectors=True):

   704         if self.Type != "connection":

   705             # Calculate the bounding box of the condition outside the transition

   706             text_width, text_height = self.ConditionSize

   707             text_bbx = wx.Rect(self.Pos.x + self.Size[0] + 5,

   708                                self.Pos.y + (self.Size[1] - text_height) / 2,

   709                                text_width,

   710                                text_height)

   711             test_text = text_bbx.InsideXY(pt.x, pt.y)

   712         else:

   713             test_text = False

   714         return test_text or Graphic_Element.HitTest(self, pt, connectors)

   715     

   716     # Refresh the transition bounding box

   717     def RefreshBoundingBox(self):

   718         bbx_x, bbx_y, bbx_width, bbx_height = self.Pos.x, self.Pos.y, self.Size[0], self.Size[1]

   719         if self.Priority != 0:

   720             bbx_y = self.Pos.y - self.PrioritySize[1] - 2

   721             bbx_width = max(self.Size[0], self.PrioritySize[0])

   722             bbx_height = self.Size[1] + self.PrioritySize[1] + 2

   723         if self.Type == "connection":

   724             bbx_x = self.Pos.x - CONNECTOR_SIZE

   725             bbx_width = bbx_width + CONNECTOR_SIZE

   726         else:

   727             text_width, text_height = self.ConditionSize

   728             # Calculate the bounding box size

   729             bbx_width = max(bbx_width, self.Size[0] + 5 + text_width)

   730             bbx_y = min(bbx_y, self.Pos.y - max(0, (text_height - self.Size[1]) / 2))

   731             bbx_height = max(bbx_height, self.Pos.y - bbx_y + (self.Size[1] + text_height) / 2)

   732         self.BoundingBox = wx.Rect(bbx_x, bbx_y, bbx_width + 1, bbx_height + 1)

   733         

   734     # Returns the connector connected to input

   735     def GetPreviousConnector(self):

   736         wires = self.Input.GetWires()

   737         if len(wires) == 1:

   738             return wires[0][0].GetOtherConnected(self.Input)

   739         return None

   740     

   741     # Returns the connector connected to output

   742     def GetNextConnector(self):

   743         wires = self.Output.GetWires()

   744         if len(wires) == 1:

   745             return wires[0][0].GetOtherConnected(self.Output)

   746         return None

   747     

   748     # Refresh the positions of the transition connectors

   749     def RefreshConnectors(self):

   750         scaling = self.Parent.GetScaling()

   751         horizontal_pos = self.Size[0] / 2

   752         vertical_pos = self.Size[1] / 2

   753         if scaling is not None:

   754             horizontal_pos = round(float(self.Pos.x + horizontal_pos) / float(scaling[0])) * scaling[0] - self.Pos.x

   755             vertical_pos = round(float(self.Pos.y + vertical_pos) / float(scaling[1])) * scaling[1] - self.Pos.y

   756         # Update input position

   757         self.Input.SetPosition(wx.Point(horizontal_pos, 0))

   758         # Update output position

   759         self.Output.SetPosition(wx.Point(horizontal_pos, self.Size[1]))

   760         if self.Type == "connection":

   761             self.Condition.SetPosition(wx.Point(0, vertical_pos))

   762         self.RefreshConnected()

   763     

   764     # Refresh the position of the wires connected to transition

   765     def RefreshConnected(self, exclude = []):

   766         self.Input.MoveConnected(exclude)

   767         self.Output.MoveConnected(exclude)

   768         if self.Type == "connection":

   769             self.Condition.MoveConnected(exclude)

   770     

   771     # Returns the transition connector that starts with the point given if it exists 

   772     def GetConnector(self, position, name = None):

   773         # if a name is given

   774         if name is not None:

   775             # Test input and output connector

   776             #if name == self.Input.GetName():

   777             #    return self.Input

   778             if name == self.Output.GetName():

   779                 return self.Output

   780             if self.Type == "connection" and name == self.Condition.GetName():

   781                 return self.Condition

   782         connectors = [self.Input, self.Output]

   783         if self.Type == "connection":

   784             connectors.append(self.Condition)

   785         return self.FindNearestConnector(position, connectors)

   786     

   787     # Returns the transition condition connector

   788     def GetConditionConnector(self):

   789         if self.Type == "connection":

   790             return self.Condition

   791         return None

   792         

   793     # Returns input and output transition connectors

   794     def GetConnectors(self):

   795         return {"inputs": [self.Input], "outputs": [self.Output]}

   796         

   797     # Test if point given is on transition input or output connector

   798     def TestConnector(self, pt, direction = None, exclude=True):

   799         # Test input connector

   800         if self.Input.TestPoint(pt, direction, exclude):

   801             return self.Input

   802         # Test output connector

   803         if self.Output.TestPoint(pt, direction, exclude):

   804             return self.Output

   805         # Test condition connector

   806         if self.Type == "connection" and self.Condition.TestPoint(pt, direction, exclude):

   807             return self.Condition

   808         return None

   809 

   810     # Changes the transition type

   811     def SetType(self, type, condition = None):

   812         if self.Type != type:

   813             if self.Type == "connection":

   814                self.Condition.UnConnect(delete = self.Parent.GetDrawingMode() == FREEDRAWING_MODE) 

   815             self.Type = type

   816             if type == "connection":

   817                 self.Condition = Connector(self, "", "BOOL", wx.Point(0, self.Size[1] / 2), WEST)

   818             else:

   819                 if condition == None:

   820                     condition = ""

   821                 self.Condition = condition

   822                 self.RefreshConditionSize()

   823         elif self.Type != "connection":

   824             if condition == None:

   825                 condition = ""

   826             self.Condition = condition

   827             self.RefreshConditionSize()

   828         self.RefreshBoundingBox()

   829         

   830     # Returns the transition type

   831     def GetType(self):

   832         return self.Type

   833 

   834     # Changes the transition priority

   835     def SetPriority(self, priority):

   836         self.Priority = priority

   837         self.RefreshPrioritySize()

   838         self.RefreshBoundingBox()

   839         

   840     # Returns the transition type

   841     def GetPriority(self):

   842         return self.Priority

   843 

   844     # Returns the transition condition

   845     def GetCondition(self):

   846         if self.Type != "connection":

   847             return self.Condition

   848         return None

   849         

   850     # Returns the transition minimum size

   851     def GetMinSize(self):

   852         return SFC_TRANSITION_SIZE

   853     

   854     # Align input element with this step

   855     def RefreshInputPosition(self):

   856         wires = self.Input.GetWires()

   857         current_pos = self.Input.GetPosition(False)

   858         input = self.GetPreviousConnector()

   859         if input:

   860             input_pos = input.GetPosition(False)

   861             diffx = current_pos.x - input_pos.x

   862             input_block = input.GetParentBlock()

   863             if isinstance(input_block, SFC_Divergence):

   864                 input_block.MoveConnector(input, diffx)

   865             else:

   866                 if isinstance(input_block, SFC_Step):

   867                     input_block.MoveActionBlock((diffx, 0))

   868                 input_block.Move(diffx, 0)

   869                 input_block.RefreshInputPosition()

   870     

   871     # Align output element with this step

   872     def RefreshOutputPosition(self, move = None):

   873         wires = self.Output.GetWires()

   874         if len(wires) != 1:

   875             return

   876         current_pos = self.Output.GetPosition(False)

   877         output = wires[0][0].GetOtherConnected(self.Output)

   878         output_pos = output.GetPosition(False)

   879         diffx = current_pos.x - output_pos.x

   880         output_block = output.GetParentBlock()

   881         if move:

   882             if isinstance(output_block, SFC_Step):

   883                 output_block.MoveActionBlock(move)

   884             wires[0][0].Move(move[0], move[1], True)

   885             if not isinstance(output_block, SFC_Divergence) or output_block.GetConnectors()["inputs"].index(output) == 0:

   886                 output_block.Move(move[0], move[1], self.Parent.Wires)

   887                 output_block.RefreshOutputPosition(move)

   888             else:

   889                 output_block.RefreshPosition()

   890         elif isinstance(output_block, SFC_Divergence):

   891             output_block.MoveConnector(output, diffx)

   892         else:

   893             if isinstance(output_block, SFC_Step):

   894                 output_block.MoveActionBlock((diffx, 0))

   895             output_block.Move(diffx, 0)

   896             output_block.RefreshOutputPosition()

   897 

   898     # Method called when a LeftDClick event have been generated

   899     def OnLeftDClick(self, event, dc, scaling):

   900         # Edit the transition properties

   901         self.Parent.EditTransitionContent(self)

   902     

   903     # Method called when a RightUp event have been generated

   904     def OnRightUp(self, event, dc, scaling):

   905         # Popup the menu with special items for a step

   906         self.Parent.PopupDefaultMenu()

   907     

   908     # Refreshes the transition state according to move defined and handle selected

   909     def ProcessDragging(self, movex, movey, event, scaling):

   910         if self.Parent.GetDrawingMode() != FREEDRAWING_MODE:

   911             movex = max(-self.BoundingBox.x, movex)

   912             if scaling is not None:

   913                 movex = round(float(self.Pos.x + movex) / float(scaling[0])) * scaling[0] - self.Pos.x

   914             self.Move(movex, 0)

   915             self.RefreshInputPosition()

   916             self.RefreshOutputPosition()

   917             return movex, 0

   918         else:

   919             return Graphic_Element.ProcessDragging(self, movex, movey, event, scaling, width_fac = 2, height_fac = 2)

   920     

   921     # Refresh input element model

   922     def RefreshInputModel(self):

   923         if self.Parent.GetDrawingMode() != FREEDRAWING_MODE:

   924             input = self.GetPreviousConnector()

   925             if input:

   926                 input_block = input.GetParentBlock()

   927                 input_block.RefreshModel(False)

   928                 if not isinstance(input_block, SFC_Divergence):

   929                     input_block.RefreshInputModel()

   930     

   931     # Refresh output element model

   932     def RefreshOutputModel(self, move=False):

   933         output = self.GetNextConnector()

   934         if output:

   935             output_block = output.GetParentBlock()

   936             output_block.RefreshModel(False)

   937             if not isinstance(output_block, SFC_Divergence) or move:

   938                 output_block.RefreshOutputModel(move)

   939     

   940     # Refreshes the transition model

   941     def RefreshModel(self, move=True):

   942         self.Parent.RefreshTransitionModel(self)

   943         # If transition has moved, refresh the model of wires connected to output

   944         if move:

   945             if self.Parent.GetDrawingMode() != FREEDRAWING_MODE:

   946                 self.RefreshInputModel()

   947                 self.RefreshOutputModel()

   948             else:

   949                 self.Output.RefreshWires()

   950     

   951     # Adds an highlight to the block

   952     def AddHighlight(self, infos, start, end ,highlight_type):

   953         if infos[0] in ["reference", "inline", "priority"] and start[0] == 0 and end[0] == 0:

   954             highlights = self.Highlights.setdefault(infos[0], [])

   955             AddHighlight(highlights, (start, end, highlight_type))

   956     

   957     # Removes an highlight from the block

   958     def RemoveHighlight(self, infos, start, end, highlight_type):

   959         if infos[0] in ["reference", "inline", "priority"]:

   960             highlights = self.Highlights.get(infos[0], [])

   961             if RemoveHighlight(highlights, (start, end, highlight_type)) and len(highlights) == 0:

   962                 self.Highlights.pop(infos[0])

   963             

   964     # Removes all the highlights of one particular type from the block

   965     def ClearHighlight(self, highlight_type=None):

   966         if highlight_type is None:

   967             self.Highlights = {}

   968         else:

   969             highlight_items = self.Highlights.items()

   970             for name, highlights in highlight_items:

   971                 highlights = ClearHighlights(highlight, highlight_type)

   972                 if len(highlights) == 0:

   973                     self.Highlights.pop(name)

   974     

   975     # Draws transition

   976     def Draw(self, dc):

   977         Graphic_Element.Draw(self, dc)

   978         if self.Value:

   979             if self.Forced:

   980                 dc.SetPen(MiterPen(wx.CYAN))

   981                 dc.SetBrush(wx.CYAN_BRUSH)

   982             else:

   983                 dc.SetPen(MiterPen(wx.GREEN))

   984                 dc.SetBrush(wx.GREEN_BRUSH)

   985         elif self.Forced:

   986             dc.SetPen(MiterPen(wx.BLUE))

   987             dc.SetBrush(wx.BLUE_BRUSH)

   988         else:

   989             dc.SetPen(MiterPen(wx.BLACK))

   990             dc.SetBrush(wx.BLACK_BRUSH)

   991         

   992         if getattr(dc, "printing", False):

   993             if self.Type != "connection":

   994                 condition_size = dc.GetTextExtent(self.Condition)

   995             if self.Priority != 0:

   996                 priority_size = dc.GetTextExtent(str(self.Priority))

   997         else:

   998             if self.Type != "connection":

   999                 condition_size = self.ConditionSize

  1000             if self.Priority != 0:

  1001                 priority_size = self.PrioritySize

  1002         

  1003         # Draw plain rectangle for representing the transition

  1004         dc.DrawRectangle(self.Pos.x, 

  1005                          self.Pos.y + (self.Size[1] - SFC_TRANSITION_SIZE[1])/2, 

  1006                          self.Size[0] + 1,

  1007                          SFC_TRANSITION_SIZE[1] + 1)

  1008         vertical_line_x = self.Input.GetPosition()[0]

  1009         dc.DrawLine(vertical_line_x, self.Pos.y, vertical_line_x, self.Pos.y + self.Size[1] + 1) 

  1010         # Draw transition condition

  1011         if self.Type != "connection":

  1012             if self.Condition != "":

  1013                 condition = self.Condition

  1014             else:

  1015                 condition = "Transition"

  1016             condition_pos = (self.Pos.x + self.Size[0] + 5,

  1017                              self.Pos.y + (self.Size[1] - condition_size[1]) / 2)

  1018             dc.DrawText(condition, condition_pos[0], condition_pos[1])

  1019         # Draw priority number

  1020         if self.Priority != 0:

  1021             priority_pos = (self.Pos.x, self.Pos.y - priority_size[1] - 2)

  1022             dc.DrawText(str(self.Priority), priority_pos[0], priority_pos[1])

  1023         # Draw input and output connectors

  1024         self.Input.Draw(dc)

  1025         self.Output.Draw(dc)

  1026         if self.Type == "connection":

  1027             self.Condition.Draw(dc)

  1028         

  1029         if not getattr(dc, "printing", False):

  1030             for name, highlights in self.Highlights.iteritems():

  1031                 if name == "priority":

  1032                     DrawHighlightedText(dc, str(self.Priority), highlights, priority_pos[0], priority_pos[1])

  1033                 else:

  1034                     DrawHighlightedText(dc, condition, highlights, condition_pos[0], condition_pos[1])

  1035 

  1036 #-------------------------------------------------------------------------------

  1037 #                Sequencial Function Chart Divergence and Convergence

  1038 #-------------------------------------------------------------------------------

  1039 

  1040 """

  1041 Class that implements the graphic representation of a divergence or convergence,

  1042 selection or simultaneous

  1043 """

  1044 

  1045 class SFC_Divergence(Graphic_Element):

  1046     

  1047     # Create a new divergence

  1048     def __init__(self, parent, type, number = 2, id = None):

  1049         Graphic_Element.__init__(self, parent)

  1050         self.Type = type

  1051         self.Id = id

  1052         self.RealConnectors = None

  1053         number = max(2, number)

  1054         self.Size = wx.Size((number - 1) * SFC_DEFAULT_SEQUENCE_INTERVAL, self.GetMinSize()[1])

  1055         # Create an input and output connector

  1056         if self.Type in [SELECTION_DIVERGENCE, SIMULTANEOUS_DIVERGENCE]:

  1057             self.Inputs = [Connector(self, "", None, wx.Point(self.Size[0] / 2, 0), NORTH, onlyone = True)]

  1058             self.Outputs = []

  1059             for i in xrange(number):

  1060                 self.Outputs.append(Connector(self, "", None, wx.Point(i * SFC_DEFAULT_SEQUENCE_INTERVAL, self.Size[1]), SOUTH, onlyone = True))

  1061         elif self.Type in [SELECTION_CONVERGENCE, SIMULTANEOUS_CONVERGENCE]:

  1062             self.Inputs = []

  1063             for i in xrange(number):

  1064                 self.Inputs.append(Connector(self, "", None, wx.Point(i * SFC_DEFAULT_SEQUENCE_INTERVAL, 0), NORTH, onlyone = True))

  1065             self.Outputs = [Connector(self, "", None, wx.Point(self.Size[0] / 2, self.Size[1]), SOUTH, onlyone = True)]

  1066         self.Value = None

  1067         self.PreviousValue = None

  1068     

  1069     def Flush(self):

  1070         for input in self.Inputs:

  1071             input.Flush()

  1072         self.Inputs = []

  1073         for output in self.Outputs:

  1074             output.Flush()

  1075         self.Outputs = []

  1076     

  1077     def SpreadCurrent(self):

  1078         if self.Parent.Debug:

  1079             self.PreviousValue = self.Value

  1080             if self.Type == SELECTION_CONVERGENCE:

  1081                 self.Value = False

  1082                 for input in self.Inputs:

  1083                     self.Value |= input.ReceivingCurrent()

  1084             elif self.Type == SIMULTANEOUS_CONVERGENCE:

  1085                 self.Value = True

  1086                 for input in self.Inputs:

  1087                     self.Value &= input.ReceivingCurrent()

  1088             elif self.Type in [SELECTION_DIVERGENCE, SIMULTANEOUS_DIVERGENCE]:

  1089                 self.Value = self.Inputs[0].ReceivingCurrent()

  1090             else:

  1091                 self.Value = False

  1092             if self.Value and not self.PreviousValue:

  1093                 if self.Visible:

  1094                     self.Parent.ElementNeedRefresh(self)

  1095                 for output in self.Outputs:

  1096                     output.SpreadCurrent(True)

  1097             elif not self.Value and self.PreviousValue:

  1098                 if self.Visible:

  1099                     self.Parent.ElementNeedRefresh(self)

  1100                 for output in self.Outputs:

  1101                     output.SpreadCurrent(False)

  1102     

  1103     # Make a clone of this SFC_Divergence

  1104     def Clone(self, parent, id = None, pos = None):

  1105         divergence = SFC_Divergence(parent, self.Type, max(len(self.Inputs), len(self.Outputs)), id)

  1106         divergence.SetSize(self.Size[0], self.Size[1])

  1107         if pos is not None:

  1108             divergence.SetPosition(pos.x, pos.y)

  1109         else:

  1110             divergence.SetPosition(self.Pos.x, self.Pos.y)

  1111         divergence.Inputs = [input.Clone(divergence) for input in self.Inputs]

  1112         divergence.Outputs = [output.Clone(divergence) for output in self.Outputs]

  1113         return divergence

  1114     

  1115     def GetConnectorTranslation(self, element):

  1116         return dict(zip(self.Inputs + self.Outputs, element.Inputs + element.Outputs))

  1117     

  1118     # Returns the RedrawRect

  1119     def GetRedrawRect(self, movex = 0, movey = 0):

  1120         rect = Graphic_Element.GetRedrawRect(self, movex, movey)

  1121         if movex != 0 or movey != 0:

  1122             for input in self.Inputs:

  1123                 if input.IsConnected():

  1124                     rect = rect.Union(input.GetConnectedRedrawRect(movex, movey))

  1125             for output in self.Outputs:

  1126                 if output.IsConnected():

  1127                     rect = rect.Union(output.GetConnectedRedrawRect(movex, movey))

  1128         return rect

  1129     

  1130     # Forbids to resize the divergence

  1131     def Resize(self, x, y, width, height):

  1132         if self.Parent.GetDrawingMode() == FREEDRAWING_MODE:

  1133             Graphic_Element.Resize(self, x, 0, width, self.GetMinSize()[1])

  1134     

  1135     # Delete this divergence by calling the appropriate method

  1136     def Delete(self):