Fix an OverflowError during rapid kinetic scrolling (#47)

This is caused by PyQt not enforcing C++ integer size restrictions on
QPoint coordinates, which we correct for by implementing our own
overflow-safe Point type.

Fixes frescobaldi/frescobaldi#2130.

Author: bmjcode

qpageview/scrollarea.py

@@ -25,7 +25,9 @@
 
 import math
 
-from PyQt6.QtCore import QPoint, QRect, QSize, Qt
+# we use util.Point here rather than raw QPoint to prevent an overflow
+# during rapid kinetic scrolling (Frescobaldi issue #2130)
+from PyQt6.QtCore import QRect, QSize, Qt
 from PyQt6.QtWidgets import QAbstractScrollArea
 
 from . import util
@@ -80,7 +82,7 @@ def areaPos(self):
             left = -self.horizontalScrollBar().value()
         if top < 0:
             top = -self.verticalScrollBar().value()
-        return QPoint(left, top)
+        return util.Point(left, top)
 
     def visibleArea(self):
         """Return a rectangle describing the part of the area that is visible."""
@@ -107,7 +109,7 @@ def offsetToEnsureVisible(self, rect):
             dx = rect.right() - area.right()
         if rect.left() < area.left() + dx:
             dx = rect.left() - area.left()
-        return QPoint(dx, dy)
+        return util.Point(dx, dy)
 
     def ensureVisible(self, rect, margins=None, allowKinetic=True):
         """Performs the minimal scroll to make rect visible.
@@ -152,7 +154,7 @@ def scrollOffset(self):
         """Return the current scroll offset."""
         x = self.horizontalScrollBar().value()
         y = self.verticalScrollBar().value()
-        return QPoint(x, y)
+        return util.Point(x, y)
 
     def canScrollBy(self, diff):
         """Does not scroll, but return the actual distance the View would scroll.
@@ -165,7 +167,7 @@ def canScrollBy(self, diff):
 
         x = min(max(0, hbar.value() + diff.x()), hbar.maximum())
         y = min(max(0, vbar.value() + diff.y()), vbar.maximum())
-        return QPoint(x - hbar.value(), y - vbar.value())
+        return util.Point(x - hbar.value(), y - vbar.value())
 
     def scrollForDragging(self, pos):
         """Slowly scroll the View if pos is close to the edge of the viewport.
@@ -180,7 +182,7 @@ def scrollForDragging(self, pos):
         dy = pos.y() - viewport.top() - 12
         if dy >= 0:
             dy = max(0, pos.y() - viewport.bottom() + 12)
-        self.steadyScroll(QPoint(dx*10, dy*10))
+        self.steadyScroll(util.Point(dx*10, dy*10))
 
     def scrollTo(self, pos):
         """Scroll the View to get pos (QPoint) in the top left corner (if possible).
@@ -204,7 +206,7 @@ def scrollBy(self, diff):
         y = vbar.value()
         vbar.setValue(vbar.value() + diff.y())
         y = vbar.value() - y
-        return QPoint(x, y)
+        return util.Point(x, y)
 
     def kineticScrollTo(self, pos):
         """Scroll the View to get pos (QPoint) in the top left corner (if possible).
@@ -328,7 +330,7 @@ def mouseReleaseEvent(self, ev):
                 diffy = int(sy * (sy + 1) / 2)
                 if speed.x() < 0: diffx = -diffx
                 if speed.y() < 0: diffy = -diffy
-                self.kineticScrollBy(QPoint(diffx, diffy))
+                self.kineticScrollBy(util.Point(diffx, diffy))
             self._dragPos = None
             self._dragTime = None
             self._dragSpeed = None
@@ -348,23 +350,23 @@ def keyPressEvent(self, ev):
         # add Home and End, even in non-kinetic mode
         scroll = self.kineticScrollBy if self.kineticScrollingEnabled else self.scrollBy
         if ev.key() == Qt.Key.Key_Home:
-            scroll(QPoint(0, -vbar.value()))
+            scroll(util.Point(0, -vbar.value()))
         elif ev.key() == Qt.Key.Key_End:
-            scroll(QPoint(0, vbar.maximum() - vbar.value()))
+            scroll(util.Point(0, vbar.maximum() - vbar.value()))
         elif self.kineticScrollingEnabled:
             # make arrow keys and PgUp and PgDn kinetic
             if ev.key() == Qt.Key.Key_PageDown:
-                self.kineticAddDelta(QPoint(0, vbar.pageStep()))
+                self.kineticAddDelta(util.Point(0, vbar.pageStep()))
             elif ev.key() == Qt.Key.Key_PageUp:
-                self.kineticAddDelta(QPoint(0, -vbar.pageStep()))
+                self.kineticAddDelta(util.Point(0, -vbar.pageStep()))
             elif ev.key() == Qt.Key.Key_Down:
-                self.kineticAddDelta(QPoint(0, vbar.singleStep()))
+                self.kineticAddDelta(util.Point(0, vbar.singleStep()))
             elif ev.key() == Qt.Key.Key_Up:
-                self.kineticAddDelta(QPoint(0, -vbar.singleStep()))
+                self.kineticAddDelta(util.Point(0, -vbar.singleStep()))
             elif ev.key() == Qt.Key.Key_Left:
-                self.kineticAddDelta(QPoint(-hbar.singleStep(), 0))
+                self.kineticAddDelta(util.Point(-hbar.singleStep(), 0))
             elif ev.key() == Qt.Key.Key_Right:
-                self.kineticAddDelta(QPoint(hbar.singleStep(), 0))
+                self.kineticAddDelta(util.Point(hbar.singleStep(), 0))
             else:
                 super().keyPressEvent(ev)
         else:
@@ -416,7 +418,7 @@ def step(self):
         dy += dy1
 
         # scroll in the right direction
-        diff = QPoint(-dx if x < 0 else dx, -dy if y < 0 else dy)
+        diff = util.Point(-dx if x < 0 else dx, -dy if y < 0 else dy)
         return diff
 
     def finished(self):
@@ -465,7 +467,7 @@ def scrollBy(self, diff):
         self._x = sx
         self._y = sy
         # the offset is accounted for in the first step
-        self._offset = QPoint(offx, offy)
+        self._offset = util.Point(offx, offy)
 
     def remainingDistance(self):
         """Return the remaining distance."""
@@ -477,15 +479,15 @@ def remainingDistance(self):
         dy = sy * (sy + 1) // 2
         if self._y < 0:
             dy = -dy
-        return QPoint(dx, dy)
+        return util.Point(dx, dy)
 
     def remainingTicks(self):
         """Return the remaining ticks of this scroll."""
         return max(abs(self._x), abs(self._y))
 
     def step(self):
         """Return a QPoint indicating the diff to scroll in this step."""
-        ret = QPoint(self._x, self._y)
+        ret = util.Point(self._x, self._y)
         if self._offset:
             ret += self._offset
             self._offset = None

qpageview/util.py

@@ -179,6 +179,24 @@ def mouseReleaseEvent(self, ev):
         super().mouseReleaseEvent(ev)
 
 
+class Point(QPoint):
+    """An overflow-safe QPoint.
+
+    This works around an oversight in PyQt, which does not
+    constrain integer arguments to fixed sizes as used in C++,
+    causing an OverflowError when those limits are exceeded.
+
+    """
+    def __init__(self, x, y):
+        super().__init__(clamp_int32(x), clamp_int32(y))
+
+    def setX(self, x):
+        super().setX(clamp_int32(x))
+
+    def setY(self, y):
+        super().setY(clamp_int32(y))
+
+
 def rotate(matrix, rotation, width, height, dest=False):
     """Rotate matrix inside a rectangular area of width x height.
 
@@ -243,6 +261,15 @@ def alignrect(rect, point, alignment=Qt.AlignmentFlag.AlignCenter):
         rect.moveBottom(point.y())
 
 
+def clamp(x, lower, upper):
+    """Return x bounded such that lower <= x <= upper."""
+    return lower if x < lower else upper if x > upper else x
+
+def clamp_int32(x):
+    """Return x bounded to the range of a 32-bit signed integer."""
+    return clamp(x, -2**31, 2**31 - 1)
+
+
 # Found at: https://stackoverflow.com/questions/1986152/why-doesnt-python-have-a-sign-function
 def sign(x):
     """Return the sign of x: -1 if x < 0, 0 if x == 0, or 1 if x > 0."""