basalt-gtk 0.0.0-rc5 → 0.1.0

package/native/CMakeLists.txt

@@ -323,19 +323,35 @@ if(TARGET basalt_core)
     tests/test_mounting.cpp
     tests/test_view.cpp
     tests/test_text.cpp
+    tests/test_selection.cpp
+    # Fonts loaded at runtime: core/FontRegistry.h's GTK half, the Pango
+    # context a late registration has to reload, and the measurement cache it
+    # has to empty.
+    tests/test_fonts.cpp
     tests/test_focus.cpp
     tests/test_key_events_gtk.cpp
     tests/test_hittest.cpp
     tests/test_scrollview.cpp
     tests/test_image.cpp
+    # Animated images: gdk-pixbuf's frames, paced by core's clamp. Real pixels,
+    # because a view that advanced its iterator and kept painting the first
+    # texture would pass on the frame index alone.
+    tests/test_animated_image.cpp
     tests/test_accessibility.cpp
     tests/test_viewprops.cpp
+    # What reached the pixels, asking what tests/test_win32_paint.cpp asks of
+    # Direct2D. No display and no window: see tests/GtkPixels.h.
+    tests/test_gtk_paint.cpp
     tests/test_textinput.cpp
     tests/test_titlebar.cpp
     # The drag regions, asking what tests/test_win32_titlebar.cpp asks of
     # Windows. Needs a shown window: it walks up from gtk_widget_pick.
     tests/test_titlebar_drag.cpp
     tests/test_version.cpp
+    # The clipboard seam and which thread it runs on, asking what
+    # tests/test_win32_clipboard.cpp asks of Windows. Uses the real clipboard and
+    # puts back what was there.
+    tests/test_gtk_clipboard.cpp
     # Hit testing lives with the touch dispatcher, which the host builds; the
     # tests need it too, and it pulls in nothing else.
     gtk/GtkFocus.cpp

package/native/gtk/ComponentRegistryGtk.cpp

@@ -3,6 +3,8 @@
 
 #include "ComponentRegistry.h"
 #include "ExpoImageComponent.h"
+#include "SafeAreaComponent.h"
+#include "ScreensComponent.h"
 
 #include <react/renderer/componentregistry/ComponentDescriptorProviderRegistry.h>
 #include <react/renderer/components/FBReactNativeSpec/ComponentDescriptors.h>
@@ -24,6 +26,24 @@ ComponentRegistryFactory getDefaultComponentRegistryFactory() {
     static auto providerRegistry = []() {
       auto registry = std::make_shared<ComponentDescriptorProviderRegistry>();
       registry->add(concreteComponentDescriptorProvider<ViewComponentDescriptor>());
+      // react-native-safe-area-context's provider. Registered on every
+      // platform, like expo-image's above: the descriptor is ordinary Fabric
+      // C++ and an app that never mounts one pays a registry entry. Without
+      // it the provider renders its children never, not badly. See
+      // core/SafeAreaComponent.h.
+      registry->add(concreteComponentDescriptorProvider<SafeAreaProviderComponentDescriptor>());
+      // react-native-screens. RNSScreen carries activityState, which is what
+      // hides the screen behind the one in front; the rest are containers that
+      // only need their names known, since an unregistered name becomes
+      // UnimplementedNativeView and carries none of the layout props. See
+      // core/ScreensComponent.h.
+      registry->add(concreteComponentDescriptorProvider<RNSScreenComponentDescriptor>());
+      registry->add(concreteComponentDescriptorProvider<RNSScreenStackComponentDescriptor>());
+      registry->add(concreteComponentDescriptorProvider<RNSScreenContainerComponentDescriptor>());
+      registry->add(concreteComponentDescriptorProvider<RNSScreenNavigationContainerComponentDescriptor>());
+      registry->add(concreteComponentDescriptorProvider<RNSScreenContentWrapperComponentDescriptor>());
+      registry->add(concreteComponentDescriptorProvider<RNSScreenStackHeaderConfigComponentDescriptor>());
+      registry->add(concreteComponentDescriptorProvider<RNSScreenStackHeaderSubviewComponentDescriptor>());
       // Text is three descriptors, and only one of them mounts. <Text> becomes
       // a Text node, its string a RawText node, and the outermost <Text>
       // becomes a Paragraph that folds the whole subtree into a single

package/native/gtk/FontRegistryFontconfig.cpp

@@ -82,8 +82,16 @@ bool registerFont(const std::string &name, const std::string &path) {
 
   // 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.
+  // something else happened to invalidate it.
+  //
+  // Only meaningful for a fontconfig backed map, which is not the only kind
+  // Pango has, and the other kind is reachable: on a Mac, Homebrew's Pango
+  // answers this with a `PangoCairoCoreTextFontMap`, which does not consult
+  // fontconfig at all. A font loaded at runtime is then registered here and
+  // invisible to the text engine. That is a property of running the GTK host on
+  // macOS, which is a comparison arrangement rather than a target, and
+  // tests/test_fonts.cpp stops at the mapping when it sees that map. docs/
+  // TESTING.md records it.
   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));

package/native/gtk/GtkFocus.cpp

@@ -42,6 +42,13 @@ GtkFocusManager::GtkFocusManager(GtkMountingManager *mountingManager, RnView *su
   g_object_add_weak_pointer(G_OBJECT(keyController_),
                             reinterpret_cast<gpointer *>(&keyController_));
 
+  // Weak for the reason the controller above is: the root can be destroyed
+  // before this manager is, and then every line of the destructor is reading
+  // freed memory. GObject nulls the pointer on finalise, which is the only way
+  // to know -- see the destructor.
+  g_object_add_weak_pointer(G_OBJECT(surfaceRoot_),
+                            reinterpret_cast<gpointer *>(&surfaceRoot_));
+
   // The root may or may not be in a window yet, depending on the order the host
   // built things in, so both are handled rather than one being assumed.
   attachToWindow();
@@ -53,8 +60,19 @@ GtkFocusManager::~GtkFocusManager() {
     g_signal_handlers_disconnect_by_data(window_, this);
     window_ = nullptr;
   }
-  if (surfaceRoot_ != nullptr && RN_IS_VIEW(surfaceRoot_)) {
+  // Only if the root is still there, which the weak pointer is what says.
+  //
+  // This used to ask `RN_IS_VIEW(surfaceRoot_)`, which cannot work and is worth
+  // recording as a trap: a type check reads the instance's type pointer out of
+  // the object, so on a freed GObject it reads GLib's 0xaa poison and
+  // dereferences it. The crash was `SIGSEGV at 0xaaaaaaaaaaaaaaaa` inside
+  // RN_IS_VIEW, from this destructor, and it was latent for as long as the
+  // freed bytes at that offset happened not to fault.
+  if (surfaceRoot_ != nullptr) {
     g_signal_handlers_disconnect_by_data(surfaceRoot_, this);
+    g_object_remove_weak_pointer(G_OBJECT(surfaceRoot_),
+                                 reinterpret_cast<gpointer *>(&surfaceRoot_));
+    surfaceRoot_ = nullptr;
   }
   // The key controller belongs to the widget, and that is exactly why it has to
   // be disconnected: it outlives *this*, because both teardown paths reset the
@@ -77,6 +95,9 @@ void GtkFocusManager::onRootChanged(GObject * /*widget*/, GParamSpec * /*spec*/,
 }
 
 void GtkFocusManager::attachToWindow() {
+  if (surfaceRoot_ == nullptr) {
+    return;
+  }
   GtkRoot *root = gtk_widget_get_root(GTK_WIDGET(surfaceRoot_));
   GtkWindow *window = GTK_IS_WINDOW(root) ? GTK_WINDOW(root) : nullptr;
   if (window == window_) {

package/native/gtk/GtkFocus.h

@@ -102,6 +102,9 @@ class GtkFocusManager {
   void emitFocus(facebook::react::Tag tag, bool focused);
 
   GtkMountingManager *mountingManager_;
+  // The surface root, held weakly: GObject nulls this when the view is
+  // finalised, which is what makes the destructor safe to run after the root
+  // has gone. A type check cannot do that job -- see the destructor.
   RnView *surfaceRoot_;
   GtkEventController *keyController_{nullptr};
   // The window this is listening to, held weakly: it outlives the manager in

package/native/gtk/GtkImageLoader.cpp

@@ -15,6 +15,9 @@ struct GtkImageLoader::Pending {
   std::string bytes;
   std::string error;
   Callback callback;
+  // Called from the worker thread as the bytes arrive, rather than from
+  // `deliver` below: see the header.
+  basalt::ImageProgress onProgress;
 };
 
 GtkImageLoader::GtkImageLoader() = default;
@@ -24,6 +27,10 @@ GtkImageLoader::~GtkImageLoader() {
     g_clear_object(&texture);
   }
   cache_.clear();
+  for (auto &[uri, animation] : animations_) {
+    g_clear_object(&animation);
+  }
+  animations_.clear();
 }
 
 // Caches the texture and drops whatever that pushed out. See core/ImageCache.h
@@ -44,6 +51,11 @@ void GtkImageLoader::remember(const std::string &uri, GdkTexture *texture) {
       g_clear_object(&it->second);
       cache_.erase(it);
     }
+    const auto animated = animations_.find(evicted);
+    if (animated != animations_.end()) {
+      g_clear_object(&animated->second);
+      animations_.erase(animated);
+    }
   }
 }
 
@@ -60,13 +72,23 @@ gboolean GtkImageLoader::deliver(gpointer data) {
     GBytes *bytes = g_bytes_new(pending->bytes.data(), pending->bytes.size());
     GError *decodeError = nullptr;
     texture = gdk_texture_new_from_bytes(bytes, &decodeError);
-    g_bytes_unref(bytes);
     if (texture == nullptr) {
       error = decodeError != nullptr ? decodeError->message : "could not decode image";
       g_clear_error(&decodeError);
     } else {
+      // The same bytes again, as an animation. A second decode rather than one
+      // path for both, because `gdk_texture_new_from_bytes` is what every
+      // still image goes through and this must not change what it produces:
+      // gdk-pixbuf's loaders and GDK's are not the same set, and a PNG that
+      // decodes one way may not decode the other.
+      //
+      // Only one frame's worth of extra work for a still image, which is what
+      // nearly every <Image> is: `is_static_image` is the first thing asked,
+      // and gdk-pixbuf has already stopped at the first frame to answer it.
+      pending->loader->rememberAnimation(pending->uri, bytes);
       pending->loader->remember(pending->uri, texture);
     }
+    g_bytes_unref(bytes);
   }
 
   pending->callback(texture, error);
@@ -74,7 +96,9 @@ gboolean GtkImageLoader::deliver(gpointer data) {
   return G_SOURCE_REMOVE;
 }
 
-void GtkImageLoader::load(const std::string &uri, Callback &&callback) {
+void GtkImageLoader::load(const std::string &uri,
+                          Callback &&callback,
+                          basalt::ImageProgress onProgress) {
   if (uri.empty()) {
     callback(nullptr, "empty source uri");
     return;
@@ -86,12 +110,12 @@ void GtkImageLoader::load(const std::string &uri, Callback &&callback) {
     return;
   }
 
-  auto *pending = new Pending{this, uri, {}, {}, std::move(callback)};
+  auto *pending = new Pending{this, uri, {}, {}, std::move(callback), std::move(onProgress)};
 
   std::thread([pending]() {
     // The fetch is in core, shared with the AppKit loader: a URI means the same
     // thing on both, and only the decode below differs.
-    fetchImageBytes(pending->uri, &pending->bytes, &pending->error);
+    fetchImageBytes(pending->uri, &pending->bytes, &pending->error, pending->onProgress);
     g_idle_add_full(G_PRIORITY_DEFAULT, deliver, pending, nullptr);
   }).detach();
 }
@@ -116,6 +140,53 @@ void GtkImageLoader::loadImage(const std::string &uri,
   });
 }
 
+// Decodes `bytes` as an animation and keeps it when it turns out to be one.
+//
+// Through a memory input stream, which is the only entry point gdk-pixbuf
+// offers for animation-from-bytes. It reads synchronously, and on the main
+// thread, for the same reason the texture above is decoded there: what comes
+// out is a GObject whose frames become GdkTextures, and both are only safe on
+// the thread that will use them. The fetch, which is the slow part, already
+// happened on the worker.
+void GtkImageLoader::rememberAnimation(const std::string &uri, GBytes *bytes) {
+  if (animations_.find(uri) != animations_.end()) {
+    return;
+  }
+
+// gdk-pixbuf 2.44 deprecated its whole animation API, with nothing in
+// gdk-pixbuf to replace it: GNOME's direction is glycin, a separate library
+// and a new dependency, and GTK4 itself has no frame source for a GIF at all
+// -- `gtk_image_set_from_file` on one shows a still. So this uses the
+// deprecated API deliberately rather than by accident, and
+// docs/backlog/image.md records what replacing it would take.
+  G_GNUC_BEGIN_IGNORE_DEPRECATIONS
+
+  GInputStream *stream = g_memory_input_stream_new_from_bytes(bytes);
+  GError *error = nullptr;
+  GdkPixbufAnimation *animation =
+      gdk_pixbuf_animation_new_from_stream(stream, nullptr, &error);
+  g_object_unref(stream);
+  if (animation == nullptr) {
+    // Not an error worth reporting: the still decode above already succeeded,
+    // and a format gdk-pixbuf has no loader for is simply not animated.
+    g_clear_error(&error);
+    return;
+  }
+
+  if (gdk_pixbuf_animation_is_static_image(animation) == TRUE) {
+    g_object_unref(animation);
+    return;
+  }
+
+  animations_[uri] = animation;
+  G_GNUC_END_IGNORE_DEPRECATIONS
+}
+
+GdkPixbufAnimation *GtkImageLoader::animation(const std::string &uri) {
+  const auto found = animations_.find(uri);
+  return found == animations_.end() ? nullptr : found->second;
+}
+
 facebook::react::IImageLoader::CacheStatus GtkImageLoader::getCacheStatus(
     const std::string &uri) {
   // Memory or nothing: there is no disk cache here, and saying `Disk` would be

package/native/gtk/GtkImageLoader.h

@@ -30,6 +30,7 @@
 #include <string>
 #include <unordered_map>
 
+#include "ImageBytes.h"
 #include "ImageCache.h"
 
 #include <react/io/IImageLoader.h>
@@ -55,7 +56,32 @@ class GtkImageLoader : public facebook::react::IImageLoader {
   GtkImageLoader(GtkImageLoader &&) = delete;
   GtkImageLoader &operator=(GtkImageLoader &&) = delete;
 
-  void load(const std::string &uri, Callback &&callback);
+  // `onProgress` is optional and is `basalt::ImageProgress`: how much of an
+  // http fetch has arrived, called from the fetching thread. Only an http URI
+  // reports anything; see core/ImageBytes.h.
+  //
+  // Not marshalled to the main thread, unlike the callback above, and that is
+  // the point of it: a Fabric event emitter may be dispatched from any thread,
+  // and a progress tick that had to wait for the main loop would arrive after
+  // the image it is about.
+  void load(const std::string &uri,
+            Callback &&callback,
+            basalt::ImageProgress onProgress = {});
+
+  // The animation behind an animated image, or null.
+  //
+  // Separate from `load` because being animated is a property of the file
+  // rather than of the request: `load` answers with the first frame, which is
+  // what a still <Image> paints and what an animated one starts on, and this
+  // says whether there is more. Both come out of the same decode.
+  //
+  // gdk-pixbuf owns the frames, and offers an iterator with a clock rather than
+  // indexed access, which is why this hands over the animation itself where the
+  // AppKit loader hands over an array of frames. The object is the loader's and
+  // is the same object each time, which is what lets a view tell a re-mount
+  // from a new animation. Good until the next load, since an eviction can take
+  // it away.
+  GdkPixbufAnimation *animation(const std::string &uri);
 
   // --- IImageLoader ----------------------------------------------------------
   //
@@ -77,8 +103,19 @@ class GtkImageLoader : public facebook::react::IImageLoader {
   //
   // Caches a texture and releases whatever the policy dropped.
   void remember(const std::string &uri, GdkTexture *texture);
+  void rememberAnimation(const std::string &uri, GBytes *bytes);
 
   std::unordered_map<std::string, GdkTexture *> cache_;
+  // Only the files that turned out to have more than one frame, so a still
+  // image costs nothing. Keyed by the same URI and dropped by the same
+  // eviction.
+  //
+  // The frames inside are gdk-pixbuf's and are not measured by the cache
+  // policy: there is no way to ask a GdkPixbufAnimation how much it is holding,
+  // and the AppKit side can because it decoded the frames itself. So an
+  // animated image is accounted as its first frame on this host. Recorded in
+  // docs/backlog/image.md rather than guessed at.
+  std::unordered_map<std::string, GdkPixbufAnimation *> animations_;
   // Which URI goes next, and when. The textures are this class's; the decision
   // is shared with the other two hosts. See core/ImageCache.h.
   basalt::ImageCachePolicy policy_;