/* ============================================================================= * SleelaUI public C ABI implementation. * * This file is the entire surface the installed header promises: it owns the * App/Window lifecycle, builds widgets into the tree, and marshals the flat C * configuration calls onto the C++ objects. Everything here has C linkage. * * Max Rupplin -- MEARVK LLC -- 2026 * ===========================================================================*/ #include "sleela_ui.h" #include "slui_backend.hpp" #include "slui_theme.hpp" #include "slui_widget.hpp" #include "slui_window.hpp" #include #include #include #include #if defined(_WIN32) # include # include #elif defined(__APPLE__) # include # include # include extern char **environ; #else # include # include extern char **environ; #endif /* ---- App ----------------------------------------------------------------- */ struct SLUIApp { std::unique_ptr backend; std::vector> windows; std::string app_id; }; /* The public SLUIWindow / SLUIWidget are just aliases for the C++ objects; we * reinterpret_cast between them at the boundary. */ static slui::Window* as_window(SLUIWindow* w) { return reinterpret_cast(w); } static slui::Widget* as_widget(SLUIWidget* w) { return reinterpret_cast(w); } static const slui::Widget* as_widget(const SLUIWidget* w) { return reinterpret_cast(w); } extern "C" { const char* slui_version_string(void) { return SLUI_VERSION_STRING; } int slui_wifi_open_settings(void) { #if defined(_WIN32) HINSTANCE result = ShellExecuteA(NULL, "open", "ms-settings:network-wifi", NULL, NULL, SW_SHOWNORMAL); return reinterpret_cast(result) > 32 ? SLUI_OK : SLUI_ERR_BACKEND; #elif defined(__APPLE__) pid_t pid = 0; char *const argv[] = {const_cast("open"), const_cast("x-apple.systempreferences:com.apple.wifi"), nullptr}; if (posix_spawnp(&pid, "open", nullptr, nullptr, argv, environ) != 0) return SLUI_ERR_BACKEND; return SLUI_OK; #else /* Launch only fixed executable/argument pairs; never pass user text to a * shell. Prefer NetworkManager's editor, then GNOME network settings. */ pid_t pid = 0; char *const nm_argv[] = {const_cast("nm-connection-editor"), nullptr}; if (posix_spawnp(&pid, "nm-connection-editor", nullptr, nullptr, nm_argv, environ) == 0) return SLUI_OK; char *const cc_argv[] = {const_cast("gnome-control-center"), const_cast("wifi"), nullptr}; if (posix_spawnp(&pid, "gnome-control-center", nullptr, nullptr, cc_argv, environ) == 0) return SLUI_OK; return SLUI_ERR_UNSUPPORTED; #endif } SLUIBackend slui_backend(void) { #if defined(SLUI_BACKEND_WIN32_BUILD) return SLUI_BACKEND_WIN32; #elif defined(SLUI_BACKEND_COCOA_BUILD) return SLUI_BACKEND_COCOA; #elif defined(SLUI_BACKEND_X11_BUILD) return SLUI_BACKEND_X11; #else return SLUI_BACKEND_UNKNOWN; #endif } const char* slui_backend_name(SLUIBackend backend) { switch (backend) { case SLUI_BACKEND_WIN32: return "win32"; case SLUI_BACKEND_COCOA: return "cocoa"; case SLUI_BACKEND_X11: return "x11"; default: return "unknown"; } } /* ---- App lifecycle ------------------------------------------------------- */ SLUIApp* slui_app_create(const char* app_id) { auto app = new (std::nothrow) SLUIApp(); if (!app) return nullptr; app->app_id = app_id ? app_id : "com.mearvk.SleelaUI"; app->backend = slui::create_backend(app->app_id); if (!app->backend) { delete app; return nullptr; } return app; } void slui_app_destroy(SLUIApp* app) { if (!app) return; app->windows.clear(); app->backend.reset(); delete app; } int slui_app_pump(SLUIApp* app, int block) { if (!app || !app->backend) return SLUI_ERR_INVALID; return app->backend->pump(block != 0); } int slui_app_run(SLUIApp* app) { if (!app || !app->backend) return SLUI_ERR_INVALID; int exit_code = 0; for (;;) { if (app->backend->should_quit(&exit_code)) break; /* Stop when every window has closed. */ bool any_open = false; for (auto& w : app->windows) if (!w->closed()) { any_open = true; break; } if (!any_open && !app->windows.empty()) break; int n = app->backend->pump(true); if (n < 0) { exit_code = n; break; } } return exit_code; } void slui_app_quit(SLUIApp* app, int exit_code) { if (app && app->backend) app->backend->quit(exit_code); } SLUIStatus slui_screen_size(SLUIApp* app, int* w, int* h) { if (!app || !app->backend) return SLUI_ERR_INVALID; int sw = 0, sh = 0; if (!app->backend->screen_size(&sw, &sh)) return SLUI_ERR_INVALID; if (w) *w = sw; if (h) *h = sh; return SLUI_OK; } /* ---- Window -------------------------------------------------------------- */ SLUIWindow* slui_window_create(SLUIApp* app, const SLUIWindowConfig* config) { if (!app || !config) return nullptr; auto win = std::make_unique(app, app->backend.get(), *config); slui::Window* raw = win.get(); app->windows.push_back(std::move(win)); return reinterpret_cast(raw); } void slui_window_destroy(SLUIWindow* window) { if (!window) return; slui::Window* w = as_window(window); w->hide(); /* Ownership stays with the App's vector; mark hidden/closed. The App frees * it at destroy time. This keeps the simple handle model safe. */ } void slui_window_show(SLUIWindow* window) { if (window) as_window(window)->show(); } int slui_window_closed(const SLUIWindow* window) { if (!window) return 0; return as_window(const_cast(window))->closed() ? 1 : 0; } void slui_window_hide(SLUIWindow* window) { if (window) as_window(window)->hide(); } void slui_window_set_title(SLUIWindow* window, const char* title) { if (window) as_window(window)->set_title(title ? title : ""); } SLUIWidget* slui_window_root(SLUIWindow* window) { if (!window) return nullptr; return as_window(window)->root_handle(); } const SLUITheme* slui_window_theme(const SLUIWindow* /*window*/) { /* The decoded theme lives inside the Window; we don't retain the ABI copy. * Hosts that need the palette should keep the SLUITheme they passed in. */ return nullptr; } void slui_window_set_theme(SLUIWindow* window, const SLUITheme* theme) { if (!window || !theme) return; as_window(window)->set_theme(slui::Theme::from_abi(*theme)); } void slui_window_request_redraw(SLUIWindow* window) { if (window) as_window(window)->request_redraw(); } void slui_window_render(SLUIWindow* window) { if (window) as_window(window)->render(); } void slui_window_set_buffering(SLUIWindow* window, int mode) { if (!window) return; if (mode < SLUI_BUFFERING_SINGLE) mode = SLUI_BUFFERING_SINGLE; if (mode > SLUI_BUFFERING_TRIPLE) mode = SLUI_BUFFERING_TRIPLE; as_window(window)->set_buffering(static_cast(mode)); } int slui_window_buffering(const SLUIWindow* window) { if (!window) return SLUI_BUFFERING_SINGLE; return static_cast( as_window(const_cast(window))->buffering()); } SLUIStatus slui_window_set_min_size(SLUIWindow* window, int width, int height) { return window ? as_window(window)->set_min_size(width, height) : SLUI_ERR_INVALID; } SLUIStatus slui_window_set_max_size(SLUIWindow* window, int width, int height) { return window ? as_window(window)->set_max_size(width, height) : SLUI_ERR_INVALID; } SLUIStatus slui_window_set_size_limits(SLUIWindow* window, int minw, int minh, int maxw, int maxh) { return window ? as_window(window)->set_size_limits(minw, minh, maxw, maxh) : SLUI_ERR_INVALID; } SLUIStatus slui_window_get_min_size(const SLUIWindow* window, SLUISize* out) { return window ? as_window(const_cast(window))->get_min_size(out) : SLUI_ERR_INVALID; } SLUIStatus slui_window_get_max_size(const SLUIWindow* window, SLUISize* out) { return window ? as_window(const_cast(window))->get_max_size(out) : SLUI_ERR_INVALID; } void slui_window_set_event_handler(SLUIWindow* window, SLUIEventHandler handler, void* user) { if (window) as_window(window)->set_event_handler(handler, user); } /* ---- Widget construction ------------------------------------------------- */ static SLUIWidget* attach(SLUIWidget* parent, std::unique_ptr w) { if (!parent) return nullptr; slui::Widget* p = as_widget(parent); slui::Widget* raw = p->add_child(std::move(w)); /* Propagate the invalidate hook from the parent so the new widget can ask * its window to repaint. */ return reinterpret_cast(raw); } SLUIWidget* slui_box(SLUIWidget* parent, SLUIOrientation orient, int spacing) { return attach(parent, std::make_unique(orient, spacing)); } SLUIWidget* slui_header_bar(SLUIWidget* parent) { return attach(parent, std::make_unique()); } SLUIWidget* slui_label(SLUIWidget* parent, const char* text) { return attach(parent, std::make_unique(text ? text : "")); } SLUIWidget* slui_button(SLUIWidget* parent, const char* text) { return attach(parent, std::make_unique(text ? text : "")); } SLUIWidget* slui_toggle(SLUIWidget* parent, const char* text, int initial_on) { return attach(parent, std::make_unique(text ? text : "", initial_on != 0)); } SLUIWidget* slui_entry(SLUIWidget* parent, const char* placeholder) { return attach(parent, std::make_unique(placeholder ? placeholder : "")); } SLUIWidget* slui_slider(SLUIWidget* parent, double min, double max, double value) { return attach(parent, std::make_unique(min, max, value)); } SLUIWidget* slui_separator(SLUIWidget* parent, SLUIOrientation orient) { return attach(parent, std::make_unique(orient)); } SLUIWidget* slui_spacer(SLUIWidget* parent) { return attach(parent, std::make_unique()); } /* ---- Expanded widget collection ------------------------------------------ */ SLUIWidget* slui_check_box(SLUIWidget* parent, const char* text, int on) { return attach(parent, std::make_unique(text ? text : "", on != 0)); } SLUIWidget* slui_radio_button(SLUIWidget* parent, const char* text, int group, int on) { return attach(parent, std::make_unique(text ? text : "", group, on != 0)); } SLUIWidget* slui_combo_box(SLUIWidget* parent) { return attach(parent, std::make_unique()); } void slui_combo_box_add(SLUIWidget* combo, const char* option) { if (combo && option) { auto* c = dynamic_cast(as_widget(combo)); if (c) c->add_option(option); } } SLUIWidget* slui_spin_button(SLUIWidget* parent, double min, double max, double step, double value) { return attach(parent, std::make_unique(min, max, step, value)); } SLUIWidget* slui_progress_bar(SLUIWidget* parent, double fraction) { return attach(parent, std::make_unique(fraction)); } SLUIWidget* slui_level_bar(SLUIWidget* parent, double fraction) { return attach(parent, std::make_unique(fraction)); } SLUIWidget* slui_spinner(SLUIWidget* parent) { return attach(parent, std::make_unique()); } SLUIWidget* slui_scroll_bar(SLUIWidget* parent, SLUIOrientation orient, double value, double page) { return attach(parent, std::make_unique(orient, value, page)); } SLUIWidget* slui_scrolled_view(SLUIWidget* parent, int policy_h, int policy_v) { return attach(parent, std::make_unique(policy_h, policy_v)); } void slui_scrolled_view_scroll_to(SLUIWidget* view, int x, int y) { if (!view) return; auto* w = as_widget(view); if (w->kind() != slui::WidgetKind::ScrolledView) return; auto* sv = static_cast(w); sv->set_scroll_x(x); sv->set_scroll_y(y); } void slui_scrolled_view_scroll_by(SLUIWidget* view, int dx, int dy) { if (!view) return; auto* w = as_widget(view); if (w->kind() != slui::WidgetKind::ScrolledView) return; static_cast(w)->scroll_by(dx, dy); } int slui_scrolled_view_scroll_x(SLUIWidget* view) { if (!view) return 0; auto* w = as_widget(view); if (w->kind() != slui::WidgetKind::ScrolledView) return 0; return static_cast(w)->scroll_x(); } int slui_scrolled_view_scroll_y(SLUIWidget* view) { if (!view) return 0; auto* w = as_widget(view); if (w->kind() != slui::WidgetKind::ScrolledView) return 0; return static_cast(w)->scroll_y(); } SLUIWidget* slui_frame(SLUIWidget* parent, const char* title) { return attach(parent, std::make_unique(title ? title : "")); } SLUIWidget* slui_card(SLUIWidget* parent) { return attach(parent, std::make_unique()); } /* Shared popup surface: a normal themed card with explicit open/close state. * It remains owned by the parent widget tree, so dismissal is safe and does * not invalidate a handle retained by the SLeeLa VM. */ SLUIWidget* slui_popup_create(SLUIWidget* parent) { SLUIWidget* popup = slui_card(parent); if (popup) { slui_widget_set_visible(popup, 0); /* A popup floats forward of the frame: mark it an overlay so the Window * paints it last (above everything) and unclipped, instead of inline in * its parent's layout where later siblings would paint over it. */ as_widget(popup)->set_overlay(true); } return popup; } void slui_popup_set_open(SLUIWidget* popup, int open) { slui_widget_set_visible(popup, open != 0); } void slui_popup_set_anchor(SLUIWidget* popup, int top_left, int x) { if (popup) as_widget(popup)->set_overlay_anchor(top_left != 0, x); } void slui_popup_anchor_to(SLUIWidget* popup, SLUIWidget* trigger) { if (popup) as_widget(popup)->set_overlay_anchor_widget(trigger ? as_widget(trigger) : nullptr); } int slui_popup_is_open(const SLUIWidget* popup) { return popup ? as_widget(popup)->visible() : 0; } SLUIWidget* slui_grid(SLUIWidget* parent, int columns, int spacing) { return attach(parent, std::make_unique(columns, spacing)); } SLUIWidget* slui_status_bar(SLUIWidget* parent) { return attach(parent, std::make_unique()); } SLUIWidget* slui_image(SLUIWidget* parent, const char* glyph, int w, int h) { return attach(parent, std::make_unique(glyph ? glyph : "", w, h)); } SLUIWidget* slui_avatar(SLUIWidget* parent, const char* initial, int diameter) { return attach(parent, std::make_unique(initial ? initial : "", diameter)); } SLUIWidget* slui_badge(SLUIWidget* parent, const char* text) { return attach(parent, std::make_unique(text ? text : "")); } SLUIWidget* slui_chip(SLUIWidget* parent, const char* text) { return attach(parent, std::make_unique(text ? text : "")); } SLUIWidget* slui_heading(SLUIWidget* parent, const char* text, int size_pt) { return attach(parent, std::make_unique(text ? text : "", size_pt)); } SLUIWidget* slui_tooltip(SLUIWidget* parent, const char* text) { return attach(parent, std::make_unique(text ? text : "")); } SLUIWidget* slui_link_button(SLUIWidget* parent, const char* text) { return attach(parent, std::make_unique(text ? text : "")); } SLUIWidget* slui_search_entry(SLUIWidget* parent, const char* placeholder) { return attach(parent, std::make_unique(placeholder ? placeholder : "")); } SLUIWidget* slui_password_entry(SLUIWidget* parent, const char* placeholder) { return attach(parent, std::make_unique( placeholder ? placeholder : "")); } SLUIWidget* slui_info_bar(SLUIWidget* parent, const char* text, int severity) { return attach(parent, std::make_unique(text ? text : "", severity)); } /* ---- Motion & custom drawing --------------------------------------------- */ SLUIWidget* slui_throbber(SLUIWidget* parent, int width_px) { return attach(parent, std::make_unique(width_px)); } void slui_throbber_set_width(SLUIWidget* t, int width_px) { if (!t) return; auto* th = dynamic_cast(as_widget(t)); if (th) th->set_width_px(width_px); } void slui_throbber_set_intensity(SLUIWidget* t, double intensity) { if (!t) return; auto* th = dynamic_cast(as_widget(t)); if (th) th->set_intensity(intensity); } void slui_throbber_set_hue(SLUIWidget* t, double hue_degrees) { if (!t) return; auto* th = dynamic_cast(as_widget(t)); if (th) th->set_hue(hue_degrees); } SLUIWidget* slui_canvas_view(SLUIWidget* parent, int width, int height) { return attach(parent, std::make_unique(width, height)); } void slui_canvas_view_set_draw(SLUIWidget* view, SLUICanvasDrawFn fn, void* user) { if (!view) return; auto* cv = dynamic_cast(as_widget(view)); if (cv) cv->set_draw_fn(reinterpret_cast(fn), user); } void slui_canvas_view_set_fps(SLUIWidget* view, double fps) { if (!view) return; auto* cv = dynamic_cast(as_widget(view)); if (cv) cv->set_fps(fps); } /* ---- Widget configuration ------------------------------------------------ */ void slui_widget_set_margin(SLUIWidget* w, int top, int right, int bottom, int left) { if (w) as_widget(w)->set_margin(slui::Margin{top, right, bottom, left}); } void slui_widget_set_align(SLUIWidget* w, SLUIAlign h, SLUIAlign v) { if (w) as_widget(w)->set_align(h, v); } void slui_widget_set_expand(SLUIWidget* w, int h_expand, int v_expand) { if (w) as_widget(w)->set_expand(h_expand != 0, v_expand != 0); } void slui_widget_set_size_request(SLUIWidget* w, int min_w, int min_h) { if (w) as_widget(w)->set_size_request(min_w, min_h); } void slui_widget_set_sensitive(SLUIWidget* w, int sensitive) { if (w) as_widget(w)->set_sensitive(sensitive != 0); } void slui_widget_set_visible(SLUIWidget* w, int visible) { if (w) as_widget(w)->set_visible(visible != 0); } void slui_widget_set_text(SLUIWidget* w, const char* text) { if (w) as_widget(w)->set_text(text ? text : ""); } void slui_widget_set_icon(SLUIWidget* w, const char* asset_path, const char* symbol_name) { if (!w) return; auto* button = dynamic_cast(as_widget(w)); if (button) button->set_icon(asset_path ? asset_path : "", symbol_name ? symbol_name : ""); } size_t slui_widget_get_text(const SLUIWidget* w, char* out, size_t cap) { if (!w) return 0; std::string s = as_widget(w)->text(); if (out && cap > 0) { size_t n = s.size() < cap - 1 ? s.size() : cap - 1; std::memcpy(out, s.data(), n); out[n] = '\0'; } return s.size(); } void slui_widget_set_toggle(SLUIWidget* w, int on) { if (w) as_widget(w)->set_toggle(on != 0); } int slui_widget_get_toggle(const SLUIWidget* w) { return w ? (as_widget(w)->toggle() ? 1 : 0) : 0; } void slui_widget_set_value(SLUIWidget* w, double value) { if (w) as_widget(w)->set_value(value); } double slui_widget_get_value(const SLUIWidget* w) { return w ? as_widget(w)->value() : 0.0; } int slui_widget_take_activated(SLUIWidget* w) { return w ? (as_widget(w)->take_activated() ? 1 : 0) : 0; } int slui_widget_is_hovered(SLUIWidget* w) { return w ? (as_widget(w)->hovered() ? 1 : 0) : 0; } int slui_widget_take_pressed(SLUIWidget* w) { return w ? (as_widget(w)->take_pressed() ? 1 : 0) : 0; } int slui_widget_take_released(SLUIWidget* w) { return w ? (as_widget(w)->take_released() ? 1 : 0) : 0; } int slui_widget_take_hover_entered(SLUIWidget* w) { return w ? (as_widget(w)->take_hover_entered() ? 1 : 0) : 0; } int slui_widget_take_hover_left(SLUIWidget* w) { return w ? (as_widget(w)->take_hover_left() ? 1 : 0) : 0; } void slui_widget_set_suggested(SLUIWidget* w, int suggested) { if (w) as_widget(w)->set_suggested(suggested != 0); } void slui_widget_set_destructive(SLUIWidget* w, int destructive) { if (w) as_widget(w)->set_destructive(destructive != 0); } void slui_widget_on_activate(SLUIWidget* w, SLUIActivateHandler handler, void* user) { if (w) as_widget(w)->on_activate(handler, user); } void slui_widget_on_value_changed(SLUIWidget* w, SLUIValueHandler handler, void* user) { if (w) as_widget(w)->on_value_changed(handler, user); } } /* extern "C" */