ms-components 0.3.0__tar.gz → 0.3.2__tar.gz

{ms_components-0.3.0 → ms_components-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ms_components
-Version: 0.3.0
+Version: 0.3.2
 Summary: PySide6 UI components for MolSuite: smart table, project browser, job monitor, PyMOL dock, steppers.
 Author: Mario S. Valdés-Tresanco, Mario E. Valdés-Tresanco
 License-Expression: MIT

ms_components-0.3.2/docs/api_reference.md

@@ -0,0 +1,102 @@
+# API reference
+
+The reference below is generated directly from the current Python sources.
+Names beginning with an underscore are implementation details.
+
+## Smart table
+
+::: ms_components.ms_table
+
+## Monitor
+
+::: ms_components.ms_monitor
+
+## Hosts and executors
+
+::: ms_components.ms_executors
+
+## Projects
+
+::: ms_components.ms_projects
+
+## Settings
+
+::: ms_components.ms_settings
+
+## PyMOL
+
+::: ms_components.ms_pymol
+
+Comparison scenes provide grid and overlay layouts without reloading structures
+or changing the camera. Assign each structure/pose pair the same positive PyMOL
+`grid_slot`, then pass its display name:
+
+```python
+dock.set_scene_context(
+    "comparison",
+    grid_labels={1: "Complex A", 3: "Complex B"},
+)
+dock.set_comparison_layout("overlay")
+```
+
+`grid_labels` is also accepted by `PymolControlBar` and `PymolSceneContext`.
+Without explicit labels, molecular object titles (or object names when no title
+is available) are joined per positive `grid_slot` within the context's `target`.
+Applications must pass display names if those names are not present in PyMOL.
+
+The **Display > Comparison > Grid / Overlay** menu appears only in comparison
+scenes. The chosen layout persists when changing poses or applying presets.
+Overlay displays the existing coordinates together; alignment remains the
+caller's responsibility.
+
+Each label is a pseudoatom named `panel_text<slot>`, initially sized 14.
+Grid labels appear at the top-left of their panel; overlay labels form a stacked
+legend that follows viewport resizing. Receptor cartoons, carbon atoms and label
+text share the slot's `COMPARISON_COLORS` color. Heteroatom colors are preserved.
+The label outline uses PyMOL's background-adaptive `front` color for readability
+on light and dark backgrounds. The palette has ten colors and repeats beyond ten
+slots.
+Existing labels are updated in place, so individual settings remain editable,
+for example `cmd.set("label_size", 18, "panel_text3")`. Presets restore label
+visibility after changing molecular representations.
+
+To replace one pose without rebuilding the scene, pass its bytes directly:
+
+```python
+dock.replace_comparison_object(
+    "pose_a", pdb_bytes, "pdb",
+    reference="receptor_a", label="Complex A [P2]",
+)
+```
+
+The new object inherits the reference's transformation and slot, is shown as
+sticks, and receives the same comparison color. Camera and auto-zoom settings
+are preserved. The previous object remains available until the replacement loads
+successfully. This API neither fetches data nor calls the hosting application.
+Hosts remain responsible for reading their data and discarding stale requests.
+
+Setting any non-comparison scene context after a comparison context removes
+the managed labels and sets `grid_mode` to zero. Applications should update
+the scene context when leaving their off-target view, even without loading a
+new structure. Unrelated grid scenes and user-created annotations are not
+removed. `"offtarget"` remains accepted as an alias for `"comparison"`.
+
+## Stepper
+
+::: ms_components.ms_stepper
+
+## Guided tutorials
+
+::: ms_components.ms_tutorial
+
+## Tool panel
+
+::: ms_components.tool_panel
+
+## Step dialog
+
+::: ms_components.step_dialog
+
+## Theme
+
+::: ms_components.theme

{ms_components-0.3.0 → ms_components-0.3.2}/docs/usage.md

@@ -178,6 +178,19 @@ panel.show()
 
 ## Projects, settings, and PyMOL
 
+Applications embedding PyMOL should call
+`ms_components.opengl.prepare_pymol_opengl()` **before creating `QApplication`**.
+It requests desktop OpenGL and shared contexts, then checks the actual context
+and compiles legacy GLSL shaders in an isolated process. A failed native check
+can select `xcb` on Linux only when an X11 display passes the same check and
+`QT_QPA_PLATFORM` was not explicitly set. Windows and macOS retain their native
+platforms. If no tested backend works, it raises `RuntimeError` before the
+application starts. Skip this call when PyMOL is disabled or running headlessly.
+
+`PymolDockWidget` also requests desktop OpenGL on its own widget and validates
+the actual context before drawing. An incompatible context displays an error
+in the viewer instead of passing it to PyMOL.
+
 - `ProjectsMenuWidget(app_id=...)` and `ProjectBrowserWindow(app_id=...)` list
   and create projects through the public `ms_flow` project catalog. Connect
   `project_requested` to open the chosen project; do not read the MolSuite

{ms_components-0.3.0 → ms_components-0.3.2}/src/ms_components/base.qss

@@ -64,6 +64,19 @@ QProgressBar#ToolProgress::chunk {
     background: palette(highlight);
 }
 
+/* ms_table: a PROGRESS cell, a filled bar with its text on top. The fill color is
+   the `tone` property, from the theme accents (theme.tone_qss). The track is the
+   header tone: it keeps text contrast and stands out from the rows. */
+QProgressBar#CellProgress {
+    border: none;
+    border-radius: 3px;
+    background: palette(dark);
+}
+
+QProgressBar#CellProgress::chunk {
+    border-radius: 3px;
+}
+
 
 /* Left gap for the first tab: `tab-bar { left }` shifts the whole bar.
    Do NOT use margins on ::tab -- Qt places the close button flush to the full
@@ -154,6 +167,14 @@ QToolButton[popupMode="MenuButtonPopup"]::menu-button {
     width: 18px;
 }
 
+/* Qt's own tooltip colours are a pale grey that dark themes leave unreadable. */
+QToolTip {
+    background: palette(window);
+    color: palette(text);
+    border: 1px solid palette(highlight);
+    padding: 4px;
+}
+
 /* Card = content surface. Nav trees/lists stay flat unless opted in. */
 QTableView,
 QTreeView[card="true"],

{ms_components-0.3.0 → ms_components-0.3.2}/src/ms_components/ms_dockwidget/widget.py

@@ -734,7 +734,10 @@ class VerticalToolbar(QWidget):
                 yield w
 
     def _layout_has_buttons(self, layout: QVBoxLayout) -> bool:
-        return any(True for _ in self._iter_buttons(layout))
+        # Action buttons (no dock_id) count too: a section holding only those is not empty.
+        return any(
+            isinstance(layout.itemAt(i).widget(), QToolButton) for i in range(layout.count())
+        )
 
     def _update_separator_visibility(self):
         self._separator.setVisible(

{ms_components-0.3.0 → ms_components-0.3.2}/src/ms_components/ms_pymol/__init__.py

@@ -1,4 +1,5 @@
 from .widget import (
+    COMPARISON_COLORS,
     PymolControlBar,
     PymolDockWidget,
     PymolPresetSpec,
@@ -6,6 +7,7 @@ from .widget import (
 )
 
 __all__ = [
+    "COMPARISON_COLORS",
     "PymolControlBar",
     "PymolDockWidget",
     "PymolPresetSpec",

{ms_components-0.3.0 → ms_components-0.3.2}/src/ms_components/ms_pymol/widget.py

@@ -1,17 +1,19 @@
 from __future__ import annotations
 
+import logging
 import os
 from collections.abc import Callable, Mapping
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, replace
 from pathlib import Path
 from typing import Any
 
 from ms_components.ms_dockwidget.widget import MSDockWidget
+from ms_components.opengl import pymol_context_error, pymol_surface_format
 
 os.environ.setdefault("QT_API", "pyside6")
 
 from PySide6.QtCore import QByteArray, QEvent, QSize, Qt, QTimer, Signal
-from PySide6.QtGui import QAction, QActionGroup, QIcon, QPainter, QPixmap
+from PySide6.QtGui import QAction, QActionGroup, QGuiApplication, QIcon, QPainter, QPixmap
 from PySide6.QtSvg import QSvgRenderer
 from PySide6.QtWidgets import (
     QFrame,
@@ -36,6 +38,44 @@ except ImportError:
 from . import plugins as _pymol_plugins  # noqa: F401
 
 
+class _PymolGLWidget(PyMOLGLWidget):
+    def __init__(self, parent):
+        super().__init__(parent)
+        self._opengl_error: str | None = None
+        self._opengl_error_label: QLabel | None = None
+        if hasattr(self, "setFormat"):
+            self.setFormat(pymol_surface_format(self.format()))
+
+    def initializeGL(self):
+        context = self.context()
+        self._opengl_error = pymol_context_error(context)
+        if self._opengl_error_label is not None:
+            self._opengl_error_label.hide()
+        if self._opengl_error:
+            logging.getLogger(__name__).error(self._opengl_error)
+            if self._opengl_error_label is None:
+                self._opengl_error_label = QLabel(self)
+                self._opengl_error_label.setWordWrap(True)
+                QVBoxLayout(self).addWidget(self._opengl_error_label)
+            self._opengl_error_label.setText(f"PyMOL viewer unavailable.\n{self._opengl_error}")
+            self._opengl_error_label.show()
+            return
+        fmt = context.format()
+        logging.getLogger(__name__).info(
+            "PyMOL context: %s, OpenGL %s.%s %s",
+            QGuiApplication.platformName(), *fmt.version(), fmt.profile().name,
+        )
+        super().initializeGL()
+
+    def paintGL(self):
+        if self._opengl_error is None:
+            super().paintGL()
+
+    def resizeGL(self, width, height):
+        if self._opengl_error is None:
+            super().resizeGL(width, height)
+
+
 SELECTION_MODES = (
     ("Atoms", 0),
     ("Residues", 1),
@@ -53,6 +93,10 @@ REPRESENTATIONS = (
 )
 
 _TOOLBAR_ICONS = Path(__file__).parent / "icons"
+COMPARISON_COLORS = (
+    "orange", "tv_green", "cyan", "magenta", "yellow",
+    "salmon", "violet", "lime", "deepteal", "hotpink",
+)
 
 
 @dataclass(frozen=True)
@@ -61,6 +105,11 @@ class PymolSceneContext:
     target: str = "all"
     selections: Mapping[str, str] = field(default_factory=dict)
     default_preset: str = ""
+    grid_labels: Mapping[int, str] = field(default_factory=dict)
+
+    @property
+    def is_comparison(self) -> bool:
+        return self.kind in {"comparison", "offtarget"}
 
     def selection(self, role: str, fallback: str = "") -> str:
         value = str(dict(self.selections or {}).get(str(role)) or "").strip()
@@ -100,6 +149,8 @@ class PymolControlBar(QFrame):
         super().__init__(parent)
         self._cmd = cmd
         self._context = PymolSceneContext()
+        self._grid_label_objects: set[str] = set()
+        self._comparison_layout = "grid"
         self._presets: dict[str, PymolPresetSpec] = {}
         self.setObjectName("PymolControlBar")
 
@@ -168,6 +219,18 @@ class PymolControlBar(QFrame):
             "Apply a representation to the current selection or scene target.",
             menu=representation_menu,
         )
+        self.comparison_menu = representation_menu.addMenu("Comparison")
+        self.comparison_menu.menuAction().setVisible(False)
+        comparison_group = QActionGroup(self.comparison_menu)
+        comparison_group.setExclusive(True)
+        self._comparison_layout_actions: dict[str, QAction] = {}
+        for label, value in (("Grid", "grid"), ("Overlay", "overlay")):
+            action = self.comparison_menu.addAction(label)
+            action.setCheckable(True)
+            action.setChecked(value == self._comparison_layout)
+            comparison_group.addAction(action)
+            action.triggered.connect(lambda checked=False, layout=value: self.set_comparison_layout(layout))
+            self._comparison_layout_actions[value] = action
 
         hide_menu = QMenu("Hide", bar)
         for label, value in (("Everything", "everything"), *REPRESENTATIONS):
@@ -359,6 +422,7 @@ class PymolControlBar(QFrame):
         target: str = "all",
         selections: Mapping[str, str] | None = None,
         default_preset: str = "",
+        grid_labels: Mapping[int, str] | None = None,
     ) -> None:
         if isinstance(context, PymolSceneContext):
             normalized = context
@@ -372,11 +436,136 @@ class PymolControlBar(QFrame):
                     if str(key).strip() and str(value).strip()
                 },
                 default_preset=str(default_preset or "").strip(),
+                grid_labels=dict(grid_labels or {}),
             )
+        was_comparison = self._context.is_comparison
         self._context = normalized
+        self.comparison_menu.menuAction().setVisible(normalized.is_comparison)
+        if was_comparison or normalized.is_comparison:
+            self._run_command("Grid labels", self._sync_grid_labels)
         self.refresh_context_label()
         self._refresh_preset_menu()
 
+    @property
+    def comparison_layout(self) -> str:
+        return self._comparison_layout
+
+    def set_comparison_layout(self, layout: str) -> None:
+        if layout not in self._comparison_layout_actions:
+            raise ValueError(f"Unsupported comparison layout: {layout}")
+        if not self._context.is_comparison:
+            raise ValueError("A comparison scene is required to change its layout.")
+        previous = self._comparison_layout
+        self._comparison_layout = layout
+
+        def apply() -> None:
+            self._sync_grid_labels()
+            self._cmd.refresh()
+
+        if not self._run_command("Comparison layout", apply):
+            self._comparison_layout = previous
+        for value, action in self._comparison_layout_actions.items():
+            action.setChecked(value == self._comparison_layout)
+
+    def _sync_grid_labels(self, *, color_objects: bool = True) -> None:
+        labels = dict(self._context.grid_labels)
+        if self._context.is_comparison:
+            self._cmd.set("grid_mode", int(self._comparison_layout == "grid"))
+            slot_names: dict[int, list[str]] = {}
+            for obj in self._cmd.get_object_list(self._context.target):
+                if obj in self._grid_label_objects:
+                    continue
+                slot = self._cmd.get_setting_int("grid_slot", obj)
+                if slot > 0:
+                    color = COMPARISON_COLORS[(slot - 1) % len(COMPARISON_COLORS)]
+                    if color_objects:
+                        self._cmd.set("cartoon_color", color, selection=obj)
+                        self._cmd.color(color, f"({obj}) and elem C")
+                    slot_names.setdefault(slot, []).append(self._cmd.get_title(obj, 1) or obj)
+            if not labels:
+                labels = {slot: " + ".join(names) for slot, names in slot_names.items()}
+        else:
+            labels = {}
+            self._cmd.set("grid_mode", 0)
+
+        wanted = {f"panel_text{slot}" for slot in labels}
+        for obj in self._grid_label_objects - wanted:
+            self._cmd.delete(obj)
+        self._grid_label_objects.intersection_update(wanted)
+        existing = set(self._cmd.get_names("objects"))
+        for slot, title in sorted(labels.items()):
+            if slot <= 0:
+                raise ValueError("Grid label slots must be positive integers.")
+            obj = f"panel_text{slot}"
+            if obj not in existing:
+                self._cmd.pseudoatom(obj, label=title)
+                self._grid_label_objects.add(obj)
+                self._cmd.hide("everything", obj)
+                self._cmd.set("label_relative_mode", 1, selection=obj)
+                self._cmd.set("label_size", 14, selection=obj)
+                self._cmd.set("label_position", [1, -1, 0], selection=obj)
+                self._cmd.set("grid_slot", slot, selection=obj)
+            elif obj in self._grid_label_objects:
+                self._cmd.label(obj, repr(title))
+            else:
+                raise ValueError(f"Grid label object '{obj}' already exists.")
+            color = COMPARISON_COLORS[(slot - 1) % len(COMPARISON_COLORS)]
+            self._cmd.set("label_color", color, selection=obj)
+            self._cmd.set("label_outline_color", "front", selection=obj)
+            self._cmd.show("labels", obj)
+        self._position_comparison_labels()
+
+    def _position_comparison_labels(self) -> None:
+        if not self._context.is_comparison:
+            return
+        existing = set(self._cmd.get_names("objects"))
+        height = max(1, self._cmd.get_viewport()[1])
+        offset = 0.0
+        for obj in sorted(self._grid_label_objects & existing,
+                          key=lambda name: self._cmd.get_setting_int("grid_slot", name)):
+            self._cmd.set("label_screen_point", [-1, 1 - offset, 0], selection=obj)
+            if self._comparison_layout == "overlay":
+                offset += 2 * (abs(self._cmd.get_setting_float("label_size", obj)) + 6) / height
+
+    def replace_comparison_object(
+        self, name: str, data: bytes, fmt: str, *, reference: str, label: str,
+    ) -> bool:
+        def apply() -> None:
+            if not self._context.is_comparison:
+                raise ValueError("A comparison scene is required to replace an object.")
+            objects = self._cmd.get_names("objects")
+            if name not in objects or reference not in objects:
+                raise ValueError("The comparison object and its reference must already exist.")
+            if name == reference:
+                raise ValueError("The comparison object must differ from its reference.")
+            slot = self._cmd.get_setting_int("grid_slot", reference)
+            if slot <= 0:
+                raise ValueError("The comparison reference must have a positive grid slot.")
+            auto_zoom = self._cmd.get_setting_int("auto_zoom")
+            temporary = self._cmd.get_unused_name("_comparison_pose")
+            try:
+                self._cmd.set("auto_zoom", 0)
+                self._cmd.load_raw(data, fmt, temporary)
+                self._cmd.matrix_copy(reference, temporary)
+                self._cmd.set("grid_slot", slot, temporary)
+                self._cmd.show("sticks", temporary)
+                self._cmd.color("atomic", temporary)
+                color = COMPARISON_COLORS[(slot - 1) % len(COMPARISON_COLORS)]
+                self._cmd.set("cartoon_color", color, temporary)
+                self._cmd.color(color, f"({temporary}) and elem C")
+                self._cmd.delete(name)
+                self._cmd.set_name(temporary, name)
+                self._context = replace(
+                    self._context, grid_labels={**self._context.grid_labels, slot: label},
+                )
+                self._sync_grid_labels(color_objects=False)
+            finally:
+                if temporary in self._cmd.get_names("objects"):
+                    self._cmd.delete(temporary)
+                self._cmd.set("auto_zoom", auto_zoom)
+
+        return self._run_command("Replace comparison object", apply)
+
     def register_preset(self, spec: PymolPresetSpec) -> None:
         key = str(spec.key or "").strip()
         if not key:
@@ -507,6 +696,8 @@ class PymolControlBar(QFrame):
 
         def apply() -> None:
             spec.callback(self._cmd, self._context)
+            if self._context.is_comparison:
+                self._sync_grid_labels()
 
         if self._run_command(spec.label, apply):
             self.preset_applied.emit(normalized_key)
@@ -585,13 +776,13 @@ class PymolDockWidget(MSDockWidget):
 
     def __init__(self, title: str, manager, parent=None):
         super().__init__(title, manager, parent)
-        self.pymol_widget = PyMOLGLWidget(self)
-        self.pymol_widget.installEventFilter(self)
+        self.pymol_widget = _PymolGLWidget(self)
         if self.cmd is not None:
             self.cmd.set("internal_gui", False)
 
         self.control_bar = PymolControlBar(self.cmd, self)
         self.toolbar = self.control_bar
+        self.pymol_widget.installEventFilter(self)
 
         self._side_panel_widget: QWidget | None = None
         self._splitter = QSplitter(Qt.Horizontal, self)
@@ -640,17 +831,31 @@ class PymolDockWidget(MSDockWidget):
         target: str = "all",
         selections: Mapping[str, str] | None = None,
         default_preset: str = "",
+        grid_labels: Mapping[int, str] | None = None,
     ) -> None:
         self.control_bar.set_scene_context(
             context,
             target=target,
             selections=selections,
             default_preset=default_preset,
+            grid_labels=grid_labels,
         )
 
     def register_preset(self, spec: PymolPresetSpec) -> None:
         self.control_bar.register_preset(spec)
 
+    def set_comparison_layout(self, layout: str) -> None:
+        self.control_bar.set_comparison_layout(layout)
+
+    @property
+    def comparison_layout(self) -> str:
+        return self.control_bar.comparison_layout
+
+    def replace_comparison_object(
+        self, name: str, data: bytes, fmt: str, *, reference: str, label: str,
+    ) -> bool:
+        return self.control_bar.replace_comparison_object(name, data, fmt, reference=reference, label=label)
+
     def unregister_preset(self, key: str) -> None:
         self.control_bar.unregister_preset(key)
 
@@ -687,10 +892,13 @@ class PymolDockWidget(MSDockWidget):
     def eventFilter(self, watched, event):
         if watched is self.pymol_widget and event.type() == QEvent.Type.MouseButtonRelease:
             QTimer.singleShot(0, self.control_bar.refresh_context_label)
+        elif watched is self.pymol_widget and event.type() == QEvent.Type.Resize and self.scene_context.is_comparison:
+            QTimer.singleShot(0, self.control_bar._position_comparison_labels)
         return super().eventFilter(watched, event)
 
 
 __all__ = [
+    "COMPARISON_COLORS",
     "PymolControlBar",
     "PymolDockWidget",
     "PymolPresetSpec",

{ms_components-0.3.0 → ms_components-0.3.2}/src/ms_components/ms_table/cell_delegate.py

@@ -58,10 +58,10 @@ from __future__ import annotations
 
 from typing import Any, Callable, Optional
 
-from PySide6.QtCore import QModelIndex, QRect, QRectF, QSize, Qt
-from PySide6.QtGui import QImage, QPainter, QPalette, QPixmap
+from PySide6.QtCore import QModelIndex, QPoint, QRect, QRectF, QSize, Qt
+from PySide6.QtGui import QImage, QPainter, QPixmap, QRegion
 from PySide6.QtWidgets import (
-    QApplication, QStyle, QStyledItemDelegate, QStyleOptionViewItem,
+    QApplication, QProgressBar, QStyle, QStyledItemDelegate, QStyleOptionViewItem,
     QWidget,
 )
 
@@ -159,6 +159,8 @@ class CellWidgetDelegate(QStyledItemDelegate):
         # Persistent widget cache: row → QWidget
         # Invalidated when the page changes (load_data)
         self._persistent_widgets: dict[int, QWidget] = {}
+        # PROGRESS cells: one hidden bar per tone, so the tone property is set once.
+        self._progress_bars: dict[str, QProgressBar] = {}
 
     # ── Invalidate the cache on page change ───────────────────────────────
 
@@ -185,30 +187,40 @@ class CellWidgetDelegate(QStyledItemDelegate):
 
         row_data = self._get_row_data(index)
 
-        # ── progress mode: a fraction 0..1 as the style's own progress bar ──
+        # ── progress mode: a fraction 0..1 (or value/max) as the style's own progress bar ──
         if col_def.kind == ColumnKind.PROGRESS:
             try:
-                fraction = min(max(float(row_data.get(col_def.display_key) or 0.0), 0.0), 1.0)
+                value = float(row_data.get(col_def.display_key) or 0.0)
+                maximum = float(row_data.get(col_def.progress_max) or 0.0) if col_def.progress_max else 1.0
+                fraction = min(max(value / maximum, 0.0), 1.0) if maximum > 0 else 0.0
             except (TypeError, ValueError):
-                fraction = 0.0
-            # ponytail: painted by hand: CE_ProgressBar under an app stylesheet draws the
-            # table's rules, not QProgressBar's, and a partial chunk came out as a line.
-            rect, pal = QRectF(option.rect.adjusted(4, 5, -4, -5)), option.palette
-            painter.save()
-            painter.setRenderHint(QPainter.Antialiasing)
-            # A selected row is Highlight already: the track goes Base so the fill still shows.
-            track = pal.color(QPalette.Base) if option.state & QStyle.State_Selected else pal.color(QPalette.Text)
-            if not option.state & QStyle.State_Selected:
-                track.setAlpha(40)
-            painter.setPen(Qt.NoPen)
-            painter.setBrush(track)
-            painter.drawRoundedRect(rect, 3, 3)
-            if fraction > 0:
-                painter.setBrush(pal.color(QPalette.Highlight))
-                painter.drawRoundedRect(QRectF(rect.x(), rect.y(), rect.width() * fraction, rect.height()), 3, 3)
-            painter.setPen(pal.color(QPalette.Text))
-            painter.drawText(rect, Qt.AlignCenter, f"{int(fraction * 100)}%")  # floored: 99.9% is not "100%"
-            painter.restore()
+                value, maximum, fraction = 0.0, 0.0, 0.0
+            text = f"{int(fraction * 100)}%"  # floored: 99.9% is not "100%"
+            if col_def.progress_max:
+                text = f"{int(value):,}/{int(maximum):,} ({text})"
+            tone = col_def.progress_tone(row_data) if col_def.progress_tone else "green"
+            # A hidden QProgressBar paints the cell, so the bar is the native one and its look is
+            # QSS (`QProgressBar#CellProgress`, `[tone=...]`). render(), not drawControl(): under a
+            # stylesheet drawControl lays the chunk out from the widget, not from the option. Into a
+            # pixmap: rendered on the view's painter it ignores the viewport offset and lands under
+            # the headers.
+            bar = self._progress_bars.get(tone)
+            if bar is None:
+                bar = self._progress_bars[tone] = QProgressBar()
+                bar.setObjectName("CellProgress")
+                bar.setProperty("tone", tone)
+                bar.setRange(0, 1000)
+                bar.setAlignment(Qt.AlignCenter)
+            bar.setValue(int(fraction * 1000))
+            bar.setFormat(text)
+            rect = option.rect.adjusted(4, 5, -4, -5)
+            bar.resize(rect.size())
+            ratio = painter.device().devicePixelRatioF()
+            pixmap = QPixmap(rect.size() * ratio)
+            pixmap.setDevicePixelRatio(ratio)
+            pixmap.fill(Qt.transparent)
+            bar.render(pixmap, QPoint(), QRegion(), QWidget.DrawChildren)
+            painter.drawPixmap(rect.topLeft(), pixmap)
             return
 
         # ── paint_factory mode (SVG / image) ───────────────────────────────

{ms_components-0.3.0 → ms_components-0.3.2}/src/ms_components/ms_table/query_builder.py

@@ -234,11 +234,13 @@ class QueryBuilder:
         attr = self._resolve_attr(sort.field)
         if attr is None:
             return pk > pk_value
+        # SQLite puts NULLs first ascending and last descending.
+        rest_of_nulls = and_(attr.is_(None), pk > pk_value)
         if sort_value is None:
-            # NULLs come first in ascending SQLite: past the null block, anything goes.
-            return attr.is_not(None) if not sort.descending else and_(attr.is_(None), pk > pk_value)
-        ahead = attr < sort_value if sort.descending else attr > sort_value
-        return or_(ahead, and_(attr == sort_value, pk > pk_value))
+            return or_(attr.is_not(None), rest_of_nulls) if not sort.descending else rest_of_nulls
+        if sort.descending:
+            return or_(attr < sort_value, and_(attr == sort_value, pk > pk_value), attr.is_(None))
+        return or_(attr > sort_value, and_(attr == sort_value, pk > pk_value))
 
     def fetch(self) -> tuple[list[dict], int]:
         """Run the query and return (rows_as_dicts, total_count)."""

{ms_components-0.3.0 → ms_components-0.3.2}/src/ms_components/ms_table/smart_table_view.py

@@ -154,6 +154,15 @@ class SmartTableView(QWidget):
             self._infinite_total_hint = total
             self._infinite_total_exact = True
             self._infinite_has_more = self._infinite_loaded_end < total
+            tail = self._infinite_pages.get(self._infinite_frontier_page)
+            if tail is not None and len(tail) < self._builder.page_size and self._infinite_has_more:
+                # The last page came back short and rows were added since: forget it, so the
+                # autofill set_total() triggers fetches it again once it is in view. Kept, its
+                # rows past the old end would stay blank forever.
+                del self._infinite_pages[self._infinite_frontier_page]
+                # The next page's cursor is the short page's last row: wrong now, so it is
+                # found by offset instead.
+                self._infinite_page_cursors.pop(self._infinite_frontier_page + 1, None)
         self._model.set_total(total)
         return True
 
@@ -749,8 +758,9 @@ class SmartTableView(QWidget):
         self.load_next_page()
 
     def _on_refresh_clicked(self):
-        # Reload this table, then let the host (e.g. DockingStudio) refresh surrounding state.
-        self.refresh()
+        # Reload this table where the user is looking (scroll and selection kept), then let
+        # the host (e.g. DockingStudio) refresh surrounding state.
+        self.refresh_preserving_view()
         self.refresh_clicked.emit()
 
     # ──────────────────────────────────────────