basalt-gtk 0.0.0-rc5

package/native/gtk/FontRegistryFontconfig.cpp

@@ -0,0 +1,127 @@
+#include "FontRegistry.h"
+
+#include <pango/pangocairo.h>
+#include <pango/pangofc-fontmap.h>
+
+#include <fontconfig/fontconfig.h>
+// FcFreeTypeQuery lives here rather than in fontconfig.h, and it is what reads
+// the family name out of the file.
+#include <fontconfig/fcfreetype.h>
+
+#include <mutex>
+#include <unordered_map>
+#include <vector>
+
+namespace basalt {
+
+namespace {
+
+struct Registry {
+  std::mutex mutex;
+  unsigned long generation{0};
+  // What the app calls it -> what the file calls itself.
+  std::unordered_map<std::string, std::string> families;
+  std::vector<std::string> order;
+};
+
+Registry &registry() {
+  static Registry instance;
+  return instance;
+}
+
+// The family name recorded inside the file. fontconfig will happily add a file
+// and then index it under a name the app has never heard of, so this is read
+// back rather than assumed.
+std::string familyInFile(const std::string &path) {
+  FcBlanks *blanks = FcConfigGetBlanks(FcConfigGetCurrent());
+  int count = 0;
+  FcPattern *pattern =
+      FcFreeTypeQuery(reinterpret_cast<const FcChar8 *>(path.c_str()), 0, blanks, &count);
+  if (pattern == nullptr) {
+    return {};
+  }
+
+  FcChar8 *family = nullptr;
+  std::string result;
+  if (FcPatternGetString(pattern, FC_FAMILY, 0, &family) == FcResultMatch && family != nullptr) {
+    result = reinterpret_cast<const char *>(family);
+  }
+  FcPatternDestroy(pattern);
+  return result;
+}
+
+} // namespace
+
+bool registerFont(const std::string &name, const std::string &path) {
+  Registry &state = registry();
+  const std::lock_guard<std::mutex> lock(state.mutex);
+
+  if (state.families.find(name) != state.families.end()) {
+    return true;
+  }
+
+  if (FcInit() == FcFalse) {
+    return false;
+  }
+  if (FcConfigAppFontAddFile(FcConfigGetCurrent(),
+                             reinterpret_cast<const FcChar8 *>(path.c_str())) == FcFalse) {
+    return false;
+  }
+
+  const std::string family = familyInFile(path);
+  if (family.empty()) {
+    // Added to fontconfig but unusable: without the real family there is no way
+    // to ask Pango for it, and pretending otherwise would fail later and
+    // further away.
+    return false;
+  }
+
+  state.families.emplace(name, family);
+  state.order.push_back(name);
+  state.generation++;
+
+  // Pango caches which fonts exist. Adding one to fontconfig behind its back
+  // leaves it looking at the old list, so the family would not be found until
+  // something else happened to invalidate it. Only meaningful for a fontconfig
+  // backed map, which is not the only kind Pango has.
+  PangoFontMap *fontMap = pango_cairo_font_map_get_default();
+  if (PANGO_IS_FC_FONT_MAP(fontMap)) {
+    pango_fc_font_map_config_changed(PANGO_FC_FONT_MAP(fontMap));
+  }
+
+  return true;
+}
+
+unsigned long fontGeneration() {
+  Registry &state = registry();
+  const std::lock_guard<std::mutex> lock(state.mutex);
+  return state.generation;
+}
+
+std::string resolveFontFamily(const std::string &name) {
+  Registry &state = registry();
+  const std::lock_guard<std::mutex> lock(state.mutex);
+  const auto it = state.families.find(name);
+  return it == state.families.end() ? name : it->second;
+}
+
+bool isFontRegistered(const std::string &name) {
+  Registry &state = registry();
+  const std::lock_guard<std::mutex> lock(state.mutex);
+  return state.families.find(name) != state.families.end();
+}
+
+std::string registeredFontNamesJoined(char separator) {
+  Registry &state = registry();
+  const std::lock_guard<std::mutex> lock(state.mutex);
+  std::string joined;
+  for (const auto &name : state.order) {
+    if (!joined.empty()) {
+      joined.push_back(separator);
+    }
+    joined += name;
+  }
+  return joined;
+}
+
+} // namespace basalt

package/native/gtk/GtkAnimationChoreographer.cpp

@@ -0,0 +1,73 @@
+#include "GtkAnimationChoreographer.h"
+
+namespace basalt {
+
+GtkAnimationChoreographer::~GtkAnimationChoreographer() {
+  detach();
+}
+
+void GtkAnimationChoreographer::onFrameClockUpdate(GdkFrameClock * /*clock*/, gpointer userData) {
+  auto *self = static_cast<GtkAnimationChoreographer *>(userData);
+  self->onAnimationFrame(self->now());
+}
+
+gboolean GtkAnimationChoreographer::syncRunningStateOnMainThread(gpointer userData) {
+  auto *self = static_cast<GtkAnimationChoreographer *>(userData);
+  self->setUpdating(self->running_.load(std::memory_order_acquire));
+  return G_SOURCE_REMOVE;
+}
+
+void GtkAnimationChoreographer::setUpdating(bool shouldUpdate) {
+  if (frameClock_ == nullptr || shouldUpdate == updating_) {
+    return;
+  }
+  if (shouldUpdate) {
+    gdk_frame_clock_begin_updating(frameClock_);
+  } else {
+    gdk_frame_clock_end_updating(frameClock_);
+  }
+  updating_ = shouldUpdate;
+}
+
+void GtkAnimationChoreographer::attachToWidget(GtkWidget *widget) {
+  detach();
+
+  GdkFrameClock *clock = gtk_widget_get_frame_clock(widget);
+  if (clock == nullptr) {
+    g_warning("GtkAnimationChoreographer: widget has no frame clock (not "
+              "realised yet); animations will not tick");
+    return;
+  }
+
+  frameClock_ = GDK_FRAME_CLOCK(g_object_ref(clock));
+  updateHandler_ = g_signal_connect(frameClock_, "update",
+                                    G_CALLBACK(onFrameClockUpdate), this);
+
+  // A resume() may have arrived before the widget was realised.
+  setUpdating(running_.load(std::memory_order_acquire));
+}
+
+void GtkAnimationChoreographer::detach() {
+  if (frameClock_ == nullptr) {
+    return;
+  }
+  setUpdating(false);
+  if (updateHandler_ != 0) {
+    g_signal_handler_disconnect(frameClock_, updateHandler_);
+    updateHandler_ = 0;
+  }
+  g_object_unref(frameClock_);
+  frameClock_ = nullptr;
+}
+
+void GtkAnimationChoreographer::resume() {
+  running_.store(true, std::memory_order_release);
+  g_idle_add_full(G_PRIORITY_DEFAULT, syncRunningStateOnMainThread, this, nullptr);
+}
+
+void GtkAnimationChoreographer::pause() {
+  running_.store(false, std::memory_order_release);
+  g_idle_add_full(G_PRIORITY_DEFAULT, syncRunningStateOnMainThread, this, nullptr);
+}
+
+} // namespace basalt

package/native/gtk/GtkAnimationChoreographer.h

@@ -0,0 +1,49 @@
+// Drives React Native's animation frame callbacks from GTK's frame clock.
+//
+// AnimationChoreographer is the frame-callback seam in ReactCxxPlatform. It is
+// NOT what drives mounting -- mounts arrive on the JS thread via the
+// RuntimeScheduler and are marshalled by GtkMountingManager. This is purely
+// the "there is a new frame" signal the animation backend needs.
+
+#pragma once
+
+#include <gtk/gtk.h>
+
+#include <react/renderer/animationbackend/AnimationChoreographer.h>
+
+#include <atomic>
+
+namespace basalt {
+
+class GtkAnimationChoreographer final : public facebook::react::AnimationChoreographer {
+ public:
+  GtkAnimationChoreographer() = default;
+  ~GtkAnimationChoreographer() override;
+
+  // Called from the JS thread. Both marshal to the main thread before touching
+  // the frame clock.
+  void resume() override;
+  void pause() override;
+
+  // Called on the GTK main thread once the surface root is realised: a widget
+  // has no frame clock before realisation.
+  void attachToWidget(GtkWidget *widget);
+  void detach();
+
+ private:
+  static void onFrameClockUpdate(GdkFrameClock *clock, gpointer userData);
+  static gboolean syncRunningStateOnMainThread(gpointer userData);
+
+  // gdk_frame_clock_begin_updating/end_updating are refcounted, so calls must
+  // be balanced. This tracks whether our single reference is currently held.
+  void setUpdating(bool shouldUpdate);
+
+  GdkFrameClock *frameClock_{nullptr};
+  gulong updateHandler_{0};
+  bool updating_{false};
+
+  // Written from the JS thread, read on the main thread.
+  std::atomic<bool> running_{false};
+};
+
+} // namespace basalt

package/native/gtk/GtkDropTarget.cpp

@@ -0,0 +1,269 @@
+#include "GtkDropTarget.h"
+
+#include "DragAndDrop.h"
+
+#include <string>
+#include <vector>
+
+namespace basalt {
+namespace {
+
+// What the drop target is currently over, so that a leave can be reported for
+// the view that was entered rather than for whatever is under the pointer when
+// the drag ends -- by then it may be nothing.
+facebook::react::Tag gCurrentTarget = 0;
+
+// Turns GTK's dragged value into the shared payload.
+//
+// Two types are asked for, and both may arrive: G_TYPE_FILE for a file
+// manager's drag and G_TYPE_STRING for selected text. A drag carrying neither
+// is one this app has nothing to say about, which `wouldAccept` then refuses.
+DragPayload payloadFrom(const GValue *value) {
+  DragPayload payload;
+  if (value == nullptr) {
+    return payload;
+  }
+  if (G_VALUE_HOLDS(value, GDK_TYPE_FILE_LIST)) {
+    auto *files = static_cast<GSList *>(g_value_get_boxed(value));
+    for (GSList *node = files; node != nullptr; node = node->next) {
+      auto *file = static_cast<GFile *>(node->data);
+      char *path = file != nullptr ? g_file_get_path(file) : nullptr;
+      if (path != nullptr) {
+        payload.files.emplace_back(path);
+        g_free(path);
+      }
+    }
+  } else if (G_VALUE_HOLDS(value, G_TYPE_FILE)) {
+    auto *file = static_cast<GFile *>(g_value_get_object(value));
+    char *path = file != nullptr ? g_file_get_path(file) : nullptr;
+    if (path != nullptr) {
+      payload.files.emplace_back(path);
+      g_free(path);
+    }
+  } else if (G_VALUE_HOLDS(value, G_TYPE_STRING)) {
+    const char *text = g_value_get_string(value);
+    if (text != nullptr) {
+      payload.text = text;
+    }
+  }
+  return payload;
+}
+
+// What a drag offers, before it is dropped.
+//
+// GTK will not hand over the value until the drop on most backends, so the
+// question "would anything here take this?" is answered from the formats the
+// drag advertises rather than from its contents. That is the same question the
+// desktop is asking, which is why the cursor can answer it.
+std::uint16_t offeredBy(GdkDrop *drop) {
+  std::uint16_t offered = DropAcceptsNone;
+  if (drop == nullptr) {
+    return offered;
+  }
+  GdkContentFormats *formats = gdk_drop_get_formats(drop);
+  if (formats == nullptr) {
+    return offered;
+  }
+  if (gdk_content_formats_contain_gtype(formats, GDK_TYPE_FILE_LIST) ||
+      gdk_content_formats_contain_gtype(formats, G_TYPE_FILE)) {
+    offered |= DropAcceptsFiles;
+  }
+  if (gdk_content_formats_contain_gtype(formats, G_TYPE_STRING)) {
+    offered |= DropAcceptsText;
+  }
+  return offered;
+}
+
+void reportLeaveIfAny(double x, double y) {
+  if (gCurrentTarget == 0) {
+    return;
+  }
+  DropEvent event;
+  event.tag = gCurrentTarget;
+  event.phase = DropPhase::Leave;
+  event.x = x;
+  event.y = y;
+  reportDrop(event);
+  gCurrentTarget = 0;
+}
+
+} // namespace
+
+facebook::react::Tag dropTargetAt(RnView *root, double x, double y, std::uint16_t accepts) {
+  if (root == nullptr || !RN_IS_VIEW(root)) {
+    return 0;
+  }
+  GtkWidget *const rootWidget = GTK_WIDGET(root);
+  GtkWidget *widget = gtk_widget_pick(rootWidget, x, y, GTK_PICK_DEFAULT);
+
+  for (; widget != nullptr; widget = gtk_widget_get_parent(widget)) {
+    // The chain is not all RnViews -- a <TextInput>'s peer is a GtkText -- so
+    // anything else is stepped over rather than stopping the walk. Same rule
+    // as GtkTitleBarLayout.cpp.
+    if (RN_IS_VIEW(widget)) {
+      const char *id = rn_view_get_native_id(RN_VIEW(widget));
+      if (id != nullptr) {
+        const std::uint16_t wanted = dropAcceptsFrom(id);
+        if (wanted != DropAcceptsNone && (wanted & accepts) != 0) {
+          return rn_view_get_tag(RN_VIEW(widget));
+        }
+      }
+    }
+    if (widget == rootWidget) {
+      break;
+    }
+  }
+  return 0;
+}
+
+DragPayload dragPayloadAt(RnView *root, double x, double y) {
+  if (root == nullptr || !RN_IS_VIEW(root)) {
+    return {};
+  }
+  GtkWidget *const rootWidget = GTK_WIDGET(root);
+  GtkWidget *widget = gtk_widget_pick(rootWidget, x, y, GTK_PICK_DEFAULT);
+
+  // The same walk the drop side makes, and the same reason: a label inside a
+  // draggable view should be draggable without being marked itself.
+  for (; widget != nullptr; widget = gtk_widget_get_parent(widget)) {
+    if (RN_IS_VIEW(widget)) {
+      const char *id = rn_view_get_native_id(RN_VIEW(widget));
+      if (id != nullptr) {
+        const DragPayload payload = dragPayloadFrom(id);
+        if (!payload.empty()) {
+          return payload;
+        }
+      }
+    }
+    if (widget == rootWidget) {
+      break;
+    }
+  }
+  return {};
+}
+
+void attachDragSource(RnView *root) {
+  if (root == nullptr || !RN_IS_VIEW(root)) {
+    return;
+  }
+
+  GtkDragSource *source = gtk_drag_source_new();
+  gtk_drag_source_set_actions(source, GDK_ACTION_COPY);
+
+  // "prepare" is asked once, when the gesture has gone far enough to be a
+  // drag, and its answer *is* the drag: returning NULL means this point is not
+  // draggable and the gesture becomes an ordinary press again. Which is why
+  // the payload has to be known already -- there is nowhere to wait here.
+  g_signal_connect(source,
+                   "prepare",
+                   G_CALLBACK(+[](GtkDragSource *, double x, double y, gpointer data)
+                                  -> GdkContentProvider * {
+                     auto *rootView = static_cast<RnView *>(data);
+                     const DragPayload payload = dragPayloadAt(rootView, x, y);
+                     if (payload.hasFiles()) {
+                       GFile *file = g_file_new_for_path(payload.files.front().c_str());
+                       GdkContentProvider *provider =
+                           gdk_content_provider_new_typed(G_TYPE_FILE, file);
+                       g_object_unref(file);
+                       return provider;
+                     }
+                     if (payload.hasText()) {
+                       return gdk_content_provider_new_typed(
+                           G_TYPE_STRING, payload.text.c_str());
+                     }
+                     return nullptr;
+                   }),
+                   root);
+
+  gtk_widget_add_controller(GTK_WIDGET(root), GTK_EVENT_CONTROLLER(source));
+}
+
+void attachDropTarget(RnView *root) {
+  if (root == nullptr || !RN_IS_VIEW(root)) {
+    return;
+  }
+
+  // Both types, and COPY only: this platform has no notion of a drag that
+  // moves or links, and offering one it cannot honour would be a cursor that
+  // promises something the drop does not do.
+  GtkDropTarget *target = gtk_drop_target_new(G_TYPE_INVALID, GDK_ACTION_COPY);
+  GType types[] = {GDK_TYPE_FILE_LIST, G_TYPE_STRING};
+  gtk_drop_target_set_gtypes(target, types, G_N_ELEMENTS(types));
+
+  // "motion" rather than "enter": enter fires once for the *window*, and what
+  // an app wants to know is which of its views the pointer is over, which
+  // changes without ever leaving.
+  g_signal_connect(target,
+                   "motion",
+                   G_CALLBACK(+[](GtkDropTarget *self, double x, double y, gpointer data)
+                                  -> GdkDragAction {
+                     auto *rootView = static_cast<RnView *>(data);
+                     const std::uint16_t offered = offeredBy(gtk_drop_target_get_current_drop(self));
+                     const facebook::react::Tag found = dropTargetAt(rootView, x, y, offered);
+
+                     if (found != gCurrentTarget) {
+                       reportLeaveIfAny(x, y);
+                     }
+                     if (found == 0) {
+                       // Nothing here takes it: no action, which is what makes
+                       // the cursor say so.
+                       return static_cast<GdkDragAction>(0);
+                     }
+                     gCurrentTarget = found;
+
+                     DropEvent event;
+                     event.tag = found;
+                     event.phase = DropPhase::Over;
+                     event.x = x;
+                     event.y = y;
+                     reportDrop(event);
+                     return GDK_ACTION_COPY;
+                   }),
+                   root);
+
+  g_signal_connect(target,
+                   "leave",
+                   G_CALLBACK(+[](GtkDropTarget *, gpointer) { reportLeaveIfAny(0.0, 0.0); }),
+                   nullptr);
+
+  g_signal_connect(target,
+                   "drop",
+                   G_CALLBACK(+[](GtkDropTarget *,
+                                  const GValue *value,
+                                  double x,
+                                  double y,
+                                  gpointer data) -> gboolean {
+                     auto *rootView = static_cast<RnView *>(data);
+                     const DragPayload payload = payloadFrom(value);
+                     // Asked again from the payload rather than from the
+                     // formats: this is the one moment the contents are known,
+                     // and a view that accepts only files should not be handed
+                     // a drag that turned out to be only text.
+                     std::uint16_t carries = DropAcceptsNone;
+                     if (payload.hasFiles()) {
+                       carries |= DropAcceptsFiles;
+                     }
+                     if (payload.hasText()) {
+                       carries |= DropAcceptsText;
+                     }
+                     const facebook::react::Tag found = dropTargetAt(rootView, x, y, carries);
+                     gCurrentTarget = 0;
+                     if (found == 0) {
+                       return FALSE;
+                     }
+
+                     DropEvent event;
+                     event.tag = found;
+                     event.phase = DropPhase::Drop;
+                     event.x = x;
+                     event.y = y;
+                     event.payload = payload;
+                     reportDrop(event);
+                     return TRUE;
+                   }),
+                   root);
+
+  gtk_widget_add_controller(GTK_WIDGET(root), GTK_EVENT_CONTROLLER(target));
+}
+
+} // namespace basalt

package/native/gtk/GtkDropTarget.h

@@ -0,0 +1,40 @@
+// The GTK half of drag and drop: what happens when something is dragged onto
+// the window.
+//
+// See core/DragAndDrop.h for the model, which is shared, and for why a view
+// declares itself a drop target by its nativeID.
+
+#pragma once
+
+#include "DragAndDrop.h"
+#include "RnView.h"
+
+#include <gtk/gtk.h>
+
+#include <cstdint>
+
+#include <react/renderer/core/ReactPrimitives.h>
+
+namespace basalt {
+
+// The deepest view under this point that would take what is being dragged, or
+// 0 for none.
+//
+// The same walk `isTitleBarDragRegionAt` makes, and it has to be: a label
+// inside a drop target should not need marking, and a drop target inside
+// another should win.
+facebook::react::Tag dropTargetAt(RnView *root, double x, double y, std::uint16_t accepts);
+
+// Attaches a GtkDropTarget to the surface root, so the window accepts files
+// and text dragged onto it from anywhere on the desktop.
+void attachDropTarget(RnView *root);
+
+// The payload a marked view under this point represents, or an empty one.
+// The other direction: see core/DragAndDrop.h.
+DragPayload dragPayloadAt(RnView *root, double x, double y);
+
+// Attaches a GtkDragSource, so a marked view can be dragged out of the window
+// to anywhere on the desktop.
+void attachDragSource(RnView *root);
+
+} // namespace basalt