basalt-win32 0.0.0-rc5

package/native/win32/DirectWriteLayout.cpp

@@ -0,0 +1,116 @@
+#include "DirectWriteLayout.h"
+
+#include "FontRegistry.h"
+
+#include <react/renderer/graphics/Color.h>
+
+#include <cmath>
+
+namespace basalt::win32 {
+namespace {
+
+using facebook::react::AttributedString;
+using facebook::react::ParagraphAttributes;
+using facebook::react::TextAttributes;
+
+RnTextAlign toAlign(const TextAttributes &attributes) {
+  if (!attributes.alignment.has_value()) {
+    return RnTextAlign::Left;
+  }
+  switch (*attributes.alignment) {
+    case facebook::react::TextAlignment::Center:
+      return RnTextAlign::Center;
+    case facebook::react::TextAlignment::Right:
+#if BASALT_RN_MINOR >= 87
+    // React Native 0.87 added the writing-direction-relative spellings, and
+    // both other desktops already fold them in here. Left out of this switch,
+    // `textAlign: 'right'` written as `end` fell through to left-aligned --
+    // which clang said out loud, in a warning nobody had recompiled this file
+    // to see.
+    //
+    // Left-to-right only, like the other two: nothing on any of these
+    // platforms resolves a writing direction yet.
+    case facebook::react::TextAlignment::End:
+#endif
+      return RnTextAlign::Right;
+    case facebook::react::TextAlignment::Justified:
+      return RnTextAlign::Justified;
+    case facebook::react::TextAlignment::Natural:
+    case facebook::react::TextAlignment::Left:
+#if BASALT_RN_MINOR >= 87
+    case facebook::react::TextAlignment::Start:
+#endif
+      break;
+  }
+  return RnTextAlign::Left;
+}
+
+// React Native's weights run 100..900 and DirectWrite's do too, but this
+// platform's style struct carries a bool. Anything at semibold or above is
+// bold, which is the same line the GTK side draws.
+bool isBold(const TextAttributes &attributes) {
+  if (!attributes.fontWeight.has_value()) {
+    return false;
+  }
+  return static_cast<int>(*attributes.fontWeight) >= static_cast<int>(facebook::react::FontWeight::Semibold);
+}
+
+} // namespace
+
+RnTextStyle buildTextStyle(const TextAttributes &attributes) {
+  RnTextStyle style;
+
+  if (!attributes.fontFamily.empty()) {
+    // Through the font seam, so a family an app registered at runtime resolves
+    // to whatever it is actually called. An unregistered name comes back
+    // unchanged and DirectWrite's own lookup gets it.
+    style.fontFamily = resolveFontFamily(attributes.fontFamily);
+  }
+
+  // A NaN fontSize is React Native's "unset", and passing it to DirectWrite
+  // produces a layout with no metrics at all rather than an error.
+  if (!std::isnan(attributes.fontSize) && attributes.fontSize > 0) {
+    style.fontSize = static_cast<float>(attributes.fontSize);
+  }
+
+  style.bold = isBold(attributes);
+  style.italic = attributes.fontStyle.has_value() &&
+      *attributes.fontStyle == facebook::react::FontStyle::Italic;
+
+  if (!std::isnan(attributes.lineHeight) && attributes.lineHeight > 0) {
+    style.lineHeight = static_cast<float>(attributes.lineHeight);
+  }
+
+  style.align = toAlign(attributes);
+
+  if (attributes.foregroundColor) {
+    const auto components = facebook::react::colorComponentsFromColor(attributes.foregroundColor);
+    style.color[0] = components.red;
+    style.color[1] = components.green;
+    style.color[2] = components.blue;
+    style.color[3] = components.alpha;
+  }
+
+  return style;
+}
+
+std::shared_ptr<RnWin32TextLayout>
+buildTextLayout(const AttributedString &attributedString,
+                const ParagraphAttributes &paragraphAttributes) {
+  std::vector<RnTextRun> runs;
+  for (const auto &fragment : attributedString.getFragments()) {
+    // An attachment is an inline `<View>`, which occupies space rather than
+    // carrying text. Its string is a placeholder React Native does not intend
+    // to be drawn, so it contributes no run -- which is also why the attachment
+    // rects the layout manager reports are all zero. See docs/BACKLOG.md.
+    if (fragment.isAttachment()) {
+      continue;
+    }
+    runs.push_back(RnTextRun{fragment.string, buildTextStyle(fragment.textAttributes)});
+  }
+
+  return RnWin32TextLayout::createFromRuns(
+      runs, static_cast<int>(paragraphAttributes.maximumNumberOfLines));
+}
+
+} // namespace basalt::win32

package/native/win32/DirectWriteLayout.h

@@ -0,0 +1,36 @@
+// AttributedString -> RnWin32TextLayout, and nothing else.
+//
+// Separate from RnWin32TextLayout.h for the reason that file states: the view
+// layer draws paragraphs and must not gain a React Native dependency to do it.
+// This is the file that does know about React Native, and it is the only place
+// a `TextAttributes` is turned into a `RnTextStyle`.
+//
+// Shared by measurement and painting -- `DirectWriteLayoutManager.cpp` calls it
+// from `TextLayoutManager::measure`, and `Win32MountingManager` calls it when a
+// Paragraph's state arrives. That sharing is the point: if the two built
+// layouts differently, Yoga would allot a box computed one way and the view
+// would paint text laid out another. `docs/DECISIONS.md` makes the same
+// argument for Pango.
+
+#pragma once
+
+#include "RnWin32TextLayout.h"
+
+#include <react/renderer/attributedstring/AttributedString.h>
+#include <react/renderer/attributedstring/ParagraphAttributes.h>
+#include <react/renderer/attributedstring/TextAttributes.h>
+
+#include <memory>
+
+namespace basalt::win32 {
+
+// One fragment's attributes, as this platform understands them. Exposed so the
+// mounting manager can ask the same question about a lone run without building
+// a whole paragraph.
+RnTextStyle buildTextStyle(const facebook::react::TextAttributes &textAttributes);
+
+std::shared_ptr<RnWin32TextLayout>
+buildTextLayout(const facebook::react::AttributedString &attributedString,
+                const facebook::react::ParagraphAttributes &paragraphAttributes);
+
+} // namespace basalt::win32

package/native/win32/DirectWriteLayoutManager.cpp

@@ -0,0 +1,124 @@
+// Replaces React Native's stub TextLayoutManager with one over DirectWrite.
+//
+// React Native's cxx platform ships a header and a stub .cpp that ignores every
+// attribute and returns `layoutConstraints.minimumSize`. The header is already
+// generic, so this project keeps it and supplies only the implementation --
+// `cmake/ReactNativeCore.cmake` removes the stub source from
+// `react_renderer_textlayoutmanager` after `add_subdirectory` so the two do not
+// collide. Same arrangement as Pango's and Core Text's; see
+// `docs/DECISIONS.md`.
+
+#include "DirectWriteLayout.h"
+
+#include "FontRegistry.h"
+
+#include <react/renderer/textlayoutmanager/TextLayoutManager.h>
+
+#include <algorithm>
+#include <cmath>
+#include <mutex>
+#include <unordered_map>
+
+namespace facebook::react {
+namespace {
+
+std::mutex &measurementCacheMutex() {
+  static std::mutex mutex;
+  return mutex;
+}
+
+// Not React Native's own `textMeasureCache_`, which has no way to be emptied.
+//
+// A font registered since a measurement invalidates it: the same string with
+// the same attributes measures differently once its family exists. That is not
+// expressible in the cache key, which React Native defines, so the cache has to
+// be droppable instead -- and without that, a font loaded after first render,
+// which is how `useFonts` and every other loader works, appears to do nothing.
+std::unordered_map<TextMeasureCacheKey, TextMeasurement> &measurementCache() {
+  static std::unordered_map<TextMeasureCacheKey, TextMeasurement> cache;
+  static unsigned long generation = 0;
+  const unsigned long current = basalt::fontGeneration();
+  if (current != generation) {
+    cache.clear();
+    generation = current;
+  }
+  return cache;
+}
+
+} // namespace
+
+TextLayoutManager::TextLayoutManager(const std::shared_ptr<const ContextContainer> &contextContainer)
+    : contextContainer_(contextContainer), textMeasureCache_(kSimpleThreadSafeCacheSizeCap) {}
+
+TextMeasurement TextLayoutManager::measure(const AttributedStringBox &attributedStringBox,
+                                           const ParagraphAttributes &paragraphAttributes,
+                                           const TextLayoutContext &layoutContext,
+                                           const LayoutConstraints &layoutConstraints) const {
+  const auto &attributedString = attributedStringBox.getValue();
+
+  // pointScaleFactor joined the cache key in React Native 0.87. On 0.86 the key
+  // has three fields and naming a fourth is a compile error. Its absence only
+  // makes the cache coarser there, and since nothing below uses the factor,
+  // coarser is harmless.
+  const TextMeasureCacheKey key{
+      .attributedString = attributedString,
+      .paragraphAttributes = paragraphAttributes,
+      .layoutConstraints = layoutConstraints,
+#if BASALT_RN_MINOR >= 87
+      .pointScaleFactor = layoutContext.pointScaleFactor,
+#endif
+  };
+
+#if BASALT_RN_MINOR < 87
+  (void)layoutContext;
+#endif
+
+  {
+    const std::lock_guard<std::mutex> lock(measurementCacheMutex());
+    auto &cache = measurementCache();
+    const auto hit = cache.find(key);
+    if (hit != cache.end()) {
+      return hit->second;
+    }
+  }
+
+  TextMeasurement measured;
+
+  // An infinite maximum width means "do not wrap".
+  const float maxWidth = std::isinf(layoutConstraints.maximumSize.width)
+      ? -1.0f
+      : static_cast<float>(layoutConstraints.maximumSize.width);
+
+  const auto layout = basalt::win32::buildTextLayout(attributedString, paragraphAttributes);
+  const basalt::win32::RnTextSize size =
+      layout == nullptr ? basalt::win32::RnTextSize{} : layout->measure(maxWidth);
+
+  // DirectWrite can report a line slightly wider than the width it was given,
+  // for an unbreakable run. Yoga treats the returned size as final, so clamping
+  // here keeps the paragraph inside the box its parent allotted.
+  measured.size = Size{
+      .width = std::min(static_cast<Float>(size.width), layoutConstraints.maximumSize.width),
+      .height = static_cast<Float>(size.height),
+  };
+
+  // Inline views (`<Text><View/></Text>`) reach here as attachment fragments.
+  // Reporting a zero frame for each keeps the count right, which is what
+  // ParagraphShadowNode iterates over, but they are not positioned -- the same
+  // gap both other desktops have, for the same reason.
+  for (const auto &fragment : attributedString.getFragments()) {
+    if (fragment.isAttachment()) {
+      measured.attachments.push_back(TextMeasurement::Attachment{
+          .frame = {.origin = {.x = 0, .y = 0}, .size = {.width = 0, .height = 0}},
+          .isClipped = false,
+      });
+    }
+  }
+
+  {
+    const std::lock_guard<std::mutex> lock(measurementCacheMutex());
+    measurementCache()[key] = measured;
+  }
+  return measured;
+}
+
+} // namespace facebook::react

package/native/win32/FontRegistryDirectWrite.cpp

@@ -0,0 +1,117 @@
+// Windows' half of core/FontRegistry.h -- the seam phase 17 found by linking.
+//
+// `expo-font` arrives here: an app loads a .ttf at runtime and then names it in
+// a `fontFamily`, so two things have to happen. DirectWrite has to be able to
+// find the file, and `resolveFontFamily` has to map the name the app used onto
+// whatever the font actually calls itself.
+//
+// The first is `AddFontResourceExW` with FR_PRIVATE, which adds the file to the
+// process's own font set. On Windows 10 1809 and later DirectWrite's system
+// font collection picks those up, which is why this is a two-line
+// implementation rather than an IDWriteFontSetBuilder and a custom collection.
+// That is also the thing about it most worth distrusting -- see the note at the
+// bottom.
+
+#include "FontRegistry.h"
+
+#include "Win32Strings.h"
+
+#include <windows.h>
+
+#include <atomic>
+#include <mutex>
+#include <string>
+#include <unordered_map>
+
+namespace basalt {
+
+using win32::widen;
+namespace {
+
+struct Registry {
+  std::mutex mutex;
+  // The name the app asked for, against the path it gave. Kept because
+  // `resolveFontFamily` has to answer for a name DirectWrite may not know by
+  // that spelling.
+  std::unordered_map<std::string, std::string> fonts;
+};
+
+Registry &registry() {
+  static Registry instance;
+  return instance;
+}
+
+// Bumped on every successful registration. The text layer reads it to know its
+// cached layouts may be stale: a paragraph measured before a font arrived was
+// measured with a fallback, and would keep those metrics forever otherwise.
+std::atomic<unsigned long> generation{0};
+
+} // namespace
+
+bool registerFont(const std::string &name, const std::string &path) {
+  if (name.empty() || path.empty()) {
+    return false;
+  }
+
+  const std::wstring widePath = widen(path);
+  // FR_PRIVATE: visible to this process only. A font an app loaded is not
+  // something to install system-wide, and doing so would need elevation.
+  if (AddFontResourceExW(widePath.c_str(), FR_PRIVATE, nullptr) == 0) {
+    return false;
+  }
+
+  {
+    std::lock_guard<std::mutex> lock(registry().mutex);
+    registry().fonts[name] = path;
+  }
+  generation.fetch_add(1, std::memory_order_relaxed);
+  return true;
+}
+
+std::string resolveFontFamily(const std::string &name) {
+  std::lock_guard<std::mutex> lock(registry().mutex);
+  const auto it = registry().fonts.find(name);
+  if (it == registry().fonts.end()) {
+    // Not one of ours: hand the name back and let DirectWrite's own lookup have
+    // it. That is what makes "Segoe UI" work without being registered.
+    return name;
+  }
+  // The name the app used is the name it will ask for. Windows matches on the
+  // font's *family* name rather than its filename, and those agree for most
+  // fonts an app ships; where they do not, this returns the wrong one. Reading
+  // the family out of the file with IDWriteFontFile would be exact and is the
+  // fix if this ever misses.
+  return name;
+}
+
+unsigned long fontGeneration() {
+  return generation.load(std::memory_order_relaxed);
+}
+
+bool isFontRegistered(const std::string &name) {
+  std::lock_guard<std::mutex> lock(registry().mutex);
+  return registry().fonts.count(name) != 0;
+}
+
+std::string registeredFontNamesJoined(char separator) {
+  std::lock_guard<std::mutex> lock(registry().mutex);
+  std::string joined;
+  for (const auto &[name, path] : registry().fonts) {
+    (void)path;
+    if (!joined.empty()) {
+      joined += separator;
+    }
+    joined += name;
+  }
+  return joined;
+}
+
+// Worth distrusting, and recorded in docs/BACKLOG.md alongside the same doubt
+// about macOS: no font has been loaded at runtime and then rendered, on any of
+// the three desktops. AddFontResourceEx is documented to make a font available
+// to GDI; that DirectWrite's system collection also sees it is true on current
+// Windows and is the sort of thing that is true until it is not. The test that
+// would settle it is an app calling expo-font and then drawing in that family,
+// which needs a host.
+
+} // namespace basalt