pygpt-net 2.6.61__py3-none-any.whl → 2.6.62__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 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)

pygpt_net/ui/widget/node_editor/editor.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.25 12:35:00                  #
+# Updated Date: 2025.09.26 12:00:00                  #
 # ================================================== #
 
 from __future__ import annotations
@@ -143,18 +143,6 @@ class NodeEditor(QWidget):
         # Centralized strings
         self.config: EditorConfig = config if isinstance(config, EditorConfig) else EditorConfig()
 
-        # Theme and palette
-        """
-        if parent and hasattr(parent, "window"):
-            theme = parent.window.core.config.get("theme")
-            if theme.startswith("light"):
-                print("[NodeEditor] Detected light theme from parent")
-                self._grid_back_color = QColor(255, 255, 255)
-                self._grid_pen_color = QColor(230, 230, 230)
-                self.gridBackColor = Property(QColor, lambda self: self._grid_back_color, lambda self, v: self._q_set("_grid_back_color", v))
-                self.gridPenColor = Property(QColor, lambda self: self._grid_pen_color, lambda self, v: self._q_set("_grid_pen_color", v))
-        """
-
         self.graph = NodeGraph(registry)
         self.scene = NodeGraphicsScene(self)
         self.view = NodeGraphicsView(self.scene, self)
@@ -422,7 +410,12 @@ class NodeEditor(QWidget):
 
     def add_node(self, type_name: str, scene_pos: QPointF):
         """Add a new node of the given type at scene_pos (undoable)."""
+        # Enforce optional per-type limit configured in registry.
+        if not self._can_add_node_of_type(type_name):
+            self._dbg(f"add_node blocked: type='{type_name}' reached its max per-layout limit")
+            return False
         self._undo.push(AddNodeCommand(self, type_name, scene_pos))
+        return True
 
     def clear(self, ask_user: bool = True):
         """Clear the entire editor (undoable), optionally asking the user for confirmation."""
@@ -438,6 +431,7 @@ class NodeEditor(QWidget):
             if reply != QMessageBox.Yes:
                 return False
         self._undo.push(ClearGraphCommand(self))
+        self._update_status_label()
         return True
 
     def undo(self):
@@ -668,6 +662,35 @@ class NodeEditor(QWidget):
         vp_pt = self.view.mapFromScene(scene_pos)
         return self.view.viewport().mapToGlobal(vp_pt)
 
+    # ---------- Per-type limit helpers ----------
+
+    def _type_limit(self, type_name: str) -> Optional[int]:
+        """Return configured max_num for type or None if unlimited."""
+        spec = self.graph.registry.get(type_name) if self.graph and self.graph.registry else None
+        if not spec:
+            return None
+        try:
+            limit = getattr(spec, "max_num", None)
+            if isinstance(limit, int) and limit <= 0:
+                return None
+            return limit if isinstance(limit, int) else None
+        except Exception:
+            return None
+
+    def _count_nodes_of_type(self, type_name: str) -> int:
+        """Count current nodes of a given type in the live graph."""
+        try:
+            return sum(1 for n in self.graph.nodes.values() if getattr(n, "type", None) == type_name)
+        except Exception:
+            return 0
+
+    def _can_add_node_of_type(self, type_name: str) -> bool:
+        """Check whether adding another node of given type is allowed by max_num."""
+        limit = self._type_limit(type_name)
+        if limit is None:
+            return True
+        return self._count_nodes_of_type(type_name) < int(limit)
+
     def _on_scene_context_menu(self, scene_pos: QPointF):
         """Show context menu for adding nodes and undo/redo/clear at empty scene position."""
         try:
@@ -685,7 +708,21 @@ class NodeEditor(QWidget):
         add_menu = menu.addMenu(self.config.menu_add())
         action_by_type: Dict[QAction, str] = {}
         for tname in self.graph.registry.types():
-            act = add_menu.addAction(tname)
+            # Prefer UI-only display name; fallback to identifier (type_name)
+            try:
+                label = self.graph.registry.display_name(tname)
+            except Exception:
+                label = tname
+            act = add_menu.addAction(label)
+            # Show the underlying identifier in tooltip to make UI/ID relation explicit
+            if label != tname:
+                try:
+                    act.setToolTip(tname)
+                except Exception:
+                    pass
+            # Disable when limit reached (evaluated in real-time, per layout)
+            if not self._can_add_node_of_type(tname):
+                act.setEnabled(False)
             action_by_type[act] = tname
 
         menu.addSeparator()
@@ -711,7 +748,8 @@ class NodeEditor(QWidget):
             self.clear(ask_user=True)
         elif chosen in action_by_type:
             type_name = action_by_type[chosen]
-            self._undo.push(AddNodeCommand(self, type_name, scene_pos))
+            # Route through editor.add_node() to enforce limit guards
+            self.add_node(type_name, scene_pos)
 
     # ---------- Z-order helpers ----------