gitpane 1.0.0__py3-none-any.whl

gitpane/ui/widget/drop_down_wheel_filter.py

@@ -0,0 +1,32 @@
+"""Keep the mouse wheel from changing the value of any drop-down list of GitPane."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QEvent, QObject
+from PySide6.QtWidgets import QComboBox
+
+if TYPE_CHECKING:
+    from PySide6.QtWidgets import QApplication
+
+
+class DropDownWheelFilter(QObject):
+    """The application event filter that turns the wheel over a drop-down list into a scroll of the form around it."""
+
+    def __init__(self, application: QApplication, owner: QObject) -> None:
+        """Watch every object of the application; the filter only acts on wheel events sent to a drop-down list.
+
+        The filter belongs to ``owner`` rather than to the application: it runs on every event of the application, so it
+        must end with the object that created it instead of outliving it on a shared application.
+        """
+        super().__init__(owner)
+        application.installEventFilter(self)
+
+    def eventFilter(self, watched: QObject, event: QEvent) -> bool:
+        """Refuse the wheel event of a drop-down list and let every other event through."""
+        if event.type() == QEvent.Type.Wheel and isinstance(watched, QComboBox):
+            # Ignoring the event lets Qt scroll the parent without changing a setting under the pointer.
+            event.ignore()
+            return True
+        return False

gitpane/ui/widget/flow_layout.py

@@ -0,0 +1,110 @@
+"""Layout that places items in rows, wrapping them to the available width."""
+
+# Adapted from the principle of Qt's "Flow Layout" example: Qt Widgets has no wrapping layout, and a scroll area
+# only follows a layout's width when that layout answers height-for-width queries.
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QPoint, QRect, QSize, Qt
+from PySide6.QtWidgets import QLayout
+
+from gitpane.config import SPACING_XS
+
+if TYPE_CHECKING:
+    from PySide6.QtWidgets import QLayoutItem, QWidget
+
+# No orientation at all: the layout never asks its parent for more room than its items need.
+NO_EXPANDING_DIRECTION = Qt.Orientation(0)
+
+
+class FlowLayout(QLayout):
+    """Place whole items left to right and wrap them to the available width instead of clipping or shrinking them.
+
+    Used by the emoji keyboard, whose grid follows its window, and by the buttons of the rebase window, which wrap on a
+    narrow screen so every action stays reachable.
+    """
+
+    def __init__(self, parent: QWidget | None = None, spacing_px: int = SPACING_XS) -> None:
+        """Start empty; spacing_px becomes the Qt spacing, the gap between two items both along a row and between rows."""
+        super().__init__(parent)
+        self.items: list[QLayoutItem] = []
+        self.setSpacing(spacing_px)
+
+    def addItem(self, item: QLayoutItem) -> None:
+        """Append an item; Qt calls this for every addWidget."""
+        self.items.append(item)
+
+    def count(self) -> int:
+        """Return how many items the layout holds."""
+        return len(self.items)
+
+    def itemAt(self, index: int) -> QLayoutItem | None:
+        """Return the item at an index, or None past the end as Qt expects."""
+        if 0 <= index < len(self.items):
+            return self.items[index]
+        return None
+
+    def takeAt(self, index: int) -> QLayoutItem | None:
+        """Remove and return the item at an index, or None past the end as Qt expects."""
+        if 0 <= index < len(self.items):
+            return self.items.pop(index)
+        return None
+
+    def expandingDirections(self) -> Qt.Orientation:
+        """Ask for no extra space: the items keep their own size and only the row breaks change."""
+        return NO_EXPANDING_DIRECTION
+
+    def hasHeightForWidth(self) -> bool:
+        """Tell Qt the height depends on the width, which makes a scroll area follow the reflow."""
+        return True
+
+    def heightForWidth(self, width: int) -> int:
+        """Return the height the items need once wrapped to this width, margins included."""
+        return self._arrange(QRect(0, 0, width, 0), apply=False)
+
+    def setGeometry(self, rect: QRect) -> None:
+        """Place the items inside the new rectangle."""
+        super().setGeometry(rect)
+        self._arrange(rect, apply=True)
+
+    def sizeHint(self) -> QSize:
+        """Prefer the minimum size; the real height comes from heightForWidth."""
+        return self.minimumSize()
+
+    def minimumSize(self) -> QSize:
+        """Return the largest shown item plus margins, the narrowest width at which every item still fits; hidden items do not count."""
+        size = QSize()
+        for item in self.items:
+            if item.isEmpty():
+                continue
+            size = size.expandedTo(item.minimumSize())
+        margins = self.contentsMargins()
+        return size + QSize(margins.left() + margins.right(), margins.top() + margins.bottom())
+
+    def _arrange(self, rect: QRect, *, apply: bool) -> int:
+        """Lay the shown items out in rows and return the height used, margins included; with apply False nothing moves.
+
+        A hidden item is skipped, so it leaves no gap. A negative Qt spacing (unset, left to the style) counts as none.
+        """
+        margins = self.contentsMargins()
+        area = rect.adjusted(margins.left(), margins.top(), -margins.right(), -margins.bottom())
+        spacing = max(0, self.spacing())
+        x = area.x()
+        y = area.y()
+        row_height = 0
+        for item in self.items:
+            if item.isEmpty():
+                continue
+            size = item.sizeHint()
+            # An item that would pass the right edge starts the next row, unless the row is still empty.
+            if x + size.width() > area.right() + 1 and row_height > 0:
+                x = area.x()
+                y += row_height + spacing
+                row_height = 0
+            if apply:
+                item.setGeometry(QRect(QPoint(x, y), size))
+            x += size.width() + spacing
+            row_height = max(row_height, size.height())
+        return y + row_height - rect.y() + margins.bottom()