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

pygpt_net/ui/widget/node_editor/view.py

@@ -6,15 +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 03:00:00                  #
 # ================================================== #
 
 from __future__ import annotations
 from typing import Optional, Tuple
 
-from PySide6.QtCore import Qt, QPointF, QRectF, QObject, Signal
-from PySide6.QtGui import QColor, QPainter, QPen, QTransform
-from PySide6.QtWidgets import QWidget, QGraphicsView, QGraphicsScene
+from PySide6.QtCore import Qt, QPointF, QRectF, QObject, Signal, QSize, QEvent
+from PySide6.QtGui import QColor, QPainter, QPen, QTransform, QIcon
+from PySide6.QtWidgets import QWidget, QGraphicsView, QGraphicsScene, QPushButton, QHBoxLayout, QLabel
+
+from .config import EditorConfig
 
 
 # ------------------------ Graphics View / Scene ------------------------
@@ -26,14 +28,7 @@ class NodeGraphicsView(QGraphicsView):
     - Ctrl + Mouse Wheel zooming
     - Middle Mouse Button panning
     - Rubber band selection
-
-    Notes:
-        - Space-panning is intentionally disabled to not conflict with typing in editors.
-        - All keyboard shortcuts (e.g., Delete) are handled at the NodeEditor level.
-
-    Args:
-        scene: Shared QGraphicsScene instance for the editor.
-        parent: Optional parent widget.
+    - Optional left-button panning only when global grab mode is enabled
     """
     def __init__(self, scene: QGraphicsScene, parent: Optional[QWidget] = None):
         super().__init__(scene, parent)
@@ -53,17 +48,10 @@ class NodeGraphicsView(QGraphicsView):
 
         self._panning = False
         self._last_pan_pos = None
+        self._global_grab_mode = False  # when True, left button pans regardless of items
 
     def drawBackground(self, painter: QPainter, rect: QRectF):
-        """Draw the checker grid in the background.
-
-        The grid spacing is fixed (20 px). Colors are read from the owning NodeEditor
-        instance if available, which allows dynamic theming.
-
-        Args:
-            painter: Active QPainter provided by Qt.
-            rect: The exposed background rect to be filled.
-        """
+        """Draw the checker grid in the background."""
         parent_editor = self.parent()  # NodeEditor
         color_back = getattr(parent_editor, "_grid_back_color", QColor(35, 35, 38))
         color_pen = getattr(parent_editor, "_grid_pen_color", QColor(55, 55, 60))
@@ -83,15 +71,23 @@ class NodeGraphicsView(QGraphicsView):
             painter.drawLine(rect.left(), y, rect.right(), y)
             y += grid
 
-    def keyPressEvent(self, e):
-        """Pass-through: the view does not handle special keys.
+    def enterEvent(self, e: QEvent):
+        """Ensure cursor reflects grab mode when entering the view."""
+        if self._global_grab_mode and not self._panning:
+            self.viewport().setCursor(Qt.OpenHandCursor)
+        else:
+            self.viewport().setCursor(Qt.ArrowCursor)
+        super().enterEvent(e)
+
+    def leaveEvent(self, e: QEvent):
+        """Restore cursor on leave."""
+        self.viewport().setCursor(Qt.ArrowCursor)
+        super().leaveEvent(e)
 
-        ESC and other keys are intentionally left for the host application/editor.
-        """
+    def keyPressEvent(self, e):
         super().keyPressEvent(e)
 
     def keyReleaseEvent(self, e):
-        """Pass-through for key release."""
         super().keyReleaseEvent(e)
 
     def wheelEvent(self, e):
@@ -102,14 +98,47 @@ class NodeGraphicsView(QGraphicsView):
             return
         super().wheelEvent(e)
 
+    def _begin_pan(self, e):
+        """Start panning from current mouse event position."""
+        self._panning = True
+        self._last_pan_pos = e.position()
+        # Use 'grab' during drag
+        self.viewport().setCursor(Qt.ClosedHandCursor)
+        e.accept()
+
+    def _end_pan(self, e):
+        """Stop panning and restore appropriate cursor."""
+        self._panning = False
+        if self._global_grab_mode:
+            self.viewport().setCursor(Qt.OpenHandCursor)
+        else:
+            self.viewport().setCursor(Qt.ArrowCursor)
+        e.accept()
+
+    def _clicked_on_empty(self, e) -> bool:
+        """Return True if the click is on empty scene space (no items)."""
+        try:
+            item = self.itemAt(int(e.position().x()), int(e.position().y()))
+            return item is None
+        except Exception:
+            return False
+
     def mousePressEvent(self, e):
-        """Start panning with Middle Mouse Button; otherwise defer to base implementation."""
+        """Panning: MMB always; LMB only in global grab mode. Also clear selection on empty click."""
         if e.button() == Qt.MiddleButton:
-            self._panning = True
-            self._last_pan_pos = e.position()
-            self.setCursor(Qt.ClosedHandCursor)
-            e.accept()
+            self._begin_pan(e)
             return
+
+        if e.button() == Qt.LeftButton:
+            if self._global_grab_mode:
+                # Global grab enabled -> pan on LMB anywhere
+                self._begin_pan(e)
+                return
+            else:
+                # No global grab: clicking empty clears selection
+                if self._clicked_on_empty(e) and self.scene():
+                    self.scene().clearSelection()
+
         super().mousePressEvent(e)
 
     def mouseMoveEvent(self, e):
@@ -124,11 +153,9 @@ class NodeGraphicsView(QGraphicsView):
         super().mouseMoveEvent(e)
 
     def mouseReleaseEvent(self, e):
-        """Stop panning on Middle Mouse Button release; otherwise defer."""
-        if self._panning and e.button() == Qt.MiddleButton:
-            self._panning = False
-            self.setCursor(Qt.ArrowCursor)
-            e.accept()
+        """Stop panning on Middle or Left Mouse Button release; otherwise defer."""
+        if self._panning and e.button() in (Qt.MiddleButton, Qt.LeftButton):
+            self._end_pan(e)
             return
         super().mouseReleaseEvent(e)
 
@@ -141,15 +168,7 @@ class NodeGraphicsView(QGraphicsView):
         self._apply_zoom(1.0 / self._zoom_step)
 
     def _apply_zoom(self, factor: float):
-        """Apply zoom scaling factor within configured bounds.
-
-        Args:
-            factor: Multiplicative factor to apply to the current zoom.
-
-        Notes:
-            The method clamps the result to [_min_zoom, _max_zoom] to prevent
-            excessive zooming.
-        """
+        """Apply zoom scaling factor within configured bounds."""
         new_zoom = self._zoom * factor
         if not (self._min_zoom <= new_zoom <= self._max_zoom):
             return
@@ -169,7 +188,6 @@ class NodeGraphicsView(QGraphicsView):
         if keep_center and self.viewport() is not None and self.viewport().rect().isValid():
             center_scene = self.mapToScene(self.viewport().rect().center())
 
-        # Reset and apply new transform to avoid cumulative floating errors
         self.resetTransform()
         self._zoom = 1.0
         if abs(z - 1.0) > 1e-9:
@@ -180,25 +198,21 @@ class NodeGraphicsView(QGraphicsView):
             self.centerOn(center_scene)
 
     def get_scroll_values(self) -> Tuple[int, int]:
-        """Return (horizontal, vertical) scrollbar values."""
         h = self.horizontalScrollBar().value() if self.horizontalScrollBar() else 0
         v = self.verticalScrollBar().value() if self.verticalScrollBar() else 0
         return int(h), int(v)
 
     def set_scroll_values(self, h: int, v: int):
-        """Set horizontal and vertical scrollbar values."""
         if self.horizontalScrollBar():
             self.horizontalScrollBar().setValue(int(h))
         if self.verticalScrollBar():
             self.verticalScrollBar().setValue(int(v))
 
     def view_state(self) -> dict:
-        """Return a serializable view state: zoom and scrollbars."""
         h, v = self.get_scroll_values()
         return {"zoom": float(self._zoom), "h": h, "v": v}
 
     def set_view_state(self, state: dict):
-        """Apply a view state previously produced by view_state()."""
         if not isinstance(state, dict):
             return
         z = state.get("zoom") or state.get("scale")
@@ -213,35 +227,137 @@ class NodeGraphicsView(QGraphicsView):
             if h is not None:
                 self.set_scroll_values(int(h), int(v if v is not None else 0))
             elif v is not None:
-                # set vertical if only v present
                 self.set_scroll_values(self.get_scroll_values()[0], int(v))
         except Exception:
             pass
 
+    def set_global_grab_mode(self, enabled: bool):
+        """Enable/disable global grab mode (left click pans anywhere)."""
+        self._global_grab_mode = bool(enabled)
+        if self._global_grab_mode:
+            self.viewport().setCursor(Qt.OpenHandCursor)
+        else:
+            if not self._panning:
+                self.viewport().setCursor(Qt.ArrowCursor)
+
+
+class NodeViewOverlayControls(QWidget):
+    """Small overlay with three buttons (Grab toggle, Zoom Out, Zoom In) anchored top-right."""
+
+    grabToggled = Signal(bool)
+    zoomInClicked = Signal()
+    zoomOutClicked = Signal()
+
+    def __init__(self, parent: Optional[QWidget] = None):
+        super().__init__(parent)
+        self.setObjectName("NodeViewOverlayControls")
+        self.setAttribute(Qt.WA_StyledBackground, True)
+
+        layout = QHBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(8)
+
+        cfg = self._cfg()
+
+        # Grab (toggle)
+        self.btnGrab = QPushButton(self)
+        self.btnGrab.setCheckable(True)
+        self.btnGrab.setToolTip(cfg.overlay_grab_tooltip())
+        self.btnGrab.setIcon(QIcon(":/icons/drag.svg"))
+        self.btnGrab.setIconSize(QSize(20, 20))
+        self.btnGrab.setMinimumSize(25, 25)
+
+        # Zoom Out
+        self.btnZoomOut = QPushButton(self)
+        self.btnZoomOut.setToolTip(cfg.overlay_zoom_out_tooltip())
+        self.btnZoomOut.setIcon(QIcon(":/icons/zoom_out.svg"))
+        self.btnZoomOut.setIconSize(QSize(20, 20))
+        self.btnZoomOut.setMinimumSize(25, 25)
+
+        # Zoom In
+        self.btnZoomIn = QPushButton(self)
+        self.btnZoomIn.setToolTip(cfg.overlay_zoom_in_tooltip())
+        self.btnZoomIn.setIcon(QIcon(":/icons/zoom_in.svg"))
+        self.btnZoomIn.setIconSize(QSize(20, 20))
+        self.btnZoomIn.setMinimumSize(25, 25)
+
+        layout.addWidget(self.btnGrab)
+        layout.addWidget(self.btnZoomIn)        
+        layout.addWidget(self.btnZoomOut)
+
+        self.btnGrab.toggled.connect(self.grabToggled.emit)
+        self.btnZoomIn.clicked.connect(self.zoomInClicked.emit)
+        self.btnZoomOut.clicked.connect(self.zoomOutClicked.emit)
+
+        self.show()
+
+    def _cfg(self) -> EditorConfig:
+        p = self.parent()
+        c = getattr(p, "config", None) if p is not None else None
+        return c if isinstance(c, EditorConfig) else EditorConfig()
+
+
+class NodeViewStatusLabel(QWidget):
+    """Fixed status overlay pinned to bottom-left that shows node type counts."""
+
+    def __init__(self, parent: Optional[QWidget] = None):
+        super().__init__(parent)
+        self.setObjectName("NodeViewStatusLabel")
+        self.setAttribute(Qt.WA_StyledBackground, True)
+
+        self._lbl = QLabel(self)
+        cfg = self._cfg()
+        self._lbl.setText(cfg.status_no_nodes())
+
+        layout = QHBoxLayout(self)
+        layout.setContentsMargins(8, 4, 8, 4)  # some padding around the text
+        layout.setSpacing(0)
+        layout.addWidget(self._lbl)
+
+        self.adjustSize()
+        self.show()
+
+    def _cfg(self) -> EditorConfig:
+        p = self.parent()
+        c = getattr(p, "config", None) if p is not None else None
+        return c if isinstance(c, EditorConfig) else EditorConfig()
+
+    def set_text(self, text: str):
+        self._lbl.setText(text)
+        # Safe: adjustSize() uses sizeHint(), which no longer calls adjustSize()
+        self.adjustSize()
+
+    def sizeHint(self):
+        """Return hint based on layout/label without calling adjustSize()."""
+        if self.layout() is not None:
+            return self.layout().sizeHint()
+        return self._lbl.sizeHint()
+
 
 class NodeGraphicsScene(QGraphicsScene):
     """Graphics scene extended with custom context menu emission."""
     sceneContextRequested = Signal(QPointF)
 
     def __init__(self, parent: Optional[QObject] = None):
-        """Initialize the scene and set a very large scene rect.
-
-        Using a large default rect avoids sudden scene rect changes while panning/zooming.
-        """
+        """Initialize the scene and set a very large scene rect."""
         super().__init__(parent)
         self.setSceneRect(-5000, -5000, 10000, 10000)
 
     def contextMenuEvent(self, event):
-        """Emit a scene-level context menu request when clicking empty space.
-
-        If the click is not on any item, the signal sceneContextRequested is emitted with
-        the scene position. Otherwise, default handling is used (propagating to items).
-        """
+        """Emit a scene-level context menu request when clicking empty space."""
         transform = self.views()[0].transform() if self.views() else QTransform()
         item = self.itemAt(event.scenePos(), transform)
         if item is None:
-            self.sceneContextRequested.emit(event.scenePos())
+            # Respect external edit permission if available on parent editor
+            editor = self.parent()
+            allowed = True
+            try:
+                if hasattr(editor, "editing_allowed") and callable(editor.editing_allowed):
+                    allowed = bool(editor.editing_allowed())
+            except Exception:
+                allowed = False
+            if allowed:
+                self.sceneContextRequested.emit(event.scenePos())
             event.accept()
             return
-        super().contextMenuEvent(event)
-
+        super().contextMenuEvent(event)

pygpt_net/ui/widget/tabs/output.py

@@ -311,7 +311,7 @@ class AddButton(QPushButton):
         )
         self.setObjectName('tab-add')
         self.setProperty('tabAdd', True)
-        self.setToolTip(trans('action.tab.add.chat'))
+        self.setToolTip(trans('action.tab.add.chat.tooltip'))
 
     def mousePressEvent(self, event):
         """

pygpt_net/ui/widget/textarea/input.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.22 12:00:00                  #
+# Updated Date: 2025.09.26 12:00:00                  #
 # ================================================== #
 
 from typing import Optional
@@ -62,8 +62,8 @@ class ChatInput(QTextEdit):
         self._icons_margin = 6           # inner left/right padding around the bar
         self._icons_spacing = 4          # spacing between buttons
         self._icons_offset_y = -4        # small upward shift (visual alignment)
-        self._icon_size = QSize(18, 18)  # icon size (matches your original)
-        self._btn_size = QSize(24, 24)   # button size (w x h), matches previous QPushButton
+        self._icon_size = QSize(18, 18)  # icon size (matches original)
+        self._btn_size = QSize(24, 24)   # button size (w x h), matches QPushButton
 
         # Storage for icon buttons and metadata
         self._icons = {}       # key -> QPushButton
@@ -94,8 +94,8 @@ class ChatInput(QTextEdit):
             key="web",
             icon=self.ICON_WEB_OFF,
             alt_icon=self.ICON_WEB_ON,
-            tooltip=trans('icon.remote_tool.web'),
-            alt_tooltip=trans('icon.remote_tool.web'),
+            tooltip=trans('icon.remote_tool.web.disabled'),
+            alt_tooltip=trans('icon.remote_tool.web.enabled'),
             callback=self.action_toggle_web,
             visible=True,
         )
@@ -124,6 +124,9 @@ class ChatInput(QTextEdit):
         self._tokens_timer.timeout.connect(self.window.controller.ui.update_tokens)
         self.textChanged.connect(self._on_text_changed_tokens)
 
+        # Paste/input safety limits
+        self._paste_max_chars = 100000000  # hard cap to prevent pathological pastes from freezing/crashing
+
     def _on_text_changed_tokens(self):
         """Schedule token count update with debounce."""
         self._tokens_timer.start()
@@ -142,15 +145,133 @@ class ChatInput(QTextEdit):
         self._text_top_padding = max(0, int(px))
         self._apply_margins()
 
+    def canInsertFromMimeData(self, source) -> bool:
+        """
+        Restrict accepted MIME types to safe, explicitly handled ones.
+        This prevents Qt from trying to parse unknown/broken formats.
+        """
+        try:
+            if source is None:
+                return False
+            return source.hasText() or source.hasUrls() or source.hasImage()
+        except Exception:
+            return False
+
     def insertFromMimeData(self, source):
         """
         Insert from mime data
 
         :param source: source
         """
-        self.handle_clipboard(source)
-        if not source.hasImage():
-            super().insertFromMimeData(source)
+        # Always process attachments first; never break input pipeline on errors.
+        try:
+            self.handle_clipboard(source)
+        except Exception as e:
+            try:
+                self.window.core.debug.log(e)
+            except Exception:
+                pass
+
+        # If an image is present, we treat it as attachment-only and do not insert textual representation.
+        try:
+            if source and source.hasImage():
+                return
+        except Exception:
+            # fallback to text extraction below
+            pass
+
+        # Insert only sanitized plain text (no HTML, no custom formats).
+        try:
+            text = self._safe_text_from_mime(source)
+            if text:
+                self.insertPlainText(text)
+        except Exception as e:
+            try:
+                self.window.core.debug.log(e)
+            except Exception:
+                pass
+
+    def _safe_text_from_mime(self, source) -> str:
+        """
+        Extracts plain text from QMimeData safely, normalizes and sanitizes it.
+        Falls back to URLs joined by space if textual content is not provided.
+        """
+        try:
+            if source is None:
+                return ""
+            if source.hasText():
+                return self._sanitize_text(source.text())
+            if source.hasUrls():
+                parts = []
+                for url in source.urls():
+                    try:
+                        if url.isLocalFile():
+                            parts.append(url.toLocalFile())
+                        else:
+                            parts.append(url.toString())
+                    except Exception:
+                        continue
+                return self._sanitize_text(" ".join([p for p in parts if p]))
+        except Exception as e:
+            try:
+                self.window.core.debug.log(e)
+            except Exception:
+                pass
+        return ""
+
+    def _sanitize_text(self, text: str) -> str:
+        """
+        Sanitize pasted text:
+        - normalize newlines
+        - remove NUL and most control chars except tab/newline
+        - strip zero-width and bidi control characters
+        - hard-cap maximum length to avoid UI freeze
+        """
+        if not text:
+            return ""
+        if not isinstance(text, str):
+            try:
+                text = str(text)
+            except Exception:
+                return ""
+
+        # Normalize line breaks
+        text = text.replace("\r\n", "\n").replace("\r", "\n")
+
+        # Remove disallowed control chars, keep tab/newline
+        out = []
+        for ch in text:
+            code = ord(ch)
+            if code == 0:
+                continue  # NUL
+            if code < 32:
+                if ch in ("\n", "\t"):
+                    out.append(ch)
+                else:
+                    out.append(" ")
+                continue
+            if code == 0x7F:
+                continue  # DEL
+            # Remove zero-width and bidi controls
+            if (0x200B <= code <= 0x200F) or (0x202A <= code <= 0x202E) or (0x2066 <= code <= 0x2069):
+                continue
+            out.append(ch)
+
+        s = "".join(out)
+
+        # Cap very large pastes
+        try:
+            limit = int(self._paste_max_chars)
+        except Exception:
+            limit = 250000
+        if limit > 0 and len(s) > limit:
+            s = s[:limit]
+            try:
+                self.window.core.debug.log(f"Input paste truncated to {limit} chars")
+            except Exception:
+                pass
+
+        return s
 
     def handle_clipboard(self, source):
         """
@@ -158,20 +279,33 @@ class ChatInput(QTextEdit):
 
         :param source: source
         """
-        if source.hasImage():
-            image = source.imageData()
-            if isinstance(image, QImage):
-                self.window.controller.attachment.from_clipboard_image(image)
-        elif source.hasUrls():
-            urls = source.urls()
-            for url in urls:
-                if url.isLocalFile():
-                    local_path = url.toLocalFile()
-                    self.window.controller.attachment.from_clipboard_url(local_path)
-        elif source.hasText():
-            text = source.text()
-            if text:
-                self.window.controller.attachment.from_clipboard_text(text)
+        if source is None:
+            return
+        try:
+            if source.hasImage():
+                image = source.imageData()
+                if isinstance(image, QImage):
+                    self.window.controller.attachment.from_clipboard_image(image)
+            elif source.hasUrls():
+                urls = source.urls()
+                for url in urls:
+                    try:
+                        if url.isLocalFile():
+                            local_path = url.toLocalFile()
+                            self.window.controller.attachment.from_clipboard_url(local_path)
+                    except Exception:
+                        # Ignore broken URL entries
+                        continue
+            elif source.hasText():
+                text = self._sanitize_text(source.text())
+                if text:
+                    self.window.controller.attachment.from_clipboard_text(text)
+        except Exception as e:
+            # Never propagate clipboard errors to UI thread
+            try:
+                self.window.core.debug.log(e)
+            except Exception:
+                pass
 
     def contextMenuEvent(self, event):
         """
@@ -395,7 +529,7 @@ class ChatInput(QTextEdit):
         btn.setCursor(Qt.PointingHandCursor)
         btn.setToolTip(tooltip or key)
         btn.setFocusPolicy(Qt.NoFocus)
-        btn.setFlat(True)  # flat button style like your original
+        btn.setFlat(True)  # flat button style
         # optional: no text
         btn.setText("")