beremiz: comparison graphics/GraphicCommons.py

equal deleted inserted replaced

-:82bfc75bcd9d
+:105c20fdeb19
 # 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 math import *
 from types import *
 from six.moves import xrange
 import wx
 (2, 3): 5
 }
 def round_scaling(x, n, constraint=0):
-fraction = float(x) / float(n)
+fraction = x / n
 if constraint == -1:
 xround = int(fraction)
 else:
 xround = round(fraction)
 if constraint == 1 and xround < fraction:
 """
 Function that calculates the nearest point of the grid defined by scaling for the given point
 """
 pos = event.GetLogicalPosition(dc)
 if scaling:
-pos.x = round(float(pos.x) / float(scaling[0])) * scaling[0]
+pos.x = round(pos.x / scaling[0]) * scaling[0]
-pos.y = round(float(pos.y) / float(scaling[1])) * scaling[1]
+pos.y = round(pos.y / scaling[1]) * scaling[1]
 return pos
 def DirectionChoice(v_base, v_target, dir_target):
 """
 scalex, scaley = dc.GetUserScale()
 pos = event.GetPosition()
 pt = wx.Point(*self.Parent.CalcUnscrolledPosition(pos.x, pos.y))
 left = (self.BoundingBox.x - 2) * scalex - HANDLE_SIZE
-center = (self.BoundingBox.x + self.BoundingBox.width / 2) * scalex - HANDLE_SIZE / 2
+center = (self.BoundingBox.x + self.BoundingBox.width // 2) * scalex - HANDLE_SIZE // 2
 right = (self.BoundingBox.x + self.BoundingBox.width + 2) * scalex
 top = (self.BoundingBox.y - 2) * scaley - HANDLE_SIZE
-middle = (self.BoundingBox.y + self.BoundingBox.height / 2) * scaley - HANDLE_SIZE / 2
+middle = (self.BoundingBox.y + self.BoundingBox.height / 2) * scaley - HANDLE_SIZE // 2
 bottom = (self.BoundingBox.y + self.BoundingBox.height + 2) * scaley
 extern_rect = wx.Rect(left, top, right + HANDLE_SIZE - left, bottom + HANDLE_SIZE - top)
 intern_rect = wx.Rect(left + HANDLE_SIZE, top + HANDLE_SIZE, right - left - HANDLE_SIZE, bottom - top - HANDLE_SIZE)
 dc.SetUserScale(1, 1)
 dc.SetPen(MiterPen(wx.BLACK))
 dc.SetBrush(wx.BLACK_BRUSH)
 left = (self.BoundingBox.x - 2) * scalex - HANDLE_SIZE
-center = (self.BoundingBox.x + self.BoundingBox.width / 2) * scalex - HANDLE_SIZE / 2
+center = (self.BoundingBox.x + self.BoundingBox.width // 2) * scalex - HANDLE_SIZE // 2
 right = (self.BoundingBox.x + self.BoundingBox.width + 2) * scalex
 top = (self.BoundingBox.y - 2) * scaley - HANDLE_SIZE
-middle = (self.BoundingBox.y + self.BoundingBox.height / 2) * scaley - HANDLE_SIZE / 2
+middle = (self.BoundingBox.y + self.BoundingBox.height // 2) * scaley - HANDLE_SIZE // 2
 bottom = (self.BoundingBox.y + self.BoundingBox.height + 2) * scaley
 for x, y in [(left, top), (center, top), (right, top),
 (left, middle), (right, middle),
 (left, bottom), (center, bottom), (right, bottom)]:
 width, height = element.GetSize()
 movex = movey = 0
 if horizontally == ALIGN_LEFT:
 movex = minx - posx
 elif horizontally == ALIGN_CENTER:
-movex = (maxx + minx - width) / 2 - posx
+movex = (maxx + minx - width) // 2 - posx
 elif horizontally == ALIGN_RIGHT:
 movex = maxx - width - posx
 if vertically == ALIGN_TOP:
 movey = miny - posy
 elif vertically == ALIGN_MIDDLE:
-movey = (maxy + miny - height) / 2 - posy
+movey = (maxy + miny - height) // 2 - posy
 elif vertically == ALIGN_BOTTOM:
 movey = maxy - height - posy
 if movex != 0 or movey != 0:
 element.Move(movex, movey)
 element.RefreshModel()
 if self.ValueSize is not None:
 width, height = self.ValueSize
 rect = rect.Union(
 wx.Rect(
 parent_pos[0] + self.Pos.x + CONNECTOR_SIZE * self.Direction[0] +
-width * (self.Direction[0] - 1) / 2,
+width * (self.Direction[0] - 1) // 2,
 parent_pos[1] + self.Pos.y + CONNECTOR_SIZE * self.Direction[1] +
 height * (self.Direction[1] - 1),
 width, height))
 return rect
 else:
 name_size = self.NameSize
 if self.Negated:
 # If connector is negated, draw a circle
-xcenter = parent_pos[0] + self.Pos.x + (CONNECTOR_SIZE * self.Direction[0]) / 2
+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
+ycenter = parent_pos[1] + self.Pos.y + (CONNECTOR_SIZE * self.Direction[1]) // 2
-dc.DrawCircle(xcenter, ycenter, CONNECTOR_SIZE / 2)
+dc.DrawCircle(xcenter, ycenter, CONNECTOR_SIZE // 2)
 else:
 xstart = parent_pos[0] + self.Pos.x
 ystart = parent_pos[1] + self.Pos.y
 if self.Edge == "rising":
 # If connector has a rising edge, draw a right arrow
 else:
 xend = xstart + CONNECTOR_SIZE * self.Direction[0]
 yend = ystart + CONNECTOR_SIZE * self.Direction[1]
 dc.DrawLine(xstart + self.Direction[0], ystart + self.Direction[1], xend, yend)
 if self.Direction[0] != 0:
-ytext = parent_pos[1] + self.Pos.y - name_size[1] / 2
+ytext = parent_pos[1] + self.Pos.y - name_size[1] // 2
 if self.Direction[0] < 0:
 xtext = parent_pos[0] + self.Pos.x + 5
 else:
 xtext = parent_pos[0] + self.Pos.x - (name_size[0] + 5)
 if self.Direction[1] != 0:
-xtext = parent_pos[0] + self.Pos.x - name_size[0] / 2
+xtext = parent_pos[0] + self.Pos.x - name_size[0] // 2
 if self.Direction[1] < 0:
 ytext = parent_pos[1] + self.Pos.y + 5
 else:
 ytext = parent_pos[1] + self.Pos.y - (name_size[1] + 5)
 # Draw the text
 self.ValueSize = self.ParentBlock.Parent.GetMiniTextExtent(self.ComputedValue)
 if self.ValueSize is not None:
 width, height = self.ValueSize
 dc.DrawText(self.ComputedValue,
 parent_pos[0] + self.Pos.x + CONNECTOR_SIZE * self.Direction[0] +
-width * (self.Direction[0] - 1) / 2,
+width * (self.Direction[0] - 1) // 2,
 parent_pos[1] + self.Pos.y + CONNECTOR_SIZE * self.Direction[1] +
 height * (self.Direction[1] - 1))
 dc.SetFont(self.ParentBlock.Parent.GetFont())
 dc.SetTextForeground(wx.BLACK)
 if self.ValueSize is None and isinstance(self.ComputedValue, (StringType, UnicodeType)):
 self.ValueSize = self.Parent.GetMiniTextExtent(self.ComputedValue)
 if self.ValueSize is not None:
 width, height = self.ValueSize
 if self.BoundingBox[2] > width * 4 or self.BoundingBox[3] > height * 4:
-x = self.Points[0].x + width * self.StartPoint[1][0] / 2
+x = self.Points[0].x + width * self.StartPoint[1][0] // 2
 y = self.Points[0].y + height * (self.StartPoint[1][1] - 1)
 rect = rect.Union(wx.Rect(x, y, width, height))
-x = self.Points[-1].x + width * self.EndPoint[1][0] / 2
+x = self.Points[-1].x + width * self.EndPoint[1][0] // 2
 y = self.Points[-1].y + height * (self.EndPoint[1][1] - 1)
 rect = rect.Union(wx.Rect(x, y, width, height))
 else:
-middle = len(self.Segments) / 2 + len(self.Segments) % 2 - 1
+middle = len(self.Segments) // 2 + len(self.Segments) % 2 - 1
-x = (self.Points[middle].x + self.Points[middle + 1].x - width) / 2
+x = (self.Points[middle].x + self.Points[middle + 1].x - width) // 2
 if self.BoundingBox[3] > height and self.Segments[middle] in [NORTH, SOUTH]:
-y = (self.Points[middle].y + self.Points[middle + 1].y - height) / 2
+y = (self.Points[middle].y + self.Points[middle + 1].y - height) // 2
 else:
 y = self.Points[middle].y - height
 rect = rect.Union(wx.Rect(x, y, width, height))
 return rect
 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
+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[1].y = (end.y + start.y) // 2
 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:
 self.Segments[i] = (-self.EndPoint[1][0], -self.EndPoint[1][1])
 else:
 # Current point is positioned in the middle of previous point
 # 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
+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[2].y = (self.Points[1].y + end.y) // 2
 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]),
 # If previous direction and end direction are opposed
 if product(self.Segments[i - 1], self.EndPoint[1]) < 0:
 # Current point is positioned in the middle of previous point
 # and end point on the current direction
 if self.Segments[i - 1][0] != 0:
-self.Points[i].x = (end.x + self.Points[i - 1].x) / 2
+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
+self.Points[i].y = (end.y + self.Points[i - 1].y) // 2
 # A point is added
 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],
 dir = self.StartPoint[1]
 elif i == len(self.Points) - 1:
 dir = self.EndPoint[1]
 else:
 dir = (0, 0)
-pointx = max(-dir[0] * MIN_SEGMENT_SIZE, min(int(round(point[0] * width / float(max(lastwidth, 1)))),
+pointx = max(-dir[0] * MIN_SEGMENT_SIZE, min(int(round(point[0] * width / max(lastwidth, 1))),
 width - dir[0] * MIN_SEGMENT_SIZE))
-pointy = max(-dir[1] * MIN_SEGMENT_SIZE, min(int(round(point[1] * height / float(max(lastheight, 1)))),
+pointy = max(-dir[1] * MIN_SEGMENT_SIZE, min(int(round(point[1] * height / max(lastheight, 1))),
 height - dir[1] * MIN_SEGMENT_SIZE))
 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)
 # Calculate the real points from the new size, it's important for
 # keeping a proportionality in the points position with the size
 # during a resize dragging
 for i, point in enumerate(self.RealPoints):
 if not (i == 0 and self.StartConnected) and not (i == len(self.Points) - 1 and self.EndConnected):
-point[0] = point[0] * width / float(max(lastwidth, 1))
+point[0] = point[0] * width / max(lastwidth, 1)
-point[1] = point[1] * height / float(max(lastheight, 1))
+point[1] = point[1] * height / max(lastheight, 1)
 # Calculate the correct position of the points from real points
 for i, point in enumerate(self.RealPoints):
 if not (i == 0 and self.StartConnected) and not (i == len(self.Points) - 1 and self.EndConnected):
 if i == 0:
 dir = self.StartPoint[1]
 segment, dir = handle
 if len(self.Segments) > 1:
 pointx = self.Points[segment].x
 pointy = self.Points[segment].y
 if dir[0] != 0:
-pointx = (self.Points[segment].x + self.Points[segment + 1].x) / 2
+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
+pointy = (self.Points[segment].y + self.Points[segment + 1].y) // 2
 self.Points.insert(segment + 1, wx.Point(pointx, pointy))
 self.Segments.insert(segment + 1, (dir[1], dir[0]))
 self.Points.insert(segment + 2, wx.Point(pointx, pointy))
 self.Segments.insert(segment + 2, dir)
 else:
 p1x = p2x = self.Points[segment].x
 p1y = p2y = self.Points[segment].y
 if dir[0] != 0:
-p1x = (2 * self.Points[segment].x + self.Points[segment + 1].x) / 3
+p1x = (2 * self.Points[segment].x + self.Points[segment + 1].x) // 3
-p2x = (self.Points[segment].x + 2 * self.Points[segment + 1].x) / 3
+p2x = (self.Points[segment].x + 2 * self.Points[segment + 1].x) // 3
 if dir[1] != 0:
-p1y = (2 * self.Points[segment].y + self.Points[segment + 1].y) / 3
+p1y = (2 * self.Points[segment].y + self.Points[segment + 1].y) // 3
-p2y = (self.Points[segment].y + 2 * self.Points[segment + 1].y) / 3
+p2y = (self.Points[segment].y + 2 * self.Points[segment + 1].y) // 3
 self.Points.insert(segment + 1, wx.Point(p1x, p1y))
 self.Segments.insert(segment + 1, (dir[1], dir[0]))
 self.Points.insert(segment + 2, wx.Point(p1x, p1y))
 self.Segments.insert(segment + 2, dir)
 self.Points.insert(segment + 3, wx.Point(p2x, p2y))
 def OnLeftDClick(self, event, dc, scaling):
 rect = self.GetRedrawRect()
 if event.ControlDown():
 direction = (self.StartPoint[1], self.EndPoint[1])
 if direction in [(EAST, WEST), (WEST, EAST)]:
-avgy = (self.StartPoint[0].y + self.EndPoint[0].y) / 2
+avgy = (self.StartPoint[0].y + self.EndPoint[0].y) // 2
 if scaling is not None:
-avgy = round(float(avgy) / scaling[1]) * scaling[1]
+avgy = round(avgy / scaling[1]) * scaling[1]
 if self.StartConnected is not None:
 movey = avgy - self.StartPoint[0].y
 startblock = self.StartConnected.GetParentBlock()
 startblock.Move(0, movey)
 startblock.RefreshModel()
 rect.Union(endblock.GetRedrawRect(0, movey))
 else:
 self.MoveEndPoint(wx.Point(self.EndPoint[0].x, avgy))
 self.Parent.RefreshBuffer()
 elif direction in [(NORTH, SOUTH), (SOUTH, NORTH)]:
-avgx = (self.StartPoint[0].x + self.EndPoint[0].x) / 2
+avgx = (self.StartPoint[0].x + self.EndPoint[0].x) // 2
 if scaling is not None:
-avgx = round(float(avgx) / scaling[0]) * scaling[0]
+avgx = round(avgx / scaling[0]) * scaling[0]
 if self.StartConnected is not None:
 movex = avgx - self.StartPoint[0].x
 startblock = self.StartConnected.GetParentBlock()
 startblock.Move(movex, 0)
 startblock.RefreshModel()
 if self.ValueSize is None and isinstance(self.ComputedValue, (StringType, UnicodeType)):
 self.ValueSize = self.Parent.GetMiniTextExtent(self.ComputedValue)
 if self.ValueSize is not None:
 width, height = self.ValueSize
 if self.BoundingBox[2] > width * 4 or self.BoundingBox[3] > height * 4:
-x = self.Points[0].x + width * (self.StartPoint[1][0] - 1) / 2
+x = self.Points[0].x + width * (self.StartPoint[1][0] - 1) // 2
 y = self.Points[0].y + height * (self.StartPoint[1][1] - 1)
 dc.DrawText(self.ComputedValue, x, y)
-x = self.Points[-1].x + width * (self.EndPoint[1][0] - 1) / 2
+x = self.Points[-1].x + width * (self.EndPoint[1][0] - 1) // 2
 y = self.Points[-1].y + height * (self.EndPoint[1][1] - 1)
 dc.DrawText(self.ComputedValue, x, y)
 else:
-middle = len(self.Segments) / 2 + len(self.Segments) % 2 - 1
+middle = len(self.Segments) // 2 + len(self.Segments) % 2 - 1
-x = (self.Points[middle].x + self.Points[middle + 1].x - width) / 2
+x = (self.Points[middle].x + self.Points[middle + 1].x - width) // 2
 if self.BoundingBox[3] > height and self.Segments[middle] in [NORTH, SOUTH]:
-y = (self.Points[middle].y + self.Points[middle + 1].y - height) / 2
+y = (self.Points[middle].y + self.Points[middle + 1].y - height) // 2
 else:
 y = self.Points[middle].y - height
 dc.DrawText(self.ComputedValue, x, y)
 dc.SetFont(self.Parent.GetFont())
 dc.SetTextForeground(wx.BLACK)

changeset 2437	105c20fdeb19
parent 2432	dbc065a2f7a5
child 2450	5024c19ca8f0