wx-accessible-grid 0.1.0__tar.gz

wx_accessible_grid-0.1.0/.gitignore

@@ -0,0 +1,8 @@
+__pycache__/
+*.pyc
+*.egg-info/
+dist/
+build/
+.venv/
+.DS_Store
+.ruff_cache/

wx_accessible_grid-0.1.0/CONTRIBUTING.md

@@ -0,0 +1,42 @@
+# Contributing
+
+**Contributions are welcome — anyone can contribute, and we want them.** This is
+a Community Access open-source project, created by Taylor Arndt.
+
+## Ways to help
+- **Report bugs** — open an issue with what you expected, what happened, your OS,
+  wxPython version, whether you use a webview, and your screen reader.
+- **Test with screen readers** — NVDA, JAWS, Narrator (Windows), VoiceOver
+  (macOS), Orca (Linux). Real-world a11y reports are the most valuable thing here.
+  Tell us how arrow navigation, in-cell editing, and selection announced.
+- **Send pull requests** — features, fixes, docs, examples.
+
+## Ground rules
+- **Accessibility first.** The whole point is a data grid that is fully
+  keyboard-operable and reads correctly in NVDA and JAWS. The grid must speak the
+  column header as you move across a row, the row header as you move down a
+  column, and only the focused cell (never the whole table on every arrow).
+  Changes shouldn't regress that; note how you tested.
+- **Real ARIA grid, never a div soup.** We render a semantic `<table role="grid">`
+  so the screen reader gets header association and row/column counts for free. A
+  hand-drawn grid reads worse.
+- **The model owns the truth.** The grid never mutates data directly — it asks the
+  model and shows what the model says is now true, so an edit the user hears
+  confirmed is the validated, normalized value.
+- Keep it **dependency-light** — wxPython plus its sibling `wx-accessible-webview`.
+- Match the existing style; format with `ruff format` (line length 100).
+
+## Dev setup
+```bash
+pip install -e ".[dev]"
+python examples/demo.py        # try it with a screen reader running
+pytest                         # the model and renderer are tested without wx
+```
+
+## Pull requests
+- Describe the change and how you verified it (which screen reader / OS, native
+  or webview).
+- One focused change per PR is easiest to review.
+
+Thanks for helping make accessible data grids in wxPython the default, not the
+exception.

wx_accessible_grid-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Taylor Arndt and Community Access
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

wx_accessible_grid-0.1.0/PKG-INFO

@@ -0,0 +1,164 @@
+Metadata-Version: 2.4
+Name: wx-accessible-grid
+Version: 0.1.0
+Summary: An accessible, editable data grid for wxPython rendered as a real ARIA grid in a WebView (arrow-key cell navigation, in-cell editing, row selection, context menus) that reads correctly in NVDA and JAWS.
+Project-URL: Homepage, https://github.com/Community-Access/wx-accessible-grid
+Author: Community Access
+Author-email: Taylor Arndt <taylor@techopolisonline.com>
+Maintainer-email: Taylor Arndt <taylor@techopolisonline.com>
+License: MIT
+License-File: LICENSE
+Keywords: a11y,accessibility,aria,datagrid,grid,jaws,keyboard,nvda,screen-reader,table,webview,webview2,wxpython,wxwidgets
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Adaptive Technologies
+Classifier: Topic :: Software Development :: User Interfaces
+Requires-Python: >=3.10
+Requires-Dist: wx-accessible-webview>=0.2.0
+Requires-Dist: wxpython>=4.2.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# wx-accessible-grid
+
+An accessible, editable data grid for wxPython that a blind person can actually
+use. Native `wx.grid.Grid` reads poorly or not at all in NVDA and JAWS, and a
+hand-built grid of `<div>`s is worse. This library takes the approach proven by
+its sibling [wx-accessible-webview](https://github.com/Community-Access/wx-accessible-webview):
+render a real, semantic ARIA grid into a WebView and let the screen reader follow
+it like any web data table, then layer spreadsheet-style keyboard behavior on top.
+
+It is built for data entry, not a spreadsheet engine. There are no formulas. What
+there is, is every control you actually edit data with, fully keyboard-operable
+and announced correctly.
+
+## What you get
+
+- Arrow keys move a single focused cell, not the document. Moving across a row
+  speaks the column header. Moving down a column speaks the row header. Only the
+  focused cell is read, so a grid with thousands of rows stays fast instead of
+  making the screen reader re-read the whole table on every keystroke.
+- `F2` or `Enter` edits a cell in place with the right control for the data: edit
+  box, combo box, checkbox, slider, or stepper. `Enter` commits, `Escape` cancels.
+- `Space`, or `Ctrl+Space`, selects a row. `Delete` deletes the selection. The
+  context menu key, or `Shift+F10`, fires a callback so you can show a native menu.
+- Pass `row_select=True` to add a real checkbox at the start of every row, so
+  selecting rows for a bulk operation (move, reorder, edit a region) is visible
+  and discoverable, not just a keystroke. The host reads `grid.selected_rows()`,
+  acts through the model, and calls `grid.refresh()`.
+- Editing round-trips through your model, so the value the screen reader confirms
+  is the validated, normalized one, never the raw keystrokes. If an edit is
+  rejected the user hears why and the editor reopens so they can fix it.
+- Only one page of rows is ever in the DOM, but `aria-rowcount` keeps the user's
+  sense of "row N of many" correct. Arrow past the bottom and the next page loads
+  and navigation just keeps going.
+
+## Install
+
+```bash
+pip install wx-accessible-grid
+```
+
+That pulls in wxPython and wx-accessible-webview.
+
+## Use it
+
+Subclass `GridModel` to describe your columns and provide the data, then drop an
+`AccessibleGrid` into a sizer.
+
+```python
+import wx
+from wx_accessible_grid import AccessibleGrid, GridModel, Column, SetResult
+from wx_accessible_grid import TEXT, COMBO, CHECKBOX, SLIDER, STEPPER, NONE
+
+class ChannelModel(GridModel):
+    def __init__(self, rows):
+        self._rows = rows
+        self._cols = [
+            Column("num", "#", editor=NONE, is_row_header=True),
+            Column("name", "Name", editor=TEXT),
+            Column("mode", "Mode", editor=COMBO, choices=["FM", "AM", "USB"]),
+            Column("active", "Active", editor=CHECKBOX),
+            Column("volume", "Volume", editor=SLIDER, min=0, max=100, step=1),
+            Column("priority", "Priority", editor=STEPPER, min=0, max=10),
+        ]
+
+    def columns(self):
+        return self._cols
+
+    def row_count(self):
+        return len(self._rows)
+
+    def display(self, row, column):
+        if column == "num":
+            return str(row + 1)
+        val = self._rows[row][column]
+        return "Yes" if (column == "active" and val) else "No" if column == "active" else str(val)
+
+    def edit_value(self, row, column):
+        # the form the editor wants, when it differs from the shown text
+        if column == "active":
+            return "true" if self._rows[row]["active"] else "false"
+        return self.display(row, column)
+
+    def set_cell(self, row, column, value):
+        # validate and normalize here; what you return is what gets announced
+        self._rows[row][column] = value
+        return SetResult(True, display=value, message=f"{column} updated")
+
+grid = AccessibleGrid(panel, ChannelModel(rows), label="Memory channels",
+                      page_size=100)
+sizer.Add(grid.control, 1, wx.EXPAND)
+```
+
+The `dev` extra (`pip install "wx-accessible-grid[dev]"`) adds pytest for the
+model and renderer tests, which run without wx.
+
+## The editors
+
+- `TEXT`: a single-line edit box. Type, then Enter to commit.
+- `COMBO`: a drop-down of fixed choices, which also stands in for a radio group.
+  Arrow through the list, Enter to commit.
+- `CHECKBOX`: a boolean toggle. Space toggles it, Enter commits.
+- `SLIDER`: a range control adjusted with the arrow keys.
+- `STEPPER`: a number spinner. Type a value or step it with the arrows.
+- `NONE`: read-only, for ids and computed columns. Not editable.
+
+`edit_value` gives the editor its starting value when that differs from the
+displayed text (a checkbox wants `true`/`false`, a slider wants a bare number,
+even if the cell shows `Yes` or `146.520 MHz`).
+
+## Keyboard
+
+- Arrows: move the focused cell. `Home` / `End`: first / last cell in the row.
+  `Ctrl+Home` / `Ctrl+End`: first / last cell in the grid. `Page Up` / `Page Down`:
+  previous / next page.
+- `F2` or `Enter`: edit the focused cell. `Enter`: commit. `Escape`: cancel.
+- `Space` or `Ctrl+Space`: select or unselect the row.
+- `Delete`: delete the selected rows, or the focused row if none are selected.
+- Context menu key or `Shift+F10`: ask the host for a row menu.
+
+## How it works
+
+The grid is a `<table role="grid">` with `<th scope="col">` column headers,
+a `<th scope="row">` row header, and `<td role="gridcell">` cells, rendered into
+an `AccessibleWebView`. A roving `tabindex` gives exactly one cell focus at a
+time, which puts the screen reader in focus mode so it reads that cell and the
+headers that changed, not the whole table. A small vanilla-JS runtime, installed
+once, handles navigation, editing, and selection, and talks to Python over the
+WebView bridge. Your `GridModel` does the validation and persistence on the
+Python side.
+
+## Status
+
+Version 0.1.0, first release, built for VRP (the accessible radio programmer) and
+extracted as a reusable library. Tested on macOS WebView with VoiceOver and in
+unit tests for the model and renderer. NVDA and JAWS verification on Windows
+WebView2 is the next milestone; reports welcome.
+
+## License
+
+MIT. A Community Access open-source project, created by Taylor Arndt.

wx_accessible_grid-0.1.0/README.md

@@ -0,0 +1,140 @@
+# wx-accessible-grid
+
+An accessible, editable data grid for wxPython that a blind person can actually
+use. Native `wx.grid.Grid` reads poorly or not at all in NVDA and JAWS, and a
+hand-built grid of `<div>`s is worse. This library takes the approach proven by
+its sibling [wx-accessible-webview](https://github.com/Community-Access/wx-accessible-webview):
+render a real, semantic ARIA grid into a WebView and let the screen reader follow
+it like any web data table, then layer spreadsheet-style keyboard behavior on top.
+
+It is built for data entry, not a spreadsheet engine. There are no formulas. What
+there is, is every control you actually edit data with, fully keyboard-operable
+and announced correctly.
+
+## What you get
+
+- Arrow keys move a single focused cell, not the document. Moving across a row
+  speaks the column header. Moving down a column speaks the row header. Only the
+  focused cell is read, so a grid with thousands of rows stays fast instead of
+  making the screen reader re-read the whole table on every keystroke.
+- `F2` or `Enter` edits a cell in place with the right control for the data: edit
+  box, combo box, checkbox, slider, or stepper. `Enter` commits, `Escape` cancels.
+- `Space`, or `Ctrl+Space`, selects a row. `Delete` deletes the selection. The
+  context menu key, or `Shift+F10`, fires a callback so you can show a native menu.
+- Pass `row_select=True` to add a real checkbox at the start of every row, so
+  selecting rows for a bulk operation (move, reorder, edit a region) is visible
+  and discoverable, not just a keystroke. The host reads `grid.selected_rows()`,
+  acts through the model, and calls `grid.refresh()`.
+- Editing round-trips through your model, so the value the screen reader confirms
+  is the validated, normalized one, never the raw keystrokes. If an edit is
+  rejected the user hears why and the editor reopens so they can fix it.
+- Only one page of rows is ever in the DOM, but `aria-rowcount` keeps the user's
+  sense of "row N of many" correct. Arrow past the bottom and the next page loads
+  and navigation just keeps going.
+
+## Install
+
+```bash
+pip install wx-accessible-grid
+```
+
+That pulls in wxPython and wx-accessible-webview.
+
+## Use it
+
+Subclass `GridModel` to describe your columns and provide the data, then drop an
+`AccessibleGrid` into a sizer.
+
+```python
+import wx
+from wx_accessible_grid import AccessibleGrid, GridModel, Column, SetResult
+from wx_accessible_grid import TEXT, COMBO, CHECKBOX, SLIDER, STEPPER, NONE
+
+class ChannelModel(GridModel):
+    def __init__(self, rows):
+        self._rows = rows
+        self._cols = [
+            Column("num", "#", editor=NONE, is_row_header=True),
+            Column("name", "Name", editor=TEXT),
+            Column("mode", "Mode", editor=COMBO, choices=["FM", "AM", "USB"]),
+            Column("active", "Active", editor=CHECKBOX),
+            Column("volume", "Volume", editor=SLIDER, min=0, max=100, step=1),
+            Column("priority", "Priority", editor=STEPPER, min=0, max=10),
+        ]
+
+    def columns(self):
+        return self._cols
+
+    def row_count(self):
+        return len(self._rows)
+
+    def display(self, row, column):
+        if column == "num":
+            return str(row + 1)
+        val = self._rows[row][column]
+        return "Yes" if (column == "active" and val) else "No" if column == "active" else str(val)
+
+    def edit_value(self, row, column):
+        # the form the editor wants, when it differs from the shown text
+        if column == "active":
+            return "true" if self._rows[row]["active"] else "false"
+        return self.display(row, column)
+
+    def set_cell(self, row, column, value):
+        # validate and normalize here; what you return is what gets announced
+        self._rows[row][column] = value
+        return SetResult(True, display=value, message=f"{column} updated")
+
+grid = AccessibleGrid(panel, ChannelModel(rows), label="Memory channels",
+                      page_size=100)
+sizer.Add(grid.control, 1, wx.EXPAND)
+```
+
+The `dev` extra (`pip install "wx-accessible-grid[dev]"`) adds pytest for the
+model and renderer tests, which run without wx.
+
+## The editors
+
+- `TEXT`: a single-line edit box. Type, then Enter to commit.
+- `COMBO`: a drop-down of fixed choices, which also stands in for a radio group.
+  Arrow through the list, Enter to commit.
+- `CHECKBOX`: a boolean toggle. Space toggles it, Enter commits.
+- `SLIDER`: a range control adjusted with the arrow keys.
+- `STEPPER`: a number spinner. Type a value or step it with the arrows.
+- `NONE`: read-only, for ids and computed columns. Not editable.
+
+`edit_value` gives the editor its starting value when that differs from the
+displayed text (a checkbox wants `true`/`false`, a slider wants a bare number,
+even if the cell shows `Yes` or `146.520 MHz`).
+
+## Keyboard
+
+- Arrows: move the focused cell. `Home` / `End`: first / last cell in the row.
+  `Ctrl+Home` / `Ctrl+End`: first / last cell in the grid. `Page Up` / `Page Down`:
+  previous / next page.
+- `F2` or `Enter`: edit the focused cell. `Enter`: commit. `Escape`: cancel.
+- `Space` or `Ctrl+Space`: select or unselect the row.
+- `Delete`: delete the selected rows, or the focused row if none are selected.
+- Context menu key or `Shift+F10`: ask the host for a row menu.
+
+## How it works
+
+The grid is a `<table role="grid">` with `<th scope="col">` column headers,
+a `<th scope="row">` row header, and `<td role="gridcell">` cells, rendered into
+an `AccessibleWebView`. A roving `tabindex` gives exactly one cell focus at a
+time, which puts the screen reader in focus mode so it reads that cell and the
+headers that changed, not the whole table. A small vanilla-JS runtime, installed
+once, handles navigation, editing, and selection, and talks to Python over the
+WebView bridge. Your `GridModel` does the validation and persistence on the
+Python side.
+
+## Status
+
+Version 0.1.0, first release, built for VRP (the accessible radio programmer) and
+extracted as a reusable library. Tested on macOS WebView with VoiceOver and in
+unit tests for the model and renderer. NVDA and JAWS verification on Windows
+WebView2 is the next milestone; reports welcome.
+
+## License
+
+MIT. A Community Access open-source project, created by Taylor Arndt.

wx_accessible_grid-0.1.0/agentnotes.md

@@ -0,0 +1,101 @@
+# Agent notes — wx-accessible-grid
+
+Handoff log. Read this first; update it as you go.
+
+## What this is
+
+A reusable, accessible, editable data grid for wxPython, spun out the same way as
+its siblings `wx-accessible-webview` and `wx-accessible-menubar`. Community Access
+open-source, MIT, created by Taylor Arndt. First consumer is VRP (the accessible
+radio programmer), whose channel grid is the motivating use case.
+
+The hard problem it solves: native `wx.grid.Grid` is inaccessible, and earlier
+in-grid editing attempts in VRP made NVDA re-read the whole table on every
+keystroke (so they fell back to a read-only table plus a native edit dialog).
+The fix here is a real `<table role="grid">` with a roving tabindex, so NVDA goes
+into focus mode and reads only the focused cell plus the headers that changed.
+
+## Architecture
+
+- `model.py` — `GridModel` (subclass it), `Column` (with one of five editors:
+  text, combo, checkbox, slider, stepper, plus `none`), `SetResult`. The model
+  owns all data, validation, and persistence; the grid never mutates data
+  directly. wx-free, unit tested.
+- `render.py` — renders the model to ARIA grid HTML one page at a time.
+  `aria-rowcount` = total + 1 (header), `aria-rowindex` absolute (header = 1,
+  first data row = 2). wx-free, unit tested.
+- `assets.py` — `GRID_CSS` and the vanilla-JS runtime (`runtime_js(handler)`).
+  The runtime is delegated off `document` so it survives re-renders; it manages
+  the roving tabindex, navigation, selection, the five in-cell editors, and the
+  Python bridge. `window.__wag` exposes setColumns/setCell/editFailed/removeRow/
+  announce/focusCell for Python to call back.
+- `grid.py` — `AccessibleGrid` widget. Owns an `AccessibleWebView`, installs the
+  runtime on load (EVT_WEBVIEW_LOADED + CallAfter), pushes column metadata,
+  renders pages, and brokers edit/select/delete/page/context bridge messages to
+  the model. `grid.control` goes in a sizer.
+- `examples/demo.py` — standalone 2,500-row demo with all five editors (run it
+  with NVDA on Windows). `tests/` — model + renderer tests (no wx needed).
+
+## Bridge protocol
+
+Page to Python (all `{type:"wag", action, ...}`): `edit{row,col,value}`,
+`select{row,selected,count}`, `delete{rows}`, `page{dir,col,fromRow}`,
+`context{row,col}`. `col` is the 0-based column index; `row` is the absolute
+0-based row index.
+
+## Focus model (important — read before editing assets.py/render.py)
+
+The grid uses the **aria-activedescendant** pattern, NOT roving tabindex. The
+`<table>` is the only focusable element (`tabindex=0`) and owns
+`aria-activedescendant`; the runtime moves that to the active cell's id instead
+of calling `cell.focus()`. This is deliberate: the accessibility-lead review
+found a focused `role=gridcell` with roving tabindex does NOT reliably put NVDA
+in focus mode under WebView2 (arrows would be dead), and every innerHTML swap
+bounced focus through document.body and out of focus mode. activedescendant fixes
+both. Do not "simplify" back to roving tabindex + cell.focus().
+
+Paging and delete replace ONLY the tbody (`window.__wag.setRows`) so the table
+element — and thus focus + focus mode — survives. Full `set_content` is only used
+for the initial render and `refresh()`.
+
+## Status (2026-06-20)
+
+- Built v0.1.0. accessibility-lead review done (4 specialists). It was a NO-SHIP;
+  all three Criticals fixed: (1) migrated to aria-activedescendant; (2) edit/
+  delete/page no longer drop focus to body; (3) two real aria-live regions are
+  rendered (polite + assertive) and success edits now announce the authoritative
+  value. Should-fix items also applied: Tab/blur edit trap, read-only announce on
+  F2, header-row navigation, page-edge guards, cell-level aria-selected,
+  aria-invalid + message-in-name on reject, identical-text re-announce. (A few
+  nice-to-haves from the review remain, noted in the review output.)
+- 11 unit tests pass (`PYTHONPATH=src pytest`). Mac WKWebView smoke passes:
+  build, edit (incl. reject keeps old value), paging, delete, runtime install.
+- WIRED INTO VRP and tested against a real CHIRP image (Baofeng UV-5R, 128
+  channels): all real columns render, name edit persisted (and the UV-5R's name
+  truncation came back as the authoritative display — the round-trip works), bad
+  frequency rejected. VRP files: `vrp/channel_grid_model.py` (ChannelGridModel),
+  `tools/grid_preview.py` (launcher), dep added to VRP pyproject + installed
+  editable. VRP's own 63 tests still pass.
+- NOT yet verified on Windows + NVDA/WebView2 — the make-or-break test, next
+  milestone. On the Parallels VM: `uv run python tools/grid_preview.py` in the
+  VRP clone (see windows-parallels-prlctl memory). The review's step-by-step VM
+  test script is in that review output; step 1 (Tab in, press Down, expect a
+  sibling cell, not a document line) is the focus-mode gate.
+- VRP's read-only table + native edit dialog are left in place; the grid is a
+  preview/beta path until NVDA proves out, then it replaces the channels view
+  (keep the dialog as the full-row fallback).
+- No git commits yet (Taylor commits/pushes himself). No PyPI release yet.
+
+## Testing
+
+- `PYTHONPATH=src <python-with-wx> -m pytest -q` — model + renderer.
+- `pip install -e ".[dev]"` then `pytest` in a clean env.
+- Real test is manual: `python examples/demo.py` with a screen reader. Drive the
+  arrow navigation, F2/Enter editing for each editor, Space selection, Delete,
+  and the context-menu key, and confirm the announcements.
+
+## Conventions
+
+Mirror the sibling libs: hatchling build, `src/` layout, MIT, ruff line length
+100, dependency-light (wxPython + wx-accessible-webview). No emojis, no markdown
+tables in docs (screen-reader rule).

wx_accessible_grid-0.1.0/examples/demo.py

@@ -0,0 +1,154 @@
+"""Standalone demo of AccessibleGrid — run it with a screen reader.
+
+    pip install -e .
+    python examples/demo.py
+
+It builds a 2,500-row grid (to exercise paging and large-dataset performance,
+the exact condition that broke earlier in-grid attempts) with one of every
+editor: text, combo, checkbox, slider, stepper. Try, with NVDA running:
+
+* Arrow around — moving across a row speaks the column; moving down speaks the
+  row number. Arrow past the bottom/top to roll onto the next/previous page.
+* F2 or Enter on a cell to edit; Enter commits, Escape cancels.
+* Space (or Ctrl+Space) to select a row; Delete to delete selected rows.
+* The Applications key (or Shift+F10) on a cell opens a native row menu.
+"""
+
+from __future__ import annotations
+
+import wx
+
+from wx_accessible_grid import (
+    CHECKBOX,
+    COMBO,
+    NONE,
+    SLIDER,
+    STEPPER,
+    TEXT,
+    AccessibleGrid,
+    Column,
+    GridModel,
+    SetResult,
+)
+
+MODES = ["FM", "NFM", "AM", "USB", "LSB", "CW", "DV"]
+
+
+class DemoModel(GridModel):
+    """An in-memory grid: a list of dict rows, all validation inline."""
+
+    def __init__(self, n: int = 2500) -> None:
+        self._cols = [
+            Column("num", "#", editor=NONE, is_row_header=True),
+            Column("name", "Name", editor=TEXT),
+            Column("mode", "Mode", editor=COMBO, choices=MODES),
+            Column("active", "Active", editor=CHECKBOX),
+            Column("volume", "Volume", editor=SLIDER, min=0, max=100, step=1),
+            Column("priority", "Priority", editor=STEPPER, min=0, max=10, step=1),
+            Column("comment", "Comment", editor=TEXT),
+        ]
+        self._rows = [
+            {
+                "name": f"Channel {i + 1}",
+                "mode": MODES[i % len(MODES)],
+                "active": i % 3 == 0,
+                "volume": (i * 7) % 101,
+                "priority": i % 11,
+                "comment": "",
+            }
+            for i in range(n)
+        ]
+
+    def columns(self) -> list[Column]:
+        return self._cols
+
+    def row_count(self) -> int:
+        return len(self._rows)
+
+    def display(self, row: int, column: str) -> str:
+        if column == "num":
+            return str(row + 1)
+        val = self._rows[row][column]
+        if column == "active":
+            return "Yes" if val else "No"
+        return str(val)
+
+    def edit_value(self, row: int, column: str) -> str:
+        if column == "active":
+            return "true" if self._rows[row]["active"] else "false"
+        if column == "num":
+            return str(row + 1)
+        return str(self._rows[row][column])
+
+    def set_cell(self, row: int, column: str, value: str) -> SetResult:
+        if column in ("volume", "priority"):
+            try:
+                num = int(float(value))
+            except ValueError:
+                return SetResult(False, message=f"{column} must be a number")
+            lo, hi = (0, 100) if column == "volume" else (0, 10)
+            if not lo <= num <= hi:
+                return SetResult(False, message=f"{column} must be {lo} to {hi}")
+            self._rows[row][column] = num
+            return SetResult(True, str(num), f"{column} set to {num}")
+        if column == "active":
+            on = value in ("true", "1", "yes")
+            self._rows[row]["active"] = on
+            return SetResult(True, "Yes" if on else "No", "Active on" if on else "Active off")
+        if column == "mode":
+            if value not in MODES:
+                return SetResult(False, message=f"{value} is not a valid mode")
+            self._rows[row]["mode"] = value
+            return SetResult(True, value, f"Mode {value}")
+        self._rows[row][column] = value
+        return SetResult(True, value, f"{column} updated")
+
+    def delete_rows(self, rows: list[int]) -> SetResult:
+        for r in sorted(rows, reverse=True):
+            if 0 <= r < len(self._rows):
+                del self._rows[r]
+        return SetResult(True, message=f"Deleted {len(rows)} row(s)")
+
+
+class DemoFrame(wx.Frame):
+    def __init__(self) -> None:
+        super().__init__(None, title="wx-accessible-grid demo", size=(900, 600))
+        panel = wx.Panel(self)
+        self.model = DemoModel()
+        self.grid = AccessibleGrid(
+            panel,
+            self.model,
+            label="Demo channels",
+            page_size=100,
+            row_select=True,
+            on_context=self._on_context,
+            description="Arrow to move, F2 or Enter to edit, Space to select.",
+        )
+        sizer = wx.BoxSizer(wx.VERTICAL)
+        sizer.Add(self.grid.control, 1, wx.EXPAND)
+        panel.SetSizer(sizer)
+        self.Show()
+        wx.CallAfter(self.grid.focus)
+
+    def _on_context(self, row: int, column: str) -> None:
+        menu = wx.Menu()
+        edit = menu.Append(wx.ID_ANY, f"Edit row {row + 1} (full)\tEnter")
+        delete = menu.Append(wx.ID_ANY, f"Delete row {row + 1}\tDel")
+        self.Bind(
+            wx.EVT_MENU,
+            lambda _e: self.grid.announce(f"Would open full editor for row {row + 1}"),
+            edit,
+        )
+        self.Bind(
+            wx.EVT_MENU,
+            lambda _e: (self.model.delete_rows([row]), self.grid.refresh()),
+            delete,
+        )
+        self.grid.control.PopupMenu(menu)
+        menu.Destroy()
+
+
+if __name__ == "__main__":
+    app = wx.App()
+    DemoFrame()
+    app.MainLoop()