pygpt-net 2.6.22__py3-none-any.whl → 2.6.23__py3-none-any.whl

pygpt_net/ui/widget/tabs/output.py

@@ -6,11 +6,11 @@
 # 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.08.25 18:00:00                  #
 # ================================================== #
 
-from PySide6.QtWidgets import QTabWidget, QMenu, QPushButton
-from PySide6.QtCore import Qt, Slot
+from PySide6.QtWidgets import QTabWidget, QMenu, QPushButton, QToolButton, QTabBar
+from PySide6.QtCore import Qt, Slot, QTimer, QEvent
 from PySide6.QtGui import QAction, QIcon, QGuiApplication
 
 from pygpt_net.core.tabs.tab import Tab
@@ -18,6 +18,7 @@ from pygpt_net.utils import trans
 
 _ICON_CACHE = {}
 
+
 def icon(path: str) -> QIcon:
     if QGuiApplication.instance() is None:
         return QIcon()
@@ -27,6 +28,7 @@ def icon(path: str) -> QIcon:
         _ICON_CACHE[path] = cached
     return cached
 
+
 ICON_PATH_ADD = ':/icons/add.svg'
 ICON_PATH_EDIT = ':/icons/edit.svg'
 ICON_PATH_CLOSE = ':/icons/close.svg'
@@ -35,6 +37,267 @@ ICON_PATH_FORWARD = ':/icons/forward'
 ICON_PATH_BACK = ':/icons/back'
 
 
+class OutputTabBar(QTabBar):
+    def __init__(
+            self,
+            window=None,
+            column=None,
+            tabs=None,
+            corner_button=None,
+            parent=None
+    ):
+        super().__init__(parent)
+        self.window = window
+        self.column = column
+        self.tabs = tabs
+        self.corner_button = corner_button
+
+        # inline [+] just after the last tab (only when there is real free space)
+        self.add_btn_inline = AddButton(window, column, tabs)
+        self.add_btn_inline.setParent(self)
+        self.add_btn_inline.setVisible(False)
+        self.add_btn_inline.raise_()
+
+        # visual gap between last tab and [+]
+        self._spacing = 3
+
+        # add button vertical offset (to align with text)
+        self._inline_y_offset = 2  # px up
+
+        # keep tabs natural width (do not stretch)
+        self.setExpanding(False)
+
+        # allow scroll buttons when needed
+        self.setUsesScrollButtons(True)
+
+        # ensure the tab bar stays visible even with 0 tabs
+        self._min_bar_height = max(self.add_btn_inline.sizeHint().height() + 6, 28)
+        self.setMinimumHeight(self._min_bar_height)
+
+        if hasattr(self.tabs, "setTabBarAutoHide"):
+            self.tabs.setTabBarAutoHide(False)
+
+        # state
+        self._inline_mode = False
+        self._corner_current = None  # track where the corner [+] currently is
+        self._last_inline_pos = None  # track last inline position to avoid useless moves
+
+        # coalesced updates (debounce to 1 per event-loop turn)
+        self._update_timer = QTimer(self)
+        self._update_timer.setSingleShot(True)
+        self._update_timer.timeout.connect(self.updateAddButtonPlacement)
+
+        # re-layout updates
+        self.currentChanged.connect(lambda _: self._queue_update())
+        self.tabMoved.connect(lambda _from, _to: self._queue_update())
+
+        # initial placement
+        QTimer.singleShot(0, self.updateAddButtonPlacement)
+
+    def sizeHint(self):
+        """
+        Override sizeHint to
+
+        :return: QSize
+        """
+        # keep a non-zero height even with 0 tabs
+        sh = super().sizeHint()
+        sh.setHeight(max(sh.height(), self._min_bar_height))
+        return sh
+
+    def minimumSizeHint(self):
+        """
+        Override minimumSizeHint
+
+        :return: QSize
+        """
+        m = super().minimumSizeHint()
+        m.setHeight(max(m.height(), self._min_bar_height))
+        return m
+
+    def _queue_update(self):
+        """Queue an update to recompute [+] placement (debounced)."""
+        # Coalesce many triggers into a single call at the end of the event loop.
+        self._update_timer.start(0)
+
+    def _visible_scroll_buttons(self):
+        """
+        Find the left and right scroll buttons if they are visible.
+
+        :return: (left_button, right_button) or (None, None) if not found
+        """
+        # find the scroll arrow buttons created by QTabBar
+        left = right = None
+        for btn in self.findChildren(QToolButton):
+            if not btn.isVisible():
+                continue
+            if not btn.autoRepeat():
+                continue
+            if left is None or btn.x() < left.x():
+                left = btn
+            if right is None or btn.x() > right.x():
+                right = btn
+        return left, right
+
+    def _set_corner_target(self, corner: Qt.Corner | None) -> bool:
+        """
+        Move the corner_button to a given corner (or detach it) only when it changes.
+
+        :param corner: target corner or None to detach
+        :return: True if changed, False if no change was needed
+        """
+        if self.corner_button is None:
+            return False
+
+        if self._corner_current == corner:
+            return False  # nothing to do
+
+        # detach only from the previously used corner
+        if self._corner_current is not None:
+            self.tabs.setCornerWidget(None, self._corner_current)
+
+        if corner is not None:
+            self.tabs.setCornerWidget(self.corner_button, corner)
+
+        self._corner_current = corner
+        return True
+
+    def _column_index(self) -> int:
+        """
+        Get the column index this tab bar belongs to (0 or 1).
+
+        :return: Column index
+        """
+        idx = 0
+        if self.column is None:
+            return idx
+        return int(self.column.get_idx())
+
+    def updateAddButtonPlacement(self):
+        """
+        Recompute where the [+] button should be placed (inline or corner).
+
+        This method is called automatically on relevant events.
+        1. If there are no tabs, show [+] in the left or right corner based on column index.
+        2. If there are tabs but scroll buttons are visible (overflow), show [+] in the top-right corner.
+        3. If there are tabs and no scroll buttons, show [+] inline after the last tab if there's room.
+        4. Otherwise, show [+] in the top-right corner.
+        """
+        # CASE 1: no tabs -> show [+] in left or right corner based on column index
+        if self.count() == 0:
+            idx = self._column_index()
+            corner = Qt.TopLeftCorner if idx == 0 else Qt.TopRightCorner
+
+            changed = False
+            changed |= self._set_corner_target(corner)
+
+            if self._inline_mode:
+                self._inline_mode = False
+                changed = True
+
+            if self.add_btn_inline.isVisible():
+                self.add_btn_inline.setVisible(False)
+                changed = True
+
+            if self.corner_button is not None and not self.corner_button.isVisible():
+                self.corner_button.setVisible(True)
+                changed = True
+            return
+
+        # CASE 2: tabs exist
+        # if scroll buttons are visible we are in overflow -> use top-right corner [+]
+        left_sb, right_sb = self._visible_scroll_buttons()
+        if left_sb or right_sb:
+            changed = False
+            if self._inline_mode:
+                self._inline_mode = False
+                changed = True
+            if self.add_btn_inline.isVisible():
+                self.add_btn_inline.setVisible(False)
+                changed = True
+            changed |= self._set_corner_target(Qt.TopRightCorner)
+            if self.corner_button is not None and not self.corner_button.isVisible():
+                self.corner_button.setVisible(True)
+                changed = True
+            return
+
+        # otherwise, put [+] inline (right after the last tab) if there's real room
+        last_rect = self.tabRect(self.count() - 1)
+        x = last_rect.right() + 1 + self._spacing
+        want_inline = (x + self.add_btn_inline.width()) <= (self.width() - 1)
+
+        if want_inline:
+            changed = False
+
+            if not self._inline_mode:
+                self._inline_mode = True
+                changed = True
+
+            # hide any corner [+]
+            if self.corner_button is not None and self.corner_button.isVisible():
+                self.corner_button.setVisible(False)
+                changed = True
+            changed |= self._set_corner_target(None)
+
+            # compute position
+            y = (self.height() - self.add_btn_inline.height()) // 2
+            # NOTE: lift inline [+] slightly to align with tabs
+            y = max(0, y - self._inline_y_offset)  # clamp to avoid negative
+            x = min(x, self.width() - self.add_btn_inline.width() - 1)  # clamp inside the bar
+            new_pos = (x, y)
+            if self._last_inline_pos != new_pos:
+                self.add_btn_inline.move(x, y)
+                self._last_inline_pos = new_pos
+                changed = True
+
+            if not self.add_btn_inline.isVisible():
+                self.add_btn_inline.setVisible(True)
+                changed = True
+
+            self.add_btn_inline.raise_()
+        else:
+            # not enough room -> top-right corner
+            changed = False
+            if self._inline_mode:
+                self._inline_mode = False
+                changed = True
+            if self.add_btn_inline.isVisible():
+                self.add_btn_inline.setVisible(False)
+                changed = True
+            changed |= self._set_corner_target(Qt.TopRightCorner)
+            if self.corner_button is not None and not self.corner_button.isVisible():
+                self.corner_button.setVisible(True)
+                changed = True
+
+    def resizeEvent(self, event):
+        """Resize event handler to recompute [+] placement."""
+        super().resizeEvent(event)
+        self._queue_update()
+
+    def showEvent(self, event):
+        """Show event handler to recompute [+] placement."""
+        super().showEvent(event)
+        self._queue_update()
+
+    def tabInserted(self, index):
+        """Tab inserted event handler to recompute [+] placement."""
+        super().tabInserted(index)
+        self._queue_update()
+
+    def tabRemoved(self, index):
+        """Tab removed event handler to recompute [+] placement."""
+        super().tabRemoved(index)
+        self._queue_update()
+
+    def event(self, e):
+        """Event handler to catch layout/style changes that may affect [+] placement."""
+        res = super().event(e)
+        # only queue updates
+        if e.type() in (QEvent.LayoutRequest, QEvent.StyleChange, QEvent.PolishRequest, QEvent.FontChange):
+            self._queue_update()
+        return res
+
+
 class AddButton(QPushButton):
     def __init__(self, window=None, column=None, tabs=None):
         super(AddButton, self).__init__(icon(ICON_PATH_ADD), "", window)
@@ -100,6 +363,7 @@ class AddButton(QPushButton):
 
         return menu
 
+
 class OutputTabs(QTabWidget):
     def __init__(self, window=None, column=None):
         super(OutputTabs, self).__init__(window)
@@ -111,14 +375,6 @@ class OutputTabs(QTabWidget):
         self.setMovable(True)
         self.init()
 
-    def set_active(self, active: bool):
-        """Set the active state of the tab bar."""
-        self.active = active
-        if self.active:
-            self.setStyleSheet("QTabBar::tab { border-bottom-width: 2px; }")
-        else:
-            self.setStyleSheet("QTabBar::tab { border-bottom-width: 0px; }")
-
     def init(self):
         """Initialize"""
         # create the [+] button
@@ -127,6 +383,38 @@ class OutputTabs(QTabWidget):
         # add the button to the top right corner of the tab bar
         self.setCornerWidget(add_button, corner=Qt.TopRightCorner)
 
+        self.setDocumentMode(True)
+
+        # use a custom tab bar that shows an inline [+] right after the tabs
+        tab_bar = OutputTabBar(
+            window=self.window,
+            column=self.column,
+            tabs=self,
+            corner_button=add_button,
+            parent=self,
+        )
+        self.setTabBar(tab_bar)
+        self.setMovable(True)
+        self.tabBar().setMovable(True)
+
+        self.setDocumentMode(True)  # QT Material fix
+        self.tabBar().setDrawBase(False)  # QT Material fix
+
+        # the custom tab bar decides when to show inline or corner [+]
+        add_button.setVisible(False)
+
+        # ensure initial recompute happens after the first layout pass
+        QTimer.singleShot(0, self._refresh_plus_button)
+
+        # tab bar visible even when empty
+        if hasattr(self, "setTabBarAutoHide"):
+            self.setTabBarAutoHide(False)
+
+        # IMPORTANT: reserve vertical space for the bar even with 0 tabs
+        # (prevents the whole widget from collapsing)
+        mh = max(self.tabBar().minimumSizeHint().height() + 2, 30)  # +2
+        self.setMinimumHeight(mh)
+
         # connect signals
         self.currentChanged.connect(self._on_current_changed)
         self.tabBarClicked.connect(self._on_tabbar_clicked)
@@ -134,6 +422,47 @@ class OutputTabs(QTabWidget):
         self.tabCloseRequested.connect(self._on_tab_close_requested)
         self.tabBar().tabMoved.connect(self._on_tab_moved)
 
+    def set_active(self, active: bool):
+        """
+        Set the active state of the tab bar.
+
+        :param active: True to activate, False to deactivate
+        """
+        self.active = active
+
+    def _refresh_plus_button(self):
+        """Force the tab bar to recompute [+] placement after tab changes."""
+        tb = self.tabBar()
+        if hasattr(tb, "updateAddButtonPlacement"):
+            tb.updateAddButtonPlacement()
+
+    def addTab(self, *args, **kwargs):
+        """Add a new tab and refresh [+] placement."""
+        idx = super().addTab(*args, **kwargs)
+        QTimer.singleShot(0, self._refresh_plus_button)  # defer until layout is done
+        return idx
+
+    def insertTab(self, *args, **kwargs):
+        """Insert a new tab at a specific index and refresh [+] placement."""
+        idx = super().insertTab(*args, **kwargs)
+        QTimer.singleShot(0, self._refresh_plus_button)
+        return idx
+
+    def removeTab(self, index):
+        """Remove a tab and refresh [+] placement."""
+        super().removeTab(index)
+        QTimer.singleShot(0, self._refresh_plus_button)
+
+    def setTabText(self, index: int, text: str):
+        """Set tab text and refresh [+] placement."""
+        super().setTabText(index, text)
+        QTimer.singleShot(0, self._refresh_plus_button)
+
+    def clear(self):
+        """Clear all tabs and refresh [+] placement."""
+        super().clear()
+        QTimer.singleShot(0, self._refresh_plus_button)
+
     def get_column(self):
         """
         Get column
@@ -170,7 +499,7 @@ class OutputTabs(QTabWidget):
                 elif tab.type == Tab.TAB_TOOL:
                     self.show_tool_menu(idx, column_idx, event.globalPos())  # tool
                 else:
-                    self.show_default_menu(idx, column_idx, event.globalPos()) # default
+                    self.show_default_menu(idx, column_idx, event.globalPos())  # default
         super(OutputTabs, self).mousePressEvent(event)
 
     def prepare_menu(self, index: int, column_idx: int) -> QMenu:
@@ -313,22 +642,28 @@ class OutputTabs(QTabWidget):
 
     @Slot(int)
     def _on_current_changed(self, _idx: int):
+        """On current tab changed"""
         self.window.controller.ui.tabs.on_tab_changed(self.currentIndex(), self.column.get_idx())
 
     @Slot(int)
     def _on_tabbar_clicked(self, _idx: int):
+        """On tab bar clicked"""
         self.window.controller.ui.tabs.on_tab_clicked(self.currentIndex(), self.column.get_idx())
 
     @Slot(int)
     def _on_tabbar_dbl_clicked(self, _idx: int):
+        """On tab bar double clicked"""
         self.window.controller.ui.tabs.on_tab_dbl_clicked(self.currentIndex(), self.column.get_idx())
 
     @Slot(int)
     def _on_tab_close_requested(self, _idx: int):
+        """On tab close requested"""
         self.window.controller.ui.tabs.on_tab_closed(self.currentIndex(), self.column.get_idx())
+        QTimer.singleShot(0, self._refresh_plus_button)  # defer until layout is done
 
     @Slot(int, int)
     def _on_tab_moved(self, _from: int, _to: int):
+        """On tab moved"""
         self.window.controller.ui.tabs.on_tab_moved(self.currentIndex(), self.column.get_idx())
 
     @Slot()
@@ -375,7 +710,7 @@ class OutputTabs(QTabWidget):
             index = self.window.core.tabs.get_max_idx_by_column(column_idx)
             if index == -1:
                 index = 0
-                
+
         self.window.controller.ui.tabs.append(
             type=type,
             tool_id=tool_id,

pygpt_net/ui/widget/textarea/input.py

@@ -6,13 +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.08.25 20:00:00                  #
 # ================================================== #
 
-from PySide6 import QtCore
-from PySide6.QtCore import Qt
+from PySide6.QtCore import Qt, QSize
 from PySide6.QtGui import QAction, QIcon, QImage
-from PySide6.QtWidgets import QTextEdit, QApplication
+from PySide6.QtWidgets import QTextEdit, QApplication, QPushButton
 
 from pygpt_net.utils import trans
 
@@ -21,6 +20,7 @@ class ChatInput(QTextEdit):
     ICON_PASTE = QIcon(":/icons/paste.svg")
     ICON_VOLUME = QIcon(":/icons/volume.svg")
     ICON_SAVE = QIcon(":/icons/save.svg")
+    ICON_ATTACHMENT = QIcon(":/icons/add.svg")
 
     def __init__(self, window=None):
         """
@@ -35,9 +35,24 @@ class ChatInput(QTextEdit):
         self.value = self.window.core.config.data['font_size.input']
         self.max_font_size = 42
         self.min_font_size = 8
+        self._text_top_padding = 10
         self.textChanged.connect(self.window.controller.ui.update_tokens)
         self.setProperty('class', 'layout-input')
 
+        # Add a "+" button in the top-left corner to add attachments
+        self._init_attachment_button()
+        self._apply_text_top_padding()
+
+    def _apply_text_top_padding(self):
+        """Apply extra top padding inside the text area by using viewport margins."""
+        m = self.viewportMargins()
+        self.setViewportMargins(m.left(), self._text_top_padding, m.right(), m.bottom())
+
+    def set_text_top_padding(self, px: int):
+        """Public helper to adjust top padding at runtime."""
+        self._text_top_padding = max(0, int(px))
+        self._apply_text_top_padding()
+
     def insertFromMimeData(self, source):
         """
         Insert from mime data
@@ -136,16 +151,16 @@ class ChatInput(QTextEdit):
         """
         handled = False
         key = event.key()
-        if key in (QtCore.Qt.Key_Return, QtCore.Qt.Key_Enter):
+        if key in (Qt.Key_Return, Qt.Key_Enter):
             mode = self.window.core.config.get('send_mode')
             if mode > 0:
                 modifiers = event.modifiers()
                 if mode == 2:
-                    if modifiers == QtCore.Qt.ShiftModifier or modifiers == QtCore.Qt.ControlModifier:
+                    if modifiers == Qt.ShiftModifier or modifiers == Qt.ControlModifier:
                         self.window.controller.chat.input.send_input()
                         handled = True
                 else:
-                    if modifiers != QtCore.Qt.ShiftModifier and modifiers != QtCore.Qt.ControlModifier:
+                    if modifiers != Qt.ShiftModifier and modifiers != Qt.ControlModifier:
                         self.window.controller.chat.input.send_input()
                         handled = True
                 self.setFocus()
@@ -178,4 +193,55 @@ class ChatInput(QTextEdit):
                 self.window.controller.ui.update_font_size()
             event.accept()
             return
-        super().wheelEvent(event)
+        super().wheelEvent(event)
+
+    # --- Added: attachment button (top-left) ---------------------------------
+
+    def _init_attachment_button(self):
+        """Create and place the '+' attachment button pinned in the top-left corner."""
+        self._attach_margin = 6  # inner padding around the button
+        self._attach_offset_y = -6  # shift the button 2px up
+
+        self._attach_btn = QPushButton(self)
+        self._attach_btn.setObjectName("chatInputAttachBtn")
+        self._attach_btn.setIconSize(QSize(18, 18)) # icon size (slightly larger for visibility)
+        self._attach_btn.setFixedSize(24, 24) # full button size
+        self._attach_btn.setCursor(Qt.PointingHandCursor)
+        self._attach_btn.setToolTip(trans("attachments.btn.input.add"))
+        self._attach_btn.setFocusPolicy(Qt.NoFocus)
+        self._attach_btn.setFlat(True) # flat button style
+
+        self._attach_btn.setIcon(self.ICON_ATTACHMENT)
+        self._attach_btn.clicked.connect(self.action_add_attachment)
+        self._update_viewport_margins_for_attachment()
+        self._reposition_attachment_button()
+
+    def _update_viewport_margins_for_attachment(self):
+        """Reserve space for the attachment button on the left and apply top text padding."""
+        top = self._text_top_padding
+        left = self._attach_btn.width() + self._attach_margin * 2 if hasattr(self, "_attach_btn") else self.viewportMargins().left()
+        self.setViewportMargins(left, top, 0, 0)
+
+    def _reposition_attachment_button(self):
+        """Keep the attachment button pinned to the top-left corner."""
+        if hasattr(self, "_attach_btn"):
+            fw = self.frameWidth()
+            x = fw + self._attach_margin
+            y = fw + self._attach_margin + self._attach_offset_y  # shift up by ~2px
+            if y < 0:
+                y = 0
+            self._attach_btn.move(x, y)
+            self._attach_btn.raise_()
+
+    def resizeEvent(self, event):
+        """Resize event keeps the attachment button in place."""
+        super().resizeEvent(event)
+        # Keep the attachment button pinned when resizing
+        try:
+            self._reposition_attachment_button()
+        except Exception:
+            pass
+
+    def action_add_attachment(self):
+        """Add attachment (button click)."""
+        self.window.controller.attachment.open_add()