pygpt-net 2.6.61__py3-none-any.whl → 2.6.63__py3-none-any.whl

pygpt_net/ui/widget/dialog/confirm.py

@@ -6,10 +6,11 @@
 # 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.27 09:30:00                  #
 # ================================================== #
 
-from PySide6.QtCore import Qt
+import sys
+from PySide6.QtCore import Qt, QTimer
 from PySide6.QtWidgets import QDialog, QLabel, QHBoxLayout, QVBoxLayout, QPushButton
 
 from pygpt_net.utils import trans
@@ -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,20 @@ 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._apply_neutral_default()
+
+        # 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 +67,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
@@ -61,4 +81,34 @@ class ConfirmDialog(QDialog):
         :param event: close event
         """
         self.window.controller.dialogs.confirm.dismiss(self.type, self.id)
-        super(ConfirmDialog, self).closeEvent(event)
+        super(ConfirmDialog, self).closeEvent(event)
+
+    def showEvent(self, event):
+        """
+        Ensure neutral button is default/active on every show.
+
+        Using a single-shot timer defers focus/default restoration until
+        after the dialog becomes visible, which prevents focus being stolen
+        by the window manager.
+        """
+        super(ConfirmDialog, self).showEvent(event)
+        QTimer.singleShot(0, self._apply_neutral_default)
+
+    def _apply_neutral_default(self):
+        """
+        Set the neutral action (No/Cancel) as default and active.
+        Always called on construction and each time the dialog is shown.
+        """
+        btn_no = self.window.ui.nodes.get('dialog.confirm.btn.no')
+        btn_yes = self.window.ui.nodes.get('dialog.confirm.btn.yes')
+        if not btn_no or not btn_yes:
+            return
+
+        # Make sure affirmative button cannot become default by leftover state
+        btn_yes.setAutoDefault(False)
+        btn_yes.setDefault(False)
+
+        # Make neutral (No/Cancel) the active default and take focus
+        btn_no.setAutoDefault(True)
+        btn_no.setDefault(True)
+        btn_no.setFocus()

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:

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 03:00:00                  #
+# Updated Date: 2025.09.26 12:00:00                  #
 # ================================================== #
 
 from PySide6.QtCore import QPoint, QItemSelectionModel, Qt, QEventLoop, QTimer, QMimeData
@@ -65,6 +65,7 @@ class PresetList(BaseList):
         self.setDragDropMode(QAbstractItemView.NoDragDrop)  # switched dynamically
         self.setDefaultDropAction(Qt.MoveAction)
         self.setDragDropOverwriteMode(False)
+        # We use our own visual indicator for drop position
         self.setDropIndicatorShown(False)
 
         self._press_pos = None
@@ -92,6 +93,18 @@ class PresetList(BaseList):
         # One-shot forced selection after refresh (list of ROLE_ID)
         self._selection_override_ids = None
 
+        # Custom drop indicator (visual only)
+        self._drop_indicator_active = False
+        # seam row for indicator (row under which the line is drawn)
+        self._drop_indicator_to_row = -1
+        self._drop_indicator_padding = 6  # visual left/right padding
+
+        # Short-lived scroll freeze to prevent jumps during click-triggered model refresh
+        self._scroll_freeze_depth = 0
+        self._scroll_freeze_timer = None
+        self._pending_scroll_value = None
+        self._pending_refocus_role_id = None
+
     # -------- Public helpers to protect updates --------
 
     def begin_model_update(self):
@@ -103,26 +116,135 @@ class PresetList(BaseList):
         """Re-enable interaction after model/view rebuild is complete."""
         self.setEnabled(True)
         self._model_updating = False
+        # If there is a pending scroll/selection stabilization, apply it right after update
+        self._apply_pending_scroll()
+        self._apply_pending_refocus()
+        QTimer.singleShot(0, self._apply_pending_scroll)
+        QTimer.singleShot(0, self._apply_pending_refocus)
+        # Unfreeze shortly after everything settled in the event loop
+        QTimer.singleShot(50, self._unfreeze_scroll)
 
     # ---------------------------------------------------
 
+    # -------- Scroll freeze helpers (prevent accidental jumps on click) --------
+
+    def _freeze_scroll(self, ms: int = 250):
+        """
+        Freeze scrollTo() effects for a very short time and keep current scroll value.
+        This avoids jumps caused by programmatic scroll during selection/refresh.
+        """
+        try:
+            sb = self.verticalScrollBar()
+        except Exception:
+            sb = None
+        if sb is not None:
+            self._pending_scroll_value = sb.value()
+        self._scroll_freeze_depth += 1
+
+        # Apply stabilization now and on next frame(s)
+        QTimer.singleShot(0, self._apply_pending_scroll)
+        QTimer.singleShot(16, self._apply_pending_scroll)
+
+        # Auto-unfreeze after given duration
+        if self._scroll_freeze_timer:
+            try:
+                self._scroll_freeze_timer.stop()
+            except Exception:
+                pass
+        self._scroll_freeze_timer = QTimer(self)
+        self._scroll_freeze_timer.setSingleShot(True)
+        self._scroll_freeze_timer.timeout.connect(self._unfreeze_scroll)
+        self._scroll_freeze_timer.start(max(50, int(ms)))
+
+    def _apply_pending_scroll(self):
+        """Re-apply saved scroll position when frozen."""
+        if self._pending_scroll_value is None:
+            return
+        try:
+            sb = self.verticalScrollBar()
+        except Exception:
+            sb = None
+        if sb is not None:
+            sb.setValue(self._pending_scroll_value)
+
+    def _unfreeze_scroll(self):
+        """Release the temporary scroll freeze."""
+        if self._scroll_freeze_depth > 0:
+            self._scroll_freeze_depth -= 1
+        if self._scroll_freeze_depth <= 0:
+            self._scroll_freeze_depth = 0
+            self._pending_scroll_value = None
+
+    def scrollTo(self, index, hint=QAbstractItemView.EnsureVisible):
+        """
+        Temporarily suppress automatic scrolling while frozen.
+        This prevents list jumping when selection triggers scrollTo during refresh.
+        """
+        if self._scroll_freeze_depth > 0:
+            self._apply_pending_scroll()
+            return
+        return super().scrollTo(index, hint)
+
+    def _apply_pending_refocus(self):
+        """
+        Ensure selection stays on the intended item (by ROLE_ID) after a model refresh.
+        Does not force scrolling when scroll is frozen.
+        """
+        pid = self._pending_refocus_role_id
+        if not pid:
+            return
+        model = self.model()
+        if model is None:
+            return
+        target_idx = None
+        try:
+            for r in range(model.rowCount()):
+                ix = model.index(r, 0)
+                if ix.data(self.ROLE_ID) == pid:
+                    target_idx = ix
+                    break
+        except Exception:
+            target_idx = None
+
+        if target_idx is not None and target_idx.isValid():
+            try:
+                sel_model = self.selectionModel()
+                if sel_model:
+                    prev_unlocked = getattr(self, "unlocked", True)
+                    self.unlocked = True
+                    try:
+                        sel_model.clearSelection()
+                        sel_model.select(target_idx, QItemSelectionModel.ClearAndSelect | QItemSelectionModel.Rows)
+                        self.setCurrentIndex(target_idx)
+                    finally:
+                        self.unlocked = prev_unlocked
+                # If refocus succeeded, clear the pending marker
+                self._pending_refocus_role_id = None
+            except Exception:
+                # Keep pending id for next attempt if apply failed
+                pass
+
+    # --------------------------------------------------------------------------
+
     def set_dnd_enabled(self, enabled: bool):
         """
         Toggle DnD behaviour at runtime.
         Using DragDrop (not InternalMove) to avoid implicit Qt reordering.
+        We also disable the native drop indicator and render our own line.
         """
         self._dnd_enabled = bool(enabled)
         if self._dnd_enabled:
             self.setDragEnabled(True)
             self.setAcceptDrops(True)
             self.setDragDropMode(QAbstractItemView.DragDrop)
-            self.setDropIndicatorShown(True)
+            self.setDropIndicatorShown(False)  # use custom indicator
         else:
             self.setDragEnabled(False)
             self.setAcceptDrops(False)
             self.setDragDropMode(QAbstractItemView.NoDragDrop)
             self.setDropIndicatorShown(False)
             self.unsetCursor()
+        self._clear_drop_indicator()  # ensure clean state
 
     def backup_selection(self):
         """
@@ -186,12 +308,21 @@ class PresetList(BaseList):
             return
         preset_id = index.data(self.ROLE_ID)
         if preset_id:
+            # Freeze scroll and remember the intended selection to re-apply after any refresh
+            self._freeze_scroll(300)
+            self._pending_refocus_role_id = preset_id
             self.window.controller.presets.select_by_id(preset_id)
+            # Re-apply selection in next ticks to win races with late refresh
+            QTimer.singleShot(0, self._apply_pending_refocus)
+            QTimer.singleShot(50, self._apply_pending_refocus)
             self.selection = self.selectionModel().selection()
             return
         row = index.row()
         if row >= 0:
+            self._freeze_scroll(300)
             self.window.controller.presets.select(row)
+            QTimer.singleShot(0, self._apply_pending_refocus)
+            QTimer.singleShot(50, self._apply_pending_refocus)
             self.selection = self.selectionModel().selection()
 
     def dblclick(self, val):
@@ -504,16 +635,13 @@ class PresetList(BaseList):
 
         self.store_scroll_position()
 
-        di_prev = self._dnd_enabled
-        self.setDropIndicatorShown(False)
+        # Use custom indicator only; do not re-enable native one here
         self.setUpdatesEnabled(False)
         try:
             self.window.controller.presets.update_list()
             self.restore_scroll_position()
         finally:
             self.setUpdatesEnabled(True)
-            if di_prev and self._dnd_enabled:
-                self.setDropIndicatorShown(True)
 
         # Clear helpers for context menu (layout will consume _selection_override_ids)
         self._ctx_menu_original_ids = None
@@ -556,6 +684,136 @@ class PresetList(BaseList):
         moved_id = self._reorder_and_persist(from_row, to_row)
         self._refresh_after_order_change(moved_id, follow_selection=False)
 
+    # --- Custom drop indicator helpers ---
+
+    def _compute_drop_locations(self, pos: QPoint) -> tuple[int, int]:
+        """
+        Compute both:
+        - to_row_drop: final insertion row used for reordering (after 'moving-down' adjustment),
+        - seam_row: row under which the visual indicator line should be drawn
+                    in the current (pre-drop) view geometry.
+
+        This keeps visuals and the final insertion point perfectly aligned.
+
+        Returns: (to_row_drop, seam_row)
+        """
+        model = self.model()
+        if model is None:
+            return -1, -1
+
+        idx = self.indexAt(pos)
+
+        beyond_last = False
+        if not idx.isValid():
+            to_row_raw = model.rowCount()  # append at the end
+            if model.rowCount() > 0:
+                last_idx = model.index(model.rowCount() - 1, 0)
+                last_rect = self.visualRect(last_idx)
+                if last_rect.isValid() and pos.y() > last_rect.bottom():
+                    beyond_last = True
+        else:
+            rect = self.visualRect(idx)
+            to_row_raw = idx.row() + (1 if pos.y() > rect.center().y() else 0)
+
+        # Keep first row pinned (cannot insert above row 1)
+        if to_row_raw <= 1:
+            to_row_raw = 1
+
+        # seam row is always the boundary under the row at (to_row_raw - 1),
+        # except in explicit "beyond last" zone where we draw under the last row.
+        if model.rowCount() > 0:
+            if beyond_last:
+                seam_row = model.rowCount() - 1
+            else:
+                seam_row = max(0, min(model.rowCount() - 1, to_row_raw - 1))
+        else:
+            seam_row = -1
+
+        # Apply 'moving down' adjustment only to the logical insertion row,
+        # never to the visual seam (otherwise the line jumps one row up).
+        from_row = self._press_index.row() if (self._press_index and self._press_index.isValid()) else -1
+        to_row_drop = to_row_raw
+        if from_row >= 0 and to_row_raw > from_row and not beyond_last:
+            to_row_drop -= 1
+
+        # Clamp to valid ranges
+        to_row_drop = max(1, min(model.rowCount(), to_row_drop))
+        if seam_row >= 0:
+            seam_row = max(0, min(model.rowCount() - 1, seam_row))
+
+        return to_row_drop, seam_row
+
+    def _update_drop_indicator_from_pos(self, pos: QPoint):
+        """
+        Update custom drop indicator state based on cursor position.
+        Draws a single horizontal line under the row where the item will land.
+        """
+        if not self._dnd_enabled or self._model_updating:
+            self._clear_drop_indicator()
+            return
+
+        model = self.model()
+        if model is None or model.rowCount() <= 0:
+            self._clear_drop_indicator()
+            return
+
+        _, seam_row = self._compute_drop_locations(pos)
+        if seam_row < 0:
+            self._clear_drop_indicator()
+            return
+
+        if not self._drop_indicator_active or self._drop_indicator_to_row != seam_row:
+            self._drop_indicator_active = True
+            self._drop_indicator_to_row = seam_row
+            self.viewport().update()
+
+    def _clear_drop_indicator(self):
+        """Hide custom drop indicator."""
+        if self._drop_indicator_active or self._drop_indicator_to_row != -1:
+            self._drop_indicator_active = False
+            self._drop_indicator_to_row = -1
+            if self.viewport():
+                self.viewport().update()
+
+    def paintEvent(self, event):
+        """
+        Standard paint + overlay a clear drop indicator line at the computed insertion position.
+        """
+        super().paintEvent(event)
+
+        if not self._drop_indicator_active or not self._dnd_enabled:
+            return
+
+        model = self.model()
+        if model is None or model.rowCount() <= 0:
+            return
+
+        seam_row = self._drop_indicator_to_row
+        if seam_row < 0 or seam_row >= model.rowCount():
+            return
+
+        idx = model.index(seam_row, 0)
+        rect = self.visualRect(idx)
+        if not rect.isValid() or rect.height() <= 0:
+            return
+
+        # Line under the seam row
+        y = rect.bottom()
+        x1 = self._drop_indicator_padding
+        x2 = self.viewport().width() - self._drop_indicator_padding
+
+        painter = QPainter(self.viewport())
+        try:
+            # Use highlight color with good contrast; 1px thickness
+            color = self.palette().highlight().color()
+            color.setAlpha(220)
+            pen = QPen(color, 1)
+            pen.setCapStyle(Qt.RoundCap)
+            painter.setPen(pen)
+            painter.drawLine(x1, y, x2, y)
+        finally:
+            painter.end()
+
     # ----------------------------
     # Mouse / DnD events
     # ----------------------------
@@ -580,6 +838,8 @@ class PresetList(BaseList):
             index = self.indexAt(self._mouse_event_point(event))
             if not index.isValid():
                 return
+            # Freeze scroll for a moment to prevent jumps caused by selection-triggered refresh
+            self._freeze_scroll(250)
             if self._dnd_enabled:
                 sel_model = self.selectionModel()
                 self._press_backup_selection = list(sel_model.selectedIndexes())
@@ -657,6 +917,7 @@ class PresetList(BaseList):
 
         self._dragging = True
         self.setCursor(QCursor(Qt.ClosedHandCursor))
+        # Let base class proceed; it will trigger startDrag when needed.
         super().mouseMoveEvent(event)
 
     def mouseReleaseEvent(self, event):
@@ -666,12 +927,18 @@ class PresetList(BaseList):
         try:
             if self._dnd_enabled and event.button() == Qt.LeftButton:
                 self.unsetCursor()
+                self._clear_drop_indicator()
                 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)
                         else:
                             self.setCurrentIndex(idx)
                             self.window.controller.presets.select(idx.row())
@@ -693,12 +960,16 @@ class PresetList(BaseList):
             return
         event.setDropAction(Qt.MoveAction)
         event.acceptProposedAction()
+        super().dragEnterEvent(event)
+        # Show indicator immediately on enter
+        self._update_drop_indicator_from_pos(self._mouse_event_point(event))
 
     def dragLeaveEvent(self, event):
         if self._model_updating:
             event.ignore()
             return
         self.unsetCursor()
+        self._clear_drop_indicator()
         super().dragLeaveEvent(event)
 
     def dragMoveEvent(self, event):
@@ -707,7 +978,6 @@ class PresetList(BaseList):
             return
         if not self._dnd_enabled:
             return
-        event.setDropAction(Qt.MoveAction)
 
         pos = self._mouse_event_point(event)
         idx = self.indexAt(pos)
@@ -715,9 +985,17 @@ class PresetList(BaseList):
         if idx.isValid() and idx.row() == 0:
             rect = self.visualRect(idx)
             if pos.y() <= rect.center().y():
+                self._clear_drop_indicator()
                 event.ignore()
                 return
+
+        # Let base class process autoscroll and internal geometry first
+        event.setDropAction(Qt.MoveAction)
         event.acceptProposedAction()
+        super().dragMoveEvent(event)
+
+        # Update custom indicator based on current cursor and updated viewport
+        self._update_drop_indicator_from_pos(pos)
 
     def dropEvent(self, event):
         """
@@ -746,26 +1024,11 @@ class PresetList(BaseList):
             event.ignore()
             self.unsetCursor()
             self._drag_selection_applied = False
+            self._clear_drop_indicator()
             return
 
-        # Target row
-        pos = self._mouse_event_point(event)
-        idx = self.indexAt(pos)
-        if not idx.isValid():
-            to_row = model.rowCount()  # append
-        else:
-            rect = self.visualRect(idx)
-            to_row = idx.row()
-            if pos.y() > rect.center().y():
-                to_row += 1
-
-        # Keep first row pinned
-        if to_row <= 1:
-            to_row = 1
-
-        # Adjust when moving down (Qt inserts before position)
-        if to_row > from_row:
-            to_row -= 1
+        # Target row computed exactly the same way as the indicator (but with 'moving down' adjustment)
+        to_row, _ = self._compute_drop_locations(self._mouse_event_point(event))
 
         moved_id = self._reorder_and_persist(from_row, to_row)
 
@@ -778,6 +1041,7 @@ class PresetList(BaseList):
         event.acceptProposedAction()
         self.unsetCursor()
         self._drag_selection_applied = False
+        self._clear_drop_indicator()
 
     # ----------------------------
     # Legacy helper (not used in new path)