bunite-core 0.6.0 → 0.8.1

package/src/native/linux/bunite_linux_runtime.cpp

@@ -0,0 +1,120 @@
+#include "bunite_linux_internal.h"
+
+#include <cstdlib>
+#include <string>
+#include <vector>
+
+namespace bunite_linux {
+
+RuntimeState g_runtime;
+
+bool isOnMainThread() {
+  return g_runtime.ui_thread_set && pthread_equal(pthread_self(), g_runtime.ui_thread);
+}
+
+}  // namespace bunite_linux
+
+namespace {
+
+constexpr int32_t kBuniteAbiVersion = 4;
+
+}  // namespace
+
+extern "C" BUNITE_EXPORT int32_t bunite_abi_version(void) { return kBuniteAbiVersion; }
+extern "C" BUNITE_EXPORT void bunite_set_log_level(int32_t level) { (void)level; }
+
+extern "C" BUNITE_EXPORT const char* bunite_engine_name(void) { return "webkitgtk"; }
+
+extern "C" BUNITE_EXPORT const char* bunite_engine_version(void) {
+  static std::string cached =
+    std::to_string(webkit_get_major_version()) + "." +
+    std::to_string(webkit_get_minor_version()) + "." +
+    std::to_string(webkit_get_micro_version());
+  return cached.c_str();
+}
+
+extern "C" BUNITE_EXPORT bool bunite_init(
+  const char* engine_dir, bool hide_console, bool popup_blocking, const char* engine_config_json
+) {
+  (void)engine_dir; (void)hide_console; (void)engine_config_json;
+  auto& rt = bunite_linux::g_runtime;
+  if (rt.initialized) return true;
+  rt.popup_blocking = popup_blocking;
+  rt.ui_thread = pthread_self();
+  rt.ui_thread_set = true;
+  rt.ui_context = g_main_context_default();
+
+  gtk_init();
+
+  GtkApplication* app = gtk_application_new("dev.bunite.app", G_APPLICATION_NON_UNIQUE);
+  GError* err = nullptr;
+  const gboolean registered = g_application_register(G_APPLICATION(app), nullptr, &err);
+  if (!registered) {
+    BUNITE_ERROR("bunite_init: g_application_register failed: %s", err ? err->message : "(unknown)");
+    if (err) g_error_free(err);
+    g_object_unref(app);
+    rt.ui_context = nullptr;
+    rt.ui_thread_set = false;
+    return false;
+  }
+
+  rt.app = app;
+  rt.initialized = true;
+  return true;
+}
+
+// JS drives the default GLib context from Bun's loop.
+extern "C" BUNITE_EXPORT void bunite_run_loop(void) {}
+extern "C" BUNITE_EXPORT void bunite_pump_once(void) {
+  if (!bunite_linux::isOnMainThread()) {
+    BUNITE_WARN("bunite_pump_once called off the GTK thread; ignoring.");
+    return;
+  }
+  GMainContext* ctx = bunite_linux::g_runtime.ui_context;
+  if (!ctx) return;
+
+  const gint64 deadline = g_get_monotonic_time() + 5000;  // 5ms
+  do {
+    if (!g_main_context_pending(ctx)) break;
+    g_main_context_iteration(ctx, FALSE);
+  } while (g_get_monotonic_time() < deadline);
+}
+
+extern "C" BUNITE_EXPORT void bunite_quit(void) {
+  auto& rt = bunite_linux::g_runtime;
+  if (!rt.initialized) return;
+  rt.shutting_down.store(true);
+
+  std::vector<GtkWindow*> windows;
+  {
+    std::lock_guard<std::mutex> lock(rt.object_mutex);
+    for (auto& [_, state] : rt.windows) {
+      if (state.window) windows.push_back(state.window);
+    }
+  }
+  for (GtkWindow* window : windows) {
+    gtk_window_destroy(window);
+  }
+
+  if (rt.app) {
+    g_application_quit(G_APPLICATION(rt.app));
+    g_object_unref(rt.app);
+    rt.app = nullptr;
+  }
+  rt.ui_context = nullptr;
+  rt.ui_thread_set = false;
+  rt.initialized = false;
+  rt.shutting_down.store(false);
+}
+
+extern "C" BUNITE_EXPORT void bunite_free_cstring(const char* value) {
+  std::free(const_cast<char*>(value));
+}
+
+extern "C" BUNITE_EXPORT void bunite_set_webview_event_handler(BuniteWebviewEventHandler handler) {
+  bunite_linux::g_runtime.webview_event_handler = handler;
+}
+
+extern "C" BUNITE_EXPORT void bunite_set_window_event_handler(BuniteWindowEventHandler handler) {
+  bunite_linux::g_runtime.window_event_handler = handler;
+}

package/src/native/linux/bunite_linux_utils.cpp

@@ -0,0 +1,114 @@
+#include "bunite_linux_internal.h"
+
+#include <json-glib/json-glib.h>
+
+#include <cctype>
+#include <cstdio>
+#include <cstring>
+
+namespace bunite_linux {
+
+void emitWindowEvent(uint32_t window_id, const char* event_name, const std::string& payload) {
+  if (BuniteWindowEventHandler h = g_runtime.window_event_handler) {
+    h(window_id, strdup(event_name ? event_name : ""), strdup(payload.c_str()));
+  }
+}
+
+void emitWebviewEvent(uint32_t view_id, const char* event_name, const std::string& payload) {
+  if (BuniteWebviewEventHandler h = g_runtime.webview_event_handler) {
+    h(view_id, strdup(event_name ? event_name : ""), strdup(payload.c_str()));
+  }
+}
+
+std::string escapeJsonString(const std::string& value) {
+  std::string out;
+  out.reserve(value.size() + 8);
+  for (unsigned char c : value) {
+    switch (c) {
+      case '"':  out += "\\\""; break;
+      case '\\': out += "\\\\"; break;
+      case '\b': out += "\\b"; break;
+      case '\f': out += "\\f"; break;
+      case '\n': out += "\\n"; break;
+      case '\r': out += "\\r"; break;
+      case '\t': out += "\\t"; break;
+      default:
+        if (c < 0x20) {
+          char buf[8];
+          std::snprintf(buf, sizeof(buf), "\\u%04x", c);
+          out += buf;
+        } else {
+          out += static_cast<char>(c);
+        }
+    }
+  }
+  return out;
+}
+
+bool globMatchCaseInsensitive(const std::string& pattern, const std::string& value) {
+  size_t pi = 0, vi = 0;
+  size_t star_p = std::string::npos, star_v = 0;
+  while (vi < value.size()) {
+    if (pi < pattern.size() &&
+        std::tolower(static_cast<unsigned char>(pattern[pi])) ==
+        std::tolower(static_cast<unsigned char>(value[vi]))) {
+      ++pi; ++vi;
+    } else if (pi < pattern.size() && pattern[pi] == '*') {
+      star_p = pi++; star_v = vi;
+    } else if (star_p != std::string::npos) {
+      pi = star_p + 1; vi = ++star_v;
+    } else {
+      return false;
+    }
+  }
+  while (pi < pattern.size() && pattern[pi] == '*') ++pi;
+  return pi == pattern.size();
+}
+
+std::vector<std::string> parseNavigationRulesJson(const std::string& json) {
+  std::vector<std::string> rules;
+  if (json.empty()) return rules;
+
+  JsonParser* parser = json_parser_new();
+  if (!json_parser_load_from_data(parser, json.c_str(), (gssize)json.size(), nullptr)) {
+    g_object_unref(parser);
+    return rules;
+  }
+  JsonNode* root = json_parser_get_root(parser);
+  if (!root || JSON_NODE_TYPE(root) != JSON_NODE_ARRAY) {
+    g_object_unref(parser);
+    return rules;
+  }
+  JsonArray* arr = json_node_get_array(root);
+  const guint n = json_array_get_length(arr);
+  rules.reserve(n);
+  for (guint i = 0; i < n; ++i) {
+    JsonNode* item = json_array_get_element(arr, i);
+    if (!item || json_node_get_value_type(item) != G_TYPE_STRING) continue;
+    const gchar* s = json_node_get_string(item);
+    if (s && *s) rules.emplace_back(s);
+  }
+  g_object_unref(parser);
+  return rules;
+}
+
+bool shouldAlwaysAllowNavigationUrl(const std::string& url) {
+  return url == "about:blank" ||
+         url.rfind("appres://app.internal/internal/", 0) == 0;
+}
+
+bool shouldAllowNavigation(const ViewState* view, const std::string& url) {
+  if (!view || shouldAlwaysAllowNavigationUrl(url) || view->navigation_rules.empty()) {
+    return true;
+  }
+  bool allowed = true;  // default-allow, last-match-wins
+  for (const std::string& raw : view->navigation_rules) {
+    const bool block = !raw.empty() && raw.front() == '^';
+    const std::string pattern = block ? raw.substr(1) : raw;
+    if (pattern.empty()) continue;
+    if (globMatchCaseInsensitive(pattern, url)) allowed = !block;
+  }
+  return allowed;
+}
+
+}  // namespace bunite_linux

package/src/native/linux/bunite_linux_view.cpp

@@ -0,0 +1,244 @@
+#include "bunite_linux_internal.h"
+#include "webview_storage.h"
+
+#include <string>
+#include <vector>
+
+namespace bunite_linux {
+
+namespace {
+
+constexpr const char* kViewIdKey = "bunite-view-id";
+
+void emit_url(uint32_t view_id, const char* name, WebKitWebView* wv) {
+  const char* uri = webkit_web_view_get_uri(wv);
+  emitWebviewEvent(view_id, name, uri ? std::string(uri) : std::string{});
+}
+
+void on_load_changed(WebKitWebView* wv, WebKitLoadEvent event, gpointer user_data) {
+  const uint32_t view_id = GPOINTER_TO_UINT(user_data);
+  switch (event) {
+    case WEBKIT_LOAD_COMMITTED:
+      emit_url(view_id, "did-navigate", wv);
+      queueViewRedraw(wv);
+      break;
+    case WEBKIT_LOAD_FINISHED:
+      emit_url(view_id, "dom-ready", wv);
+      queueViewRedraw(wv);
+      break;
+    default: break;
+  }
+}
+
+GtkWidget* on_create(WebKitWebView* wv, WebKitNavigationAction* action, gpointer user_data) {
+  const uint32_t view_id = GPOINTER_TO_UINT(user_data);
+  WebKitURIRequest* req = webkit_navigation_action_get_request(action);
+  const char* uri = webkit_uri_request_get_uri(req);
+  std::string payload = "{\"url\":\"" + escapeJsonString(uri ? uri : "") + "\"}";
+  emitWebviewEvent(view_id, "new-window-open", payload);
+  (void)wv;
+  return nullptr;  // cancel; JS opens via load_url if desired
+}
+
+// WebKitGTK fires nav-action for sub-frames with no main-frame discriminator — iframes hit nav rules.
+gboolean on_decide_policy(WebKitWebView* wv, WebKitPolicyDecision* decision,
+                          WebKitPolicyDecisionType type, gpointer user_data) {
+  (void)wv;
+  if (type != WEBKIT_POLICY_DECISION_TYPE_NAVIGATION_ACTION &&
+      type != WEBKIT_POLICY_DECISION_TYPE_NEW_WINDOW_ACTION) return FALSE;
+  const uint32_t view_id = GPOINTER_TO_UINT(user_data);
+  auto* nav = WEBKIT_NAVIGATION_POLICY_DECISION(decision);
+  WebKitNavigationAction* action = webkit_navigation_policy_decision_get_navigation_action(nav);
+  WebKitURIRequest* request = webkit_navigation_action_get_request(action);
+  const char* uri = webkit_uri_request_get_uri(request);
+  const std::string url_str = uri ? uri : "";
+  const bool allow = shouldAllowNavigation(findView(view_id), url_str);
+  emitWebviewEvent(view_id, "will-navigate", url_str);
+  if (allow) webkit_policy_decision_use(decision);
+  else webkit_policy_decision_ignore(decision);
+  return TRUE;
+}
+
+}  // namespace
+
+ViewState* findView(uint32_t view_id) {
+  std::lock_guard<std::mutex> lock(g_runtime.object_mutex);
+  auto it = g_runtime.views.find(view_id);
+  return it == g_runtime.views.end() ? nullptr : &it->second;
+}
+
+uint32_t viewIdForWebView(WebKitWebView* wv) {
+  if (!wv) return 0;
+  return GPOINTER_TO_UINT(g_object_get_data(G_OBJECT(wv), kViewIdKey));
+}
+
+bool createView(uint32_t view_id, uint32_t window_id,
+                const char* url, const char* html, const char* preload, const char* appres_root,
+                const char* navigation_rules_json, const char* preload_origins_json,
+                double x, double y, double width, double height, bool auto_resize) {
+  auto* window_state = findWindow(window_id);
+  if (!window_state) {
+    BUNITE_ERROR("bunite_view_create: window %u not found", window_id);
+    return false;
+  }
+  if (findView(view_id)) {
+    BUNITE_ERROR("bunite_view_create: view %u already exists", view_id);
+    return false;
+  }
+
+  WebKitUserContentManager* ucm = webkit_user_content_manager_new();
+
+  // Origin-gate the preload so http(s) navigations don't inherit the RPC bridge.
+  if (preload && *preload) {
+    const char* origins = (preload_origins_json && *preload_origins_json)
+      ? preload_origins_json : "[]";
+    std::string gated;
+    gated.reserve(strlen(preload) + 128);
+    gated += "(function(){var _o=";
+    gated += origins;
+    gated += ";_o.push('appres://app.internal');";
+    gated += "if(_o.indexOf(location.origin)<0)return;";
+    gated += preload;
+    gated += "})();";
+    WebKitUserScript* script = webkit_user_script_new(
+      gated.c_str(),
+      WEBKIT_USER_CONTENT_INJECT_TOP_FRAME,
+      WEBKIT_USER_SCRIPT_INJECT_AT_DOCUMENT_START,
+      nullptr, nullptr);
+    webkit_user_content_manager_add_script(ucm, script);
+    webkit_user_script_unref(script);
+  }
+
+  WebKitWebView* wv = WEBKIT_WEB_VIEW(g_object_new(
+    WEBKIT_TYPE_WEB_VIEW,
+    "user-content-manager", ucm,
+    nullptr));
+  g_object_unref(ucm);
+
+  WebKitSettings* settings = webkit_web_view_get_settings(wv);
+  webkit_settings_set_javascript_can_open_windows_automatically(settings, !g_runtime.popup_blocking);
+
+  g_object_set_data(G_OBJECT(wv), kViewIdKey, GUINT_TO_POINTER(view_id));
+  registerAppresScheme(webkit_web_view_get_context(wv));
+
+  g_signal_connect(wv, "load-changed", G_CALLBACK(on_load_changed), GUINT_TO_POINTER(view_id));
+  g_signal_connect(wv, "decide-policy", G_CALLBACK(on_decide_policy), GUINT_TO_POINTER(view_id));
+  g_signal_connect(wv, "create", G_CALLBACK(on_create), GUINT_TO_POINTER(view_id));
+
+  GtkWidget* container = GTK_WIDGET(wv);
+  if (auto_resize) {
+    gtk_overlay_set_child(window_state->host, GTK_WIDGET(wv));
+  } else {
+    container = gtk_fixed_new();
+    gtk_widget_set_halign(container, GTK_ALIGN_START);
+    gtk_widget_set_valign(container, GTK_ALIGN_START);
+    gtk_widget_set_overflow(container, GTK_OVERFLOW_HIDDEN);
+    gtk_fixed_put(GTK_FIXED(container), GTK_WIDGET(wv), 0, 0);
+    gtk_overlay_add_overlay(window_state->host, container);
+  }
+
+  {
+    std::lock_guard<std::mutex> lock(g_runtime.object_mutex);
+    auto& st = g_runtime.views[view_id];
+    st.webview = wv;
+    st.container = container;
+    st.window_id = window_id;
+    st.appres_root = appres_root ? appres_root : "";
+    st.preload_script = preload ? preload : "";
+    st.navigation_rules = parseNavigationRulesJson(navigation_rules_json ? navigation_rules_json : "");
+  }
+
+  if (!auto_resize) applyViewBounds(view_id, x, y, width, height);
+  queueViewRedraw(wv);
+
+  if (url && *url) {
+    webkit_web_view_load_uri(wv, url);
+  } else if (html && *html) {
+    webkit_web_view_load_html(wv, html, "appres://app.internal/");
+  }
+
+  emitWebviewEvent(view_id, "view-ready", "");
+  return true;
+}
+
+void queueViewRedraw(WebKitWebView* wv) {
+  if (!wv) return;
+  GtkWidget* widget = GTK_WIDGET(wv);
+  gtk_widget_queue_resize(widget);
+  gtk_widget_queue_draw(widget);
+
+  g_object_ref(widget);
+  g_idle_add_full(G_PRIORITY_DEFAULT_IDLE,
+    +[](gpointer data) -> gboolean {
+      GtkWidget* w = GTK_WIDGET(data);
+      gtk_widget_queue_resize(w);
+      gtk_widget_queue_draw(w);
+      GtkWidget* parent = gtk_widget_get_parent(w);
+      if (parent) gtk_widget_queue_draw(parent);
+      GtkWidget* grandparent = parent ? gtk_widget_get_parent(parent) : nullptr;
+      if (grandparent) gtk_widget_queue_draw(grandparent);
+      return G_SOURCE_REMOVE;
+    },
+    widget,
+    +[](gpointer data) { g_object_unref(data); });
+}
+
+void applyViewBounds(uint32_t view_id, double x, double y, double w, double h) {
+  auto* v = findView(view_id);
+  if (!v) return;
+  const int scale = gtk_widget_get_scale_factor(GTK_WIDGET(v->webview));
+  const int s = scale > 0 ? scale : 1;
+  // floor origin, ceil far edge — preserve coverage at non-integer scales.
+  const int x0 = (int)(x / s);
+  const int y0 = (int)(y / s);
+  const int x1 = (int)((x + w + s - 1) / s);
+  const int y1 = (int)((y + h + s - 1) / s);
+  GtkWidget* widget = GTK_WIDGET(v->webview);
+  GtkWidget* container = v->container ? v->container : widget;
+  const int width = x1 - x0;
+  const int height = y1 - y0;
+  gtk_widget_set_margin_start(container, x0);
+  gtk_widget_set_margin_top(container, y0);
+  gtk_widget_set_size_request(container, width, height);
+  gtk_widget_set_size_request(widget, width, height);
+  gtk_widget_queue_resize(container);
+  gtk_widget_queue_draw(container);
+  queueViewRedraw(v->webview);
+}
+
+void detachViewSideState(uint32_t view_id) {
+  bunite::WebviewContentStorage::instance().remove(view_id);
+  std::vector<uint32_t> request_ids;
+  for (auto& [rid, p] : g_runtime.pending_route_tasks) {
+    if (p.view_id == view_id) request_ids.push_back(rid);
+  }
+  for (uint32_t rid : request_ids) {
+    auto it = g_runtime.pending_route_tasks.find(rid);
+    WebKitURISchemeRequest* req = it->second.request;
+    g_runtime.pending_route_tasks.erase(it);
+    GError* err = g_error_new_literal(G_IO_ERROR, G_IO_ERROR_CANCELLED, "view destroyed");
+    webkit_uri_scheme_request_finish_error(req, err);
+    g_error_free(err);
+    g_object_unref(req);
+  }
+}
+
+void removeView(uint32_t view_id) {
+  WebKitWebView* wv = nullptr;
+  GtkWidget* container = nullptr;
+  {
+    std::lock_guard<std::mutex> lock(g_runtime.object_mutex);
+    auto it = g_runtime.views.find(view_id);
+    if (it == g_runtime.views.end()) return;
+    wv = it->second.webview;
+    container = it->second.container;
+    g_runtime.views.erase(it);
+  }
+  detachViewSideState(view_id);
+  GtkWidget* target = container ? container : (wv ? GTK_WIDGET(wv) : nullptr);
+  if (target && gtk_widget_get_parent(target)) {
+    gtk_widget_unparent(target);
+  }
+}
+
+}  // namespace bunite_linux

package/src/native/linux/bunite_linux_window.cpp

@@ -0,0 +1,101 @@
+#include "bunite_linux_internal.h"
+
+namespace bunite_linux {
+
+namespace {
+
+gboolean on_close_request(GtkWindow* window, gpointer user_data) {
+  (void)window;
+  const uint32_t window_id = GPOINTER_TO_UINT(user_data);
+  auto* state = findWindow(window_id);
+  if (!state) return FALSE;
+  if (!state->close_pending.exchange(true)) {
+    emitWindowEvent(window_id, "close-requested", "");
+  }
+  return TRUE;  // JS must call destroy or reset_close_pending
+}
+
+void on_destroy(GtkWidget* widget, gpointer user_data) {
+  (void)widget;
+  const uint32_t window_id = GPOINTER_TO_UINT(user_data);
+  emitWindowEvent(window_id, "close", "");
+  std::vector<uint32_t> orphans;
+  bool last = false;
+  {
+    std::lock_guard<std::mutex> lock(g_runtime.object_mutex);
+    // GTK destroyed child view widgets with the parent; drop stale entries.
+    for (auto it = g_runtime.views.begin(); it != g_runtime.views.end();) {
+      if (it->second.window_id == window_id) {
+        orphans.push_back(it->first);
+        it = g_runtime.views.erase(it);
+      } else ++it;
+    }
+    g_runtime.windows.erase(window_id);
+    last = g_runtime.windows.empty();
+  }
+  for (uint32_t vid : orphans) detachViewSideState(vid);
+  if (last && !g_runtime.shutting_down.load()) {
+    emitWindowEvent(0, "all-windows-closed", "");
+  }
+}
+
+}  // namespace
+
+WindowState* findWindow(uint32_t window_id) {
+  std::lock_guard<std::mutex> lock(g_runtime.object_mutex);
+  auto it = g_runtime.windows.find(window_id);
+  return it == g_runtime.windows.end() ? nullptr : &it->second;
+}
+
+bool createWindow(uint32_t window_id, double x, double y, double width, double height,
+                  const char* title, const char* title_bar_style,
+                  bool transparent, bool hidden, bool minimized, bool maximized) {
+  (void)x; (void)y;             // GTK4/Wayland: compositor places windows
+  (void)title_bar_style;
+  (void)transparent;
+
+  if (!g_runtime.app) {
+    BUNITE_ERROR("bunite_window_create: GtkApplication not initialized");
+    return false;
+  }
+
+  GtkWindow* win = GTK_WINDOW(gtk_application_window_new(g_runtime.app));
+  if (title && *title) gtk_window_set_title(win, title);
+  gtk_window_set_default_size(win, (int)width, (int)height);
+
+  GtkOverlay* host = GTK_OVERLAY(gtk_overlay_new());
+  gtk_window_set_child(win, GTK_WIDGET(host));
+
+  const gpointer id_ptr = GUINT_TO_POINTER(window_id);
+  g_signal_connect(win, "close-request", G_CALLBACK(on_close_request), id_ptr);
+  g_signal_connect(win, "destroy", G_CALLBACK(on_destroy), id_ptr);
+
+  {
+    std::lock_guard<std::mutex> lock(g_runtime.object_mutex);
+    auto& st = g_runtime.windows[window_id];
+    st.window = win;
+    st.host = host;
+    st.close_pending.store(false);
+    st.minimized.store(minimized);
+    st.maximized.store(maximized);
+  }
+
+  if (!hidden) gtk_window_present(win);
+  if (maximized) gtk_window_maximize(win);
+  if (minimized) gtk_window_minimize(win);
+
+  return true;
+}
+
+void destroyWindow(uint32_t window_id) {
+  GtkWindow* w = nullptr;
+  {
+    std::lock_guard<std::mutex> lock(g_runtime.object_mutex);
+    auto it = g_runtime.windows.find(window_id);
+    if (it == g_runtime.windows.end()) return;
+    w = it->second.window;
+  }
+  if (w) gtk_window_destroy(w);
+}
+
+}  // namespace bunite_linux