xbintsc 0.5.36 → 0.5.37

package/runtime/ext_gui/browser_abort.cpp

@@ -0,0 +1,249 @@
+/*
+ * xbintsc GUI engine — `AbortController` / `AbortSignal`.
+ *
+ * The pair exists so `addEventListener(..., { signal })` can actually remove a
+ * listener, as the DOM specifies. The engine has no Web-IDL machinery, so both
+ * objects are plain runtime objects with a shared hidden state:
+ *
+ *   controller.__xt_gui_abort_state   the state object
+ *   controller.__xt_gui_abort_signal  the signal handed out by `.signal`
+ *   signal.__xt_gui_abort_state       the same state object
+ *
+ * The state holds `aborted`, `reason` and the 'abort' listener list. Every value
+ * lives in a runtime object reachable from the handle the page kept, so the
+ * mark-sweep collector sees the whole graph.
+ */
+
+#include "dom_api_internal.h"
+#include "listener_options.h"
+
+namespace domapi {
+
+xt_value abort_signal_proto();
+xt_value abort_controller_proto();
+
+namespace {
+
+xt_value new_state() {
+  xt_value state = xt_object_new();
+  xt_object_set(state, xt_string_from_cstr("aborted"), XT_FALSE);
+  xt_object_set(state, xt_string_from_cstr("reason"), XT_UNDEFINED);
+  xt_object_set(state, xt_string_from_cstr("listeners"), xt_array_new(0, nullptr));
+  return state;
+}
+
+xt_value state_of(xt_value self) { return xt_object_get_cstr(self, "__xt_gui_abort_state"); }
+
+xt_value signal_of(xt_value self) { return xt_object_get_cstr(self, "__xt_gui_abort_signal"); }
+
+bool state_aborted(xt_value state) {
+  return XT_IS_OBJECT(state) && value_truthy(xt_object_get_cstr(state, "aborted"));
+}
+
+xt_value abort_signal_from_state(xt_value state, xt_value controller) {
+  xt_value signal = xt_object_new_with_proto(abort_signal_proto());
+  xt_object_set(signal, xt_string_from_cstr("__xt_gui_abort_state"), state);
+  if (!XT_IS_UNDEFINED(controller)) {
+    xt_object_set(signal, xt_string_from_cstr("__xt_gui_abort_controller"), controller);
+  }
+  return signal;
+}
+
+/** Call `fn` (or `{ handleEvent }`) with an `{ type, target }` event. */
+void call_abort_listener(xt_value fn, xt_value signal) {
+  xt_value event = xt_object_new_with_proto(event_proto());
+  xt_object_set(event, xt_string_from_cstr("type"), xt_string_from_cstr("abort"));
+  xt_object_set(event, xt_string_from_cstr("target"), signal);
+  xt_object_set(event, xt_string_from_cstr("currentTarget"), signal);
+  xt_object_set(event, xt_string_from_cstr("defaultPrevented"), XT_FALSE);
+  if (XT_IS_FUNCTION(fn)) {
+    xt_value args[1] = {event};
+    xt_call_with_this(fn, signal, 1, args);
+    return;
+  }
+  if (XT_IS_OBJECT(fn)) {
+    xt_value handler = xt_object_get_cstr(fn, "handleEvent");
+    if (XT_IS_FUNCTION(handler)) {
+      xt_value args[1] = {event};
+      xt_call_with_this(handler, fn, 1, args);
+    }
+  }
+}
+
+#define METHOD(name) xt_value name(xt_value self, xt_value env, int32_t argc, xt_value *argv)
+
+METHOD(signal_aborted_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  return state_aborted(state_of(self)) ? XT_TRUE : XT_FALSE;
+}
+
+METHOD(signal_reason_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xt_value state = state_of(self);
+  if (!XT_IS_OBJECT(state)) return XT_UNDEFINED;
+  return xt_object_get_cstr(state, "reason");
+}
+
+METHOD(signal_onabort_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  return xt_object_get_cstr(self, "__xt_gui_onabort");
+}
+
+METHOD(signal_onabort_set) {
+  (void)env;
+  if (argc >= 1) xt_object_set(self, xt_string_from_cstr("__xt_gui_onabort"), xt_arg(argc, argv, 0));
+  return XT_UNDEFINED;
+}
+
+/** `signal.addEventListener("abort", fn, options?)` — only 'abort' exists. */
+METHOD(signal_add_listener) {
+  (void)env;
+  xt_value state = state_of(self);
+  if (!XT_IS_OBJECT(state) || argc < 2) return XT_UNDEFINED;
+  std::string type = to_string_value(xt_arg(argc, argv, 0));
+  if (type != "abort") return XT_UNDEFINED;
+  xt_value fn = xt_arg(argc, argv, 1);
+  if (!XT_IS_FUNCTION(fn) && !XT_IS_OBJECT(fn)) return XT_UNDEFINED;
+  XtGuiListenerOptions options = xt_gui_listener_options(xt_arg(argc, argv, 2));
+  xt_value entry = xt_object_new();
+  xt_object_set(entry, xt_string_from_cstr("fn"), fn);
+  xt_object_set(entry, xt_string_from_cstr("once"), options.once ? XT_TRUE : XT_FALSE);
+  xt_array_push(xt_object_get_cstr(state, "listeners"), entry);
+  return XT_UNDEFINED;
+}
+
+METHOD(signal_remove_listener) {
+  (void)env;
+  xt_value state = state_of(self);
+  if (!XT_IS_OBJECT(state) || argc < 2) return XT_UNDEFINED;
+  xt_value listeners = xt_object_get_cstr(state, "listeners");
+  if (!XT_IS_ARRAY(listeners)) return XT_UNDEFINED;
+  xt_value fn = xt_arg(argc, argv, 1);
+  xt_value kept = xt_array_new(0, nullptr);
+  int32_t count = (int32_t)xt_to_number(xt_array_length(listeners));
+  for (int32_t i = 0; i < count; i++) {
+    xt_value entry = xt_array_get(listeners, xt_number((double)i));
+    if (!xt_truthy(xt_seq(xt_object_get_cstr(entry, "fn"), fn))) xt_array_push(kept, entry);
+  }
+  xt_object_set(state, xt_string_from_cstr("listeners"), kept);
+  return XT_UNDEFINED;
+}
+
+/** `signal.throwIfAborted()`: raise the abort reason (an `Error` by default). */
+METHOD(signal_throw_if_aborted) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xt_value state = state_of(self);
+  if (!state_aborted(state)) return XT_UNDEFINED;
+  xt_value reason = xt_object_get_cstr(state, "reason");
+  if (XT_IS_UNDEFINED(reason) || reason == XT_NULL) {
+    reason = xt_error_ctor_by_name(xt_string_from_cstr("Error"), 0, nullptr);
+  }
+  xt_throw(reason);
+  return XT_UNDEFINED;
+}
+
+METHOD(controller_signal_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xt_value signal = signal_of(self);
+  if (XT_IS_OBJECT(signal)) return signal;
+  xt_value state = state_of(self);
+  if (!XT_IS_OBJECT(state)) {
+    state = new_state();
+    xt_object_set(self, xt_string_from_cstr("__xt_gui_abort_state"), state);
+  }
+  signal = abort_signal_from_state(state, self);
+  xt_object_set(self, xt_string_from_cstr("__xt_gui_abort_signal"), signal);
+  return signal;
+}
+
+/** `controller.abort(reason)`: flip the state and dispatch 'abort' once. */
+METHOD(controller_abort) {
+  (void)env;
+  xt_value state = state_of(self);
+  if (!XT_IS_OBJECT(state) || state_aborted(state)) return XT_UNDEFINED;
+  xt_value reason = argc >= 1 ? xt_arg(argc, argv, 0) : XT_UNDEFINED;
+  if (XT_IS_UNDEFINED(reason)) {
+    xt_value message = xt_string_from_cstr("This operation was aborted");
+    reason = xt_error_ctor_by_name(xt_string_from_cstr("Error"), 1, &message);
+  }
+  xt_object_set(state, xt_string_from_cstr("aborted"), XT_TRUE);
+  xt_object_set(state, xt_string_from_cstr("reason"), reason);
+  xt_value signal = signal_of(self);
+  if (!XT_IS_OBJECT(signal)) signal = controller_signal_get(self, XT_UNDEFINED, 0, nullptr);
+  xt_value onabort = xt_object_get_cstr(signal, "__xt_gui_onabort");
+  if (XT_IS_FUNCTION(onabort)) call_abort_listener(onabort, signal);
+  xt_value listeners = xt_object_get_cstr(state, "listeners");
+  int32_t count = XT_IS_ARRAY(listeners) ? (int32_t)xt_to_number(xt_array_length(listeners)) : 0;
+  xt_value snapshot = xt_array_new(0, nullptr);
+  for (int32_t i = 0; i < count; i++) {
+    xt_array_push(snapshot, xt_array_get(listeners, xt_number((double)i)));
+  }
+  xt_object_set(state, xt_string_from_cstr("listeners"), xt_array_new(0, nullptr));
+  for (int32_t i = 0; i < count; i++) {
+    xt_value entry = xt_array_get(snapshot, xt_number((double)i));
+    call_abort_listener(xt_object_get_cstr(entry, "fn"), signal);
+  }
+  return XT_UNDEFINED;
+}
+
+#undef METHOD
+
+}  // namespace
+
+xt_value abort_signal_proto() {
+  static xt_value proto = XT_UNDEFINED;
+  if (XT_IS_OBJECT(proto)) return proto;
+  proto = xt_object_new();
+  xt_gc_add_root(&proto);
+  xt_object_define_getter(proto, xt_string_from_cstr("aborted"),
+                          xt_closure_new((void *)signal_aborted_get, 0, nullptr));
+  xt_object_define_getter(proto, xt_string_from_cstr("reason"),
+                          xt_closure_new((void *)signal_reason_get, 0, nullptr));
+  xt_object_define_getter(proto, xt_string_from_cstr("onabort"),
+                          xt_closure_new((void *)signal_onabort_get, 0, nullptr));
+  xt_object_define_setter(proto, xt_string_from_cstr("onabort"),
+                          xt_closure_new((void *)signal_onabort_set, 0, nullptr));
+  xt_object_set(proto, xt_string_from_cstr("addEventListener"),
+                xt_closure_new((void *)signal_add_listener, 0, nullptr));
+  xt_object_set(proto, xt_string_from_cstr("removeEventListener"),
+                xt_closure_new((void *)signal_remove_listener, 0, nullptr));
+  xt_object_set(proto, xt_string_from_cstr("throwIfAborted"),
+                xt_closure_new((void *)signal_throw_if_aborted, 0, nullptr));
+  return proto;
+}
+
+xt_value abort_controller_proto() {
+  static xt_value proto = XT_UNDEFINED;
+  if (XT_IS_OBJECT(proto)) return proto;
+  proto = xt_object_new();
+  xt_gc_add_root(&proto);
+  xt_object_define_getter(proto, xt_string_from_cstr("signal"),
+                          xt_closure_new((void *)controller_signal_get, 0, nullptr));
+  xt_object_set(proto, xt_string_from_cstr("abort"),
+                xt_closure_new((void *)controller_abort, 0, nullptr));
+  return proto;
+}
+
+xt_value abort_controller_new() {
+  xt_value controller = xt_object_new_with_proto(abort_controller_proto());
+  xt_object_set(controller, xt_string_from_cstr("__xt_gui_abort_state"), new_state());
+  return controller;
+}
+
+xt_value abort_signal_new(bool aborted) {
+  xt_value state = new_state();
+  if (aborted) xt_object_set(state, xt_string_from_cstr("aborted"), XT_TRUE);
+  return abort_signal_from_state(state, XT_UNDEFINED);
+}
+
+}  // namespace domapi

package/runtime/ext_gui/browser_dialogs.cpp

@@ -0,0 +1,76 @@
+/*
+ * xbintsc GUI engine — `window.confirm` / `window.prompt`.
+ *
+ * A compiled page has no browser chrome, so a blocking dialog is opt-in: with
+ * `XT_GUI_DIALOGS=1` and a live window the engine shows a native SDL message
+ * box. Otherwise (and always for `prompt`, which would need a text input) the
+ * message is written to stderr and the documented default is returned — the
+ * arguments are never silently dropped. `confirm` answers false and `prompt`
+ * answers `defaultValue` (or "") when no dialog is shown.
+ */
+
+#include "gui_engine.h"
+
+#include <stdio.h>
+#include <string>
+
+namespace {
+
+std::string message_of(int32_t argc, xt_value *argv) {
+  if (argc < 1) return std::string();
+  const char *data = xt_string_data(xt_to_string(xt_arg(argc, argv, 0)));
+  return data != nullptr ? data : "";
+}
+
+bool dialogs_enabled() {
+  const char *value = SDL_getenv("XT_GUI_DIALOGS");
+  return value != nullptr && value[0] == '1';
+}
+
+bool show_message(XtGuiWindow *win, const std::string &message, bool with_cancel) {
+  if (win == nullptr || win->window == nullptr) return false;
+  SDL_MessageBoxButtonData buttons[2];
+  SDL_zero(buttons);
+  int count = 1;
+  buttons[0].flags = SDL_MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT;
+  buttons[0].buttonID = 1;
+  buttons[0].text = "OK";
+  if (with_cancel) {
+    buttons[1].flags = SDL_MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT;
+    buttons[1].buttonID = 0;
+    buttons[1].text = "Cancel";
+    count = 2;
+  }
+  SDL_MessageBoxData data;
+  SDL_zero(data);
+  data.flags = SDL_MESSAGEBOX_INFORMATION;
+  data.window = win->window;
+  data.title = "xbintsc";
+  data.message = message.c_str();
+  data.numbuttons = count;
+  data.buttons = buttons;
+  int pressed = -1;
+  if (!SDL_ShowMessageBox(&data, &pressed)) return false;
+  return pressed == 1;
+}
+
+}  // namespace
+
+xt_value xt_browser_confirm(XtGuiWindow *win, int32_t argc, xt_value *argv) {
+  std::string message = message_of(argc, argv);
+  if (dialogs_enabled() && show_message(win, message, true)) return XT_TRUE;
+  fprintf(stderr, "confirm: %s\n", message.c_str());
+  return XT_FALSE;
+}
+
+xt_value xt_browser_prompt(XtGuiWindow *win, int32_t argc, xt_value *argv) {
+  std::string message = message_of(argc, argv);
+  std::string fallback;
+  if (argc >= 2) {
+    const char *data = xt_string_data(xt_to_string(xt_arg(argc, argv, 1)));
+    if (data != nullptr) fallback = data;
+  }
+  if (dialogs_enabled()) show_message(win, message, false);
+  fprintf(stderr, "prompt: %s\n", message.c_str());
+  return xt_string_from_cstr(fallback.c_str());
+}

package/runtime/ext_gui/browser_media.cpp

@@ -0,0 +1,176 @@
+/*
+ * xbintsc GUI engine — live `matchMedia` lists.
+ *
+ * `window.matchMedia(query)` returns one cached `MediaQueryList` per query. The
+ * engine re-evaluates every live list on a window resize (the same evaluator
+ * `@media` rules use) and dispatches a `change` event when the match flips, so
+ * a page can react to a viewport change instead of polling `matches`.
+ */
+
+#include "gui_engine.h"
+
+
+#include <string>
+#include <vector>
+
+#include "css.h"
+
+namespace {
+
+std::string string_value(xt_value value) {
+  const char *data = xt_string_data(xt_to_string(value));
+  return data != nullptr ? data : "";
+}
+
+xt_value listeners_of(xt_value self, bool create) {
+  xt_value listeners = xt_object_get_cstr(self, "__xt_gui_media_listeners");
+  if (XT_IS_ARRAY(listeners) || !create) return listeners;
+  listeners = xt_array_new(0, nullptr);
+  xt_object_set(self, xt_string_from_cstr("__xt_gui_media_listeners"), listeners);
+  return listeners;
+}
+
+void add_listener(xt_value self, xt_value fn, bool once, xt_value signal) {
+  if (!XT_IS_FUNCTION(fn)) return;
+  xt_value entry = xt_object_new();
+  xt_object_set(entry, xt_string_from_cstr("fn"), fn);
+  xt_object_set(entry, xt_string_from_cstr("once"), once ? XT_TRUE : XT_FALSE);
+  xt_object_set(entry, xt_string_from_cstr("signal"), signal);
+  xt_array_push(listeners_of(self, true), entry);
+}
+
+void remove_listener(xt_value self, xt_value fn) {
+  xt_value listeners = listeners_of(self, false);
+  if (!XT_IS_ARRAY(listeners)) return;
+  xt_value kept = xt_array_new(0, nullptr);
+  int32_t count = (int32_t)xt_to_number(xt_array_length(listeners));
+  for (int32_t i = 0; i < count; i++) {
+    xt_value entry = xt_array_get(listeners, xt_number((double)i));
+    if (!xt_truthy(xt_seq(xt_object_get_cstr(entry, "fn"), fn))) xt_array_push(kept, entry);
+  }
+  xt_object_set(self, xt_string_from_cstr("__xt_gui_media_listeners"), kept);
+}
+
+void call_change_listener(xt_value fn, xt_value list, xt_value event) {
+  if (!XT_IS_FUNCTION(fn)) return;
+  xt_value args[1] = {event};
+  xt_call_with_this(fn, list, 1, args);
+}
+
+#define METHOD(name) xt_value name(xt_value self, xt_value env, int32_t argc, xt_value *argv)
+
+METHOD(media_add_event_listener) {
+  (void)env;
+  if (argc < 2 || string_value(xt_arg(argc, argv, 0)) != "change") return XT_UNDEFINED;
+  bool once = false;
+  xt_value options = xt_arg(argc, argv, 2);
+  if (XT_IS_OBJECT(options)) once = xt_truthy(xt_object_get_cstr(options, "once")) != 0;
+  add_listener(self, xt_arg(argc, argv, 1), once, XT_UNDEFINED);
+  return XT_UNDEFINED;
+}
+
+METHOD(media_remove_event_listener) {
+  (void)env;
+  if (argc < 2 || string_value(xt_arg(argc, argv, 0)) != "change") return XT_UNDEFINED;
+  remove_listener(self, xt_arg(argc, argv, 1));
+  return XT_UNDEFINED;
+}
+
+/** Legacy `addListener(fn)` / `removeListener(fn)`. */
+METHOD(media_add_listener) {
+  (void)env;
+  if (argc >= 1) add_listener(self, xt_arg(argc, argv, 0), false, XT_UNDEFINED);
+  return XT_UNDEFINED;
+}
+
+METHOD(media_remove_listener) {
+  (void)env;
+  if (argc >= 1) remove_listener(self, xt_arg(argc, argv, 0));
+  return XT_UNDEFINED;
+}
+
+METHOD(media_onchange_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  return xt_object_get_cstr(self, "__xt_gui_media_onchange");
+}
+
+METHOD(media_onchange_set) {
+  (void)env;
+  if (argc >= 1) {
+    xt_object_set(self, xt_string_from_cstr("__xt_gui_media_onchange"), xt_arg(argc, argv, 0));
+  }
+  return XT_UNDEFINED;
+}
+
+#undef METHOD
+
+xt_value build_list(const std::string &query, bool matches) {
+  xt_value list = xt_object_new();
+  xt_object_set(list, xt_string_from_cstr("media"), xt_string_from_cstr(query.c_str()));
+  xt_object_set(list, xt_string_from_cstr("matches"), matches ? XT_TRUE : XT_FALSE);
+  xt_object_set(list, xt_string_from_cstr("__xt_gui_media_query"),
+                xt_string_from_cstr(query.c_str()));
+  xt_object_set(list, xt_string_from_cstr("addEventListener"),
+                xt_closure_new((void *)media_add_event_listener, 0, nullptr));
+  xt_object_set(list, xt_string_from_cstr("removeEventListener"),
+                xt_closure_new((void *)media_remove_event_listener, 0, nullptr));
+  xt_object_set(list, xt_string_from_cstr("addListener"),
+                xt_closure_new((void *)media_add_listener, 0, nullptr));
+  xt_object_set(list, xt_string_from_cstr("removeListener"),
+                xt_closure_new((void *)media_remove_listener, 0, nullptr));
+  xt_object_define_getter(list, xt_string_from_cstr("onchange"),
+                          xt_closure_new((void *)media_onchange_get, 0, nullptr));
+  xt_object_define_setter(list, xt_string_from_cstr("onchange"),
+                          xt_closure_new((void *)media_onchange_set, 0, nullptr));
+  return list;
+}
+
+}  // namespace
+
+xt_value xt_browser_media_list(xt_value window, const std::string &query) {
+  XtGuiWindow *win = xt_gui_window_from_this(window);
+  if (win == nullptr) return build_list(query, false);
+  auto cached = win->media_lists_by_query.find(query);
+  if (cached != win->media_lists_by_query.end()) return cached->second;
+  float width = 0.0f;
+  float height = 0.0f;
+  xt_gui_window_viewport(win, &width, &height);
+  xt_value list = build_list(query, xtgui::xt_css_media_matches(query, width, height));
+  win->media_lists.push_back(list);
+  win->media_lists_by_query[query] = list;
+  return list;
+}
+
+void xt_gui_media_lists_notify(XtGuiWindow *win) {
+  if (win == nullptr) return;
+  float width = 0.0f;
+  float height = 0.0f;
+  xt_gui_window_viewport(win, &width, &height);
+  for (xt_value list : win->media_lists) {
+    if (!XT_IS_OBJECT(list)) continue;
+    std::string query = string_value(xt_object_get_cstr(list, "__xt_gui_media_query"));
+    bool matches = xtgui::xt_css_media_matches(query, width, height);
+    bool was = xt_truthy(xt_object_get_cstr(list, "matches"));
+    xt_object_set(list, xt_string_from_cstr("matches"), matches ? XT_TRUE : XT_FALSE);
+    if (was == matches) continue;
+    xt_value event = xt_object_new();
+    xt_object_set(event, xt_string_from_cstr("type"), xt_string_from_cstr("change"));
+    xt_object_set(event, xt_string_from_cstr("media"), xt_string_from_cstr(query.c_str()));
+    xt_object_set(event, xt_string_from_cstr("matches"), matches ? XT_TRUE : XT_FALSE);
+    xt_value onchange = xt_object_get_cstr(list, "__xt_gui_media_onchange");
+    call_change_listener(onchange, list, event);
+    xt_value listeners = listeners_of(list, false);
+    if (!XT_IS_ARRAY(listeners)) continue;
+    xt_value snapshot = xt_array_new(0, nullptr);
+    int32_t count = (int32_t)xt_to_number(xt_array_length(listeners));
+    for (int32_t i = 0; i < count; i++) {
+      xt_array_push(snapshot, xt_array_get(listeners, xt_number((double)i)));
+    }
+    for (int32_t i = 0; i < count; i++) {
+      xt_value entry = xt_array_get(snapshot, xt_number((double)i));
+      call_change_listener(xt_object_get_cstr(entry, "fn"), list, event);
+    }
+  }
+}

package/runtime/ext_gui/browser_navigation.cpp

@@ -0,0 +1,130 @@
+/*
+ * xbintsc GUI engine — window navigation and focus.
+ *
+ * `scrollTo` / `scrollBy` move the page viewport (painting and hit testing
+ * subtract the offset), `scrollX`/`scrollY` (and the `page*Offset` aliases)
+ * report it, and `focus` / `blur` raise the OS window and toggle
+ * `document.hasFocus()` plus the corresponding window events.
+ */
+
+#include "gui_engine.h"
+
+#include <cmath>
+
+namespace {
+
+xt_value scroll_axis(xt_value options, const char *name) {
+  if (!XT_IS_OBJECT(options)) return XT_UNDEFINED;
+  return xt_object_get_cstr(options, name);
+}
+
+double coordinate(xt_value value, double fallback) {
+  return XT_IS_NUMBER(value) ? xt_to_number(value) : fallback;
+}
+
+#define METHOD(name) xt_value name(xt_value self, xt_value env, int32_t argc, xt_value *argv)
+
+/** `scrollTo(x, y)` / `scrollTo({ left, top })`. */
+METHOD(win_scroll_to) {
+  (void)env;
+  XtGuiWindow *win = xt_gui_window_from_this(self);
+  if (win == nullptr || argc < 1) return XT_UNDEFINED;
+  xt_value options = xt_arg(argc, argv, 0);
+  double x = 0;
+  double y = 0;
+  if (XT_IS_OBJECT(options) && !XT_IS_ARRAY(options)) {
+    x = coordinate(scroll_axis(options, "left"), coordinate(scroll_axis(options, "x"), 0));
+    y = coordinate(scroll_axis(options, "top"), coordinate(scroll_axis(options, "y"), 0));
+  } else {
+    x = coordinate(options, 0);
+    if (argc >= 2) y = coordinate(xt_arg(argc, argv, 1), 0);
+  }
+  xt_gui_scroll_to(win, (float)x, (float)y);
+  return XT_UNDEFINED;
+}
+
+METHOD(win_scroll_by) {
+  (void)env;
+  XtGuiWindow *win = xt_gui_window_from_this(self);
+  if (win == nullptr || argc < 1) return XT_UNDEFINED;
+  xt_value options = xt_arg(argc, argv, 0);
+  double dx = 0;
+  double dy = 0;
+  if (XT_IS_OBJECT(options) && !XT_IS_ARRAY(options)) {
+    dx = coordinate(scroll_axis(options, "left"), coordinate(scroll_axis(options, "x"), 0));
+    dy = coordinate(scroll_axis(options, "top"), coordinate(scroll_axis(options, "y"), 0));
+  } else {
+    dx = coordinate(options, 0);
+    if (argc >= 2) dy = coordinate(xt_arg(argc, argv, 1), 0);
+  }
+  xt_gui_scroll_to(win, win->scroll_x + (float)dx, win->scroll_y + (float)dy);
+  return XT_UNDEFINED;
+}
+
+METHOD(win_scroll_x_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  XtGuiWindow *win = xt_gui_window_from_this(self);
+  return xt_number(win != nullptr ? (double)win->scroll_x : 0.0);
+}
+
+METHOD(win_scroll_y_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  XtGuiWindow *win = xt_gui_window_from_this(self);
+  return xt_number(win != nullptr ? (double)win->scroll_y : 0.0);
+}
+
+METHOD(win_focus) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  XtGuiWindow *win = xt_gui_window_from_this(self);
+  if (win == nullptr || !win->open) return XT_UNDEFINED;
+  if (win->window != nullptr) SDL_RaiseWindow(win->window);
+  if (!win->focused) {
+    win->focused = 1;
+    xt_gui_emit(win, "focus");
+  }
+  return XT_UNDEFINED;
+}
+
+METHOD(win_blur) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  XtGuiWindow *win = xt_gui_window_from_this(self);
+  if (win == nullptr || !win->open) return XT_UNDEFINED;
+  if (win->focused) {
+    win->focused = 0;
+    xt_gui_emit(win, "blur");
+  }
+  return XT_UNDEFINED;
+}
+
+#undef METHOD
+
+}  // namespace
+
+void xt_browser_install_window_navigation(xt_value proto) {
+  xt_object_set(proto, xt_string_from_cstr("scrollTo"),
+                xt_closure_new((void *)win_scroll_to, 0, nullptr));
+  xt_object_set(proto, xt_string_from_cstr("scroll"),
+                xt_closure_new((void *)win_scroll_to, 0, nullptr));
+  xt_object_set(proto, xt_string_from_cstr("scrollBy"),
+                xt_closure_new((void *)win_scroll_by, 0, nullptr));
+  xt_object_set(proto, xt_string_from_cstr("focus"),
+                xt_closure_new((void *)win_focus, 0, nullptr));
+  xt_object_set(proto, xt_string_from_cstr("blur"),
+                xt_closure_new((void *)win_blur, 0, nullptr));
+  xt_object_define_getter(proto, xt_string_from_cstr("scrollX"),
+                          xt_closure_new((void *)win_scroll_x_get, 0, nullptr));
+  xt_object_define_getter(proto, xt_string_from_cstr("scrollY"),
+                          xt_closure_new((void *)win_scroll_y_get, 0, nullptr));
+  xt_object_define_getter(proto, xt_string_from_cstr("pageXOffset"),
+                          xt_closure_new((void *)win_scroll_x_get, 0, nullptr));
+  xt_object_define_getter(proto, xt_string_from_cstr("pageYOffset"),
+                          xt_closure_new((void *)win_scroll_y_get, 0, nullptr));
+}