pygpt-net 2.6.67__py3-none-any.whl → 2.7.1__py3-none-any.whl

pygpt_net/ui/widget/lists/preset.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.26 12:00:00                  #
+# Updated Date: 2025.12.27 21:00:00                  #
 # ================================================== #
 
 from PySide6.QtCore import QPoint, QItemSelectionModel, Qt, QEventLoop, QTimer, QMimeData
@@ -17,6 +17,7 @@ from pygpt_net.core.types import (
     MODE_EXPERT,
 )
 from pygpt_net.ui.widget.lists.base import BaseList
+    # Keep imports minimal and unchanged
 from pygpt_net.utils import trans
 
 
@@ -56,7 +57,8 @@ class PresetList(BaseList):
         self.setItemsExpandable(False)
         self.setUniformRowHeights(True)
         self.setSelectionBehavior(QAbstractItemView.SelectRows)
-        self.setSelectionMode(QAbstractItemView.SingleSelection)
+        # ExtendedSelection enables Ctrl/Shift multi-select gestures
+        self.setSelectionMode(QAbstractItemView.ExtendedSelection)
 
         # Drag & drop state
         self._dnd_enabled = False
@@ -75,6 +77,14 @@ class PresetList(BaseList):
         self._dragging = False
         self._dragged_was_selected = False
 
+        # Virtual multi-select: suppress single-item business click once (Ctrl/Shift)
+        self._suppress_item_click = False
+        # Flag for "virtual" Ctrl multi-select gesture
+        self._ctrl_multi_active = False
+        self._ctrl_multi_index = None
+        # Guard to detect Shift-click range selection and bypass single-select follow-ups
+        self._was_shift_click = False
+
         # Mark that we already applied selection at drag start (one-shot per DnD)
         self._drag_selection_applied = False
 
@@ -105,6 +115,14 @@ class PresetList(BaseList):
         self._pending_scroll_value = None
         self._pending_refocus_role_id = None
 
+        # RMB-anchored scroll guard (preserve viewport after destructive updates from context menu)
+        self._rmb_anchor_scroll_value = None
+        self._scroll_guard_active = False
+        self._pre_update_scroll_value = 0
+        self._connected_model = None
+        self._model_signals_connected = False
+        self._connect_model_signals_safely()
+
     # -------- Public helpers to protect updates --------
 
     def begin_model_update(self):
@@ -157,7 +175,7 @@ class PresetList(BaseList):
         self._scroll_freeze_timer.start(max(50, int(ms)))
 
     def _apply_pending_scroll(self):
-        """Re-apply saved scroll position when frozen."""
+        """Re-apply saved scroll position when frozen or guard is active."""
         if self._pending_scroll_value is None:
             return
         try:
@@ -177,10 +195,10 @@ class PresetList(BaseList):
 
     def scrollTo(self, index, hint=QAbstractItemView.EnsureVisible):
         """
-        Temporarily suppress automatic scrolling while frozen.
+        Temporarily suppress automatic scrolling while frozen or guard is active.
         This prevents list jumping when selection triggers scrollTo during refresh.
         """
-        if self._scroll_freeze_depth > 0:
+        if self._scroll_freeze_depth > 0 or self._scroll_guard_active:
             self._apply_pending_scroll()
             return
         return super().scrollTo(index, hint)
@@ -224,6 +242,149 @@ class PresetList(BaseList):
                 # Keep pending id for next attempt if apply failed
                 pass
 
+    # --------------------------------------------------------------------------
+    # RMB-anchored scroll guard: capture scroll at context open and restore after delete
+    # --------------------------------------------------------------------------
+
+    def _connect_model_signals_safely(self):
+        """Connect model change signals once to preserve scroll after updates."""
+        model = self.model()
+        if model is None:
+            return
+        if self._connected_model is model and self._model_signals_connected:
+            return
+
+        if self._connected_model is not None and self._connected_model is not model:
+            try:
+                self._connected_model.rowsAboutToBeRemoved.disconnect(self._on_rows_about_to_be_removed)
+            except Exception:
+                pass
+            try:
+                self._connected_model.rowsRemoved.disconnect(self._on_rows_removed)
+            except Exception:
+                pass
+            try:
+                self._connected_model.modelAboutToBeReset.disconnect(self._on_model_about_to_be_reset)
+            except Exception:
+                pass
+            try:
+                self._connected_model.modelReset.disconnect(self._on_model_reset)
+            except Exception:
+                pass
+            try:
+                self._connected_model.layoutAboutToBeChanged.disconnect(self._on_layout_about_to_change)
+            except Exception:
+                pass
+            try:
+                self._connected_model.layoutChanged.disconnect(self._on_layout_changed)
+            except Exception:
+                pass
+
+        try:
+            model.rowsAboutToBeRemoved.connect(self._on_rows_about_to_be_removed)
+        except Exception:
+            pass
+        try:
+            model.rowsRemoved.connect(self._on_rows_removed)
+        except Exception:
+            pass
+        try:
+            model.modelAboutToBeReset.connect(self._on_model_about_to_be_reset)
+        except Exception:
+            pass
+        try:
+            model.modelReset.connect(self._on_model_reset)
+        except Exception:
+            pass
+        try:
+            model.layoutAboutToBeChanged.connect(self._on_layout_about_to_change)
+        except Exception:
+            pass
+        try:
+            model.layoutChanged.connect(self._on_layout_changed)
+        except Exception:
+            pass
+
+        self._connected_model = model
+        self._model_signals_connected = True
+
+    def setModel(self, model):
+        """Reconnect model signals when the view's model is replaced."""
+        super().setModel(model)
+        self._connect_model_signals_safely()
+
+    def _activate_scroll_guard(self, override_value: int | None = None):
+        """Arm guard with provided anchor value (or current) and keep it until updates settle."""
+        try:
+            sb = self.verticalScrollBar()
+        except Exception:
+            sb = None
+        val = None
+        if override_value is not None:
+            val = int(override_value)
+        elif sb is not None:
+            val = sb.value()
+        if val is None:
+            val = 0
+        self._pre_update_scroll_value = val
+        self._pending_scroll_value = val
+        self._scroll_guard_active = True
+
+    def _schedule_scroll_restore(self):
+        """Restore anchored scroll repeatedly to outlast selection-driven scrolls."""
+        if not self._scroll_guard_active:
+            return
+
+        def apply():
+            try:
+                sb = self.verticalScrollBar()
+                if sb is None:
+                    return
+                target = min(self._pre_update_scroll_value, sb.maximum())
+                sb.setValue(target)
+                self._pending_scroll_value = target
+            except Exception:
+                pass
+
+        QTimer.singleShot(0, apply)
+        QTimer.singleShot(25, apply)
+        QTimer.singleShot(75, apply)
+        QTimer.singleShot(150, apply)
+        QTimer.singleShot(300, apply)
+        QTimer.singleShot(600, self._clear_scroll_guard)
+
+    def _clear_scroll_guard(self):
+        """Clear RMB anchor guard."""
+        self._scroll_guard_active = False
+        self._rmb_anchor_scroll_value = None
+
+    # Model signal handlers
+
+    def _on_rows_about_to_be_removed(self, parent, start, end):
+        if self._scroll_guard_active:
+            # guard already armed by action; nothing else to do
+            return
+
+    def _on_rows_removed(self, parent, start, end):
+        if self._scroll_guard_active:
+            self._schedule_scroll_restore()
+
+    def _on_model_about_to_be_reset(self):
+        if self._scroll_guard_active:
+            return
+
+    def _on_model_reset(self):
+        if self._scroll_guard_active:
+            self._schedule_scroll_restore()
+
+    def _on_layout_about_to_change(self):
+        if self._scroll_guard_active:
+            return
+
+    def _on_layout_changed(self):
+        if self._scroll_guard_active:
+            self._schedule_scroll_restore()
+
     # --------------------------------------------------------------------------
 
     def set_dnd_enabled(self, enabled: bool):
@@ -303,6 +464,16 @@ class PresetList(BaseList):
         """Row click handler; select by ID (stable under reordering)."""
         if self._model_updating:
             return
+
+        # Suppress business click after virtual Ctrl/Shift selection
+        if self._suppress_item_click:
+            self._suppress_item_click = False
+            return
+
+        # Ignore business click if multiple rows are selected
+        if self._has_multi_selection():
+            return
+
         index = val
         if not index.isValid():
             return
@@ -333,70 +504,184 @@ class PresetList(BaseList):
         if row >= 0:
             self.window.controller.presets.editor.edit(row)
 
+    # ----------------------------
+    # Selection helpers (multi / single)
+    # ----------------------------
+
+    def _selected_indexes(self):
+        """Return list of selected row indexes (column 0)."""
+        try:
+            return list(self.selectionModel().selectedRows())
+        except Exception:
+            return []
+
+    def _selected_rows(self) -> list[int]:
+        """Return list of selected row numbers."""
+        try:
+            return [ix.row() for ix in self.selectionModel().selectedRows()]
+        except Exception:
+            return []
+
+    def _selected_role_ids(self) -> list[str]:
+        """Return list of selected ROLE_ID (stable IDs)."""
+        try:
+            out = []
+            for ix in self.selectionModel().selectedRows():
+                pid = ix.data(self.ROLE_ID)
+                if pid:
+                    out.append(pid)
+            return out
+        except Exception:
+            return []
+
+    def _has_multi_selection(self) -> bool:
+        """Check whether more than one row is selected."""
+        try:
+            return len(self.selectionModel().selectedRows()) > 1
+        except Exception:
+            return False
+
+    # ----------------------------
+    # Context menu
+    # ----------------------------
+
     def show_context_menu(self, pos: QPoint):
         """Context menu event"""
         if self._model_updating:
             return
+
+        # Capture RMB anchor scroll value at the moment of opening the context menu
+        try:
+            self._rmb_anchor_scroll_value = self.verticalScrollBar().value()
+        except Exception:
+            self._rmb_anchor_scroll_value = None
+
         global_pos = self.viewport().mapToGlobal(pos)
         mode = self.window.core.config.get('mode')
         index = self.indexAt(pos)
-        idx = index.row()
+        idx = index.row() if index.isValid() else -1
+
+        # Gather selection state
+        selected_idx_list = self._selected_indexes()
+        selected_ids = [ix.data(self.ROLE_ID) for ix in selected_idx_list if ix.data(self.ROLE_ID)]
+        selected_rows = [ix.row() for ix in selected_idx_list]
+        multi = len(selected_rows) > 1
 
+        # Allow menu on empty area only when multi-selection is active
+        if not index.isValid() and not multi:
+            return
+
+        # Resolve clicked item (for single)
         preset = None
-        preset_id = None
         if idx >= 0:
             preset_id = self.window.core.presets.get_by_idx(idx, mode)
             if preset_id:
                 preset = self.window.core.presets.items.get(preset_id)
 
-        is_current = idx >= 0 and self.window.controller.presets.is_current(idx)
-        is_special = bool(index.data(self.ROLE_IS_SPECIAL)) if index.isValid() else False
-
-        if idx >= 0:
-            menu = QMenu(self)
-
-            edit_act = QAction(self._ICO_EDIT, trans('preset.action.edit'), menu)
-            edit_act.triggered.connect(lambda checked=False, it=index: self.action_edit(it))
-            menu.addAction(edit_act)
-
-            if mode == MODE_EXPERT and preset and not preset.filename.startswith("current."):
-                if not preset.enabled:
+        # Determine special/current flags for single target
+        is_current_single = idx >= 0 and self.window.controller.presets.is_current(idx)
+        is_special_single = bool(index.data(self.ROLE_IS_SPECIAL)) if index.isValid() else False
+
+        # Build menu
+        menu = QMenu(self)
+
+        # Edit (only for single)
+        edit_act = QAction(self._ICO_EDIT, trans('preset.action.edit'), menu)
+        edit_act.triggered.connect(lambda checked=False, it=index: self.action_edit(it))
+        edit_act.setEnabled(idx >= 0 and not multi)
+        menu.addAction(edit_act)
+
+        # Enable / Disable (single or multi, expert mode; ignore current.*)
+        if mode == MODE_EXPERT:
+            if multi:
+                items = self.window.core.presets.items
+                any_enable = False
+                any_disable = False
+                for ix in selected_idx_list:
+                    pid = ix.data(self.ROLE_ID)
+                    if not pid:
+                        continue
+                    it = items.get(pid)
+                    if not it:
+                        continue
+                    if getattr(it, "filename", "").startswith("current."):
+                        continue
+                    if getattr(it, "enabled", False):
+                        any_disable = True
+                    else:
+                        any_enable = True
+                if any_enable:
                     enable_act = QAction(self._ICO_CHECK, trans('preset.action.enable'), menu)
-                    enable_act.triggered.connect(lambda checked=False, it=index: self.action_enable(it))
+                    enable_act.triggered.connect(lambda checked=False, ids=list(selected_ids): self.action_enable(ids))
                     menu.addAction(enable_act)
-                else:
+                if any_disable:
                     disable_act = QAction(self._ICO_CLOSE, trans('preset.action.disable'), menu)
-                    disable_act.triggered.connect(lambda checked=False, it=index: self.action_disable(it))
+                    disable_act.triggered.connect(lambda checked=False, ids=list(selected_ids): self.action_disable(ids))
                     menu.addAction(disable_act)
-
-            duplicate_act = QAction(self._ICO_COPY, trans('preset.action.duplicate'), menu)
+            else:
+                if preset and not getattr(preset, "filename", "").startswith("current."):
+                    if not getattr(preset, "enabled", False):
+                        enable_act = QAction(self._ICO_CHECK, trans('preset.action.enable'), menu)
+                        enable_act.triggered.connect(lambda checked=False, it=index: self.action_enable(it))
+                        menu.addAction(enable_act)
+                    else:
+                        disable_act = QAction(self._ICO_CLOSE, trans('preset.action.disable'), menu)
+                        disable_act.triggered.connect(lambda checked=False, it=index: self.action_disable(it))
+                        menu.addAction(disable_act)
+
+        # Duplicate (single or multi)
+        duplicate_act = QAction(self._ICO_COPY, trans('preset.action.duplicate'), menu)
+        if multi:
+            duplicate_act.triggered.connect(lambda checked=False, ids=list(selected_ids): self.action_duplicate(ids))
+        else:
             duplicate_act.triggered.connect(lambda checked=False, it=index: self.action_duplicate(it))
 
-            if self._dnd_enabled and not is_current and not is_special:
-                up_act = QAction(self._ICO_UP, trans('common.up'), menu)
-                down_act = QAction(self._ICO_DOWN, trans('common.down'), menu)
-                up_act.setEnabled(idx > 1)
-                down_act.setEnabled(idx < (self.model().rowCount() - 1))
-                up_act.triggered.connect(lambda checked=False, it=index: self.action_move_up(it))
-                down_act.triggered.connect(lambda checked=False, it=index: self.action_move_down(it))
-                menu.addAction(up_act)
-                menu.addAction(down_act)
-
-            if is_current:
-                edit_act.setEnabled(False)
-                restore_act = QAction(self._ICO_UNDO, trans('dialog.editor.btn.defaults'), menu)
-                restore_act.triggered.connect(lambda checked=False, it=index: self.action_restore(it))
-                menu.addAction(restore_act)
-                menu.addAction(duplicate_act)
+        # Up/Down only for single, non-current, non-special, and when DnD is on
+        if not multi and self._dnd_enabled and not is_current_single and not is_special_single and idx >= 0:
+            up_act = QAction(self._ICO_UP, trans('common.up'), menu)
+            down_act = QAction(self._ICO_DOWN, trans('common.down'), menu)
+            up_act.setEnabled(idx > 1)
+            down_act.setEnabled(idx < (self.model().rowCount() - 1))
+            up_act.triggered.connect(lambda checked=False, it=index: self.action_move_up(it))
+            down_act.triggered.connect(lambda checked=False, it=index: self.action_move_down(it))
+            menu.addAction(up_act)
+            menu.addAction(down_act)
+
+        # Restore / Delete depending on current / multi
+        if not multi and is_current_single:
+            edit_act.setEnabled(False)
+            restore_act = QAction(self._ICO_UNDO, trans('dialog.editor.btn.defaults'), menu)
+            restore_act.triggered.connect(lambda checked=False, it=index: self.action_restore(it))
+            menu.addAction(restore_act)
+            menu.addAction(duplicate_act)
+        else:
+            # In multi-selection: disable delete if any current.* or special in selection
+            can_delete_all = True
+            if multi:
+                for ix in selected_idx_list:
+                    pid = ix.data(self.ROLE_ID)
+                    if not pid:
+                        continue
+                    if pid.startswith("current.") or bool(ix.data(self.ROLE_IS_SPECIAL)):
+                        can_delete_all = False
+                        break
+            else:
+                can_delete_all = idx >= 0 and not is_current_single
+
+            delete_act = QAction(self._ICO_DELETE, trans('preset.action.delete'), menu)
+            if multi:
+                delete_act.triggered.connect(lambda checked=False, ids=list(selected_ids): self.action_delete(ids))
             else:
-                delete_act = QAction(self._ICO_DELETE, trans('preset.action.delete'), menu)
                 delete_act.triggered.connect(lambda checked=False, it=index: self.action_delete(it))
-                menu.addAction(duplicate_act)
-                menu.addAction(delete_act)
+            delete_act.setEnabled(can_delete_all)
 
-            self.selection = self.selectionModel().selection()
-            menu.exec_(global_pos)
+            menu.addAction(duplicate_act)
+            menu.addAction(delete_act)
 
+        self.selection = self.selectionModel().selection()
+        menu.exec_(global_pos)
+
+        # Restore selection after context menu if needed
         self.store_scroll_position()
         if self.restore_after_ctx_menu:
             if self._backup_selection is not None:
@@ -410,6 +695,12 @@ class PresetList(BaseList):
         self.restore_after_ctx_menu = True
         self.restore_scroll_position()
 
+    # ----------------------------
+    # Context actions (single or multi)
+    # If 'item' is a QModelIndex -> single row (int will be passed to external code).
+    # If 'item' is a list/tuple -> multi; pass list of ROLE_ID strings to external code.
+    # ----------------------------
+
     def action_edit(self, item):
         idx = item.row()
         if idx >= 0:
@@ -417,12 +708,23 @@ class PresetList(BaseList):
             self.window.controller.presets.editor.edit(idx)
 
     def action_duplicate(self, item):
+        if isinstance(item, (list, tuple)):
+            self.restore_after_ctx_menu = False
+            self.window.controller.presets.duplicate(list(item))
+            return
         idx = item.row()
         if idx >= 0:
             self.restore_after_ctx_menu = False
             self.window.controller.presets.duplicate(idx)
 
     def action_delete(self, item):
+        # Preserve scroll at the RMB anchor position before delete
+        self._activate_scroll_guard(self._rmb_anchor_scroll_value)
+
+        if isinstance(item, (list, tuple)):
+            self.restore_after_ctx_menu = False
+            self.window.controller.presets.delete(list(item))
+            return
         idx = item.row()
         if idx >= 0:
             self.restore_after_ctx_menu = False
@@ -432,11 +734,17 @@ class PresetList(BaseList):
         self.window.controller.presets.restore()
 
     def action_enable(self, item):
+        if isinstance(item, (list, tuple)):
+            self.window.controller.presets.enable(list(item))
+            return
         idx = item.row()
         if idx >= 0:
             self.window.controller.presets.enable(idx)
 
     def action_disable(self, item):
+        if isinstance(item, (list, tuple)):
+            self.window.controller.presets.disable(list(item))
+            return
         idx = item.row()
         if idx >= 0:
             self.window.controller.presets.disable(idx)
@@ -834,12 +1142,48 @@ class PresetList(BaseList):
         if self._model_updating:
             event.ignore()
             return
+
+        # Ctrl+Left: virtual toggle without business click
+        if event.button() == Qt.LeftButton and (event.modifiers() & Qt.ControlModifier):
+            idx = self.indexAt(self._mouse_event_point(event))
+            if idx.isValid():
+                self._ctrl_multi_active = True
+                self._ctrl_multi_index = idx
+                self._suppress_item_click = True
+                event.accept()
+                return
+            self._suppress_item_click = True
+            event.accept()
+            return
+
+        # Shift+Left: let Qt perform range selection (anchor -> clicked), suppress business click
+        if event.button() == Qt.LeftButton and (event.modifiers() & Qt.ShiftModifier):
+            idx = self.indexAt(self._mouse_event_point(event))
+            if idx.isValid():
+                self._suppress_item_click = True
+                self._was_shift_click = True
+                super().mousePressEvent(event)  # default range selection
+                return
+            # Shift on empty area -> ignore silently
+            self._suppress_item_click = True
+            self._was_shift_click = True
+            event.accept()
+            return
+
         if event.button() == Qt.LeftButton:
             index = self.indexAt(self._mouse_event_point(event))
-            if not index.isValid():
-                return
+            # When multiple are selected, a single plain click clears the multi-selection
+            if self._has_multi_selection():
+                sel_model = self.selectionModel()
+                sel_model.clearSelection()
+                if not index.isValid():
+                    event.accept()
+                    return
+                # continue with default single selection for clicked row
+
             # Freeze scroll for a moment to prevent jumps caused by selection-triggered refresh
-            self._freeze_scroll(250)
+            if index.isValid():
+                self._freeze_scroll(250)
             if self._dnd_enabled:
                 sel_model = self.selectionModel()
                 self._press_backup_selection = list(sel_model.selectedIndexes())
@@ -859,22 +1203,29 @@ class PresetList(BaseList):
                 return
             else:
                 super().mousePressEvent(event)
+
         elif event.button() == Qt.RightButton:
             index = self.indexAt(self._mouse_event_point(event))
-            if index.isValid():
-                sel_model = self.selectionModel()
-                # Save original IDs (before we temporarily select right-click row)
-                self._ctx_menu_original_ids = []
-                for ix in sel_model.selectedRows():
-                    pid = ix.data(self.ROLE_ID)
-                    if pid:
-                        self._ctx_menu_original_ids.append(pid)
+            sel_model = self.selectionModel()
+            selected_rows = [ix.row() for ix in sel_model.selectedRows()]
+            multi = len(selected_rows) > 1
 
-                self._backup_selection = list(sel_model.selectedIndexes())
-                sel_model.clearSelection()
-                sel_model.select(
-                    index, QItemSelectionModel.Select | QItemSelectionModel.Rows
-                )
+            # Save original IDs only if we are going to change selection
+            if index.isValid():
+                if multi and index.row() in selected_rows:
+                    # Keep existing multi-selection; do not alter selection on right click
+                    self._backup_selection = None
+                    self._ctx_menu_original_ids = [ix.data(self.ROLE_ID) for ix in sel_model.selectedRows() if ix.data(self.ROLE_ID)]
+                else:
+                    # Right-click outside current selection (or not multi) -> select the clicked row temporarily
+                    self._ctx_menu_original_ids = []
+                    for ix in sel_model.selectedRows():
+                        pid = ix.data(self.ROLE_ID)
+                        if pid:
+                            self._ctx_menu_original_ids.append(pid)
+                    self._backup_selection = list(sel_model.selectedIndexes())
+                    sel_model.clearSelection()
+                    sel_model.select(index, QItemSelectionModel.Select | QItemSelectionModel.Rows)
             event.accept()
         else:
             super().mousePressEvent(event)
@@ -924,6 +1275,35 @@ class PresetList(BaseList):
         if self._model_updating:
             event.ignore()
             return
+
+        # If the click was a Shift-based range selection, bypass single-select synchronization
+        if event.button() == Qt.LeftButton and self._was_shift_click:
+            self._was_shift_click = False
+            # Let Qt finish its own release processing; do not run our single-select logic
+            super().mouseReleaseEvent(event)
+            return
+
+        # Finish "virtual" Ctrl toggle on same row
+        if event.button() == Qt.LeftButton and self._ctrl_multi_active:
+            try:
+                idx = self.indexAt(self._mouse_event_point(event))
+                if idx.isValid() and self._ctrl_multi_index and idx == self._ctrl_multi_index:
+                    sel_model = self.selectionModel()
+                    sel_model.select(idx, QItemSelectionModel.Toggle | QItemSelectionModel.Rows)
+            finally:
+                self._ctrl_multi_active = False
+                self._ctrl_multi_index = None
+                # do not emit business click after Ctrl path
+                self._press_pos = None
+                self._press_index = None
+                self._press_backup_selection = None
+                self._press_backup_current = None
+                self._dragging = False
+                self._dragged_was_selected = False
+                self._drag_selection_applied = False
+            event.accept()
+            return
+
         try:
             if self._dnd_enabled and event.button() == Qt.LeftButton:
                 self.unsetCursor()
@@ -931,17 +1311,21 @@ class PresetList(BaseList):
                 if not self._dragging:
                     idx = self.indexAt(self._mouse_event_point(event))
                     if idx.isValid():
-                        pid = idx.data(self.ROLE_ID)
-                        if pid:
-                            # Keep scroll stable also for this late selection path
-                            self._freeze_scroll(300)
-                            self._pending_refocus_role_id = pid
-                            self.window.controller.presets.select_by_id(pid)
-                            QTimer.singleShot(0, self._apply_pending_refocus)
-                            QTimer.singleShot(50, self._apply_pending_refocus)
+                        # Skip business selection if multi-selection is active (e.g., after Shift)
+                        if self._has_multi_selection():
+                            pass
                         else:
-                            self.setCurrentIndex(idx)
-                            self.window.controller.presets.select(idx.row())
+                            pid = idx.data(self.ROLE_ID)
+                            if pid:
+                                # Keep scroll stable also for this late selection path
+                                self._freeze_scroll(300)
+                                self._pending_refocus_role_id = pid
+                                self.window.controller.presets.select_by_id(pid)
+                                QTimer.singleShot(0, self._apply_pending_refocus)
+                                QTimer.singleShot(50, self._apply_pending_refocus)
+                            else:
+                                self.setCurrentIndex(idx)
+                                self.window.controller.presets.select(idx.row())
         finally:
             self._press_pos = None
             self._press_index = None
@@ -1064,6 +1448,11 @@ class PresetList(BaseList):
         self.window.controller.presets.persist_order_for_mode(mode, uuids)
 
     def selectionCommand(self, index, event=None):
+        """
+        Selection command
+        :param index: Index
+        :param event: Event
+        """
         # Prevent selection changes while model is updating (guards against stale indexes)
         if self._model_updating:
             return QItemSelectionModel.NoUpdate