New f// keys filter CTable rows and columns in the data panel

`f` takes the same string expressions as CTable.where() (dotted nested
names, and/or) and pages through the matching view; `/` narrows the
visible columns by case-insensitive substring, and column paging plus
the `c` goto-column modal operate on that subset.  Both filters combine
freely, are remembered per node for the session, and are shown in the
data header along with the unfiltered totals; escape clears one layer
per press (dim mode, then rows, then columns).

Author: FrancescAlted

doc/getting_started/b2view.rst

@@ -92,6 +92,12 @@ navigation (paging, ``g``, ``t`` / ``b``) then operates on the filtered
 rows.  Press ``escape`` (or submit an empty expression) to go back to the
 unfiltered table; each node remembers its filter for the session.
 
+Columns can be filtered too: press ``/`` and type a case-insensitive
+substring (e.g. ``payment``) to show only the matching columns — column
+paging and the ``c`` goto-column modal then operate on that subset.  Row
+and column filters combine freely; ``escape`` clears them one layer at a
+time (row filter first, then columns).
+
 CLI options
 -----------
 

src/blosc2/b2view/app.py

@@ -211,6 +211,7 @@ class HelpScreen(ModalScreen[None]):
                 ("left / right", "move cursor; pages at the edges"),
                 ("s / e  (home / end)", "first / last column window"),
                 ("c", "go to column index or name..."),
+                ("/", "filter visible columns by substring (CTable)"),
             ],
         ),
         (
@@ -374,7 +375,7 @@ def action_cancel(self) -> None:
 
 
 class FilterScreen(ModalScreen[str | None]):
-    """Small modal asking for a CTable row filter expression."""
+    """Small modal asking for a CTable filter (row expression or column pattern)."""
 
     CSS = """
     FilterScreen {
@@ -395,14 +396,22 @@ class FilterScreen(ModalScreen[str | None]):
 
     BINDINGS: ClassVar = [("escape", "cancel", "Cancel")]
 
-    def __init__(self, *, current: str | None = None):
+    def __init__(
+        self,
+        *,
+        current: str | None = None,
+        title: str = "Filter rows (empty clears)",
+        placeholder: str = "e.g. payment.tips > 100 and trip.km > 0",
+    ):
         super().__init__()
         self.current = current or ""
+        self.title_text = title
+        self.placeholder = placeholder
 
     def compose(self) -> ComposeResult:
         with Vertical(id="filter-dialog"):
-            yield Static("Filter rows (empty clears)", id="filter-title")
-            yield Input(placeholder="e.g. payment.tips > 100 and trip.km > 0", id="filter-input")
+            yield Static(self.title_text, id="filter-title")
+            yield Input(placeholder=self.placeholder, id="filter-input")
 
     def on_mount(self) -> None:
         input_widget = self.query_one("#filter-input", Input)
@@ -454,6 +463,7 @@ class B2ViewApp(App):
         Binding("e", "grid_col_end", "Row end", show=False),
         Binding("c", "go_to_column", "Go to column", show=False),
         Binding("f", "filter_rows", "Filter rows", show=False),
+        Binding("slash", "filter_columns", "Filter columns", show=False),
         Binding("d", "dim_cycle", "Dim mode", show=False),
         Binding("enter", "dim_toggle_nav", "Toggle nav", show=False),
         Binding("escape", "dim_exit", "Exit dim mode", show=False),
@@ -503,9 +513,7 @@ def compose(self) -> ComposeResult:
                             yield Static("", id="vlmetadata")
                 with B2ViewPanel(id="data-pane") as data_pane:
                     data_pane.border_title = "data"
-                    data_pane.border_subtitle = (
-                        "?(help) | d(im mode) | f(ilter) | rows: t/b/g(oto) | cols: s/e/c(goto)"
-                    )
+                    data_pane.border_subtitle = "?(help) | d(im mode) | filter: f(rows) /(cols) | rows: t/b/g(oto) | cols: s/e/c(goto)"
                     yield Static("", id="data-header")
                     with Horizontal(id="data-table-row"):
                         yield BufferedDataTable(id="data-table", show_row_labels=True, zebra_stripes=True)
@@ -1092,10 +1100,15 @@ def _update_data_header(self, data: dict) -> None:
                 header_parts.append(f"cols {data['col_start']}:{data['col_stop']} of {data['ncols']}")
             if data.get("source_kind") == "ctable" and self.browser is not None:
                 flt = self.browser.get_filter(self.selected_path)
+                col_flt = self.browser.get_column_filter(self.selected_path)
                 if flt:
                     total = self.browser.base_nrows(self.selected_path)
                     header_parts.append(f"filter: [bold]{markup_escape(flt)}[/bold] ({total} total)")
-                    header_parts.append("<f>edit <Esc>clear")
+                if col_flt:
+                    total_cols = self.browser.base_ncols(self.selected_path)
+                    header_parts.append(f"cols: [bold]{markup_escape(col_flt)}[/bold] ({total_cols} total)")
+                if flt or col_flt:
+                    header_parts.append("<Esc>clear")
 
         line = ", ".join(header_parts)
         if self._dim_mode and layout is not None:
@@ -1241,6 +1254,37 @@ def _apply_filter(self, expr: str | None) -> None:
         self._update_data_header(data)
         self.query_one("#data-table", DataTable).focus()
 
+    def action_filter_columns(self) -> None:
+        if not self._in_data_grid():
+            return
+        if self.table_page.get("source_kind") != "ctable":
+            self.notify("Column filtering is only supported for CTable nodes", severity="warning")
+            return
+        screen = FilterScreen(
+            current=self.browser.get_column_filter(self.selected_path),
+            title="Filter columns by substring (empty clears)",
+            placeholder="e.g. payment",
+        )
+        self.push_screen(screen, self._apply_column_filter)
+
+    def _apply_column_filter(self, pattern: str | None) -> None:
+        if pattern is None or self.browser is None or self.table_page is None:
+            return
+        if pattern == (self.browser.get_column_filter(self.selected_path) or ""):
+            return
+        try:
+            self.browser.set_column_filter(self.selected_path, pattern)
+        except Exception as exc:
+            self.notify(f"Invalid column filter: {exc}", severity="error")
+            return
+        self.grid_col_start = 0
+        self.table_buffer = None
+        data = self._load_table_page(self.selected_path, self.table_page["start"])
+        cursor_row = self.query_one("#data-table", DataTable).cursor_row
+        self._update_data_table(data, cursor_row=cursor_row, cursor_col=0)
+        self._update_data_header(data)
+        self.query_one("#data-table", DataTable).focus()
+
     def _go_to_column(self, col: int | None) -> None:
         if col is None or self.table_page is None:
             return
@@ -1481,19 +1525,26 @@ def action_dim_toggle_nav(self) -> None:
         self._dim_toggle()
 
     def action_dim_exit(self) -> None:
-        """Escape: exit dim mode, or clear an active CTable filter."""
+        """Escape: exit dim mode, or clear an active CTable filter.
+
+        One layer per press: dim mode, then the row filter, then the
+        column filter.
+        """
         if self._dim_mode:
             self._dim_mode = False
             if self.table_page is not None:
                 self._update_data_header(self.table_page)
             return
         if (
-            self._in_data_grid()
-            and self.table_page.get("source_kind") == "ctable"
-            and self.browser is not None
-            and self.browser.get_filter(self.selected_path)
+            not self._in_data_grid()
+            or self.table_page.get("source_kind") != "ctable"
+            or self.browser is None
         ):
+            return
+        if self.browser.get_filter(self.selected_path):
             self._apply_filter("")
+        elif self.browser.get_column_filter(self.selected_path):
+            self._apply_column_filter("")
 
     def action_grid_row_top(self) -> None:
         """Jump to the first row of the table."""

src/blosc2/b2view/model.py

@@ -139,6 +139,9 @@ def __init__(self, urlpath: str):
         # Per-path row filters for CTable nodes (path -> expr / where() view)
         self._filters: dict[str, str] = {}
         self._filter_views: dict[str, Any] = {}
+        # Per-path column filters (path -> substring pattern / matched names)
+        self._column_filters: dict[str, str] = {}
+        self._column_selections: dict[str, list[str]] = {}
 
     def close(self) -> None:
         close = getattr(self.store, "close", None)
@@ -264,6 +267,8 @@ def preview(
             return preview_array(obj, slices=slices, max_rows=max_rows, max_cols=max_cols)
         if kind == "ctable":
             obj = self._filter_views.get(path, obj)
+            if columns is None:
+                columns = self._column_selections.get(path)
             stop = min(start + max_rows, len(obj)) if stop is None else stop
             return preview_ctable(
                 obj, start=start, stop=stop, columns=columns, max_cols=max_cols, col_start=col_start
@@ -273,7 +278,15 @@ def preview(
         return {"message": f"Preview is not supported for {kind!r} objects."}
 
     def column_names(self, path: str) -> list[str] | None:
-        """Return the column names for a CTable path, or None for other kinds."""
+        """Return the column names for a CTable path, or None for other kinds.
+
+        When a column filter is active, only the matching names are returned
+        (navigation operates on the filtered universe).
+        """
+        path = self.normalize_path(path)
+        selection = self._column_selections.get(path)
+        if selection is not None:
+            return list(selection)
         names = list(getattr(self._get_object(path), "col_names", []) or [])
         return names or None
 
@@ -302,6 +315,37 @@ def base_nrows(self, path: str) -> int:
         """Return the unfiltered row count of the CTable at *path*."""
         return len(self._get_object(path))
 
+    def set_column_filter(self, path: str, pattern: str | None) -> int:
+        """Set or clear the column filter of a CTable path; return the match count.
+
+        Columns are matched by case-insensitive substring, keeping the table
+        order.  An empty (or None) *pattern* clears the filter.  A pattern
+        matching no column raises ValueError and leaves any previous filter
+        untouched.
+        """
+        path = self.normalize_path(path)
+        pattern = (pattern or "").strip()
+        all_names = list(getattr(self._get_object(path), "col_names", []) or [])
+        if not pattern:
+            self._column_filters.pop(path, None)
+            self._column_selections.pop(path, None)
+            return len(all_names)
+        needle = pattern.lower()
+        selection = [name for name in all_names if needle in name.lower()]
+        if not selection:
+            raise ValueError(f"no column matches {pattern!r}")
+        self._column_filters[path] = pattern
+        self._column_selections[path] = selection
+        return len(selection)
+
+    def get_column_filter(self, path: str) -> str | None:
+        """Return the active column filter pattern for *path*, if any."""
+        return self._column_filters.get(self.normalize_path(path))
+
+    def base_ncols(self, path: str) -> int:
+        """Return the unfiltered column count of the CTable at *path*."""
+        return len(list(getattr(self._get_object(path), "col_names", []) or []))
+
     def _get_object(self, path: str) -> Any:
         """Return the object represented by *path*."""
         path = self.normalize_path(path)

tests/b2view/test_basics.py

@@ -546,3 +546,53 @@ async def submit_filter(expr: str) -> None:
         await wait_for_table(pilot)
         assert app.browser.get_filter("/level0/ctable") is None
         assert app.table_page["nrows"] == NROWS
+
+        # ── Column filtering ('/' modal) ─────────────────────────────────
+
+        async def submit_column_filter(pattern: str) -> None:
+            await pilot.press("slash")
+            await pilot.pause()
+            assert isinstance(app.screen, FilterScreen)
+            app.screen.query_one("#filter-input", Input).value = pattern
+            await pilot.press("enter")
+            await wait_for_table(pilot)
+
+        # 'v1' matches v10..v19; paging universe shrinks to those 10 columns
+        await submit_column_filter("v1")
+        page = app.table_page
+        assert page["ncols"] == 10
+        assert page["columns"][0] == "v10"
+        assert all(name.startswith("v1") for name in page["columns"])
+
+        # The goto-column modal resolves names within the filtered set
+        await pilot.press("c")
+        await pilot.pause()
+        app.screen.query_one("#gotocol-input", Input).value = "v15"
+        await pilot.press("enter")
+        await wait_for_table(pilot)
+        assert app.table_page["columns"][0] == "v15"
+
+        # Row and column filters combine (back at the first column window)
+        await pilot.press("s")
+        await wait_for_table(pilot)
+        await submit_filter("b >= 100 and b < 110")
+        page = app.table_page
+        assert page["nrows"] == 10
+        assert page["ncols"] == 10
+        np.testing.assert_array_equal(page["data"]["v10"], expected["v10"][100:110])
+
+        # A pattern matching nothing notifies and keeps the selection
+        await submit_column_filter("nosuchcol")
+        assert app.browser.get_column_filter("/level0/ctable") == "v1"
+        assert app.table_page["ncols"] == 10
+
+        # Escape clears one layer at a time: row filter first, then columns
+        await pilot.press("escape")
+        await wait_for_table(pilot)
+        assert app.browser.get_filter("/level0/ctable") is None
+        assert app.table_page["nrows"] == NROWS
+        assert app.table_page["ncols"] == 10
+        await pilot.press("escape")
+        await wait_for_table(pilot)
+        assert app.browser.get_column_filter("/level0/ctable") is None
+        assert app.table_page["ncols"] == len(expected)

todo/b2view.md

@@ -11,10 +11,6 @@ Tests live in `tests/b2view/` (marker `tui`); see the note at the top of
 
 ### Navigation
 
-- [ ] Column-name search/filter for wide CTables (e.g. `/` to filter the
-      visible columns by substring).  Note: the `c` goto-column modal already
-      resolves unique name prefixes; this item is about *filtering* the
-      visible set, not jumping.
 - [ ] Row paging can lose page alignment after dim-mode single-row scrolls
       (`_scroll_navigable_viewport` shifts by 1); consider re-aligning on the
       next page up/down, as column paging does now.
@@ -73,3 +69,21 @@ Tests live in `tests/b2view/` (marker `tui`); see the note at the top of
   caught that the resize handler lived on the App, which never receives
   Resize events; moved to BufferedDataTable.on_resize, so the windows now
   re-fit on terminal resize and panel maximize/restore for real.
+- 2026-06-12: The terminal owns the mouse by default, so native text
+  selection/copy works; `--mouse` lets b2view capture it instead
+  (click-to-focus, wheel scrolls the data grid by half a page, paging at
+  the edges via the same path as the arrow keys).
+- 2026-06-12: Dim-mode index/viewport movements clamp at the boundaries
+  instead of wrapping (left/right dimension *selection* still cycles);
+  navigable viewports clamp to the last full page / whole-column window.
+- 2026-06-12: CTable row filtering — `f` opens a modal that takes the same
+  string expressions as `CTable.where()` (dotted nested names, and/or) and
+  pages through the matching view; escape or an empty expression clears,
+  filters are remembered per node (`StoreBrowser.set_filter`), and the data
+  header shows the active filter plus the unfiltered total.
+- 2026-06-12: CTable column filtering — `/` filters the visible columns by
+  case-insensitive substring (`StoreBrowser.set_column_filter`); column
+  paging, the two-pass width fit and the `c` goto-column modal all operate
+  on the filtered subset (`preview_ctable` already took a `columns`
+  universe).  Combines freely with the row filter; escape clears one layer
+  per press (dim mode, then rows, then columns).