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

pygpt_net/ui/widget/tabs/output.py

@@ -6,21 +6,301 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2024.12.14 07: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.QtGui import QAction, QIcon
+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
 from pygpt_net.utils import trans
-import pygpt_net.icons_rc
+
+_ICON_CACHE = {}
+
+
+def icon(path: str) -> QIcon:
+    if QGuiApplication.instance() is None:
+        return QIcon()
+    cached = _ICON_CACHE.get(path)
+    if cached is None:
+        cached = QIcon(path)
+        _ICON_CACHE[path] = cached
+    return cached
+
+
+ICON_PATH_ADD = ':/icons/add.svg'
+ICON_PATH_EDIT = ':/icons/edit.svg'
+ICON_PATH_CLOSE = ':/icons/close.svg'
+ICON_PATH_RELOAD = ':/icons/reload.svg'
+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__(QIcon(":/icons/add.svg"), "", window)
+        super(AddButton, self).__init__(icon(ICON_PATH_ADD), "", window)
         self.window = window
         self.column = column
         self.tabs = tabs
@@ -65,26 +345,25 @@ class AddButton(QPushButton):
         :return: menu
         """
         menu = QMenu(self)
+        menu.setAttribute(Qt.WA_DeleteOnClose, True)
 
-        actions = {}
-        actions['add_chat'] = QAction(QIcon(":/icons/add.svg"), trans('action.tab.add.chat'), self)
-        actions['add_chat'].triggered.connect(
-            lambda: self.tabs.add_tab(index, column_idx, Tab.TAB_CHAT)
+        add_chat = QAction(icon(ICON_PATH_ADD), trans('action.tab.add.chat'), menu)
+        add_chat.triggered.connect(
+            lambda: self.tabs.add_tab(-2, column_idx, Tab.TAB_CHAT)
         )
-        actions['add_notepad'] = QAction(QIcon(":/icons/add.svg"), trans('action.tab.add.notepad'), self)
-        actions['add_notepad'].triggered.connect(
-            lambda: self.tabs.add_tab(index, column_idx, Tab.TAB_NOTEPAD)
+        add_notepad = QAction(icon(ICON_PATH_ADD), trans('action.tab.add.notepad'), menu)
+        add_notepad.triggered.connect(
+            lambda: self.tabs.add_tab(-2, column_idx, Tab.TAB_NOTEPAD)
         )
 
-        # add chat, add notepad
-        menu.addAction(actions['add_chat'])
-        menu.addAction(actions['add_notepad'])
+        menu.addAction(add_chat)
+        menu.addAction(add_notepad)
 
-        # add tools submenu
-        self.window.controller.tools.append_tab_menu(self, menu, index, column_idx, self.tabs)
+        self.window.controller.tools.append_tab_menu(self, menu, -2, column_idx, self.tabs)
 
         return menu
 
+
 class OutputTabs(QTabWidget):
     def __init__(self, window=None, column=None):
         super(OutputTabs, self).__init__(window)
@@ -96,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
@@ -112,22 +383,85 @@ class OutputTabs(QTabWidget):
         # add the button to the top right corner of the tab bar
         self.setCornerWidget(add_button, corner=Qt.TopRightCorner)
 
-        # connect signals
-        self.currentChanged.connect(
-            lambda: self.window.controller.ui.tabs.on_tab_changed(self.currentIndex(), self.column.get_idx())
-        )
-        self.tabBarClicked.connect(
-            lambda: self.window.controller.ui.tabs.on_tab_clicked(self.currentIndex(), self.column.get_idx())
-        )
-        self.tabBarDoubleClicked.connect(
-            lambda: self.window.controller.ui.tabs.on_tab_dbl_clicked(self.currentIndex(), self.column.get_idx())
-        )
-        self.tabCloseRequested.connect(
-            lambda: self.window.controller.ui.tabs.on_tab_closed(self.currentIndex(), self.column.get_idx())
-        )
-        self.tabBar().tabMoved.connect(
-            lambda: self.window.controller.ui.tabs.on_tab_moved(self.currentIndex(), self.column.get_idx())
+        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)
+        self.tabBarDoubleClicked.connect(self._on_tabbar_dbl_clicked)
+        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):
         """
@@ -165,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:
@@ -177,44 +511,40 @@ class OutputTabs(QTabWidget):
         :return: menu
         """
         menu = QMenu(self)
+        menu.setAttribute(Qt.WA_DeleteOnClose, True)
 
-        actions = {}
-        actions['add_chat'] = QAction(QIcon(":/icons/add.svg"), trans('action.tab.add.chat'), self)
-        actions['add_chat'].triggered.connect(
+        add_chat = QAction(icon(ICON_PATH_ADD), trans('action.tab.add.chat'), menu)
+        add_chat.triggered.connect(
             lambda: self.add_tab(index, column_idx, Tab.TAB_CHAT)
         )
-        actions['add_notepad'] = QAction(QIcon(":/icons/add.svg"), trans('action.tab.add.notepad'), self)
-        actions['add_notepad'].triggered.connect(
+        add_notepad = QAction(icon(ICON_PATH_ADD), trans('action.tab.add.notepad'), menu)
+        add_notepad.triggered.connect(
             lambda: self.add_tab(index, column_idx, Tab.TAB_NOTEPAD)
         )
-        actions['edit'] = QAction(QIcon(":/icons/edit.svg"), trans('action.rename'), self)
-        actions['edit'].triggered.connect(
+        edit = QAction(icon(ICON_PATH_EDIT), trans('action.rename'), menu)
+        edit.triggered.connect(
             lambda: self.rename_tab(index, column_idx)
         )
-        actions['move_right'] = QAction(QIcon(":/icons/forward"), trans('action.tab.move.right'), self)
-        actions['move_right'].triggered.connect(
+        move_right = QAction(icon(ICON_PATH_FORWARD), trans('action.tab.move.right'), menu)
+        move_right.triggered.connect(
             lambda: self.window.controller.ui.tabs.move_tab(index, column_idx, 1)
         )
-        actions['move_left'] = QAction(QIcon(":/icons/back"), trans('action.tab.move.left'), self)
-        actions['move_left'].triggered.connect(
+        move_left = QAction(icon(ICON_PATH_BACK), trans('action.tab.move.left'), menu)
+        move_left.triggered.connect(
             lambda: self.window.controller.ui.tabs.move_tab(index, column_idx, 0)
         )
 
-        # add chat, add notepad
-        menu.addAction(actions['add_chat'])
-        menu.addAction(actions['add_notepad'])
+        menu.addAction(add_chat)
+        menu.addAction(add_notepad)
 
-        # add tools submenu
         self.window.controller.tools.append_tab_menu(self, menu, index, column_idx, self)
 
-        # rename tab
-        menu.addAction(actions['edit'])
+        menu.addAction(edit)
 
-        # move tab left, move tab right
         if column_idx != 0:
-            menu.addAction(actions['move_left'])
+            menu.addAction(move_left)
         if column_idx != 1:
-            menu.addAction(actions['move_right'])
+            menu.addAction(move_right)
 
         return menu
 
@@ -227,19 +557,18 @@ class OutputTabs(QTabWidget):
         :param global_pos: global position
         """
         context_menu = self.prepare_menu(index, column_idx)
-        actions = {}
-        actions['close'] = QAction(QIcon(":/icons/close.svg"), trans('action.tab.close'), self)
-        actions['close'].triggered.connect(
+        close_act = QAction(icon(ICON_PATH_CLOSE), trans('action.tab.close'), context_menu)
+        close_act.triggered.connect(
             lambda: self.close_tab(index, column_idx)
         )
-        actions['close_all'] = QAction(QIcon(":/icons/close.svg"), trans('action.tab.close_all.notepad'), self)
-        actions['close_all'].triggered.connect(
+        close_all_act = QAction(icon(ICON_PATH_CLOSE), trans('action.tab.close_all.notepad'), context_menu)
+        close_all_act.triggered.connect(
             lambda: self.close_all(Tab.TAB_NOTEPAD, column_idx)
         )
-        context_menu.addAction(actions['close'])
+        context_menu.addAction(close_act)
 
         if self.window.core.tabs.count_by_type(Tab.TAB_NOTEPAD) > 1:
-            context_menu.addAction(actions['close_all'])
+            context_menu.addAction(close_all_act)
 
         context_menu.exec(global_pos)
 
@@ -252,20 +581,19 @@ class OutputTabs(QTabWidget):
         :param global_pos: global position
         """
         context_menu = self.prepare_menu(index, column_idx)
-        actions = {}
-        actions['close'] = QAction(QIcon(":/icons/close.svg"), trans('action.tab.close'), self)
-        actions['close'].triggered.connect(
+        close_act = QAction(icon(ICON_PATH_CLOSE), trans('action.tab.close'), context_menu)
+        close_act.triggered.connect(
             lambda: self.close_tab(index, column_idx)
         )
-        actions['close_all'] = QAction(QIcon(":/icons/close.svg"), trans('action.tab.close_all.chat'), self)
-        actions['close_all'].triggered.connect(
+        close_all_act = QAction(icon(ICON_PATH_CLOSE), trans('action.tab.close_all.chat'), context_menu)
+        close_all_act.triggered.connect(
             lambda: self.close_all(Tab.TAB_CHAT, column_idx)
         )
 
         # at least one chat tab must be open
         if self.window.core.tabs.count_by_type(Tab.TAB_CHAT) > 1:
-            context_menu.addAction(actions['close'])
-            context_menu.addAction(actions['close_all'])
+            context_menu.addAction(close_act)
+            context_menu.addAction(close_all_act)
 
         context_menu.exec(global_pos)
 
@@ -278,12 +606,11 @@ class OutputTabs(QTabWidget):
         :param global_pos: global position
         """
         context_menu = self.prepare_menu(index, column_idx)
-        actions = {}
-        actions['refresh'] = QAction(QIcon(":/icons/reload.svg"), trans('action.refresh'), self)
-        actions['refresh'].triggered.connect(
+        refresh = QAction(icon(ICON_PATH_RELOAD), trans('action.refresh'), context_menu)
+        refresh.triggered.connect(
             lambda: self.window.controller.files.update_explorer()
         )
-        context_menu.addAction(actions['refresh'])
+        context_menu.addAction(refresh)
         context_menu.exec(global_pos)
 
     def show_tool_menu(self, index: int, column_idx: int, global_pos):
@@ -295,12 +622,11 @@ class OutputTabs(QTabWidget):
         :param global_pos: global position
         """
         context_menu = self.prepare_menu(index, column_idx)
-        actions = {}
-        actions['close'] = QAction(QIcon(":/icons/close.svg"), trans('action.tab.close'), self)
-        actions['close'].triggered.connect(
+        close_act = QAction(icon(ICON_PATH_CLOSE), trans('action.tab.close'), context_menu)
+        close_act.triggered.connect(
             lambda: self.close_tab(index, column_idx)
         )
-        context_menu.addAction(actions['close'])
+        context_menu.addAction(close_act)
         context_menu.exec(global_pos)
 
     def show_default_menu(self, index: int, column_idx: int, global_pos):
@@ -314,6 +640,32 @@ class OutputTabs(QTabWidget):
         context_menu = self.prepare_menu(index, column_idx)
         context_menu.exec(global_pos)
 
+    @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()
     def rename_tab(self, index: int, column_idx: int):
         """
@@ -354,9 +706,14 @@ class OutputTabs(QTabWidget):
         :param type: type
         :param tool_id: tool id
         """
+        if index == -2:  # new btn
+            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,
             idx=index,
             column_idx=column_idx,
-        )
+        )

pygpt_net/ui/widget/textarea/calendar_note.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.01.19 02:00:00                  #
+# Updated Date: 2025.08.24 23:00:00                  #
 # ================================================== #
 
 from PySide6.QtCore import Qt
@@ -16,7 +16,6 @@ from PySide6.QtWidgets import QTextEdit
 from pygpt_net.core.tabs.tab import Tab
 from pygpt_net.core.text.finder import Finder
 from pygpt_net.utils import trans
-import pygpt_net.icons_rc
 
 
 class CalendarNote(QTextEdit):