slikui-python 0.1.1__cp310-cp310-win32.whl

slikui/__init__.py

@@ -0,0 +1,115 @@
+"""slikui — Python bindings for the slikui C++ UI library.
+
+Distribution `slikui`, import package `slikui`, compiled module `slikui._slikui`.
+Layering: `_slikui` binds the C++ API 1:1; `slikui/_py` adds a thin Pythonic
+surface (kwargs → setters, App shell, pixel helpers). See
+docs/python-bindings-plan.md.
+"""
+
+from slikui._slikui import (  # noqa: F401 — re-exported
+    Accordion,
+    Button,
+    ButtonVariant,
+    Checkbox,
+    Color,
+    Column,
+    Container,
+    Context,
+    CrossMode,
+    DrawCmd,
+    DrawCmdType,
+    DrawList,
+    Divider,
+    Dropdown,
+    Expander,
+    IRenderSink,
+    Image,
+    ImageFit,
+    Label,
+    ListView,
+    Panel,
+    ProgressBar,
+    Radio,
+    RenderSink,
+    Row,
+    ScrollArea,
+    Sink,
+    Slider,
+    Spacer,
+    Spinner,
+    Swatch,
+    Switch,
+    Tabs,
+    Target,
+    TextArea,
+    TexFormat,
+    TextField,
+    Theme,
+    ThemePreset,
+    Time,
+    Vec2,
+    Widget,
+    apply_preset,
+    find_system_font,
+    theme_presets,
+    use_theme,
+)
+from slikui._py import builder
+from slikui._py.app import App
+from slikui._py.renderer import CanvasSink
+from slikui._py.events import (
+    focus_lost,
+    frame_resize,
+    key_press,
+    key_release,
+    mods,
+    mouse_click,
+    mouse_move,
+    mouse_press,
+    mouse_release,
+    scroll,
+    text_input,
+    text_input_str,
+)
+from slikui._py.pixels import to_rgba
+from slikui._slikui import (  # noqa: F401 — input enums
+    EventType,
+    Key,
+    Mod,
+    MouseButton,
+    set_leak_warnings,
+)
+
+from slikui._slikui import __version__  # from include/slikui/version.hpp
+
+# Pythonic sugar on the bound classes: `container.add(slikui.Label, "hi")` and
+# `ctx.set_root(slikui.Column)`. nanobind classes are heap types, so type-level
+# assignment is allowed; if a future build forbids it, use the module-level
+# helpers `slikui.add(container, ...)` / `slikui.set_root(context, ...)`.
+_PATCHED = builder.try_patch()
+
+__all__ = [
+    "Accordion", "App", "Button", "ButtonVariant", "Checkbox", "Color",
+    "Column", "Container", "Context", "CrossMode", "Divider", "Dropdown",
+    "Expander", "Image", "ImageFit", "Label", "ListView", "Panel",
+    "ProgressBar", "Radio", "Row", "ScrollArea", "Sink", "Slider",
+    "Spacer", "Spinner", "Swatch", "Switch", "Tabs", "Target", "TextArea",
+    "TextField", "Theme", "ThemePreset", "Time", "Vec2", "Widget",
+    "__version__", "add", "apply_preset", "find_system_font",
+    "set_root", "theme_presets", "to_rgba", "use_theme",
+    # events
+    "EventType", "Key", "Mod", "MouseButton",
+    "focus_lost", "frame_resize", "key_press", "key_release", "mods",
+    "mouse_click", "mouse_move", "mouse_press", "mouse_release",
+    "scroll", "text_input", "text_input_str",
+]
+
+
+def add(container, cls, *args, **props):
+    """Fallback for `container.add(cls, *args, **props)` if type patching is off."""
+    return builder.container_add(container, cls, *args, **props)
+
+
+def set_root(context, cls, *args, **props):
+    """Fallback for `context.set_root(cls, *args, **props)` if type patching is off."""
+    return builder.context_set_root(context, cls, *args, **props)

slikui/_py/app.py

@@ -0,0 +1,112 @@
+"""Headless app shell: Target + Sink + Context with conveniences.
+
+`App` holds every owner (target, sink, context), so the C++ side never sees a
+dangling backend even though the bindings are non-owning.
+"""
+
+import atexit
+import weakref
+
+from slikui._py.builder import context_set_root
+from slikui._slikui import Context, Sink, Target, find_system_font
+
+# Weakrefs of Apps waiting for an atexit close; pruned as refs die.
+_exit_close_refs = []
+
+
+def _register_exit_close(app):
+    """Run app.close() during interpreter shutdown, before module teardown.
+
+    Python-level atexit callbacks run while every module (slikui's extension
+    included) is still healthy. Waiting for App.__del__ is too late: nanobind
+    starts releasing its internals as soon as its module is freed during
+    module clearing, before __main__'s globals are collected. The weakref
+    keeps the App collectable; close() unregisters.
+    """
+    _exit_close_refs[:] = [r for r in _exit_close_refs if r() is not None]
+    ref = weakref.ref(app)
+    _exit_close_refs.append(ref)
+
+    def _close():
+        a = ref()
+        if a is not None:
+            try:
+                a.close()
+            except Exception:
+                pass
+
+    app._exit_close = _close
+    atexit.register(_close)
+
+
+class App:
+    def __init__(self, width, height, *, font=None, scale=1.0, theme=None):
+        self.width = int(width)
+        self.height = int(height)
+        self.scale = float(scale)
+        # Logical frame is width x height; the framebuffer carries the scale.
+        self.target = Target(int(self.width * self.scale), int(self.height * self.scale))
+        self.sink = Sink(self.target)
+        self.sink.set_scale(self.scale)
+        self.ctx = Context(self.sink)
+        self.ctx.set_frame_size(float(self.width), float(self.height))
+        if font is not None:
+            self.ctx.load_font_file(font)
+        elif not self.ctx.load_font_file(find_system_font()):
+            # No system font (minimal containers, e.g. manylinux): fall back
+            # to the bundled DejaVu Sans subset so text still renders.
+            self.ctx.load_default_font()
+        if theme is not None:
+            self.ctx.theme = theme
+        _register_exit_close(self)
+
+    def set_root(self, cls, *args, **props):
+        return context_set_root(self.ctx, cls, *args, **props)
+
+    def resize(self, width, height):
+        self.width, self.height = int(width), int(height)
+        self.target.resize(int(self.width * self.scale), int(self.height * self.scale))
+        self.ctx.set_frame_size(float(self.width), float(self.height))
+
+    def tick(self, now=0.0, dt=0.0):
+        self.ctx.tick(now, dt)
+
+    def handle(self, event):
+        self.ctx.handle(event)
+
+    def render(self, clear=True):
+        self.ctx.render(clear)
+        return self.target.pixels()  # zero-copy (H, W) uint32, ABGR packing
+
+    def close(self):
+        """Destroy the widget tree now, releasing the Python callbacks it holds.
+
+        A callback capturing a widget wrapper closes a cycle through C++
+        ownership that the GC cannot see; destroying the tree while the
+        interpreter is alive is what makes shutdown leak-free. Called
+        automatically by __exit__/__del__/atexit; safe to call twice.
+        """
+        self.ctx.clear_tree()
+        ec = getattr(self, "_exit_close", None)
+        if ec is not None:
+            atexit.unregister(ec)
+            self._exit_close = None
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc):
+        self.close()
+        return False
+
+    def __del__(self):
+        # Best effort: App is not part of any reference cycle (the cycle lives
+        # between the context wrapper and callbacks inside the C++ tree), so in
+        # the normal case this runs mid-interpreter and releases everything.
+        # At interpreter shutdown the same call is harmless but too late; GUI
+        # apps that keep their UI until exit can silence the report with
+        # slikui.set_leak_warnings(False).
+        try:
+            self.close()
+        except Exception:
+            pass

slikui/_py/builder.py

@@ -0,0 +1,37 @@
+"""kwargs → setters, and the `add`/`set_root` factories.
+
+No registry to keep in sync: a kwarg name `foo` resolves to the method
+`set_foo`, or to `foo` itself when there is no setter (e.g. `on_click=`).
+A wrong name is a loud AttributeError, not a silent no-op.
+"""
+
+
+def apply_props(widget, props):
+    for name, value in props.items():
+        fn = getattr(widget, f"set_{name}", None) or getattr(widget, name)
+        fn(value)
+    return widget
+
+
+def container_add(self, cls, *args, **props):
+    """self.add(slikui.Label, "hi", font_size=26) → construct + apply kwargs."""
+    fn = getattr(self, f"add_{cls.__name__.lower()}")
+    return apply_props(fn(*args), props)
+
+
+def context_set_root(self, cls, *args, **props):
+    """ctx.set_root(slikui.Column, padding=16) → construct + apply kwargs."""
+    fn = getattr(self, f"set_root_{cls.__name__.lower()}")
+    return apply_props(fn(*args), props)
+
+
+def try_patch():
+    """Attach `add`/`set_root` to the bound classes. True on success."""
+    try:
+        from slikui._slikui import Context, Widget
+
+        Widget.add = container_add  # inherited by every widget, incl. ScrollArea
+        Context.set_root = context_set_root
+        return True
+    except (AttributeError, TypeError):
+        return False

slikui/_py/events.py

@@ -0,0 +1,103 @@
+"""Friendly slikui::Event constructors — for tests, apps and window bridges.
+
+`Context.handle()` consumes these directly. Positions are logical points
+(Vec2-compatible pairs); `mods` accepts an int mask or a string like
+"ctrl+shift". A typical click is `mouse_press(p)` then `mouse_release(p)`.
+"""
+
+from slikui._slikui import Event, EventType, Key, Mod, MouseButton, Vec2
+
+_MOD_NAMES = {
+    "shift": int(Mod.ModShift),
+    "ctrl": int(Mod.ModCtrl),
+    "control": int(Mod.ModCtrl),
+    "alt": int(Mod.ModAlt),
+    "option": int(Mod.ModAlt),
+    "super": int(Mod.ModSuper),
+    "cmd": int(Mod.ModSuper),
+    "meta": int(Mod.ModSuper),
+}
+
+
+def mods(value) -> int:
+    """Int mask, or a string like "ctrl+shift" / "alt|cmd"."""
+    if value is None:
+        return 0
+    if isinstance(value, int):
+        return value
+    mask = 0
+    for part in str(value).replace("|", "+").split("+"):
+        name = part.strip().lower()
+        if name:
+            mask |= _MOD_NAMES[name]
+    return mask
+
+
+def mouse_move(pos, delta=(0.0, 0.0)):
+    e = Event(EventType.MouseMove)
+    e.pos = Vec2(*pos)
+    e.delta = Vec2(*delta)
+    return e
+
+
+def mouse_press(pos, button=MouseButton.MouseLeft, mods_=0):
+    e = Event(EventType.MousePress)
+    e.pos = Vec2(*pos)
+    e.button = int(button)
+    e.mods = mods(mods_)
+    return e
+
+
+def mouse_release(pos, button=MouseButton.MouseLeft, mods_=0):
+    e = Event(EventType.MouseRelease)
+    e.pos = Vec2(*pos)
+    e.button = int(button)
+    e.mods = mods(mods_)
+    return e
+
+
+def mouse_click(pos, button=MouseButton.MouseLeft, mods_=0):
+    """Press + release pair at `pos`."""
+    return (mouse_press(pos, button, mods_), mouse_release(pos, button, mods_))
+
+
+def scroll(pos, ticks):
+    e = Event(EventType.Scroll)
+    e.pos = Vec2(*pos)
+    e.scroll = Vec2(*ticks)
+    return e
+
+
+def key_press(key, mods_=0):
+    e = Event(EventType.KeyPress)
+    e.key = key
+    e.mods = mods(mods_)
+    return e
+
+
+def key_release(key, mods_=0):
+    e = Event(EventType.KeyRelease)
+    e.key = key
+    e.mods = mods(mods_)
+    return e
+
+
+def text_input(char: str):
+    e = Event(EventType.TextInput)
+    e.codepoint = ord(char)
+    return e
+
+
+def text_input_str(text: str):
+    """One TextInput event per Unicode scalar."""
+    return [text_input(ch) for ch in text]
+
+
+def focus_lost():
+    return Event(EventType.FocusLost)
+
+
+def frame_resize(width, height):
+    e = Event(EventType.FrameResize)
+    e.pos = Vec2(float(width), float(height))
+    return e

slikui/_py/pixels.py

@@ -0,0 +1,17 @@
+"""Pixel helpers.
+
+slikui frames are `(H, W) uint32` in ABGR packing — 0xAABBGGRR values, i.e.
+little-endian byte order B, G, R, A. `to_rgba` converts to the conventional
+(H, W, 4) uint8 RGBA layout (a copy; the raw view is the zero-cost path).
+"""
+
+import numpy as np
+
+
+def to_rgba(frame):
+    frame = np.asarray(frame)
+    r = frame & 0xFF
+    g = (frame >> 8) & 0xFF
+    b = (frame >> 16) & 0xFF
+    a = (frame >> 24) & 0xFF
+    return np.stack([r, g, b, a], axis=-1).astype(np.uint8, copy=False)

slikui/_py/renderer.py

@@ -0,0 +1,329 @@
+"""CanvasSink — a pure-Python (numpy) renderer implementing the slikui contract.
+
+This is the "your renderer" seam: subclass `slikui.RenderSink`, and slikui hands
+you every frame as a flat command list (Rect/Line/Glyph/Image/ClipPush/ClipPop)
+plus texture uploads. CanvasSink rasterizes that list into a numpy uint32
+buffer with the exact same math as the C++ software backend in
+`include/slikui/backends/software/software.hpp` — same blend formula, same SDF
+coverage, same sampling — so frames come out pixel-identical.
+
+Pixel format: 0xAABBGGRR uint32, straight alpha, row-major (H, W).
+
+Usage:
+    sink = CanvasSink(320, 240)
+    ctx = slikui.Context(sink)
+    ctx.set_frame_size(320, 240)
+    ctx.load_font_file(slikui.find_system_font())
+    ...
+    ctx.tick(0.0, 1 / 60)
+    ctx.render()          # slikui calls sink.upload/render with the draw list
+    frame = sink.buffer   # (240, 320) uint32 view
+
+Coordinates: DrawList commands are logical points; `set_scale(s)` maps them
+to device pixels exactly like software.Sink (HiDPI).
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+from slikui._slikui import DrawCmdType, RenderSink, TexFormat
+
+_F32 = np.float32
+_U32 = np.uint32
+
+
+def _clamp01(v):
+    # C++ clamp01: v < 0 ? 0 : (v > 1 ? 1 : v)
+    return np.where(v < _F32(0), _F32(0), np.where(v > _F32(1), _F32(1), v))
+
+
+def _sd_rounded_box(px, py, bx, by, r):
+    """Approximate SDF of a rounded box, half-extents (bx, by), radius r.
+
+    Mirrors detail::sd_rounded_box operation-for-operation (float32) so edge
+    coverage matches the C++ rasterizer bit for bit.
+    """
+    qx = np.abs(px) - (bx - r)
+    qy = np.abs(py) - (by - r)
+    ax = np.maximum(qx, _F32(0))
+    ay = np.maximum(qy, _F32(0))
+    outside = np.sqrt(ax * ax + ay * ay)
+    return (outside + np.minimum(np.maximum(qx, qy), _F32(0))) - r
+
+
+def _intersect(ax, ay, aw, ah, bx, by, bw, bh):
+    # Rect::intersect in float32
+    nx = np.maximum(ax, bx)
+    ny = np.maximum(ay, by)
+    nr = np.minimum(ax + aw, bx + bw)
+    nb = np.minimum(ay + ah, by + bh)
+    return nx, ny, np.maximum(_F32(0), nr - nx), np.maximum(_F32(0), nb - ny)
+
+
+class CanvasSink(RenderSink):
+    """Software renderer in numpy. Subclass of slikui.RenderSink."""
+
+    def __init__(self, width, height, *, scale=1.0):
+        super().__init__()
+        self._scale = _F32(scale)
+        self._buf = np.zeros((int(height), int(width)), np.uint32)
+        self._textures = {}  # id -> (h, w) or (h, w, 4) uint8
+        self._clips = []     # list of (x, y, w, h) float32
+
+    # -- surface ------------------------------------------------------------
+
+    @property
+    def buffer(self):
+        """The (H, W) uint32 framebuffer, 0xAABBGGRR. Zero-copy view."""
+        return self._buf
+
+    @property
+    def width(self):
+        return self._buf.shape[1]
+
+    @property
+    def height(self):
+        return self._buf.shape[0]
+
+    def resize(self, width, height):
+        self._buf = np.zeros((int(height), int(width)), np.uint32)
+
+    def set_scale(self, scale):
+        self._scale = _F32(scale)
+
+    @property
+    def scale(self):
+        return float(self._scale)
+
+    # -- IRenderSink ---------------------------------------------------------
+
+    def upload(self, up):
+        n = up.width * up.height * (4 if up.format == TexFormat.Rgba8 else 1)
+        data = np.frombuffer(bytes(up.pixels), np.uint8, n).copy()
+        if up.format == TexFormat.Rgba8:
+            data = data.reshape(up.height, up.width, 4)
+        else:
+            data = data.reshape(up.height, up.width)
+        self._textures[up.id] = data
+
+    def render(self, cmds, framebuffer_size):
+        self._clips = [(_F32(0), _F32(0), _F32(self.width), _F32(self.height))]
+        for c in cmds:
+            self._execute(c)
+
+    # -- command dispatch -----------------------------------------------------
+
+    def _execute(self, c):
+        s = self._scale
+        x = _F32(c.rect.x) * s
+        y = _F32(c.rect.y) * s
+        w = _F32(c.rect.w) * s
+        h = _F32(c.rect.h) * s
+        t = c.type
+        if t == DrawCmdType.ClipPush:
+            self._clips.append(_intersect(x, y, w, h, *self._clips[-1]))
+        elif t == DrawCmdType.ClipPop:
+            if len(self._clips) > 1:
+                self._clips.pop()
+        elif t == DrawCmdType.Rect:
+            if c.hollow:
+                self._stroke_rect(x, y, w, h, c.color,
+                                  _F32(c.thickness) * s, _F32(c.radius) * s)
+            else:
+                self._fill_rect(x, y, w, h, c.color, _F32(c.radius) * s)
+        elif t == DrawCmdType.Line:
+            self._stroke_line(x, y, w, h, c.color, _F32(c.thickness) * s)
+        elif t == DrawCmdType.Glyph:
+            self._draw_glyph(c, x, y, w, h)
+        elif t == DrawCmdType.Image:
+            self._draw_image(c, x, y, w, h)
+
+    # -- blending --------------------------------------------------------------
+
+    def _blend(self, X, Y, mask, sr, sg, sb, sa):
+        """C++ blend() over selected pixels.
+
+        sr..sa: scalar _U32 or full-grid arrays (per-pixel src color/alpha);
+        anything array-valued is masked down to the selected pixels here.
+        """
+        mask = mask & (X >= 0) & (Y >= 0) & (X < self.width) & (Y < self.height)
+        if not mask.any():
+            return
+        ys = np.broadcast_to(Y, mask.shape)[mask]
+        xs = np.broadcast_to(X, mask.shape)[mask]
+        dst = self._buf[ys, xs]
+        dr = dst & _U32(0xFF)
+        dg = (dst >> _U32(8)) & _U32(0xFF)
+        db = (dst >> _U32(16)) & _U32(0xFF)
+        da = dst >> _U32(24)
+        sr, sg, sb, sa = (_v[mask] if np.ndim(_v) else _v
+                          for _v in (sr, sg, sb, sa))
+        ia = _U32(255) - sa
+        # (s*a + d*ia + 127) / 255 with uint32 floor division == C++ integer math
+        out_r = (sr * sa + dr * ia + _U32(127)) // _U32(255)
+        out_g = (sg * sa + dg * ia + _U32(127)) // _U32(255)
+        out_b = (sb * sa + db * ia + _U32(127)) // _U32(255)
+        out_a = sa + da * ia // _U32(255)
+        self._buf[ys, xs] = (
+            (out_a << _U32(24)) | (out_b << _U32(16)) |
+            (out_g << _U32(8)) | out_r)
+
+    def _faded_alpha(self, color_a, f):
+        """Color::faded: with_alpha(clamp01(a/255 * f)) -> uint8 (truncating)."""
+        a = (_F32(color_a) / _F32(255)) * f
+        a = np.minimum(np.maximum(a, _F32(0)), _F32(1))
+        return (_F32(255) * a).astype(np.uint8)
+
+    # -- primitives --------------------------------------------------------------
+
+    def _grid(self, y0, y1, x0, x1):
+        """Inclusive integer pixel grid as broadcastable (Y, X) int64 arrays."""
+        Y = np.arange(int(y0), int(y1) + 1, dtype=np.int64)[:, None]
+        X = np.arange(int(x0), int(x1) + 1, dtype=np.int64)[None, :]
+        return Y, X
+
+    def _clip_mask(self, X, Y):
+        cx, cy, cw, ch = self._clips[-1]
+        return (X >= cx) & (X < cx + cw) & (Y >= cy) & (Y < cy + ch)
+
+    def _full_mask(self, X, Y):
+        return np.ones(np.broadcast_shapes(Y.shape, X.shape), dtype=bool)
+
+    def _fill_rect(self, x, y, w, h, color, radius):
+        clip = self._clips[-1]
+        x, y, w, h = _intersect(x, y, w, h, *clip)
+        if w <= 0 or h <= 0:
+            return
+        if radius <= 0:
+            # NOTE: matches C++ exactly — the fast path loops from int(r.x)
+            # with no per-pixel clip check, so a fractional origin paints the
+            # pixel below clip.x too. Quirk kept on purpose.
+            Y, X = self._grid(y, np.ceil(y + h) - 1, x, np.ceil(x + w) - 1)
+            self._blend(X, Y, self._full_mask(X, Y),
+                        _U32(color.r), _U32(color.g), _U32(color.b),
+                        _U32(color.a))
+            return
+        # Per-pixel SDF coverage (this path does check the clip per pixel).
+        Y, X = self._grid(y - 1, np.ceil(y + h), x - 1, np.ceil(x + w))
+        px = (X.astype(_F32) + _F32(0.5) - x) - w * _F32(0.5)
+        py = (Y.astype(_F32) + _F32(0.5) - y) - h * _F32(0.5)
+        d = _sd_rounded_box(px, py, w * _F32(0.5), h * _F32(0.5), radius)
+        cov = _clamp01(_F32(0.5) - d)
+        mask = (cov > _F32(0)) & self._clip_mask(X, Y)
+        sa = self._faded_alpha(color.a, cov).astype(_U32)
+        self._blend(X, Y, mask, _U32(color.r), _U32(color.g), _U32(color.b), sa)
+
+    def _stroke_rect(self, x, y, w, h, color, thickness, radius):
+        inner_r = np.maximum(radius - thickness, _F32(0))
+        Y, X = self._grid(y - 1, np.ceil(y + h), x - 1, np.ceil(x + w))
+        px = (X.astype(_F32) + _F32(0.5) - x) - w * _F32(0.5)
+        py = (Y.astype(_F32) + _F32(0.5) - y) - h * _F32(0.5)
+        d_out = _sd_rounded_box(px, py, w * _F32(0.5), h * _F32(0.5), radius)
+        bi_x = np.maximum(w * _F32(0.5) - thickness, _F32(0))
+        bi_y = np.maximum(h * _F32(0.5) - thickness, _F32(0))
+        d_in = _sd_rounded_box(px, py, bi_x, bi_y, inner_r)
+        cov = _clamp01(_F32(0.5) - d_out) * _clamp01(_F32(0.5) + d_in)
+        mask = (cov > _F32(0)) & self._clip_mask(X, Y)
+        sa = self._faded_alpha(color.a, cov).astype(_U32)
+        self._blend(X, Y, mask, _U32(color.r), _U32(color.g), _U32(color.b), sa)
+
+    def _stroke_line(self, x, y, dx, dy, color, thickness):
+        ax, ay = x, y
+        bx = x + dx
+        by = y + dy
+        half = thickness * _F32(0.5)
+        bx0 = np.minimum(ax, bx) - half - _F32(1)
+        by0 = np.minimum(ay, by) - half - _F32(1)
+        bw = np.abs(bx - ax) + _F32(2) * half + _F32(2)
+        bh = np.abs(by - ay) + _F32(2) * half + _F32(2)
+        cx, cy, cw, ch = self._clips[-1]
+        bx0, by0, bw, bh = _intersect(bx0, by0, bw, bh, cx, cy, cw, ch)
+        Y, X = self._grid(by0, np.ceil(by0 + bh), bx0, np.ceil(bx0 + bw))
+        px = X.astype(_F32) + _F32(0.5)
+        py = Y.astype(_F32) + _F32(0.5)
+        ddx = bx - ax
+        ddy = by - ay
+        len2 = ddx * ddx + ddy * ddy
+        with np.errstate(divide="ignore", invalid="ignore"):
+            t = ((px - ax) * ddx + (py - ay) * ddy) / len2
+        t = np.where(len2 > _F32(0), t, _F32(0))
+        t = _clamp01(t)
+        proj_x = ax + ddx * t
+        proj_y = ay + ddy * t
+        dist = np.sqrt((px - proj_x) * (px - proj_x) +
+                       (py - proj_y) * (py - proj_y))
+        cov = _clamp01((half + _F32(0.5)) - dist)
+        mask = cov > _F32(0)
+        sa = self._faded_alpha(color.a, cov).astype(_U32)
+        self._blend(X, Y, mask, _U32(color.r), _U32(color.g), _U32(color.b), sa)
+
+    def _uv_maps(self, c, x, y, w, h, X, Y):
+        # shared uv math for glyph/image: sample point from pixel center
+        fx = X.astype(_F32) + _F32(0.5)
+        fy = Y.astype(_F32) + _F32(0.5)
+        u = _F32(c.uv.x) + ((fx - x) / w) * _F32(c.uv.w)
+        v = _F32(c.uv.y) + ((fy - y) / h) * _F32(c.uv.h)
+        return u, v
+
+    def _draw_glyph(self, c, x, y, w, h):
+        tex = self._textures.get(c.tex_id)
+        if tex is None or c.uv.w <= 0 or c.uv.h <= 0:
+            return
+        clip = self._clips[-1]
+        cx, cy, cw, ch = _intersect(x, y, w, h, *clip)
+        if cw <= 0 or ch <= 0:
+            return
+        Y, X = self._grid(cy, np.ceil(cy + ch) - 1, cx, np.ceil(cx + cw) - 1)
+        u, v = self._uv_maps(c, x, y, w, h, X, Y)
+        alpha = self._sample_alpha(tex, u, v)
+        # Color c = cmd.color.faded(a.a / 255); blend only where a > 0.
+        f = alpha.astype(_F32) / _F32(255)
+        sa = self._faded_alpha(c.color.a, f).astype(_U32)
+        mask = sa > _U32(0)
+        self._blend(X, Y, mask, _U32(c.color.r), _U32(c.color.g),
+                    _U32(c.color.b), sa)
+
+    def _sample_alpha(self, tex, u, v):
+        """detail::sample_alpha — bilinear alpha, clamped, rounded (+0.5)."""
+        th, tw = tex.shape
+        fx = np.maximum(np.minimum(u, _F32(tw - 1)), _F32(0))
+        fy = np.maximum(np.minimum(v, _F32(th - 1)), _F32(0))
+        x0 = fx.astype(np.int64)
+        y0 = fy.astype(np.int64)
+        x1 = np.minimum(x0 + 1, tw - 1)
+        y1 = np.minimum(y0 + 1, th - 1)
+        tx = fx - x0.astype(_F32)
+        ty = fy - y0.astype(_F32)
+        a00 = tex[y0, x0].astype(_F32)
+        a10 = tex[y0, x1].astype(_F32)
+        a01 = tex[y1, x0].astype(_F32)
+        a11 = tex[y1, x1].astype(_F32)
+        a = (a00 * (_F32(1) - tx) + a10 * tx) * (_F32(1) - ty) + \
+            (a01 * (_F32(1) - tx) + a11 * tx) * ty
+        return (a + _F32(0.5)).astype(np.uint8)
+
+    def _draw_image(self, c, x, y, w, h):
+        tex = self._textures.get(c.tex_id)
+        if tex is None:
+            return
+        clip = self._clips[-1]
+        cx, cy, cw, ch = _intersect(x, y, w, h, *clip)
+        if cw <= 0 or ch <= 0:
+            return
+        Y, X = self._grid(cy, np.ceil(cy + ch) - 1, cx, np.ceil(cx + cw) - 1)
+        u, v = self._uv_maps(c, x, y, w, h, X, Y)
+        if tex.ndim == 3:
+            # Rgba8: nearest sample, blend the texel's own color/alpha.
+            th, tw = tex.shape[:2]
+            sx = np.clip(u.astype(np.int64), 0, tw - 1)
+            sy = np.clip(v.astype(np.int64), 0, th - 1)
+            px = tex[sy, sx]
+            self._blend(X, Y, self._full_mask(X, Y),
+                        px[..., 0].astype(_U32), px[..., 1].astype(_U32),
+                        px[..., 2].astype(_U32), px[..., 3].astype(_U32))
+        else:
+            # Alpha8 image: white with the sampled alpha (sample_alpha path).
+            alpha = self._sample_alpha(tex, u, v)
+            self._blend(X, Y, alpha > 0, _U32(255), _U32(255), _U32(255),
+                        alpha.astype(_U32))

slikui_python-0.1.1.dist-info/METADATA

@@ -0,0 +1,112 @@
+Metadata-Version: 2.4
+Name: slikui-python
+Version: 0.1.1
+Summary: Python bindings for slikui — a header-only C++20 UI library
+Author: slikui contributors
+License-Expression: MIT
+License-File: LICENSE
+License-File: third_party/fonts/LICENSE-DejaVu.txt
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: User Interfaces
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Project-URL: Homepage, https://github.com/jamesgregson/slikui
+Project-URL: Documentation, https://github.com/jamesgregson/slikui/tree/main/python
+Requires-Python: >=3.10
+Requires-Dist: numpy>=1.24
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
+Provides-Extra: demo
+Requires-Dist: glfw>=2.5; extra == "demo"
+Requires-Dist: PyOpenGL; extra == "demo"
+Description-Content-Type: text/markdown
+
+# slikui — Python bindings for slikui
+
+Install from PyPI · import `slikui` · compiled module `slikui._slikui`.
+
+```sh
+pip install slikui-python
+```
+
+pip picks the wheel matching your OS, CPU and Python (3.10–3.14 on Linux
+x86_64/aarch64, macOS arm64, Windows x64). No wheel for your platform (e.g.
+Intel macOS)? pip builds from the sdist instead — that needs a C++20 compiler.
+
+The same wheels and sdist are attached to every
+[GitHub Release](https://github.com/jamesgregson/slikui/releases).
+
+Headless, testable UI: the software rasterizer renders into a `numpy`
+framebuffer — no window, no GPU, no event loop required.
+
+```python
+import slikui
+
+ui = slikui.App(320, 200)                     # Target + Sink + Context + font (system, else bundled)
+root = ui.set_root(slikui.Column, padding=16, gap=8)
+root.add(slikui.Label, "Hello, slikui!", font_size=26)
+root.add(slikui.Button, "Save", variant=slikui.ButtonVariant.Primary)
+
+ui.tick(0.0, 1 / 60)                        # layout + animation
+frame = ui.render()                         # zero-copy np.ndarray (H, W) uint32
+```
+
+`App.close()` — also run by `with App(...)` and automatically at exit —
+destroys the tree and releases Python callbacks it holds, so shutdown is
+leak-free even when callbacks capture widget wrappers.
+
+Build from source (the C++ side is header-only, nothing to link):
+
+```
+pip install -e .                # editable, into your venv — from the repo root
+python -m pytest python/tests   # 38 tests: widgets, events, renderer parity
+python python/examples/hello.py # writes hello.ppm
+```
+
+Events are first-class: build slikui events in Python and drive the real
+dispatch path (see `python/tests/test_events.py`):
+
+```python
+ui.handle(slikui.mouse_press((60, 40)))   # click through hit-testing
+ui.handle(slikui.text_input("h"))         # into the focused TextField
+ui.handle(slikui.scroll(pos, (0, -1)))    # wheel, "ctrl+shift" mods supported
+```
+
+Interactive demo — a Python-native GLFW + OpenGL host with the slikui software
+rasterizer as the UI layer (`pip install glfw PyOpenGL`):
+
+```
+python python/examples/glfw_demo.py
+```
+
+Lit cube/sphere/torus over a procedural sky; the controls panel is rasterized
+on the CPU into a `uint32` buffer and blended over the GL scene as one
+texture. Drag orbits, wheel zooms, the panel edits material/sky/light/camera.
+
+**Your own renderer.** `slikui.RenderSink` is a trampoline over C++
+`IRenderSink`: subclass it, implement `upload(tex)` and `render(commands,
+fb_size)`, and slikui hands you every frame as a flat command list — point it at
+pygame, moderngl, PIL, anything. `slikui.CanvasSink` is a worked example: a
+pure-numpy rasterizer that produces **pixel-identical** output to the C++
+software backend (same blend/SDF/sampling math, verified by test):
+
+```python
+sink = slikui.CanvasSink(320, 240)
+ctx = slikui.Context(sink)          # any RenderSink subclass works here
+ctx.set_frame_size(320, 240)
+ctx.load_default_font()           # bundled DejaVu Sans subset; or load_font_file(path)
+# ... build the tree, tick ...
+ctx.render()
+frame = sink.buffer               # (240, 320) uint32, 0xAABBGGRR
+```
+
+See it side by side: `python python/examples/pyrenderer_demo.py` renders one
+tree through both renderers and reports the pixel diff (it is 0).
+
+Design and milestones: `docs/python-bindings-plan.md` — M0 (values, software
+backend, core widgets), M1 (full widget surface + themes) and M2 (events,
+popups, tooltips, simulated-input tests) are done; M3 (wheels/CI/docs) and
+M4 (GLFW+GL backend bindings) are tabled.

slikui_python-0.1.1.dist-info/RECORD

@@ -0,0 +1,14 @@
+slikui/__init__.py,sha256=LsRYckcm820yzbx1cR5y2WpbblL4NcrWSOM421sPnFg,3230
+slikui/_py/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+slikui/_py/app.py,sha256=-1mLfkHDRHoFeD4_h4AjpbmswOJ_iaTLc77KZdNwg00,4211
+slikui/_py/builder.py,sha256=gv5cyd3iT0msvDYlxxqsK_RYZ8u0a4BhiiJn-OHDfdk,1305
+slikui/_py/events.py,sha256=AyRu0G8zkr6vYSMLn1RTROzmMWasOVuW5YzpiQR0ziw,2584
+slikui/_py/pixels.py,sha256=wAjVtVxoYFbP-qGj-CtWdCak4bIhXawBTSGqQafO2Qw,519
+slikui/_py/renderer.py,sha256=21dfP0uXuMCu_Ya51qu3-6Xu8c7m5iRMuMfFc0dBm5A,13801
+slikui/_slikui.cp310-win32.pyd,sha256=CP6uZ1aCFe8HRC2mJB9jDSzcByK0_gAcH03RFpSegp4,435200
+slikui/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+slikui_python-0.1.1.dist-info/METADATA,sha256=TwSE-2_hNCPt8oepRBOmwPO5zUIPEPfH-IZAltCP478,4583
+slikui_python-0.1.1.dist-info/WHEEL,sha256=WR2gNbyWAK2A1soqGQb-YCxatrzCZ2LAO6P0FLTYzyQ,101
+slikui_python-0.1.1.dist-info/licenses/LICENSE,sha256=aBfC36-nE3my79yfCCxAgso5fE_miKCKPmwr2aWLKtU,1097
+slikui_python-0.1.1.dist-info/licenses/third_party/fonts/LICENSE-DejaVu.txt,sha256=PxoRvJmiHdti0OufPtLhtTDtEyMPx55apovioKGoCC8,9003
+slikui_python-0.1.1.dist-info/RECORD,,

slikui_python-0.1.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: scikit-build-core 1.1.2
+Root-Is-Purelib: false
+Tag: cp310-cp310-win32
+

slikui_python-0.1.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 slikui contributors
+
+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.

slikui_python-0.1.1.dist-info/licenses/third_party/fonts/LICENSE-DejaVu.txt

@@ -0,0 +1,187 @@
+Fonts are (c) Bitstream (see below). DejaVu changes are in public domain.
+Glyphs imported from Arev fonts are (c) Tavmjong Bah (see below)
+
+
+Bitstream Vera Fonts Copyright
+------------------------------
+
+Copyright (c) 2003 by Bitstream, Inc. All Rights Reserved. Bitstream Vera is
+a trademark of Bitstream, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of the fonts accompanying this license ("Fonts") and associated
+documentation files (the "Font Software"), to reproduce and distribute the
+Font Software, including without limitation the rights to use, copy, merge,
+publish, distribute, and/or sell copies of the Font Software, and to permit
+persons to whom the Font Software is furnished to do so, subject to the
+following conditions:
+
+The above copyright and trademark notices and this permission notice shall
+be included in all copies of one or more of the Font Software typefaces.
+
+The Font Software may be modified, altered, or added to, and in particular
+the designs of glyphs or characters in the Fonts may be modified and
+additional glyphs or characters may be added to the Fonts, only if the fonts
+are renamed to names not containing either the words "Bitstream" or the word
+"Vera".
+
+This License becomes null and void to the extent applicable to Fonts or Font
+Software that has been modified and is distributed under the "Bitstream
+Vera" names.
+
+The Font Software may be sold as part of a larger software package but no
+copy of one or more of the Font Software typefaces may be sold by itself.
+
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF COPYRIGHT, PATENT,
+TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL BITSTREAM OR THE GNOME
+FOUNDATION BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, INCLUDING
+ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER DEALINGS IN THE
+FONT SOFTWARE.
+
+Except as contained in this notice, the names of Gnome, the Gnome
+Foundation, and Bitstream Inc., shall not be used in advertising or
+otherwise to promote the sale, use or other dealings in this Font Software
+without prior written authorization from the Gnome Foundation or Bitstream
+Inc., respectively. For further information, contact: fonts at gnome dot
+org.
+
+Arev Fonts Copyright
+------------------------------
+
+Copyright (c) 2006 by Tavmjong Bah. All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the fonts accompanying this license ("Fonts") and
+associated documentation files (the "Font Software"), to reproduce
+and distribute the modifications to the Bitstream Vera Font Software,
+including without limitation the rights to use, copy, merge, publish,
+distribute, and/or sell copies of the Font Software, and to permit
+persons to whom the Font Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright and trademark notices and this permission notice
+shall be included in all copies of one or more of the Font Software
+typefaces.
+
+The Font Software may be modified, altered, or added to, and in
+particular the designs of glyphs or characters in the Fonts may be
+modified and additional glyphs or characters may be added to the
+Fonts, only if the fonts are renamed to names not containing either
+the words "Tavmjong Bah" or the word "Arev".
+
+This License becomes null and void to the extent applicable to Fonts
+or Font Software that has been modified and is distributed under the 
+"Tavmjong Bah Arev" names.
+
+The Font Software may be sold as part of a larger software package but
+no copy of one or more of the Font Software typefaces may be sold by
+itself.
+
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL
+TAVMJONG BAH BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.
+
+Except as contained in this notice, the name of Tavmjong Bah shall not
+be used in advertising or otherwise to promote the sale, use or other
+dealings in this Font Software without prior written authorization
+from Tavmjong Bah. For further information, contact: tavmjong @ free
+. fr.
+
+TeX Gyre DJV Math
+-----------------
+Fonts are (c) Bitstream (see below). DejaVu changes are in public domain.
+
+Math extensions done by B. Jackowski, P. Strzelczyk and P. Pianowski
+(on behalf of TeX users groups) are in public domain.
+
+Letters imported from Euler Fraktur from AMSfonts are (c) American
+Mathematical Society (see below).
+Bitstream Vera Fonts Copyright
+Copyright (c) 2003 by Bitstream, Inc. All Rights Reserved. Bitstream Vera
+is a trademark of Bitstream, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of the fonts accompanying this license (“Fonts”) and associated
+documentation
+files (the “Font Software”), to reproduce and distribute the Font Software,
+including without limitation the rights to use, copy, merge, publish,
+distribute,
+and/or sell copies of the Font Software, and to permit persons  to whom
+the Font Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright and trademark notices and this permission notice
+shall be
+included in all copies of one or more of the Font Software typefaces.
+
+The Font Software may be modified, altered, or added to, and in particular
+the designs of glyphs or characters in the Fonts may be modified and
+additional
+glyphs or characters may be added to the Fonts, only if the fonts are
+renamed
+to names not containing either the words “Bitstream” or the word “Vera”.
+
+This License becomes null and void to the extent applicable to Fonts or
+Font Software
+that has been modified and is distributed under the “Bitstream Vera”
+names.
+
+The Font Software may be sold as part of a larger software package but
+no copy
+of one or more of the Font Software typefaces may be sold by itself.
+
+THE FONT SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF COPYRIGHT, PATENT,
+TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL BITSTREAM OR THE GNOME
+FOUNDATION
+BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, INCLUDING ANY GENERAL,
+SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, WHETHER IN AN
+ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF THE USE OR
+INABILITY TO USE
+THE FONT SOFTWARE OR FROM OTHER DEALINGS IN THE FONT SOFTWARE.
+Except as contained in this notice, the names of GNOME, the GNOME
+Foundation,
+and Bitstream Inc., shall not be used in advertising or otherwise to promote
+the sale, use or other dealings in this Font Software without prior written
+authorization from the GNOME Foundation or Bitstream Inc., respectively.
+For further information, contact: fonts at gnome dot org.
+
+AMSFonts (v. 2.2) copyright
+
+The PostScript Type 1 implementation of the AMSFonts produced by and
+previously distributed by Blue Sky Research and Y&Y, Inc. are now freely
+available for general use. This has been accomplished through the
+cooperation
+of a consortium of scientific publishers with Blue Sky Research and Y&Y.
+Members of this consortium include:
+
+Elsevier Science IBM Corporation Society for Industrial and Applied
+Mathematics (SIAM) Springer-Verlag American Mathematical Society (AMS)
+
+In order to assure the authenticity of these fonts, copyright will be
+held by
+the American Mathematical Society. This is not meant to restrict in any way
+the legitimate use of the fonts, such as (but not limited to) electronic
+distribution of documents containing these fonts, inclusion of these fonts
+into other public domain or commercial font collections or computer
+applications, use of the outline data to create derivative fonts and/or
+faces, etc. However, the AMS does require that the AMS copyright notice be
+removed from any derivative versions of the fonts which have been altered in
+any way. In addition, to ensure the fidelity of TeX documents using Computer
+Modern fonts, Professor Donald Knuth, creator of the Computer Modern faces,
+has requested that any alterations which yield different font metrics be
+given a different name.
+
+$Id$