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

pygpt_net/ui/widget/node_editor/item.py

@@ -6,7 +6,7 @@
 # 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.25 12:05:00                  #
 # ================================================== #
 
 from __future__ import annotations
@@ -140,20 +140,16 @@ class PortItem(QGraphicsObject):
         except Exception:
             pass
         cap_val = self._allowed_capacity()
+        cfg = self.node_item.editor.config
         if isinstance(cap_val, int):
             if cap_val < 0:
-                cap_str = "unlimited (∞)"
+                cap_str = cfg.cap_unlimited()
             else:
                 cap_str = str(cap_val)
         else:
-            cap_str = "n/a"
-        tip = (
-            f"Node: {node_name}\n"
-            f"Port: {self.side.upper()} • {self.prop_id}\n"
-            f"Allowed connections: {cap_str}\n\n"
-            f"Click: start a new connection\n"
-            f"Ctrl+Click: rewire/detach existing"
-        )
+            cap_str = cfg.cap_na()
+        side_label = cfg.side_label(self.side).upper()
+        tip = cfg.port_tooltip(node_name, side_label, self.prop_id, cap_str)
         self.setToolTip(tip)
         try:
             self._label_cap.setToolTip(tip)
@@ -225,6 +221,11 @@ class PortItem(QGraphicsObject):
     def mousePressEvent(self, e):
         """Emit portClicked on left click to begin a connection or rewire."""
         if e.button() == Qt.LeftButton:
+            try:
+                # Bring parent node to front when clicking the port
+                self.node_item.editor.raise_node_to_top(self.node_item)
+            except Exception:
+                pass
             self.node_item.editor._dbg(f"Port clicked: side={self.side}, node={self.node_item.node.name}({self.node_item.node.uuid}), prop={self.prop_id}, connected_count={self._connected_count}")
             self.portClicked.emit(self)
             e.accept()
@@ -355,7 +356,7 @@ class EdgeItem(QGraphicsPathItem):
         ss = self._editor.window().styleSheet()
         if ss:
             menu.setStyleSheet(ss)
-        act_del = QAction("Delete connection", menu)
+        act_del = QAction(self._editor.config.edge_context_delete(), menu)
         menu.addAction(act_del)
         chosen = menu.exec(event.screenPos())
         if chosen == act_del:

pygpt_net/ui/widget/node_editor/node.py

@@ -6,14 +6,14 @@
 # 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.25 15:32:39                  #
 # ================================================== #
 
 from __future__ import annotations
 import re
-from typing import Dict, Optional, List, Any
+from typing import Dict, Optional, List, Any, Tuple
 
-from PySide6.QtCore import Qt, QPointF, QRectF, QSizeF, Signal,QEvent
+from PySide6.QtCore import Qt, QPointF, QRectF, QSizeF, Signal, QEvent
 from PySide6.QtGui import QAction, QBrush, QColor, QPainter, QPainterPath, QPen
 from PySide6.QtWidgets import (
     QWidget, QApplication, QGraphicsItem, QGraphicsWidget, QGraphicsProxyWidget, QStyleOptionGraphicsItem,
@@ -86,12 +86,65 @@ class SingleLineTextEdit(QTextEdit):
             c.setPosition(min(pos, len(t2)))
             self.setTextCursor(c)
 
+    def _apply_menu_theme(self, menu: QMenu):
+        """Apply app/window stylesheet + palette + font to context menu."""
+        try:
+            wnd = self.window()
+        except Exception:
+            wnd = None
+        stylesheet = ""
+        pal = None
+        font = None
+        try:
+            if wnd:
+                stylesheet = wnd.styleSheet() or ""
+                pal = wnd.palette()
+                font = wnd.font()
+        except Exception:
+            pass
+        try:
+            app = QApplication.instance()
+            if app:
+                if not stylesheet and app.styleSheet():
+                    stylesheet = app.styleSheet()
+                if pal is None:
+                    pal = app.palette()
+                if font is None:
+                    font = app.font()
+        except Exception:
+            pass
+        try:
+            if pal:
+                menu.setPalette(pal)
+            if font:
+                menu.setFont(font)
+            if stylesheet:
+                menu.setStyleSheet(stylesheet)
+            menu.ensurePolished()
+        except Exception:
+            pass
+
+    def contextMenuEvent(self, e):
+        """Ensure standard context menu follows app-wide (e.g., Qt Material) styling."""
+        try:
+            menu = self.createStandardContextMenu()
+        except Exception:
+            return super().contextMenuEvent(e)
+        self._apply_menu_theme(menu)
+        try:
+            menu.exec(e.globalPos())
+        finally:
+            try:
+                menu.deleteLater()
+            except Exception:
+                pass
+
 
 class NodeContentWidget(QWidget):
     """Form-like widget that renders property editors for a node.
 
     The widget builds appropriate Qt editors based on PropertyModel.type:
-        - "str": QLineEdit
+        - "str": QLineEdit-like (SingleLineTextEdit with placeholder support)
         - "text": QTextEdit
         - "int": QSpinBox
         - "float": QDoubleSpinBox
@@ -103,6 +156,8 @@ class NodeContentWidget(QWidget):
 
     Notes:
         - For Base ID-like properties, the field is read-only; a composed display value is shown.
+        - Placeholder and description are applied when provided in the type spec or model
+          (description is shown as tooltip on both the editor and its label).
         - ShortcutOverride is handled so typing in editors does not trigger scene shortcuts.
 
     Signal:
@@ -125,7 +180,24 @@ class NodeContentWidget(QWidget):
         self._editors: Dict[str, QWidget] = {}
         for pid, pm in node.properties.items():
             editable = self._editable_from_spec(pid, pm)
+
+            # Resolve UI hints: placeholder and description from spec (fallback to model)
+            placeholder = self._spec_text_attr(pid, "placeholder")
+            try:
+                if not placeholder and hasattr(pm, "placeholder") and getattr(pm, "placeholder") not in (None, ""):
+                    placeholder = str(getattr(pm, "placeholder"))
+            except Exception:
+                pass
+            description = self._spec_text_attr(pid, "description")
+            try:
+                if not description and hasattr(pm, "description") and getattr(pm, "description") not in (None, ""):
+                    description = str(getattr(pm, "description"))
+            except Exception:
+                pass
+
             w: QWidget
+            extra_tooltip: Optional[str] = None  # used e.g. for capacity hints
+
             if pm.type == "str":
                 te = SingleLineTextEdit()
                 te.setFocusPolicy(Qt.StrongFocus)
@@ -145,17 +217,31 @@ class NodeContentWidget(QWidget):
                     te.setReadOnly(not editable)
 
                 te.setPlainText(txt)
+                if placeholder:
+                    try:
+                        te.setPlaceholderText(placeholder)
+                    except Exception:
+                        pass
                 te.textChanged.connect(lambda pid=pid, te=te: self.valueChanged.emit(pid, te.toPlainText()))
                 te.editingFinished.connect(lambda pid=pid, te=te: self.valueChanged.emit(pid, te.toPlainText()))
                 w = te
+
             elif pm.type == "text":
                 te = QTextEdit()
                 te.setFocusPolicy(Qt.StrongFocus)
                 if pm.value is not None:
                     te.setPlainText(str(pm.value))
                 te.setReadOnly(not editable)
+                if placeholder:
+                    try:
+                        te.setPlaceholderText(placeholder)
+                    except Exception:
+                        pass
                 te.textChanged.connect(lambda pid=pid, te=te: self.valueChanged.emit(pid, te.toPlainText()))
+                # Ensure context menu follows global (Material) style
+                self._install_styled_context_menu(te)
                 w = te
+
             elif pm.type == "int":
                 w = QSpinBox()
                 w.setFocusPolicy(Qt.StrongFocus)
@@ -163,7 +249,10 @@ class NodeContentWidget(QWidget):
                 if pm.value is not None:
                     w.setValue(int(pm.value))
                 w.setEnabled(editable)
+
+                # QSpinBox has no placeholder; use tooltip only
                 w.valueChanged.connect(lambda v, pid=pid: self.valueChanged.emit(pid, int(v)))
+
             elif pm.type == "float":
                 w = QDoubleSpinBox()
                 w.setFocusPolicy(Qt.StrongFocus)
@@ -173,6 +262,7 @@ class NodeContentWidget(QWidget):
                     w.setValue(float(pm.value))
                 w.setEnabled(editable)
                 w.valueChanged.connect(lambda v, pid=pid: self.valueChanged.emit(pid, float(v)))
+
             elif pm.type == "bool":
                 w = QCheckBox()
                 w.setFocusPolicy(Qt.StrongFocus)
@@ -180,6 +270,7 @@ class NodeContentWidget(QWidget):
                     w.setChecked(bool(pm.value))
                 w.setEnabled(editable)
                 w.toggled.connect(lambda v, pid=pid: self.valueChanged.emit(pid, bool(v)))
+
             elif pm.type == "combo":
                 w = QComboBox()
                 w.setFocusPolicy(Qt.StrongFocus)
@@ -188,20 +279,92 @@ class NodeContentWidget(QWidget):
                 if pm.value is not None and pm.value in (pm.options or []):
                     w.setCurrentText(pm.value)
                 w.setEnabled(editable)
+                # QComboBox placeholder works when editable; we keep non-editable by default
                 w.currentTextChanged.connect(lambda v, pid=pid: self.valueChanged.emit(pid, v))
+
             else:
                 # Render a read-only capacity placeholder for port-like properties ("input/output").
                 cap_text = self._capacity_text_for_property(pid, pm)
                 w = QLabel(cap_text)
                 w.setEnabled(False)
-                w.setToolTip(f"Allowed connections (IN/OUT): {cap_text}")
+                extra_tooltip = self.editor.config.port_capacity_tooltip(cap_text)
 
             name = self._display_name_for_property(pid, pm)
             if name == "Base ID":
-                name = "ID"
+                name = self.editor.config.label_id()
             self.form.addRow(name, w)
             self._editors[pid] = w
 
+            # Apply tooltip(s) after the row is created so we can also set the label tooltip
+            if description or extra_tooltip:
+                final_tt_parts: List[str] = []
+                if description:
+                    final_tt_parts.append(description)
+                if extra_tooltip:
+                    final_tt_parts.append(extra_tooltip)
+                final_tt = "\n".join(final_tt_parts)
+                try:
+                    w.setToolTip(final_tt)
+                except Exception:
+                    pass
+                try:
+                    lbl = self.form.labelForField(w)
+                    if lbl is not None:
+                        lbl.setToolTip(description or "")
+                except Exception:
+                    pass
+
+    def _install_styled_context_menu(self, te: QTextEdit):
+        """Install a custom context menu handler that applies global styles."""
+        try:
+            te.setContextMenuPolicy(Qt.CustomContextMenu)
+            te.customContextMenuRequested.connect(
+                lambda pos, _te=te: self._show_styled_standard_menu(_te, pos)
+            )
+        except Exception:
+            pass
+
+    def _show_styled_standard_menu(self, te: QTextEdit, pos):
+        """Create standard menu and apply app/window stylesheet + palette + font."""
+        try:
+            menu = te.createStandardContextMenu()
+        except Exception:
+            return
+        stylesheet = ""
+        pal = None
+        font = None
+        try:
+            # Prefer editor helpers (consistent with the rest of NodeEditor)
+            stylesheet = self.editor._current_stylesheet()
+            pal = self.editor._current_palette()
+            font = self.editor._current_font()
+        except Exception:
+            try:
+                wnd = te.window()
+                if wnd:
+                    stylesheet = wnd.styleSheet() or ""
+                    pal = wnd.palette()
+                    font = wnd.font()
+            except Exception:
+                pass
+        try:
+            if pal:
+                menu.setPalette(pal)
+            if font:
+                menu.setFont(font)
+            if stylesheet:
+                menu.setStyleSheet(stylesheet)
+            menu.ensurePolished()
+        except Exception:
+            pass
+        try:
+            menu.exec(te.mapToGlobal(pos))
+        finally:
+            try:
+                menu.deleteLater()
+            except Exception:
+                pass
+
     def event(self, e):
         """
         Filter ShortcutOverride so editor keystrokes are not eaten by the scene.
@@ -481,6 +644,55 @@ class NodeContentWidget(QWidget):
 
         return None
 
+    # --- Spec helpers for UI hints ---
+
+    def _get_prop_spec(self, pid: str) -> Optional[Any]:
+        """Return a property specification object from the registry for this node type."""
+        try:
+            reg = self.graph.registry
+            if not reg:
+                return None
+            type_spec = reg.get(self.node.type)
+            if not type_spec:
+                return None
+
+            for attr in ("properties", "props", "fields", "ports", "inputs", "outputs"):
+                try:
+                    cont = getattr(type_spec, attr, None)
+                    if isinstance(cont, dict) and pid in cont:
+                        return cont[pid]
+                except Exception:
+                    pass
+            for meth in ("get_property", "property_spec", "get_prop", "prop", "property"):
+                if hasattr(type_spec, meth):
+                    try:
+                        return getattr(type_spec, meth)(pid)
+                    except Exception:
+                        pass
+        except Exception:
+            pass
+        return None
+
+    def _spec_text_attr(self, pid: str, key: str) -> Optional[str]:
+        """Get a string attribute (e.g., 'placeholder', 'description') from spec if available."""
+        obj = self._get_prop_spec(pid)
+        if obj is None:
+            return None
+        try:
+            v = getattr(obj, key, None)
+            if isinstance(v, str) and v != "":
+                return v
+        except Exception:
+            pass
+        try:
+            if isinstance(obj, dict):
+                v = obj.get(key)
+                if isinstance(v, str) and v != "":
+                    return v
+        except Exception:
+            pass
+        return None
+
 
 class NodeItem(QGraphicsWidget):
     """Rounded node with title and ports aligned to property rows.
@@ -854,6 +1066,14 @@ class NodeItem(QGraphicsWidget):
         if self._resizing:
             return
 
+        # When global grab mode is active, suppress resize/move cursors
+        view = self.editor.view
+        if getattr(view, "_global_grab_mode", False):
+            self._hover_resize_mode = "none"
+            self.unsetCursor()
+            self.update()
+            return
+
         mode = self._hit_resize_zone(pos)
         self._hover_resize_mode = mode
 
@@ -891,9 +1111,9 @@ class NodeItem(QGraphicsWidget):
         self.update()
 
     def hoverMoveEvent(self, event):
-        """While panning is active, suppress resize hints; otherwise update hover state."""
+        """While panning is active or global grab is enabled, suppress resize hints; otherwise update hover state."""
         view = self.editor.view
-        if getattr(view, "_panning", False):
+        if getattr(view, "_panning", False) or getattr(view, "_global_grab_mode", False):
             self._hover_resize_mode = "none"
             self.unsetCursor()
             self.update()
@@ -912,6 +1132,17 @@ class NodeItem(QGraphicsWidget):
 
     def mousePressEvent(self, event):
         """Start resize when pressing the proper zone; otherwise begin move drag."""
+        # Always bring clicked node to front (dynamic z-order)
+        try:
+            self.editor.raise_node_to_top(self)
+        except Exception:
+            pass
+
+        # If global grab is active, do not initiate node drag/resize (view handles panning)
+        if getattr(self.editor.view, "_global_grab_mode", False) and event.button() == Qt.LeftButton:
+            event.ignore()
+            return
+
         if event.button() == Qt.LeftButton:
             mode = self._hit_resize_zone(event.pos())
             if mode != "none":
@@ -971,7 +1202,7 @@ class NodeItem(QGraphicsWidget):
             return
 
         if self._dragging and event.button() == Qt.LeftButton:
-            if self._overlaps:
+            if bool(getattr(self.editor, "enable_collisions", True)) and self._overlaps:
                 self.setPos(self._last_valid_pos)
             else:
                 if self.pos() != self._start_pos:
@@ -1047,6 +1278,14 @@ class NodeItem(QGraphicsWidget):
                 if _qt_is_valid(self._overlay):
                     self._overlay.update()
                 return False
+
+            if obj is self._content and et == QEvent.MouseButtonPress:
+                # Bring to front when clicking inside embedded editors (proxy widget area)
+                try:
+                    self.editor.raise_node_to_top(self)
+                except Exception:
+                    pass
+                return False
         except Exception:
             pass
         return False
@@ -1065,6 +1304,11 @@ class NodeItem(QGraphicsWidget):
                 if not getattr(self, "_dragging", False):
                     return value
 
+                # When collisions are disabled, skip overlap checks entirely
+                if not bool(getattr(self.editor, "enable_collisions", True)):
+                    self._overlaps = False
+                    return value
+
                 sc = self.scene()
                 if sc is None or not _qt_is_valid(sc):
                     return value
@@ -1115,6 +1359,17 @@ class NodeItem(QGraphicsWidget):
                 pass
             return super().itemChange(change, value)
 
+        if change == QGraphicsItem.ItemSelectedHasChanged:
+            # Bring newly selected node to front as well (e.g., rubber-band selection)
+            try:
+                ed = getattr(self, "editor", None)
+                if ed and getattr(ed, "_alive", True) and not getattr(ed, "_closing", False):
+                    if self.isSelected():
+                        ed.raise_node_to_top(self)
+            except Exception:
+                pass
+            return super().itemChange(change, value)
+
         return super().itemChange(change, value)
 
     def contextMenuEvent(self, event):
@@ -1123,15 +1378,15 @@ class NodeItem(QGraphicsWidget):
         ss = self.editor.window().styleSheet()
         if ss:
             menu.setStyleSheet(ss)
-        act_rename = QAction("Rename", menu)
-        act_delete = QAction("Delete", menu)
+        act_rename = QAction(self.editor.config.node_context_rename(), menu)
+        act_delete = QAction(self.editor.config.node_context_delete(), menu)
         menu.addAction(act_rename)
         menu.addSeparator()
         menu.addAction(act_delete)
         chosen = menu.exec(event.screenPos())
         if chosen == act_rename:
             from PySide6.QtWidgets import QInputDialog
-            new_name, ok = QInputDialog.getText(self.editor.window(), "Rename Node", "Name:", text=self.node.name)
+            new_name, ok = QInputDialog.getText(self.editor.window(), self.editor.config.rename_dialog_title(), self.editor.config.rename_dialog_label(), text=self.node.name)
             if ok and new_name:
                 self.node.name = new_name
                 self.update()