beremiz: comparison graphics/GraphicCommons.py

equal deleted inserted replaced

-:c3c3d1318130
+:69dfdb26f600
 """
 Basic vector operations for calculate wire points
 """
-def vector(p1, p2, normal = True):
+def vector(p1, p2, normal=True):
 """
 Create a vector from two points and define if vector must be normal
 """
 vector = (p2.x - p1.x, p2.y - p1.y)
 if normal:
 """
 Class that implements a generic graphic element
 """
 # Create a new graphic element
-def __init__(self, parent, id = None):
+def __init__(self, parent, id=None):
 ToolTipProducer.__init__(self, parent)
 self.Parent = parent
 self.Id = id
 self.oldPos = None
 self.StartPos = None
 # Returns the bounding box
 def GetBoundingBox(self):
 return self.BoundingBox
 # Returns the RedrawRect
-def GetRedrawRect(self, movex = 0, movey = 0):
+def GetRedrawRect(self, movex=0, movey=0):
 scalex, scaley = self.Parent.GetViewScale()
 rect = wx.Rect()
 rect.x = self.BoundingBox.x - int(HANDLE_SIZE / scalex) - 3 - abs(movex)
 rect.y = self.BoundingBox.y - int(HANDLE_SIZE / scaley) - 3 - abs(movey)
 rect.width = self.BoundingBox.width + 2 * (int(HANDLE_SIZE / scalex) + abs(movex) + 1) + 4
 rect.height = self.BoundingBox.height + 2 * (int(HANDLE_SIZE / scaley) + abs(movey) + 1) + 4
 return rect
-def Refresh(self, rect = None):
+def Refresh(self, rect=None):
 if self.Visible:
 if rect is not None:
 self.Parent.RefreshRect(self.Parent.GetScrolledRect(rect), False)
 else:
 self.Parent.RefreshRect(self.Parent.GetScrolledRect(self.GetRedrawRect()), False)
 cursor = HANDLE_CURSORS.get(handle, 0)
 wx.CallAfter(self.Parent.SetCurrentCursor, cursor)
 return 0, 0
 # Moves the element
-def Move(self, dx, dy, exclude = []):
+def Move(self, dx, dy, exclude=[]):
 self.Pos.x += max(-self.BoundingBox.x, dx)
 self.Pos.y += max(-self.BoundingBox.y, dy)
 self.RefreshConnected(exclude)
 self.RefreshBoundingBox()
 def Resize(self, x, y, width, height):
 self.Move(x, y)
 self.SetSize(width, height)
 # Refreshes the element state according to move defined and handle selected
-def ProcessDragging(self, movex, movey, event, scaling, width_fac = 1, height_fac = 1):
+def ProcessDragging(self, movex, movey, event, scaling, width_fac=1, height_fac=1):
 handle_type, handle = self.Handle
 # If it is a resize handle, calculate the values from resizing
 if handle_type == HANDLE_RESIZE:
 if scaling is not None:
 scaling = (scaling[0] * width_fac, scaling[1] * height_fac)
 blocks.extend(block)
 wires.extend(wire)
 return blocks, wires
 # Make a clone of this element
-def Clone(self, parent, pos = None):
+def Clone(self, parent, pos=None):
 group = Graphic_Group(parent)
 connectors = {}
 exclude_names = {}
 wires = []
 if pos is not None:
 new_pos = wx.Point(x + dx, y + dy)
 newid = parent.GetNewId()
 if parent.IsNamedElement(element):
 name = parent.GenerateNewName(element, exclude_names)
 exclude_names[name.upper()] = True
-new_element = element.Clone(parent, newid, name, pos = new_pos)
+new_element = element.Clone(parent, newid, name, pos=new_pos)
 else:
-new_element = element.Clone(parent, newid, pos = new_pos)
+new_element = element.Clone(parent, newid, pos=new_pos)
 new_element.SetBestSize(parent.Scaling)
 else:
 new_element = element.Clone(parent)
 connectors.update(element.GetConnectorTranslation(new_element))
 group.SelectElement(new_element)
 endblock = element.EndConnected.GetParentBlock()
 if startblock in self.Elements and endblock in self.Elements:
 self.WireExcluded.append(element)
 # Returns the RedrawRect
-def GetRedrawRect(self, movex = 0, movey = 0):
+def GetRedrawRect(self, movex=0, movey=0):
 rect = None
 for element in self.Elements:
 if rect is None:
 rect = element.GetRedrawRect(movex, movey)
 else:
 """
 Class that implements a connector for any type of block
 """
 # Create a new connector
-def __init__(self, parent, name, type, position, direction, negated = False, edge = "none", onlyone = False):
+def __init__(self, parent, name, type, position, direction, negated=False, edge="none", onlyone=False):
 DebugDataConsumer.__init__(self)
 ToolTipProducer.__init__(self, parent.Parent)
 self.ParentBlock = parent
 self.Name = name
 self.Type = type
 for wire, handle in self.Wires:
 wire.Flush()
 self.Wires = []
 # Returns the RedrawRect
-def GetRedrawRect(self, movex = 0, movey = 0):
+def GetRedrawRect(self, movex=0, movey=0):
 parent_pos = self.ParentBlock.GetPosition()
 x = min(parent_pos[0] + self.Pos.x, parent_pos[0] + self.Pos.x + self.Direction[0] * CONNECTOR_SIZE)
 y = min(parent_pos[1] + self.Pos.y, parent_pos[1] + self.Pos.y + self.Direction[1] * CONNECTOR_SIZE)
 has_modifier = self.Negated or self.Edge != "none"
 if self.Direction[0] == 0:
 # Change the connector selection
 def SetSelected(self, selected):
 self.Selected = selected
 # Make a clone of the connector
-def Clone(self, parent = None):
+def Clone(self, parent=None):
 if parent is None:
 parent = self.ParentBlock
 return Connector(parent, self.Name, self.Type, wx.Point(self.Pos[0], self.Pos[1]),
 self.Direction, self.Negated)
 # Returns the connector parent block
 def GetParentBlock(self):
 return self.ParentBlock
 # Returns the connector type
-def GetType(self, raw = False):
+def GetType(self, raw=False):
 if self.ParentBlock.IsEndType(self.Type) or raw:
 return self.Type
 elif (self.Negated or self.Edge != "none") and self.ParentBlock.IsOfType("BOOL", self.Type):
 return "BOOL"
 else:
 # Returns the connector relative position
 def GetRelPosition(self):
 return self.Pos
 # Returns the connector absolute position
-def GetPosition(self, size = True):
+def GetPosition(self, size=True):
 parent_pos = self.ParentBlock.GetPosition()
 # If the position of the end of the connector is asked
 if size:
 x = parent_pos[0] + self.Pos.x + self.Direction[0] * CONNECTOR_SIZE
 y = parent_pos[1] + self.Pos.y + self.Direction[1] * CONNECTOR_SIZE
 # Change the connector direction
 def SetDirection(self, direction):
 self.Direction = direction
 # Connect a wire to this connector at the last place
-def Connect(self, wire, refresh = True):
+def Connect(self, wire, refresh=True):
 self.InsertConnect(len(self.Wires), wire, refresh)
 # Connect a wire to this connector at the place given
-def InsertConnect(self, idx, wire, refresh = True):
+def InsertConnect(self, idx, wire, refresh=True):
 if wire not in self.Wires:
 self.Wires.insert(idx, wire)
 if wire[1] == 0:
 wire[0].ConnectStartPoint(None, self)
 else:
 if tmp_wire == wire:
 return i
 return None
 # Unconnect a wire or all wires connected to the connector
-def UnConnect(self, wire = None, unconnect = True, delete = False):
+def UnConnect(self, wire=None, unconnect=True, delete=False):
 i = 0
 found = False
 while i < len(self.Wires) and not found:
 if not wire or self.Wires[i][0] == wire:
 # If Unconnect haven't been called from a wire, disconnect the connector in the wire
 # Returns if connector has one or more wire connected
 def IsConnected(self):
 return len(self.Wires) > 0
 # Move the wires connected
-def MoveConnected(self, exclude = []):
+def MoveConnected(self, exclude=[]):
 if len(self.Wires) > 0:
 # Calculate the new position of the end point
 parent_pos = self.ParentBlock.GetPosition()
 x = parent_pos[0] + self.Pos.x + self.Direction[0] * CONNECTOR_SIZE
 y = parent_pos[1] + self.Pos.y + self.Direction[1] * CONNECTOR_SIZE
 """
 Class that implements a wire for connecting two blocks
 """
 # Create a new wire
-def __init__(self, parent, start = None, end = None):
+def __init__(self, parent, start=None, end=None):
 Graphic_Element.__init__(self, parent)
 DebugDataConsumer.__init__(self)
 self.StartPoint = start
 self.EndPoint = end
 self.StartConnected = None
 def Flush(self):
 self.StartConnected = None
 self.EndConnected = None
 # Returns the RedrawRect
-def GetRedrawRect(self, movex = 0, movey = 0):
+def GetRedrawRect(self, movex=0, movey=0):
 rect = Graphic_Element.GetRedrawRect(self, movex, movey)
 if self.StartConnected:
 rect = rect.Union(self.StartConnected.GetRedrawRect(movex, movey))
 if self.EndConnected:
 rect = rect.Union(self.EndConnected.GetRedrawRect(movex, movey))
 else:
 y = self.Points[middle].y - height
 rect = rect.Union(wx.Rect(x, y, width, height))
 return rect
-def Clone(self, parent, connectors = {}, dx = 0, dy = 0):
+def Clone(self, parent, connectors={}, dx=0, dy=0):
 start_connector = connectors.get(self.StartConnected, None)
 end_connector = connectors.get(self.EndConnected, None)
 if start_connector is not None and end_connector is not None:
 wire = Wire(parent)
 wire.SetPoints([(point.x + dx, point.y + dy) for point in self.Points])
 if index < len(self.Points):
 return self.Points[index].x, self.Points[index].y
 return None
 # Returns a list of the position of all wire points
-def GetPoints(self, invert = False):
+def GetPoints(self, invert=False):
 points = self.VerifyPoints()
 points[0] = wx.Point(points[0].x - CONNECTOR_SIZE * self.StartPoint[1][0],
 points[0].y - CONNECTOR_SIZE * self.StartPoint[1][1])
 points[-1] = wx.Point(points[-1].x - CONNECTOR_SIZE * self.EndPoint[1][0],
 points[-1].y - CONNECTOR_SIZE * self.EndPoint[1][1])
 elif index == -1 and self.EndConnected:
 return self.EndConnected.GetBlockId(), self.EndConnected.GetName()
 return None
 # Update the wire points position by keeping at most possible the current positions
-def GeneratePoints(self, realpoints = True):
+def GeneratePoints(self, realpoints=True):
 i = 0
 # Calculate the start enad end points with the minimum segment size in the right direction
 end = wx.Point(self.EndPoint[0].x + self.EndPoint[1][0] * MIN_SEGMENT_SIZE,
 self.EndPoint[0].y + self.EndPoint[1][1] * MIN_SEGMENT_SIZE)
 start = wx.Point(self.StartPoint[0].x + self.StartPoint[1][0] * MIN_SEGMENT_SIZE,
 self.RefreshBoundingBox()
 self.RefreshRealPoints()
 return points
 # Moves all the wire points except the first and the last if they are connected
-def Move(self, dx, dy, endpoints = False):
+def Move(self, dx, dy, endpoints=False):
 for i, point in enumerate(self.Points):
 if endpoints or not (i == 0 and self.StartConnected) and not (i == len(self.Points) - 1 and self.EndConnected):
 point.x += dx
 point.y += dy
 self.StartPoint[0] = self.Points[0]
 self.MoveStartPoint(point)
 self.StartConnected = connector
 self.RefreshBoundingBox()
 # Unconnects wire start point
-def UnConnectStartPoint(self, delete = False):
+def UnConnectStartPoint(self, delete=False):
 if delete:
 self.StartConnected = None
 self.Delete()
 elif self.StartConnected:
-self.StartConnected.UnConnect(self, unconnect = False)
+self.StartConnected.UnConnect(self, unconnect=False)
 self.StartConnected = None
 self.RefreshBoundingBox()
 # Moves the wire end point and update the wire points
 def MoveEndPoint(self, point):
 self.MoveEndPoint(point)
 self.EndConnected = connector
 self.RefreshBoundingBox()
 # Unconnects wire end point
-def UnConnectEndPoint(self, delete = False):
+def UnConnectEndPoint(self, delete=False):
 if delete:
 self.EndConnected = None
 self.Delete()
 elif self.EndConnected:
-self.EndConnected.UnConnect(self, unconnect = False)
+self.EndConnected.UnConnect(self, unconnect=False)
 self.EndConnected = None
 self.RefreshBoundingBox()
 # Moves the wire segment given by its index
 def MoveSegment(self, idx, movex, movey, scaling):
 """
 Class that implements a comment
 """
 # Create a new comment
-def __init__(self, parent, content, id = None):
+def __init__(self, parent, content, id=None):
 Graphic_Element.__init__(self, parent)
 self.Id = id
 self.Content = content
 self.Pos = wx.Point(0, 0)
 self.Size = wx.Size(0, 0)
 self.Highlights = []
 # Make a clone of this comment
-def Clone(self, parent, id = None, pos = None):
+def Clone(self, parent, id=None, pos=None):
 comment = Comment(parent, self.Content, id)
 if pos is not None:
 comment.SetPosition(pos.x, pos.y)
 comment.SetSize(self.Size[0], self.Size[1])
 return comment
 # Returns the comment position
 def GetPosition(self):
 return self.Pos.x, self.Pos.y
 # Moves the comment
-def Move(self, dx, dy, connected = True):
+def Move(self, dx, dy, connected=True):
 self.Pos.x += dx
 self.Pos.y += dy
 self.RefreshBoundingBox()
 # Resizes the comment with the position and the size given

changeset 1744	69dfdb26f600
parent 1743	c3c3d1318130
child 1749	d73b64672238