pygpt-net 2.6.57__py3-none-any.whl → 2.6.59__py3-none-any.whl

pygpt_net/tools/web_browser/ui/widgets.py

@@ -0,0 +1,351 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# ================================================== #
+# This file is a part of PYGPT package               #
+# Website: https://pygpt.net                         #
+# GitHub:  https://github.com/szczyglis-dev/py-gpt   #
+# MIT License                                        #
+# Created By  : Marcin Szczygliński                  #
+# Updated Date: 2025.09.22 19:00:00                  #
+# ================================================== #
+
+from PySide6.QtCore import Qt, Slot, QUrl, QObject, Signal, QSize
+from PySide6.QtGui import QIcon
+from PySide6.QtWidgets import (
+    QVBoxLayout,
+    QHBoxLayout,
+    QLineEdit,
+    QPushButton,
+    QWidget,
+    QSizePolicy,
+)
+
+from pygpt_net.ui.widget.element.labels import HelpLabel
+from pygpt_net.ui.widget.textarea.html import HtmlOutput
+from pygpt_net.utils import trans
+
+
+class ToolWidget:
+    def __init__(self, window=None, tool=None):
+        """
+        HTML/JS canvas widget
+
+        :param window: Window instance
+        :param tool: Tool instance
+        """
+        self.window = window
+        self.tool = tool  # tool instance
+        self.output = None  # output
+
+        # --- Navigation bar state ---
+        self.nav_bar = None
+        self.nav_layout = None
+        self.address_bar = None
+        self.btn_back = None
+        self.btn_next = None
+        self.btn_reload = None
+        self.btn_go = None
+
+    def on_open(self):
+        """On open"""
+        pass
+
+    def on_delete(self):
+        """On delete"""
+        if self.tool:
+            self.tool.signals.url.disconnect(self.open_url)  # keep connections clean
+        try:
+            if hasattr(self.output, 'titleChanged'):
+                self.output.titleChanged.disconnect(self.on_update_title)
+            elif hasattr(self.output, 'page') and self.output.page() and hasattr(self.output.page(), 'titleChanged'):
+                self.output.page().titleChanged.disconnect(self.on_update_title)
+        except Exception:
+            pass
+        if self.output:
+            self.output.on_delete()
+
+    def set_tab(self, tab):
+        """
+        Set tab
+
+        :param tab: Tab
+        """
+        self.output.set_tab(tab)
+
+    def setup(self, all: bool = True) -> QVBoxLayout:
+        """
+        Setup widget body
+
+        :param all: If True, setup all widgets
+        :return: QVBoxLayout
+        """
+        self.output = BrowserOutput(self.window)
+        if hasattr(self.output, 'titleChanged'):
+            try:
+                self.output.titleChanged.connect(self.on_update_title)
+            except TypeError:
+                pass
+        elif hasattr(self.output, 'page') and self.output.page() and hasattr(self.output.page(), 'titleChanged'):
+            try:
+                self.output.page().titleChanged.connect(self.on_update_title)
+            except TypeError:
+                pass
+        else:
+            def _emit_title_from_load(ok: bool):
+                if not ok:
+                    return
+                title = ""
+                try:
+                    if hasattr(self.output, 'title'):
+                        title = self.output.title()
+                    elif hasattr(self.output, 'page') and self.output.page():
+                        title = self.output.page().title()
+                except Exception:
+                    title = ""
+                if title and title.strip() and title != "about:blank":
+                    self.on_update_title(title)
+
+        # ---- Navigation bar ----
+        self.nav_bar = QWidget()
+        self.nav_layout = QHBoxLayout(self.nav_bar)
+        self.nav_layout.setContentsMargins(6, 4, 6, 4)  # small margins for compact look
+        self.nav_layout.setSpacing(6)
+        self.nav_bar.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
+
+        # Icon size and fixed navbar height (to prevent taking too much space)
+        icon_size_px = 20  # base icon size for QPushButtons
+        nav_height = max(32, min(44, icon_size_px + 16))  # compact, never half-screen
+        self.nav_bar.setFixedHeight(nav_height)
+
+        # Buttons
+        self.btn_back = QPushButton()
+        self.btn_back.setToolTip("Back")
+        self.btn_back.setIcon(QIcon(":/icons/back.svg"))
+        self.btn_back.setIconSize(QSize(icon_size_px, icon_size_px))
+        self.btn_back.setFixedHeight(nav_height - 8)
+        self.btn_back.setEnabled(False)
+        self.btn_back.setAutoDefault(False)  # prevent Enter from triggering this
+        try:
+            self.btn_back.setDefault(False)
+        except Exception:
+            pass
+
+        self.btn_next = QPushButton()
+        self.btn_next.setToolTip("Next")
+        self.btn_next.setIcon(QIcon(":/icons/forward.svg"))
+        self.btn_next.setIconSize(QSize(icon_size_px, icon_size_px))
+        self.btn_next.setFixedHeight(nav_height - 8)
+        self.btn_next.setEnabled(False)
+        self.btn_next.setAutoDefault(False)
+        try:
+            self.btn_next.setDefault(False)
+        except Exception:
+            pass
+
+        self.btn_reload = QPushButton()
+        self.btn_reload.setToolTip("Reload")
+        self.btn_reload.setIcon(QIcon(":/icons/reload.svg"))
+        self.btn_reload.setIconSize(QSize(icon_size_px, icon_size_px))
+        self.btn_reload.setFixedHeight(nav_height - 8)
+        self.btn_reload.setAutoDefault(False)
+        try:
+            self.btn_reload.setDefault(False)
+        except Exception:
+            pass
+
+        # "Go" button
+        self.btn_go = QPushButton()
+        self.btn_go.setToolTip("Open URL")
+        self.btn_go.setIcon(QIcon(":/icons/redo.svg"))
+        self.btn_go.setIconSize(QSize(icon_size_px, icon_size_px))
+        self.btn_go.setFixedHeight(nav_height - 8)
+        self.btn_go.setAutoDefault(False)  # avoid stealing Enter
+        try:
+            self.btn_go.setDefault(False)
+        except Exception:
+            pass
+
+        # Address bar (custom line edit to capture Enter and avoid default button reload)
+        self.address_bar = AddressLineEdit(on_return_callback=self._on_address_enter)
+        self.address_bar.setPlaceholderText("Enter URL and press Enter")
+        self.address_bar.setFixedHeight(nav_height - 8)
+        # Still keep the Qt signal for completeness (won't fire because we intercept the key)
+        self.address_bar.returnPressed.connect(self._on_address_enter)
+
+        # Hook up button actions
+        self.btn_back.clicked.connect(lambda: self._navigate('back'))
+        self.btn_next.clicked.connect(lambda: self._navigate('forward'))
+        self.btn_reload.clicked.connect(lambda: self._navigate('reload'))
+        self.btn_go.clicked.connect(self._on_address_enter)  # "Go" triggers address open
+
+        # Build nav layout
+        self.nav_layout.addWidget(self.btn_back)
+        self.nav_layout.addWidget(self.btn_next)
+        self.nav_layout.addWidget(self.btn_reload)
+        self.nav_layout.addWidget(self.address_bar, 1)
+        self.nav_layout.addWidget(self.btn_go)
+
+        sec_label = HelpLabel(trans("tool.web_browser.security.footer"))
+        sec_label.setAlignment(Qt.AlignCenter)
+
+        bottom_layout = QHBoxLayout()
+        bottom_layout.addWidget(sec_label)
+
+        output_layout = QVBoxLayout()
+        # put navigation bar above the web output
+        output_layout.addWidget(self.nav_bar)
+        output_layout.addWidget(self.output, 1)
+        output_layout.setContentsMargins(0, 0, 0, 0)
+
+        # connect signals
+        self.output.signals.save_as.connect(
+            self.tool.handle_save_as)
+        self.output.signals.audio_read.connect(
+            self.window.controller.chat.render.handle_audio_read)
+
+        # Keep nav bar in sync with the underlying view if signals are available
+        # (urlChanged/loadStarted/loadFinished are part of QWebEngineView)
+        if hasattr(self.output, 'urlChanged'):
+            self.output.urlChanged.connect(self._on_url_changed)
+        if hasattr(self.output, 'loadStarted'):
+            try:
+                self.output.loadStarted.connect(lambda: self._update_nav_controls())
+            except TypeError:
+                pass
+        if hasattr(self.output, 'loadFinished'):
+            try:
+                self.output.loadFinished.connect(lambda ok: self._update_nav_controls())
+            except TypeError:
+                pass
+
+        self.tool.signals.url.connect(self.open_url)
+        self.tool.signals.closed.connect(self.on_delete)
+
+        layout = QVBoxLayout()
+        layout.addLayout(output_layout, 1)
+        layout.addLayout(bottom_layout, 0)
+        return layout
+
+    @Slot(str)
+    def open_url(self, url: str):
+        """
+        Open URL in output
+
+        :param url: URL
+        """
+        print("Opening URL:", url)
+        if self.address_bar:
+            self.address_bar.setText(url)
+        self.output.setUrl(QUrl(url))
+        self._update_nav_controls()
+
+    # ------------------
+    # Navigation helpers
+    # ------------------
+    def _show_navbar(self, show: bool):
+        """Show/hide the navigation bar."""
+        if self.nav_bar:
+            self.nav_bar.setVisible(show)
+        # Keep controls state up-to-date
+        self._update_nav_controls()
+
+    def _navigate(self, action: str):
+        """Perform navigation action on the output view."""
+        if not self.output:
+            return
+        try:
+            if action == 'back' and hasattr(self.output, 'back'):
+                self.output.back()
+            elif action == 'forward' and hasattr(self.output, 'forward'):
+                self.output.forward()
+            elif action == 'reload' and hasattr(self.output, 'reload'):
+                self.output.reload()
+        finally:
+            self._update_nav_controls()
+
+    def _on_address_enter(self):
+        """Handle Enter pressed in the address bar or clicking GO."""
+        if not self.output or not self.address_bar:
+            return
+        text = self.address_bar.text().strip()
+        if not text:
+            return
+        url = QUrl.fromUserInput(text)
+        if url.isValid():
+            self._show_navbar(True)
+            self.output.setUrl(url)
+            self._update_nav_controls()
+
+    def _on_url_changed(self, url: QUrl):
+        """Keep address bar in sync with the view URL."""
+        if self.address_bar:
+            self.address_bar.setText(url.toString())
+        self._update_nav_controls()
+
+    def _update_nav_controls(self):
+        """Enable/disable back/forward buttons based on history."""
+        if not self.output:
+            return
+        # Reload is generally available when navbar is visible
+        if self.btn_reload:
+            self.btn_reload.setEnabled(True)
+        # Back/forward depend on history if available
+        if self.btn_back and self.btn_next:
+            try:
+                hist = self.output.history()
+                self.btn_back.setEnabled(bool(hist and hist.canGoBack()))
+                self.btn_next.setEnabled(bool(hist and hist.canGoForward()))
+            except Exception:
+                # If history is not available, keep safe defaults
+                self.btn_back.setEnabled(False)
+                self.btn_next.setEnabled(False)
+
+    @Slot(str)
+    def on_update_title(self, title: str):
+        """Update tab title when the page title changes."""
+        if not self.output:
+            return
+        tab = self.output.tab
+        if tab is None:
+            return
+        if self.window and title and title.strip() and title != "about:blank":
+            try:
+                self.window.controller.ui.tabs.update_title_by_tab(tab, title)
+            except Exception:
+                pass
+
+
+class BrowserOutput(HtmlOutput):
+    def __init__(self, window=None):
+        """
+        HTML canvas output
+
+        :param window: main window
+        """
+        super(BrowserOutput, self).__init__(window)
+        self.window = window
+
+
+# --- Address bar input widget ---
+class AddressLineEdit(QLineEdit):
+    """
+    Custom QLineEdit that ensures Enter triggers opening the typed URL
+    and prevents default buttons (e.g., Reload) from consuming the key.
+    """
+    def __init__(self, on_return_callback=None, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._on_return_callback = on_return_callback
+
+    def keyPressEvent(self, event):
+        if event.key() in (Qt.Key_Return, Qt.Key_Enter):
+            # Call the assigned handler and stop propagation so default buttons won't trigger.
+            if callable(self._on_return_callback):
+                self._on_return_callback()
+            event.accept()
+            return
+        super().keyPressEvent(event)
+
+
+class ToolSignals(QObject):
+    url = Signal(str)  # url
+    closed = Signal()  # dialog closed

pygpt_net/ui/widget/textarea/html.py

@@ -6,12 +6,12 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.24 23:00:00                  #
+# Updated Date: 2025.09.22 19:00:00                  #
 # ================================================== #
 
 import re
 
-from PySide6.QtCore import Qt, QObject, Signal, Slot, QEvent
+from PySide6.QtCore import Qt, QObject, Signal, Slot, QEvent, QCoreApplication, QEventLoop, QUrl
 from PySide6.QtWebChannel import QWebChannel
 from PySide6.QtWebEngineCore import QWebEngineSettings, QWebEnginePage
 from PySide6.QtWebEngineWidgets import QWebEngineView
@@ -42,34 +42,131 @@ class HtmlOutput(QWebEngineView):
         self.meta = None
         self.tab = None
         self.setMouseTracking(True)
+
+        # OpenGL widgets
+        self._glwidget = None
+        self._glwidget_filter_installed = False
+        self._unloaded = False
+        self._destroyed = False
+
         self.installEventFilter(self)
 
+    def _detach_gl_event_filter(self):
+        """Detach OpenGL widget event filter if installed"""
+        if self._glwidget and self._glwidget_filter_installed:
+            try:
+                self._glwidget.removeEventFilter(self)
+            except Exception as e:
+                self._on_delete_failed(e)
+        self._glwidget = None
+        self._glwidget_filter_installed = False
+
+    def _on_delete_failed(self, e):
+        """
+        Handle delete failure
+
+        :param e: Exception instance
+        """
+        pass
+        self.window.core.debug.log(e)
+
+    def unload(self):
+        """Unload the current page and free resources"""
+        try:
+            self.hide()
+            p = self.page()
+            p.triggerAction(QWebEnginePage.Stop)
+            p.setUrl(QUrl("about:blank"))
+            p.history().clear()
+            p.setLifecycleState(QWebEnginePage.LifecycleState.Discarded)
+        except Exception as e:
+            self._on_delete_failed(e)
+        finally:
+            self._unloaded = True
+
     def on_delete(self):
         """Clean up on delete"""
+        if self._destroyed:
+            return
+        if not self._unloaded:
+            self.unload()
+
+        self.hide()
+        self._detach_gl_event_filter()
+
         if self.finder:
-            self.finder.disconnect()  # disconnect finder
-            self.finder = None  # delete finder
+            try:
+                self.finder.disconnect()
+            except Exception as e:
+                self._on_delete_failed(e)
+            finally:
+                self.finder = None
 
-        self.tab = None  # clear tab reference
+        self.tab = None
+
+        # disconnect signals
+        try:
+            self.loadFinished.disconnect(self.on_page_loaded)
+            self.customContextMenuRequested.disconnect(self.on_context_menu)
+            self.signals.save_as.disconnect()
+            self.signals.audio_read.disconnect()
+        except Exception as e:
+            self._on_delete_failed(e)
 
-        # delete page
         page = self.page()
-        if page:
-            if hasattr(page, 'bridge'):
-                page.bridge.deleteLater()
-            if hasattr(page, 'channel'):
-                page.channel.deleteLater()
-            if hasattr(page, 'signals') and page.signals:
-                page.signals.deleteLater()
-            page.deleteLater()  # delete page
 
-        # disconnect signals
-        self.loadFinished.disconnect(self.on_page_loaded)
-        self.customContextMenuRequested.disconnect(self.on_context_menu)
-        self.signals.save_as.disconnect()
-        self.signals.audio_read.disconnect()
+        try:
+            page.triggerAction(QWebEnginePage.Stop)
+        except Exception as e:
+            self._on_delete_failed(e)
+
+        try:
+            page.setUrl(QUrl("about:blank"))
+        except Exception as e:
+            self._on_delete_failed(e)
 
-        self.deleteLater()  # delete widget
+        try:
+            page.history().clear()
+        except Exception as e:
+            self._on_delete_failed(e)
+
+        try:
+            page.setLifecycleState(QWebEnginePage.LifecycleState.Discarded)
+        except Exception as e:
+            self._on_delete_failed(e)
+
+        try:
+            if hasattr(page, "setWebChannel"):
+                page.setWebChannel(None)
+        except Exception as e:
+            self._on_delete_failed(e)
+
+        prof = None
+        try:
+            prof = page.profile()
+        except Exception as e:
+            self._on_delete_failed(e)
+
+        """
+        if prof is not None:
+            try:
+                prof.deleteLater()
+            except Exception as e:
+                self._on_delete_failed(e)
+        """
+
+        try:
+            self.deleteLater()
+        except Exception as e:
+            self._on_delete_failed(e)
+
+        try:
+            QCoreApplication.sendPostedEvents(None, QEvent.DeferredDelete)
+            QCoreApplication.processEvents(QEventLoop.AllEvents, 50)
+        except Exception as e:
+            self._on_delete_failed(e)
+
+        self._destroyed = True
 
     def set_tab(self, tab):
         """
@@ -251,11 +348,15 @@ class HtmlOutput(QWebEngineView):
         :param source: source
         :param event: event
         """
-        if (event.type() == QEvent.ChildAdded and
-                source is self and
-                event.child().isWidgetType()):
+        if event.type() == QEvent.ChildAdded and source is self and event.child().isWidgetType():
+            self._detach_gl_event_filter()
             self._glwidget = event.child()
-            self._glwidget.installEventFilter(self)
+            try:
+                self._glwidget.installEventFilter(self)
+                self._glwidget_filter_installed = True
+            except Exception:
+                self._glwidget = None
+                self._glwidget_filter_installed = False
         elif (event.type() == event.Type.MouseButtonPress):
             if self.tab:
                 col_idx = self.tab.column_idx
@@ -288,6 +389,8 @@ class CustomWebEnginePage(QWebEnginePage):
         if self.window.core.config.has("zoom"):
             self.setZoomFactor(self.window.core.config.get("zoom"))
 
+        self.loaded = False
+
         # bridge Python <> JavaScript
         self.bridge = Bridge(self.window)
         self.channel = QWebChannel(self)
@@ -306,6 +409,9 @@ class CustomWebEnginePage(QWebEnginePage):
         self.parent.finder.matches = num
         self.parent.finder.on_find_finished()
 
+    def set_loaded(self, loaded: bool = True):
+        self.loaded = loaded
+
     def on_view_changed(self):
         """On view changed"""
         zoom = self.zoomFactor()
@@ -346,6 +452,37 @@ class CustomWebEnginePage(QWebEnginePage):
         """
         self.signals.js_message.emit(line_number, message, source_id)  # handled in debug controller
 
+    def cleanup(self):
+        """Cleanup method to release resources"""
+        self.loaded = False
+        try:
+            self.findTextFinished.disconnect()
+            self.zoomFactorChanged.disconnect()
+            self.selectionChanged.disconnect()
+        except Exception:
+            pass
+
+        if self.bridge:
+            try:
+                self.bridge.cleanup()
+            except Exception:
+                pass
+            self.bridge = None
+
+        if self.channel:
+            try:
+                self.channel.unregisterObject("bridge")
+            except Exception:
+                pass
+            self.channel = None
+
+        if self.signals:
+            try:
+                self.signals.deleteLater()
+            except Exception:
+                pass
+            self.signals = None
+
 
 class Bridge(QObject):
     """Bridge between Python and JavaScript"""
@@ -380,6 +517,17 @@ class Bridge(QObject):
         """
         self.window.controller.chat.render.scroll = pos
 
+    def cleanup(self):
+        """Cleanup method to release resources"""
+        if self.window:
+            try:
+                self.window = None
+            except Exception:
+                pass
+
+        # delete the bridge object
+        self.deleteLater()
+
 
 class WebEngineSignals(QObject):
     save_as = Signal(str, str)

pygpt_net/ui/widget/textarea/web.py

@@ -531,7 +531,7 @@ class CustomWebEnginePage(QWebEnginePage):
         return super().acceptNavigationRequest(url, _type, isMainFrame)
 
     def javaScriptConsoleMessage(self, level, message, line_number, source_id):
-        print("[JS CONSOLE] Line", line_number, ":", message)
+        #  print("[JS CONSOLE] Line", line_number, ":", message)
         self.signals.js_message.emit(line_number, message, source_id)  # handled in debug controller
 
     def cleanup(self):