plcopeneditor_history: comparison graphics/GraphicCommons.py

equal deleted inserted replaced

-:04a02b4b2a57
+:dd6f693e46a1
 #
 #You should have received a copy of the GNU General Public
 #License along with this library; if not, write to the Free Software
 #Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-from wxPython.wx import *
 import wx
 from math import *
 #-------------------------------------------------------------------------------
 CURSORS = None
 def ResetCursors():
 global CURSORS
 if CURSORS == None:
-CURSORS = [wxNullCursor,
+CURSORS = [wx.NullCursor,
-wxStockCursor(wxCURSOR_HAND),
+wx.StockCursor(wx.CURSOR_HAND),
-wxStockCursor(wxCURSOR_SIZENWSE),
+wx.StockCursor(wx.CURSOR_SIZENWSE),
-wxStockCursor(wxCURSOR_SIZENESW),
+wx.StockCursor(wx.CURSOR_SIZENESW),
-wxStockCursor(wxCURSOR_SIZEWE),
+wx.StockCursor(wx.CURSOR_SIZEWE),
-wxStockCursor(wxCURSOR_SIZENS)]
+wx.StockCursor(wx.CURSOR_SIZENS)]
 HANDLE_CURSORS = {
 (1, 1) : 2,
 (3, 3) : 2,
 (1, 3) : 3,
 # Method called when a new box starts to be edited
 def OnLeftDown(self, event, dc, scaling):
 pos = GetScaledEventPosition(event, dc, scaling)
 # Save the point for calculate the box position and size
 self.startPoint = pos
-self.currentBox = wxRect(pos.x, pos.y, 0, 0)
+self.currentBox = wx.Rect(pos.x, pos.y, 0, 0)
-self.drawingSurface.SetCursor(wxStockCursor(wxCURSOR_CROSS))
+self.drawingSurface.SetCursor(wx.StockCursor(wx.CURSOR_CROSS))
 self.Redraw()
 # Method called when dragging with a box edited
 def OnMotion(self, event, dc, scaling):
 pos = GetScaledEventPosition(event, dc, scaling)
 # Save the last position and size of the box for erasing it
-self.lastBox = wxRect(self.currentBox.x, self.currentBox.y, self.currentBox.width,
+self.lastBox = wx.Rect(self.currentBox.x, self.currentBox.y, self.currentBox.width,
 self.currentBox.height)
 # Calculate new position and size of the box
 if pos.x >= self.startPoint.x:
 self.currentBox.x = self.startPoint.x
 self.currentBox.width = pos.x - self.startPoint.x + 1
 self.currentBox.height = self.startPoint.y - pos.y + 1
 self.Redraw()
 # Method called when dragging is stopped
 def OnLeftUp(self, event, dc, scaling):
-self.drawingSurface.SetCursor(wxNullCursor)
+self.drawingSurface.SetCursor(wx.NullCursor)
 self.lastBox = self.currentBox
 self.currentBox = None
 self.Redraw()
 # Method that erase the last box and draw the new box
 def Redraw(self):
 dc = self.drawingSurface.GetLogicalDC()
-dc.SetPen(wxPen(wxWHITE, 1, wxDOT))
+dc.SetPen(wx.Pen(wx.WHITE, 1, wx.DOT))
-dc.SetBrush(wxTRANSPARENT_BRUSH)
+dc.SetBrush(wx.TRANSPARENT_BRUSH)
-dc.SetLogicalFunction(wxXOR)
+dc.SetLogicalFunction(wx.XOR)
 if self.lastBox:
 # Erase last box
 dc.DrawRectangle(self.lastBox.x, self.lastBox.y, self.lastBox.width,
 self.lastBox.height)
 if self.currentBox:
 self.currentBox.height)
 # Erase last box
 def Erase(self):
 dc = self.drawingSurface.GetLogicalDC()
-dc.SetPen(wxPen(wxWHITE, 1, wxDOT))
+dc.SetPen(wx.Pen(wx.WHITE, 1, wx.DOT))
-dc.SetBrush(wxTRANSPARENT_BRUSH)
+dc.SetBrush(wx.TRANSPARENT_BRUSH)
-dc.SetLogicalFunction(wxXOR)
+dc.SetLogicalFunction(wx.XOR)
 if self.lastBox:
 dc.DrawRectangle(self.lastBox.x, self.lastBox.y, self.lastBox.width,
 self.lastBox.height)
 # Draw current box
 def Draw(self):
 dc = self.drawingSurface.GetLogicalDC()
-dc.SetPen(wxPen(wxWHITE, 1, wxDOT))
+dc.SetPen(wx.Pen(wx.WHITE, 1, wx.DOT))
-dc.SetBrush(wxTRANSPARENT_BRUSH)
+dc.SetBrush(wx.TRANSPARENT_BRUSH)
-dc.SetLogicalFunction(wxXOR)
+dc.SetLogicalFunction(wx.XOR)
 if self.currentBox:
 # Draw current box
 dc.DrawRectangle(self.currentBox.x, self.currentBox.y, self.currentBox.width,
 self.currentBox.height)
 self.Id = id
 self.oldPos = None
 self.Handle = False
 self.Dragging = False
 self.Selected = False
-self.Pos = wxPoint(0, 0)
+self.Pos = wx.Point(0, 0)
-self.Size = wxSize(0, 0)
+self.Size = wx.Size(0, 0)
-self.BoundingBox = wxRect(0, 0, 0, 0)
+self.BoundingBox = wx.Rect(0, 0, 0, 0)
 self.CurrentCursor = 0
 ResetCursors()
 # Make a clone of this element
 def Clone(self):
 def GetSize(self):
 return self.Size.GetWidth(), self.Size.GetHeight()
 # Refresh the element Bounding Box
 def RefreshBoundingBox(self):
-self.BoundingBox = wxRect(self.Pos.x, self.Pos.y, self.Size[0], self.Size[1])
+self.BoundingBox = wx.Rect(self.Pos.x, self.Pos.y, self.Size[0], self.Size[1])
 # Refresh the element connectors position
 def RefreshConnectors(self):
 pass
 def SetSelected(self, selected):
 self.Selected = selected
 # Test if the point is on a handle of this element
 def TestHandle(self, pt):
-extern_rect = wxRect(self.BoundingBox.x - HANDLE_SIZE - 2, self.BoundingBox.y - HANDLE_SIZE - 2,
+extern_rect = wx.Rect(self.BoundingBox.x - HANDLE_SIZE - 2, self.BoundingBox.y - HANDLE_SIZE - 2,
 self.BoundingBox.width + 2 * HANDLE_SIZE + 4, self.BoundingBox.height + 2 * HANDLE_SIZE + 4)
-intern_rect = wxRect(self.BoundingBox.x - 2, self.BoundingBox.y - 2,
+intern_rect = wx.Rect(self.BoundingBox.x - 2, self.BoundingBox.y - 2,
 self.BoundingBox.width + 4, self.BoundingBox.height + 4)
 # Verify that this element is selected
 if self.Selected and extern_rect.InsideXY(pt.x, pt.y) and not intern_rect.InsideXY(pt.x, pt.y):
 # Find if point is on a handle horizontally
 if self.BoundingBox.x - HANDLE_SIZE - 2 <= pt.x < self.BoundingBox.x - 2:
 pass
 # Draws the handles of this element if it is selected
 def Draw(self, dc):
 if self.Selected:
-dc.SetPen(wxBLACK_PEN)
+dc.SetPen(wx.BLACK_PEN)
-dc.SetBrush(wxBLACK_BRUSH)
+dc.SetBrush(wx.BLACK_BRUSH)
 dc.DrawRectangle(self.BoundingBox.x - HANDLE_SIZE - 2, self.BoundingBox.y - HANDLE_SIZE - 2, HANDLE_SIZE, HANDLE_SIZE)
 dc.DrawRectangle(self.BoundingBox.x + (self.BoundingBox.width - HANDLE_SIZE) / 2,
 self.BoundingBox.y - HANDLE_SIZE - 2, HANDLE_SIZE, HANDLE_SIZE)
 dc.DrawRectangle(self.BoundingBox.x + self.BoundingBox.width + 2,
 self.BoundingBox.y - HANDLE_SIZE - 2, HANDLE_SIZE, HANDLE_SIZE)
 self.BoundingBox.y + self.BoundingBox.height + 2, HANDLE_SIZE, HANDLE_SIZE)
 dc.DrawRectangle(self.BoundingBox.x + (self.BoundingBox.width - HANDLE_SIZE) / 2,
 self.BoundingBox.y + self.BoundingBox.height + 2, HANDLE_SIZE, HANDLE_SIZE)
 dc.DrawRectangle(self.BoundingBox.x - HANDLE_SIZE - 2, self.BoundingBox.y + self.BoundingBox.height + 2, HANDLE_SIZE, HANDLE_SIZE)
 dc.DrawRectangle(self.BoundingBox.x - HANDLE_SIZE - 2, self.BoundingBox.y + (self.BoundingBox.height - HANDLE_SIZE) / 2, HANDLE_SIZE, HANDLE_SIZE)
-dc.SetBrush(wxWHITE_BRUSH)
+dc.SetBrush(wx.WHITE_BRUSH)
 #-------------------------------------------------------------------------------
 #                           Group of graphic elements
 #-------------------------------------------------------------------------------
 bbox = element.GetBoundingBox()
 minx = min(minx, bbox.x)
 miny = min(miny, bbox.y)
 maxx = max(maxx, bbox.x + bbox.width)
 maxy = max(maxy, bbox.y + bbox.height)
-self.BoundingBox = wxRect(minx, miny, maxx - minx, maxy - miny)
+self.BoundingBox = wx.Rect(minx, miny, maxx - minx, maxy - miny)
 else:
-self.BoundingBox = wxRect(0, 0, 0, 0)
+self.BoundingBox = wx.Rect(0, 0, 0, 0)
 # Forbids to change the group position
 def SetPosition(x, y):
 pass
 self.Direction = direction
 self.Wires = []
 self.Negated = negated
 self.Edge = edge
 self.OneConnected = onlyone
-self.Pen = wxBLACK_PEN
+self.Pen = wx.BLACK_PEN
 self.RefreshNameSize()
 # Change the connector pen
 def SetPen(self, pen):
 self.Pen = pen
 # Make a clone of the connector
 def Clone(self):
-return Connector(self.ParentBlock, self.Name, self.Type, wxPoint(self.Pos[0], self.Pos[1]),
+return Connector(self.ParentBlock, 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
 self.RefreshNameSize()
 # Changes the connector name size
 def RefreshNameSize(self):
 if self.Name != "":
-dc = wxClientDC(self.ParentBlock.Parent)
+dc = wx.ClientDC(self.ParentBlock.Parent)
 self.NameSize = dc.GetTextExtent(self.Name)
 else:
 self.NameSize = 0, 0
 # Returns the connector name 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
 else:
 x = parent_pos[0] + self.Pos.x
 y = parent_pos[1] + self.Pos.y
-return wxPoint(x, y)
+return wx.Point(x, y)
 # Change the connector relative position
 def SetPosition(self, pos):
 self.Pos = pos
 y = parent_pos[1] + self.Pos.y + self.Direction[1] * CONNECTOR_SIZE
 # Move the corresponding point on all the wires connected
 for wire, index in self.Wires:
 if wire not in exclude:
 if index == 0:
-wire.MoveStartPoint(wxPoint(x, y))
+wire.MoveStartPoint(wx.Point(x, y))
 else:
-wire.MoveEndPoint(wxPoint(x, y))
+wire.MoveEndPoint(wx.Point(x, y))
 # Refreshes the model of all the wires connected
 def RefreshWires(self):
 for wire in self.Wires:
 wire[0].RefreshModel()
 def GetConnectedBlocks(self):
 blocks = []
 for wire, handle in self.Wires:
 # Get other connector connected to each wire
 if handle == 0:
-connector = blocks.GetEndConnected()
+connector = wire.GetEndConnected()
 else:
-connector = blocks.GetStartConnected()
+connector = wire.GetStartConnected()
 # Get parent block for this connector
 if connector:
 block = connector.GetParentBlock()
 if block not in blocks:
 blocks.append(block)
 # Calculate a square around the end point of this connector
 x = parent_pos[0] + self.Pos.x + self.Direction[0] * CONNECTOR_SIZE - ANCHOR_DISTANCE
 y = parent_pos[1] + self.Pos.y + self.Direction[1] * CONNECTOR_SIZE - ANCHOR_DISTANCE
 width = ANCHOR_DISTANCE * 2 + abs(self.Direction[0]) * CONNECTOR_SIZE
 height = ANCHOR_DISTANCE * 2 + abs(self.Direction[1]) * CONNECTOR_SIZE
-rect = wxRect(x, y, width, height)
+rect = wx.Rect(x, y, width, height)
 return rect.InsideXY(pt.x, pt.y)
 return False
 # Draws the connector
 def Draw(self, dc):
 dc.SetPen(self.Pen)
-dc.SetBrush(wxWHITE_BRUSH)
+dc.SetBrush(wx.WHITE_BRUSH)
 parent_pos = self.ParentBlock.GetPosition()
 if self.Negated:
 # If connector is negated, draw a circle
 xcenter = parent_pos[0] + self.Pos.x + (CONNECTOR_SIZE * self.Direction[0]) / 2
 ycenter = parent_pos[1] + self.Pos.y + (CONNECTOR_SIZE * self.Direction[1]) / 2
 if segment == -1:
 segment = len(self.Segments) - 1
 # The selected segment is reinitialised
 if segment == None:
 if self.StartConnected:
-self.StartConnected.SetPen(wxBLACK_PEN)
+self.StartConnected.SetPen(wx.BLACK_PEN)
 if self.EndConnected:
-self.EndConnected.SetPen(wxBLACK_PEN)
+self.EndConnected.SetPen(wx.BLACK_PEN)
 # The segment selected is the first
 elif segment == 0:
 if self.StartConnected:
-self.StartConnected.SetPen(wxRED_PEN)
+self.StartConnected.SetPen(wx.RED_PEN)
 if self.EndConnected:
 # There is only one segment
 if len(self.Segments) == 1:
-self.EndConnected.SetPen(wxRED_PEN)
+self.EndConnected.SetPen(wx.RED_PEN)
 else:
-self.EndConnected.SetPen(wxBLACK_PEN)
+self.EndConnected.SetPen(wx.BLACK_PEN)
 # The segment selected is the last
 elif segment == len(self.Segments) - 1:
 if self.StartConnected:
-self.StartConnected.SetPen(wxBLACK_PEN)
+self.StartConnected.SetPen(wx.BLACK_PEN)
 if self.EndConnected:
-self.EndConnected.SetPen(wxRED_PEN)
+self.EndConnected.SetPen(wx.RED_PEN)
 self.SelectedSegment = segment
 # Reinitialize the wire points
 def ResetPoints(self):
 if self.StartPoint and self.EndPoint:
 if len(self.Points) > 1:
 minx, minbbxx = min(minx, self.Points[-1].x), min(minbbxx, self.Points[-1].x - end_radius)
 maxx, maxbbxx = max(maxx, self.Points[-1].x), max(maxbbxx, self.Points[-1].x + end_radius)
 miny, minbbxy = min(miny, self.Points[-1].y), min(minbbxy, self.Points[-1].y - end_radius)
 maxy, maxbbxy = max(maxy, self.Points[-1].y), max(maxbbxy, self.Points[-1].y + end_radius)
-self.Pos = wxPoint(minx, miny)
+self.Pos = wx.Point(minx, miny)
-self.Size = wxSize(maxx -minx + 1, maxy - miny + 1)
+self.Size = wx.Size(maxx -minx + 1, maxy - miny + 1)
-self.BoundingBox = wxRect(minbbxx, minbbxy, maxbbxx - minbbxx + 1, maxbbxy - minbbxy + 1)
+self.BoundingBox = wx.Rect(minbbxx, minbbxy, maxbbxx - minbbxx + 1, maxbbxy - minbbxy + 1)
 # Refresh the realpoints that permits to keep the proportionality in wire during resizing
 def RefreshRealPoints(self):
 if len(self.Points) > 0:
 self.RealPoints = []
 # Returns if the point given is on one of the wire segments
 def HitTest(self, pt):
 test = False
 for i in xrange(len(self.Points) - 1):
-rect = wxRect(0, 0, 0, 0)
+rect = wx.Rect(0, 0, 0, 0)
 x1, y1 = self.Points[i].x, self.Points[i].y
 x2, y2 = self.Points[i + 1].x, self.Points[i + 1].y
 # Calculate a rectangle around the segment
-rect = wxRect(min(x1, x2) - ANCHOR_DISTANCE, min(y1, y2) - ANCHOR_DISTANCE,
+rect = wx.Rect(min(x1, x2) - ANCHOR_DISTANCE, min(y1, y2) - ANCHOR_DISTANCE,
 abs(x1 - x2) + 2 * ANCHOR_DISTANCE, abs(y1 - y2) + 2 * ANCHOR_DISTANCE)
 test |= rect.InsideXY(pt.x, pt.y)
 return test
 # Returns the wire start or end point if the point given is on one of them
 def TestPoint(self, pt):
 # Test the wire start point
-rect = wxRect(self.Points[0].x - ANCHOR_DISTANCE, self.Points[0].y - ANCHOR_DISTANCE,
+rect = wx.Rect(self.Points[0].x - ANCHOR_DISTANCE, self.Points[0].y - ANCHOR_DISTANCE,
 2 * ANCHOR_DISTANCE, 2 * ANCHOR_DISTANCE)
 if rect.InsideXY(pt.x, pt.y):
 return 0
 # Test the wire end point
 if len(self.Points) > 1:
-rect = wxRect(self.Points[-1].x - ANCHOR_DISTANCE, self.Points[-1].y - ANCHOR_DISTANCE,
+rect = wx.Rect(self.Points[-1].x - ANCHOR_DISTANCE, self.Points[-1].y - ANCHOR_DISTANCE,
 2 * ANCHOR_DISTANCE, 2 * ANCHOR_DISTANCE)
 if rect.InsideXY(pt.x, pt.y):
 return -1
 return None
 # If wire is not in a Ladder Diagram, first and last segments are excluded
 if 0 < i < len(self.Segments) - 1 or all:
 x1, y1 = self.Points[i].x, self.Points[i].y
 x2, y2 = self.Points[i + 1].x, self.Points[i + 1].y
 # Calculate a rectangle around the segment
-rect = wxRect(min(x1, x2) - ANCHOR_DISTANCE, min(y1, y2) - ANCHOR_DISTANCE,
+rect = wx.Rect(min(x1, x2) - ANCHOR_DISTANCE, min(y1, y2) - ANCHOR_DISTANCE,
 abs(x1 - x2) + 2 * ANCHOR_DISTANCE, abs(y1 - y2) + 2 * ANCHOR_DISTANCE)
 if rect.InsideXY(pt.x, pt.y):
 return i, self.Segments[i]
 return None
 # Define the wire points
 def SetPoints(self, points):
 if len(points) > 1:
-self.Points = [wxPoint(x, y) for x, y in points]
+self.Points = [wx.Point(x, y) for x, y in points]
 # Calculate the start and end directions
 self.StartPoint = [None, vector(self.Points[0], self.Points[1])]
 self.EndPoint = [None, vector(self.Points[-1], self.Points[-2])]
 # Calculate the start and end points
-self.StartPoint[0] = wxPoint(self.Points[0].x + CONNECTOR_SIZE * self.StartPoint[1][0],
+self.StartPoint[0] = wx.Point(self.Points[0].x + CONNECTOR_SIZE * self.StartPoint[1][0],
 self.Points[0].y + CONNECTOR_SIZE * self.StartPoint[1][1])
-self.EndPoint[0] = wxPoint(self.Points[-1].x + CONNECTOR_SIZE * self.EndPoint[1][0],
+self.EndPoint[0] = wx.Point(self.Points[-1].x + CONNECTOR_SIZE * self.EndPoint[1][0],
 self.Points[-1].y + CONNECTOR_SIZE * self.EndPoint[1][1])
 self.Points[0] = self.StartPoint[0]
 self.Points[-1] = self.EndPoint[0]
 # Calculate the segments directions
 self.Segments = []
 return None
 # Returns a list of the position of all wire points
 def GetPoints(self, invert = False):
 points = self.VerifyPoints()
-points[0] = wxPoint(points[0].x - CONNECTOR_SIZE * self.StartPoint[1][0],
+points[0] = wx.Point(points[0].x - CONNECTOR_SIZE * self.StartPoint[1][0],
 points[0].y - CONNECTOR_SIZE * self.StartPoint[1][1])
-points[-1] = wxPoint(points[-1].x - CONNECTOR_SIZE * self.EndPoint[1][0],
+points[-1] = wx.Point(points[-1].x - CONNECTOR_SIZE * self.EndPoint[1][0],
 points[-1].y - CONNECTOR_SIZE * self.EndPoint[1][1])
 # An inversion of the list is asked
 if invert:
 points.reverse()
 return points
 # Update the wire points position by keeping at most possible the current positions
 def GeneratePoints(self, realpoints = True):
 i = 0
 # Calculate the start enad end points with the minimum segment size in the right direction
-end = wxPoint(self.EndPoint[0].x + self.EndPoint[1][0] * MIN_SEGMENT_SIZE,
+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 = wxPoint(self.StartPoint[0].x + self.StartPoint[1][0] * MIN_SEGMENT_SIZE,
+start = wx.Point(self.StartPoint[0].x + self.StartPoint[1][0] * MIN_SEGMENT_SIZE,
 self.StartPoint[0].y + self.StartPoint[1][1] * MIN_SEGMENT_SIZE)
 # Evaluate the point till it's the last
 while i < len(self.Points) - 1:
 # The next point is the last
 if i + 1 == len(self.Points) - 1:
 v_end = vector(self.Points[i], end)
 # The current point is the first
 if i == 0:
 # If the end point is not in the start direction, a point is added
 if v_end != self.Segments[0] or v_end == self.EndPoint[1]:
-self.Points.insert(1, wxPoint(start.x, start.y))
+self.Points.insert(1, wx.Point(start.x, start.y))
 self.Segments.insert(1, DirectionChoice((self.Segments[0][1],
 self.Segments[0][0]), v_end, self.EndPoint[1]))
 # The current point is the second
 elif i == 1:
 # The previous direction and the target direction are mainly opposed, a point is added
 if product(v_end, self.Segments[0]) < 0:
-self.Points.insert(2, wxPoint(self.Points[1].x, self.Points[1].y))
+self.Points.insert(2, wx.Point(self.Points[1].x, self.Points[1].y))
 self.Segments.insert(2, DirectionChoice((self.Segments[1][1],
 self.Segments[1][0]), v_end, self.EndPoint[1]))
 # The previous direction and the end direction are the same or they are
 # perpendiculars and the end direction points towards current segment
 elif product(self.Segments[0], self.EndPoint[1]) >= 0 and product(self.Segments[1], self.EndPoint[1]) <= 0:
 self.Points[1].x = end.x
 if self.Segments[0][1] != 0:
 self.Points[1].y = end.y
 # If the previous direction and the end direction are the same, a point is added
 if product(self.Segments[0], self.EndPoint[1]) > 0:
-self.Points.insert(2, wxPoint(self.Points[1].x, self.Points[1].y))
+self.Points.insert(2, wx.Point(self.Points[1].x, self.Points[1].y))
 self.Segments.insert(2, DirectionChoice((self.Segments[1][1],
 self.Segments[1][0]), v_end, self.EndPoint[1]))
 else:
 # Current point is positioned in the middle of start point
 # and end point on the current direction and a point is added
 if self.Segments[0][0] != 0:
 self.Points[1].x = (end.x + start.x) / 2
 if self.Segments[0][1] != 0:
 self.Points[1].y = (end.y + start.y) / 2
-self.Points.insert(2, wxPoint(self.Points[1].x, self.Points[1].y))
+self.Points.insert(2, wx.Point(self.Points[1].x, self.Points[1].y))
 self.Segments.insert(2, DirectionChoice((self.Segments[1][1],
 self.Segments[1][0]), v_end, self.EndPoint[1]))
 else:
 # The previous direction and the end direction are perpendiculars
 if product(self.Segments[i - 1], self.EndPoint[1]) == 0:
 else:
 test = True
 # If the current point is the third, test if the second
 # point can be aligned with the end point
 if i == 2:
-test_point = wxPoint(self.Points[1].x, self.Points[1].y)
+test_point = wx.Point(self.Points[1].x, self.Points[1].y)
 if self.Segments[1][0] != 0:
 test_point.y = end.y
 if self.Segments[1][1] != 0:
 test_point.x = end.x
-test = norm(vector(self.Points[0], test_point, False)) > MIN_SEGMENT_SIZE
+vector_test = vector(self.Points[0], test_point, False)
+test = norm(vector_test) > MIN_SEGMENT_SIZE and product(self.Segments[0], vector_test) > 0
 # The previous point can be aligned
 if test:
 self.Points[i].x, self.Points[i].y = end.x, end.y
 if self.Segments[i - 1][0] != 0:
 self.Points[i - 1].y = end.y
 # and end point on the current direction and a point is added
 if self.Segments[1][0] != 0:
 self.Points[2].x = (self.Points[1].x + end.x) / 2
 if self.Segments[1][1] != 0:
 self.Points[2].y = (self.Points[1].y + end.y) / 2
-self.Points.insert(3, wxPoint(self.Points[2].x, self.Points[2].y))
+self.Points.insert(3, wx.Point(self.Points[2].x, self.Points[2].y))
 self.Segments.insert(3, DirectionChoice((self.Segments[2][1],
 self.Segments[2][0]), v_end, self.EndPoint[1]))
 else:
 # Current point is aligned with end point
 if self.Segments[i - 1][0] != 0:
 if self.Segments[i - 1][0] != 0:
 self.Points[i].x = (end.x + self.Points[i - 1].x) / 2
 if self.Segments[i - 1][1] != 0:
 self.Points[i].y = (end.y + self.Points[i - 1].y) / 2
 # A point is added
-self.Points.insert(i + 1, wxPoint(self.Points[i].x, self.Points[i].y))
+self.Points.insert(i + 1, wx.Point(self.Points[i].x, self.Points[i].y))
 self.Segments.insert(i + 1, DirectionChoice((self.Segments[i][1],
 self.Segments[i][0]), v_end, self.EndPoint[1]))
 else:
 # Current point is the first, and second is not mainly in the first direction
 if i == 0 and product(vector(start, self.Points[1]), self.Segments[0]) < 0:
 # If first and second directions aren't perpendiculars, a point is added
 if product(self.Segments[0], self.Segments[1]) != 0:
-self.Points.insert(1, wxPoint(start.x, start.y))
+self.Points.insert(1, wx.Point(start.x, start.y))
 self.Segments.insert(1, DirectionChoice((self.Segments[0][1],
 self.Segments[0][0]), vector(start, self.Points[1]), self.Segments[1]))
 else:
 self.Points[1].x, self.Points[1].y = start.x, start.y
 else:
 dir = (0, 0)
 pointx = max(-dir[0] * MIN_SEGMENT_SIZE, min(int(round(point[0] * (width - 1) / float(lastwidth - 1))),
 width - dir[0] * MIN_SEGMENT_SIZE - 1))
 pointy = max(-dir[1] * MIN_SEGMENT_SIZE, min(int(round(point[1] * (height - 1) / float(lastheight - 1))),
 height - dir[1] * MIN_SEGMENT_SIZE - 1))
-self.Points[i] = wxPoint(minx + x + pointx, miny + y + pointy)
+self.Points[i] = wx.Point(minx + x + pointx, miny + y + pointy)
 self.StartPoint[0] = self.Points[0]
 self.EndPoint[0] = self.Points[-1]
 self.GeneratePoints(False)
 # Test if the wire position or size have changed
 if x != 0 and minx == self.Pos.x:
 dir = (0, 0)
 realpointx = max(-dir[0] * MIN_SEGMENT_SIZE, min(int(round(point[0])),
 width - dir[0] * MIN_SEGMENT_SIZE - 1))
 realpointy = max(-dir[1] * MIN_SEGMENT_SIZE, min(int(round(point[1])),
 height - dir[1] * MIN_SEGMENT_SIZE - 1))
-self.Points[i] = wxPoint(minx + x + realpointx, miny + y + realpointy)
+self.Points[i] = wx.Point(minx + x + realpointx, miny + y + realpointy)
 self.StartPoint[0] = self.Points[0]
 self.EndPoint[0] = self.Points[-1]
 self.GeneratePoints(False)
 # Moves the wire start point and update the wire points
 pointy = self.Points[segment].y
 if dir[0] != 0:
 pointx = (self.Points[segment].x + self.Points[segment + 1].x) / 2
 if dir[1] != 0:
 pointy = (self.Points[segment].y + self.Points[segment + 1].y) / 2
-self.Points.insert(segment + 1, wxPoint(pointx, pointy))
+self.Points.insert(segment + 1, wx.Point(pointx, pointy))
 self.Segments.insert(segment + 1, (dir[1], dir[0]))
-self.Points.insert(segment + 2, wxPoint(pointx, pointy))
+self.Points.insert(segment + 2, wx.Point(pointx, pointy))
 self.Segments.insert(segment + 2, dir)
 self.GeneratePoints()
 # Delete the handled segment by removing the two segment points
 def DeleteSegment(self):
 pos = GetScaledEventPosition(event, dc, scaling)
 # Test if a point have been handled
 #result = self.TestPoint(pos)
 #if result != None:
 #    self.Handle = (HANDLE_POINT, result)
-#    self.Parent.SetCursor(wxStockCursor(wxCURSOR_HAND))
+#    self.Parent.SetCursor(wx.StockCursor(wx.CURSOR_HAND))
 #else:
 # Test if a segment have been handled
 result = self.TestSegment(pos)
 if result != None:
 if result[1] in (NORTH, SOUTH):
-self.Parent.SetCursor(wxStockCursor(wxCURSOR_SIZEWE))
+self.Parent.SetCursor(wx.StockCursor(wx.CURSOR_SIZEWE))
 elif result[1] in (EAST, WEST):
-self.Parent.SetCursor(wxStockCursor(wxCURSOR_SIZENS))
+self.Parent.SetCursor(wx.StockCursor(wx.CURSOR_SIZENS))
 self.Handle = (HANDLE_SEGMENT, result)
 # Execute the default method for a graphic element
 else:
 Graphic_Element.OnLeftDown(self, event, dc, scaling)
 self.oldPos = pos
 # Method called when a LeftDClick event have been generated
 def OnLeftDClick(self, event, dc, scaling):
 self.ResetPoints()
 self.GeneratePoints()
+self.RefreshModel()
+self.Parent.RefreshBuffer()
 # Method called when a Motion event have been generated
 def OnMotion(self, event, dc, scaling):
 pos = GetScaledEventPosition(event, dc, scaling)
 if not event.Dragging():
 # Test if a segment has been handled
 result = self.TestSegment(pos)
 if result:
 if result[1] in (NORTH, SOUTH):
-wxCallAfter(self.Parent.SetCursor, wxStockCursor(wxCURSOR_SIZEWE))
+if self.CurrentCursor != 4:
+self.CurrentCursor = 4
+wx.CallAfter(self.Parent.SetCursor, CURSORS[4])
 elif result[1] in (EAST, WEST):
-wxCallAfter(self.Parent.SetCursor, wxStockCursor(wxCURSOR_SIZENS))
+if self.CurrentCursor != 5:
+self.CurrentCursor = 5
+wx.CallAfter(self.Parent.SetCursor, CURSORS[5])
 else:
 # Test if a point has been handled
 #result = self.TestPoint(pos)
 #if result != None:
 #    if result == 0 and self.StartConnected:
 def ProcessDragging(self, movex, movey):
 handle_type, handle = self.Handle
 # A point has been handled
 if handle_type == HANDLE_POINT:
 # Try to connect point to a connector
-new_pos = wxPoint(self.Points[handle].x + movex, self.Points[handle].y + movey)
+new_pos = wx.Point(self.Points[handle].x + movex, self.Points[handle].y + movey)
 connector = self.Parent.FindBlockConnector(new_pos)
 if connector:
 if handle == 0 and self.EndConnected != connector:
 connector.Connect((self, handle))
 self.SetStartPointDirection(connector.GetDirection())
 if self.EndConnected and self.EndPoint[1] in [WEST, NORTH]:
 self.EndConnected.RefreshParentBlock()
 # Draws the wire lines and points
 def Draw(self, dc):
-dc.SetPen(wxBLACK_PEN)
+dc.SetPen(wx.BLACK_PEN)
-dc.SetBrush(wxBLACK_BRUSH)
+dc.SetBrush(wx.BLACK_BRUSH)
 # Draw the start and end points if they are not connected or the mouse is over them
 if len(self.Points) > 0 and (not self.StartConnected or self.OverStart):
 dc.DrawCircle(self.Points[0].x, self.Points[0].y, POINT_RADIUS)
 if len(self.Points) > 1 and (not self.EndConnected or self.OverEnd):
 dc.DrawCircle(self.Points[-1].x, self.Points[-1].y, POINT_RADIUS)
 # Draw the wire lines and the last point (it seems that DrawLines stop before the last point)
 dc.DrawLines(self.Points)
 dc.DrawPoint(self.Points[-1].x, self.Points[-1].y)
 # Draw the segment selected in red
 if self.SelectedSegment != None:
-dc.SetPen(wxRED_PEN)
+dc.SetPen(wx.RED_PEN)
 dc.DrawLine(self.Points[self.SelectedSegment].x, self.Points[self.SelectedSegment].y,
 self.Points[self.SelectedSegment + 1].x, self.Points[self.SelectedSegment + 1].y)
 if self.SelectedSegment == len(self.Segments) - 1:
 dc.DrawPoint(self.Points[-1].x, self.Points[-1].y)
 Graphic_Element.Draw(self, dc)
 # Create a new comment
 def __init__(self, parent, content, id = None):
 Graphic_Element.__init__(self, parent)
 self.Id = id
 self.Content = content
-self.Pos = wxPoint(0, 0)
+self.Pos = wx.Point(0, 0)
-self.Size = wxSize(0, 0)
+self.Size = wx.Size(0, 0)
 # Method for keeping compatibility with others
 def Clean(self):
 pass
 def Delete(self):
 self.Parent.DeleteComment(self)
 # Refresh the comment bounding box
 def RefreshBoundingBox(self):
-self.BoundingBox = wxRect(self.Pos.x, self.Pos.y, self.Size[0] + 1, self.Size[1] + 1)
+self.BoundingBox = wx.Rect(self.Pos.x, self.Pos.y, self.Size[0] + 1, self.Size[1] + 1)
 # Changes the comment size
 def SetSize(self, width, height):
 self.Size.SetWidth(width)
 self.Size.SetHeight(height)
 def GetSize(self):
 return self.Size.GetWidth(), self.Size.GetHeight()
 # Returns the comment minimum size
 def GetMinSize(self):
-dc = wxClientDC(self.Parent)
+dc = wx.ClientDC(self.Parent)
 min_width = 0
 min_height = 0
 # The comment minimum size is the maximum size of words in the content
 for line in self.Content.splitlines():
 for word in line.split(" "):
 # Edit the comment content
 self.Parent.EditCommentContent(self)
 # Draws the comment and its content
 def Draw(self, dc):
-dc.SetPen(wxBLACK_PEN)
+dc.SetPen(wx.BLACK_PEN)
-dc.SetBrush(wxWHITE_BRUSH)
+dc.SetBrush(wx.WHITE_BRUSH)
 # Draws the comment shape
-polygon = [wxPoint(self.Pos.x, self.Pos.y),
+polygon = [wx.Point(self.Pos.x, self.Pos.y),
-wxPoint(self.Pos.x + self.Size[0] - 10, self.Pos.y),
+wx.Point(self.Pos.x + self.Size[0] - 10, self.Pos.y),
-wxPoint(self.Pos.x + self.Size[0], self.Pos.y + 10),
+wx.Point(self.Pos.x + self.Size[0], self.Pos.y + 10),
-wxPoint(self.Pos.x + self.Size[0], self.Pos.y + self.Size[1] + 1),
+wx.Point(self.Pos.x + self.Size[0], self.Pos.y + self.Size[1] + 1),
-wxPoint(self.Pos.x, self.Pos.y + self.Size[1] + 1)]
+wx.Point(self.Pos.x, self.Pos.y + self.Size[1] + 1)]
 dc.DrawPolygon(polygon)
-lines = [wxPoint(self.Pos.x + self.Size[0] - 10, self.Pos.y),
+lines = [wx.Point(self.Pos.x + self.Size[0] - 10, self.Pos.y),
-wxPoint(self.Pos.x + self.Size[0] - 10, self.Pos.y + 10),
+wx.Point(self.Pos.x + self.Size[0] - 10, self.Pos.y + 10),
-wxPoint(self.Pos.x + self.Size[0], self.Pos.y + 10)]
+wx.Point(self.Pos.x + self.Size[0], self.Pos.y + 10)]
 dc.DrawLines(lines)
 # Draws the comment content
 y = self.Pos.y + 10
 for line in self.Content.splitlines():
 first = True

changeset 64	dd6f693e46a1
parent 60	ef940f442b8d
child 80	c798a68c5560