pygpt-net 2.6.60__py3-none-any.whl → 2.6.62__py3-none-any.whl

pygpt_net/ui/dialog/db.py

@@ -6,13 +6,13 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.05 18:00:00                  #
+# Updated Date: 2025.09.26 03:00:00                  #
 # ================================================== #
 
-from PySide6.QtCore import Qt, QTimer, QSignalBlocker
+from PySide6.QtCore import Qt, QTimer, QSignalBlocker, QObject, QEvent
 from PySide6.QtGui import QAction, QIcon, QIntValidator
 from PySide6.QtWidgets import QGridLayout, QScrollArea, QSplitter, QComboBox, QLineEdit, QPushButton, \
-    QHBoxLayout, QVBoxLayout, QLabel, QWidget, QSizePolicy, QCheckBox, QMenuBar, QAbstractItemView, QHeaderView, QStyledItemDelegate
+    QHBoxLayout, QVBoxLayout, QLabel, QWidget, QSizePolicy, QCheckBox, QMenuBar, QAbstractItemView, QHeaderView, QStyledItemDelegate, QMenu, QApplication
 
 from pygpt_net.ui.widget.dialog.db import DatabaseDialog
 from pygpt_net.ui.widget.lists.db import DatabaseList, DatabaseTableModel
@@ -32,6 +32,98 @@ class _FastTextDelegate(QStyledItemDelegate):
         return s
 
 
+class _ContextMenuStyler(QObject):
+    """
+    Ensures that any QMenu spawned from the observed widgets adopts the same
+    application stylesheet, palette and font (e.g. Qt Material), even if
+    the menu is created without a parent or uses platform defaults.
+    The filter is installed only on specific widgets (no app-wide filters).
+    """
+
+    def __init__(self, style_source: QWidget):
+        super().__init__(style_source)
+        self._source = style_source
+        self._scan_timer = QTimer(self)
+        self._scan_timer.setInterval(50)  # fast enough to catch freshly spawned menus
+        self._scan_timer.timeout.connect(self._scan_and_style)
+        self._scan_ticks = 0
+        self._scan_ticks_max = 8  # up to ~400ms window
+
+    def eventFilter(self, obj, event):
+        # Trigger styling round right before/around menu show moments
+        if event.type() in (QEvent.ContextMenu, QEvent.MouseButtonPress, QEvent.KeyPress):
+            if event.type() == QEvent.ContextMenu:
+                self._start_scan()
+            elif event.type() == QEvent.MouseButtonPress and hasattr(event, "button") and event.button() == Qt.RightButton:
+                self._start_scan()
+            elif event.type() == QEvent.KeyPress:
+                key = getattr(event, "key", lambda: None)()
+                mods = getattr(event, "modifiers", lambda: Qt.NoModifier)()
+                if key == Qt.Key_Menu or (key == Qt.Key_F10 and (mods & Qt.ShiftModifier)):
+                    self._start_scan()
+        return False  # do not consume events
+
+    def _start_scan(self):
+        # Start a short, repeated scan to reliably catch the menu top-level window
+        self._scan_ticks = 0
+        if not self._scan_timer.isActive():
+            # immediate pass + scheduled ones
+            QTimer.singleShot(0, self._scan_and_style)
+            self._scan_timer.start()
+
+    def _scan_and_style(self):
+        self._scan_ticks += 1
+        app = QApplication.instance()
+        if app is None:
+            self._scan_timer.stop()
+            return
+
+        found_any = False
+        for w in app.topLevelWidgets():
+            if isinstance(w, QMenu):
+                found_any = True
+                self._ensure_menu_style(w)
+
+        # Stop once we scanned enough frames, or if no menus appear after a short while
+        if self._scan_ticks >= self._scan_ticks_max or (self._scan_ticks >= 2 and not found_any):
+            self._scan_timer.stop()
+
+    def _ensure_menu_style(self, menu: QMenu):
+        # Avoid re-styling the same widget repeatedly
+        if bool(menu.property("_pygpt_menu_styled")):
+            return
+
+        app = QApplication.instance()
+        try:
+            # Apply application-level stylesheet (covers Qt Material CSS selectors for QMenu)
+            if app is not None:
+                ss = app.styleSheet()
+                if ss:
+                    # Assign directly to the menu; do not append, to avoid duplication on repeated shows
+                    menu.setStyleSheet(ss)
+
+            # Copy palette, font and style from the source window to guarantee readable contrast
+            src = self._source.window() if self._source is not None else None
+            if src is None and app is not None:
+                src = app.activeWindow()
+
+            if src is not None:
+                menu.setPalette(src.palette())
+                menu.setFont(src.font())
+                # Also align QStyle to prevent platform defaults from clashing with stylesheet
+                menu.setStyle(src.style())
+
+            # Mark as processed
+            menu.setProperty("_pygpt_menu_styled", True)
+
+            # Update to reflect changes immediately if the menu is already visible
+            if menu.isVisible():
+                menu.update()
+        except Exception:
+            # Fail-safe: never break the context menu on styling issues
+            pass
+
+
 class Database:
     def __init__(self, window=None):
         """
@@ -94,6 +186,9 @@ class Database:
         self.batch_actions_menu.addAction(self.delete_all_action)
         self.batch_actions_menu.addAction(self.truncate_action)
 
+        # Ensure QMenu used by menu bar follows the application/theme styling
+        self._apply_menu_style(self.batch_actions_menu)
+
         layout = QGridLayout()
         layout.addWidget(splitter, 1, 0)
         layout.setMenuBar(self.menu_bar)
@@ -102,6 +197,22 @@ class Database:
         self.window.ui.dialog['debug.db'].setLayout(layout)
         self.window.ui.dialog['debug.db'].setWindowTitle("Debug: Database (SQLite)")
 
+    def _apply_menu_style(self, menu: QMenu):
+        """Ensure QMenu follows application/theme styling consistently."""
+        try:
+            app = QApplication.instance()
+            if app is not None:
+                ss = app.styleSheet()
+                if ss:
+                    menu.setStyleSheet(ss)
+            if self.window is not None:
+                menu.setStyle(self.window.style())
+                menu.setPalette(self.window.palette())
+                menu.setFont(self.window.font())
+        except Exception:
+            # Never break UI if styling fails
+            pass
+
     def _on_splitter_moved(self, pos, index):
         if self._text_viewer is not None:
             self._text_viewer.setUpdatesEnabled(False)
@@ -267,6 +378,34 @@ class DataBrowser(QWidget):
         self.setLayout(main_layout)
 
         view = self.get_list_widget()
+
+        # Robust, local-only context menu styling (no app-wide filters)
+        self._menu_styler = _ContextMenuStyler(self.window if self.window is not None else self)
+        if hasattr(view, "installEventFilter"):
+            view.installEventFilter(self._menu_styler)
+        # Context menu usually originates from the viewport in item views
+        if hasattr(view, "viewport") and callable(view.viewport):
+            vp = view.viewport()
+            if vp is not None and hasattr(vp, "installEventFilter"):
+                vp.installEventFilter(self._menu_styler)
+        # Also watch headers (they may expose their own context menus)
+        if hasattr(view, "horizontalHeader"):
+            hh = view.horizontalHeader()
+            if hh is not None:
+                hh.installEventFilter(self._menu_styler)
+                if hasattr(hh, "viewport"):
+                    hvp = hh.viewport()
+                    if hvp is not None:
+                        hvp.installEventFilter(self._menu_styler)
+        if hasattr(view, "verticalHeader"):
+            vh = view.verticalHeader()
+            if vh is not None:
+                vh.installEventFilter(self._menu_styler)
+                if hasattr(vh, "viewport"):
+                    vvp = vh.viewport()
+                    if vvp is not None:
+                        vvp.installEventFilter(self._menu_styler)
+
         if hasattr(view, "setUniformRowHeights"):
             view.setUniformRowHeights(True)
         if hasattr(view, "setWordWrap"):

pygpt_net/ui/dialog/preset.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.28 09:00:00                  #
+# Updated Date: 2025.09.25 13:04:51                  #
 # ================================================== #
 
 from PySide6.QtCore import Qt
@@ -156,6 +156,8 @@ class Preset(BaseConfigDialog):
         modes = QWidget()
         modes.setLayout(rows_mode)
         modes.setContentsMargins(0, 0, 0, 0)
+        # Ensure modes column never grows taller than its content; avoids creating vertical gap above the splitter.
+        modes.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Maximum)
         self.window.ui.nodes['preset.editor.modes'] = modes
 
         # experts
@@ -208,7 +210,7 @@ class Preset(BaseConfigDialog):
                 # special case with settings icon on right
                 node_layout = QHBoxLayout()
                 builder_btn = QPushButton(QIcon(":/icons/robot.svg"), "")
-                builder_btn.setToolTip("Open Agents Builder (beta)")
+                builder_btn.setToolTip(trans("agent.builder.tooltip"))
                 builder_btn.clicked.connect(lambda: self.window.tools.get("agent_builder").toggle())
                 node_layout.setContentsMargins(0, 0, 0, 0)
                 node_layout.addLayout(options[key])
@@ -265,6 +267,8 @@ class Preset(BaseConfigDialog):
         widget_base = QWidget()
         widget_base.setLayout(rows)
         widget_base.setMinimumWidth(300)
+        # Keep base column at content height; do not stretch vertically.
+        widget_base.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Maximum)
 
         self.window.ui.nodes['preset.editor.experts'].setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
 
@@ -274,12 +278,16 @@ class Preset(BaseConfigDialog):
 
         widget_main = QWidget()
         widget_main.setLayout(main)
+        # Critical: ensure the whole top pane (base + modes) stays at content height.
+        widget_main.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Maximum)
 
         splitter = QSplitter(Qt.Vertical)
         splitter.addWidget(widget_main)
         splitter.addWidget(widget_prompt)
-        splitter.setStretchFactor(0, 1)
-        splitter.setStretchFactor(1, 2)
+        splitter.setChildrenCollapsible(False)  # avoid accidental collapsing of any pane
+        # All extra vertical space goes to bottom (extra agent options); top stays at its sizeHint.
+        splitter.setStretchFactor(0, 0)
+        splitter.setStretchFactor(1, 1)
         self.window.ui.splitters['editor.presets'] = splitter
 
         widget_personalize = QWidget()
@@ -398,13 +406,17 @@ class AvatarWidget(QWidget):
         main_layout.setContentsMargins(0, 0, 0, 0)
 
         current_avatar_label = QLabel(trans("preset.personalize.avatar.current"))
+        # Center the section title for better visual balance.
+        current_avatar_label.setAlignment(Qt.AlignHCenter)
         main_layout.addWidget(current_avatar_label)
 
         self.avatar_preview = QLabel(self)
         self.avatar_preview.setFixedSize(200, 200)
-        self.avatar_preview.setStyleSheet("border: 1px solid gray;")
+        # Keep a visible border, but round it to visually indicate the circular avatar.
+        self.avatar_preview.setStyleSheet("border: 1px solid gray; border-radius: 100px; background: transparent;")
         self.avatar_preview.setAlignment(Qt.AlignCenter)
-        main_layout.addWidget(self.avatar_preview)
+        # Center the avatar widget within the column.
+        main_layout.addWidget(self.avatar_preview, 0, Qt.AlignHCenter)
 
         buttons_layout = QHBoxLayout()
 
@@ -417,6 +429,8 @@ class AvatarWidget(QWidget):
         self.remove_button.setEnabled(False)
         buttons_layout.addWidget(self.remove_button)
         buttons_layout.setContentsMargins(0, 10, 0, 0)
+        # Center the action buttons below the avatar.
+        buttons_layout.setAlignment(Qt.AlignCenter)
 
         main_layout.addLayout(buttons_layout)
         main_layout.setContentsMargins(0, 10, 0, 0)
@@ -440,7 +454,9 @@ class AvatarWidget(QWidget):
         pixmap = QPixmap(file_path)
         if not pixmap.isNull():
             cover_pix = self.get_cover_pixmap(pixmap, self.avatar_preview.width(), self.avatar_preview.height())
-            self.avatar_preview.setPixmap(cover_pix)
+            # Render the avatar as a circular pixmap.
+            circle_pix = self.get_circular_pixmap(cover_pix, self.avatar_preview.width(), self.avatar_preview.height())
+            self.avatar_preview.setPixmap(circle_pix)
         self.remove_button.setEnabled(True)
 
     def enable_remove_button(self, enabled: bool = True):
@@ -472,7 +488,30 @@ class AvatarWidget(QWidget):
         y = (scaled_pix.height() - target_height) // 2
         return scaled_pix.copy(x, y, target_width, target_height)
 
+    def get_circular_pixmap(self, pixmap, target_width: int, target_height: int):
+        """
+        Create a circular version of the given pixmap using an antialiased clip path.
+
+        :param pixmap: Source pixmap already scaled/cropped to target size
+        :param target_width: Target width
+        :param target_height: Target height
+        :return: Circular masked pixmap with transparent corners
+        """
+        from PySide6.QtGui import QPainter, QPainterPath, QPixmap  # local import to avoid altering global imports
+        result = QPixmap(target_width, target_height)
+        result.fill(Qt.transparent)
+
+        painter = QPainter(result)
+        painter.setRenderHint(QPainter.Antialiasing, True)
+        path = QPainterPath()
+        path.addEllipse(0, 0, target_width, target_height)
+        painter.setClipPath(path)
+        painter.drawPixmap(0, 0, pixmap)
+        painter.end()
+
+        return result
+
     def remove_avatar(self):
         """Remove the current avatar image."""
         self.avatar_preview.clear()
-        self.remove_button.setEnabled(False)
+        self.remove_button.setEnabled(False)

pygpt_net/ui/layout/toolbox/presets.py

@@ -1,3 +1,4 @@
+# ui/layout/presets.py
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 # ================================================== #
@@ -6,11 +7,11 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.05 18:00:00                  #
+# Updated Date: 2025.09.26 13:30:00                  #
 # ================================================== #
 
 from PySide6 import QtCore
-from PySide6.QtGui import QStandardItemModel, Qt, QIcon
+from PySide6.QtGui import QStandardItemModel, QStandardItem, Qt, QIcon
 from PySide6.QtWidgets import QVBoxLayout, QHBoxLayout, QPushButton, QWidget, QSizePolicy
 
 from pygpt_net.core.types import (
@@ -113,35 +114,52 @@ class Presets:
         nodes = self.window.ui.nodes
         models = self.window.ui.models
 
-        view = nodes[self.id]
+        view: PresetList = nodes[self.id]
         model = models.get(self.id)
 
-        view.backup_selection()
+        # If view requested selection override, do NOT override it by backup
+        selection_override_ids = getattr(view, "_selection_override_ids", None)
+        if not selection_override_ids:
+            view.backup_selection()
 
         if model is None:
             model = self.create_model(self.window)
             models[self.id] = model
             view.setModel(model)
 
+        # Preserve current scroll position across model rebuild to avoid a visible jump to the top.
+        # This is applied while updates are disabled, then restored just before re-enabling them.
+        try:
+            v = view.verticalScrollBar().value()
+            h = view.horizontalScrollBar().value()
+            view.set_pending_v_scroll(v)
+            view.set_pending_h_scroll(h)
+        except Exception:
+            pass
+
+        # Block user input during model rebuild to avoid crashes on quick clicks
+        view.begin_model_update()
+
+        # Turn off updates to avoid flicker and transient artifacts
         view.setUpdatesEnabled(False)
         try:
-            if not data:
-                model.setRowCount(0)
-            else:
-                count = len(data)
-                model.setRowCount(count)
+            # Rebuild model cleanly to avoid any stale items causing visual glitches
+            model.clear()
+            model.setColumnCount(1)
 
+            if data:
                 is_expert_mode = (mode == MODE_EXPERT)
                 is_agent_mode = (mode == MODE_AGENT)
                 count_experts = self.window.core.experts.count_experts if is_agent_mode else None
                 startswith_current = "current."
 
-                index_fn = model.index
-                set_item_data = model.setItemData
-                display_role = QtCore.Qt.DisplayRole
-                tooltip_role = QtCore.Qt.ToolTipRole
+                role_uuid = QtCore.Qt.UserRole + 1
+                role_id = QtCore.Qt.UserRole + 2
+                role_is_special = QtCore.Qt.UserRole + 3
 
                 for i, (key, item) in enumerate(data.items()):
+                    qitem = QStandardItem()
+
                     name = item.name
                     if is_expert_mode and item.enabled and not key.startswith(startswith_current):
                         name = f"[x] {name}"
@@ -153,9 +171,39 @@ class Presets:
                     prompt = str(item.prompt)
                     tooltip = prompt if len(prompt) <= 80 else f"{prompt[:80]}..."
 
-                    idx = index_fn(i, 0)
-                    set_item_data(idx, {display_role: name, tooltip_role: tooltip})
+                    qitem.setText(name)
+                    qitem.setToolTip(tooltip)
+                    qitem.setData(item.uuid, role_uuid)
+                    qitem.setData(key, role_id)
+                    qitem.setData(key.startswith(startswith_current), role_is_special)
+
+                    # Pin row 0 (no drag, no drop)
+                    # Other rows: drag enabled only; drop is handled by view between rows
+                    if i != 0 and not key.startswith(startswith_current):
+                        flags = Qt.ItemIsEnabled | Qt.ItemIsSelectable | Qt.ItemIsDragEnabled
+                    else:
+                        flags = Qt.ItemIsEnabled | Qt.ItemIsSelectable
+                    qitem.setFlags(flags)
+
+                    model.appendRow(qitem)
         finally:
+            # Apply pending scroll (if any) before re-enabling updates
+            view.apply_pending_scroll()
             view.setUpdatesEnabled(True)
 
-        view.restore_selection()
+        dnd_enabled = bool(self.window.core.config.get('presets.drag_and_drop.enabled'))
+        view.set_dnd_enabled(dnd_enabled)
+
+        # If override requested, force saved selection IDs to those override IDs
+        if selection_override_ids:
+            view._saved_selection_ids = list(selection_override_ids)
+            view._selection_override_ids = None  # consume one-shot override
+
+        # Restore selection by ID (so it follows the same item even if rows moved)
+        view.restore_selection()
+        # Force repaint in case Qt defers layout until next input
+        view.viewport().update()
+
+        # Clear one-shot pending scroll values and re-enable user interaction
+        view.clear_pending_scroll()
+        view.end_model_update()

pygpt_net/ui/main.py

@@ -22,7 +22,7 @@ from pygpt_net.controller import Controller
 from pygpt_net.tools import Tools
 from pygpt_net.ui import UI
 from pygpt_net.ui.widget.textarea.web import ChatWebOutput
-from pygpt_net.utils import get_app_meta, freeze_updates, set_env, has_env, get_env
+from pygpt_net.utils import get_app_meta, freeze_updates, set_env, has_env, get_env, trans
 
 
 class MainWindow(QMainWindow, QtStyleTools):
@@ -356,7 +356,7 @@ class MainWindow(QMainWindow, QtStyleTools):
         self.core.presets.save_all()
         print("Exiting...")
         print("")
-        print("Do you like PyGPT? Support the development of the project: https://pygpt.net/#donate")
+        print(f"{trans('exit.msg')} https://pygpt.net/#donate")
 
     def changeEvent(self, event):
         """

pygpt_net/ui/widget/dialog/confirm.py

@@ -6,9 +6,10 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2024.04.12 10:00:00                  #
+# Updated Date: 2025.09.26 10:00:00                  #
 # ================================================== #
 
+import sys
 from PySide6.QtCore import Qt
 from PySide6.QtWidgets import QDialog, QLabel, QHBoxLayout, QVBoxLayout, QPushButton
 
@@ -32,6 +33,7 @@ class ConfirmDialog(QDialog):
         self.setWindowTitle(trans('dialog.confirm.title'))
         self.setWindowFlags(self.windowFlags() | Qt.WindowStaysOnTopHint)  # always on top
 
+        # Buttons
         self.window.ui.nodes['dialog.confirm.btn.yes'] = QPushButton(trans('dialog.confirm.yes'))
         self.window.ui.nodes['dialog.confirm.btn.yes'].clicked.connect(
             lambda: self.window.controller.dialogs.confirm.accept(self.type, self.id, self.parent_object))
@@ -40,9 +42,24 @@ class ConfirmDialog(QDialog):
         self.window.ui.nodes['dialog.confirm.btn.no'].clicked.connect(
             lambda: self.window.controller.dialogs.confirm.dismiss(self.type, self.id))
 
+        # Always make the neutral action (No/Cancel) the default/active one.
+        # This ensures Enter triggers the safe option by default.
+        self.window.ui.nodes['dialog.confirm.btn.no'].setAutoDefault(True)
+        self.window.ui.nodes['dialog.confirm.btn.no'].setDefault(True)
+        self.window.ui.nodes['dialog.confirm.btn.no'].setFocus()
+        self.window.ui.nodes['dialog.confirm.btn.yes'].setAutoDefault(False)
+        self.window.ui.nodes['dialog.confirm.btn.yes'].setDefault(False)
+
+        # Bottom button row with platform-specific ordering
+        # Windows: affirmative on the left, neutral on the right
+        # Linux/macOS: neutral on the left, affirmative on the right
         bottom = QHBoxLayout()
-        bottom.addWidget(self.window.ui.nodes['dialog.confirm.btn.no'])
-        bottom.addWidget(self.window.ui.nodes['dialog.confirm.btn.yes'])
+        if self._affirmative_on_left():
+            bottom.addWidget(self.window.ui.nodes['dialog.confirm.btn.yes'])
+            bottom.addWidget(self.window.ui.nodes['dialog.confirm.btn.no'])
+        else:
+            bottom.addWidget(self.window.ui.nodes['dialog.confirm.btn.no'])
+            bottom.addWidget(self.window.ui.nodes['dialog.confirm.btn.yes'])
 
         self.layout = QVBoxLayout()
         self.message = QLabel("")
@@ -54,6 +71,13 @@ class ConfirmDialog(QDialog):
         self.layout.addLayout(bottom)
         self.setLayout(self.layout)
 
+    def _affirmative_on_left(self) -> bool:
+        """
+        Decide button order depending on the platform.
+        Returns True on Windows, False otherwise (Linux/macOS).
+        """
+        return sys.platform.startswith('win')
+
     def closeEvent(self, event):
         """
         Close event handler

pygpt_net/ui/widget/draw/painter.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.02 15:00:00                  #
+# Updated Date: 2025.09.26 12:00:00                  #
 # ================================================== #
 
 import datetime
@@ -98,6 +98,11 @@ class PainterWidget(QWidget):
         self._autoScrollMinSpeed = 2           # px per tick (min)
         self._autoScrollMaxSpeed = 18          # px per tick (max)
 
+        # Pan (middle mouse) state
+        self._panning = False
+        self._panLastGlobalPos = QPoint()
+        self._cursorBeforePan = None  # store/restore cursor shape while panning
+
         # Actions
         self._act_undo = QAction(QIcon(":/icons/undo.svg"), trans('action.undo'), self)
         self._act_undo.triggered.connect(self.undo)
@@ -1084,6 +1089,69 @@ class PainterWidget(QWidget):
             if scrolled or dx != 0 or dy != 0:
                 self.update()
 
+    # ---------- Pan (middle mouse drag) ----------
+
+    def _can_pan(self) -> bool:
+        """
+        Return True if widget is inside a scroll area and content is scrollable.
+        """
+        self._find_scroll_area()
+        if self._scrollArea is None:
+            return False
+        hbar = self._scrollArea.horizontalScrollBar()
+        vbar = self._scrollArea.verticalScrollBar()
+        h_ok = hbar is not None and hbar.maximum() > hbar.minimum()
+        v_ok = vbar is not None and vbar.maximum() > vbar.minimum()
+        return h_ok or v_ok
+
+    def _start_pan(self, global_pos: QPoint):
+        """
+        Begin view panning with middle mouse button.
+        """
+        if self._panning:
+            return
+        self._panning = True
+        self._panLastGlobalPos = QPoint(global_pos)
+        # Store current cursor to restore later
+        self._cursorBeforePan = QCursor(self.cursor())
+        # Use a closed hand to indicate grabbing the canvas
+        self.setCursor(QCursor(Qt.ClosedHandCursor))
+        self.grabMouse()
+
+    def _update_pan(self, global_pos: QPoint):
+        """
+        Update scrollbars based on mouse movement delta in global coordinates.
+        """
+        if not self._panning or self._scrollArea is None:
+            return
+        dx = global_pos.x() - self._panLastGlobalPos.x()
+        dy = global_pos.y() - self._panLastGlobalPos.y()
+        self._panLastGlobalPos = QPoint(global_pos)
+
+        hbar = self._scrollArea.horizontalScrollBar()
+        vbar = self._scrollArea.verticalScrollBar()
+
+        # Dragging the content to the right should reveal the left side -> subtract deltas
+        if hbar is not None and hbar.maximum() > hbar.minimum():
+            hbar.setValue(int(max(hbar.minimum(), min(hbar.maximum(), hbar.value() - dx))))
+        if vbar is not None and vbar.maximum() > vbar.minimum():
+            vbar.setValue(int(max(vbar.minimum(), min(vbar.maximum(), vbar.value() - dy))))
+
+    def _end_pan(self):
+        """
+        End panning and restore previous cursor.
+        """
+        if not self._panning:
+            return
+        self._panning = False
+        self.releaseMouse()
+        try:
+            if self._cursorBeforePan is not None:
+                # Restore previous cursor (do not guess based on mode/crop)
+                self.setCursor(self._cursorBeforePan)
+        finally:
+            self._cursorBeforePan = None
+
     # ---------- Events ----------
 
     def wheelEvent(self, event):
@@ -1109,6 +1177,14 @@ class PainterWidget(QWidget):
 
         :param event: Event
         """
+        # Middle button: start panning if scrollable
+        if event.button() == Qt.MiddleButton:
+            if not (self.cropping and self._selecting) and not self.drawing and self._can_pan():
+                gp = event.globalPosition().toPoint()
+                self._start_pan(gp)
+                event.accept()
+                return
+
         if event.button() == Qt.LeftButton:
             self._mouseDown = True
             if self.cropping:
@@ -1146,6 +1222,13 @@ class PainterWidget(QWidget):
 
         :param event: Event
         """
+        # Update panning if active
+        if self._panning and (event.buttons() & Qt.MiddleButton):
+            gp = event.globalPosition().toPoint()
+            self._update_pan(gp)
+            event.accept()
+            return
+
         if self.cropping and self._selecting and (event.buttons() & Qt.LeftButton):
             self._selectionRect = QRect(self._selectionStart, self._to_canvas_point(event.position()))
             self.update()
@@ -1175,6 +1258,12 @@ class PainterWidget(QWidget):
 
         :param event: Event
         """
+        # End panning on middle button release
+        if event.button() == Qt.MiddleButton:
+            self._end_pan()
+            event.accept()
+            return
+
         if event.button() in (Qt.LeftButton, Qt.RightButton):
             self._mouseDown = False
             if self.cropping and self._selecting: