beremiz: comparison graphics/SFC

equal deleted inserted replaced

-:2a70d5240300
+:21164625b393
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 from __future__ import absolute_import
+from __future__ import division
+from future.builtins import round
 import wx
+from six.moves import xrange
 from graphics.GraphicCommons import *
 from graphics.DebugDataConsumer import DebugDataConsumer
 from plcopen.structures import *
 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)
+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.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.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.RefreshBoundingBox()
 # Add output connector to step
 def AddOutput(self):
 if not self.Output:
-self.Output = Connector(self, "", None, wx.Point(self.Size[0] / 2, self.Size[1]), SOUTH, onlyone=True)
+self.Output = Connector(self, "", None, wx.Point(self.Size[0] // 2, self.Size[1]), SOUTH, onlyone=True)
 self.RefreshBoundingBox()
 # Remove output connector from step
 def RemoveOutput(self):
 if self.Output:
 self.RefreshBoundingBox()
 # Add action connector to step
 def AddAction(self):
 if not self.Action:
-self.Action = Connector(self, "", None, wx.Point(self.Size[0], self.Size[1] / 2), EAST, onlyone=True)
+self.Action = Connector(self, "", None, wx.Point(self.Size[0], self.Size[1] // 2), EAST, onlyone=True)
 self.RefreshBoundingBox()
 # Remove action connector from step
 def RemoveAction(self):
 if self.Action:
 self.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
+horizontal_pos = self.Size[0] // 2
-vertical_pos = self.Size[1] / 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
+horizontal_pos = round((self.Pos.x + horizontal_pos) / scaling[0]) * scaling[0] - self.Pos.x
-vertical_pos = round(float(self.Pos.y + vertical_pos) / float(scaling[1])) * scaling[1] - self.Pos.y
+vertical_pos = round((self.Pos.y + vertical_pos) / 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:
 else:
 return text_width + 10, text_height + 10
 # Updates the step size
 def UpdateSize(self, width, height):
-diffx = self.Size.GetWidth() / 2 - width / 2
+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()
 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
+movex = round((self.Pos.x + movex) / scaling[0]) * scaling[0] - self.Pos.x
-movey = round(float(self.Pos.y + movey) / float(scaling[1])) * scaling[1] - self.Pos.y
+movey = round((self.Pos.y + movey) / scaling[1]) * scaling[1] - self.Pos.y
 if self.Parent.GetDrawingMode() == FREEDRAWING_MODE:
 self.Move(movex, movey)
 self.RefreshConnected()
 return movex, movey
 elif self.Initial:
 # 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,
+name_pos = (self.Pos.x + (self.Size[0] - name_size[0]) // 2,
-self.Pos.y + (self.Size[1] - name_size[1]) / 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.Type = None
 self.Id = id
 self.Priority = 0
 self.Size = wx.Size(SFC_TRANSITION_SIZE[0], SFC_TRANSITION_SIZE[1])
 # Create an input and output connector
-self.Input = Connector(self,  "", None, wx.Point(self.Size[0] / 2, 0),            NORTH, onlyone=True)
+self.Input = Connector(self,  "", None, wx.Point(self.Size[0] // 2, 0),            NORTH, onlyone=True)
-self.Output = Connector(self, "", None, wx.Point(self.Size[0] / 2, self.Size[1]), SOUTH, onlyone=True)
+self.Output = Connector(self, "", None, wx.Point(self.Size[0] // 2, self.Size[1]), SOUTH, onlyone=True)
 self.SetType(type, condition)
 self.SetPriority(priority)
 self.Highlights = {}
 self.PreviousValue = None
 self.PreviousSpreading = False
 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,
+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
 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_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)
+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()
 return None
 # Refresh the positions of the transition connectors
 def RefreshConnectors(self):
 scaling = self.Parent.GetScaling()
-horizontal_pos = self.Size[0] / 2
+horizontal_pos = self.Size[0] // 2
-vertical_pos = self.Size[1] / 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
+horizontal_pos = round((self.Pos.x + horizontal_pos) / scaling[0]) * scaling[0] - self.Pos.x
-vertical_pos = round(float(self.Pos.y + vertical_pos) / float(scaling[1])) * scaling[1] - self.Pos.y
+vertical_pos = round((self.Pos.y + vertical_pos) / 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":
 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)
+self.Condition = Connector(self, "", "BOOL", wx.Point(0, self.Size[1] // 2), WEST)
 else:
 if condition is None:
 condition = ""
 self.Condition = condition
 self.RefreshConditionSize()
 # 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
+movex = round((self.Pos.x + movex) / scaling[0]) * scaling[0] - self.Pos.x
 self.Move(movex, 0)
 self.RefreshInputPosition()
 self.RefreshOutputPosition()
 return movex, 0
 else:
 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.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.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)
+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])
 self.RealConnectors = None
 number = max(2, number)
 self.Size = wx.Size((number - 1) * SFC_DEFAULT_SEQUENCE_INTERVAL, self.GetMinSize()[1])
 # Create an input and output connector
 if self.Type in [SELECTION_DIVERGENCE, SIMULTANEOUS_DIVERGENCE]:
-self.Inputs = [Connector(self, "", None, wx.Point(self.Size[0] / 2, 0), NORTH, onlyone=True)]
+self.Inputs = [Connector(self, "", None, wx.Point(self.Size[0] // 2, 0), NORTH, onlyone=True)]
 self.Outputs = []
 for i in xrange(number):
 self.Outputs.append(Connector(self, "", None, wx.Point(i * SFC_DEFAULT_SEQUENCE_INTERVAL, self.Size[1]), SOUTH, onlyone=True))
 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.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:
 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.SetPosition(wx.Point(int(round(position.x*width / 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.SetPosition(wx.Point(int(round(position.x*width / self.Size[0])), height))
 output.MoveConnected()
 self.Size = wx.Size(width, height)
 self.RefreshBoundingBox()
 # Returns the divergence minimum size
 # 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]))
+self.RealConnectors["Inputs"].append(position.x / self.Size[0])
 for output in self.Outputs:
 position = output.GetRelPosition()
-self.RealConnectors["Outputs"].append(float(position.x)/float(self.Size[0]))
+self.RealConnectors["Outputs"].append(position.x / 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)
 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
+movex = round((self.Pos.x + movex) / 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:
 self.SetTarget(target)
 self.Id = id
 self.Size = wx.Size(SFC_JUMP_SIZE[0], SFC_JUMP_SIZE[1])
 self.Highlights = []
 # Create an input and output connector
-self.Input = Connector(self, "", None, wx.Point(self.Size[0] / 2, 0), NORTH, onlyone=True)
+self.Input = Connector(self, "", None, wx.Point(self.Size[0] // 2, 0), NORTH, onlyone=True)
 self.Value = None
 self.PreviousValue = None
 def Flush(self):
 if self.Input is not None:
 # 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,
+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
 return None
 # Refresh the element connectors position
 def RefreshConnectors(self):
 scaling = self.Parent.GetScaling()
-horizontal_pos = self.Size[0] / 2
+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
+horizontal_pos = round((self.Pos.x + horizontal_pos) / 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=None):
 # 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
+movex = round((self.Pos.x + movex) / 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)
 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])
+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] // 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])]
+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)
+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)
 self.Id = id
 self.Size = wx.Size(SFC_ACTION_MIN_SIZE[0], SFC_ACTION_MIN_SIZE[1])
 self.MinSize = wx.Size(SFC_ACTION_MIN_SIZE[0], SFC_ACTION_MIN_SIZE[1])
 self.Highlights = {}
 # Create an input and output connector
-self.Input = Connector(self, "", None, wx.Point(0, SFC_ACTION_MIN_SIZE[1] / 2), WEST, onlyone=True)
+self.Input = Connector(self, "", None, wx.Point(0, SFC_ACTION_MIN_SIZE[1] // 2), WEST, onlyone=True)
 self.SetActions(actions)
 self.Value = None
 self.PreviousValue = None
 def Flush(self):
 def GetLineNumber(self):
 return len(self.Actions)
 def GetLineSize(self):
 if len(self.Actions) > 0:
-return self.Size[1] / len(self.Actions)
+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):
 return None
 # Refresh the element connectors position
 def RefreshConnectors(self):
 scaling = self.Parent.GetScaling()
-vertical_pos = SFC_ACTION_MIN_SIZE[1] / 2
+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
+vertical_pos = round((self.Pos.y + vertical_pos) / 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=None):
 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
+movex = round((self.Pos.x + movex) / 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)
 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,
+qualifier_pos = (self.Pos.x + (colsize[0] - qualifier_size[0]) // 2,
-self.Pos.y + i * line_size + line_size / 2 - qualifier_size[1])
+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,
+duration_pos = (self.Pos.x + (colsize[0] - duration_size[0]) // 2,
-self.Pos.y + i * line_size + line_size / 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,
+qualifier_pos = (self.Pos.x + (colsize[0] - qualifier_size[0]) // 2,
-self.Pos.y + i * line_size + (line_size - qualifier_size[1]) / 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,
+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)
+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,
+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)
+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():

changeset 2459	21164625b393
parent 2457	9deec258ab1a
child 3303	0ffb41625592