basalt-gtk 0.0.0-rc5

package/native/gtk/GtkTouchDispatcher.h

@@ -0,0 +1,139 @@
+// GTK input into React Native's touch events.
+//
+// React Native's Pressability -- what backs <Pressable>, <TouchableOpacity> and
+// every onPress in an app -- runs on the responder system in JavaScript, and
+// the responder system is fed by touchstart/touchmove/touchend. So a pointer on
+// a desktop is reported here as a single touch point, which is also what React
+// Native for Windows and macOS do. W3C pointer events exist alongside these and
+// are only consulted for hover, behind a feature flag.
+//
+// Controllers are attached to the surface root, not to every view. A GTK
+// controller per widget would mean creating and destroying controllers on every
+// mutation, and would still need the same hit test: `gtk_widget_pick` already
+// walks the widget tree and returns the deepest widget at a point, which is the
+// same answer React Native's own hit testing is looking for now that every view
+// is allocated at the frame Yoga gave it.
+
+#pragma once
+
+#include "GtkMountingManager.h"
+#include "HoverTracker.h"
+#include "PointerButtons.h"
+#include "RnView.h"
+
+#include <react/renderer/components/view/TouchEventEmitter.h>
+#include <react/renderer/graphics/Point.h>
+
+namespace basalt {
+
+// The tag of the React Native view under a point, in `root`'s coordinates, or 0
+// if the point hits nothing.
+//
+// A free function because it is a pure function of the widget tree and nothing
+// else, which is also what makes it testable: hit testing is the part of input
+// most likely to be quietly wrong, and it needs no gestures to exercise.
+facebook::react::Tag hitTestTag(RnView *root, double x, double y);
+
+class GtkTouchDispatcher {
+ public:
+  GtkTouchDispatcher(GtkMountingManager *mountingManager, RnView *surfaceRoot);
+  ~GtkTouchDispatcher();
+
+  GtkTouchDispatcher(const GtkTouchDispatcher &) = delete;
+  GtkTouchDispatcher &operator=(const GtkTouchDispatcher &) = delete;
+  GtkTouchDispatcher(GtkTouchDispatcher &&) = delete;
+  GtkTouchDispatcher &operator=(GtkTouchDispatcher &&) = delete;
+
+  // Synthesises a press and release at a point in surface-root coordinates,
+  // entering at the same place the GTK gesture callbacks do.
+  //
+  // This exists because the input path is otherwise untestable in automation:
+  // synthesising a real pointer event means driving the window system, which on
+  // macOS needs accessibility permission a headless run does not have. It skips
+  // GDK's event delivery and nothing else, so it proves hit testing, emitter
+  // lookup and event-beat delivery, but not that GTK routes clicks here.
+  void synthesiseTap(double x, double y);
+  // The same, with a button. BASALT_TEST_SECONDARY_TAP is what needs it: a
+  // right-click cannot be injected any other way, and it is the one click whose
+  // whole point is that it does *not* press what it lands on.
+  void synthesiseTap(double x, double y, basalt::PointerButton button);
+
+  // A press, a run of moves, and a release. The same reason as synthesiseTap,
+  // one step further: a gesture recogniser cannot be exercised by a tap at all
+  // -- a pan is defined by the movement between the two -- so a drag has to be
+  // injectable for anything about it to be provable outside a person's hand.
+  void synthesiseDrag(double fromX, double fromY, double toX, double toY, int steps);
+
+  // Moves the pointer without pressing it, which is what produces hover. Same
+  // reason as the two above, and the same entry point the motion controller
+  // uses. A negative coordinate means the pointer left the surface.
+  void synthesiseHover(double x, double y);
+
+ private:
+  static void onPressed(GtkGestureClick *gesture, int count, double x, double y, gpointer userData);
+  static void onReleased(GtkGestureClick *gesture, int count, double x, double y, gpointer userData);
+  static void onCancelled(GtkGesture *gesture, GdkEventSequence *sequence, gpointer userData);
+  static void onMotion(GtkEventControllerMotion *controller, double x, double y, gpointer userData);
+  static void onPointerLeft(GtkEventControllerMotion *controller, gpointer userData);
+
+  // `button` decides whether this presses anything. Only the primary one drives
+  // the touch model; a secondary or middle click produces a pointer event and
+  // nothing else, which is what keeps a right-click from firing every
+  // `<Pressable>` it lands on. See core/PointerButtons.h.
+  void dispatchTouchStart(double x, double y, basalt::PointerButton button);
+  void dispatchTouchMove(double x, double y);
+  void dispatchTouchEnd(double x, double y, basalt::PointerButton button);
+  void dispatchTouchCancel();
+
+  // The hover half. Separate from dispatchTouchMove because the two answer
+  // different questions about the same motion event: the touch model asks which
+  // view the finger went down on, and hover asks which views the cursor is
+  // inside right now.
+  void dispatchHover(double x, double y);
+  void dispatchHoverLeave();
+
+  enum class TouchKind { Start, Move, End, Cancel };
+
+  // Hands the pointer to a gesture recogniser that has activated, cancelling
+  // React Native's touch. True when that happened, which means the caller has
+  // nothing left to report.
+  bool yieldToGesture(double x, double y);
+
+  // Builds the TouchEvent for the current gesture. React Native wants three
+  // lists -- all touches, the ones that changed, and the ones that started on
+  // the event target -- which with one pointer are the same list, except on
+  // touchend where nothing is touching any more.
+  void emit(TouchKind kind, facebook::react::Tag target, double x, double y);
+
+  // A pointerMove at the view under the cursor. The only pointer event a host
+  // emits for hover; see core/HoverTracker.h.
+  // A press or a release as a pointer event, which is the only form a
+  // non-primary click arrives in.
+  void emitPointerButton(bool down,
+                         facebook::react::Tag target,
+                         double originX,
+                         double originY,
+                         double x,
+                         double y,
+                         basalt::PointerButton button);
+  void emitPointerMove(
+      facebook::react::Tag target, double originX, double originY, double x, double y);
+
+  GtkMountingManager *mountingManager_;
+  RnView *surfaceRoot_;
+
+  GtkGesture *clickGesture_{nullptr};
+  GtkEventController *motionController_{nullptr};
+
+  // The view a gesture started on. React Native reports every touch in a
+  // gesture against the target it began on, even after the pointer leaves that
+  // view, because that is what the responder system expects.
+  facebook::react::Tag activeTarget_{0};
+  bool isDown_{false};
+
+  // Where the cursor was, so that enter and leave can be told from over and
+  // out. See core/HoverTracker.h.
+  HoverTracker hover_;
+};
+
+} // namespace basalt

package/native/gtk/GtkWindowControl.cpp

@@ -0,0 +1,223 @@
+// The Linux half of core/WindowControl.h.
+//
+// GTK4 is the most opinionated of the three desktops about this, and several of
+// these functions are shaped by what it will not do. `windowCapabilities()` is
+// how an app finds that out without reading this file.
+//
+// **A window cannot be positioned.** `gtk_window_move` is gone in GTK4 and
+// nothing replaced it: on Wayland a client has no idea where its window is and
+// no way to say, and GTK removed the X11 call rather than ship an API that
+// works on one display server. So `setWindowPosition` and the `x`/`y` in
+// `windowBounds` are honest zeroes, and `centerWindow` is the window manager's
+// job -- which, on both display servers, it does by default for a window that
+// has not been placed.
+//
+// **A window's size is a request.** `gtk_window_set_default_size` is what a
+// client has; the compositor may ignore it. That is also true of the other two
+// desktops in a tiling window manager, and the answer is the same: ask, and
+// report what actually happened through the bounds listener.
+//
+// **A window has no maximum size and does not float.**
+// `gtk_window_set_geometry_hints` and `gtk_window_set_keep_above` were both
+// removed in GTK4, for the same reason as `gtk_window_move`: Wayland has no
+// protocol for either, and an API that worked on X11 alone would be one that
+// silently does nothing half the time -- which is the thing GTK4 decided not to
+// ship. A minimum *is* expressible, because it is a property of the widget
+// rather than a request to the compositor.
+
+#include <vector>
+#include "WindowControl.h"
+
+#include "GtkTitleBar.h"
+
+#include <gtk/gtk.h>
+
+namespace basalt {
+
+namespace {
+
+
+// The window this process owns. The same question PlatformServicesGtk.cpp asks
+// for a popup's parent, and asked the same way: GTK has a list of toplevels
+// rather than an idea of "the app's window".
+GtkWindow *window() {
+  GListModel *toplevels = gtk_window_get_toplevels();
+  if (toplevels == nullptr) {
+    return nullptr;
+  }
+  GtkWindow *fallback = nullptr;
+  const guint count = g_list_model_get_n_items(toplevels);
+  for (guint i = 0; i < count; i++) {
+    auto *candidate = static_cast<GtkWindow *>(g_list_model_get_item(toplevels, i));
+    if (candidate == nullptr) {
+      continue;
+    }
+    const bool visible = gtk_widget_get_visible(GTK_WIDGET(candidate)) != FALSE;
+    if (visible && gtk_window_is_active(candidate)) {
+      g_object_unref(candidate);
+      return candidate;
+    }
+    if (visible && fallback == nullptr) {
+      fallback = candidate;
+    }
+    g_object_unref(candidate);
+  }
+  return fallback;
+}
+
+} // namespace
+
+// The displays, and the three things GTK 4 will not say about them.
+//
+// `gdk_monitor_get_workarea`, `gdk_display_get_primary_monitor` and any way to
+// ask where the pointer is were all in GTK 3 and are all gone -- not
+// overlooked, removed. Wayland has no protocol for a work area a client can
+// read, no notion of a primary output, and tells a client the pointer's
+// position only while it is over one of that client's surfaces. GTK 4 dropped
+// the X11-only versions rather than offer an API that answers on one display
+// server and not the other.
+//
+// So the work area is reported as the full bounds, the first monitor is
+// reported as primary, and the pointer is reported as unknown. Each is a
+// truthful answer to a question this desktop does not answer, which is the
+// same rule `WindowCapabilities` follows for position and always-on-top.
+std::vector<DisplayInfo> displays() {
+  std::vector<DisplayInfo> found;
+  GdkDisplay *display = gdk_display_get_default();
+  if (display == nullptr) {
+    return found;
+  }
+  GListModel *monitors = gdk_display_get_monitors(display);
+  if (monitors == nullptr) {
+    return found;
+  }
+  const guint count = g_list_model_get_n_items(monitors);
+  for (guint i = 0; i < count; i++) {
+    auto *monitor = static_cast<GdkMonitor *>(g_list_model_get_item(monitors, i));
+    if (monitor == nullptr) {
+      continue;
+    }
+    if (gdk_monitor_is_valid(monitor)) {
+      GdkRectangle geometry{};
+      gdk_monitor_get_geometry(monitor, &geometry);
+
+      DisplayInfo info;
+      info.x = geometry.x;
+      info.y = geometry.y;
+      info.width = geometry.width;
+      info.height = geometry.height;
+      // No work area to ask for; see above.
+      info.workX = info.x;
+      info.workY = info.y;
+      info.workWidth = info.width;
+      info.workHeight = info.height;
+      // `gdk_monitor_get_scale`, not `get_scale_factor`: the factor is an
+      // integer and a display at 150% is real, which is the case the integer
+      // rounds away.
+      const double scale = gdk_monitor_get_scale(monitor);
+      info.scaleFactor = scale > 0.0 ? scale : 1.0;
+      info.primary = found.empty();
+      found.push_back(info);
+    }
+    g_object_unref(monitor);
+  }
+  return found;
+}
+
+PointerPosition pointerPosition() {
+  // Unknown, and not a gap this host can fill: see above.
+  return {};
+}
+
+WindowBounds windowBounds() {
+  WindowBounds bounds;
+  GtkWindow *target = window();
+  if (target == nullptr) {
+    return bounds;
+  }
+  bounds.width = gtk_widget_get_width(GTK_WIDGET(target));
+  bounds.height = gtk_widget_get_height(GTK_WIDGET(target));
+  bounds.fullScreen = gtk_window_is_fullscreen(target) != FALSE;
+  bounds.maximized = gtk_window_is_maximized(target) != FALSE;
+  // x and y stay zero. See the header of this file: GTK4 has no way to ask.
+  return bounds;
+}
+
+void setWindowSize(double width, double height) {
+  GtkWindow *target = window();
+  if (target == nullptr || width <= 0.0 || height <= 0.0) {
+    return;
+  }
+  // `default_size` rather than a resize call, because that is the only one GTK4
+  // has: it is the size the window takes when it is not being managed into
+  // something else, and setting it on a mapped window resizes it.
+  gtk_window_set_default_size(target, static_cast<int>(width), static_cast<int>(height));
+}
+
+void setWindowPosition(double /*x*/, double /*y*/) {
+  // Deliberately nothing. See the header: GTK4 removed `gtk_window_move` and
+  // Wayland has no equivalent, so an app asking for a position is asking for
+  // something no Linux desktop will do. Failing silently is the same answer the
+  // compositor gives and is better than a warning an app cannot act on.
+}
+
+void centerWindow() {
+  // Also nothing, and for the same reason -- centring is positioning. Both
+  // display servers centre an unplaced window by default, so an app that never
+  // moves its window already gets what this would have asked for.
+}
+
+void setWindowFullScreen(bool fullScreen) {
+  GtkWindow *target = window();
+  if (target == nullptr) {
+    return;
+  }
+  if (fullScreen) {
+    gtk_window_fullscreen(target);
+  } else {
+    gtk_window_unfullscreen(target);
+  }
+}
+
+
+void applyWindowSizeLimits() {
+  GtkWindow *target = window();
+  if (target == nullptr) {
+    return;
+  }
+  // The minimum only, and through the widget rather than the window manager:
+  // GTK works out a toplevel's minimum from what its content needs, and this is
+  // how a client adds to that. -1 is GTK's "no request", which is what a
+  // cleared limit means.
+  const WindowSizeLimits limits = windowSizeLimits();
+  gtk_widget_set_size_request(GTK_WIDGET(target),
+                              limits.minWidth > 0.0 ? static_cast<int>(limits.minWidth) : -1,
+                              limits.minHeight > 0.0 ? static_cast<int>(limits.minHeight) : -1);
+  // The maximum is dropped rather than approximated. A window that enforced one
+  // by resizing itself back down would fight the person dragging its corner,
+  // which is worse than not having the feature; `windowCapabilities()` says so
+  // instead.
+}
+
+void setWindowResizable(bool resizable) {
+  GtkWindow *target = window();
+  if (target != nullptr) {
+    gtk_window_set_resizable(target, resizable ? TRUE : FALSE);
+  }
+}
+
+void setWindowAlwaysOnTop(bool /*alwaysOnTop*/) {
+  // Nothing to do, and that is the answer rather than a gap. See the header.
+}
+
+WindowCapabilities windowCapabilities() {
+  WindowCapabilities capabilities;
+  capabilities.position = false;
+  capabilities.minimumSize = true;
+  capabilities.maximumSize = false;
+  capabilities.resizable = true;
+  capabilities.alwaysOnTop = false;
+  return capabilities;
+}
+
+} // namespace basalt

package/native/gtk/GtkWindowModule.cpp

@@ -0,0 +1,194 @@
+#include "GtkWindowModule.h"
+
+#include "WindowControl.h"
+#include "WindowMethods.h"
+#include "GtkTitleBar.h"
+#include "PlatformServices.h"
+
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace basalt {
+
+namespace {
+
+using facebook::jsi::Object;
+using facebook::jsi::Runtime;
+using facebook::jsi::String;
+using facebook::jsi::Value;
+using facebook::react::TurboModule;
+
+constexpr const char *kMetricsChangedEvent = "basaltTitleBarMetricsChanged";
+
+// processColor's 0xAARRGGBB, or nullopt for anything that is not a number --
+// which is how JavaScript asks for the system's colour back.
+std::optional<uint32_t> colorArgument(const Value *args, size_t count, size_t index) {
+  if (index >= count || !args[index].isNumber()) {
+    return std::nullopt;
+  }
+  return static_cast<uint32_t>(static_cast<int64_t>(args[index].asNumber()));
+}
+
+Value metricsValue(Runtime &runtime, const TitleBarMetrics &metrics) {
+  Object object(runtime);
+  object.setProperty(runtime, "height", metrics.height);
+  object.setProperty(runtime, "buttonsWidth", metrics.buttonsWidth);
+  object.setProperty(runtime,
+                     "style",
+                     String::createFromAscii(
+                         runtime, metrics.style == TitleBarStyle::Hidden ? "hidden" : "native"));
+  return Value(runtime, object);
+}
+
+} // namespace
+
+GtkWindowModule::GtkWindowModule(std::shared_ptr<facebook::react::CallInvoker> jsInvoker)
+    : TurboModule(kModuleName, std::move(jsInvoker)) {
+  methodMap_["setTitle"] = MethodMetadata{1, setTitle};
+  methodMap_["setTitleBarColors"] = MethodMetadata{3, setTitleBarColors};
+  methodMap_["setTitleBarStyle"] = MethodMetadata{1, setTitleBarStyle};
+  methodMap_["getTitleBarMetrics"] = MethodMetadata{0, getTitleBarMetrics};
+  methodMap_["minimize"] = MethodMetadata{0, minimize};
+  methodMap_["toggleMaximize"] = MethodMetadata{0, toggleMaximize};
+  methodMap_["close"] = MethodMetadata{0, closeWindow};
+  methodMap_["startWindowDrag"] = MethodMetadata{0, startWindowDrag};
+  // A window's geometry. The bodies are in core/WindowMethods.h, written once:
+  // nothing about reading two numbers or shaping the answer differs per
+  // desktop, and three copies would be three chances to drift.
+  methodMap_["setSize"] = MethodMetadata{2, windowSetSize};
+  methodMap_["setPosition"] = MethodMetadata{2, windowSetPosition};
+  methodMap_["center"] = MethodMetadata{0, windowCenter};
+  methodMap_["setFullScreen"] = MethodMetadata{1, windowSetFullScreen};
+  // How big it may be, whether it may be resized at all, and whether it floats.
+  // Not every desktop does every one of these; `getCapabilities` is how an app
+  // finds out rather than guessing. See core/WindowControl.h.
+  methodMap_["setMinimumSize"] = MethodMetadata{2, windowSetMinimumSize};
+  methodMap_["setMaximumSize"] = MethodMetadata{2, windowSetMaximumSize};
+  methodMap_["setResizable"] = MethodMetadata{1, windowSetResizable};
+  methodMap_["setAlwaysOnTop"] = MethodMetadata{1, windowSetAlwaysOnTop};
+  methodMap_["getCapabilities"] = MethodMetadata{0, windowGetCapabilities};
+  methodMap_["getBounds"] = MethodMetadata{0, windowGetBounds};
+  // What a NativeEventEmitter over this module calls; the events go out as
+  // device events either way.
+  methodMap_["addListener"] = MethodMetadata{1, noop};
+  methodMap_["removeListeners"] = MethodMetadata{1, noop};
+
+  titleBar().setMetricsListener([this](const TitleBarMetrics &metrics) {
+    emitDeviceEvent(kMetricsChangedEvent, [metrics](Runtime &runtime, std::vector<Value> &args) {
+      args.emplace_back(metricsValue(runtime, metrics));
+    });
+  });
+
+  // The window's geometry, the same way the title bar's metrics go out: a
+  // device event, so `useWindow()` can hand an app live bounds rather than a
+  // snapshot it has to remember to refresh.
+  setWindowBoundsListener([this](const WindowBounds &bounds) {
+    emitDeviceEvent(kWindowBoundsEvent, [bounds](Runtime &runtime, std::vector<Value> &args) {
+      Object object(runtime);
+      object.setProperty(runtime, "x", bounds.x);
+      object.setProperty(runtime, "y", bounds.y);
+      object.setProperty(runtime, "width", bounds.width);
+      object.setProperty(runtime, "height", bounds.height);
+      object.setProperty(runtime, "fullScreen", bounds.fullScreen);
+      object.setProperty(runtime, "maximized", bounds.maximized);
+      args.emplace_back(Value(runtime, object));
+    });
+  });
+
+  // And ask for the bounds once, now that something is listening. The host
+  // primes the cache when its window appears, but this module is built lazily
+  // -- the first time JavaScript asks for it -- so an app that mounts before
+  // then would read a window of no size and never be told otherwise.
+  postToUiThread([] { notifyWindowBoundsChanged(); });
+}
+
+GtkWindowModule::~GtkWindowModule() {
+  titleBar().setMetricsListener(nullptr);
+  setWindowBoundsListener(nullptr);
+}
+
+Value GtkWindowModule::setTitle(Runtime &runtime,
+                                   TurboModule & /*module*/,
+                                   const Value *args,
+                                   size_t count) {
+  std::optional<std::string> title;
+  if (count > 0 && args[0].isString()) {
+    title = args[0].getString(runtime).utf8(runtime);
+  }
+  postToUiThread([title = std::move(title)]() mutable { titleBar().setTitle(std::move(title)); });
+  return Value::undefined();
+}
+
+Value GtkWindowModule::setTitleBarColors(Runtime & /*runtime*/,
+                                            TurboModule & /*module*/,
+                                            const Value *args,
+                                            size_t count) {
+  const auto background = colorArgument(args, count, 0);
+  const auto text = colorArgument(args, count, 1);
+  const auto border = colorArgument(args, count, 2);
+  postToUiThread([background, text, border] { titleBar().setColors(background, text, border); });
+  return Value::undefined();
+}
+
+Value GtkWindowModule::setTitleBarStyle(Runtime &runtime,
+                                           TurboModule & /*module*/,
+                                           const Value *args,
+                                           size_t count) {
+  const bool hidden =
+      count > 0 && args[0].isString() && args[0].getString(runtime).utf8(runtime) == "hidden";
+  postToUiThread([hidden] {
+    titleBar().setStyle(hidden ? TitleBarStyle::Hidden : TitleBarStyle::Native);
+  });
+  return Value::undefined();
+}
+
+Value GtkWindowModule::getTitleBarMetrics(Runtime &runtime,
+                                             TurboModule & /*module*/,
+                                             const Value * /*args*/,
+                                             size_t /*count*/) {
+  return metricsValue(runtime, titleBar().metrics());
+}
+
+Value GtkWindowModule::minimize(Runtime & /*runtime*/,
+                      TurboModule & /*module*/,
+                      const Value * /*args*/,
+                      size_t /*count*/) {
+  postToUiThread([] { titleBar().minimize(); });
+  return Value::undefined();
+}
+
+Value GtkWindowModule::toggleMaximize(Runtime & /*runtime*/,
+                            TurboModule & /*module*/,
+                            const Value * /*args*/,
+                            size_t /*count*/) {
+  postToUiThread([] { titleBar().toggleMaximize(); });
+  return Value::undefined();
+}
+
+Value GtkWindowModule::closeWindow(Runtime & /*runtime*/,
+                         TurboModule & /*module*/,
+                         const Value * /*args*/,
+                         size_t /*count*/) {
+  postToUiThread([] { titleBar().close(); });
+  return Value::undefined();
+}
+
+Value GtkWindowModule::startWindowDrag(Runtime & /*runtime*/,
+                             TurboModule & /*module*/,
+                             const Value * /*args*/,
+                             size_t /*count*/) {
+  postToUiThread([] { titleBar().startDrag(); });
+  return Value::undefined();
+}
+
+Value GtkWindowModule::noop(Runtime & /*runtime*/,
+                               TurboModule & /*module*/,
+                               const Value * /*args*/,
+                               size_t /*count*/) {
+  return Value::undefined();
+}
+
+} // namespace basalt

package/native/gtk/GtkWindowModule.h

@@ -0,0 +1,62 @@
+// `BasaltWindow` on Linux: the module src/TitleBar.js talks to.
+//
+// The same four methods the Windows and macOS modules have, because the
+// JavaScript is shared and does not know which desktop it is on. What differs
+// is underneath, in GtkTitleBar.h.
+
+#pragma once
+
+#include <ReactCommon/TurboModule.h>
+
+#include <memory>
+
+namespace basalt {
+
+class GtkWindowModule : public facebook::react::TurboModule {
+ public:
+  static constexpr const char *kModuleName = "BasaltWindow";
+
+  explicit GtkWindowModule(std::shared_ptr<facebook::react::CallInvoker> jsInvoker);
+  ~GtkWindowModule() override;
+
+ private:
+  static facebook::jsi::Value setTitle(facebook::jsi::Runtime &runtime,
+                                       facebook::react::TurboModule &module,
+                                       const facebook::jsi::Value *args,
+                                       size_t count);
+  static facebook::jsi::Value setTitleBarColors(facebook::jsi::Runtime &runtime,
+                                                facebook::react::TurboModule &module,
+                                                const facebook::jsi::Value *args,
+                                                size_t count);
+  static facebook::jsi::Value setTitleBarStyle(facebook::jsi::Runtime &runtime,
+                                               facebook::react::TurboModule &module,
+                                               const facebook::jsi::Value *args,
+                                               size_t count);
+  static facebook::jsi::Value getTitleBarMetrics(facebook::jsi::Runtime &runtime,
+                                                 facebook::react::TurboModule &module,
+                                                 const facebook::jsi::Value *args,
+                                                 size_t count);
+  // The caption buttons' functions, for an app drawing its own header.
+  static facebook::jsi::Value minimize(facebook::jsi::Runtime &runtime,
+                                       facebook::react::TurboModule &module,
+                                       const facebook::jsi::Value *args,
+                                       size_t count);
+  static facebook::jsi::Value toggleMaximize(facebook::jsi::Runtime &runtime,
+                                             facebook::react::TurboModule &module,
+                                             const facebook::jsi::Value *args,
+                                             size_t count);
+  static facebook::jsi::Value closeWindow(facebook::jsi::Runtime &runtime,
+                                          facebook::react::TurboModule &module,
+                                          const facebook::jsi::Value *args,
+                                          size_t count);
+  static facebook::jsi::Value startWindowDrag(facebook::jsi::Runtime &runtime,
+                                              facebook::react::TurboModule &module,
+                                              const facebook::jsi::Value *args,
+                                              size_t count);
+  static facebook::jsi::Value noop(facebook::jsi::Runtime &runtime,
+                                   facebook::react::TurboModule &module,
+                                   const facebook::jsi::Value *args,
+                                   size_t count);
+};
+
+} // namespace basalt