pygpt-net 2.7.5__py3-none-any.whl → 2.7.6__py3-none-any.whl

pygpt_net/tools/image_viewer/ui/dialogs.py

@@ -6,17 +6,18 @@
 # 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: 2026.01.03 17:00:00                  #
 # ================================================== #
 
-from PySide6.QtCore import Qt
+from PySide6.QtCore import Qt, QPoint, QSize, QEvent
 from PySide6.QtGui import QAction, QIcon
-from PySide6.QtWidgets import QMenuBar, QVBoxLayout, QHBoxLayout, QSizePolicy
+from PySide6.QtWidgets import QMenuBar, QVBoxLayout, QHBoxLayout, QSizePolicy, QScrollArea
 
 from pygpt_net.ui.widget.dialog.base import BaseDialog
 from pygpt_net.ui.widget.image.display import ImageLabel
 from pygpt_net.utils import trans
 
+
 class DialogSpawner:
     def __init__(self, window=None):
         """
@@ -44,8 +45,14 @@ class DialogSpawner:
         pixmap = ImageLabel(dialog, self.path)
         pixmap.setSizePolicy(QSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored))
 
+        # scrollable container for pixmap
+        scroll = QScrollArea(dialog)
+        scroll.setWidgetResizable(True)
+        scroll.setAlignment(Qt.AlignCenter)
+        scroll.setWidget(pixmap)
+
         row = QHBoxLayout()
-        row.addWidget(pixmap)
+        row.addWidget(scroll)
 
         layout = QVBoxLayout()
         layout.addLayout(row)
@@ -53,6 +60,10 @@ class DialogSpawner:
         dialog.append_layout(layout)
         dialog.source = source
         dialog.pixmap = pixmap
+        dialog.scroll_area = scroll
+
+        # install event filter for wheel zoom and panning and cursor changes
+        dialog.scroll_area.viewport().installEventFilter(dialog)
 
         return dialog
 
@@ -74,13 +85,32 @@ class ImageViewerDialog(BaseDialog):
         self.actions = {}
         self.source = None
         self.pixmap = None
+        self.scroll_area = None
+
+        # cache for image change / resize handling
         self._last_src_key = 0
         self._last_target_size = None
+
+        # icons
         self._icon_add = QIcon(":/icons/add.svg")
         self._icon_folder = QIcon(":/icons/folder.svg")
         self._icon_save = QIcon(":/icons/save.svg")
         self._icon_logout = QIcon(":/icons/logout.svg")
 
+        # zoom / pan state
+        self._zoom_mode = 'fit'  # 'fit' or 'manual'
+        self._zoom_factor = 1.0  # current manual factor (image space)
+        self._fit_factor = 1.0   # computed on-the-fly for fit mode
+        self._min_zoom = 0.05
+        self._max_zoom = 16.0
+        self._zoom_step = 1.25
+        self._drag_active = False
+        self._drag_last_pos = QPoint()
+
+        # performance guards to prevent extremely huge widget sizes
+        self._max_widget_dim = 32768          # max single dimension (px) for the view widget
+        self._max_total_pixels = 80_000_000   # max total pixels of the view widget (about 80MP)
+
     def append_layout(self, layout):
         """
         Update layout
@@ -98,18 +128,30 @@ class ImageViewerDialog(BaseDialog):
         """
         src = self.source.pixmap() if self.source is not None else None
         if src and not src.isNull() and self.pixmap is not None:
-            target_size = self.pixmap.size()
             key = src.cacheKey()
-            if key != self._last_src_key or target_size != self._last_target_size:
-                self.pixmap.setPixmap(
-                    src.scaled(
+            # reset to fit mode on new image
+            if key != self._last_src_key:
+                self._zoom_mode = 'fit'
+                self._zoom_factor = 1.0
+                if self.scroll_area is not None:
+                    self.scroll_area.setWidgetResizable(True)
+                # ensure no distortion in fit mode
+                if self.pixmap is not None:
+                    self.pixmap.setScaledContents(False)
+
+            if self._zoom_mode == 'fit':
+                target_size = self._viewport_size()
+                if key != self._last_src_key or target_size != self._last_target_size:
+                    # scale to viewport while keeping aspect ratio, smooth transform
+                    scaled = src.scaled(
                         target_size,
                         Qt.KeepAspectRatio,
                         Qt.SmoothTransformation
                     )
-                )
-                self._last_src_key = key
-                self._last_target_size = target_size
+                    self.pixmap.setPixmap(scaled)
+                    self._fit_factor = self._compute_fit_factor(src.size(), target_size)
+                    self._last_src_key = key
+                    self._last_target_size = target_size
         super(ImageViewerDialog, self).resizeEvent(event)
 
     def setup_menu(self) -> QMenuBar:
@@ -152,4 +194,248 @@ class ImageViewerDialog(BaseDialog):
         self.file_menu.addAction(self.actions["save_as"])
         self.file_menu.addAction(self.actions["exit"])
 
-        return self.menu_bar
+        return self.menu_bar
+
+    # =========================
+    # Zoom / pan implementation
+    # =========================
+
+    def eventFilter(self, obj, event):
+        """
+        Handle wheel zoom, panning and cursor changes on the scroll area viewport.
+        """
+        if self.scroll_area is None or obj is not self.scroll_area.viewport():
+            return super(ImageViewerDialog, self).eventFilter(obj, event)
+
+        et = event.type()
+
+        # Always show grab cursor when mouse is over the image area
+        if et == QEvent.Enter:
+            if self._has_image():
+                self.scroll_area.viewport().setCursor(Qt.OpenHandCursor)
+            return False
+
+        if et == QEvent.Leave:
+            self.scroll_area.viewport().unsetCursor()
+            return False
+
+        if et == QEvent.MouseButtonPress:
+            if event.button() == Qt.LeftButton and self._can_drag():
+                self._drag_active = True
+                self._drag_last_pos = self._event_pos(event)
+                self.scroll_area.viewport().setCursor(Qt.ClosedHandCursor)
+                event.accept()
+                return True
+            return False
+
+        if et == QEvent.MouseMove:
+            if self._drag_active:
+                pos = self._event_pos(event)
+                delta = pos - self._drag_last_pos
+                self._drag_last_pos = pos
+                # move scrollbars opposite to mouse movement
+                hbar = self.scroll_area.horizontalScrollBar()
+                vbar = self.scroll_area.verticalScrollBar()
+                hbar.setValue(hbar.value() - delta.x())
+                vbar.setValue(vbar.value() - delta.y())
+                event.accept()
+                return True
+            return False
+
+        if et == QEvent.MouseButtonRelease:
+            if event.button() == Qt.LeftButton and self._drag_active:
+                self._drag_active = False
+                # back to grab cursor
+                if self._has_image():
+                    self.scroll_area.viewport().setCursor(Qt.OpenHandCursor)
+                event.accept()
+                return True
+            return False
+
+        if et == QEvent.Wheel:
+            # zoom in/out with mouse wheel
+            if not self._has_image():
+                return False
+
+            # start manual zoom from current fit factor if needed
+            if self._zoom_mode == 'fit':
+                self._fit_factor = self._compute_fit_factor(
+                    self.source.pixmap().size(),
+                    self._viewport_size()
+                )
+                self._zoom_factor = self._fit_factor
+                self._zoom_mode = 'manual'
+                # switch to manual rendering path: original pixmap + scaled contents
+                self.scroll_area.setWidgetResizable(False)
+                self.pixmap.setScaledContents(True)
+                # ensure we display original image for better performance (no giant intermediate pixmaps)
+                self.pixmap.setPixmap(self.source.pixmap())
+
+            old_w = max(1, self.pixmap.width())
+            old_h = max(1, self.pixmap.height())
+
+            angle = 0
+            try:
+                angle = event.angleDelta().y()
+                if angle == 0:
+                    angle = event.angleDelta().x()
+            except Exception:
+                pass
+
+            if angle == 0:
+                return False
+
+            step = self._zoom_step if angle > 0 else (1.0 / self._zoom_step)
+            # compute tentative new factor and clamp by hard min/max and size guards
+            tentative = self._zoom_factor * step
+            tentative = max(self._min_zoom, min(self._max_zoom, tentative))
+            # apply size-based guards to avoid extremely huge widget sizes
+            tentative = self._clamp_factor_by_size(tentative)
+
+            if abs(tentative - self._zoom_factor) < 1e-9:
+                event.accept()
+                return True
+
+            vp_pos = self._event_pos(event)
+            hbar = self.scroll_area.horizontalScrollBar()
+            vbar = self.scroll_area.verticalScrollBar()
+
+            # position in content coords before zoom (keep point under cursor stable)
+            content_x = hbar.value() + vp_pos.x()
+            content_y = vbar.value() + vp_pos.y()
+            rx = content_x / float(old_w)
+            ry = content_y / float(old_h)
+
+            self._zoom_factor = tentative
+            self._set_scaled_pixmap_by_factor(self._zoom_factor)
+
+            new_w = max(1, self.pixmap.width())
+            new_h = max(1, self.pixmap.height())
+
+            hbar.setValue(int(rx * new_w - vp_pos.x()))
+            vbar.setValue(int(ry * new_h - vp_pos.y()))
+
+            event.accept()
+            return True
+
+        return super(ImageViewerDialog, self).eventFilter(obj, event)
+
+    def _has_image(self) -> bool:
+        """Check if source image is available."""
+        return (
+            self.source is not None
+            and self.source.pixmap() is not None
+            and not self.source.pixmap().isNull()
+            and self.pixmap is not None
+        )
+
+    def _can_drag(self) -> bool:
+        """Allow dragging only when image does not fit into the viewport."""
+        if not self._has_image():
+            return False
+        if self._zoom_mode != 'manual':
+            return False
+        vp = self._viewport_size()
+        return self.pixmap.width() > vp.width() or self.pixmap.height() > vp.height()
+
+    def _viewport_size(self) -> QSize:
+        """Get current viewport size."""
+        if self.scroll_area is not None:
+            return self.scroll_area.viewport().size()
+        return self.size()
+
+    def _compute_fit_factor(self, img_size: QSize, target: QSize) -> float:
+        """Compute factor for fitting image into target size."""
+        iw = max(1, img_size.width())
+        ih = max(1, img_size.height())
+        tw = max(1, target.width())
+        th = max(1, target.height())
+        return min(tw / float(iw), th / float(ih))
+
+    def _clamp_factor_by_size(self, factor: float) -> float:
+        """
+        Clamp zoom factor to avoid creating extremely large widget sizes.
+        This keeps interactivity smooth by limiting max resulting dimensions and total pixels.
+        """
+        src = self.source.pixmap()
+        if not src or src.isNull():
+            return factor
+
+        iw = max(1, src.width())
+        ih = max(1, src.height())
+
+        # only guard when zooming in; zooming out should not be limited by these caps
+        if factor <= 1.0:
+            return factor
+
+        # desired size
+        dw = iw * factor
+        dh = ih * factor
+
+        scale = 1.0
+
+        # total pixel cap
+        total = dw * dh
+        if total > self._max_total_pixels:
+            from math import sqrt
+            scale = min(scale, sqrt(self._max_total_pixels / float(total)))
+
+        # dimension caps
+        if dw * scale > self._max_widget_dim:
+            scale = min(scale, self._max_widget_dim / float(dw))
+        if dh * scale > self._max_widget_dim:
+            scale = min(scale, self._max_widget_dim / float(dh))
+
+        if scale < 1.0:
+            return max(self._min_zoom, factor * scale)
+        return factor
+
+    def _set_scaled_pixmap_by_factor(self, factor: float):
+        """
+        Scale and display the image using provided factor relative to the original image.
+        In manual mode this avoids allocating giant intermediate QPixmaps by:
+        - drawing the original pixmap;
+        - enabling scaled contents;
+        - resizing the label to the required size.
+        """
+        if not self._has_image():
+            return
+
+        src = self.source.pixmap()
+        iw = max(1, src.width())
+        ih = max(1, src.height())
+
+        # target size based on factor (KeepAspectRatio preserved by proportional math)
+        new_w = max(1, int(round(iw * factor)))
+        new_h = max(1, int(round(ih * factor)))
+
+        # enforce guards once more to be safe
+        guarded_factor = self._clamp_factor_by_size(factor)
+        if abs(guarded_factor - factor) > 1e-9:
+            new_w = max(1, int(round(iw * guarded_factor)))
+            new_h = max(1, int(round(ih * guarded_factor)))
+            self._zoom_factor = guarded_factor  # keep internal factor in sync
+
+        if self._zoom_mode == 'manual':
+            # ensure manual path uses original pixmap and scaled contents
+            if self.pixmap.pixmap() is None or self.pixmap.pixmap().cacheKey() != src.cacheKey():
+                self.pixmap.setPixmap(src)
+            self.pixmap.setScaledContents(True)
+            self.pixmap.resize(new_w, new_h)
+        else:
+            # fallback (not expected here): keep classic high-quality scaling
+            scaled = src.scaled(new_w, new_h, Qt.KeepAspectRatio, Qt.SmoothTransformation)
+            self.pixmap.setScaledContents(False)
+            self.pixmap.setPixmap(scaled)
+            if self.scroll_area is not None:
+                self.scroll_area.setWidgetResizable(True)
+
+    def _event_pos(self, event) -> QPoint:
+        """
+        Extract integer QPoint from mouse/touchpad event position (supports QPointF in 6.9+).
+        """
+        if hasattr(event, "position"):
+            return event.position().toPoint()
+        if hasattr(event, "pos"):
+            return event.pos()
+        return QPoint(0, 0)

pygpt_net/tools/text_editor/ui/widgets.py

@@ -6,7 +6,7 @@
 # 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: 2026.01.03 00:00:00                  #
 # ================================================== #
 
 from PySide6.QtGui import QAction, QIcon, QKeySequence
@@ -67,6 +67,10 @@ class TextFileEditor(BaseCodeEditor):
             )
             menu.addAction(action)
 
+        # Add zoom submenu
+        zoom_menu = self.window.ui.context_menu.get_zoom_menu(self, "editor", self.value, self.on_zoom_changed)
+        menu.addMenu(zoom_menu)
+
         action = QAction(self._icon_search, trans('text.context_menu.find'), menu)
         action.triggered.connect(self.find_open)
         action.setShortcut(QKeySequence.StandardKey.Find)

pygpt_net/ui/base/context_menu.py

@@ -6,8 +6,9 @@
 # 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: 2026.01.03 00:00:00                  #
 # ================================================== #
+from typing import Union
 
 from PySide6.QtWidgets import QMenu
 from PySide6.QtGui import QAction, QIcon
@@ -24,6 +25,8 @@ class ContextMenu:
     _ICON_CODE = QIcon(":/icons/code.svg")
     _ICON_TEXT = QIcon(":/icons/text.svg")
     _ICON_TRANSLATOR = QIcon(":/icons/translate.svg")
+    _ICON_ZOOM_IN = QIcon(":/icons/zoom_in.svg")
+    _ICON_ZOOM_OUT = QIcon(":/icons/zoom_out.svg")
 
     def __init__(self, window=None):
         """
@@ -33,6 +36,46 @@ class ContextMenu:
         """
         self.window = window
 
+    def get_zoom_menu(self, parent, parent_type: str, current_zoom: Union[int, float], callback = None) -> QMenu:
+        """
+        Get zoom menu (Zoom In/Out)
+
+        :param parent: Parent menu
+        :param parent_type: Type of textarea ('chat', 'notepad', etc.)
+        :param current_zoom: Current zoom level
+        :param callback: Callback function on zoom change
+        :return: Menu
+        """
+        menu = QMenu(trans('context_menu.zoom'), parent)
+        if parent_type in ("font_size.input", "font_size", "editor"):
+            action_zoom_in = QAction(self._ICON_ZOOM_IN, trans('context_menu.zoom.in'), menu)
+            new_zoom = current_zoom + 2
+            action_zoom_in.triggered.connect(
+                lambda checked=False, new_zoom=new_zoom: callback(new_zoom)
+            )
+            menu.addAction(action_zoom_in)
+            action_zoom_out = QAction(self._ICON_ZOOM_OUT, trans('context_menu.zoom.out'), menu)
+            new_zoom = current_zoom - 2
+            action_zoom_out.triggered.connect(
+                lambda checked=False, new_zoom=new_zoom: callback(new_zoom)
+            )
+            menu.addAction(action_zoom_out)
+        elif parent_type in ("zoom"):
+            action_zoom_in = QAction(self._ICON_ZOOM_IN, trans('context_menu.zoom.in'), menu)
+            new_zoom = current_zoom + 0.1
+            action_zoom_in.triggered.connect(
+                lambda checked=False, new_zoom=new_zoom: callback(new_zoom)
+            )
+            menu.addAction(action_zoom_in)
+            action_zoom_out = QAction(self._ICON_ZOOM_OUT, trans('context_menu.zoom.out'), menu)
+            new_zoom = current_zoom - 0.1
+            action_zoom_out.triggered.connect(
+                lambda checked=False, new_zoom=new_zoom: callback(new_zoom)
+            )
+            menu.addAction(action_zoom_out)
+
+        return menu
+
     def get_copy_to_menu(
             self,
             parent,

pygpt_net/ui/layout/toolbox/indexes.py

@@ -6,10 +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: 2026.01.03 17:00:00                  #
 # ================================================== #
 
-from PySide6.QtGui import QStandardItemModel, Qt, QIcon
+from PySide6.QtCore import Qt, QSize
+from PySide6.QtGui import QStandardItemModel, QIcon
 from PySide6.QtWidgets import QVBoxLayout, QHBoxLayout, QPushButton, QWidget, QCheckBox, QSizePolicy
 
 from pygpt_net.ui.widget.element.labels import HelpLabel, TitleLabel
@@ -54,6 +55,14 @@ class Indexes:
         """
         nodes = self.window.ui.nodes
         nodes['indexes.new'] = QPushButton(self._settings_icon, "")
+        # Configure compact, borderless settings button aligned to the right
+        icon_size = 20
+        nodes['indexes.new'].setFlat(True)
+        nodes['indexes.new'].setStyleSheet("QPushButton { border: none; background: transparent; padding: 0; }")
+        nodes['indexes.new'].setIconSize(QSize(icon_size, icon_size))
+        nodes['indexes.new'].setFixedSize(icon_size, icon_size)
+        nodes['indexes.new'].setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
+        nodes['indexes.new'].setFocusPolicy(Qt.NoFocus)
         nodes['indexes.new'].clicked.connect(self._open_llama_index_settings)
 
         nodes['indexes.label'] = TitleLabel(trans("toolbox.indexes.label"))
@@ -119,6 +128,14 @@ class Indexes:
         nodes['llama_index.mode.select'].setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
 
         nodes['indexes.new'] = QPushButton(self._settings_icon, "")
+        # Configure compact, borderless settings button for options row
+        icon_size = 20
+        nodes['indexes.new'].setFlat(True)
+        nodes['indexes.new'].setStyleSheet("QPushButton { border: none; background: transparent; padding: 0; }")
+        nodes['indexes.new'].setIconSize(QSize(icon_size, icon_size))
+        nodes['indexes.new'].setFixedSize(icon_size, icon_size)
+        nodes['indexes.new'].setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
+        nodes['indexes.new'].setFocusPolicy(Qt.NoFocus)
         nodes['indexes.new'].clicked.connect(self._open_llama_index_settings)
 
         nodes['indexes.label'] = TitleLabel(trans("toolbox.indexes.label"))
@@ -129,6 +146,8 @@ class Indexes:
         idx_layout.addWidget(nodes['indexes.select'])
         idx_layout.addWidget(nodes['indexes.new'], alignment=Qt.AlignRight)
         idx_layout.setContentsMargins(0, 0, 0, 10)
+        # Ensure the combo takes maximum horizontal space
+        idx_layout.setStretch(1, 1)
         idx_widget = QWidget()
         idx_widget.setLayout(idx_layout)
         idx_widget.setMinimumHeight(55)
@@ -138,6 +157,7 @@ class Indexes:
         mode_layout.addWidget(nodes['llama_index.mode.label'])
         mode_layout.addWidget(nodes['llama_index.mode.select'])
         mode_layout.setContentsMargins(0, 0, 0, 10)
+        mode_layout.setStretch(1, 1)
         mode_widget = QWidget()
         mode_widget.setLayout(mode_layout)
         mode_widget.setMinimumHeight(55)
@@ -173,23 +193,6 @@ class Indexes:
         if self._last_combo_signature != signature:
             self.window.ui.nodes['indexes.select'].set_keys(combo_keys)
             self._last_combo_signature = signature
-        """
-        # store previous selection
-        self.window.ui.nodes[self.id].backup_selection()
-
-        self.window.ui.models[self.id].removeRows(0, self.window.ui.models[self.id].rowCount())
-        i = 0
-        for item in data:
-            self.window.ui.models[self.id].insertRow(i)
-            name = item['name']
-            index = self.window.ui.models[self.id].index(i, 0)
-            self.window.ui.models[self.id].setData(index, "ID: " + item['id'], QtCore.Qt.ToolTipRole)
-            self.window.ui.models[self.id].setData(self.window.ui.models[self.id].index(i, 0), name)
-            i += 1
-
-        # restore previous selection
-        self.window.ui.nodes[self.id].restore_selection()
-        """
 
     def _open_llama_index_settings(self):
         self.window.controller.settings.open_section('llama-index')

pygpt_net/ui/layout/toolbox/model.py

@@ -6,10 +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: 2026.01.03 17:00:00                  #
 # ================================================== #
-
-from PySide6.QtWidgets import QVBoxLayout, QWidget
+from PySide6.QtCore import Qt, QSize
+from PySide6.QtGui import QIcon
+from PySide6.QtWidgets import QVBoxLayout, QWidget, QPushButton, QHBoxLayout, QSizePolicy
 
 from pygpt_net.ui.widget.element.labels import TitleLabel
 from pygpt_net.ui.widget.lists.model_combo import ModelCombo
@@ -27,6 +28,7 @@ class Model:
         self.window = window
         self.id = 'prompt.model'
         self.label_key = f'{self.id}.label'
+        self._settings_icon = QIcon(":/icons/settings.svg")
 
     def setup(self) -> QWidget:
         """
@@ -51,12 +53,33 @@ class Model:
         nodes[self.label_key] = label
 
         combo = ModelCombo(self.window, self.id)
+        # Ensure combo takes maximum horizontal space
+        combo.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
         nodes[self.id] = combo
 
+        nodes['prompt.model.settings'] = QPushButton(self._settings_icon, "")
+        # Configure compact, borderless settings button aligned to the right
+        icon_size = 20
+        nodes['prompt.model.settings'].setFlat(True)
+        nodes['prompt.model.settings'].setStyleSheet("QPushButton { border: none; padding: 0; }")
+        nodes['prompt.model.settings'].setIconSize(QSize(icon_size, icon_size))
+        nodes['prompt.model.settings'].setFixedSize(icon_size, icon_size)
+        nodes['prompt.model.settings'].setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
+        nodes['prompt.model.settings'].setFocusPolicy(Qt.NoFocus)
+        nodes['prompt.model.settings'].clicked.connect(self._open_settings)
+
+        model_cols = QHBoxLayout()
+        model_cols.addWidget(combo, 1)  # stretch to take remaining space
+        model_cols.addWidget(nodes['prompt.model.settings'], alignment=Qt.AlignRight)
+        model_cols.setContentsMargins(0, 0, 0, 0)
+
         layout = QVBoxLayout()
         layout.addWidget(label)
-        layout.addWidget(combo)
+        layout.addLayout(model_cols)
         layout.addStretch()
         layout.setContentsMargins(2, 5, 5, 5)
 
-        return layout
+        return layout
+
+    def _open_settings(self):
+        self.window.controller.model.editor.open()

pygpt_net/ui/widget/image/display.py

@@ -6,7 +6,7 @@
 # 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: 2026.01.03 17:00:00                  #
 # ================================================== #
 
 from PySide6.QtGui import QAction, QIcon
@@ -27,6 +27,17 @@ class ImageLabel(QLabel):
         self.window = window
         self.path = path
 
+    def _get_window(self):
+        """
+        Get main window instance
+
+        :return: Window instance
+        """
+        if self.window is not None:
+            if hasattr(self.window, 'window'):
+                return self.window.window
+        return self.window
+
     def contextMenuEvent(self, event):
         """
         Context menu event
@@ -36,6 +47,8 @@ class ImageLabel(QLabel):
         if not self.path:
             return
 
+        win = self._get_window()
+
         actions = {}
         use_actions = []
         actions['open'] = QAction(QIcon(":/icons/fullscreen.svg"), trans('img.action.open'), self)
@@ -64,13 +77,13 @@ class ImageLabel(QLabel):
             self,
         )
         actions['use_attachment'].triggered.connect(
-            lambda: self.window.controller.files.use_attachment(self.path),
+            lambda: win.controller.files.use_attachment(self.path),
         )
         use_actions.append(actions['use_attachment'])
 
         # use by filetype
-        if self.window.core.filesystem.actions.has_use(self.path):
-            extra_use_actions = self.window.core.filesystem.actions.get_use(self, self.path)
+        if win.core.filesystem.actions.has_use(self.path):
+            extra_use_actions = win.core.filesystem.actions.get_use(self, self.path)
             for action in extra_use_actions:
                 use_actions.append(action)
 
@@ -97,7 +110,8 @@ class ImageLabel(QLabel):
 
         :param event: mouse event
         """
-        self.window.tools.get("viewer").open(self.path)
+        win = self._get_window()
+        win.tools.get("viewer").open(self.path)
 
     def action_open_dir(self, event):
         """
@@ -105,7 +119,8 @@ class ImageLabel(QLabel):
 
         :param event: mouse event
         """
-        self.window.tools.get("viewer").open_dir(self.path)
+        win = self._get_window()
+        win.tools.get("viewer").open_dir(self.path)
 
     def action_save(self, event):
         """
@@ -113,7 +128,8 @@ class ImageLabel(QLabel):
 
         :param event: mouse event
         """
-        self.window.tools.get("viewer").save(self.path)
+        win = self._get_window()
+        win.tools.get("viewer").save(self.path)
 
     def action_delete(self, event):
         """
@@ -121,4 +137,5 @@ class ImageLabel(QLabel):
 
         :param event: mouse event
         """
-        self.window.tools.get("viewer").delete(self.path)
+        win = self._get_window()
+        win.tools.get("viewer").delete(self.path)