Nam Pham Dinh ThanhandClaude Opus 5
509ae96854
Settings sat closer to its icon than Dashboard and Giám sát do. Those are tree rows, laid out by the style; Settings was a QPushButton, whose icon-to-label gap is also the style's — and the two do not agree. The Windows fix for this was a 19px icon box that nudged the label 1px, which is exactly the kind of tuning that only holds on the machine it was measured on: on macOS the gap is tighter again. The row now lays itself out, 4px in and 6px between, the same two numbers the tree uses. Icon x=4 and label x=26 against the rows' 4 and 26 — equal, not close. The language drop-list showed a tick over its own text. macOS marks the current row with a checkmark and Windows does not, and the popup inherits the combo's width — which for "EN/JP/VN" is about 50px, all of it needed by the letters. widen_popup() measures the longest item plus the platform's indicator and sets the view's minimum, so the tick has its own room wherever it is drawn. That check found two more: the project picker (191px of text in a 138px popup) and the provider list (221px in 138px) were both truncating names here, tick or no tick. Neither could be reproduced on this machine, so the checks assert the property that made the bug possible — spacing we control rather than the style's, and a popup measured against text + indicator — not the platform. 21/21 checkers pass. check_nav segfaults in Qt teardown after printing its verdict, twice in one suite run and 0 times in 8 standalone runs; pre-existing. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
703 lines
27 KiB
Python
703 lines
27 KiB
Python
"""Reusable widgets: a collapsible list section, a plan checklist, a thin
|
||
collapse strip, and a scroll-wheel guard for value widgets in scrollable
|
||
forms."""
|
||
from __future__ import annotations
|
||
|
||
from pathlib import Path
|
||
|
||
from PySide6.QtCore import QEvent, QObject, QPointF, QRectF, Qt, Signal
|
||
from PySide6.QtGui import QColor, QPainter, QPen
|
||
from PySide6.QtWidgets import (
|
||
QAbstractSpinBox, QCheckBox, QComboBox, QDoubleSpinBox, QFrame,
|
||
QHBoxLayout, QLabel, QListWidget, QListWidgetItem, QPushButton, QSizePolicy,
|
||
QVBoxLayout, QWidget,
|
||
)
|
||
|
||
from ..core.flows import STEP_DONE, STEP_ERROR, STEP_PENDING, STEP_RUNNING
|
||
from ..theme import current_palette
|
||
from .icons import DOT_BLUE, DOT_GREEN, DOT_GREY, DOT_RED, dot_icon, icon
|
||
|
||
|
||
def _style_card(frame: QFrame) -> None:
|
||
"""Give a stat/budget card its surface. Flat by design: the raised surface
|
||
plus a hairline is what separates it from the page — the old drop shadow
|
||
made a grid of these look like it was hovering off the screen."""
|
||
p = current_palette()
|
||
frame.setStyleSheet(
|
||
f"QFrame {{ background: {p.surface}; border: 1px solid {p.border};"
|
||
f" border-radius: {p.radius_lg}px; }}")
|
||
|
||
|
||
class StatCard(QFrame):
|
||
"""A titled value card (e.g. token count + its cost as the subtitle) —
|
||
shared by Dashboard and Monitoring's token/cost displays."""
|
||
|
||
def __init__(self):
|
||
super().__init__()
|
||
self.setFrameShape(QFrame.NoFrame)
|
||
_style_card(self)
|
||
lay = QVBoxLayout(self)
|
||
self.title_lbl = QLabel("")
|
||
self.title_lbl.setObjectName("hint")
|
||
self.title_lbl.setStyleSheet("border: none;")
|
||
self.value_lbl = QLabel("—")
|
||
self.value_lbl.setStyleSheet("border: none; font-size: 22px; font-weight: 600;")
|
||
self.sub_lbl = QLabel("")
|
||
self.sub_lbl.setObjectName("hint")
|
||
self.sub_lbl.setStyleSheet("border: none;")
|
||
# Word-wrap the sub-label: a long note (e.g. the "estimated tokens"
|
||
# sentence on the cost card) would otherwise report a single-line
|
||
# sizeHint hundreds of px wide, forcing its WHOLE grid column open and
|
||
# throwing every card in the row out of alignment.
|
||
self.sub_lbl.setWordWrap(True)
|
||
# Number first, name under it — the figure is what the eye is looking
|
||
# for, and it is how the audit page's tiles are drawn.
|
||
lay.addWidget(self.value_lbl)
|
||
lay.addWidget(self.title_lbl)
|
||
lay.addWidget(self.sub_lbl)
|
||
|
||
def set(self, title: str, value: str, sub: str = "") -> None:
|
||
self.title_lbl.setText(title)
|
||
self.value_lbl.setText(value)
|
||
self.sub_lbl.setText(sub)
|
||
|
||
def as_hero(self) -> "StatCard":
|
||
"""Make this the headline card: bigger number, accent colour.
|
||
|
||
Used for the one figure a screen is really about (Dashboard's total
|
||
cost), so a row of otherwise identical tiles has a clear first read.
|
||
"""
|
||
from ..theme import current_palette
|
||
p = current_palette()
|
||
self.value_lbl.setStyleSheet(
|
||
f"border: none; font-size: 34px; font-weight: 700; color: {p.accent};")
|
||
self.setObjectName("heroCard")
|
||
return self
|
||
|
||
|
||
class BudgetCard(QFrame):
|
||
"""Remaining/Budget box — same card chrome as :class:`StatCard`, plus a
|
||
direct budget-entry field. The card is a dumb display: the owning tab
|
||
(Dashboard/Monitoring, both share the same ``usage.budget_*`` config) wires
|
||
``apply_btn.clicked`` to persist a new budget and refresh, and calls
|
||
:meth:`set` with pre-formatted text + whether to render in the ⚠ warn color
|
||
(the app turns the remaining balance red past 85% budget used)."""
|
||
|
||
def __init__(self):
|
||
super().__init__()
|
||
self.setFrameShape(QFrame.NoFrame)
|
||
_style_card(self)
|
||
lay = QVBoxLayout(self)
|
||
self.title_lbl = QLabel("")
|
||
self.title_lbl.setObjectName("hint")
|
||
self.title_lbl.setStyleSheet("border: none;")
|
||
self.value_lbl = QLabel("—")
|
||
self._value_style = "border: none; font-size: 22px; font-weight: 600;"
|
||
self.value_lbl.setStyleSheet(self._value_style)
|
||
self.sub_lbl = QLabel("")
|
||
self.sub_lbl.setObjectName("hint")
|
||
self.sub_lbl.setStyleSheet("border: none;")
|
||
# Word-wrap the sub-label: a long note (e.g. the "estimated tokens"
|
||
# sentence on the cost card) would otherwise report a single-line
|
||
# sizeHint hundreds of px wide, forcing its WHOLE grid column open and
|
||
# throwing every card in the row out of alignment.
|
||
self.sub_lbl.setWordWrap(True)
|
||
# Same order as StatCard: the number first, its name under it.
|
||
lay.addWidget(self.value_lbl)
|
||
lay.addWidget(self.title_lbl)
|
||
lay.addWidget(self.sub_lbl)
|
||
|
||
row = QHBoxLayout()
|
||
row.setSpacing(4)
|
||
self.budget_spin = QDoubleSpinBox()
|
||
self.budget_spin.setRange(0, 100_000_000)
|
||
self.budget_spin.setDecimals(2)
|
||
self.budget_spin.setButtonSymbols(QAbstractSpinBox.NoButtons)
|
||
self.apply_btn = QPushButton()
|
||
self.apply_btn.setFixedWidth(30)
|
||
row.addWidget(self.budget_spin, 1)
|
||
row.addWidget(self.apply_btn)
|
||
lay.addLayout(row)
|
||
|
||
def set(self, title: str, value: str, sub: str, warn: bool = False) -> None:
|
||
self.title_lbl.setText(title)
|
||
self.value_lbl.setText(value)
|
||
self.value_lbl.setStyleSheet(
|
||
self._value_style + (f" color: {current_palette().danger};" if warn else ""))
|
||
self.sub_lbl.setText(sub)
|
||
|
||
|
||
def fmt_tokens(n: int) -> str:
|
||
if n >= 1_000_000:
|
||
return f"{n / 1e6:.2f}M"
|
||
if n >= 1_000:
|
||
return f"{n / 1e3:.1f}K"
|
||
return str(n)
|
||
|
||
|
||
class _WheelGuard(QObject):
|
||
"""Swallows wheel events on a value widget unless the user has clicked
|
||
into it first (i.e. it has keyboard focus). Without this, scrolling a
|
||
Settings/task-editor form accidentally spins whatever combo box or
|
||
spin box the cursor happens to pass over, silently changing values."""
|
||
|
||
def eventFilter(self, obj, event): # noqa: N802
|
||
if event.type() == QEvent.Wheel and not obj.hasFocus():
|
||
event.ignore()
|
||
return True # eat it → the scroll area scrolls instead
|
||
return False
|
||
|
||
|
||
_wheel_guard = _WheelGuard()
|
||
|
||
|
||
def guard_wheel(root: QWidget) -> None:
|
||
"""Protect every QComboBox / spin box / date-time edit under ``root``:
|
||
the mouse wheel only changes their value after an explicit click into
|
||
the widget (StrongFocus excludes wheel-acquired focus), otherwise the
|
||
wheel scrolls the surrounding form like the user expects."""
|
||
targets = root.findChildren(QComboBox) + root.findChildren(QAbstractSpinBox)
|
||
for w in targets:
|
||
w.setFocusPolicy(Qt.StrongFocus)
|
||
w.installEventFilter(_wheel_guard)
|
||
|
||
|
||
def widen_popup(combo) -> None:
|
||
"""Give a drop-list room for its text AND the tick beside the current item.
|
||
|
||
macOS draws a checkmark against the selected row; Windows does not. A combo
|
||
only as wide as "VN" therefore looked fine here and had its two letters
|
||
covered there. The popup inherits the combo's width unless told otherwise,
|
||
so measure what has to fit and say so.
|
||
"""
|
||
from PySide6.QtWidgets import QStyle
|
||
|
||
view = combo.view()
|
||
fm = view.fontMetrics()
|
||
longest = max((fm.horizontalAdvance(combo.itemText(i))
|
||
for i in range(combo.count())), default=0)
|
||
tick = combo.style().pixelMetric(QStyle.PM_IndicatorWidth, None, combo)
|
||
pad = combo.style().pixelMetric(QStyle.PM_FocusFrameHMargin, None, combo) * 2
|
||
view.setMinimumWidth(longest + tick + pad + 16)
|
||
|
||
|
||
def ui_scale(widget: QWidget) -> float:
|
||
"""How much bigger this machine draws things than the design baseline.
|
||
|
||
Breakpoints written as raw pixels only hold on the screen they were tuned
|
||
on. At 125%/150% display scaling Qt still reports logical pixels, but every
|
||
label, button and margin is taller — so the same layout needs MORE logical
|
||
width before it stops being cramped. Font height is the honest proxy for
|
||
that: it moves with the display scale and with a user's font-size choice,
|
||
both of which change how much fits.
|
||
|
||
1.0 at the 15px line height the layouts were measured against.
|
||
"""
|
||
return max(0.75, min(2.5, widget.fontMetrics().height() / 15.0))
|
||
|
||
|
||
class _NarrowGuard(QObject):
|
||
"""Calls back when the WINDOW crosses a width threshold.
|
||
|
||
Watching the widget's own width does not work: a pane whose minimum width is
|
||
larger than the space available never reports being narrow — it just gets
|
||
clipped, which is the very problem being solved. The window always knows its
|
||
real size, so that is what gets watched.
|
||
|
||
A fold the user did by hand is never undone: auto-expand only reverses an
|
||
auto-collapse.
|
||
"""
|
||
|
||
def __init__(self, owner: QWidget, threshold: int, apply):
|
||
super().__init__(owner)
|
||
self._owner = owner
|
||
self._threshold = threshold
|
||
self._apply = apply
|
||
self._auto = False # True while WE are the ones holding it folded
|
||
self._window = None
|
||
|
||
def attach(self) -> None:
|
||
win = self._owner.window()
|
||
if win is not None and win is not self._owner and win is not self._window:
|
||
win.installEventFilter(self)
|
||
self._window = win
|
||
# Dragging the window to a monitor with different scaling changes
|
||
# how much fits without changing its width, so re-decide then too.
|
||
handle = win.windowHandle()
|
||
if handle is not None:
|
||
handle.screenChanged.connect(lambda *_a: self.check())
|
||
self.check()
|
||
|
||
def eventFilter(self, obj, ev): # noqa: N802 - Qt override
|
||
if ev.type() == QEvent.Resize and obj is self._window:
|
||
self.check()
|
||
return super().eventFilter(obj, ev)
|
||
|
||
def check(self) -> None:
|
||
win = self._owner.window()
|
||
width = win.width() if win is not None else self._owner.width()
|
||
# The threshold is written for the baseline scale and grows with the
|
||
# machine's — see ui_scale().
|
||
narrow = width < self._threshold * ui_scale(self._owner)
|
||
if narrow == self._auto:
|
||
return
|
||
self._auto = narrow
|
||
self._apply(narrow)
|
||
|
||
|
||
def narrow_guard(owner: QWidget, threshold: int, apply):
|
||
"""Fold `owner`'s secondary panes below `threshold` px of window width.
|
||
|
||
``apply(narrow: bool)`` does the folding. Call ``.attach()`` from showEvent.
|
||
"""
|
||
return _NarrowGuard(owner, threshold, apply)
|
||
|
||
|
||
class ToggleSwitch(QCheckBox):
|
||
"""A checkbox drawn as an on/off switch.
|
||
|
||
Subclasses QCheckBox rather than replacing it, so every ``isChecked()`` /
|
||
``setChecked()`` / ``stateChanged`` call site keeps working untouched — only
|
||
the painting changes. A switch reads as "this is on or off" where a tick box
|
||
reads as "this is selected", which is what these settings actually mean.
|
||
"""
|
||
|
||
_W, _H = 34, 18
|
||
|
||
def __init__(self, text: str = "", parent=None):
|
||
super().__init__(text, parent)
|
||
self.setCursor(Qt.PointingHandCursor)
|
||
|
||
def sizeHint(self): # noqa: N802 - Qt override
|
||
base = super().sizeHint()
|
||
base.setWidth(base.width() + self._W)
|
||
base.setHeight(max(base.height(), self._H + 4))
|
||
return base
|
||
|
||
def paintEvent(self, _e): # noqa: N802 - Qt override
|
||
from ..theme import current_palette
|
||
p = current_palette()
|
||
painter = QPainter(self)
|
||
painter.setRenderHint(QPainter.Antialiasing)
|
||
y = (self.height() - self._H) // 2
|
||
track = QRectF(0, y, self._W, self._H)
|
||
on = self.isChecked()
|
||
enabled = self.isEnabled()
|
||
fill = QColor(p.accent_solid if on else p.border_strong)
|
||
if not enabled:
|
||
fill.setAlpha(110)
|
||
painter.setPen(Qt.NoPen)
|
||
painter.setBrush(fill)
|
||
painter.drawRoundedRect(track, self._H / 2, self._H / 2)
|
||
knob = self._H - 4
|
||
kx = self._W - knob - 2 if on else 2
|
||
painter.setBrush(QColor("#FFFFFF" if enabled else p.text_faint))
|
||
painter.drawEllipse(QRectF(kx, y + 2, knob, knob))
|
||
if self.text():
|
||
painter.setPen(QColor(p.text if enabled else p.text_faint))
|
||
painter.drawText(
|
||
QRectF(self._W + 8, 0, self.width() - self._W - 8, self.height()),
|
||
int(Qt.AlignLeft | Qt.AlignVCenter), self.text())
|
||
painter.end()
|
||
|
||
|
||
class SegmentedControl(QWidget):
|
||
"""Two-to-four choices shown side by side instead of hidden in a drop-list.
|
||
|
||
Exposes the slice of the QComboBox API this app's settings code uses
|
||
(addItem / findData / currentData / setCurrentIndex / currentIndexChanged),
|
||
so it drops into an existing form without touching the save/load paths.
|
||
"""
|
||
|
||
currentIndexChanged = Signal(int)
|
||
|
||
def __init__(self, parent=None):
|
||
super().__init__(parent)
|
||
self._data: list = []
|
||
self._buttons: list = []
|
||
self._current = -1
|
||
lay = QHBoxLayout(self)
|
||
lay.setContentsMargins(0, 0, 0, 0)
|
||
lay.setSpacing(0)
|
||
self._lay = lay
|
||
lay.addStretch(1)
|
||
|
||
def addItem(self, text: str, data=None) -> None: # noqa: N802 - Qt-style name
|
||
from PySide6.QtWidgets import QPushButton
|
||
btn = QPushButton(text)
|
||
btn.setObjectName("segItem")
|
||
btn.setCheckable(True)
|
||
btn.setCursor(Qt.PointingHandCursor)
|
||
index = len(self._buttons)
|
||
btn.clicked.connect(lambda _c=False, i=index: self.setCurrentIndex(i))
|
||
self._lay.insertWidget(index, btn)
|
||
self._buttons.append(btn)
|
||
self._data.append(data)
|
||
if self._current < 0:
|
||
self.setCurrentIndex(0)
|
||
|
||
def findData(self, value) -> int: # noqa: N802
|
||
return self._data.index(value) if value in self._data else -1
|
||
|
||
def currentData(self): # noqa: N802
|
||
return self._data[self._current] if 0 <= self._current < len(self._data) else None
|
||
|
||
def currentIndex(self) -> int: # noqa: N802
|
||
return self._current
|
||
|
||
def count(self) -> int:
|
||
return len(self._buttons)
|
||
|
||
def setItemText(self, index: int, text: str) -> None: # noqa: N802
|
||
if 0 <= index < len(self._buttons):
|
||
self._buttons[index].setText(text)
|
||
|
||
def setCurrentIndex(self, index: int) -> None: # noqa: N802
|
||
if not (0 <= index < len(self._buttons)) or index == self._current:
|
||
for i, b in enumerate(self._buttons):
|
||
b.setChecked(i == self._current)
|
||
return
|
||
self._current = index
|
||
for i, b in enumerate(self._buttons):
|
||
b.setChecked(i == index)
|
||
self.currentIndexChanged.emit(index)
|
||
|
||
|
||
def section_panels(sections, width: int = 260):
|
||
"""Left list + right panel: pick a section, see that section only.
|
||
|
||
``sections`` is [(label, widget)]. Returns (list_widget, stack) for the
|
||
caller to place side by side. Used by Settings and the Task editor so both
|
||
are navigated the same way, instead of one long scroll where you cannot
|
||
tell which group you are in or how many are left.
|
||
"""
|
||
from PySide6.QtWidgets import QListWidget, QListWidgetItem, QStackedWidget
|
||
|
||
index = QListWidget()
|
||
index.setObjectName("sectionIndex")
|
||
index.setFrameShape(QListWidget.NoFrame)
|
||
index.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
|
||
index.setTextElideMode(Qt.ElideRight)
|
||
index.setWordWrap(False)
|
||
|
||
stack = QStackedWidget()
|
||
for label, widget in sections:
|
||
item = QListWidgetItem(label)
|
||
item.setToolTip(label)
|
||
index.addItem(item)
|
||
stack.addWidget(widget)
|
||
index.currentRowChanged.connect(stack.setCurrentIndex)
|
||
index.setCurrentRow(0)
|
||
|
||
natural = max(index.fontMetrics().horizontalAdvance(lab) for lab, _w in sections) + 36
|
||
index.setFixedWidth(max(120, min(width, natural)))
|
||
return index, stack
|
||
|
||
|
||
def section_index(scroll, sections, width: int = 260):
|
||
"""A clickable table of contents for a long scrolling dialog.
|
||
|
||
``sections`` is [(label, anchor_widget)]. Clicking a row scrolls its anchor
|
||
into view; scrolling the dialog moves the highlight back. Purely navigation:
|
||
every field stays exactly where it was, in the same one scrolling column —
|
||
Settings and the Task editor were five stacked group boxes deep with no way
|
||
to tell what was further down.
|
||
|
||
Returns the QListWidget so the caller can place it.
|
||
"""
|
||
from PySide6.QtWidgets import QListWidget, QListWidgetItem
|
||
|
||
index = QListWidget()
|
||
index.setObjectName("sectionIndex")
|
||
index.setFrameShape(QListWidget.NoFrame)
|
||
# Long section names (and 125%/150% display scaling) used to push a
|
||
# horizontal scrollbar into this list. It elides instead, with the full
|
||
# name on hover.
|
||
index.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
|
||
index.setTextElideMode(Qt.ElideRight)
|
||
index.setWordWrap(False)
|
||
for label, anchor in sections:
|
||
item = QListWidgetItem(label)
|
||
item.setToolTip(label)
|
||
item.setData(Qt.UserRole, anchor)
|
||
index.addItem(item)
|
||
index.setCurrentRow(0)
|
||
# Wide enough for the longest name at the CURRENT font — so the width grows
|
||
# with display scaling instead of eliding everything — but capped so it
|
||
# never eats the form beside it. `width` is that cap, not a fixed size.
|
||
natural = max(index.fontMetrics().horizontalAdvance(lab) for lab, _a in sections) + 36
|
||
index.setFixedWidth(max(120, min(width, natural)))
|
||
|
||
def _jump(item):
|
||
anchor = item.data(Qt.UserRole)
|
||
if anchor is not None:
|
||
# Scroll so the section's top edge lands at the top of the viewport,
|
||
# rather than merely "somewhere visible".
|
||
bar = scroll.verticalScrollBar()
|
||
top = anchor.mapTo(scroll.widget(), anchor.rect().topLeft()).y()
|
||
bar.setValue(min(top, bar.maximum()))
|
||
|
||
index.itemClicked.connect(_jump)
|
||
|
||
def _follow(value: int):
|
||
"""Highlight the last section whose top has passed the viewport top."""
|
||
row = 0
|
||
for i in range(index.count()):
|
||
anchor = index.item(i).data(Qt.UserRole)
|
||
if anchor is None:
|
||
continue
|
||
top = anchor.mapTo(scroll.widget(), anchor.rect().topLeft()).y()
|
||
if top <= value + 4:
|
||
row = i
|
||
if index.currentRow() != row:
|
||
blocked = index.blockSignals(True)
|
||
index.setCurrentRow(row)
|
||
index.blockSignals(blocked)
|
||
|
||
scroll.verticalScrollBar().valueChanged.connect(_follow)
|
||
return index
|
||
|
||
|
||
class CollapseStrip(QWidget):
|
||
"""The slim bar shown in place of a collapsed side panel.
|
||
|
||
It draws a clear chevron (▸ / ◂) near the top — the expand affordance — over
|
||
a thin handle line, and the whole strip is clickable to expand the panel."""
|
||
|
||
clicked = Signal()
|
||
WIDTH = 18 # click target width; wide enough to show the expand arrow
|
||
|
||
def __init__(self, tooltip: str = "Click to expand", expand_dir: str = "right"):
|
||
super().__init__()
|
||
self._hover = False
|
||
self._dir = "left" if expand_dir == "left" else "right"
|
||
self.setFixedWidth(self.WIDTH)
|
||
self.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding)
|
||
self.setCursor(Qt.PointingHandCursor)
|
||
self.setToolTip(tooltip)
|
||
|
||
def enterEvent(self, e) -> None: # noqa: N802
|
||
self._hover = True
|
||
self.update()
|
||
super().enterEvent(e)
|
||
|
||
def leaveEvent(self, e) -> None: # noqa: N802
|
||
self._hover = False
|
||
self.update()
|
||
super().leaveEvent(e)
|
||
|
||
def mousePressEvent(self, e) -> None: # noqa: N802
|
||
if e.button() == Qt.LeftButton:
|
||
self.clicked.emit()
|
||
super().mousePressEvent(e)
|
||
|
||
def paintEvent(self, e) -> None: # noqa: N802
|
||
p = QPainter(self)
|
||
p.setRenderHint(QPainter.Antialiasing)
|
||
w = self.width()
|
||
tok = current_palette()
|
||
accent = QColor(tok.accent) if self._hover else QColor(tok.text_faint)
|
||
|
||
# A small rounded "button" at the top carries the expand arrow so the
|
||
# collapsed panel always shows a clear, clickable affordance.
|
||
bw = min(w - 2.0, 16.0)
|
||
btn = QRectF((w - bw) / 2.0, 6.0, bw, 18.0)
|
||
p.setPen(QPen(QColor(tok.border_strong), 1.0))
|
||
p.setBrush(QColor(tok.hover if self._hover else tok.surface))
|
||
p.drawRoundedRect(btn, float(tok.radius_sm), float(tok.radius_sm))
|
||
|
||
cx = w / 2.0
|
||
cy = btn.center().y()
|
||
s = 4.0
|
||
pen = QPen(accent, 2.0)
|
||
pen.setCapStyle(Qt.RoundCap)
|
||
pen.setJoinStyle(Qt.RoundJoin)
|
||
p.setPen(pen)
|
||
if self._dir == "right": # '›' — expands content to the right
|
||
tip_x, base_x = cx + s / 2.0, cx - s / 2.0
|
||
else: # '‹' — expands content to the left
|
||
tip_x, base_x = cx - s / 2.0, cx + s / 2.0
|
||
p.drawLine(QPointF(base_x, cy - s), QPointF(tip_x, cy))
|
||
p.drawLine(QPointF(tip_x, cy), QPointF(base_x, cy + s))
|
||
|
||
# thin handle line below the button
|
||
p.setPen(Qt.NoPen)
|
||
p.setBrush(QColor(tok.border_strong))
|
||
line_w = 2.0
|
||
x = (w - line_w) / 2.0
|
||
ltop = btn.bottom() + 6.0
|
||
lbottom = max(ltop, self.height() - 10.0)
|
||
p.drawRoundedRect(QRectF(x, ltop, line_w, lbottom - ltop), 1.0, 1.0)
|
||
p.end()
|
||
|
||
|
||
class PlanSection(QWidget):
|
||
"""A collapsible checklist of the current message's plan steps with live
|
||
line-icon status markers (pending dot · running play · done check · error
|
||
close). Hidden until it has steps; updated in place as the agent calls
|
||
``update_plan``."""
|
||
|
||
@staticmethod
|
||
def _step_color(status: str) -> str | None:
|
||
"""Row text colour per step status; None leaves the default. Resolved
|
||
per call so it follows a live theme switch."""
|
||
p = current_palette()
|
||
return {STEP_RUNNING: p.accent, STEP_DONE: p.success, STEP_ERROR: p.danger}.get(status)
|
||
|
||
@staticmethod
|
||
def _step_icon(status: str):
|
||
if status == STEP_RUNNING:
|
||
return icon("play", color=DOT_BLUE)
|
||
if status == STEP_DONE:
|
||
return icon("check", color=DOT_GREEN)
|
||
if status == STEP_ERROR:
|
||
return icon("close", color=DOT_RED)
|
||
return dot_icon(DOT_GREY) # pending
|
||
|
||
def __init__(self, title: str = "Plan", max_height: int = 150):
|
||
super().__init__()
|
||
self._title = title
|
||
self._count = 0
|
||
|
||
lay = QVBoxLayout(self)
|
||
lay.setContentsMargins(0, 0, 0, 0)
|
||
lay.setSpacing(2)
|
||
|
||
self.header = QPushButton()
|
||
self.header.setCheckable(True)
|
||
self.header.setChecked(True)
|
||
self.header.setStyleSheet("text-align:left; font-weight:600;")
|
||
self.header.toggled.connect(self._toggle)
|
||
lay.addWidget(self.header)
|
||
|
||
self.list = QListWidget()
|
||
self.list.setMaximumHeight(max_height) # scrolls when longer
|
||
lay.addWidget(self.list)
|
||
|
||
self.setVisible(False)
|
||
self._update_header()
|
||
|
||
def set_steps(self, steps) -> None:
|
||
"""Replace the checklist with ``[{title, status}]`` (the agent sends the FULL
|
||
list each update, so we rebuild in place)."""
|
||
self.list.clear()
|
||
self._count = 0
|
||
for s in steps or []:
|
||
title = str((s or {}).get("title", "")).strip()
|
||
if not title:
|
||
continue
|
||
status = str((s or {}).get("status", STEP_PENDING)).strip().lower()
|
||
item = QListWidgetItem(self._step_icon(status), f" {title}")
|
||
color = self._step_color(status)
|
||
if color:
|
||
item.setForeground(QColor(color))
|
||
self.list.addItem(item)
|
||
self._count += 1
|
||
self.setVisible(self._count > 0)
|
||
if self._count and not self.header.isChecked():
|
||
self.header.setChecked(True)
|
||
self.list.setVisible(self.header.isChecked())
|
||
self._update_header()
|
||
|
||
def clear(self) -> None:
|
||
self.list.clear()
|
||
self._count = 0
|
||
self.setVisible(False)
|
||
self._update_header()
|
||
|
||
def set_title(self, title: str) -> None:
|
||
"""Update the header label (for live language switching)."""
|
||
self._title = title
|
||
self._update_header()
|
||
|
||
def _toggle(self, on: bool) -> None:
|
||
self.list.setVisible(on)
|
||
self._update_header()
|
||
|
||
def _update_header(self) -> None:
|
||
arrow = "▾" if self.header.isChecked() else "▸"
|
||
self.header.setText(f"{arrow} {self._title} ({self._count})")
|
||
|
||
|
||
class CollapsibleSection(QWidget):
|
||
"""A pull-down header + a scrollable list. Hidden until it has items."""
|
||
|
||
activated = Signal(str) # emits the path of a clicked item
|
||
|
||
def __init__(self, title: str, max_height: int = 130):
|
||
super().__init__()
|
||
self._title = title
|
||
self._paths: list[str] = []
|
||
|
||
lay = QVBoxLayout(self)
|
||
lay.setContentsMargins(0, 0, 0, 0)
|
||
lay.setSpacing(2)
|
||
|
||
self.header = QPushButton()
|
||
self.header.setCheckable(True)
|
||
self.header.setChecked(False)
|
||
self.header.setStyleSheet("text-align:left; font-weight:600;")
|
||
self.header.toggled.connect(self._toggle)
|
||
lay.addWidget(self.header)
|
||
|
||
self.list = QListWidget()
|
||
self.list.setMaximumHeight(max_height) # scrolls when longer
|
||
self.list.setVisible(False)
|
||
self.list.itemActivated.connect(self._emit)
|
||
self.list.itemClicked.connect(self._emit)
|
||
lay.addWidget(self.list)
|
||
|
||
self.setVisible(False)
|
||
self._update_header()
|
||
|
||
def add(self, path: str) -> None:
|
||
if not path or path in self._paths:
|
||
return
|
||
self._paths.append(path)
|
||
item = QListWidgetItem(Path(path).name)
|
||
item.setData(Qt.UserRole, path)
|
||
item.setToolTip(path)
|
||
self.list.addItem(item)
|
||
self.setVisible(True)
|
||
# Auto-open so added / restored files are visible without a click.
|
||
if not self.header.isChecked():
|
||
self.header.setChecked(True)
|
||
self._update_header()
|
||
|
||
def remove(self, path: str) -> None:
|
||
if path not in self._paths:
|
||
return
|
||
i = self._paths.index(path)
|
||
self._paths.pop(i)
|
||
item = self.list.takeItem(i)
|
||
del item
|
||
self.setVisible(bool(self._paths))
|
||
self._update_header()
|
||
|
||
def paths(self) -> list[str]:
|
||
return list(self._paths)
|
||
|
||
def clear(self) -> None:
|
||
self._paths.clear()
|
||
self.list.clear()
|
||
self.setVisible(False)
|
||
self._update_header()
|
||
|
||
def set_title(self, title: str) -> None:
|
||
"""Update the header label (for live language switching)."""
|
||
self._title = title
|
||
self._update_header()
|
||
|
||
def _toggle(self, on: bool) -> None:
|
||
self.list.setVisible(on)
|
||
self._update_header()
|
||
|
||
def _update_header(self) -> None:
|
||
arrow = "▾" if self.header.isChecked() else "▸"
|
||
self.header.setText(f"{arrow} {self._title} ({len(self._paths)})")
|
||
|
||
def _emit(self, item: QListWidgetItem) -> None:
|
||
path = item.data(Qt.UserRole)
|
||
if path:
|
||
self.activated.emit(path)
|