basalt-gtk 0.0.0-rc5

package/native/gtk/GtkMountingManager.h

@@ -0,0 +1,146 @@
+// basalt-core — Fabric mounting layer
+//
+// Implements ReactCxxPlatform's IMountingManager: the single interface
+// ReactHost requires in order to put a React Native surface on screen.
+// Everything below translates ShadowViewMutation into GTK4 widget operations.
+
+#pragma once
+
+#include "GtkImageLoader.h"
+#include "GtkScrollView.h"
+#include "GtkTextInput.h"
+#include "MountingWalk.h"
+#include "RnView.h"
+
+#include <react/renderer/uimanager/IMountingManager.h>
+
+#include <memory>
+#include <unordered_map>
+
+namespace basalt {
+
+// The mutation walk, the registry and the surface-root handling all live in
+// MountingWalk and are shared with every other desktop platform. What is left
+// here is the part that is genuinely GTK: making a widget, parenting it, and
+// turning a ShadowView into widget state.
+class GtkMountingManager final : public facebook::react::IMountingManager,
+                                 public MountingWalk<GtkMountingManager, RnView *> {
+ public:
+
+  // The image loader, for the host to hand to React Native's
+  // `ImageLoaderModule` -- which is what `Image.getSize` and `Image.prefetch`
+  // reach. Shared so that module can hold a weak reference to it.
+  std::shared_ptr<GtkImageLoader> imageLoader() const { return imageLoader_; }
+  GtkMountingManager();
+  ~GtkMountingManager() noexcept override;
+
+  // --- IMountingManager -----------------------------------------------------
+
+  // Called on the JS thread, from the event loop's "update the rendering"
+  // step. Hands the transaction to the GTK main thread; does not touch widgets.
+  void executeMount(facebook::react::SurfaceId surfaceId,
+                    facebook::react::MountingTransaction &&transaction) override;
+
+  void dispatchCommand(const facebook::react::ShadowView &shadowView,
+                       const std::string &commandName,
+                       const folly::dynamic &args) override;
+
+  facebook::react::ComponentRegistryFactory getComponentRegistryFactory() override;
+
+  bool hasComponent(const std::string &name) override;
+
+  // ReactCxxPlatform hands the UIManager to the mounting manager and to nothing
+  // else. Reanimated needs it, and is constructed from JavaScript where no host
+  // object is in reach, so this passes it on. See core/UIManagerAccess.h.
+  void setUIManager(std::weak_ptr<facebook::react::UIManager> uiManager) noexcept override;
+
+  // --- Host-facing ----------------------------------------------------------
+  //
+  // createSurfaceRoot, destroySurfaceRoot, getSurfaceRoot, viewForTag and
+  // eventEmitterForTag come from MountingWalk. Callers cast the emitter to what
+  // they need: GtkTouchDispatcher to TouchEventEmitter, the image path to
+  // ImageEventEmitter.
+
+  // Applies a transaction to the widget tree. Invoked on the GTK main thread by
+  // executeMount's marshalling -- not part of IMountingManager, and never to be
+  // called directly.
+  // The main-thread half of dispatchCommand, public for the same reason
+  // applyTransaction is: the idle callback that carries it across has to call
+  // it, and the tests call it directly rather than spinning a main loop.
+  void applyCommand(facebook::react::Tag tag,
+                    const std::string &commandName,
+                    const folly::dynamic &args);
+
+  // A press ended on this view. A <Switch> is toggled from React Native's own
+  // touch path rather than by the GtkSwitch's own input, so that a press means
+  // the same thing on three desktops -- and so that the same synthesised tap
+  // the rest of the suite uses can reach it. See applyControlPeer.
+  //
+  // A no-op for every view that is not a switch.
+  void pressedView(facebook::react::Tag tag);
+
+  void applyTransaction(facebook::react::SurfaceId surfaceId,
+                        facebook::react::MountingTransaction &&transaction);
+
+  // The scroll views, for the host's BASALT_TEST_SCROLL instrument. Nothing
+  // else reaches in here: a real wheel arrives at the GtkEventControllerScroll
+  // the manager attached itself.
+  GtkScrollViewManager &scrollViews() {
+    return scrollViews_;
+  }
+
+ private:
+  // --- What MountingWalk asks of a platform ---------------------------------
+  friend class MountingWalk<GtkMountingManager, RnView *>;
+
+  RnView *createView(const facebook::react::ShadowView &shadowView);
+  RnView *createRootView(facebook::react::Tag tag);
+  void destroyView(RnView *view);
+  void insertChild(RnView *parent, RnView *child, int index);
+  void removeChild(RnView *parent, RnView *child);
+  void updateView(RnView *view, const facebook::react::ShadowView &shadowView);
+  void forgetTag(facebook::react::Tag tag);
+
+  // The GTK half of a control: a GtkSpinner for <ActivityIndicator> and
+  // <RefreshControl>, a GtkSwitch for <Switch>. Everything that is not a
+  // widget -- which props mean what, which scroll view a refresh control
+  // belongs to, when `onShow` fires -- is in MountingWalk.
+  void applyControlPeer(RnView *view, const basalt::ControlState &state);
+
+  // React DevTools' overlay rectangles. The parsing and the clearing are in
+  // MountingWalk; this is the drawing.
+  void setHighlights(RnView *view, const std::vector<basalt::Highlight> &highlights);
+
+  // --- The GTK half of updateView -------------------------------------------
+  void applyProps(RnView *view, const facebook::react::ShadowView &shadowView);
+  void applyText(RnView *view, const facebook::react::ShadowView &shadowView);
+  void applyImage(RnView *view, const facebook::react::ShadowView &shadowView);
+  void applyScrollView(RnView *view, const facebook::react::ShadowView &shadowView);
+  void applyAccessibility(RnView *view, const facebook::react::ShadowView &shadowView);
+  void applyTextInput(RnView *view, const facebook::react::ShadowView &shadowView);
+  void applyLayoutMetrics(RnView *view, const facebook::react::ShadowView &shadowView);
+
+  // Shared rather than held by value: React Native's `ImageLoaderModule` takes
+  // a `weak_ptr<IImageLoader>`, and this is the loader it gets. See
+  // `imageLoader()`.
+  std::shared_ptr<GtkImageLoader> imageLoader_ = std::make_shared<GtkImageLoader>();
+  GtkScrollViewManager scrollViews_;
+  GtkTextInputManager textInputs_;
+
+  // A <Switch> is a controlled component: the widget is not allowed to decide
+  // its own state, so the value React last sent is kept here and put straight
+  // back after the toggle that told JavaScript about it. React Native's iOS
+  // switch does exactly this.
+  std::unordered_map<facebook::react::Tag, bool> switchValues_;
+
+  // The CSS class each tinted control is currently carrying, so the next tint
+  // can take it off again. Interned strings owned by the table in the .cpp,
+  // never freed here.
+  std::unordered_map<facebook::react::Tag, const char *> controlClasses_;
+
+  // The source each <Image> is currently showing, so that a mutation which
+  // changed only layout does not restart the load.
+  std::unordered_map<facebook::react::Tag, std::string> imageUris_;
+};
+
+} // namespace basalt

package/native/gtk/GtkRunLoopObserver.cpp

@@ -0,0 +1,77 @@
+#include "GtkRunLoopObserver.h"
+
+#include <react/utils/RunLoopObserverManager.h>
+
+namespace basalt {
+
+namespace {
+
+struct BeatSource {
+  GSource source;
+  // A bare pointer into a shared_ptr held below. GSource is a C struct with no
+  // destructor of its own, so the owning reference lives in a member that
+  // finalize() destroys explicitly.
+  std::shared_ptr<facebook::react::RunLoopObserverManager> *manager;
+};
+
+// Called once per main-loop iteration, before the loop polls. Returning FALSE
+// with no timeout means "I am never ready", so this source never causes a
+// wake-up and never spins: it only rides along on iterations that something
+// else caused.
+gboolean beatPrepare(GSource *source, gint *timeout) {
+  auto *self = reinterpret_cast<BeatSource *>(source);
+  if (self->manager != nullptr && *self->manager != nullptr) {
+    (*self->manager)->onRender();
+  }
+  *timeout = -1;
+  return FALSE;
+}
+
+gboolean beatCheck(GSource * /*source*/) {
+  return FALSE;
+}
+
+gboolean beatDispatch(GSource * /*source*/, GSourceFunc /*callback*/, gpointer /*userData*/) {
+  return G_SOURCE_CONTINUE;
+}
+
+void beatFinalize(GSource *source) {
+  auto *self = reinterpret_cast<BeatSource *>(source);
+  delete self->manager;
+  self->manager = nullptr;
+}
+
+GSourceFuncs beatSourceFuncs = {
+    .prepare = beatPrepare,
+    .check = beatCheck,
+    .dispatch = beatDispatch,
+    .finalize = beatFinalize,
+    .closure_callback = nullptr,
+    .closure_marshal = nullptr,
+};
+
+} // namespace
+
+GSource *installRunLoopObserver(std::shared_ptr<facebook::react::RunLoopObserverManager> manager) {
+  GSource *source = g_source_new(&beatSourceFuncs, sizeof(BeatSource));
+  auto *self = reinterpret_cast<BeatSource *>(source);
+  self->manager = new std::shared_ptr<facebook::react::RunLoopObserverManager>(std::move(manager));
+
+  // Below the default, so this runs after ordinary work has been queued rather
+  // than ahead of it. prepare() is called regardless of priority, but keeping
+  // it low makes the intent clear.
+  g_source_set_priority(source, G_PRIORITY_DEFAULT_IDLE);
+  g_source_set_name(source, "react-native event beat");
+  g_source_attach(source, nullptr);
+  return source;
+}
+
+void removeRunLoopObserver(GSource *source) {
+  if (source == nullptr) {
+    return;
+  }
+  g_source_destroy(source);
+  g_source_unref(source);
+}
+
+} // namespace basalt

package/native/gtk/GtkRunLoopObserver.h

@@ -0,0 +1,41 @@
+// Driving React Native's event beat from the GTK main loop.
+//
+// Nothing an EventEmitter produces reaches JavaScript on its own.
+// `EventQueue::onEnqueue` only sets a flag on the EventBeat; the queue is
+// flushed when something calls `RunLoopObserverManager::onRender()`, which
+// induces the beat. Until that is wired, touches are enqueued and silently
+// never delivered -- which is exactly how this platform behaved before input
+// existed, and why it was not noticed earlier.
+//
+// The observer React Native asks for is `Activity::BeforeWaiting`: run just
+// before the loop goes to sleep, having drained whatever else was pending. On
+// iOS that is a CFRunLoopObserver, and on Android the Choreographer.
+//
+// The GLib equivalent is a GSource that does its work in `prepare()` and never
+// reports itself ready. `prepare()` runs once per main-loop iteration, before
+// the poll, and an idle loop blocks in that poll rather than spinning -- so
+// this costs one function call per iteration when busy and nothing at all when
+// the application is idle. A tick callback on the frame clock would also work,
+// but it would hold the frame clock open and wake the process at display rate
+// forever, which is the wrong trade for a desktop app that is usually still.
+
+#pragma once
+
+#include <glib.h>
+
+#include <memory>
+
+namespace facebook::react {
+class RunLoopObserverManager;
+}
+
+namespace basalt {
+
+// Installs the source on the default main context. Returns the GSource, which
+// the caller owns: destroy it with removeRunLoopObserver before the manager it
+// refers to goes away.
+GSource *installRunLoopObserver(std::shared_ptr<facebook::react::RunLoopObserverManager> manager);
+
+void removeRunLoopObserver(GSource *source);
+
+} // namespace basalt