basalt-appkit 0.0.0-rc5

package/native/appkit/AppKitImageLoader.h

@@ -0,0 +1,80 @@
+// Loading the pixels behind <Image>.
+//
+// React Native's cxx platform does not do this for us. `ImageManager` has a
+// platform variant under `imagemanager/platform/cxx`, and every method in it is
+// a stub that returns an empty `ImageRequest` -- so no `ImageResponse` ever
+// arrives, and `ImageState` never carries anything to render. The platform view
+// is expected to load its own image, which is also what Android does (Fresco,
+// from `ReactImageView`, not from the shadow node).
+//
+// So the mounting manager reads the URI straight off `ImageProps::sources` and
+// asks this to produce a CGImage.
+//
+// Which URIs work is in core/ImageBytes.h, shared with the GTK loader. What is
+// here is the decode and the cache, which is the only part that differs --
+// and one thing that genuinely differs beyond spelling: a CGImage is immutable
+// and thread-safe, so decoding happens on the worker thread. The GTK side has
+// to decode on the main thread, because a GdkTexture is a GObject.
+
+#pragma once
+
+#import <Cocoa/Cocoa.h>
+
+#include <functional>
+#include <string>
+#include <unordered_map>
+
+#include "ImageCache.h"
+
+#include <react/io/IImageLoader.h>
+
+namespace basalt {
+
+// Also React Native's own `IImageLoader`, which is what `Image.getSize` and
+// `Image.prefetch` reach. Upstream's `ImageLoaderModule` takes one and
+// `ReactCxxTurboModuleProvider` never supplies it -- see
+// docs/backlog/upstream.md -- so the host registers the module itself with
+// this as the loader.
+class AppKitImageLoader : public facebook::react::IImageLoader {
+ public:
+  // `image` is null when the load failed, and `error` says why. Always called
+  // on the main thread, possibly synchronously if the image is cached.
+  using Callback = std::function<void(CGImageRef image, const std::string &error)>;
+
+  AppKitImageLoader();
+  ~AppKitImageLoader();
+
+  AppKitImageLoader(const AppKitImageLoader &) = delete;
+  AppKitImageLoader &operator=(const AppKitImageLoader &) = delete;
+  AppKitImageLoader(AppKitImageLoader &&) = delete;
+  AppKitImageLoader &operator=(AppKitImageLoader &&) = delete;
+
+  void load(const std::string &uri, Callback &&callback);
+
+  // --- IImageLoader ----------------------------------------------------------
+  //
+  // The same decode as `load`, reporting the size rather than the pixels. It
+  // goes through the same cache, so `Image.getSize` on something already on
+  // screen answers without touching the disk or the network.
+  void loadImage(const std::string &uri,
+                 const facebook::react::IImageLoaderOnLoadCallback &&onLoad) override;
+
+  facebook::react::IImageLoader::CacheStatus getCacheStatus(const std::string &uri) override;
+
+ private:
+  struct Pending;
+
+  // Decoded images, keyed by URI. CGImages are immutable and shareable, so two
+  // <Image>s with the same source draw the same object.
+  //
+  // Nothing evicts from this yet; see docs/BACKLOG.md.
+  // Caches an image and releases whatever the policy dropped.
+  void remember(const std::string &uri, CGImageRef image);
+
+  std::unordered_map<std::string, CGImageRef> cache_;
+  // Which URI goes next, and when. The images are this class's; the decision
+  // is shared with the other two hosts. See core/ImageCache.h.
+  basalt::ImageCachePolicy policy_;
+};
+
+} // namespace basalt

package/native/appkit/AppKitImageLoader.mm

@@ -0,0 +1,156 @@
+#import "AppKitImageLoader.h"
+
+#include "ImageBytes.h"
+
+#import <ImageIO/ImageIO.h>
+
+#include <thread>
+#include <utility>
+
+namespace basalt {
+
+// Carries one completed load from the worker thread to the main thread.
+struct AppKitImageLoader::Pending {
+  AppKitImageLoader *loader;
+  std::string uri;
+  CGImageRef image;
+  std::string error;
+  Callback callback;
+};
+
+AppKitImageLoader::AppKitImageLoader() = default;
+
+AppKitImageLoader::~AppKitImageLoader() {
+  for (auto &[uri, image] : cache_) {
+    (void)uri;
+    CGImageRelease(image);
+  }
+  cache_.clear();
+}
+
+namespace {
+
+// ImageIO rather than NSImage. An NSImage is a list of representations at
+// different sizes with a resolution attached, and asking one for a CGImage
+// means telling it a size and a context -- so a 160x100 PNG can come back
+// 320x200 on a Retina display, which then measures wrong. CGImageSource hands
+// back exactly what is in the file.
+CGImageRef decode(const std::string &bytes, std::string *error) {
+  if (bytes.empty()) {
+    *error = "no image data";
+    return nullptr;
+  }
+
+  CFDataRef data = CFDataCreate(kCFAllocatorDefault,
+                                reinterpret_cast<const UInt8 *>(bytes.data()),
+                                static_cast<CFIndex>(bytes.size()));
+  if (data == nullptr) {
+    *error = "could not wrap image data";
+    return nullptr;
+  }
+
+  CGImageSourceRef source = CGImageSourceCreateWithData(data, nullptr);
+  CFRelease(data);
+  if (source == nullptr) {
+    *error = "unrecognised image format";
+    return nullptr;
+  }
+
+  // Index 0: an animated GIF and a multi-page TIFF both have more, and drawing
+  // the first frame is the honest thing to do until there is an animator. See
+  // docs/BACKLOG.md.
+  CGImageRef image = CGImageSourceCreateImageAtIndex(source, 0, nullptr);
+  CFRelease(source);
+  if (image == nullptr) {
+    *error = "could not decode image";
+    return nullptr;
+  }
+  return image;
+}
+
+} // namespace
+
+// Caches the image and releases whatever that pushed out. See core/ImageCache.h
+// for the policy; the bytes are this file's to measure, because only Core
+// Graphics knows how big a decoded image is.
+void AppKitImageLoader::remember(const std::string &uri, CGImageRef image) {
+  cache_[uri] = image;
+
+  // Height times the row stride, which is what the decode actually allocated
+  // -- rows are padded, so width times four is an underestimate on some
+  // widths and this is not.
+  const size_t bytes = CGImageGetBytesPerRow(image) * CGImageGetHeight(image);
+
+  for (const std::string &evicted : policy_.insert(uri, bytes)) {
+    const auto it = cache_.find(evicted);
+    if (it != cache_.end()) {
+      CGImageRelease(it->second);
+      cache_.erase(it);
+    }
+  }
+}
+
+void AppKitImageLoader::load(const std::string &uri, Callback &&callback) {
+  if (uri.empty()) {
+    callback(nullptr, "empty source uri");
+    return;
+  }
+
+  if (const auto it = cache_.find(uri); it != cache_.end()) {
+    policy_.noteUse(uri);
+    callback(it->second, {});
+    return;
+  }
+
+  auto *pending = new Pending{this, uri, nullptr, {}, std::move(callback)};
+
+  std::thread([pending]() {
+    std::string bytes;
+    // Both the fetch and the decode run here. A CGImage is immutable and
+    // thread-safe, so unlike the GTK side there is nothing that has to wait for
+    // the main thread except the delivery itself.
+    if (fetchImageBytes(pending->uri, &bytes, &pending->error)) {
+      pending->image = decode(bytes, &pending->error);
+    }
+
+    dispatch_async_f(dispatch_get_main_queue(), pending, [](void *data) {
+      std::unique_ptr<Pending> done{static_cast<Pending *>(data)};
+      if (done->image != nullptr) {
+        // The cache takes the reference the decode produced; the callback
+        // borrows it, and a view that keeps the image retains its own.
+        done->loader->remember(done->uri, done->image);
+      }
+      done->callback(done->image, done->error);
+    });
+  }).detach();
+}
+
+
+void AppKitImageLoader::loadImage(const std::string &uri,
+                                  const facebook::react::IImageLoaderOnLoadCallback &&onLoad) {
+  // Copied because the callback outlives this call: `load` answers on a later
+  // turn of the main queue, and the reference it was handed is gone by then.
+  auto callback = onLoad;
+  load(uri, [callback](CGImageRef image, const std::string &error) {
+    if (image == nullptr) {
+      // The message rather than a size: `Image.getSize` rejects with it, and a
+      // zero-by-zero success would be indistinguishable from a 0x0 image.
+      callback(0.0, 0.0, error.empty() ? "could not load image" : error.c_str());
+      return;
+    }
+    callback(static_cast<double>(CGImageGetWidth(image)),
+             static_cast<double>(CGImageGetHeight(image)),
+             nullptr);
+  });
+}
+
+facebook::react::IImageLoader::CacheStatus AppKitImageLoader::getCacheStatus(
+    const std::string &uri) {
+  // Memory or nothing: there is no disk cache here, and saying `Disk` would be
+  // claiming a persistence this has not got.
+  return cache_.find(uri) != cache_.end()
+      ? facebook::react::IImageLoader::CacheStatus::Memory
+      : facebook::react::IImageLoader::CacheStatus::None;
+}
+
+} // namespace basalt

package/native/appkit/AppKitKeyEvents.h

@@ -0,0 +1,26 @@
+// An NSEvent as a key combination, in the vocabulary core/KeyEvents.h defines.
+//
+// Separate from AppKitFocus because it is a translation and nothing else: no
+// registry, no focus, no decision. The three hosts each need one of these and
+// they share no code, which is exactly why the *names* they translate into are
+// constants in core rather than literals here.
+
+#pragma once
+
+#include "KeyEvents.h"
+
+#include <optional>
+
+#ifdef __OBJC__
+@class NSEvent;
+#endif
+
+namespace basalt {
+
+#ifdef __OBJC__
+// The combination this key press represents, or nothing for a press with no key
+// to speak of -- a bare modifier, or a dead key mid-composition.
+std::optional<KeyCombination> keyCombinationFrom(NSEvent *event);
+#endif
+
+} // namespace basalt

package/native/appkit/AppKitKeyEvents.mm

@@ -0,0 +1,97 @@
+#include "AppKitKeyEvents.h"
+
+#import <AppKit/AppKit.h>
+
+#include <string>
+
+namespace basalt {
+namespace {
+
+// AppKit reports the arrows and the navigation block as characters in the
+// private-use area, which is why these are compared against
+// `charactersIgnoringModifiers` rather than against a key code: a key code is
+// keyboard-layout dependent and these are not.
+const char *specialNameFor(unichar character) {
+  switch (character) {
+  case NSUpArrowFunctionKey:
+    return kKeyArrowUp;
+  case NSDownArrowFunctionKey:
+    return kKeyArrowDown;
+  case NSLeftArrowFunctionKey:
+    return kKeyArrowLeft;
+  case NSRightArrowFunctionKey:
+    return kKeyArrowRight;
+  case NSPageUpFunctionKey:
+    return kKeyPageUp;
+  case NSPageDownFunctionKey:
+    return kKeyPageDown;
+  case NSHomeFunctionKey:
+    return kKeyHome;
+  case NSEndFunctionKey:
+    return kKeyEnd;
+  // Forward delete. The key most keyboards label "delete" is backspace, below.
+  case NSDeleteFunctionKey:
+    return kKeyDelete;
+  case NSCarriageReturnCharacter:
+  case NSEnterCharacter:
+    return kKeyEnter;
+  case NSTabCharacter:
+  // Shift-Tab arrives as its own character rather than as Tab with a modifier.
+  // Reported as Tab with shift set, because that is what a browser reports and
+  // what an app will have bound.
+  case NSBackTabCharacter:
+    return kKeyTab;
+  case 0x1B:
+    return kKeyEscape;
+  case NSDeleteCharacter:
+    return kKeyBackspace;
+  default:
+    return nullptr;
+  }
+}
+
+} // namespace
+
+std::optional<KeyCombination> keyCombinationFrom(NSEvent *event) {
+  if (event == nil) {
+    return std::nullopt;
+  }
+
+  KeyModifiers modifiers;
+  const NSEventModifierFlags flags = event.modifierFlags;
+  modifiers.alt = (flags & NSEventModifierFlagOption) != 0;
+  modifiers.ctrl = (flags & NSEventModifierFlagControl) != 0;
+  // Command is `meta`, as it is in a browser on this platform and in
+  // react-native-macos. An app binding Cmd+Z writes metaKey.
+  modifiers.meta = (flags & NSEventModifierFlagCommand) != 0;
+  modifiers.shift = (flags & NSEventModifierFlagShift) != 0;
+
+  NSString *bare = event.charactersIgnoringModifiers;
+  if (bare.length > 0) {
+    if (const char *special = specialNameFor([bare characterAtIndex:0])) {
+      return KeyCombination{std::string(special), modifiers};
+    }
+  }
+
+  // A character, with its case. `characters` applies Shift, so Shift+A is "A"
+  // and its shift modifier is also set -- both true, as in a browser. It also
+  // applies Option, so Option+A is "å" on a US layout, which is again what a
+  // browser reports and what the person actually typed.
+  //
+  // Not `charactersIgnoringModifiers`, which would report "a" for Shift+A and
+  // make the two indistinguishable to an app that binds by character.
+  NSString *typed = event.characters;
+  if (typed.length == 0) {
+    // A bare modifier, or a dead key part-way through composing. Neither is a
+    // combination and neither should be offered to an app as one.
+    return std::nullopt;
+  }
+  // Control turns a letter into its control character -- Ctrl+A is 0x01 -- which
+  // is not a name anybody binds. The unmodified character is what an app means.
+  if (modifiers.ctrl && bare.length > 0) {
+    typed = bare;
+  }
+  return KeyCombination{std::string(typed.UTF8String), modifiers};
+}
+
+} // namespace basalt