pgwidgets-js 0.4.0__tar.gz → 0.4.2__tar.gz

{pgwidgets_js-0.4.0 → pgwidgets_js-0.4.2}/.github/workflows/tests.yml

@@ -11,13 +11,13 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.12", "3.13"]
+        python-version: ["3.12", "3.13", "3.14"]
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
 
       - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version: ${{ matrix.python-version }}
 

{pgwidgets_js-0.4.0 → pgwidgets_js-0.4.2}/PKG-INFO

@@ -1,19 +1,19 @@
 Metadata-Version: 2.4
 Name: pgwidgets-js
-Version: 0.4.0
+Version: 0.4.2
 Summary: pgwidgets JavaScript widget library — static assets for use with Python servers
 Author: PGWidgets Developers
-License: BSD-3-Clause
+License-Expression: BSD-3-Clause
 Project-URL: Homepage, https://github.com/naojsoft/pgwidgets-js
 Project-URL: Repository, https://github.com/naojsoft/pgwidgets-js
 Keywords: widgets,ui,gui,javascript,websocket
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: BSD License
 Classifier: Programming Language :: JavaScript
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: User Interfaces
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown

{pgwidgets_js-0.4.0 → pgwidgets_js-0.4.2}/docs/WhatsNew.rst

@@ -1,6 +1,93 @@
 What's New
 ==========
 
+Recent changes — since ``v0.4.0``
+---------------------------------
+
+TreeView: a header drag resizes one column, qt-style
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Dragging a header divider now resizes the column to its left and
+nothing else.  The columns after it keep their widths and slide along,
+and the table grows past the viewport into the horizontal scrollbar --
+what a qt ``QHeaderView`` does in its default Interactive mode.  A drag
+first pins every column to the width it is rendering at, so a column
+still on ``"1fr"`` stops re-dividing the leftover space and drifting
+while an unrelated boundary is dragged.
+
+Previously a drag behaved like a splitter: every pixel the column
+gained came out of the next one, so widening a column ate its
+neighbour down to the 5 px floor before anything to the right would
+move.  For the same reason the last column had no divider -- it has no
+neighbour to take width from.  It has one now.
+
+TreeView: ``select_path()`` and friends default ``state`` to true
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+``select_path(path, state = true)``, ``select_paths()`` and
+``select_all()`` now default ``state``, matching ``select_cell()`` /
+``select_cells()`` and the Python API, where a caller writes
+``select_path(path)`` to select a row.
+
+A bridge that forwards only the arguments it was given -- as the Python
+proxy does, being generated from the ``defs.py`` parameter lists --
+passed ``undefined`` otherwise, and the call quietly did nothing.
+``select_all()`` was worse than a no-op: it took the ``else`` branch
+and cleared the selection instead of filling it.
+
+TreeView / TableView: selecting from code no longer fires ``selected``
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+``clear_selection()``, ``set_selected()``, ``select_path()``,
+``select_paths()`` and ``select_all()`` now change the selection
+silently: selecting from code is not the user selecting something.  The
+caller already knows what it did, and two views that clear each other's
+selection would otherwise ping-pong.  Only pointer and keyboard
+interaction reports a selection.
+
+This is a behaviour change -- ``clear_selection()`` previously
+documented that it fires ``selected`` with an empty list -- and it
+brings these widgets in line with what the desktop toolkits already
+did.  A caller that leaned on the callback to update itself should now
+call its handler directly after selecting.  ``TableView`` inherits all
+of these from ``TreeView``; it also declares ``clear_selection`` in
+``defs.py`` now, which only ``TreeView`` had.
+
+``cell_action`` names the clicked row by path as well as by value
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+A button cell fired ``cell_action(row_values, col_key)``, which is what
+a table wants but not what a tree does -- a tree names a row by its
+path.  The callback now sends both, as
+``cell_action(path, row_values, col_key)``, and the consumer keeps
+whichever suits the widget it is presenting.  Existing handlers take one
+more leading argument.
+
+TreeView / TableView: ``get_column_widths()``
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Returns the width of every column, left to right.  The widths are
+measured from the rendered header cells, so an auto-sized (``1fr``)
+column reports a real number rather than nothing; when the view is not
+on screen yet it falls back to the widths that were set.
+
+Text widgets: scroll alignment, and a styleable ``TextSource`` caret
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+``TextArea`` gains ``scroll_to_lineno(lineno, align)`` and
+``scroll_to_end()``.  A ``<textarea>`` has no per-line elements, so the
+line's position is computed from the line height -- approximate when
+wrapping is on.
+
+``TextSource.scroll_to_ref()`` takes the same ``align`` -- ``'nearest'``
+(the default, as before), ``'center'`` or ``'top'`` -- mapped onto
+``scrollIntoView``'s ``block`` value, so a search that scrolls to its
+match can put the match in the middle of the view instead of merely
+bringing it into sight.  ``set_cursor_style(style, color)`` styles the
+caret through CSS ``caret-color`` / ``caret-shape``: it is the browser's
+own caret, so it is drawn only while the editor has the focus, and the
+``'block'`` shape needs a browser that supports ``caret-shape``.
+
 Recent changes — since ``v0.3.6``
 ---------------------------------
 

{pgwidgets_js-0.4.0 → pgwidgets_js-0.4.2}/docs/widgets/display.rst

@@ -385,14 +385,16 @@ supplies no value for it, so most interiors need no
      - Expand or collapse a single node by key path.
    * - ``get_selected()`` / ``set_selected(paths)``
      - Get or set selection.  ``set_selected`` accepts a single
-       path or an array of paths.
+       path or an array of paths.  Setting is silent -- see
+       "Selecting from code" below.
    * - ``clear_selection()``
-     - Drop all selection.  Fires the ``selected`` callback with
-       an empty list.
-   * - ``select_path(path, state)`` / ``select_paths(paths, state)``
-     - Select or deselect by key path(s).
-   * - ``select_all(state)``
-     - Select or deselect all nodes.
+     - Drop all selection.  Silent, like the other selection
+       setters.
+   * - ``select_path(path, state=true)`` / ``select_paths(paths, state=true)``
+     - Select or deselect by key path(s).  ``state`` defaults to
+       true, so ``select_path(path)`` selects.
+   * - ``select_all(state=true)``
+     - Select or deselect all nodes.  ``state`` defaults to true.
    * - ``get_subtree(status='all')``
      - Return a dict-tree containing a subset.  ``status`` is
        ``"all"``, ``"selected"``, ``"expanded"``, or ``"collapsed"``.
@@ -415,8 +417,13 @@ supplies no value for it, so most interiors need no
      - Column manipulation.  ``before`` is a column key.
    * - ``set_column_width(col_key, width)``
      - Set column width.
+   * - ``get_column_widths()``
+     - The width of every column, left to right, in pixels.
+       Measured from the rendered header cells, so an auto-sized
+       (``"1fr"``) column reports a real number; falls back to the
+       widths that were set when the view is not on screen yet.
    * - ``set_optimal_column_widths()``
-     - Auto-size all columns.
+     - Auto-size all columns to their header and cell content.
    * - ``set_row_spacing(px)`` / ``set_column_spacing(px)``
      - Set the vertical (row) / horizontal (column) cell padding in
        pixels.  ``set_row_spacing(0)`` also relaxes the row min-height
@@ -467,15 +474,20 @@ across the row.
   col_key)``; fires on row double-click or Enter.  ``col_key``
   is the column the click landed on (``null`` for
   keyboard-triggered activation).
-- ``selected`` -- selection changed; handler receives an array of
-  ``{path, values}`` objects.
+- ``selected`` -- the user changed the selection; handler
+  receives an array of ``{path, values}`` objects.  Selecting
+  from code does not fire it -- see "Selecting from code" below.
 - ``expanded`` / ``collapsed`` -- handler ``(widget, values, path)``.
 - ``cell_edited`` -- ``(widget, path, col_key, oldValue, newValue)``.
-- ``cell_selected`` -- cell-mode selection changed; handler
-  receives ``(widget, cells)`` where each cell is
-  ``{path, col_key, value}``.
-- ``cell_action`` -- ``(widget, row_values, col_key)``; fires
-  when the user clicks a ``widget: "button"`` cell.
+- ``cell_selected`` -- the user changed the cell-mode selection;
+  handler receives ``(widget, cells)`` where each cell is
+  ``{path, col_key, value}``.  Like ``selected``, it does not
+  fire for selection made from code.
+- ``cell_action`` -- ``(widget, path, row_values, col_key)``;
+  fires when the user clicks a ``widget: "button"`` cell.  Both
+  names for the row are sent: a table normally wants
+  ``row_values``, a tree its ``path``.  (Before v0.4.1 the
+  ``path`` argument was not there.)
 - ``copy`` / ``cut`` / ``paste`` -- ``(widget, tsv)``; fire from
   Ctrl/Cmd+C/X/V and from the programmatic helpers.
 - ``sorted`` -- ``(widget, col_key, ascending)``.
@@ -499,6 +511,30 @@ gate the per-row widget.  An empty row value of ``null`` /
 ``false`` on a button column suppresses that row's button if
 ``visible_key`` is also unset.
 
+**Resizing columns.** Every header cell carries a divider on its right
+edge, the last column included.  Dragging one resizes *that* column and
+leaves the rest alone: the columns after it keep their widths and slide
+along, and the table grows past the viewport into the horizontal
+scrollbar.  This is what a qt ``QHeaderView`` does in its default
+Interactive mode.  A drag pins every column to the width it is
+rendering at, so a column still on ``"1fr"`` stops re-dividing the
+leftover space and drifting.  (Before v0.4.2 a drag behaved like a
+splitter, taking the width it gained out of the next column, and the
+last column had no divider at all because it has no neighbour to take
+from.)
+
+**Selecting from code.** ``set_selected``, ``select_path``,
+``select_paths``, ``select_all``, ``clear_selection`` and their
+cell-mode counterparts ``select_cell`` / ``select_cells`` /
+``clear_cell_selection`` all change the selection *silently*:
+``selected`` and ``cell_selected`` report pointer and keyboard
+interaction only.  The caller already knows what it selected, and
+two views that clear each other's selection would otherwise
+ping-pong.  Call your own handler after selecting if it needs to
+run.  (Before v0.4.1, ``clear_selection`` fired ``selected`` with
+an empty list, and the desktop toolkits ginga wraps disagreed
+among themselves on the rest.)
+
 **Colour overrides.** Each of the four ``set_*_color`` methods
 takes ``fg`` (text), ``bg`` (background), and ``bold``.  All
 three are optional; passing all-null clears that layer's
@@ -572,11 +608,14 @@ dicts (preferred) or a list of positional arrays:
    table.append_row({NAME: "Carol", DEPT: "Sales", SALARY: 71000});
    table.sort_by_column("SALARY", false);  // descending
 
-**Callbacks:** identical to TreeView, including the new
+**Callbacks:** identical to TreeView, including the
 ``activated`` 4-arg signature with ``col_key``, the
 ``cell_selected`` / ``cell_action`` / ``copy`` / ``cut`` /
 ``paste`` callbacks, and the per-cell ``cell_edited``
-signature.
+signature.  ``cell_action`` carries the clicked row's ``path``
+ahead of its values here too, even though a flat table normally
+reads the values; the path is a single-element array of the
+row's key.  Selecting from code is silent, as on a TreeView.
 
 TableView ``set_columns`` accepts the same column descriptor
 fields as TreeView, including ``widget`` / ``choices`` /

{pgwidgets_js-0.4.0 → pgwidgets_js-0.4.2}/docs/widgets/text.rst

@@ -164,6 +164,15 @@ Multi-line text editor.
      - Set word-wrap mode.
    * - ``set_limit(numlines)``
      - Limit visible lines (scrollback).
+   * - ``scroll_to_lineno(lineno, align="nearest")``
+     - Scroll so line *lineno* (0-based, clamped to the text) is in
+       view.  ``align`` is ``"nearest"`` (scroll the least amount
+       that brings the line into view), ``"center"`` or ``"top"``.
+       A ``<textarea>`` has no per-line elements, so the line's
+       position is computed from the line height -- approximate when
+       ``wrap`` is on.
+   * - ``scroll_to_end()``
+     - Scroll to the last line.
 
 **Callbacks:** None.
 
@@ -325,10 +334,23 @@ position-returning method on the public API uses refs.
      - Find all non-overlapping matches; returns an array of ref pairs.
    * - ``replace(query, replacement, {all, start_ref, case_insensitive})``
      - Find and replace; returns the number of replacements.
-   * - ``scroll_to_ref(ref)``
+   * - ``scroll_to_ref(ref, align="nearest")``
      - Scroll the view so the line containing *ref* is visible.
+       ``align`` is ``"nearest"`` (the default), ``"center"`` or
+       ``"top"``, mapped onto ``scrollIntoView``'s ``block`` value,
+       so a search can put its match in the middle of the view
+       rather than merely bringing it into sight.
+       To scroll to a line number, mint a ref for it first with
+       ``get_ref_line_start(lineno)``.
    * - ``scroll_to_cursor()``
      - Scroll to cursor position.
+   * - ``set_cursor_style(style="line", color=null)``
+     - Style the caret: ``style`` is ``"line"`` or ``"block"``,
+       ``color`` any CSS colour (``null`` restores the browser's).
+       This styles the browser's own caret through ``caret-color``
+       / ``caret-shape``, so it is drawn only while the editor has
+       the focus, and ``"block"`` needs a browser that supports
+       ``caret-shape``.
 
 **Callbacks:**
 

{pgwidgets_js-0.4.0 → pgwidgets_js-0.4.2}/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pgwidgets",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "A native JavaScript widget library with Qt/GTK-style layout and controls",
   "type": "module",
   "main": "Widgets.js",

{pgwidgets_js-0.4.0 → pgwidgets_js-0.4.2}/pgwidgets_js/defs.py

@@ -537,6 +537,8 @@ WIDGETS = {
             "set_limit": ["numlines"],
             "set_scroll_position": ["h_pct", "v_pct"],
             "get_scroll_position": [],
+            "scroll_to_lineno": ["lineno", "align"],
+            "scroll_to_end": [],
         },
         "callbacks": ["scrolled"],
     },
@@ -566,6 +568,7 @@ WIDGETS = {
             "set_icon": ["ref", "icon_url"],
             "get_cursor": [],
             "set_cursor": ["ref"],
+            "set_cursor_style": ["style", "color"],
             "get_selection_range": [],
             "has_selection": [],
             "get_selection_bounds": [],
@@ -608,7 +611,7 @@ WIDGETS = {
             "find_all": ["query", "opts"],
             "replace": ["query", "replacement", "opts"],
             # Scrolling
-            "scroll_to_ref": ["ref"],
+            "scroll_to_ref": ["ref", "align"],
             "scroll_to_cursor": [],
             "set_scroll_position": ["h_pct", "v_pct"],
             "get_scroll_position": [],
@@ -795,6 +798,7 @@ WIDGETS = {
             "select_paths": ["paths", "state"],
             "select_all": ["state"],
             "set_column_width": ["col_key", "width"],
+            "get_column_widths": [],
             "set_optimal_column_widths": [],
             "sort_by_column": ["col_key", "ascending"],
             "scroll_to_path": ["path"],
@@ -854,10 +858,12 @@ WIDGETS = {
             "clear": [],
             "get_selected": [],
             "set_selected": ["items"],
+            "clear_selection": [],
             "select_path": ["path", "state"],
             "select_paths": ["paths", "state"],
             "select_all": ["state"],
             "set_column_width": ["col_index", "width"],
+            "get_column_widths": [],
             "set_optimal_column_widths": [],
             "set_row_spacing": ["px"],
             "set_column_spacing": ["px"],

{pgwidgets_js-0.4.0 → pgwidgets_js-0.4.2}/pgwidgets_js/static/modules/TextArea.js

@@ -182,6 +182,57 @@ class TextArea extends Widget {
         this._scrollSilent = false;
     }
 
+    /**
+     * Scrolls so that line *lineno* (0-based) is visible.
+     *
+     * NOTE: a <textarea> has no per-line elements to measure, so the
+     * line's position is derived from the computed line height.  With
+     * wrapping on, a long logical line occupies more than one visual
+     * line and the result is approximate.
+     *
+     * @param {number} lineno - Line to scroll to (0-based).
+     * @param {string} [align='nearest'] - Where the line should end up:
+     *   'nearest' scrolls the least amount that brings it into view,
+     *   'center' puts it in the middle and 'top' at the top.
+     */
+    scroll_to_lineno(lineno, align = 'nearest') {
+        let ta = this._textarea;
+        let style = window.getComputedStyle(ta);
+        let lineHeight = parseFloat(style.lineHeight);
+        if (! isFinite(lineHeight)) {
+            // 'normal' -- approximate it from the font size
+            lineHeight = parseFloat(style.fontSize) * 1.2;
+        }
+        let padTop = parseFloat(style.paddingTop) || 0;
+        let top = padTop + Math.max(0, lineno) * lineHeight;
+        let view = ta.clientHeight;
+        let pos = ta.scrollTop;
+        let target;
+        if (align === 'center') {
+            target = top - (view - lineHeight) / 2;
+        } else if (align === 'top') {
+            target = top;
+        } else {
+            if (top < pos) target = top;
+            else if (top + lineHeight > pos + view) target = top + lineHeight - view;
+            else target = pos;
+        }
+        let maxY = ta.scrollHeight - view;
+        ta.scrollTop = Math.max(0, Math.min(target, maxY));
+        this._scrollSilent = true;
+        this._syncFromScroll();
+        this._scrollSilent = false;
+    }
+
+    /** Scrolls to the end of the buffer. */
+    scroll_to_end() {
+        let ta = this._textarea;
+        ta.scrollTop = Math.max(0, ta.scrollHeight - ta.clientHeight);
+        this._scrollSilent = true;
+        this._syncFromScroll();
+        this._scrollSilent = false;
+    }
+
     /**
      * Returns the current scroll position as [h_pct, v_pct] (0–1).
      * @returns {number[]}

{pgwidgets_js-0.4.0 → pgwidgets_js-0.4.2}/pgwidgets_js/static/modules/TextSource.js

@@ -1996,9 +1996,10 @@ class TextSource extends Widget {
     /**
      * Scroll the view so that the line containing *ref* is visible.
      * @param {TextBufferRef} ref
+     * @param {string} [align='nearest'] - 'nearest', 'center' or 'top'.
      */
-    scroll_to_ref(ref) {
-        this._scrollToOffset(this._offsetOf(ref));
+    scroll_to_ref(ref, align = 'nearest') {
+        this._scrollToOffset(this._offsetOf(ref), align);
     }
 
     /**
@@ -2007,16 +2008,39 @@ class TextSource extends Widget {
      * ref over the wire (the Python side owns the ref and passes its offset).
      * @private
      * @param {number} offset
+     * @param {string} [align='nearest'] - 'nearest' scrolls the least
+     *   amount that brings the line into view, 'center' puts it in the
+     *   middle of the view and 'top' at the top.
      */
-    _scrollToOffset(offset) {
+    _scrollToOffset(offset, align = 'nearest') {
         let line = this._lineOfOffset(this._clampOffset(offset));
         let lineDiv = this._edit.children[line];
         if (lineDiv && lineDiv.scrollIntoView) {
-            lineDiv.scrollIntoView({ block: 'nearest' });
+            let block = { center: 'center', top: 'start' }[align] || 'nearest';
+            lineDiv.scrollIntoView({ block: block });
             this._syncFromScroll();
         }
     }
 
+    /**
+     * Set the appearance of the text caret.
+     *
+     * NOTE: this styles the browser's own caret, which means it is only
+     * drawn while the editor has the keyboard focus, and that the block
+     * shape needs a browser supporting the CSS 'caret-shape' property
+     * (elsewhere the caret keeps its color but stays a thin bar).
+     *
+     * @param {string} [style='line'] - 'line' or 'block'.
+     * @param {?string} [color=null] - Any CSS color, or null for the
+     *   browser default.
+     */
+    set_cursor_style(style = 'line', color = null) {
+        this._cursorStyle = style;
+        this._cursorColor = color;
+        this._edit.style.caretColor = (color === null) ? '' : color;
+        this._edit.style.caretShape = (style === 'block') ? 'block' : '';
+    }
+
     /** Scroll so the cursor is visible. */
     scroll_to_cursor() {
         let line = this._lineOfOffset(this._cursor);

{pgwidgets_js-0.4.0 → pgwidgets_js-0.4.2}/pgwidgets_js/static/modules/TreeView.js

@@ -676,12 +676,16 @@ class TreeView extends Widget {
                 this._onHeaderClick(this._columns[i].key);
             });
 
-            if (i < this._columns.length - 1) {
-                let handle = document.createElement('div');
-                handle.className = 'treeview-resize-handle';
-                cell.appendChild(handle);
-                this._setupColumnResize(handle, i);
-            }
+            // Every column gets a divider, the last one included -- qt
+            // lets you drag the final section's right edge too.  (The
+            // last one used to be skipped because resizing worked like a
+            // splitter, and the last column has no neighbour to take the
+            // width from; now that a drag only resizes its own column,
+            // there is nothing special about it.)
+            let handle = document.createElement('div');
+            handle.className = 'treeview-resize-handle';
+            cell.appendChild(handle);
+            this._setupColumnResize(handle, i);
 
             this._header.appendChild(cell);
         }
@@ -714,8 +718,22 @@ class TreeView extends Widget {
         }
     }
 
+    /**
+     * Wire up one header divider.
+     *
+     * Dragging resizes only the column to the divider's left: the
+     * columns after it keep their widths and slide along, the table
+     * grows past the viewport and the horizontal scrollbar takes up the
+     * difference.  That is what a qt ``QHeaderView`` does in its default
+     * Interactive mode, and what makes a too-narrow column widenable
+     * without robbing its neighbour.
+     *
+     * (It used to behave like a splitter -- every pixel the dragged
+     * column gained came out of the next one, so widening a column ate
+     * the one beside it down to the 5 px floor before anything moved.)
+     */
     _setupColumnResize(handle, colIndex) {
-        let startX, startWidthA, startWidthB;
+        let startX, startWidth;
         const onMouseMove = (e) => {
             let dx = e.clientX - startX;
             // 5 px floor matches the width of ``.treeview-resize-handle``
@@ -726,11 +744,11 @@ class TreeView extends Widget {
             // *inflate* any column whose declared ``colwidth`` was
             // below 30 the moment a drag started, making columns
             // like a 10 px Mute / checkbox column un-resizable.
-            let newA = Math.max(5, startWidthA + dx);
-            let newB = Math.max(5, startWidthB - dx);
-            this._colWidths[colIndex] = newA + 'px';
-            this._colWidths[colIndex + 1] = newB + 'px';
+            this._colWidths[colIndex] = Math.max(5, startWidth + dx) + 'px';
             this._applyGridTemplate();
+            // the table's total width changes now (it did not when this
+            // stole from the neighbour), so the scrollbar has to follow
+            this._syncScrollbars();
         };
         const onMouseUp = () => {
             document.removeEventListener('mousemove', onMouseMove);
@@ -741,8 +759,18 @@ class TreeView extends Widget {
             e.stopPropagation();
             startX = e.clientX;
             let cells = this._header.querySelectorAll('.treeview-header-cell');
-            startWidthA = cells[colIndex].getBoundingClientRect().width;
-            startWidthB = cells[colIndex + 1].getBoundingClientRect().width;
+            // Pin every column to the width it is rendering at before
+            // the drag starts.  Any track still on an ``fr`` unit would
+            // otherwise re-divide the leftover space on each move, so
+            // columns the user never touched would drift as a side
+            // effect of dragging one boundary.
+            for (let i = 0; i < this._colWidths.length; i++) {
+                if (cells[i]) {
+                    this._colWidths[i] =
+                        cells[i].getBoundingClientRect().width + 'px';
+                }
+            }
+            startWidth = parseFloat(this._colWidths[colIndex]);
             document.addEventListener('mousemove', onMouseMove);
             document.addEventListener('mouseup', onMouseUp);
         });
@@ -1395,13 +1423,25 @@ class TreeView extends Widget {
     }
 
     /**
-     * Clear all selection.  Fires the 'selected' callback with an
-     * empty list.
+     * Clear all selection.
+     *
+     * NOTE: this and the other selection setters below do NOT fire the
+     * 'selected' callback -- selecting from code is not the user
+     * selecting something.  The caller already knows what it just did,
+     * and a pair of views that clear each other's selection would
+     * otherwise ping-pong.  Only pointer and keyboard interaction
+     * reports a selection.
+     *
+     * NOTE: the ``state`` argument of the select_* methods defaults to
+     * true, matching select_cell()/select_cells() and the Python side
+     * (whose callers write ``select_path(path)`` to select a row).  A
+     * bridge that forwards only the arguments it was given would
+     * otherwise pass ``undefined`` here, and the call would silently do
+     * nothing -- or, for select_all(), clear the selection instead.
      */
     clear_selection() {
         this._selection = [];
         this._updateSelectionDisplay();
-        this.make_callback('selected', this.get_selected());
     }
 
     set_selected(paths) {
@@ -1423,10 +1463,9 @@ class TreeView extends Widget {
             }
         }
         this._updateSelectionDisplay();
-        this.make_callback('selected', this.get_selected());
     }
 
-    select_path(path, state) {
+    select_path(path, state = true) {
         let node = this._nodeAtPath(path);
         if (!node) return;
         let idx = this._selection.indexOf(node);
@@ -1436,10 +1475,9 @@ class TreeView extends Widget {
             this._selection.splice(idx, 1);
         }
         this._updateSelectionDisplay();
-        this.make_callback('selected', this.get_selected());
     }
 
-    select_paths(paths, state) {
+    select_paths(paths, state = true) {
         for (let path of paths) {
             let node = this._nodeAtPath(path);
             if (!node) continue;
@@ -1451,10 +1489,9 @@ class TreeView extends Widget {
             }
         }
         this._updateSelectionDisplay();
-        this.make_callback('selected', this.get_selected());
     }
 
-    select_all(state) {
+    select_all(state = true) {
         if (state) {
             this._selection = [];
             this._walkNodes(this._root, (n) => this._selection.push(n));
@@ -1462,7 +1499,6 @@ class TreeView extends Widget {
             this._selection = [];
         }
         this._updateSelectionDisplay();
-        this.make_callback('selected', this.get_selected());
     }
 
     /**
@@ -1477,6 +1513,23 @@ class TreeView extends Widget {
         this._applyGridTemplate();
     }
 
+    /**
+     * The current width of every column, in pixels, left to right.
+     *
+     * Measured from the rendered header cells so that auto-sized
+     * columns ('1fr') report a real number too; falls back to the
+     * widths that were set when the view is not on screen yet, and to
+     * 0 for a column whose width was never set.
+     * @returns {number[]}
+     */
+    get_column_widths() {
+        return this._columns.map((col, i) => {
+            let cell = this._headerCells ? this._headerCells[i] : null;
+            if (cell && cell.offsetWidth) return cell.offsetWidth;
+            return parseFloat(this._colWidths[i]) || 0;
+        });
+    }
+
     set_optimal_column_widths() {
         if (!this.element.isConnected) {
             requestAnimationFrame(() => this.set_optimal_column_widths());
@@ -2870,8 +2923,10 @@ class TreeView extends Widget {
      *   Change fires ``cell_edited`` with the new option string.
      * - ``progress``: <progress max=col.max value=val>.  Read-only.
      * - ``button``:  <button>.  Click fires
-     *   ``cell_action(row_values, col_key)``.  The button label is
-     *   the per-row value when non-null, else ``col.text`` if set.
+     *   ``cell_action(path, row_values, col_key)`` -- both ways of
+     *   naming the row, since a tree wants the path and a table wants
+     *   the values.  The button label is the per-row value when
+     *   non-null, else ``col.text`` if set.
      */
     _buildCellWidget(node, colDef, val) {
         let colKey = colDef.key;
@@ -2936,8 +2991,8 @@ class TreeView extends Widget {
                               : (colDef.text || ''));
             el.addEventListener('click', (e) => {
                 e.stopPropagation();
-                this.make_callback('cell_action', node.values || {},
-                                   colKey);
+                this.make_callback('cell_action', path,
+                                   node.values || {}, colKey);
             });
             return el;
         }