fastpygrid 0.1.0__py3-none-win_amd64.whl

fastgrid/__init__.py

@@ -0,0 +1,13 @@
+"""fastgrid — a fast grid split into a GUI-free core and thin toolkit hosts.
+
+    core/        model + geometry + selection + paint() + the Direct2D engine (gpu.py)
+    render/      gpu_tk.py (tkinter host) · gpu_qt.py (PySide6 host)
+
+Both hosts drive the SAME Direct2D engine, so behaviour and looks match.
+
+    from fastgrid.render.gpu_tk import make_sheet   # tkinter
+    win = make_sheet(headers, rows, frozen_columns=2); win.mainloop()
+"""
+from .core import GridModel, selection, theme
+
+__all__ = ["GridModel", "selection", "theme"]

fastgrid/core/__init__.py

@@ -0,0 +1,8 @@
+"""GUI-free core: model + geometry + selection + display-list paint.
+Import nothing from any toolkit here."""
+from . import selection, theme
+from .model import GridModel
+from .geometry import Geometry
+from .paint import paint, DisplayList
+
+__all__ = ["GridModel", "Geometry", "paint", "DisplayList", "selection", "theme"]

fastgrid/core/coremodel.py

@@ -0,0 +1,359 @@
+"""CoreModel -- GridModel backed by the C++ arena engine (gridcore.dll).
+
+Cell text lives in C++; the bulk text paths (copy/delete/paste/find) and undo
+run there in one ctypes call each, avoiding the millions of Python str objects
+that are the pure-Python floor. Everything else (view/filter/sort orchestration,
+styles, choices, readonly, geometry) stays in Python: those touch one column or
+the visible viewport, where per-cell access is already cheap.
+
+`self._rows` is a thin shim delegating to the engine, so every inherited
+GridModel method keeps working unchanged; only the handful of bulk hot methods
+are overridden to call C++ directly.
+
+Scope: data-row mutations. Header rows are read-only through the fast path
+(headers stay Python, as in GridModel); editing a header cell is not routed
+through this backend. Falls back to GridModel if the DLL is unavailable.
+"""
+import ctypes
+import os
+import struct
+
+from .model import GridModel, PAD_ROWS, _clean, _grow, _norm_ranges
+
+_DLL = os.path.join(os.path.dirname(__file__), "_gridstore", "gridcore.dll")
+
+
+def _load():
+    if not os.path.exists(_DLL):
+        return None
+    try:
+        lib = ctypes.CDLL(_DLL)
+    except OSError:
+        return None
+    P, I, C = ctypes.c_void_p, ctypes.c_int, ctypes.c_char_p
+    IP = ctypes.POINTER(I)
+    sig = {
+        "gc_new": ([I, I], P), "gc_free": ([P], None),
+        "gc_ndata": ([P], I), "gc_grow_cols": ([P, I], None),
+        "gc_load_packed": ([P, C, I], None),
+        "gc_cell": ([P, I, I], C), "gc_set_raw": ([P, I, I, C], I),
+        "gc_set_view": ([P, IP, I], None),
+        "gc_copy": ([P, I, I, I, I, IP], P),
+        "gc_delete": ([P, IP, I, IP, I, IP, I, IP], I),
+        "gc_paste": ([P, I, I, C, I, IP, I, IP, I, I, I, IP], I),
+        "gc_set_cell": ([P, I, I, C, IP, I, IP, I], I),
+        "gc_undo": ([P, IP], I), "gc_redo": ([P, IP], I),
+        "gc_find": ([P, C, I, I, IP, I, I, IP, IP], P),
+    }
+    for name, (args, res) in sig.items():
+        fn = getattr(lib, name)
+        fn.argtypes, fn.restype = args, res
+    return lib
+
+
+_LIB = _load()
+
+
+def _iarr(seq):
+    """A ctypes int array (or None) from a Python iterable."""
+    seq = list(seq)
+    if not seq:
+        return None, 0
+    return (ctypes.c_int * len(seq))(*seq), len(seq)
+
+
+def _pack(rows):
+    """Length-prefixed (u32 len + utf-8 bytes) row-major buffer for gc_load_packed."""
+    parts = []
+    for r in rows:
+        for c in r:
+            b = c.encode("utf-8")
+            parts.append(struct.pack("<I", len(b)))
+            parts.append(b)
+    return b"".join(parts)
+
+
+def make_model(headers, rows, editable=True, on_edit=None):
+    """CoreModel (C++ backend) when gridcore.dll is available, else the pure
+    Python GridModel. Drop-in: identical public API."""
+    cls = CoreModel if _LIB else GridModel
+    return cls(headers, rows, editable=editable, on_edit=on_edit)
+
+
+class _CoreRow:
+    __slots__ = ("_c", "_r")
+
+    def __init__(self, core, r):
+        self._c, self._r = core, r
+
+    def __getitem__(self, col):
+        return _LIB.gc_cell(self._c, self._r, col).decode("utf-8")
+
+
+class _CoreRows:
+    """Read shim making `self._rows[r][c]` delegate to the C++ engine, so inherited
+    GridModel code (sort/filter/distinct/cell/style) works unchanged. Reads only:
+    every inherited mutation path (set_cell/paste/delete/undo/grow) is overridden
+    to call the engine directly."""
+    __slots__ = ("_c",)
+
+    def __init__(self, core):
+        self._c = core
+
+    def __len__(self):
+        return _LIB.gc_ndata(self._c)
+
+    def __getitem__(self, r):
+        return _CoreRow(self._c, r)
+
+    def __iter__(self):
+        for r in range(len(self)):
+            yield _CoreRow(self._c, r)
+
+
+class CoreModel(GridModel):
+    # ---- storage: build the engine instead of a Python matrix ----
+    def set_data(self, headers, rows):
+        if headers and isinstance(headers[0], (list, tuple)):
+            hdr = [[str(h) for h in hrow] for hrow in headers]
+        else:
+            hdr = [[str(h) for h in headers] or ["A"]]
+        w = max(len(hrow) for hrow in hdr)
+        self._headers = [hrow + [""] * (w - len(hrow)) for hrow in hdr]
+        self._hdr = len(self._headers)
+        self._w = w
+
+        data = [([str(c) for c in r][:w] + [""] * (w - len(r))) for r in rows]
+        if getattr(self, "_core", None):
+            _LIB.gc_free(self._core)
+        self._core = _LIB.gc_new(w, 0)            # hdr=0: engine holds DATA rows only
+        if data:
+            _LIB.gc_load_packed(self._core, _pack(data), len(data))
+        self._rows = _CoreRows(self._core)
+        self._init_view_state()                   # _undo holds tagged ops; cell diffs live in C++
+
+    def __del__(self):
+        c = getattr(self, "_core", None)
+        if c and _LIB:
+            _LIB.gc_free(c)
+
+    # ---- view: keep GridModel's Python rebuild, then push the mapping to C++ ----
+    def _rebuild(self):
+        super()._rebuild()
+        if self._is_plain():
+            _LIB.gc_set_view(self._core, None, -1)
+        else:
+            arr, n = _iarr(self._view)
+            _LIB.gc_set_view(self._core, arr, n)
+
+    def _ro_arrays(self):
+        rc, n_rc = _iarr(sorted(self._readonly))
+        rr, n_rr = _iarr(sorted(k for k in self._readonly_rows if k >= 0))   # data rows only
+        return rc, n_rc, rr, n_rr
+
+    def _touch(self, cols):
+        for c in cols:
+            self._distinct.pop(c, None)
+
+    def _push_snap(self, rng):
+        # Cell diff lives in the C++ engine; the Python entry carries the view state
+        # active at this edit + the touched rect (to reselect on undo), tagged to
+        # interleave with 'view' ops.
+        self._undo.append(("edit", self._filt_snapshot(), rng))
+        del self._undo[:-200]
+        self._redo.clear()
+
+    # ---- bulk hot paths -> C++ ----
+    def selection_text(self, ranges):
+        rs = _norm_ranges(ranges)
+        if not rs:
+            return ""
+        r1 = max(0, min(r[0] for r in rs)); c1 = max(0, min(r[1] for r in rs))
+        r2 = max(r[2] for r in rs); c2 = min(self._w - 1, max(r[3] for r in rs))
+        H = self._hdr
+        lines = []
+        for gr in range(r1, min(H, r2 + 1)):          # header rows (Python)
+            lines.append("\t".join(_clean(self.cell(gr, c)) for c in range(c1, c2 + 1)))
+        d_lo = max(r1, H)                              # data rows (C++)
+        if d_lo <= r2:
+            n = ctypes.c_int()
+            p = _LIB.gc_copy(self._core, d_lo - H, c1, r2 - H, c2, ctypes.byref(n))
+            lines.append(ctypes.string_at(p, n.value).decode("utf-8"))
+        return "\n".join(lines)
+
+    def delete_selection(self, ranges):
+        if not self.editable:
+            return False
+        H = self._hdr
+        rects, box = [], None
+        for r1, c1, r2, c2 in _norm_ranges(ranges):
+            r1 = max(r1, H)                            # data rows only
+            if r1 <= r2:
+                rects.extend((r1 - H, c1, r2 - H, c2))
+                box = _grow(_grow(box, r1, c1), r2, c2)   # grid rect to reselect on undo
+        if not rects:
+            return False
+        ra = (ctypes.c_int * len(rects))(*rects)
+        rc, n_rc, rr, n_rr = self._ro_arrays()
+        tgt = (ctypes.c_int * 2)()
+        changed = _LIB.gc_delete(self._core, ra, len(rects) // 4, rc, n_rc, rr, n_rr, tgt)
+        if changed:
+            cols = {c for i in range(0, len(rects), 4) for c in range(max(0, rects[i + 1]),
+                    min(self._w, rects[i + 3] + 1))}
+            self._touch(cols)
+            self._push_snap(box)
+            self._find_cache = None
+            self._used = None
+            if not self._is_plain():
+                self._rebuild()
+            if self.on_edit:
+                self.on_edit()
+            self.changed()
+        return bool(changed)
+
+    def paste_text(self, text, ranges, active):
+        if not self.editable or not text:
+            return None
+        rs = _norm_ranges(ranges)
+        if rs:
+            start_gr = min(r[0] for r in rs); start_col = min(r[1] for r in rs)
+            sel_r2 = max(r[2] for r in rs); sel_c2 = max(r[3] for r in rs)
+        else:
+            start_gr, start_col = active
+            sel_r2, sel_c2 = active
+        H = self._hdr
+        d_start = max(0, start_gr - H)                  # header-row paste not routed
+        rc, n_rc, rr, n_rr = self._ro_arrays()
+        pre = _LIB.gc_ndata(self._core)
+        # C++ parses the raw clipboard, fills a 1x1 over a multi-cell selection,
+        # and returns the block dims -- no Python split/scan.
+        payload = text.encode("utf-8")
+        dims = (ctypes.c_int * 2)()
+        changed = _LIB.gc_paste(self._core, d_start, start_col, payload, len(payload),
+                                rc, n_rc, rr, n_rr, sel_r2 - start_gr + 1,
+                                sel_c2 - start_col + 1, dims)
+        nblock, maxw = dims[0], dims[1]
+        if nblock == 0:                                # clipboard was all-blank
+            return None
+        if changed:
+            if _LIB.gc_ndata(self._core) > pre:        # materialised -> all columns gained a blank
+                self._distinct.clear()
+            else:
+                self._touch(range(start_col, start_col + maxw))
+            self._push_snap((start_gr, start_col,
+                             start_gr + nblock - 1, start_col + maxw - 1))
+            self._find_cache = None
+            self._used = None
+        if not self._is_plain():
+            self._rebuild()
+        if self.on_edit:
+            self.on_edit()
+        self.changed()
+        end_gr = start_gr + nblock - 1
+        end_col = start_col + maxw - 1
+        return (start_gr, start_col, min(end_gr, self.nrows() - 1), min(end_col, self._w - 1))
+
+    def set_cell(self, gr, col, text):
+        if not self.editable or col in self._readonly or self.row_readonly(gr) \
+                or not (0 <= col < self._w) or gr < self._hdr:
+            return False
+        text = str(text)
+        rc, n_rc, rr, n_rr = self._ro_arrays()
+        pre = _LIB.gc_ndata(self._core)
+        changed = _LIB.gc_set_cell(self._core, gr - self._hdr, col, text.encode("utf-8"),
+                                   rc, n_rc, rr, n_rr)
+        if not changed:
+            return False
+        if _LIB.gc_ndata(self._core) > pre:           # materialised -> all columns gained a blank
+            self._distinct.clear()
+        else:
+            self._touch([col])
+        self._push_snap((gr, col, gr, col))
+        self._find_cache = None
+        self._used = None
+        if self._rebuilds_on_edit(gr, col):
+            self._rebuild()
+        if self.on_edit:
+            self.on_edit()
+        self.changed()
+        return True
+
+    def grow_cols(self, new_w):
+        """Widen the sheet to `new_w` columns (editing past the last column, uncapped).
+        The C++ core re-strides its buffer; headers gain blank trailing cells. No-op
+        if it already has that many. New columns start blank and are fully editable."""
+        if new_w <= self._w:
+            return
+        _LIB.gc_grow_cols(self._core, new_w)
+        for hrow in self._headers:
+            hrow += [""] * (new_w - len(hrow))
+        self._w = new_w
+        self._distinct.clear()
+        self._used = None
+        self.changed()
+
+    def _replay_edit(self, entry, use_new):
+        # base undo()/redo() dispatch 'view' vs 'edit'; a cell edit drives the C++ stack.
+        tgt = (ctypes.c_int * 2)()
+        fn = _LIB.gc_redo if use_new else _LIB.gc_undo
+        if not fn(self._core, tgt):
+            return None
+        self._install_filt(entry[1])
+        if self.on_edit:
+            self.on_edit()
+        self.changed()
+        return self._clamp_target(entry[2])
+
+    # ---- find -> C++ (data) + Python (header rows) ----
+    def find_matches(self, query, case=False, scope=None):
+        if not query:
+            self._find_cache = None
+            return [], False
+        H = self._hdr
+        out = []
+        needle = query if case else query.lower()
+        # header rows in Python (tiny), in grid order first
+        hdr_scope = None
+        if scope:
+            hdr_scope = [(r1, c1, r2, c2) for (r1, c1, r2, c2) in scope if r1 < H]
+        hrows = range(H) if not scope else None
+        for hr in (range(H) if hrows is not None else []):
+            for c in range(self._w):
+                v = self._headers[hr][c]
+                if v and needle in (v if case else v.lower()):
+                    out.append((hr, c))
+        if scope and hdr_scope:
+            seen = set()
+            for (r1, c1, r2, c2) in hdr_scope:
+                for hr in range(max(0, r1), min(H, r2 + 1)):
+                    for c in range(max(0, c1), min(self._w, c2 + 1)):
+                        if (hr, c) in seen:
+                            continue
+                        seen.add((hr, c))
+                        v = self._headers[hr][c]
+                        if v and needle in (v if case else v.lower()):
+                            out.append((hr, c))
+        # data rows in C++
+        nb = query.encode("utf-8")
+        sc = None
+        if scope:
+            flat = []
+            for (r1, c1, r2, c2) in scope:
+                if r2 < H:
+                    continue
+                flat.extend((max(0, r1 - H), c1, r2 - H, c2))
+            sc, nsc = _iarr(flat)
+        else:
+            nsc = 0
+        cnt, capped = ctypes.c_int(), ctypes.c_int()
+        p = _LIB.gc_find(self._core, nb, len(nb), 1 if case else 0, sc, nsc // 4 if scope else 0,
+                         self.FIND_LIMIT, ctypes.byref(cnt), ctypes.byref(capped))
+        raw = ctypes.string_at(p, cnt.value * 8)
+        data = [(raw[i] | raw[i + 1] << 8 | raw[i + 2] << 16 | raw[i + 3] << 24,
+                 raw[i + 4] | raw[i + 5] << 8 | raw[i + 6] << 16 | raw[i + 7] << 24)
+                for i in range(0, len(raw), 8)]
+        for gr, c in data:
+            out.append((gr + H, c))
+        if scope:
+            out = sorted(set(out))
+        return out, bool(capped.value)

fastgrid/core/filter.py

@@ -0,0 +1,91 @@
+"""Column filter/sort popup logic -- GUI-free, like FindController.
+
+The Tk and Qt filter popups are just widgets: a value checklist, a search box
+and OK/Cancel. All the actual behaviour (deferred distinct scan, per-value
+checked state, search over a capped column, and the exact commit rules for
+"clear vs keep exactly the checked members") lives here, driven identically by
+both. The widget only renders ``rows(query)`` with a checkbox per ``checked(v)``
+and forwards clicks to ``toggle`` / ``toggle_all`` and OK to ``commit``.
+"""
+
+
+class FilterController:
+    def __init__(self, model, col):
+        self.model = model
+        self.col = col
+        self.state = None          # v -> bool user toggles; None until load()
+        self.active = None         # the column's active filter set, or None
+        self.preloaded = []        # distinct preview (may be capped)
+        self.capped = False
+
+    def load(self):
+        """Deferred distinct scan -- run on the next event-loop tick so opening the
+        popup is instant even on a 1M-row column."""
+        self.active = self.model._filters.get(self.col)
+        self.preloaded, self.capped = self.model.distinct_capped(self.col)
+        self.state = {v: self.checked(v) for v in self.preloaded}
+
+    def checked(self, v):
+        """An explicit user toggle, else the default from the active filter (all
+        allowed when there's no filter)."""
+        if self.state and v in self.state:
+            return self.state[v]
+        return self.active is None or v in self.active
+
+    def rows(self, query):
+        q = query.strip().lower()
+        if not q:
+            return self.preloaded
+        if self.capped:                # search the whole column, not just the preview
+            return self.model.distinct_matching(self.col, q)
+        return [v for v in self.preloaded if q in v.lower()]
+
+    def all_on(self, rows):
+        return bool(rows) and all(self.checked(v) for v in rows)
+
+    def truncated(self, rows):
+        return len(rows) >= self.model.DISTINCT_CAP
+
+    def toggle(self, v):
+        self.state[v] = not self.checked(v)
+
+    def toggle_all(self, rows):
+        target = not self.all_on(rows)
+        for v in rows:
+            self.state[v] = target
+
+    def commit(self, query):
+        """Apply the popup on OK. With a search query: too-many -> "contains",
+        else filter TO the checked matches. Empty query: clear when everything's
+        checked and we truly know it's everything, else keep exactly the checked."""
+        query = query.strip()
+        if query:
+            rows = self.rows(query)
+            if self.truncated(rows):
+                self.model.set_text_filter(self.col, "contains", query)
+            else:
+                keep = {v for v in rows if self.checked(v)}
+                self.model.set_filter(self.col, keep or None)
+            return
+        known = set(self.preloaded) | set(self.state)
+        checked = {v for v in known if self.checked(v)}
+        if len(checked) == len(known) and (self.active is None or not self.capped):
+            self.model.set_filter(self.col, None)
+        else:
+            self.model.set_filter(self.col, checked)
+
+
+if __name__ == "__main__":   # headless self-check of the commit rules
+    from .model import GridModel
+    m = GridModel(["A"], [["x"], ["y"], ["x"], ["z"]])
+    f = FilterController(m, 0); f.load()
+    assert f.rows("") == ["x", "y", "z"], f.rows("")
+    assert f.all_on(f.rows(""))
+    f.toggle("y"); assert not f.checked("y")
+    f.commit("")                                    # keep exactly {x, z}
+    assert m._filters[0] == {"x", "z"}, m._filters
+    f2 = FilterController(m, 0); f2.load()          # everything checked -> clears
+    f2.toggle_all(f2.rows("")); assert f2.all_on(f2.rows(""))
+    # active filter present + not capped -> "all checked" clears it
+    f2.commit(""); assert 0 not in m._filters, m._filters
+    print("filter self-check ok")

fastgrid/core/find.py

@@ -0,0 +1,100 @@
+"""Ctrl+F find controller -- GUI-free search/navigation over model.find_matches.
+
+Both the Tk and Qt find bars drive this identical logic; only the surrounding
+widgets differ:
+
+  * highlight every matching cell (lazy, via model find-state) + a distinct
+    active-match marker;
+  * count reads "i/N" (or "i/N+" when the navigable list was capped, "No results",
+    or "" when the query is empty);
+  * Next/Prev wrap; the FIRST Enter lands on the highlighted nearest match rather
+    than skipping past it;
+  * nearest match is relative to the current cell (row-major >=);
+  * an optional scope (the selection, when it covers more than one cell) confines
+    the search and is KEPT visible while stepping (selection isn't collapsed);
+  * case-sensitivity toggle.
+
+The controller talks to the host grid through a tiny surface it already exposes:
+``.active``/``.anchor``/``.sel``/``.extra`` (selection state), ``.model`` and
+``.scroll_into_view(r, c)``. Highlight repaints happen via ``model.set_find`` /
+``model.clear_find`` (which fire the model's change callback -> the grid redraws).
+"""
+from .selection import normalize
+
+
+class FindController:
+    def __init__(self, grid):
+        self.grid = grid
+        self.model = grid.model
+        self.matches = []
+        self.idx = -1
+        self.capped = False
+        self.case = False
+        self.scope = None            # active scope rects, or None
+        self.scope_range = None      # scope captured at open() (for the toggle)
+        self.query = ""
+        self.current = (1, 0)        # anchor for nearest / "already on match"
+        self.on_count = lambda text: None    # the widget sets this to update its label
+
+    @staticmethod
+    def _scope_of(ranges):
+        """A meaningful scope = the selection when it covers more than one cell."""
+        rngs = normalize(ranges)
+        multi = len(rngs) > 1 or (rngs and (rngs[0][0] != rngs[0][2]
+                                            or rngs[0][1] != rngs[0][3]))
+        return rngs if multi else None
+
+    def open(self, ranges):
+        """Enter find: capture scope from the current selection, anchor nearest on
+        the active cell. Returns whether a scope is available (for the widget)."""
+        self.scope_range = self._scope_of(ranges)
+        self.scope = self.scope_range
+        self.current = tuple(self.grid.active)
+        self.query = ""
+        self.matches, self.idx = [], -1
+        self.run("", navigate=False)
+        return self.scope_range is not None
+
+    def run(self, query, navigate=False):
+        self.query = query
+        self.matches, self.capped = self.model.find_matches(query, self.case, self.scope)
+        if not self.matches:
+            self.idx = -1
+            self.on_count("No results" if query else "")
+            self.model.set_find(query, self.case, self.scope, None)
+            return
+        self.idx = next((i for i, c in enumerate(self.matches) if c >= self.current), 0)
+        self._activate(navigate)
+
+    def _activate(self, navigate):
+        cell = self.matches[self.idx]
+        self.on_count("%d/%d%s" % (self.idx + 1, len(self.matches), "+" if self.capped else ""))
+        if navigate:
+            self.current = cell
+            if self.scope is None:                       # collapse selection onto the match
+                self.grid.active = self.grid.anchor = cell
+                self.grid.sel, self.grid.extra = (cell[0], cell[1], cell[0], cell[1]), []
+            self.grid.scroll_into_view(*cell)            # scoped: keep selection, just reveal
+        self.model.set_find(self.query, self.case, self.scope, cell)   # highlight + redraw
+
+    def step(self, delta):
+        if not self.matches:
+            self.run(self.query, navigate=True)
+            return
+        if tuple(self.current) != tuple(self.matches[self.idx]):
+            self._activate(True)                         # first Enter lands on the match
+            return
+        self.idx = (self.idx + delta) % len(self.matches)
+        self._activate(True)
+
+    def set_case(self, on):
+        self.case = on
+        self.run(self.query, navigate=False)
+
+    def set_scope(self, on):
+        self.scope = self.scope_range if on else None
+        self.run(self.query, navigate=False)
+
+    def close(self):
+        self.matches, self.idx = [], -1
+        self.model.clear_find()