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

pygpt_net/ui/widget/node_editor/editor.py

@@ -6,17 +6,17 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.24 00:00:00                  #
+# Updated Date: 2025.09.26 12:00:00                  #
 # ================================================== #
 
 from __future__ import annotations
-from typing import Dict, Optional, List, Tuple, Any, Union
+from typing import Dict, Optional, List, Tuple, Any, Union, Callable
 
 from PySide6.QtCore import Qt, QPoint, QPointF, QRectF, QSizeF, Property, QEvent
-from PySide6.QtGui import  QAction, QColor, QUndoStack, QPalette,  QCursor, QKeySequence, QShortcut
+from PySide6.QtGui import QAction, QColor, QUndoStack, QPalette, QCursor, QKeySequence, QShortcut, QFont
 from PySide6.QtWidgets import (
     QWidget, QApplication, QGraphicsView, QMenu, QMessageBox, QLineEdit, QSpinBox, QDoubleSpinBox, QComboBox,
-    QTextEdit, QPlainTextEdit
+    QTextEdit, QPlainTextEdit, QLabel
 )
 
 from pygpt_net.core.node_editor.graph import NodeGraph
@@ -28,8 +28,9 @@ from pygpt_net.utils import trans
 from .command import AddNodeCommand, ClearGraphCommand, RewireConnectionCommand, ConnectCommand, DeleteNodeCommand, DeleteConnectionCommand
 from .item import EdgeItem, PortItem
 from .node import NodeItem
-from .view import NodeGraphicsScene, NodeGraphicsView
+from .view import NodeGraphicsScene, NodeGraphicsView, NodeViewOverlayControls, NodeViewStatusLabel
 from .utils import _qt_is_valid
+from .config import EditorConfig
 
 
 # ------------------------ NodeEditor ------------------------
@@ -132,13 +133,16 @@ class NodeEditor(QWidget):
         if _qt_is_valid(self.view):
             self.view.viewport().update()
 
-    def __init__(self, parent: Optional[QWidget] = None, registry: Optional[NodeTypeRegistry] = None):
+    def __init__(self, parent: Optional[QWidget] = None, registry: Optional[NodeTypeRegistry] = None, config: Optional[EditorConfig] = None):
         """Initialize the editor, scene, view, graph and interaction state."""
         super().__init__(parent)
         self.setObjectName("NodeEditor")
         self._debug = False
         self._dbg("INIT NodeEditor")
 
+        # Centralized strings
+        self.config: EditorConfig = config if isinstance(config, EditorConfig) else EditorConfig()
+
         self.graph = NodeGraph(registry)
         self.scene = NodeGraphicsScene(self)
         self.view = NodeGraphicsView(self.scene, self)
@@ -163,6 +167,14 @@ class NodeEditor(QWidget):
         self._spawn_index: int = 0
         self._saved_drag_mode: Optional[QGraphicsView.DragMode] = None
 
+        # Collisions on/off flag
+        self.enable_collisions: bool = False
+        # Top Z counter for new nodes when collisions are disabled (keeps newest on top)
+        self._z_top: float = 2.0
+
+        # External guard for scene editing/menu (callable bool); when None -> allowed
+        self.editing_allowed: Optional[Callable[[], bool]] = None
+
         self.scene.sceneContextRequested.connect(self._on_scene_context_menu)
         self.graph.nodeAdded.connect(self._on_graph_node_added)
         self.graph.nodeRemoved.connect(self._on_graph_node_removed)
@@ -197,6 +209,17 @@ class NodeEditor(QWidget):
         self._base_id_max: Dict[str, Dict[str, int]] = {}
         self._reset_base_id_counters()
 
+        # Top-right overlay controls (Grab, Zoom Out, Zoom In)
+        self._controls = NodeViewOverlayControls(self)
+        self._controls.grabToggled.connect(self._on_grab_toggled)
+        self._controls.zoomInClicked.connect(self.zoom_in)
+        self._controls.zoomOutClicked.connect(self.zoom_out)
+        self._controls.raise_()
+
+        # Bottom-left fixed status label
+        self._status = NodeViewStatusLabel(self)
+        self._status.raise_()
+
     # ---------- Debug helper ----------
     def _dbg(self, msg: str):
         """Conditional debug logger (enabled by self._debug)."""
@@ -225,9 +248,8 @@ class NodeEditor(QWidget):
         """Update internal flag when focus moves to/from text widgets."""
         self._text_input_active = self._is_text_entry_widget(now)
 
-    # Backward-compatible helper used by other parts
     def _is_text_input_focused(self) -> bool:
-        """Return True if an input field is currently focused."""
+        """Return True if a text-like input currently has focus."""
         return bool(self._text_input_active)
 
     # ---------- QWidget overrides ----------
@@ -246,65 +268,44 @@ class NodeEditor(QWidget):
     def closeEvent(self, e):
         """Perform a thorough cleanup to prevent dangling Qt wrappers during shutdown."""
         self._dbg("closeEvent -> full cleanup")
-
-        # Make the editor effectively inert for any in-flight events
         self._closing = True
         self._alive = False
         self._ready_for_theme = False
-
-        # Stop listening to global focus changes
         try:
             app = QApplication.instance()
             if app:
                 app.focusChanged.disconnect(self._on_focus_changed)
         except Exception:
             pass
-
-        # Disconnect scene signals and filters
         try:
             if _qt_is_valid(self.scene):
                 self.scene.sceneContextRequested.disconnect(self._on_scene_context_menu)
         except Exception:
             pass
-
-        # Cancel any interactive wire state before clearing items
         self._reset_interaction_states(remove_hidden_edges=True)
-
         try:
             if _qt_is_valid(self.scene):
                 self.scene.removeEventFilter(self)
         except Exception:
             pass
-
-        # Disconnect graph signals early to prevent callbacks during teardown
         self._disconnect_graph_signals()
-
-        # Clear undo stack to drop references to scene items and widgets
         try:
             if self._undo is not None:
                 self._undo.clear()
         except Exception:
             pass
-
-        # Proxies/widgets first (prevents QWidget-in-scene dangling)
         self._cleanup_node_proxies()
-
-        # Remove edge items, then all remaining scene items
         try:
             self._remove_all_edge_items_from_scene()
             if _qt_is_valid(self.scene):
                 self.scene.clear()
         except Exception:
             pass
-
-        # Detach view from scene to break mutual references
         try:
             if _qt_is_valid(self.view):
                 self.view.setScene(None)
         except Exception:
             pass
-
-        # Drop internal maps to help GC
         try:
             self._uuid_to_item.clear()
             self._conn_uuid_to_edge.clear()
@@ -314,8 +315,6 @@ class NodeEditor(QWidget):
         self._interactive_src_port = None
         self._hover_candidate = None
         self._pending_node_positions.clear()
-
-        # Optionally schedule deletion of scene/view
         try:
             if _qt_is_valid(self.scene):
                 self.scene.deleteLater()
@@ -326,11 +325,8 @@ class NodeEditor(QWidget):
                 self.view.deleteLater()
         except Exception:
             pass
-
         self.scene = None
         self.view = None
-
-        # Force-flush all deferred deletions to avoid old wrappers lingering into the next open
         try:
             from PySide6.QtWidgets import QApplication
             from PySide6.QtCore import QEvent
@@ -339,7 +335,6 @@ class NodeEditor(QWidget):
                 QApplication.processEvents()
         except Exception:
             pass
-
         super().closeEvent(e)
 
     def _disconnect_graph_signals(self):
@@ -357,22 +352,26 @@ class NodeEditor(QWidget):
                 pass
 
     def resizeEvent(self, e):
-        """Keep the view sized to the editor widget."""
+        """Keep the view sized to the editor widget and position overlays."""
         if _qt_is_valid(self.view):
             self.view.setGeometry(self.rect())
+        self._position_overlay_controls()
+        self._position_status_label()
         super().resizeEvent(e)
 
     def showEvent(self, e):
-        """Cache the spawn origin and reapply stylesheets when shown."""
+        """Cache the spawn origin, reapply stylesheets and position overlays."""
         if self._spawn_origin is None and _qt_is_valid(self.view):
             self._spawn_origin = self.view.mapToScene(self.view.viewport().rect().center())
         self._reapply_stylesheets()
+        self._position_overlay_controls()
+        self._position_status_label()
+        self._update_status_label()
         super().showEvent(e)
 
     def event(self, e):
         """React to global style/palette changes and reset interactions on focus loss."""
         et = e.type()
-        # Do not accept ShortcutOverride here; we rely on the editor-level QShortcut for Delete.
         if et in (QEvent.StyleChange, QEvent.PaletteChange, QEvent.FontChange,
                   QEvent.ApplicationPaletteChange, QEvent.ApplicationFontChange):
             self._reapply_stylesheets()
@@ -381,18 +380,45 @@ class NodeEditor(QWidget):
             self._reset_interaction_states(remove_hidden_edges=False)
         return super().event(e)
 
+    def _position_overlay_controls(self):
+        """Place the top-right overlay controls with 10px margin."""
+        try:
+            if _qt_is_valid(self._controls):
+                sz = self._controls.sizeHint()
+                x = max(10, self.width() - sz.width() - 10)
+                y = 10
+                self._controls.move(x, y)
+                self._controls.raise_()
+                self._controls.show()
+        except Exception:
+            pass
+
+    def _position_status_label(self):
+        """Place bottom-left status label with 10px margin."""
+        try:
+            if _qt_is_valid(self._status):
+                s = self._status.sizeHint()
+                x = 10
+                y = max(10, self.height() - s.height() - 10)
+                self._status.move(x, y)
+                self._status.raise_()
+                self._status.show()
+        except Exception:
+            pass
+
     # ---------- Public API ----------
 
     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.
-
-        Returns:
-            bool: True if a clear operation was initiated.
-        """
+        """Clear the entire editor (undoable), optionally asking the user for confirmation."""
         if not self._alive or self.scene is None or self.view is None:
             return False
         if ask_user and self.on_clear and callable(self.on_clear):
@@ -405,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):
@@ -416,20 +443,10 @@ class NodeEditor(QWidget):
         self._undo.redo()
 
     def save_layout(self) -> dict:
-        """Serialize the current layout into a compact, value-only dict.
-
-        Notes:
-            - Property specification (type, editable, allowed_inputs/outputs, etc.) is NOT exported.
-            - Only dynamic, value-carrying properties are persisted.
-            - Registry definitions are the single source of truth for property specs during load.
-        """
+        """Serialize the current layout into a compact, value-only dict."""
         if not self._alive or self.scene is None or self.view is None:
             return False
-
-        # Build compact graph payload (nodes + connections without specs)
         compact = self._serialize_layout_compact()
-
-        # Positions and sizes come from live scene items
         compact["positions"] = {
             nuuid: [self._uuid_to_item[nuuid].pos().x(), self._uuid_to_item[nuuid].pos().y()]
             for nuuid in self._uuid_to_item
@@ -439,77 +456,40 @@ class NodeEditor(QWidget):
                     float(self._uuid_to_item[nuuid].size().height())]
             for nuuid in self._uuid_to_item
         }
-
-        # Persist the current view (zoom and scrollbars)
         try:
             compact["view"] = self._save_view_state()
         except Exception:
             compact["view"] = {}
-
         return compact
 
     def load_layout(self, data: dict):
-        """
-        Load layout using the live registry for node specs. Only values from the layout are applied,
-        and only for properties that still exist in the current spec. Everything else falls back to
-        the registry defaults. Connections are recreated only if ports still exist and can connect.
-
-        Example:
-            editor.load_layout({
-                "nodes": [
-                    {"uuid": "n1", "type": "Agent", "values": {"name": "Collector"}, "pos": [100, 120], "size": [220, 180]},
-                    {"uuid": "n2", "type": "Tool",  "values": {"kind": "Search"}}
-                ],
-                "connections": [
-                    {"uuid": "c1", "src_node": "n1", "src_prop": "out", "dst_node": "n2", "dst_prop": "in"}
-                ]
-            })
-        """
+        """Load layout using the live registry for node specs (value-only merge)."""
         if not self._alive or self.scene is None or self.view is None:
             return False
-
-        # Guard: mark layout import phase to avoid auto-renumbering of Base ID on nodeAdded.
         self._is_loading_layout = True
         try:
             self._dbg("load_layout -> registry-first import with value-only merge")
-            # Reset interaction and clear both scene and graph (do not reuse graph.from_dict here).
             self._reset_interaction_states(remove_hidden_edges=True)
             self._clear_scene_only(hard=True)
             try:
                 self.graph.clear(silent=True)
             except Exception:
-                # Be defensive in case .clear is not available or raises
                 self.graph.nodes = {}
                 self.graph.connections = {}
 
-            # Also reset per-layout Base ID counters; they will be rebuilt from the loaded data.
             self._reset_base_id_counters()
-
-            # Extract normalized structures from possibly diverse layout shapes.
             nodes_norm, conns_norm, positions, sizes = self._normalize_layout_dict(data)
 
-            # 1) Create nodes from registry spec, preserve UUID, set values that match current spec.
             created: Dict[str, NodeModel] = {}
             for nd in nodes_norm:
                 tname = nd.get("type")
                 nuuid = nd.get("uuid")
                 if not tname or not nuuid:
-                    self._dbg(f"load_layout: skip node without type/uuid: {nd}")
-                    continue
-
-                # Ensure type exists in registry.
-                spec = self.graph.registry.get(tname) if self.graph and self.graph.registry else None
-                if spec is None:
-                    self._dbg(f"load_layout: skip node '{nuuid}' with unknown type '{tname}' (not in registry)")
                     continue
-
                 try:
                     node = self.graph.create_node_from_type(tname)
-                except Exception as ex:
-                    self._dbg(f"load_layout: create_node_from_type failed for '{tname}': {ex}")
+                except Exception:
                     continue
-
-                # Preserve UUID and optional name from layout (if present).
                 try:
                     node.uuid = nuuid
                 except Exception:
@@ -520,16 +500,12 @@ class NodeEditor(QWidget):
                         node.name = name
                     except Exception:
                         pass
-
-                # Preserve friendly node.id from layout if present (keeps per-layout numbering).
                 try:
                     fid = nd.get("id")
                     if isinstance(fid, str) and fid.strip():
                         node.id = fid.strip()
                 except Exception:
                     pass
-
-                # Apply property values only for properties that exist in the current spec.
                 values_map: Dict[str, Any] = nd.get("values", {})
                 for pid, pm in list(node.properties.items()):
                     if pid in values_map:
@@ -538,11 +514,6 @@ class NodeEditor(QWidget):
                             pm.value = val
                         except Exception:
                             pass
-                    else:
-                        # Keep default from registry-created node.
-                        pass
-
-                # Schedule position (used in _on_graph_node_added) and add to graph.
                 pos_xy = positions.get(nuuid)
                 if isinstance(pos_xy, (list, tuple)) and len(pos_xy) == 2:
                     try:
@@ -552,7 +523,6 @@ class NodeEditor(QWidget):
                 self.graph.add_node(node)
                 created[nuuid] = node
 
-            # 2) Apply sizes after items exist.
             for nuuid, wh in sizes.items():
                 item = self._uuid_to_item.get(nuuid)
                 if item and isinstance(wh, (list, tuple)) and len(wh) == 2:
@@ -562,53 +532,36 @@ class NodeEditor(QWidget):
                     except Exception:
                         pass
 
-            # 3) Recreate connections if possible.
             for cd in conns_norm:
                 cuuid = cd.get("uuid")
                 s_n = cd.get("src_node")
                 s_p = cd.get("src_prop")
                 d_n = cd.get("dst_node")
                 d_p = cd.get("dst_prop")
-
                 if not (s_n in created and d_n in created and isinstance(s_p, str) and isinstance(d_p, str)):
-                    self._dbg(f"load_layout: skip connection with missing nodes/props: {cd}")
                     continue
-
-                # Validate ports exist in current spec.
                 if s_p not in created[s_n].properties or d_p not in created[d_n].properties:
-                    self._dbg(f"load_layout: skip connection with non-existing port(s) in current spec: {cd}")
                     continue
-
-                # Check if connection is allowed in current graph state.
-                ok, reason = self.graph.can_connect((s_n, s_p), (d_n, d_p))
+                ok, _ = self.graph.can_connect((s_n, s_p), (d_n, d_p))
                 if not ok:
-                    self._dbg(f"load_layout: cannot connect ({s_n}.{s_p}) -> ({d_n}.{d_p}): {reason}")
                     continue
-
-                # Try to preserve original connection UUID if available.
                 conn_model = ConnectionModel(
                     uuid=cuuid if isinstance(cuuid, str) and cuuid else None,
                     src_node=s_n, src_prop=s_p,
                     dst_node=d_n, dst_prop=d_p
                 )
-                ok_add, reason_add = self.graph.add_connection(conn_model)
+                ok_add, _ = self.graph.add_connection(conn_model)
                 if not ok_add:
-                    # Fallback: let graph assign a fresh UUID (should rarely be needed).
-                    ok2, reason2, _ = self.graph.connect((s_n, s_p), (d_n, d_p))
-                    if not ok2:
-                        self._dbg(f"load_layout: failed to add connection even via connect(): {reason_add} / {reason2}")
+                    self.graph.connect((s_n, s_p), (d_n, d_p))
 
-            # 4) Sync ports after all nodes/connections are in place.
             for item in self._uuid_to_item.values():
                 if _qt_is_valid(item):
                     item.update_ports_positions()
 
-            # Rebuild Base ID counters based on the just-loaded layout.
             self._rebuild_base_id_counters()
-
             self._reapply_stylesheets()
+            self._update_status_label()
 
-            # Restore view state if present; otherwise center on content (backward compatible).
             vs = self._extract_view_state(data)
             if vs:
                 self._apply_view_state(vs)
@@ -616,7 +569,6 @@ class NodeEditor(QWidget):
                 self.center_on_content()
             return True
         finally:
-            # Always clear the loading flag even if exceptions happen during import.
             self._is_loading_layout = False
 
     def export_schema(self, as_list: bool = False) -> Union[dict, List[dict]]:
@@ -649,17 +601,13 @@ class NodeEditor(QWidget):
         """Create a NodeItem when a NodeModel is added to the graph."""
         if node.uuid in self._uuid_to_item:
             return
-
-        # Do not auto-increment Base ID here to avoid double steps.
-        # Base ID assignment is handled at the command/model creation stage (e.g. AddNodeCommand).
         pos = self._pending_node_positions.pop(node.uuid, None)
         if pos is None:
             pos = self._next_spawn_pos()
         self._dbg(f"graph.nodeAdded -> add item for node={node.name}({node.uuid}) at {pos}")
         self._add_node_item(node, pos)
-
-        # Keep Base ID counters in sync with newly added nodes.
         self._update_base_id_counters_from_node(node)
+        self._update_status_label()
 
     def _on_graph_node_removed(self, node_uuid: str):
         """Remove the NodeItem when model is removed from the graph."""
@@ -674,9 +622,8 @@ class NodeEditor(QWidget):
                 self.scene.removeItem(item)
             except Exception:
                 pass
-
-        # Rebuild Base ID counters after removal to reflect current layout state.
         self._rebuild_base_id_counters()
+        self._update_status_label()
 
     def _on_graph_connection_added(self, conn: ConnectionModel):
         """Create an EdgeItem when a ConnectionModel appears in the graph."""
@@ -705,36 +652,83 @@ class NodeEditor(QWidget):
         self._dbg("graph.cleared -> clear scene only")
         self._reset_interaction_states(remove_hidden_edges=True)
         self._clear_scene_only(hard=True)
-        # Reset Base ID counters on clear so next layout starts fresh.
         self._reset_base_id_counters()
+        self._update_status_label()
 
     # ---------- Scene helpers ----------
 
     def _scene_to_global(self, scene_pos: QPointF) -> QPoint:
         """Convert scene coordinates to a global screen QPoint."""
-        from PySide6.QtCore import QPoint as _QPoint
         vp_pt = self.view.mapFromScene(scene_pos)
-        if isinstance(vp_pt, QPointF):
-            vp_pt = _QPoint(int(vp_pt.x()), int(vp_pt.y()))
         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:
+            allowed = True if self.editing_allowed is None else bool(self.editing_allowed())
+        except Exception:
+            allowed = False
+        if not allowed:
+            return
+
         menu = QMenu(self.window())
         ss = self.window().styleSheet()
         if ss:
             menu.setStyleSheet(ss)
 
-        add_menu = menu.addMenu("Add")
+        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()
-        act_undo = QAction("Undo", menu)
-        act_redo = QAction("Redo", menu)
-        act_clear = QAction("Clear", menu)
+        act_undo = QAction(self.config.menu_undo(), menu)
+        act_redo = QAction(self.config.menu_redo(), menu)
+        act_clear = QAction(self.config.menu_clear(), menu)
         act_undo.setEnabled(self._undo.canUndo())
         act_redo.setEnabled(self._undo.canRedo())
         menu.addAction(act_undo)
@@ -754,7 +748,32 @@ 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 ----------
+
+    def raise_node_to_top(self, item: NodeItem):
+        """Bring the given node item to the front (dynamic z-order)."""
+        if not _qt_is_valid(item):
+            return
+        if not getattr(self, "_alive", True) or getattr(self, "_closing", False):
+            return
+        try:
+            self._z_top = float(self._z_top) if isinstance(self._z_top, (int, float)) else 2.0
+        except Exception:
+            self._z_top = 2.0
+        try:
+            cur = float(item.zValue())
+            if cur > self._z_top:
+                self._z_top = cur
+        except Exception:
+            pass
+        try:
+            self._z_top += 1.0
+            item.setZValue(self._z_top)
+        except Exception:
+            pass
 
     # ---------- Add/remove nodes/edges ----------
 
@@ -767,12 +786,16 @@ class NodeEditor(QWidget):
         """Create and place a NodeItem for the given NodeModel."""
         item = NodeItem(self, node)
         self.scene.addItem(item)
-        free_pos = self._find_free_position(scene_pos, item.size())
-        item.setPos(free_pos)
+        pos = scene_pos if not bool(self.enable_collisions) else self._find_free_position(scene_pos, item.size())
+        item.setPos(pos)
         item.update_ports_positions()
-        # From now on it's safe for itemChange to touch the scene/edges
+        if not bool(self.enable_collisions):
+            try:
+                self._z_top = float(self._z_top) + 1.0
+            except Exception:
+                self._z_top = 3.0
+            item.setZValue(self._z_top)
         item.mark_ready_for_scene_ops(True)
-
         self._uuid_to_item[node.uuid] = item
         self._apply_styles_to_content(item._content)
 
@@ -788,10 +811,8 @@ class NodeEditor(QWidget):
                     if r.intersects(other):
                         return True
             return False
-
         if not collides(desired):
             return desired
-
         x = y = 0
         dx, dy = 1, 0
         segment_length = 1
@@ -834,7 +855,6 @@ class NodeEditor(QWidget):
         if ex and _qt_is_valid(ex):
             self._dbg(f"_add_edge_for_connection: guard skip duplicate for uuid={conn.uuid}")
             return
-
         src_item = self._uuid_to_item.get(conn.src_node)
         dst_item = self._uuid_to_item.get(conn.dst_node)
         if not src_item or not dst_item:
@@ -903,33 +923,55 @@ class NodeEditor(QWidget):
             return wnd.palette()
         return QApplication.instance().palette() if QApplication.instance() else self.palette()
 
+    def _current_font(self) -> QFont:
+        """Return the active application/widget font to keep NodeEditor consistent with the app."""
+        wnd = self.window()
+        if isinstance(wnd, QWidget):
+            return wnd.font()
+        app = QApplication.instance()
+        if app:
+            return app.font()
+        return self.font()
+
     def _apply_styles_to_content(self, content_widget: QWidget):
-        """Propagate palette and stylesheet to the embedded content widget subtree."""
+        """Propagate palette, font and stylesheet to the embedded content widget subtree."""
         if content_widget is None:
             return
         content_widget.setAttribute(Qt.WA_StyledBackground, True)
         stylesheet = self._current_stylesheet()
         pal = self._current_palette()
+        font = self._current_font()
         content_widget.setPalette(pal)
+        content_widget.setFont(font)
         if stylesheet:
             content_widget.setStyleSheet(stylesheet)
         content_widget.ensurePolished()
         for w in content_widget.findChildren(QWidget):
+            w.setPalette(pal)
+            w.setFont(font)
+            if stylesheet:
+                w.setStyleSheet(stylesheet)
             w.ensurePolished()
 
     def _reapply_stylesheets(self):
-        """Reapply palette and stylesheet to all NodeContentWidget instances."""
+        """Reapply palette, font and stylesheet to all NodeContentWidget instances."""
         if not getattr(self, "_alive", True) or getattr(self, "_closing", False):
             return
         stylesheet = self._current_stylesheet()
         pal = self._current_palette()
+        font = self._current_font()
         for item in self._uuid_to_item.values():
             if item._content and _qt_is_valid(item._content):
                 item._content.setPalette(pal)
+                item._content.setFont(font)
                 if stylesheet:
                     item._content.setStyleSheet(stylesheet)
                 item._content.ensurePolished()
                 for w in item._content.findChildren(QWidget):
+                    w.setPalette(pal)
+                    w.setFont(font)
+                    if stylesheet:
+                        w.setStyleSheet(stylesheet)
                     w.ensurePolished()
 
     # ---------- Edge/Port helpers + rewire ----------
@@ -1349,7 +1391,7 @@ class NodeEditor(QWidget):
             return
 
         self._dbg(f"Delete shortcut -> nodes={len(nodes)}, edges={len(edges)} (undoable)")
-        self._undo.beginMacro("Delete selection")
+        self._undo.beginMacro(self.config.macro_delete_selection())
         try:
             for n in nodes:
                 # Push per-node undoable deletion (restores its own connections)
@@ -2035,4 +2077,32 @@ class NodeEditor(QWidget):
                 "dst_prop": c.dst_prop,
             }
 
-        return {"nodes": nodes_out, "connections": conns_out}
+        return {"nodes": nodes_out, "connections": conns_out}
+
+    # ---------- Overlay controls handlers ----------
+
+    def _on_grab_toggled(self, enabled: bool):
+        """Enable/disable global grab mode (left-button panning anywhere)."""
+        if _qt_is_valid(self.view):
+            self.view.set_global_grab_mode(bool(enabled))
+        # Visual feedback is provided by the checkable state (style handles appearance)
+
+    # ---------- Status label ----------
+
+    def _update_status_label(self):
+        """Compute node counts by type and update bottom-left status label."""
+        try:
+            counts: Dict[str, int] = {}
+            unknown = self.config.type_unknown()
+            for n in self.graph.nodes.values():
+                t = getattr(n, "type", unknown) or unknown
+                counts[t] = counts.get(t, 0) + 1
+            if not counts:
+                text = self.config.status_no_nodes()
+            else:
+                parts = [f"{k}: {counts[k]}" for k in sorted(counts.keys(), key=lambda s: s.lower())]
+                text = ", ".join(parts)
+            self._status.set_text(text)
+            self._position_status_label()
+        except Exception:
+            pass