blenderui 0.1.0__tar.gz

blenderui-0.1.0/.gitignore

@@ -0,0 +1,11 @@
+build*/
+build-ui/
+*.obj
+*.o
+reference/
+
+# packaging
+dist/
+wheelhouse/
+*.egg-info/
+*.whl

blenderui-0.1.0/ARCHITECTURE.md

@@ -0,0 +1,120 @@
+# BUI Architecture
+
+BUI is a decoupled UI toolkit extracted from the Blender project
+(`source/blender/editors/interface` and its support layers). It contains **only**
+reusable interface machinery — no Blender application logic (no scene graph,
+depsgraph, nodes, operators-on-datablocks, file loading, Python).
+
+```
+┌──────────────────────────────────────────────────────────────────┐
+│  ui/      widget toolkit: blocks/buttons, layout engine,         │
+│           widget drawing, handlers, views, view2d                │
+└──────┬───────────────┬──────────────┬─────────────┬──────────────┘
+       │               │              │             │
+┌──────▼──────┐ ┌──────▼──────┐ ┌─────▼──────────┐ ┌▼──────────────────┐
+│ types/      │ │ gpu/        │ │ compat/        │ │ api/  stable C    │
+│ DNA data    │ │ draw seam   │ │ RNA / CTX / WM │ │ ABI for hosts     │
+│ shapes      │ │ (null back- │ │ / ED / BLF /   │ │ & bindings        │
+│ (verbatim)  │ │  end + sink │ │ IMB seams      │ └───┬─────────┬─────┘
+│             │ │  dispatch)  │ │ (stubs & hooks)│     │         │
+└──────┬──────┘ └──────┬──────┘ └─────┬──────────┘ ┌───▼───┐ ┌───▼──────┐
+       │               │              │            │buipy  │ │bui_qt    │
+       │               │              │            │Python │ │QPainter  │
+       │               │              │            │binding│ │backend   │
+┌──────▼───────────────▼──────────────▼──────────┐└───────┘ └──────────┘
+│  core/   pure C11 foundation extracted from blenlib            │
+│          listbase · ghash · mempool · memarena · dynstr        │
+│          math (vec/mat/rot/color/geom) · strings · rct         │
+│          guarded-allocator shim · threads stubs                │
+└────────────────────────────────────────────────────────────────┘
+```
+
+Dependency rule: arrows point downward only. `ui/` never includes Blender
+application code; everything it needs arrives through `types/`, `gpu/`, or
+`compat/`.
+
+## Modules
+
+| Module | Contents | Status |
+|---|---|---|
+| `core/` | C11 subset of blenlib, de-C++ified with mechanical transforms (namespaces stripped, casts normalized, MEM API mapped). Inline math lives in `include/intern/*.c` included by headers (`MINLINE` = `static inline` in C). | **Builds + tested** |
+| `types/` | Verbatim `DNA_*_types.h` struct definitions. `DNA_listBase.h` aliases `blender::{Link,LinkData,ListBase}` onto the core's C structs so DNA structs and the C listbase API share one type. | **Builds** |
+| `gpu/` | The draw surface used by the toolkit (`GPU_*`, `imm*`) behind seam headers + a null backend that *records and forwards*: with a sink installed it emits screen-space primitives (`GPU_backend_sink.h`); without one it discards them. Theme colors reach the GPU layer through function-pointer hooks. | **Builds + tested** |
+| `compat/` | Seam headers carrying upstream API names (`RNA_access.hh`, `BLF_api.hh`, …) with BUI-owned opaque types and stub implementations (`intern/bui_stubs.cc`). | **Builds** |
+| `ui/` | The toolkit sources from `editors/interface`: interface.cc family, widgets, handlers, regions, view2d, views, textbox. Option-gated (`-DBUI_BUILD_UI=ON`). | **Compiles + links** |
+| `kit/` | Blender's UI as a retained-mode C runtime: node tree, uiLayout-style layout, `interface_handlers.cc` interaction rules, widget drawing ported from `interface_widgets.cc` (widget-base shader parameters rendered by `gpu/` raster), menus, color picker, views, editors; Tk-style pack/grid/place geometry managers, canvas display list, multi-line text area; UI undo/redo, Tab field traversal, vertical multi-drag, panel animation; damage-driven rendering; native Win32 window host (`kit_window.c`). C API: `kit/include/BUI_kit.h`. | **Builds + tested** |
+| `api/` | `bui_c_api.h` — small stable C ABI: version info + sink/viewport plumbing for hosts and bindings. | **Builds + tested** |
+| `bindings/python/` | `buipy` CPython extension (no third-party deps) + `bui` package: `bui.components` (Blender component library), `bui.qtsyntax` / `bui.tksyntax` (Qt / tkinter APIs as thin facades over the kit), `bui.host` (native or Tk windows), `SvgSink` headless renderer, `bui.qt.BuiCanvas` PySide6/PyQt6 widget. | **Builds + tested** |
+| `backends/qt/` | C++ Qt backend: `BUI::QtSink` (BuiGpuSink → QPainter) + `BUI::BuiWidget` (QWidget host, no moc needed). Gate: `-DBUI_BUILD_QT_BACKEND=ON`. | **Shipped** (builds where Qt exists) |
+| `examples/` | `bui_svg_demo.c` (C, sink → SVG), `python_demo.py` (buipy → SVG). | **Builds + run** |
+
+## Render-sink dispatch
+
+The null backend is the integration seam. `gpu/include/GPU_backend_sink.h`
+defines `BuiGpuSink` — a function-pointer table (`triangles`, `lines`,
+`points`, `text`, `scissor`, `begin_frame`, `end_frame`). The null backend:
+
+- records immediate-mode vertices (`immBegin/immAttr*/immVertex*/immEnd`),
+- decodes vertex batches (pos/color attributes, index buffers),
+- applies the model matrix and forwards screen-space primitives to the sink,
+- or, with no sink installed, discards everything (pure null).
+
+Real renderers plug in at three levels: C (`bui_set_render_sink`), Qt/C++
+(`BUI::QtSink`), Python (`buipy.set_backend`). See INTEGRATION.md.
+
+## Build
+
+```sh
+cmake -S . -B build -G "MinGW Makefiles"     # or any generator
+cmake --build build
+ctest --test-dir build                       # core tests + buipy tests
+cmake -S . -B build-ui -DBUI_BUILD_UI=ON -DBUI_BUILD_EXAMPLES=ON
+cmake --build build-ui                       # + widget toolkit (bui_ui)
+```
+
+Options: `BUI_BUILD_PYTHON_BINDINGS` (ON; auto-skips without Python dev
+files), `BUI_BUILD_QT_BACKEND` (OFF; needs Qt5/Qt6 Widgets),
+`BUI_BUILD_EXAMPLES`, `BUI_BUILD_TESTS`.
+
+Windows note: the toolchain must resolve MinGW runtime DLLs from
+`/c/msys64/ucrt64/bin` **before** `/mingw64/bin` or other vendors' paths
+(cc1.exe loads zlib1/gmp from PATH). If builds fail silently, prepend the
+ucrt64 dir: `export PATH="/c/msys64/ucrt64/bin:$PATH"`.
+
+## Decoupling inventory (what was cut, what remains)
+
+Cut entirely (Blender application logic): scene/mesh/node/depsgraph/modifiers,
+animrig (only the DNA structs + a minimal `animrig::Slot` wrapper remain),
+asset system, sequencer, render, Python-in-Blender, file I/O (BLO),
+eyedroppers, app-specific UI templates, window manager backends (GHOST),
+operator system.
+
+Remaining seams before a *hosted* toolkit (real widgets on screen) works —
+call-site counts measured from the copied sources:
+
+| Seam | Touchpoints | Notes |
+|---|---|---|
+| WM (events/operators/keymaps) | ~183 | Needs lite `wmEvent`/`wmOperator` structs + handler plumbing in `compat/` |
+| ED (screen/region services) | ~120 | Region redraw tagging, area/region lookup — small BUI-owned implementations |
+| CTX (context) | ~46 | Minimal `bContext` replacement |
+| BLF (fonts) | ~45 | Text measurement/draw hook; null impl first |
+| IMB (images/icons) | ~23 | Icon texture registration hook |
+| RNA (properties) | ~16 entry points | Opaque `PropertyRNA` + accessor vtable |
+
+These seams block *widget-tree hosting* (creating blocks/buttons driven by
+events), not compilation: all five libraries — `bui_core`, `bui_gpu`,
+`bui_compat`, `bui_api`, `bui_ui` — build and link cleanly today, and the
+render pipeline is exercisable end-to-end through the sink (see
+`examples/`).
+
+## Porting notes
+
+- Upstream files keep their names and SPDX headers (GPL-2.0-or-later). The
+  mechanical de-C++ pass is intentionally boring so future syncs stay easy.
+- `core/include/fmt/*` is a declaration-level stand-in for the external {fmt}
+  library; swap for real {fmt} if you need formatted strings.
+- `MEM_guardedalloc.h` is a plain-malloc shim with the upstream C++ template
+  surface (`MEM_new<T>`, `MEM_new_zeroed<T>`, `MEM_new_array_uninitialized<T>`,
+  `MEM_delete<T>`, `MEM_SAFE_DELETE`).
+- `GPU_batch.hh` carries a layout contract: the first four members of
+  `blender::gpu::VertBuf` must match `GPUVertBufInternal` in `gpu_null.c`.

blenderui-0.1.0/CHANGELOG.md

@@ -0,0 +1,31 @@
+# Changelog
+
+All notable changes to **blenderui** (BUI). The format follows
+[Keep a Changelog](https://keepachangelog.com); versions follow
+[Semantic Versioning](https://semver.org).
+
+## [Unreleased]
+
+## [0.1.0] - first release
+
+### Added
+- **C kit** (`kit/`): Blender's UI as a C runtime. It has the node tree,
+  Tk's packer and gridder in C, input and interaction (hover, drag grabs,
+  continuous cursor, menus, tooltips), widget drawing ported from Blender's
+  `interface_widgets.cc`, and damage-driven raster rendering. Also: undo and
+  redo, animation, the text area, canvas, scroll views, scrollbars and
+  multi-select.
+- **Native window host** for Windows (Win32): DPI-aware, vsync'd
+  animation, clipboard, cursors, window-manager features. Other platforms use
+  a stdlib-Tk-hosted window.
+- **`bui.tksyntax`**: the complete tkinter API (7846/7846 public names of
+  the tkinter and ttk classes), plus `ttk`, `messagebox`, `filedialog`,
+  `simpledialog`, `colorchooser`, `font` and `scrolledtext`. Run existing apps
+  unchanged with `python -m bui.tksyntax app.py`, `blenderui-tk app.py` or
+  `install()`.
+- **`bui.qtsyntax`**: a Qt-style API subset (widgets, layouts, signals,
+  `QPainter`, menus, timers).
+- **`bui.components`**: 45 Blender components (layouts, values, views,
+  menus, pie menus, the color picker, editors, templates).
+- Packaging as `blenderui` (scikit-build-core), with `import blenderui` as
+  an alias of `bui`.

blenderui-0.1.0/CMakeLists.txt

@@ -0,0 +1,69 @@
+# BUI - Blender-derived UI toolkit
+#
+# A decoupled UI library extracted from the Blender project.
+# The application-specific layers (scene, nodes, depsgraph, operators on
+# datablocks...) are NOT part of this library. Only reusable interface
+# machinery lives here: core containers/math (C), UI types, drawing
+# abstraction, and the widget toolkit.
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+cmake_minimum_required(VERSION 3.20)
+
+# One version for the C library, the Python package and the PyPI wheel.
+file(STRINGS "${CMAKE_CURRENT_SOURCE_DIR}/bindings/python/bui/_version.py" _bui_version_line
+     REGEX "^__version__")
+string(REGEX MATCH "[0-9]+[.][0-9]+[.][0-9]+" BUI_VERSION "${_bui_version_line}")
+project(bui LANGUAGES C CXX VERSION ${BUI_VERSION})
+
+option(BUI_BUILD_TESTS "Build BUI test executables" ON)
+option(BUI_BUILD_EXAMPLES "Build BUI example applications" OFF)
+option(BUI_WARNINGS_AS_ERRORS "Treat compiler warnings as errors" OFF)
+option(BUI_BUILD_PYTHON_BINDINGS "Build the buipy CPython bindings (needs Python3 dev files)" ON)
+option(BUI_BUILD_QT_BACKEND "Build the Qt/QPainter backend (needs Qt5/Qt6 with Widgets)" OFF)
+
+if(NOT CMAKE_BUILD_TYPE)
+  set(CMAKE_BUILD_TYPE Release)
+endif()
+
+set(CMAKE_C_STANDARD 11)
+set(CMAKE_C_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+if(MSVC)
+  add_compile_options(/W3)
+else()
+  add_compile_options(-Wall -Wno-unused-parameter -Wno-missing-field-initializers)
+  if(NOT BUI_WARNINGS_AS_ERRORS)
+    add_compile_options(-Wno-error)
+  endif()
+endif()
+
+set(BUI_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+
+# Dependency order matters: each layer may only use layers above it in this list.
+add_subdirectory(core)   # pure C foundation
+add_subdirectory(types)  # BUI-owned shared data types
+add_subdirectory(gpu)    # draw abstraction (null backend + sink dispatch)
+add_subdirectory(compat) # seam headers/stubs replacing Blender-app APIs
+add_subdirectory(ui)     # the widget toolkit
+add_subdirectory(kit)    # Blender UI runtime in C (widgets, input, damage rendering)
+add_subdirectory(api)    # stable C ABI for hosts & bindings
+
+if(BUI_BUILD_TESTS)
+  enable_testing()
+  add_subdirectory(core/tests)
+endif()
+
+if(BUI_BUILD_PYTHON_BINDINGS)
+  add_subdirectory(bindings/python)
+endif()
+
+if(BUI_BUILD_QT_BACKEND)
+  add_subdirectory(backends/qt)
+endif()
+
+if(BUI_BUILD_EXAMPLES)
+  add_subdirectory(examples)
+endif()

blenderui-0.1.0/INTEGRATION.md

@@ -0,0 +1,234 @@
+# Host integration guide
+
+> **High-level syntax layers (recommended):** you may not need any of the
+> plumbing below. `bindings/python` ships two application-facing APIs that
+> render through BUI — **Qt syntax** (`bui.qtsyntax`) and **tkinter syntax**
+> (`bui.tksyntax`). See "High-level syntax layers" at the bottom, and
+> "Testing the Python bindings" for the one setup step they need.
+
+BUI draws; you present. The toolkit never opens a window, creates a GL
+context, or picks a UI framework. Instead, every draw call funnels through the
+**GPU seam** into a render **sink** you install. This document covers the
+three supported paths: plain C/C++, Qt (C++), and Python (PySide6/PyQt6 or
+headless).
+
+```
+                    ┌────────────────────────┐
+   your host        │   sink (BuiGpuSink)    │
+ ┌────────────────┐ │  triangles()           │      renderer
+ │ ui toolkit ────┼─┼─▶ lines()  ────────────┼──▶  Qt QPainter /
+ │ (bui_ui)       │ │  points()              │      PySide6 QPainter /
+ │ gpu seam       │ │  text()  scissor()     │      OpenGL / SVG / console
+ │ (gpu_null.c)   │ │  begin/end_frame()     │      — anything
+ └────────────────┘ └────────────────────────┘
+```
+
+## 1. Plain C / C++
+
+```c
+#include "bui_c_api.h"
+
+static void my_triangles(void *user, const float (*coords)[2],
+                         const float (*colors)[4], int count) {
+  /* rasterize / record / forward `count` vertices */
+}
+
+BuiGpuSink sink = {0};
+sink.user = my_renderer_state;
+sink.triangles = my_triangles;
+/* sink.lines, sink.points, sink.text, sink.scissor,
+   sink.begin_frame, sink.end_frame are optional */
+bui_set_render_sink(&sink);
+
+bui_set_viewport(1280, 720);   /* pixels */
+/* ... drive BUI drawing ... */
+bui_set_render_sink(NULL);     /* restore the discarding backend */
+```
+
+The coordinate contract: 2D positions transformed by the current model matrix
+(identity matrices → pixel coordinates), colors as RGBA floats 0..1.
+
+A complete minimal example is `examples/svg_demo.c` — it installs an SVG
+recorder and draws through the immediate-mode seam:
+
+```sh
+cmake --build build --target bui_svg_demo
+./build/examples/bui_svg_demo out.svg
+```
+
+## 2. Qt (C++)
+
+Enable the backend and link it:
+
+```sh
+cmake -S . -B build-qt -DBUI_BUILD_QT_BACKEND=ON   # needs Qt5/Qt6 Widgets
+cmake --build build-qt
+```
+
+```cpp
+#include "BuiWidget.h"   // backends/qt
+
+BUI::BuiWidget *canvas = new BUI::BuiWidget(window);
+canvas->render_func = [&](int w, int h) {
+  // BUI draw calls; primitives land on QPainter automatically.
+};
+```
+
+`BUI::BuiWidget` handles paint/resize/mouse plumbing; `BUI::QtSink` maps BUI
+primitives onto `QPainter` (per-vertex colors reduce to the first vertex color
+per primitive, which matches how the toolkit draws shapes). The backend does
+not require moc or OpenGL.
+
+## 3. Python
+
+The `buipy` extension (built by default when Python development files are
+found) exposes the same sink protocol to Python — no third-party packages.
+
+### Headless / CI — SVG output
+
+```python
+import buipy
+from bui.svg import SvgSink
+
+sink = SvgSink(640, 480)
+buipy.set_backend(sink)
+buipy.demo_scene(640, 480)   # or your own draw calls
+sink.save("frame.svg")
+```
+
+### PySide6 / PyQt6 window
+
+```python
+import sys
+from PySide6.QtWidgets import QApplication   # PyQt6 works identically
+import buipy
+from bui.qt import BuiCanvas
+
+app = QApplication(sys.argv)
+canvas = BuiCanvas()               # default renders the demo scene
+# canvas.render_func = lambda: <BUI draw calls>
+canvas.resize(800, 600)
+canvas.show()
+sys.exit(app.exec())
+```
+
+`BuiCanvas` installs a `QtPainterBackend` for each paint pass, so the toolkit
+renders through the same QPainter path as the C++ backend — pure Python, no
+shiboken build.
+
+## High-level syntax layers
+
+Two facades speak the syntax of established toolkits on top of the C kit
+(`kit/`, exposed to Python as `buipy.KitNode` / `buipy.KitContext`): widgets
+are kit nodes, layouts are the kit's C geometry managers, and windows come
+from `bui.host` (native Win32 on Windows, Tk elsewhere or with
+`BUI_HOST=tk`):
+
+### Qt syntax — `bui.qtsyntax`
+
+```python
+from bui.qtsyntax import QApplication, QWidget, QPushButton, QLabel, QVBoxLayout
+
+app = QApplication([])
+window = QWidget()
+window.setWindowTitle("BUI — Qt syntax")
+layout = QVBoxLayout()
+status = QLabel("Press the button.")
+button = QPushButton("Click me")
+button.clicked.connect(lambda: status.setText("Clicked!"))
+layout.addWidget(status)
+layout.addWidget(button)
+window.setLayout(layout)
+window.show()
+app.exec()
+```
+
+Supported surface: see [SYNTAX_COVERAGE.md](SYNTAX_COVERAGE.md) for the
+exact, honest list (the daily-driver core: windows, labels, buttons,
+checkboxes, box layouts, signals, a `setStyleSheet` subset). Anything not
+yet implemented raises a clear error naming that file. The window host is
+chosen at runtime: **PySide6/PyQt6** if installed, otherwise a stdlib
+tkinter window — the same code runs either way, always rendered by BUI.
+
+### tkinter syntax — `bui.tksyntax`
+
+```python
+from bui.tksyntax import Tk, Label, Button, Checkbutton
+
+root = Tk()
+root.title("BUI — tkinter syntax")
+root.geometry("420x260")
+status = Label(root, text="")
+status.pack()
+Button(root, text="Click me", command=lambda: status.setText("Clicked!")).pack(pady=4)
+Checkbutton(root, text="Enable feature").pack()
+root.mainloop()
+```
+
+Runs on the Python standard library alone. `pack(side=, padx=, pady=)`,
+`place(x=, y=)`, `config(**kw)`, `invoke()` are supported; widgets render onto
+a tk.Canvas **via the BUI sink**, so swapping the host renderer (Qt, SVG,
+custom) changes nothing in app code.
+
+## Testing the Python bindings
+
+`buipy` is a **compiled extension** — it lives in the CMake build tree and is
+built for one specific interpreter. `ModuleNotFoundError: No module named
+'buipy'` means Python cannot find (or cannot load) that file. Three ways to
+fix, fastest first:
+
+**1. Nothing to install (auto-locate).** `import bui` finds the extension in
+`build*/bindings/python` automatically. Just build and run:
+
+```sh
+cmake -S . -B build -G "MinGW Makefiles"
+cmake --build build --target buipy
+python examples/python_demo.py            # needs the interpreter CMake used
+```
+
+**2. Match the interpreter.** The extension only loads in the interpreter it
+was built for (CMake found Python 3.14 on this machine →
+`buipy.cp314-win_amd64.pyd`). Check which one CMake picked and run that one:
+
+```sh
+grep Python3_EXECUTABLE build/CMakeCache.txt
+C:/Users/ppmpr/AppData/Local/Programs/Python/Python314/python.exe examples/python_demo.py
+```
+
+To target a different interpreter, point CMake at it explicitly:
+
+```sh
+cmake -S . -B build-py312 -DPython3_EXECUTABLE="C:/Path/Python312/python.exe"
+cmake --build build-py312 --target buipy
+```
+
+**3. pip install (no PYTHONPATH ever again):**
+
+```sh
+cmake --build build --target buipy
+python -m pip install bindings/python     # stages bui/ + the .pyd into site-packages
+python -c "import bui; print(bui.version())"
+```
+
+Sanity check either way:
+
+```sh
+python -c "import bui; print(bui.version())"     # -> 0.1.0
+python -m pytest bindings/python/tests           # or: ctest --test-dir build
+```
+
+## Wire format reference
+
+| Callback | Payload |
+|---|---|
+| `begin_frame(w, h)` | Start of a frame batch; viewport in pixels |
+| `scissor(x, y, w, h)` | Clip rect; `w`/`h` ≤ 0 clears clipping |
+| `triangles(coords, colors, n)` | Non-indexed triangles, 3 vertices each |
+| `lines(coords, colors, n)` | Line list, endpoints in pairs |
+| `points(coords, colors, n, size)` | Points at `size` pixels |
+| `text(x, y, text, size, rgba)` | UTF-8 text run at baseline |
+| `end_frame()` | End of frame batch |
+
+All coordinates are 2D floats; colors RGBA floats 0..1. Callbacks may be
+invoked with or without the GIL held — the Python bindings handle this
+internally.