Desktop workbench overhaul: toolbar options, input/constants/result redesign, design-token pass

app_desktop/constants_editor.py

@@ -7,6 +7,7 @@
 from PySide6.QtWidgets import (
     QCheckBox,
     QHBoxLayout,
+    QLabel,
     QPushButton,
     QPlainTextEdit,
     QStackedWidget,
@@ -21,7 +22,7 @@
     normalize_constants_state,
     parse_constants_text,
 )
-from app_desktop.theme import constants_editor_style
+from app_desktop.theme import CARD_PADDING, constants_editor_style
 from app_desktop.widget_hints import set_accessible_description
 
 
@@ -73,22 +74,12 @@ def __init__(
         layout.setContentsMargins(8, 8, 8, 8)
         layout.setSpacing(8)
 
-        header_layout = QHBoxLayout()
-        header_layout.setContentsMargins(0, 0, 0, 0)
-        header_layout.setSpacing(6)
+        # The checkbox is legacy/hidden; keep it for callers that still poke it, but it no longer
+        # occupies its own header row (the summary + ? sit in the controls row, like the data card).
         self.checkbox = QCheckBox(checkbox_text)
         self.checkbox.setChecked(bool(checked))
         self.checkbox.toggled.connect(self._on_checked_changed)
         self.checkbox.hide()
-        header_layout.addWidget(self.checkbox)
-        self.help_button = _HelpButton("?")
-        self.help_button.setFlat(True)
-        self.help_button.setFocusPolicy(Qt.NoFocus)
-        self.help_button.setFixedWidth(24)
-        self.help_button.hide()
-        header_layout.addWidget(self.help_button)
-        header_layout.addStretch()
-        layout.addLayout(header_layout)
 
         self.controls_widget = QWidget()
         controls_layout = QHBoxLayout(self.controls_widget)
@@ -103,18 +94,37 @@ def __init__(
         self.remove_button.clicked.connect(self._remove_row)
         self.clear_button.clicked.connect(self.clear)
         self.view_toggle_button.clicked.connect(self._toggle_view)
+        # Card title on the LEFT of the controls row (mirrors the data card's "输入数据" title).
+        self.title_label = QLabel("输入常数")
+        self.title_label.setObjectName("constants_title")
+        controls_layout.addWidget(self.title_label)
         controls_layout.addWidget(self.add_button)
         controls_layout.addWidget(self.remove_button)
         controls_layout.addWidget(self.clear_button)
         controls_layout.addWidget(self.view_toggle_button)
         controls_layout.addStretch()
+        # Row-count summary (mirrors the data card's "N 行"), then the ? help button — both on the
+        # RIGHT of the controls row, not a separate header line.
+        self.summary_label = QLabel("")
+        self.summary_label.setObjectName("constants_summary")
+        controls_layout.addWidget(self.summary_label)
+        self.help_button = _HelpButton("?")
+        self.help_button.setFlat(True)
+        self.help_button.setFocusPolicy(Qt.NoFocus)
+        self.help_button.setFixedWidth(24)
+        self.help_button.hide()
+        controls_layout.addWidget(self.help_button)
         layout.addWidget(self.controls_widget)
 
         self.stack = QStackedWidget()
         self.table_view = QTableWidget(self._min_rows, 2)
         self.table_view.setHorizontalHeaderLabels(["Name", "Value"])
         self.table_view.setMinimumHeight(120)
         self.table_view.itemChanged.connect(self._on_table_changed)
+        # Excel-like block copy (Ctrl/Cmd+C → TSV).
+        from app_desktop.table_copy import install_cell_copy
+
+        install_cell_copy(self.table_view)
         self.stack.addWidget(self.table_view)
 
         self.text_view = QPlainTextEdit()
@@ -130,15 +140,29 @@ def __init__(
         layout.addWidget(self.stack)
 
         self._on_checked_changed(self.checkbox.isChecked())
+        self._update_summary()
         self._constructed = True
 
     def set_embedded_in_workbench(self, embedded: bool) -> None:
         embedded = bool(embedded)
         self.setProperty("datalab_constants_embedded", embedded)
         layout = self.layout()
         if layout is not None:
-            margin = 0 if embedded else 8
-            layout.setContentsMargins(margin, margin, margin, margin)
+            # Embedded card now has its own border (like the data card) → pad content off it with
+            # the shared CARD_PADDING; standalone keeps its tighter 8px inset.
+            if embedded:
+                layout.setContentsMargins(*CARD_PADDING)
+            else:
+                layout.setContentsMargins(8, 8, 8, 8)
+        self.setStyleSheet(constants_editor_style(embedded=embedded))
+        self.style().unpolish(self)
+        self.style().polish(self)
+
+    def refresh_theme_style(self) -> None:
+        """Re-apply the (theme-dependent) editor style for the current embedded state. Its style is
+        otherwise set once at construction/embedding, so a live light↔dark toggle would leave the
+        button colors stale — the theme refresh calls this."""
+        embedded = bool(self.property("datalab_constants_embedded"))
         self.setStyleSheet(constants_editor_style(embedded=embedded))
         self.style().unpolish(self)
         self.style().polish(self)
@@ -273,7 +297,19 @@ def _apply_inputs_visibility(self) -> None:
         self.controls_widget.setEnabled(visible)
         self.stack.setEnabled(visible)
 
+    def _update_summary(self) -> None:
+        """Show the number of filled constant rows (mirrors the data card's "N 行")."""
+        label = getattr(self, "summary_label", None)
+        if label is None:
+            return
+        try:
+            count = len([r for r in self.rows() if (r.get("name") or r.get("value"))])
+        except Exception:
+            count = 0
+        label.setText(f"{count} 行")
+
     def _emit_changed(self, *_args: object) -> None:
+        self._update_summary()
         if not self._syncing:
             self.changed.emit()
 

app_desktop/current_page_stack.py

@@ -1,20 +1,45 @@
 from __future__ import annotations
 
 from PySide6.QtCore import QSize
-from PySide6.QtWidgets import QStackedWidget
+from PySide6.QtWidgets import QStackedWidget, QWidget
 
 
 class CurrentPageStack(QStackedWidget):
-    """QStackedWidget whose layout hints come only from the current page."""
+    """QStackedWidget whose height tracks the CURRENT page only.
+
+    A plain QStackedWidget sizes to its tallest page, so a short mode config would sit in a hollow
+    gap; capping it at Maximum policy instead clipped a mode whose config grows after layout
+    (fitting→comparison). This subclass pins its own fixed height to the active page's sizeHint,
+    re-syncing on page change and when the active page's layout invalidates — so it is always
+    exactly as tall as the current page needs (no gap, no clip).
+    """
+
+    def __init__(self, parent: QWidget | None = None) -> None:
+        super().__init__(parent)
+        self.currentChanged.connect(lambda _index: self._sync_height_to_current())
 
     def sizeHint(self) -> QSize:
         page = self.currentWidget()
-        if page is None:
-            return super().sizeHint()
-        return page.sizeHint()
+        return page.sizeHint() if page is not None else super().sizeHint()
 
     def minimumSizeHint(self) -> QSize:
+        page = self.currentWidget()
+        return page.minimumSizeHint() if page is not None else super().minimumSizeHint()
+
+    def _sync_height_to_current(self) -> None:
         page = self.currentWidget()
         if page is None:
-            return super().minimumSizeHint()
-        return page.minimumSizeHint()
+            return
+        # Fix the stack to the current page's preferred height so the layout neither inflates a
+        # short page (gap) nor caps a taller/grown page (clip).
+        self.setFixedHeight(max(page.sizeHint().height(), page.minimumSizeHint().height()))
+
+    def event(self, evt) -> bool:  # type: ignore[no-untyped-def]
+        # LayoutRequest fires when the current page's contents change size (e.g. a mode reveals
+        # extra fields). Re-sync so a dynamically growing page is not clipped.
+        result = super().event(evt)
+        from PySide6.QtCore import QEvent
+
+        if evt.type() == QEvent.Type.LayoutRequest:
+            self._sync_height_to_current()
+        return result

app_desktop/fitting_latex_writer.py

@@ -38,8 +38,13 @@ def latex_escape(text: str) -> str:
     return "".join(mapping.get(ch, ch) for ch in str(text))
 
 
-def build_fit_latex_preamble(*, use_dcolumn: bool, digits: int, latex_group_size: int) -> list[str]:
-    group_size = max(1, int(latex_group_size))
+def build_fit_latex_preamble(
+    *, use_dcolumn: bool, digits: int, latex_group_size: int, native_group_width: bool = True
+) -> list[str]:
+    # max(0, ...) not max(1, ...): group_size 0 must stay 0 so build_sisetup_block emits the
+    # "no grouping" body (group-digits = false). max(1,..) forced 0→1 → grouping stayed ON,
+    # contradicting the UI's "0 = 不分组" (dual-model review F1).
+    group_size = max(0, int(latex_group_size))
     lines = [
         "\\documentclass{article}",
         "\\usepackage{ifxetex}",
@@ -65,12 +70,14 @@ def build_fit_latex_preamble(*, use_dcolumn: bool, digits: int, latex_group_size
             ]
         )
     lines.append("\\usepackage{siunitx}")
-    # Centralized v2/v3-compatible \sisetup{...} block — see helper for
-    # the ``\@ifpackagelater`` guard around v3-only ``digit-group-size``.
+    # native_group_width True → emit siunitx digit-group-size (native S-column variable-width
+    # grouping); False (bundled Tectonic) → don't (cells are pre-grouped app-side).
+    emit_dgs = bool(native_group_width and not use_dcolumn and group_size > 0)
     lines.append(
         build_sisetup_block(
             group_size=group_size,
             include_dcolumn=use_dcolumn,
+            emit_digit_group_size=emit_dgs,
         ).rstrip("\n")
     )
     lines.extend(
@@ -105,10 +112,25 @@ def build_fit_latex_block(
     default_uncertainty_digits: int | None = None,
     cleaned_substituted: str | None = None,
     units: Mapping[str, Any] | None = None,
+    native_group_width: bool = True,
 ) -> list[str]:
+    from datalab_latex.latex_formatting import group_digits_both_sides
+
     default_unc_digits = default_uncertainty_digits
     variable_pairs = variable_pairs or []
     target_column = (target_column or "").strip()
+    # App-side grouping when the engine can't vary the siunitx group WIDTH (non-native) and
+    # grouping is on in siunitx (non-dcolumn) mode: pre-group each value cell + use a plain r
+    # column instead of an S column siunitx would re-group at a fixed 3.
+    _group = max(0, int(latex_group_size))
+    app_group = (not native_group_width) and (not use_dcolumn) and _group > 0
+
+    def _maybe_group(cell: str) -> str:
+        if app_group and "\\multicolumn" not in cell and "\\text" not in cell:
+            # The grouped value goes into a plain r column, so return the grouped string directly —
+            # wrapping it in \text{...} (with its \, thin-spaces) broke TeX compilation (CodeRabbit).
+            return group_digits_both_sides(cell, _group)
+        return cell
 
     def _format_cell_value(val: mp.mpf, sigma_obj, *, is_input: bool) -> str:
         sigma_digits = None if is_input else default_unc_digits
@@ -125,14 +147,16 @@ def _format_cell_value(val: mp.mpf, sigma_obj, *, is_input: bool) -> str:
                 sigma = mp.mpf(sigma)
             except Exception:
                 sigma = None
-        return format_value_for_latex_file(
-            mp.mpf(val),
-            sigma,
-            use_dcolumn=use_dcolumn,
-            latex_input_decimals=digits,
-            is_input=is_input,
-            latex_group_size=latex_group_size,
-            uncertainty_digits=sigma_digits,
+        return _maybe_group(
+            format_value_for_latex_file(
+                mp.mpf(val),
+                sigma,
+                use_dcolumn=use_dcolumn,
+                latex_input_decimals=digits,
+                is_input=is_input,
+                latex_group_size=latex_group_size,
+                uncertainty_digits=sigma_digits,
+            )
         )
 
     def _format_key(key: str) -> str:
@@ -221,26 +245,26 @@ def _target_unit() -> str:
         ("RMSE", fit_result.rmse),
     ]
     for label, value in metrics:
-        val_text = format_value_for_latex_file(
+        val_text = _maybe_group(format_value_for_latex_file(
             mp.mpf(value),
             None,
             use_dcolumn=use_dcolumn,
             latex_input_decimals=digits,
             is_input=True,
             latex_group_size=latex_group_size,
-        )
+        ))
         row_unit = output_unit if label == "RMSE" else ""
         table_rows.append((label, val_text, row_unit))
 
     def _format_diagnostic_value(value: object) -> str:
-        return format_value_for_latex_file(
+        return _maybe_group(format_value_for_latex_file(
             mp.mpf(value),
             None,
             use_dcolumn=use_dcolumn,
             latex_input_decimals=digits,
             is_input=True,
             latex_group_size=latex_group_size,
-        )
+        ))
 
     diagnostic_entries, diagnostic_warnings = build_fitting_diagnostic_latex_entries(
         fit_result,
@@ -296,6 +320,9 @@ def _format_diagnostic_value(value: object) -> str:
     value_cells = [val for _, val, _unit in table_rows]
     if use_dcolumn:
         numeric_spec = calculate_dcolumn_format_for_column(value_cells, "fit_values")
+    elif app_group:
+        # Cells are pre-grouped + wrapped in \text{}; a plain right-aligned column.
+        numeric_spec = "r"
     else:
         numeric_spec = siunitx_column_spec(value_cells)
     include_unit_column = any(unit for _key, _val, unit in table_rows)

app_desktop/formula_preview.py

@@ -35,6 +35,13 @@
 _IDENTIFIER_RE: Final = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")
 _INLINE_PREVIEW_MAX_WIDTH: Final = 520
 _INLINE_PREVIEW_MAX_HEIGHT: Final = 104
+# The label reserves 12px padding + a 1px border on each side (formula_inline_preview_style). The
+# rendered pixmap must fit INSIDE that inset, otherwise a tall formula fills the label edge-to-edge
+# and paints over the bottom padding/rounded border (the "border not closed" bug). Cap the pixmap a
+# little smaller than the label content box so the rounded border always stays visible.
+_INLINE_PREVIEW_INSET: Final = 2 * (12 + 1)
+_INLINE_PREVIEW_PIXMAP_MAX_HEIGHT: Final = _INLINE_PREVIEW_MAX_HEIGHT - _INLINE_PREVIEW_INSET
+_INLINE_PREVIEW_PIXMAP_MAX_WIDTH: Final = _INLINE_PREVIEW_MAX_WIDTH - _INLINE_PREVIEW_INSET
 
 
 class FormulaPreviewLabel(QLabel):
@@ -192,6 +199,9 @@ def configure_formula_preview_label(label: QLabel, *, constrain_size: bool = Fal
     label.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Minimum)
     label.setCursor(Qt.CursorShape.PointingHandCursor)
     label.setToolTip("Click to enlarge formula")
+    # WA_StyledBackground makes Qt honour the stylesheet's border-radius on a QLabel — without
+    # it the rounded background/border isn't clipped to the corners, so they look squared-off.
+    label.setAttribute(Qt.WidgetAttribute.WA_StyledBackground, True)
     label.setStyleSheet(formula_inline_preview_style())
 
 
@@ -264,14 +274,16 @@ def update_formula_preview_with_empty_text(
     )
     pixmap = QPixmap()
     if result.ok and result.png_bytes and _load_png_pixmap(pixmap, result.png_bytes):
-        if pixmap.width() > _INLINE_PREVIEW_MAX_WIDTH:
+        # Scale to fit INSIDE the label's padded content box (leaving the border visible), not to the
+        # label's outer max size — see _INLINE_PREVIEW_PIXMAP_MAX_* above.
+        if pixmap.width() > _INLINE_PREVIEW_PIXMAP_MAX_WIDTH:
             pixmap = pixmap.scaledToWidth(
-                _INLINE_PREVIEW_MAX_WIDTH,
+                _INLINE_PREVIEW_PIXMAP_MAX_WIDTH,
                 Qt.TransformationMode.SmoothTransformation,
             )
-        if pixmap.height() > _INLINE_PREVIEW_MAX_HEIGHT:
+        if pixmap.height() > _INLINE_PREVIEW_PIXMAP_MAX_HEIGHT:
             pixmap = pixmap.scaledToHeight(
-                _INLINE_PREVIEW_MAX_HEIGHT,
+                _INLINE_PREVIEW_PIXMAP_MAX_HEIGHT,
                 Qt.TransformationMode.SmoothTransformation,
             )
         label.setPixmap(pixmap)