ren-ui-python 0.1.0__py3-none-any.whl

ren_ui/native/icon.cpp

@@ -0,0 +1,79 @@
+// SPDX-License-Identifier: MIT
+// Build-time PNG -> native 16/32-pixel app icons; no Python imaging dependency.
+#include <Application.h>
+#include <AppFileInfo.h>
+#include <Bitmap.h>
+#include <File.h>
+#include <IconUtils.h>
+#include <TranslationUtils.h>
+#include <View.h>
+#include <algorithm>
+#include <cmath>
+#include <cstdio>
+#include <cstring>
+#include <memory>
+#include <stdexcept>
+#include <string>
+
+void check(status_t status, const char* operation)
+{
+    if (status != B_OK)
+        throw std::runtime_error(std::string(operation) + ": " + strerror(status));
+}
+
+void setIcon(BAppFileInfo& info, BBitmap* source, icon_size size)
+{
+    BRect bounds(0, 0, size - 1, size - 1);
+    BBitmap rgba(bounds, B_BITMAP_ACCEPTS_VIEWS, B_RGBA32);
+    BBitmap indexed(bounds, B_CMAP8);
+    check(rgba.InitCheck(), "Create RGBA icon");
+    check(indexed.InitCheck(), "Create indexed icon");
+    memset(rgba.Bits(), 0, rgba.BitsLength());
+    auto* view = new BView(bounds, "icon", B_FOLLOW_NONE, 0);
+    rgba.AddChild(view);
+    if (!rgba.Lock()) throw std::runtime_error("Cannot lock icon bitmap");
+    float width = source->Bounds().Width() + 1;
+    float height = source->Bounds().Height() + 1;
+    float scale = std::min(float(size) / width, float(size) / height);
+    float w = std::max(1.f, std::floor(width * scale));
+    float h = std::max(1.f, std::floor(height * scale));
+    float x = std::floor((size - w) / 2), y = std::floor((size - h) / 2);
+    view->SetDrawingMode(B_OP_COPY);
+    view->SetHighColor(0, 0, 0, 0);
+    view->FillRect(bounds);
+    view->SetDrawingMode(B_OP_ALPHA);
+    view->SetBlendingMode(B_PIXEL_ALPHA, B_ALPHA_COMPOSITE);
+    view->DrawBitmap(source, source->Bounds(), BRect(x, y, x + w - 1, y + h - 1),
+        B_FILTER_BITMAP_BILINEAR);
+    view->Sync();
+    rgba.Unlock();
+    check(BIconUtils::ConvertToCMAP8(&rgba, &indexed), "Convert icon palette");
+    check(info.SetIcon(&indexed, size, false), "Write app icon");
+}
+
+int main(int argc, char** argv)
+{
+    if (argc != 3) return 2;
+    try {
+        BApplication app("application/x-vnd.ren-icon-builder");
+        check(app.InitCheck(), "Connect to Haiku app_server");
+        std::unique_ptr<BBitmap> source(BTranslationUtils::GetBitmapFile(argv[1]));
+        if (!source) throw std::runtime_error("Cannot decode PNG; check Haiku PNG Translator");
+        check(source->InitCheck(), "Decode PNG");
+        if (source->Bounds().Width() >= 4096 || source->Bounds().Height() >= 4096
+            || source->BitsLength() > 64 * 1024 * 1024)
+            throw std::runtime_error("PNG icon exceeds 4096 pixels or 64 MiB");
+        BFile executable(argv[2], B_READ_WRITE);
+        check(executable.InitCheck(), "Open launcher");
+        BAppFileInfo info(&executable);
+        check(info.InitCheck(), "Open app metadata");
+        info.SetInfoLocation(B_USE_BOTH_LOCATIONS);
+        setIcon(info, source.get(), B_LARGE_ICON);
+        setIcon(info, source.get(), B_MINI_ICON);
+        puts("Generated PNG app icons: 32x32 and 16x16, resources and attributes");
+        return 0;
+    } catch (const std::exception& error) {
+        fprintf(stderr, "ren-icon: %s\n", error.what());
+        return 1;
+    }
+}

ren_ui/native/launcher.cpp

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: MIT
+// Compiled per application. Resolve the actual image, including Deskbar symlinks.
+#include <OS.h>
+#include <image.h>
+#include <Path.h>
+#include <cstdio>
+#include <cstdlib>
+#include <dlfcn.h>
+#include <string>
+#include <vector>
+#include <unistd.h>
+
+#ifndef REN_APP_NAME
+#error REN_APP_NAME must be supplied by the build tool
+#endif
+
+int main(int argc, char** argv)
+{
+    image_info image;
+    int32 cookie = 0;
+    std::string executable;
+    while (get_next_image_info(B_CURRENT_TEAM, &cookie, &image) == B_OK) {
+        if (image.type == B_APP_IMAGE) {
+            executable = image.name;
+            break;
+        }
+    }
+    BPath path(executable.c_str());
+    BPath apps;
+    BPath prefix;
+    if (executable.empty() || path.GetParent(&apps) != B_OK || apps.GetParent(&prefix) != B_OK) {
+        fprintf(stderr, "ren-ui: cannot locate application image\n");
+        return 1;
+    }
+    std::string root = std::string(prefix.Path()) + "/data/" REN_APP_NAME;
+    std::string pythonPath = root + "/runtime:" + root + "/app";
+    std::string entry = root + "/app/" REN_ENTRY;
+    if (setenv("PYTHONPATH", pythonPath.c_str(), 1) != 0
+        || setenv("REN_UI_ASSET_ROOT", (root + "/app").c_str(), 1) != 0 || chdir((root + "/app").c_str()) != 0) {
+        perror("ren-ui: application directory");
+        return 1;
+    }
+    std::vector<char*> arguments;
+    arguments.push_back(const_cast<char*>(REN_PYTHON));
+    arguments.push_back(const_cast<char*>("-s"));
+    arguments.push_back(const_cast<char*>("-B"));
+    arguments.push_back(const_cast<char*>(entry.c_str()));
+    for (int i = 1; i < argc; ++i) arguments.push_back(argv[i]);
+    arguments.push_back(nullptr);
+    // Keep this executable as the application's image so Tracker/BRoster see
+    // its own signature and resources, instead of the generic Python binary.
+    void* python = dlopen(REN_PYTHON_LIBRARY, RTLD_NOW | RTLD_GLOBAL);
+    if (!python) {
+        fprintf(stderr, "ren-ui: cannot load %s: %s\n", REN_PYTHON_LIBRARY, dlerror());
+        return 1;
+    }
+    using PythonMain = int (*)(int, char**);
+    auto run = reinterpret_cast<PythonMain>(dlsym(python, "Py_BytesMain"));
+    if (!run) {
+        fprintf(stderr, "ren-ui: Python runtime has no Py_BytesMain\n");
+        return 1;
+    }
+    return run(static_cast<int>(arguments.size()) - 1, arguments.data());
+}

ren_ui/project.py

@@ -0,0 +1,209 @@
+"""Validated, explicit application manifests; no shell interpolation."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path, PurePosixPath
+import re
+import struct
+import zlib
+import tomllib
+
+
+class ProjectError(ValueError):
+    pass
+
+
+def _string(table, key, default=None):
+    value = table.get(key, default)
+    if not isinstance(value, str) or not value.strip() or any(ord(c) < 32 for c in value):
+        raise ProjectError(f"{key} must be a nonempty, single-line string")
+    return value
+
+
+def _relative(value):
+    if not isinstance(value, str) or not value or "\\" in value or any(ord(c) < 32 for c in value):
+        raise ProjectError("Source paths must be nonempty relative POSIX paths")
+    path = PurePosixPath(value)
+    if path.is_absolute() or ".." in path.parts or str(path) == ".":
+        raise ProjectError(f"Path must stay within the project: {value}")
+    return path
+
+
+@dataclass(frozen=True)
+class Project:
+    root: Path
+    name: str
+    version: str
+    revision: int
+    title: str
+    signature: str
+    summary: str
+    description: str
+    author: str
+    license: str
+    license_file: str
+    entry: str
+    include: tuple[str, ...]
+    requires: tuple[str, ...]
+    icon: str | None = None
+
+    @property
+    def package_version(self):
+        return f"{self.version}-{self.revision}"
+
+    @classmethod
+    def load(cls, root: Path):
+        root = root.resolve()
+        try:
+            data = tomllib.loads((root / "ren.toml").read_text(encoding="utf-8"))
+        except (OSError, tomllib.TOMLDecodeError) as exc:
+            raise ProjectError(f"Cannot read {root / 'ren.toml'}: {exc}") from exc
+        unknown = set(data) - {"app", "build"}
+        if unknown:
+            raise ProjectError(f"Unknown manifest tables: {', '.join(sorted(unknown))}")
+        app, build = data.get("app", {}), data.get("build", {})
+        if not isinstance(app, dict) or not isinstance(build, dict):
+            raise ProjectError("app and build must be TOML tables")
+        unknown = set(app) - {"name", "version", "revision", "title", "signature", "summary", "description", "author", "license", "license-file", "entry", "icon"}
+        unknown |= set(build) - {"include", "requires"}
+        if unknown:
+            raise ProjectError(f"Unknown manifest keys: {', '.join(sorted(unknown))}")
+        name = _string(app, "name")
+        if not re.fullmatch(r"[a-z][a-z0-9_]*", name):
+            raise ProjectError("name must start with a lowercase letter and contain only a-z, 0-9, _")
+        version = _string(app, "version", "0.1.0")
+        if not re.fullmatch(r"[0-9]+(?:\.[0-9]+){0,3}", version):
+            raise ProjectError("version must contain 1–4 numeric components, e.g. 1.2.0")
+        revision = app.get("revision", 1)
+        if type(revision) is not int or revision < 1:
+            raise ProjectError("revision must be a positive integer")
+        signature = _string(app, "signature", f"application/x-vnd.ren-{name}")
+        if not re.fullmatch(r"application/[A-Za-z0-9][A-Za-z0-9.+_-]*", signature):
+            raise ProjectError("signature must be an application MIME type")
+        title = _string(app, "title", name)
+        if title in (".", "..") or "/" in title or "\\" in title:
+            raise ProjectError("title must be a single Deskbar filename without slashes")
+        license_name = _string(app, "license", "MIT")
+        if not re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9_.+-]*", license_name):
+            raise ProjectError("license must be a license identifier such as MIT")
+        entry = str(_relative(_string(app, "entry", "main.py")))
+        if not entry.endswith(".py"):
+            raise ProjectError("entry must be a Python file")
+        license_file = str(_relative(_string(app, "license-file", "LICENSE")))
+        include = build.get("include", [entry])
+        requires = build.get("requires", [])
+        if not isinstance(include, list) or not include:
+            raise ProjectError("build.include must be a nonempty array of source paths")
+        include = tuple(str(_relative(path)) for path in include)
+        if not isinstance(requires, list) or not all(isinstance(item, str) and re.fullmatch(
+            r"[a-zA-Z0-9_:+.\-]+(?:\s+(?:>=|<=|==|!=|>|<|=)\s+[a-zA-Z0-9_.+~\-]+)?", item
+        ) for item in requires):
+            raise ProjectError("build.requires must contain Haiku dependency expressions")
+        project = cls(root, name, version, revision, title, signature,
+                      _string(app, "summary", f"{name} application"),
+                      _string(app, "description", app.get("summary", f"{name} application")),
+                      _string(app, "author", "Unknown author"), license_name, license_file,
+                      entry, include, tuple(requires),
+                      str(_relative(_string(app, "icon"))) if "icon" in app else None)
+        if project.icon is not None:
+            project.icon_bytes()
+        files = project.source_files()
+        if entry not in files:
+            raise ProjectError("entry must be included by build.include")
+        if not project.safe_path(license_file).is_file():
+            raise ProjectError(f"License file is missing: {license_file}")
+        return project
+
+    def icon_bytes(self) -> bytes:
+        if self.icon is None:
+            return b""
+        path = self.safe_path(self.icon)
+        suffix = path.suffix.lower()
+        if suffix not in {".hvif", ".png"} or not path.is_file():
+            raise ProjectError("app.icon must name an existing .hvif or .png file")
+        limit = 64 * 1024 if suffix == ".hvif" else 16 * 1024 * 1024
+        with path.open("rb") as file:
+            data = file.read(limit + 1)
+        if suffix == ".hvif":
+            if not 7 <= len(data) <= limit or not data.startswith(b"ncif"):
+                raise ProjectError("app.icon must be an HVIF file of at most 64 KiB")
+        else:
+            if (len(data) < 33 or len(data) > limit
+                    or data[:8] != b"\x89PNG\r\n\x1a\n"
+                    or data[8:16] != b"\x00\x00\x00\rIHDR"
+                    or zlib.crc32(data[12:29]) != struct.unpack(">I", data[29:33])[0]):
+                raise ProjectError("app.icon must be a PNG file with a valid IHDR, at most 16 MiB")
+            width, height = struct.unpack(">II", data[16:24])
+            if not 1 <= width <= 4096 or not 1 <= height <= 4096:
+                raise ProjectError("PNG app.icon dimensions must be between 1 and 4096")
+            offset, pixels, ended = 8, False, False
+            while offset < len(data):
+                if offset + 12 > len(data):
+                    raise ProjectError("PNG app.icon has a truncated chunk")
+                length = struct.unpack(">I", data[offset:offset + 4])[0]
+                end = offset + length + 12
+                kind = data[offset + 4:offset + 8]
+                if end > len(data) or zlib.crc32(data[offset + 4:end - 4]) != struct.unpack(">I", data[end - 4:end])[0]:
+                    raise ProjectError("PNG app.icon has a truncated chunk or invalid CRC")
+                if kind == b"IHDR" and offset != 8:
+                    raise ProjectError("PNG app.icon has duplicate IHDR chunks")
+                pixels |= kind == b"IDAT" and length > 0
+                offset = end
+                if kind == b"IEND":
+                    ended = length == 0 and offset == len(data)
+                    break
+            if not pixels or not ended:
+                raise ProjectError("PNG app.icon needs image data and a final IEND chunk")
+
+        return data
+
+    def safe_path(self, relative: str) -> Path:
+        relative = _relative(relative)
+        current = self.root
+        for part in relative.parts:
+            current /= part
+            if current.is_symlink():
+                raise ProjectError(f"Symlinked sources are not supported: {relative}")
+        if not current.resolve().is_relative_to(self.root):
+            raise ProjectError(f"Source escapes project: {relative}")
+        return current
+
+    def source_files(self) -> dict[str, Path]:
+        files = {}
+        excluded = {".git", ".venv", "__pycache__", ".ren-build", "dist", "build"}
+        def collect(relative):
+            path = self.safe_path(relative)
+            if path.is_dir():
+                for child in sorted(path.iterdir()):
+                    if child.name not in excluded and not child.name.endswith((".pyc", ".pyo")):
+                        collect(child.relative_to(self.root).as_posix())
+            elif path.is_file():
+                files[relative] = path
+            else:
+                raise ProjectError(f"Source is missing or not a regular file: {relative}")
+        for relative in self.include:
+            collect(relative)
+        if self.icon is not None:
+            collect(self.icon)
+        return files
+
+
+def quote(value: str) -> str:
+    """Haiku PackageInfo and RDEF quoted string (not shell quoting)."""
+    return '"' + value.replace("\\", "\\\\").replace('"', '\\"') + '"'
+
+
+def package_info(project: Project, architecture: str, python_package: str, secondary: str = "") -> str:
+    suffix = f"_{secondary}" if secondary else ""
+    fields = {
+        "name": project.name, "version": project.package_version,
+        "architecture": architecture, "summary": quote(project.summary),
+        "description": quote(project.description), "packager": quote(project.author),
+        "vendor": quote(project.author), "copyrights": quote(project.author),
+        "licenses": quote(f"{project.name}_{project.license}"),
+    }
+    lines = [f"{key} {value}" for key, value in fields.items()]
+    lines += ["provides {", f"    {project.name} = {project.package_version}", "}", "requires {",
+              f"    haiku{suffix}", f"    lib:libstdc++{suffix}", f"    lib:libgcc_s{suffix}", f"    {python_package}"]
+    lines += [f"    {item}" for item in project.requires]
+    return "\n".join(lines + ["}", ""])

ren_ui/resources.py

@@ -0,0 +1,30 @@
+"""Locate assets identically in a source project and an installed HPKG."""
+from __future__ import annotations
+
+import os
+from pathlib import Path
+import sys
+
+
+def asset_path(name: str | Path) -> Path:
+    """Resolve a project-relative resource; ren run and the launcher set the root."""
+    path = Path(name)
+    if path.is_absolute() or '..' in path.parts:
+        raise ValueError("Asset name must be relative to the application directory")
+    root = os.environ.get("REN_UI_ASSET_ROOT")
+    if root is None:
+        entry = getattr(sys.modules.get("__main__"), "__file__", None)
+        if not entry:
+            raise RuntimeError("Use ren run or set REN_UI_ASSET_ROOT to the project directory")
+        root = str(Path(entry).resolve().parent)
+    return Path(root).resolve() / path
+
+
+def image_path(source: str | Path) -> Path:
+    if not isinstance(source, (str, Path)) or not str(source) or '\0' in str(source):
+        raise ValueError("Image source must be a nonempty file path without NUL characters")
+    path = Path(source)
+    path = path if path.is_absolute() else asset_path(path)
+    if not path.is_file():
+        raise ValueError(f"Image file not found: {path}")
+    return path.resolve()

ren_ui/system.py

@@ -0,0 +1,70 @@
+"""Selected Application Kit and Storage Kit services (require an active app)."""
+import os
+from pathlib import Path
+
+from .app import Application
+from ._native import utf8
+
+
+def _native():
+    app = Application._current
+    if app is None or app._closed:
+        raise RuntimeError("Show a window before using Haiku services")
+    app._check_ui_thread()
+    return app._native
+
+
+def alert(text: str, *, title="Message"):
+    _native().call("alert", utf8(title), utf8(text))
+
+
+def confirm(text: str, *, title="Confirm", accept="OK", cancel="Cancel") -> bool:
+    """Show a native two-button dialog; Escape/cancel returns False."""
+    return _native().call("confirm", utf8(title), utf8(text), utf8(accept), utf8(cancel)) == 1
+
+
+def _file_panel(save: bool, title: str | None, directory: str | Path | None, name: str = "") -> Path | None:
+    start = ""
+    if directory is not None:
+        if not Path(directory).is_dir():
+            raise ValueError("directory must be an existing directory")
+        start = str(Path(directory).resolve())
+    if "/" in name:
+        raise ValueError("name must be a file name without a directory")
+    path = _native().call("file_panel", int(save), utf8(title or ""), utf8(start), utf8(name))
+    return Path(os.fsdecode(path)) if path else None
+
+
+def open_file(*, title: str | None = None, directory: str | Path | None = None) -> Path | None:
+    """Let the user pick an existing file in a native panel; None if cancelled."""
+    return _file_panel(False, title, directory)
+
+
+def save_file(*, title: str | None = None, directory: str | Path | None = None, name: str = "") -> Path | None:
+    """Let the user choose where to save; None if cancelled. Writes nothing."""
+    return _file_panel(True, title, directory, name)
+
+
+def set_clipboard(text: str):
+    _native().call("clipboard_set", utf8(text))
+
+
+def get_clipboard() -> str:
+    return _native().call("clipboard_get").decode("utf-8")
+
+
+def open_url(url: str):
+    """Ask BRoster to open an http, https or mailto URL."""
+    if url.split(":", 1)[0].lower() not in ("http", "https", "mailto"):
+        raise ValueError("Supported URL schemes: http, https, mailto")
+    _native().call("launch", utf8(url))
+
+
+def settings_directory(app_name: str, *, create=True) -> Path:
+    if not app_name or app_name in (".", "..") or "/" in app_name or "\\" in app_name:
+        raise ValueError("app_name must be a single directory name")
+    utf8(app_name)
+    directory = Path(_native().call("directory", 0).decode("utf-8")) / app_name
+    if create:
+        directory.mkdir(parents=True, exist_ok=True)
+    return directory