pane-ui 0.1.0__tar.gz

pane_ui-0.1.0/LICENSE

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

pane_ui-0.1.0/PKG-INFO

@@ -0,0 +1,107 @@
+Metadata-Version: 2.4
+Name: pane-ui
+Version: 0.1.0
+Summary: Python bindings for Pane, a modern minimalist Windows UI engine built on WPF
+Author: Hunter
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/HunterH1218/pane
+Project-URL: Repository, https://github.com/HunterH1218/pane
+Project-URL: Issues, https://github.com/HunterH1218/pane/issues
+Keywords: wpf,windows,ui,gui,desktop,pythonnet
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: C#
+Classifier: Topic :: Software Development :: User Interfaces
+Classifier: Topic :: Software Development :: Widget Sets
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pythonnet>=3.0
+Dynamic: license-file
+
+# pane
+
+Python bindings for [Pane](https://github.com/HunterH1218/pane) — a modern, minimalist
+Windows UI engine built on WPF. Build real native Windows app UIs from Python:
+buttons, checkboxes, sliders, text input, tabs, live light/dark theming and
+accent-color switching, all with a single custom-chrome window.
+
+The engine itself is C#/WPF; this package drives it in-process via
+[pythonnet](https://pythonnet.github.io/), so widgets are the real native
+controls, not a re-implementation.
+
+**Windows only** (WPF has no cross-platform equivalent). Requires the free
+[.NET 8 Desktop Runtime](https://dotnet.microsoft.com/download/dotnet/8.0) —
+not the SDK, just the runtime.
+
+## Install
+
+```
+pip install pane-ui
+```
+
+## Quick start
+
+```python
+import pane
+
+def build(window):
+    window.Content = pane.stack(
+        pane.text("Hello from Python", size="title", bold=True),
+        pane.button("Click me", style="primary", on_click=lambda: print("clicked!")),
+        pane.checkbox("Enable notifications", checked=True),
+        spacing=12,
+        margin=24,
+    )
+
+pane.run(build, title="My App")
+```
+
+Run the full widget gallery from the source repo for a tour of everything
+available: `python examples/gallery.py`.
+
+## Widgets
+
+`button`, `checkbox`, `radio_button`, `toggle_switch`, `text_box`,
+`password_box`, `progress_bar`, `slider`, `combo_box`, `list_box`, `nav_list`,
+`tab_control`, `expander`, `group_box`, `separator`, `text`, plus
+`set_tooltip` / `set_context_menu` helpers.
+
+## Layout
+
+`stack(*children, orientation=, spacing=, margin=)`,
+`grid(children, rows=, columns=)`, `card(*children)`, `sidebar(*children)`,
+`scroll(child)`.
+
+## Theming
+
+```python
+pane.set_theme("light")        # or "dark"
+pane.toggle_theme()
+pane.set_accent("#4C82F7")     # hex string or (r, g, b) tuple
+pane.reset_accent()
+```
+
+Every widget re-themes live, mid-run, no restart needed.
+
+## Events
+
+Callbacks adapt to whatever you write - zero args or one:
+
+```python
+pane.button("Save", on_click=lambda: print("saved"))
+pane.slider(on_change=lambda value: print(value))
+```
+
+## Threading
+
+`pane.run(builder)` builds the window on a dedicated UI thread and blocks
+until it's closed. Build your widget tree inside `builder`. To update the UI
+later from another thread (a timer, a background task), use
+`pane.invoke(fn)` to marshal back onto the UI thread.
+
+## License
+
+MIT

pane_ui-0.1.0/README.md

@@ -0,0 +1,84 @@
+# pane
+
+Python bindings for [Pane](https://github.com/HunterH1218/pane) — a modern, minimalist
+Windows UI engine built on WPF. Build real native Windows app UIs from Python:
+buttons, checkboxes, sliders, text input, tabs, live light/dark theming and
+accent-color switching, all with a single custom-chrome window.
+
+The engine itself is C#/WPF; this package drives it in-process via
+[pythonnet](https://pythonnet.github.io/), so widgets are the real native
+controls, not a re-implementation.
+
+**Windows only** (WPF has no cross-platform equivalent). Requires the free
+[.NET 8 Desktop Runtime](https://dotnet.microsoft.com/download/dotnet/8.0) —
+not the SDK, just the runtime.
+
+## Install
+
+```
+pip install pane-ui
+```
+
+## Quick start
+
+```python
+import pane
+
+def build(window):
+    window.Content = pane.stack(
+        pane.text("Hello from Python", size="title", bold=True),
+        pane.button("Click me", style="primary", on_click=lambda: print("clicked!")),
+        pane.checkbox("Enable notifications", checked=True),
+        spacing=12,
+        margin=24,
+    )
+
+pane.run(build, title="My App")
+```
+
+Run the full widget gallery from the source repo for a tour of everything
+available: `python examples/gallery.py`.
+
+## Widgets
+
+`button`, `checkbox`, `radio_button`, `toggle_switch`, `text_box`,
+`password_box`, `progress_bar`, `slider`, `combo_box`, `list_box`, `nav_list`,
+`tab_control`, `expander`, `group_box`, `separator`, `text`, plus
+`set_tooltip` / `set_context_menu` helpers.
+
+## Layout
+
+`stack(*children, orientation=, spacing=, margin=)`,
+`grid(children, rows=, columns=)`, `card(*children)`, `sidebar(*children)`,
+`scroll(child)`.
+
+## Theming
+
+```python
+pane.set_theme("light")        # or "dark"
+pane.toggle_theme()
+pane.set_accent("#4C82F7")     # hex string or (r, g, b) tuple
+pane.reset_accent()
+```
+
+Every widget re-themes live, mid-run, no restart needed.
+
+## Events
+
+Callbacks adapt to whatever you write - zero args or one:
+
+```python
+pane.button("Save", on_click=lambda: print("saved"))
+pane.slider(on_change=lambda value: print(value))
+```
+
+## Threading
+
+`pane.run(builder)` builds the window on a dedicated UI thread and blocks
+until it's closed. Build your widget tree inside `builder`. To update the UI
+later from another thread (a timer, a background task), use
+`pane.invoke(fn)` to marshal back onto the UI thread.
+
+## License
+
+MIT

pane_ui-0.1.0/pane/__init__.py

@@ -0,0 +1,79 @@
+"""
+pane - Python bindings for the Pane WPF UI engine.
+
+Builds real Pane-styled WPF windows and widgets from Python, in-process, via
+pythonnet. The engine itself (Pane.dll, the XAML control styles) is plain
+C#/WPF and untouched by this package - this is a thin, Pythonic layer that
+creates and drives the same native controls the WPF gallery app uses.
+
+    import pane
+
+    def build(window):
+        window.Content = pane.stack(
+            pane.text("Hello from Python", size="title"),
+            pane.button("Click me", style="primary", on_click=lambda: print("clicked")),
+            spacing=12, margin=24,
+        )
+
+    pane.run(build, title="My App")
+"""
+
+from .app import close, current_window, invoke, is_ui_thread, run
+from .layout import card, grid, scroll, sidebar, stack
+from .theme import current_theme, reset_accent, set_accent, set_theme, toggle_theme
+from .widgets import (
+    button,
+    checkbox,
+    combo_box,
+    expander,
+    group_box,
+    list_box,
+    nav_list,
+    password_box,
+    progress_bar,
+    radio_button,
+    separator,
+    set_context_menu,
+    set_tooltip,
+    slider,
+    tab_control,
+    text,
+    text_box,
+    toggle_switch,
+)
+
+__all__ = [
+    "run",
+    "invoke",
+    "close",
+    "is_ui_thread",
+    "current_window",
+    "set_theme",
+    "toggle_theme",
+    "current_theme",
+    "set_accent",
+    "reset_accent",
+    "button",
+    "checkbox",
+    "radio_button",
+    "toggle_switch",
+    "text_box",
+    "password_box",
+    "progress_bar",
+    "slider",
+    "combo_box",
+    "list_box",
+    "nav_list",
+    "tab_control",
+    "expander",
+    "group_box",
+    "separator",
+    "text",
+    "set_tooltip",
+    "set_context_menu",
+    "stack",
+    "grid",
+    "card",
+    "sidebar",
+    "scroll",
+]

pane_ui-0.1.0/pane/_bootstrap.py

@@ -0,0 +1,92 @@
+"""
+Internal: loads the CLR runtime and the Pane assembly exactly once.
+
+This is the only module that knows about pythonnet/clr - everything else in
+the package imports .NET types lazily, after ensure_loaded() has run.
+"""
+
+import os
+import sys
+import threading
+
+_initialized = False
+_lock = threading.Lock()
+
+
+def _find_build_output():
+    """Locate Pane.dll plus the runtimeconfig.json CoreCLR needs to host the
+    WPF shared framework. Prefers the bundled copy shipped inside this
+    installed package; falls back to a locally built dev-repo output so
+    `pip install -e .` from a source checkout works without a separate
+    packaging step."""
+    here = os.path.dirname(os.path.abspath(__file__))
+
+    bundled_dir = os.path.join(here, "_native")
+    bundled_config = os.path.join(bundled_dir, "Pane.runtimeconfig.json")
+    if os.path.exists(bundled_config):
+        return bundled_dir, bundled_config
+
+    repo_root = os.path.abspath(os.path.join(here, "..", ".."))
+    dev_candidates = [
+        os.path.join(repo_root, "src", "Pane.Template", "bin", "Debug", "net8.0-windows"),
+        os.path.join(repo_root, "src", "Pane.Template", "bin", "Release", "net8.0-windows"),
+    ]
+    for candidate in dev_candidates:
+        config = os.path.join(candidate, "Pane.Template.runtimeconfig.json")
+        if os.path.exists(config):
+            return candidate, config
+
+    raise RuntimeError(
+        "Could not find Pane.dll. If you're developing from source, run "
+        "`dotnet build Pane.sln` in the repo root first. If you installed via "
+        "pip, this package build is missing its bundled native files."
+    )
+
+
+def ensure_loaded():
+    global _initialized
+    if _initialized:
+        return
+    with _lock:
+        if _initialized:
+            return
+
+        if sys.platform != "win32":
+            raise ImportError(
+                "pane only runs on Windows - it's built on WPF, which has no "
+                "cross-platform equivalent."
+            )
+
+        bin_dir, runtimeconfig = _find_build_output()
+
+        from pythonnet import load
+        try:
+            load("coreclr", runtime_config=runtimeconfig)
+        except Exception as ex:
+            raise RuntimeError(
+                "pane couldn't start the .NET runtime. This usually means the "
+                ".NET 8 Desktop Runtime isn't installed - get it from "
+                "https://dotnet.microsoft.com/download/dotnet/8.0 "
+                "(the \"Desktop Runtime\" download for your platform, not the SDK) "
+                "and try again."
+            ) from ex
+
+        import clr
+        sys.path.append(bin_dir)
+        clr.AddReference("Pane")
+        clr.AddReference("PresentationFramework")
+        clr.AddReference("PresentationCore")
+        clr.AddReference("WindowsBase")
+
+        # WPF's pack:// URI scheme (used everywhere Pane loads its own XAML
+        # resource dictionaries) is registered lazily inside PackUriHelper's
+        # static constructor. In a normal WPF .exe that happens automatically
+        # during app startup; hosted from Python it never runs on its own, so
+        # the first pack:// Uri construction throws UriFormatException:
+        # "Invalid port specified". Touching PackUriHelper once, up front,
+        # forces that registration before any Pane code needs it.
+        from System.IO.Packaging import PackUriHelper
+        from System import Uri
+        PackUriHelper.Create(Uri("http://pane-bootstrap/"))
+
+        _initialized = True

pane_ui-0.1.0/pane/_convert.py

@@ -0,0 +1,42 @@
+"""Internal: Python <-> .NET value conversion helpers shared by widgets and layout."""
+
+from . import _bootstrap
+
+_bootstrap.ensure_loaded()
+
+from System.Windows import Thickness  # noqa: E402
+from System.Windows.Media import Color  # noqa: E402
+
+
+def to_thickness(value):
+    if isinstance(value, Thickness):
+        return value
+    if isinstance(value, (int, float)):
+        return Thickness(value)
+    if isinstance(value, (tuple, list)):
+        if len(value) == 2:
+            h, v = value
+            return Thickness(h, v, h, v)
+        if len(value) == 4:
+            return Thickness(*value)
+    raise ValueError(f"Invalid margin/padding value: {value!r} (expected a number, or a 2/4-tuple)")
+
+
+def to_color(value):
+    if isinstance(value, Color):
+        return value
+    if isinstance(value, str):
+        s = value.lstrip("#")
+        if len(s) == 6:
+            r, g, b = int(s[0:2], 16), int(s[2:4], 16), int(s[4:6], 16)
+            return Color.FromRgb(r, g, b)
+        if len(s) == 8:
+            a, r, g, b = int(s[0:2], 16), int(s[2:4], 16), int(s[4:6], 16), int(s[6:8], 16)
+            return Color.FromArgb(a, r, g, b)
+        raise ValueError(f"Invalid hex color: {value!r} (expected '#RRGGBB' or '#AARRGGBB')")
+    if isinstance(value, (tuple, list)):
+        if len(value) == 3:
+            return Color.FromRgb(*value)
+        if len(value) == 4:
+            return Color.FromArgb(*value)
+    raise ValueError(f"Invalid color value: {value!r} (expected a hex string or an (r,g,b) / (a,r,g,b) tuple)")

pane_ui-0.1.0/pane/_events.py

@@ -0,0 +1,32 @@
+"""Internal: arity-aware callback wiring so `on_click=lambda: ...` and
+`on_click=lambda value: ...` both work without the caller having to match a
+specific .NET event-handler signature."""
+
+import inspect
+
+
+def arity(fn):
+    try:
+        sig = inspect.signature(fn)
+        params = [
+            p
+            for p in sig.parameters.values()
+            if p.kind in (p.POSITIONAL_ONLY, p.POSITIONAL_OR_KEYWORD)
+        ]
+        return len(params)
+    except (TypeError, ValueError):
+        return 1
+
+
+def make_handler(callback, value_fn):
+    """Returns a (sender, args) -> None .NET-event-shaped handler that calls
+    `callback()` if it takes no arguments, or `callback(value_fn())` otherwise."""
+    n = arity(callback)
+
+    def handler(sender, args):
+        if n == 0:
+            callback()
+        else:
+            callback(value_fn())
+
+    return handler

pane_ui-0.1.0/pane/_native/Pane.runtimeconfig.json

@@ -0,0 +1,10 @@
+{
+  "runtimeOptions": {
+    "tfm": "net8.0",
+    "frameworks": [
+      { "name": "Microsoft.NETCore.App", "version": "8.0.0" },
+      { "name": "Microsoft.WindowsDesktop.App", "version": "8.0.0" }
+    ],
+    "rollForward": "LatestMinor"
+  }
+}

pane_ui-0.1.0/pane/app.py

@@ -0,0 +1,112 @@
+"""The entry point for building and running a Pane UI from Python."""
+
+import threading
+
+from . import _bootstrap
+
+_bootstrap.ensure_loaded()
+
+from Pane import PaneTheme, PaneWindow, ThemeManager  # noqa: E402
+from System import Action, Uri  # noqa: E402
+from System.Threading import ApartmentState, Thread  # noqa: E402
+from System.Threading import ThreadStart  # noqa: E402
+from System.Windows import Application, ResizeMode, ResourceDictionary  # noqa: E402
+
+_PANE_XAML_URI = "pack://application:,,,/Pane;component/Themes/Pane.xaml"
+
+_state = {
+    "app": None,
+    "window": None,
+    "dispatcher": None,
+    "ui_thread_id": None,
+}
+
+
+def is_ui_thread():
+    return threading.get_ident() == _state["ui_thread_id"]
+
+
+def invoke(fn):
+    """Runs fn on the UI thread and returns its result, blocking the caller.
+    Safe to call from any thread, including the UI thread itself."""
+    if _state["dispatcher"] is None:
+        raise RuntimeError("The Pane UI is not running - call pane.run() first")
+    if is_ui_thread():
+        return fn()
+
+    box = {}
+
+    def wrapper():
+        box["result"] = fn()
+
+    _state["dispatcher"].Invoke(Action(wrapper))
+    return box.get("result")
+
+
+def current_window():
+    return _state["window"]
+
+
+def close():
+    """Closes the running window. Safe to call from any thread."""
+    invoke(lambda: _state["window"].Close())
+
+
+def run(builder, *, title="Pane App", width=1000, height=700, theme="dark", resizable=True):
+    """
+    Builds and shows a window, then blocks the calling thread until it's closed.
+
+    `builder(window)` runs on the dedicated UI thread before the window is
+    shown - build your widget tree there and assign it to `window.Content`.
+    Use pane.button(...), pane.stack(...), etc. only inside `builder` (or
+    inside a callback that pane.invoke()s back onto the UI thread).
+    """
+    ready = threading.Event()
+    error_box = {}
+
+    def ui_main():
+        try:
+            app = Application()
+            _state["app"] = app
+
+            # App.xaml normally does this merge declaratively; a bare Application()
+            # built from Python has no resources until we merge Pane.xaml ourselves.
+            merged = ResourceDictionary()
+            merged.Source = Uri(_PANE_XAML_URI)
+            app.Resources.MergedDictionaries.Add(merged)
+
+            ThemeManager.Initialize(PaneTheme.Dark if theme == "dark" else PaneTheme.Light)
+
+            window = PaneWindow()
+            window.Title = title
+            window.Width = width
+            window.Height = height
+            if not resizable:
+                window.ResizeMode = ResizeMode.NoResize
+
+            _state["window"] = window
+            _state["dispatcher"] = window.Dispatcher
+            _state["ui_thread_id"] = threading.get_ident()
+
+            builder(window)
+
+            ready.set()
+            app.Run(window)
+        except Exception as ex:  # noqa: BLE001 - surfaced to the caller below
+            error_box["error"] = ex
+            ready.set()
+        finally:
+            _state["app"] = None
+            _state["window"] = None
+            _state["dispatcher"] = None
+            _state["ui_thread_id"] = None
+
+    thread = Thread(ThreadStart(ui_main))
+    thread.SetApartmentState(ApartmentState.STA)
+    thread.Start()
+
+    ready.wait()
+    if "error" in error_box:
+        raise error_box["error"]
+
+    thread.Join()

pane_ui-0.1.0/pane/layout.py

@@ -0,0 +1,113 @@
+"""Layout container helpers: stack, grid, card, scroll."""
+
+from . import _bootstrap
+
+_bootstrap.ensure_loaded()
+
+from System.Windows import GridLength, GridUnitType, Thickness  # noqa: E402
+
+from ._convert import to_thickness  # noqa: E402
+from .widgets import _find_style  # noqa: E402
+
+
+def stack(*children, orientation="vertical", spacing=0, margin=None):
+    from System.Windows.Controls import Orientation, StackPanel
+
+    panel = StackPanel()
+    panel.Orientation = Orientation.Vertical if orientation == "vertical" else Orientation.Horizontal
+    if margin is not None:
+        panel.Margin = to_thickness(margin)
+
+    for i, child in enumerate(children):
+        if spacing and i > 0:
+            m = child.Margin
+            if orientation == "vertical":
+                child.Margin = Thickness(m.Left, spacing, m.Right, m.Bottom)
+            else:
+                child.Margin = Thickness(spacing, m.Top, m.Right, m.Bottom)
+        panel.Children.Add(child)
+    return panel
+
+
+def _parse_length(value):
+    if value == "auto":
+        return GridLength(1, GridUnitType.Auto)
+    if isinstance(value, str) and value.endswith("*"):
+        factor = 1.0 if value == "*" else float(value[:-1])
+        return GridLength(factor, GridUnitType.Star)
+    return GridLength(float(value), GridUnitType.Pixel)
+
+
+def grid(children, *, rows=None, columns=None, margin=None):
+    """
+    children: a list of (row, col, widget) or (row, col, widget, row_span, col_span) tuples.
+    rows / columns: lists of "auto", "*", "2*", or a pixel size, e.g. rows=["auto", "*"].
+    """
+    from System.Windows.Controls import ColumnDefinition, Grid, RowDefinition
+
+    g = Grid()
+    for r in rows or ["auto"]:
+        rd = RowDefinition()
+        rd.Height = _parse_length(r)
+        g.RowDefinitions.Add(rd)
+    for c in columns or ["auto"]:
+        cd = ColumnDefinition()
+        cd.Width = _parse_length(c)
+        g.ColumnDefinitions.Add(cd)
+
+    for entry in children:
+        row, col, widget = entry[0], entry[1], entry[2]
+        row_span = entry[3] if len(entry) > 3 else 1
+        col_span = entry[4] if len(entry) > 4 else 1
+        Grid.SetRow(widget, row)
+        Grid.SetColumn(widget, col)
+        if row_span > 1:
+            Grid.SetRowSpan(widget, row_span)
+        if col_span > 1:
+            Grid.SetColumnSpan(widget, col_span)
+        g.Children.Add(widget)
+
+    if margin is not None:
+        g.Margin = to_thickness(margin)
+    return g
+
+
+def card(*children, padding=20, spacing=12, orientation="vertical", margin=None):
+    from System.Windows.Controls import Border
+
+    border = Border()
+    border.Style = _find_style("Pane.Card")
+    if padding is not None:
+        border.Padding = to_thickness(padding)
+    if margin is not None:
+        border.Margin = to_thickness(margin)
+    border.Child = stack(*children, orientation=orientation, spacing=spacing)
+    return border
+
+
+def sidebar(*children, width=240):
+    from System.Windows.Controls import DockPanel
+
+    border_style = _find_style("Pane.Sidebar")
+    from System.Windows.Controls import Border
+
+    border = Border()
+    border.Style = border_style
+    border.Width = width
+
+    panel = DockPanel()
+    panel.LastChildFill = True
+    for child in children:
+        panel.Children.Add(child)
+    border.Child = panel
+    return border
+
+
+def scroll(child, *, padding=None):
+    from System.Windows.Controls import ScrollViewer
+
+    sv = ScrollViewer()
+    sv.Content = child
+    if padding is not None:
+        sv.Padding = to_thickness(padding)
+    return sv

pane_ui-0.1.0/pane/theme.py

@@ -0,0 +1,31 @@
+"""Theme and accent-color control - thin wrappers over Pane.ThemeManager."""
+
+from . import _bootstrap
+
+_bootstrap.ensure_loaded()
+
+from Pane import PaneTheme, ThemeManager  # noqa: E402
+
+from ._convert import to_color  # noqa: E402
+
+
+def set_theme(theme):
+    """theme: "dark" or "light"."""
+    ThemeManager.SetTheme(PaneTheme.Dark if theme == "dark" else PaneTheme.Light)
+
+
+def toggle_theme():
+    ThemeManager.ToggleTheme()
+
+
+def current_theme():
+    return "dark" if ThemeManager.CurrentTheme == PaneTheme.Dark else "light"
+
+
+def set_accent(color):
+    """color: a "#RRGGBB" / "#AARRGGBB" hex string, or an (r,g,b) / (a,r,g,b) tuple."""
+    ThemeManager.SetAccentColor(to_color(color))
+
+
+def reset_accent():
+    ThemeManager.ResetAccentColor()

pane_ui-0.1.0/pane/widgets.py

@@ -0,0 +1,306 @@
+"""Widget factory functions - each returns a real, Pane-styled WPF control.
+
+Most Pane controls (checkboxes, radio buttons, text boxes, sliders, ...) are
+styled implicitly by Pane.xaml, so a plain `CheckBox()` picks up Pane's look
+automatically once it's added to a window built by pane.run(). Only the
+handful of controls with named styles (Button variants, ToggleSwitch, Card,
+ColorSwatch, NavigationList) need an explicit style lookup here.
+"""
+
+from . import _bootstrap
+
+_bootstrap.ensure_loaded()
+
+from System.Windows import Application, FontWeights, TextWrapping  # noqa: E402
+
+from ._convert import to_thickness  # noqa: E402
+from ._events import make_handler  # noqa: E402
+
+_FONT_SIZE_KEYS = {
+    "caption": "Pane.Font.Size.Caption",
+    "body": "Pane.Font.Size.Body",
+    "subtitle": "Pane.Font.Size.Subtitle",
+    "title": "Pane.Font.Size.Title",
+    "title-large": "Pane.Font.Size.TitleLarge",
+}
+
+_TEXT_COLOR_KEYS = {
+    "primary": "Pane.Brush.Text.Primary",
+    "secondary": "Pane.Brush.Text.Secondary",
+    "disabled": "Pane.Brush.Text.Disabled",
+}
+
+
+def _find_style(key):
+    app = Application.Current
+    if app is None:
+        raise RuntimeError(
+            "No Pane window is running yet - build widgets inside the function "
+            "you pass to pane.run(), not before it."
+        )
+    return app.FindResource(key)
+
+
+def _apply_common(element, *, width=None, height=None, margin=None, enabled=None):
+    if width is not None:
+        element.Width = width
+    if height is not None:
+        element.Height = height
+    if margin is not None:
+        element.Margin = to_thickness(margin)
+    if enabled is not None:
+        element.IsEnabled = enabled
+
+
+# --- Buttons ----------------------------------------------------------------
+
+def button(label, *, style="secondary", on_click=None, width=None, height=None, margin=None, enabled=True):
+    from System.Windows.Controls import Button
+
+    btn = Button()
+    btn.Content = label
+    if style == "primary":
+        btn.Style = _find_style("Pane.Button.Primary")
+    elif style == "ghost":
+        btn.Style = _find_style("Pane.Button.Ghost")
+    # else "secondary": leave unset - Pane's implicit Button style applies.
+    _apply_common(btn, width=width, height=height, margin=margin, enabled=enabled)
+    if on_click:
+        btn.Click += make_handler(on_click, lambda: None)
+    return btn
+
+
+# --- Selection ----------------------------------------------------------------
+
+def checkbox(label, *, checked=False, on_change=None, width=None, margin=None, enabled=True):
+    from System.Windows.Controls import CheckBox
+
+    cb = CheckBox()
+    cb.Content = label
+    cb.IsChecked = checked
+    _apply_common(cb, width=width, margin=margin, enabled=enabled)
+    if on_change:
+        handler = make_handler(on_change, lambda: cb.IsChecked)
+        cb.Checked += handler
+        cb.Unchecked += handler
+        cb.Indeterminate += handler
+    return cb
+
+
+def radio_button(label, group, *, checked=False, on_change=None, width=None, margin=None, enabled=True):
+    from System.Windows.Controls import RadioButton
+
+    rb = RadioButton()
+    rb.Content = label
+    rb.GroupName = group
+    rb.IsChecked = checked
+    _apply_common(rb, width=width, margin=margin, enabled=enabled)
+    if on_change:
+        rb.Checked += make_handler(on_change, lambda: True)
+    return rb
+
+
+def toggle_switch(*, checked=False, on_change=None, margin=None, enabled=True):
+    from System.Windows.Controls.Primitives import ToggleButton
+
+    tb = ToggleButton()
+    tb.Style = _find_style("Pane.ToggleSwitch")
+    tb.IsChecked = checked
+    _apply_common(tb, margin=margin, enabled=enabled)
+    if on_change:
+        handler = make_handler(on_change, lambda: bool(tb.IsChecked))
+        tb.Checked += handler
+        tb.Unchecked += handler
+    return tb
+
+
+# --- Text input ----------------------------------------------------------------
+
+def text_box(*, text="", placeholder="", on_change=None, width=None, margin=None, enabled=True):
+    from System.Windows.Controls import TextBox
+    from Pane.Controls import PaneAssist
+
+    tbx = TextBox()
+    tbx.Text = text
+    if placeholder:
+        PaneAssist.SetPlaceholder(tbx, placeholder)
+    _apply_common(tbx, width=width, margin=margin, enabled=enabled)
+    if on_change:
+        tbx.TextChanged += make_handler(on_change, lambda: tbx.Text)
+    return tbx
+
+
+def password_box(*, on_change=None, width=None, margin=None, enabled=True):
+    from System.Windows.Controls import PasswordBox
+
+    pwd = PasswordBox()
+    _apply_common(pwd, width=width, margin=margin, enabled=enabled)
+    if on_change:
+        pwd.PasswordChanged += make_handler(on_change, lambda: pwd.Password)
+    return pwd
+
+
+# --- Progress & range ----------------------------------------------------------------
+
+def progress_bar(*, value=0, minimum=0, maximum=100, indeterminate=False, width=None, margin=None):
+    from System.Windows.Controls import ProgressBar
+
+    pb = ProgressBar()
+    pb.Minimum = minimum
+    pb.Maximum = maximum
+    pb.Value = value
+    pb.IsIndeterminate = indeterminate
+    _apply_common(pb, width=width, margin=margin)
+    return pb
+
+
+def slider(*, value=0, minimum=0, maximum=100, on_change=None, width=None, margin=None, enabled=True):
+    from System.Windows.Controls import Slider
+
+    s = Slider()
+    s.Minimum = minimum
+    s.Maximum = maximum
+    s.Value = value
+    _apply_common(s, width=width, margin=margin, enabled=enabled)
+    if on_change:
+        s.ValueChanged += make_handler(on_change, lambda: s.Value)
+    return s
+
+
+# --- Choices & lists ----------------------------------------------------------------
+
+def combo_box(items, *, selected_index=0, on_change=None, width=None, margin=None, enabled=True):
+    from System.Windows.Controls import ComboBox, ComboBoxItem
+
+    cb = ComboBox()
+    for item in items:
+        cbi = ComboBoxItem()
+        cbi.Content = str(item)
+        cb.Items.Add(cbi)
+    if items:
+        cb.SelectedIndex = selected_index
+    _apply_common(cb, width=width, margin=margin, enabled=enabled)
+    if on_change:
+        cb.SelectionChanged += make_handler(on_change, lambda: cb.SelectedIndex)
+    return cb
+
+
+def list_box(items, *, selected_index=0, on_select=None, width=None, height=None, margin=None, enabled=True):
+    from System.Windows.Controls import ListBox, ListBoxItem
+
+    lb = ListBox()
+    for item in items:
+        lbi = ListBoxItem()
+        lbi.Content = str(item)
+        lb.Items.Add(lbi)
+    if items:
+        lb.SelectedIndex = selected_index
+    _apply_common(lb, width=width, height=height, margin=margin, enabled=enabled)
+    if on_select:
+        lb.SelectionChanged += make_handler(on_select, lambda: lb.SelectedIndex)
+    return lb
+
+
+def nav_list(items, *, selected_index=0, on_select=None):
+    """A Pane-styled sidebar navigation list (see Pane.NavigationList)."""
+    from System.Windows.Controls import ListBox, ListBoxItem
+
+    lb = ListBox()
+    lb.Style = _find_style("Pane.NavigationList")
+    for item in items:
+        lbi = ListBoxItem()
+        lbi.Content = str(item)
+        lb.Items.Add(lbi)
+    if items:
+        lb.SelectedIndex = selected_index
+    if on_select:
+        lb.SelectionChanged += make_handler(on_select, lambda: lb.SelectedIndex)
+    return lb
+
+
+def tab_control(tabs, *, width=None, height=None, margin=None):
+    """tabs: a dict of {header: content_element}, or a list of (header, content) pairs."""
+    from System.Windows.Controls import TabControl, TabItem
+
+    tc = TabControl()
+    entries = tabs.items() if isinstance(tabs, dict) else tabs
+    for header, content in entries:
+        ti = TabItem()
+        ti.Header = header
+        ti.Content = content
+        tc.Items.Add(ti)
+    _apply_common(tc, width=width, height=height, margin=margin)
+    return tc
+
+
+# --- Layout & overlays ----------------------------------------------------------------
+
+def expander(header, content, *, expanded=False, margin=None):
+    from System.Windows.Controls import Expander
+
+    e = Expander()
+    e.Header = header
+    e.Content = content
+    e.IsExpanded = expanded
+    _apply_common(e, margin=margin)
+    return e
+
+
+def group_box(header, content, *, margin=None):
+    from System.Windows.Controls import GroupBox
+
+    g = GroupBox()
+    g.Header = header
+    g.Content = content
+    _apply_common(g, margin=margin)
+    return g
+
+
+def separator(*, margin=None):
+    from System.Windows.Controls import Separator
+
+    s = Separator()
+    _apply_common(s, margin=margin)
+    return s
+
+
+def text(content, *, size="body", bold=False, color="primary", wrap=False, margin=None):
+    from System.Windows.Controls import TextBlock
+
+    tb = TextBlock()
+    tb.Text = str(content)
+    # SetResourceReference (not a direct value assignment) so this text keeps
+    # tracking theme/accent changes live, the same way {DynamicResource} does in XAML.
+    tb.SetResourceReference(TextBlock.FontFamilyProperty, "Pane.Font.Family")
+    tb.SetResourceReference(TextBlock.FontSizeProperty, _FONT_SIZE_KEYS.get(size, _FONT_SIZE_KEYS["body"]))
+    tb.SetResourceReference(TextBlock.ForegroundProperty, _TEXT_COLOR_KEYS.get(color, _TEXT_COLOR_KEYS["primary"]))
+    if bold:
+        tb.FontWeight = FontWeights.SemiBold
+    if wrap:
+        tb.TextWrapping = TextWrapping.Wrap
+    _apply_common(tb, margin=margin)
+    return tb
+
+
+def set_tooltip(element, tooltip_text):
+    element.ToolTip = tooltip_text
+    return element
+
+
+def set_context_menu(element, items):
+    """items: a list of (label, on_click) pairs; use None for a separator."""
+    from System.Windows.Controls import ContextMenu, MenuItem, Separator
+
+    menu = ContextMenu()
+    for item in items:
+        if item is None:
+            menu.Items.Add(Separator())
+            continue
+        label, on_click = item
+        mi = MenuItem()
+        mi.Header = label
+        if on_click:
+            mi.Click += make_handler(on_click, lambda: None)
+        menu.Items.Add(mi)
+    element.ContextMenu = menu
+    return element

pane_ui-0.1.0/pane_ui.egg-info/PKG-INFO

@@ -0,0 +1,107 @@
+Metadata-Version: 2.4
+Name: pane-ui
+Version: 0.1.0
+Summary: Python bindings for Pane, a modern minimalist Windows UI engine built on WPF
+Author: Hunter
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/HunterH1218/pane
+Project-URL: Repository, https://github.com/HunterH1218/pane
+Project-URL: Issues, https://github.com/HunterH1218/pane/issues
+Keywords: wpf,windows,ui,gui,desktop,pythonnet
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: C#
+Classifier: Topic :: Software Development :: User Interfaces
+Classifier: Topic :: Software Development :: Widget Sets
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pythonnet>=3.0
+Dynamic: license-file
+
+# pane
+
+Python bindings for [Pane](https://github.com/HunterH1218/pane) — a modern, minimalist
+Windows UI engine built on WPF. Build real native Windows app UIs from Python:
+buttons, checkboxes, sliders, text input, tabs, live light/dark theming and
+accent-color switching, all with a single custom-chrome window.
+
+The engine itself is C#/WPF; this package drives it in-process via
+[pythonnet](https://pythonnet.github.io/), so widgets are the real native
+controls, not a re-implementation.
+
+**Windows only** (WPF has no cross-platform equivalent). Requires the free
+[.NET 8 Desktop Runtime](https://dotnet.microsoft.com/download/dotnet/8.0) —
+not the SDK, just the runtime.
+
+## Install
+
+```
+pip install pane-ui
+```
+
+## Quick start
+
+```python
+import pane
+
+def build(window):
+    window.Content = pane.stack(
+        pane.text("Hello from Python", size="title", bold=True),
+        pane.button("Click me", style="primary", on_click=lambda: print("clicked!")),
+        pane.checkbox("Enable notifications", checked=True),
+        spacing=12,
+        margin=24,
+    )
+
+pane.run(build, title="My App")
+```
+
+Run the full widget gallery from the source repo for a tour of everything
+available: `python examples/gallery.py`.
+
+## Widgets
+
+`button`, `checkbox`, `radio_button`, `toggle_switch`, `text_box`,
+`password_box`, `progress_bar`, `slider`, `combo_box`, `list_box`, `nav_list`,
+`tab_control`, `expander`, `group_box`, `separator`, `text`, plus
+`set_tooltip` / `set_context_menu` helpers.
+
+## Layout
+
+`stack(*children, orientation=, spacing=, margin=)`,
+`grid(children, rows=, columns=)`, `card(*children)`, `sidebar(*children)`,
+`scroll(child)`.
+
+## Theming
+
+```python
+pane.set_theme("light")        # or "dark"
+pane.toggle_theme()
+pane.set_accent("#4C82F7")     # hex string or (r, g, b) tuple
+pane.reset_accent()
+```
+
+Every widget re-themes live, mid-run, no restart needed.
+
+## Events
+
+Callbacks adapt to whatever you write - zero args or one:
+
+```python
+pane.button("Save", on_click=lambda: print("saved"))
+pane.slider(on_change=lambda value: print(value))
+```
+
+## Threading
+
+`pane.run(builder)` builds the window on a dedicated UI thread and blocks
+until it's closed. Build your widget tree inside `builder`. To update the UI
+later from another thread (a timer, a background task), use
+`pane.invoke(fn)` to marshal back onto the UI thread.
+
+## License
+
+MIT

pane_ui-0.1.0/pane_ui.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE
+README.md
+pyproject.toml
+pane/__init__.py
+pane/_bootstrap.py
+pane/_convert.py
+pane/_events.py
+pane/app.py
+pane/layout.py
+pane/theme.py
+pane/widgets.py
+pane/_native/Pane.dll
+pane/_native/Pane.runtimeconfig.json
+pane_ui.egg-info/PKG-INFO
+pane_ui.egg-info/SOURCES.txt
+pane_ui.egg-info/dependency_links.txt
+pane_ui.egg-info/requires.txt
+pane_ui.egg-info/top_level.txt

pane_ui-0.1.0/pane_ui.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pane_ui-0.1.0/pane_ui.egg-info/requires.txt

@@ -0,0 +1 @@
+pythonnet>=3.0

pane_ui-0.1.0/pane_ui.egg-info/top_level.txt

@@ -0,0 +1 @@
+pane

pane_ui-0.1.0/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pane-ui"
+version = "0.1.0"
+description = "Python bindings for Pane, a modern minimalist Windows UI engine built on WPF"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.9"
+authors = [
+    { name = "Hunter" },
+]
+keywords = ["wpf", "windows", "ui", "gui", "desktop", "pythonnet"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Operating System :: Microsoft :: Windows",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: C#",
+    "Topic :: Software Development :: User Interfaces",
+    "Topic :: Software Development :: Widget Sets",
+]
+dependencies = [
+    "pythonnet>=3.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/HunterH1218/pane"
+Repository = "https://github.com/HunterH1218/pane"
+Issues = "https://github.com/HunterH1218/pane/issues"
+
+[tool.setuptools.packages.find]
+include = ["pane*"]
+
+[tool.setuptools.package-data]
+pane = ["_native/*.dll", "_native/*.json"]

pane_ui-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+