basalt-win32 0.0.0-rc5

package/native/win32/RnWin32Image.h

@@ -0,0 +1,93 @@
+// The decoded pixels of an <Image>, and how they fill a frame.
+//
+// Device-independent on purpose. Direct2D's own ID2D1Bitmap belongs to the
+// render target that made it, so holding one would tie an image to a window and
+// make it useless to the offscreen snapshot -- and would have to be rebuilt
+// whenever a device is lost. A WIC bitmap is the Windows equivalent of GTK's
+// GdkTexture and macOS's CGImage: decoded once, owned by nobody in particular,
+// converted to a device bitmap at paint time and cached there.
+//
+// Only the decode and the draw are here. Fetching the bytes -- file, data URI,
+// http -- is `core/ImageBytes.cpp` in the shared half, because a URI means the
+// same thing on every desktop; see `docs/DECISIONS.md`.
+
+#pragma once
+
+#include <cstdint>
+#include <memory>
+#include <string>
+
+struct ID2D1RenderTarget;
+struct IWICBitmap;
+struct ID2D1Bitmap;
+
+namespace basalt::win32 {
+
+// How an image fills its frame. Mirrors React Native's ImageResizeMode, minus
+// Repeat, which needs a tiled draw rather than one image draw.
+enum class RnImageFit {
+  Cover,
+  Contain,
+  Stretch,
+  Center,
+  // Tiled from the top left at the image's own size, which is what CSS
+  // `repeat` and React Native's `resizeMode: 'repeat'` mean.
+  Repeat,
+};
+
+const char *imageFitName(RnImageFit fit);
+
+class RnWin32Image {
+ public:
+  // Straight from pixels, premultiplied BGRA with a stride of width * 4. What
+  // the tests use, and what a decoder that is not WIC would hand over.
+  static std::shared_ptr<RnWin32Image>
+  fromPixels(unsigned width, unsigned height, const uint8_t *bgra);
+
+  // Decodes PNG, JPEG, GIF, BMP, TIFF and anything else WIC has a codec for.
+  // Null if the bytes are not an image WIC understands.
+  static std::shared_ptr<RnWin32Image> fromEncodedBytes(const uint8_t *data, size_t size);
+
+  ~RnWin32Image();
+
+  RnWin32Image(const RnWin32Image &) = delete;
+  RnWin32Image &operator=(const RnWin32Image &) = delete;
+
+  unsigned width() const { return width_; }
+  unsigned height() const { return height_; }
+
+  // Draws into a box `boxWidth` by `boxHeight` at the target's current origin,
+  // scaled and positioned by `fit`.
+  // `tint`, when given, recolours the image keeping its alpha -- one silhouette
+  // asset drawn in any colour, which is what `tintColor` is for. Four floats,
+  // red green blue alpha, which is what the caller already holds.
+  //
+  // Not a `D2D1_COLOR_F`, though that is what it becomes: this header declares
+  // its Direct2D types rather than including d2d1.h, and that one is a typedef
+  // of a typedef -- `D3DCOLORVALUE`, itself `_D3DCOLORVALUE` -- so it cannot be
+  // forward-declared at all. Declaring `struct D2D_COLOR_F` instead defines a
+  // *different* type of that name and every later include of d2d1.h fails on
+  // the redefinition, which is exactly what it did. Floats cannot collide with
+  // anything, and the colour is built where d2d1.h is already in scope.
+  void draw(ID2D1RenderTarget *target,
+            float boxWidth,
+            float boxHeight,
+            RnImageFit fit,
+            const float *tint = nullptr) const;
+
+ private:
+  RnWin32Image() = default;
+
+  IWICBitmap *bitmap_ = nullptr;
+  unsigned width_ = 0;
+  unsigned height_ = 0;
+
+  // The device bitmap for the target that last drew this image. An <Image> in a
+  // list is drawn into the same target every frame, so this converts once; a
+  // second target -- the snapshot -- replaces it rather than growing a map,
+  // because nothing here draws into two targets in the same frame.
+  mutable ID2D1Bitmap *deviceBitmap_ = nullptr;
+  mutable ID2D1RenderTarget *deviceTarget_ = nullptr;
+};
+
+} // namespace basalt::win32

package/native/win32/RnWin32TextLayout.cpp

@@ -0,0 +1,310 @@
+#include "RnWin32TextLayout.h"
+
+#include "Win32Strings.h"
+
+#include <windows.h>
+
+#include <d2d1.h>
+#include <dwrite.h>
+#include <wrl/client.h>
+
+#include <algorithm>
+#include <vector>
+
+using Microsoft::WRL::ComPtr;
+
+namespace basalt::win32 {
+namespace {
+
+// Whether a run needs a brush of its own. Exact rather than tolerant: these
+// numbers come from the same ColorComponents on both sides of the comparison,
+// so anything but equality would be inventing a tolerance to hide a bug.
+bool sameColour(const float a[4], const float b[4]) {
+  return a[0] == b[0] && a[1] == b[1] && a[2] == b[2] && a[3] == b[3];
+}
+
+// One shared DirectWrite factory for the process.
+//
+// DWRITE_FACTORY_TYPE_SHARED rather than ISOLATED: the shared factory caches
+// font data across everything in the process and is documented thread-safe,
+// which is what lets measurement happen on Fabric's layout thread and painting
+// on the UI thread with no lock between them. The GTK side cannot do this --
+// see the header.
+IDWriteFactory *dwriteFactory() {
+  static IDWriteFactory *factory = [] {
+    IDWriteFactory *created = nullptr;
+    DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED,
+                        __uuidof(IDWriteFactory),
+                        reinterpret_cast<IUnknown **>(&created));
+    return created;
+  }();
+  return factory;
+}
+
+DWRITE_TEXT_ALIGNMENT toDWriteAlignment(RnTextAlign align) {
+  switch (align) {
+    case RnTextAlign::Center:
+      return DWRITE_TEXT_ALIGNMENT_CENTER;
+    case RnTextAlign::Right:
+      return DWRITE_TEXT_ALIGNMENT_TRAILING;
+    case RnTextAlign::Justified:
+      return DWRITE_TEXT_ALIGNMENT_JUSTIFIED;
+    case RnTextAlign::Left:
+      break;
+  }
+  return DWRITE_TEXT_ALIGNMENT_LEADING;
+}
+
+// What "unconstrained" means to DirectWrite. It has no notion of an infinite
+// width and will happily produce NaN metrics from one, so this is a width no
+// paragraph reaches rather than FLT_MAX.
+constexpr float kUnconstrained = 1.0e6f;
+
+} // namespace
+
+std::shared_ptr<RnWin32TextLayout>
+RnWin32TextLayout::create(std::string utf8Text, const RnTextStyle &style, int maximumNumberOfLines) {
+  IDWriteFactory *factory = dwriteFactory();
+  if (factory == nullptr) {
+    return nullptr;
+  }
+
+  const std::wstring family = widen(style.fontFamily);
+
+  IDWriteTextFormat *format = nullptr;
+  const HRESULT hr = factory->CreateTextFormat(
+      family.empty() ? L"Segoe UI" : family.c_str(),
+      nullptr, // the system font collection
+      style.bold ? DWRITE_FONT_WEIGHT_BOLD : DWRITE_FONT_WEIGHT_NORMAL,
+      style.italic ? DWRITE_FONT_STYLE_ITALIC : DWRITE_FONT_STYLE_NORMAL,
+      DWRITE_FONT_STRETCH_NORMAL,
+      // In DIPs at 96 dpi, which is React Native's density-independent pixel
+      // exactly. Nothing here multiplies by a scale factor, and nothing should:
+      // the render target carries the display scale, the same division of
+      // labour `docs/DECISIONS.md` records for Pango's absolute sizes.
+      style.fontSize,
+      L"",
+      &format);
+  if (FAILED(hr) || format == nullptr) {
+    return nullptr;
+  }
+
+  format->SetTextAlignment(toDWriteAlignment(style.align));
+  format->SetParagraphAlignment(DWRITE_PARAGRAPH_ALIGNMENT_NEAR);
+  format->SetWordWrapping(DWRITE_WORD_WRAPPING_WRAP);
+  if (style.lineHeight > 0.0f) {
+    // Baseline at 80% of the line box is DirectWrite's own recommendation for
+    // uniform spacing, and it is what an unset baseline would have produced.
+    format->SetLineSpacing(
+        DWRITE_LINE_SPACING_METHOD_UNIFORM, style.lineHeight, style.lineHeight * 0.8f);
+  }
+
+  auto layout = std::shared_ptr<RnWin32TextLayout>(new RnWin32TextLayout());
+  layout->utf8_ = std::move(utf8Text);
+  layout->utf16_ = widen(layout->utf8_);
+  layout->style_ = style;
+  layout->maximumNumberOfLines_ = maximumNumberOfLines > 0 ? maximumNumberOfLines : 0;
+  layout->format_ = format;
+  return layout;
+}
+
+std::shared_ptr<RnWin32TextLayout>
+RnWin32TextLayout::createFromRuns(const std::vector<RnTextRun> &runs, int maximumNumberOfLines) {
+  if (runs.empty()) {
+    return create(std::string{}, RnTextStyle{}, maximumNumberOfLines);
+  }
+
+  // The first run's style is the paragraph's: alignment and line spacing belong
+  // to the whole thing rather than to a span, and React Native applies them
+  // that way too.
+  std::string joined;
+  for (const auto &run : runs) {
+    joined += run.text;
+  }
+
+  auto layout = create(joined, runs.front().style, maximumNumberOfLines);
+  if (layout == nullptr) {
+    return nullptr;
+  }
+
+  // One style needs no ranges, and skipping them keeps the common case -- a
+  // plain <Text> -- free of per-range work.
+  if (runs.size() == 1) {
+    return layout;
+  }
+
+  // Ranges are counted in UTF-16 code units, not bytes and not code points, so
+  // each run's extent has to be measured after conversion. Getting this wrong
+  // shifts every style after the first emoji.
+  unsigned start = 0;
+  for (const auto &run : runs) {
+    const unsigned length = static_cast<unsigned>(widen(run.text).size());
+    layout->runs_.push_back(ResolvedRun{start, length, run.style});
+    start += length;
+  }
+  return layout;
+}
+
+RnWin32TextLayout::~RnWin32TextLayout() {
+  if (format_ != nullptr) {
+    format_->Release();
+    format_ = nullptr;
+  }
+}
+
+IDWriteTextLayout *RnWin32TextLayout::buildLayout(float maxWidth, float maxHeight) const {
+  IDWriteFactory *factory = dwriteFactory();
+  if (factory == nullptr || format_ == nullptr) {
+    return nullptr;
+  }
+
+  const float width = maxWidth < 0.0f ? kUnconstrained : maxWidth;
+  const float height = maxHeight < 0.0f ? kUnconstrained : maxHeight;
+
+  IDWriteTextLayout *layout = nullptr;
+  const HRESULT hr = factory->CreateTextLayout(
+      utf16_.c_str(), static_cast<UINT32>(utf16_.size()), format_, width, height, &layout);
+  if (FAILED(hr)) {
+    return nullptr;
+  }
+
+  // Per-span styling, applied here rather than at creation so that measurement
+  // and painting see exactly the same runs -- which is the whole reason this
+  // function exists.
+  for (const auto &run : runs_) {
+    const DWRITE_TEXT_RANGE range{run.start, run.length};
+    const std::wstring family = widen(run.style.fontFamily);
+    if (!family.empty()) {
+      layout->SetFontFamilyName(family.c_str(), range);
+    }
+    layout->SetFontSize(run.style.fontSize, range);
+    layout->SetFontWeight(
+        run.style.bold ? DWRITE_FONT_WEIGHT_BOLD : DWRITE_FONT_WEIGHT_NORMAL, range);
+    layout->SetFontStyle(
+        run.style.italic ? DWRITE_FONT_STYLE_ITALIC : DWRITE_FONT_STYLE_NORMAL, range);
+  }
+  return layout;
+}
+
+float RnWin32TextLayout::applyLineLimit(IDWriteTextLayout *layout) const {
+  if (layout == nullptr || maximumNumberOfLines_ <= 0) {
+    return -1.0f;
+  }
+
+  UINT32 lineCount = 0;
+  // The documented two-call form: the first is expected to fail with
+  // E_NOT_SUFFICIENT_BUFFER and to fill in the count.
+  layout->GetLineMetrics(nullptr, 0, &lineCount);
+  if (lineCount == 0) {
+    return -1.0f;
+  }
+
+  std::vector<DWRITE_LINE_METRICS> lines(lineCount);
+  if (FAILED(layout->GetLineMetrics(lines.data(), lineCount, &lineCount))) {
+    return -1.0f;
+  }
+
+  const UINT32 limit = static_cast<UINT32>(maximumNumberOfLines_);
+  if (lineCount <= limit) {
+    // A limit the paragraph already fits inside is not a truncation, and must
+    // not become one. This is the shape of the trap `docs/DECISIONS.md` records
+    // Pango springing: there, setting the *default* ellipsize mode with no
+    // height collapsed every wrapping paragraph to a single line. DirectWrite
+    // will not trim without a height, so declining to set one here is what
+    // makes the same default safe.
+    return -1.0f;
+  }
+
+  float limitHeight = 0.0f;
+  for (UINT32 i = 0; i < limit; i++) {
+    limitHeight += lines[i].height;
+  }
+
+  layout->SetMaxHeight(limitHeight);
+
+  // An ellipsis on the last line that fits, which is React Native's default
+  // `ellipsizeMode: 'tail'`.
+  ComPtr<IDWriteInlineObject> ellipsis;
+  if (SUCCEEDED(dwriteFactory()->CreateEllipsisTrimmingSign(layout, ellipsis.GetAddressOf()))) {
+    DWRITE_TRIMMING trimming{};
+    trimming.granularity = DWRITE_TRIMMING_GRANULARITY_CHARACTER;
+    layout->SetTrimming(&trimming, ellipsis.Get());
+  }
+  return limitHeight;
+}
+
+RnTextSize RnWin32TextLayout::measure(float maxWidth) const {
+  ComPtr<IDWriteTextLayout> layout;
+  layout.Attach(buildLayout(maxWidth, -1.0f));
+  if (!layout) {
+    return {};
+  }
+
+  const float limitHeight = applyLineLimit(layout.Get());
+
+  DWRITE_TEXT_METRICS metrics{};
+  if (FAILED(layout->GetMetrics(&metrics))) {
+    return {};
+  }
+
+  // `width` rather than `widthIncludingTrailingWhitespace`, so a trailing space
+  // does not widen the box -- which is what every other platform reports and
+  // what makes empty text measure to zero.
+  RnTextSize size{metrics.width, metrics.height};
+  if (limitHeight >= 0.0f) {
+    size.height = std::min(size.height, limitHeight);
+  }
+  return size;
+}
+
+void RnWin32TextLayout::draw(ID2D1RenderTarget *target, float width, float height) const {
+  if (target == nullptr) {
+    return;
+  }
+
+  ComPtr<IDWriteTextLayout> layout;
+  layout.Attach(buildLayout(width, height));
+  if (!layout) {
+    return;
+  }
+  applyLineLimit(layout.Get());
+
+  ComPtr<ID2D1SolidColorBrush> brush;
+  const D2D1_COLOR_F colour =
+      D2D1::ColorF(style_.color[0], style_.color[1], style_.color[2], style_.color[3]);
+  if (FAILED(target->CreateSolidColorBrush(colour, brush.GetAddressOf()))) {
+    return;
+  }
+
+  // Per-run colour, which DirectWrite carries as a *drawing effect* rather than
+  // as a range attribute like family or weight. That sounds like it needs a
+  // custom IDWriteTextRenderer, and it does for anything else you might attach
+  // -- but Direct2D's own renderer has one special case, and this is it: a
+  // drawing effect that is an ID2D1Brush is used to paint that range.
+  //
+  // So `Hello <Text style={{color:'red'}}>world</Text>` renders in two colours
+  // here as it does on the other two desktops, without this file learning what
+  // a glyph run is.
+  //
+  // The brushes have to outlive DrawTextLayout, which is why they are held
+  // rather than created and dropped in the loop.
+  std::vector<ComPtr<ID2D1SolidColorBrush>> runBrushes;
+  for (const ResolvedRun &run : runs_) {
+    if (run.length == 0 || sameColour(run.style.color, style_.color)) {
+      continue;
+    }
+    ComPtr<ID2D1SolidColorBrush> runBrush;
+    const D2D1_COLOR_F runColour = D2D1::ColorF(
+        run.style.color[0], run.style.color[1], run.style.color[2], run.style.color[3]);
+    if (FAILED(target->CreateSolidColorBrush(runColour, runBrush.GetAddressOf()))) {
+      continue;
+    }
+    layout->SetDrawingEffect(runBrush.Get(), DWRITE_TEXT_RANGE{run.start, run.length});
+    runBrushes.push_back(std::move(runBrush));
+  }
+
+  target->DrawTextLayout(
+      D2D1::Point2F(0.0f, 0.0f), layout.Get(), brush.Get(), D2D1_DRAW_TEXT_OPTIONS_NONE);
+}
+
+} // namespace basalt::win32

package/native/win32/RnWin32TextLayout.h

@@ -0,0 +1,160 @@
+// A laid-out paragraph, and nothing that knows what React Native is.
+//
+// Deliberately separate from whatever turns an `AttributedString` into one of
+// these, for the same reason `appkit/RnTextLayout.h` is separate from
+// `CoreTextLayout.h`: the view layer draws paragraphs and must not gain a React
+// Native dependency to do it. `basalt_win32_view` builds and is tested on a
+// Windows box with nothing but a compiler and the SDK, and that is worth
+// keeping -- it is the whole reason there is a test suite on this platform
+// before there is a host.
+//
+// One object serves measurement and painting. That is not tidiness: if the two
+// built layouts differently -- a different default font, a different wrap mode
+// -- Yoga would allot a box computed one way and the view would paint text laid
+// out another, and the result is clipped or overlapping text that looks like a
+// rendering bug rather than a measurement one. The GTK side makes the same
+// argument in `docs/DECISIONS.md`.
+//
+// Unlike Pango, DirectWrite needs no mutex around any of this. Pango's font map
+// is not documented as reentrant, so GTK serialises every measurement on one
+// lock and hides the cost behind a cache; a DWRITE_FACTORY_TYPE_SHARED factory
+// is documented thread-safe, and this builds a fresh IDWriteTextLayout per call
+// rather than mutating a held one. Fabric's layout thread and the UI thread can
+// therefore measure at the same time, which on GTK they cannot.
+
+#pragma once
+
+#include <memory>
+#include <vector>
+#include <string>
+
+// Forward-declared rather than included, so a translation unit that only builds
+// or measures a paragraph does not pull in <d2d1.h> and <dwrite.h> and
+// windows.h behind them. The tests do exactly that.
+struct ID2D1RenderTarget;
+struct IDWriteTextFormat;
+struct IDWriteTextLayout;
+
+namespace basalt::win32 {
+
+enum class RnTextAlign {
+  Left,
+  Center,
+  Right,
+  Justified,
+};
+
+// The attributes this platform honours. React Native has many more; each one
+// added here is a line in `DirectWriteLayout`, which is the file that will
+// translate an AttributedString once there is a mounting manager to deliver
+// one.
+struct RnTextStyle {
+  std::string fontFamily = "Segoe UI";
+  float fontSize = 14.0f;
+  bool bold = false;
+  bool italic = false;
+  // 0 means the font's own line spacing, which is what React Native means by an
+  // unset lineHeight.
+  float lineHeight = 0.0f;
+  RnTextAlign align = RnTextAlign::Left;
+  float color[4] = {0.0f, 0.0f, 0.0f, 1.0f};
+};
+
+struct RnTextSize {
+  float width = 0.0f;
+  float height = 0.0f;
+};
+
+// One styled span of a paragraph.
+//
+// React Native's `<Text>` is not one string with one style: a
+// ParagraphShadowNode folds its whole subtree into an AttributedString of
+// fragments, each with its own font, size and weight. A layout built from only
+// the first fragment's style renders `Hello <b>world</b>` entirely unbold,
+// which measures wrong as well as looking wrong.
+struct RnTextRun {
+  std::string text;
+  RnTextStyle style;
+};
+
+class RnWin32TextLayout {
+ public:
+  // `maximumNumberOfLines` of 0 means no limit, matching
+  // ParagraphAttributes::maximumNumberOfLines. Returns null if DirectWrite
+  // could not produce a text format, which in practice means the process has no
+  // DirectWrite at all.
+  static std::shared_ptr<RnWin32TextLayout>
+  create(std::string utf8Text, const RnTextStyle &style, int maximumNumberOfLines);
+
+  // The same thing for a paragraph of differently styled spans. The first run's
+  // style sets the paragraph defaults -- alignment and line height, which
+  // DirectWrite has no per-range form of -- and each run's font family, size,
+  // weight, slant and colour are applied over its own character range.
+  //
+  // Colour is the odd one, and `draw` is where it happens: DirectWrite carries
+  // it as a drawing effect rather than as a range attribute, and a drawing
+  // effect is only meaningful to whoever renders the layout.
+  static std::shared_ptr<RnWin32TextLayout>
+  createFromRuns(const std::vector<RnTextRun> &runs, int maximumNumberOfLines);
+
+  ~RnWin32TextLayout();
+
+  RnWin32TextLayout(const RnWin32TextLayout &) = delete;
+  RnWin32TextLayout &operator=(const RnWin32TextLayout &) = delete;
+
+  // The original UTF-8, for `describeTree`. Kept alongside the UTF-16 copy
+  // DirectWrite needs so that the cross-host dump does not depend on a
+  // conversion round-tripping.
+  const std::string &text() const { return utf8_; }
+
+  const RnTextStyle &style() const { return style_; }
+  int maximumNumberOfLines() const { return maximumNumberOfLines_; }
+
+  // The size this paragraph needs at `maxWidth`. Pass a negative width for
+  // unconstrained. In React Native's density-independent pixels, like every
+  // other coordinate here: DirectWrite measures in DIPs at 96 dpi and nothing
+  // multiplies by a scale factor, which is what keeps a `fontSize` of 16 the
+  // same sixteen units it is on the other two desktops.
+  RnTextSize measure(float maxWidth) const;
+
+  // Draws at the target's current origin, into a box `width` by `height`.
+  void draw(ID2D1RenderTarget *target, float width, float height) const;
+
+ private:
+  RnWin32TextLayout() = default;
+
+  // The one place a layout is configured. Both `measure` and `draw` go through
+  // it, which is what makes the size Yoga is told the size the text is painted
+  // at.
+  //
+  // Returns a reference the caller owns and must release; the two callers do it
+  // with a ComPtr. A fresh layout per call rather than one held and mutated,
+  // because `SetMaxWidth` on a shared layout is exactly the race that a
+  // thread-safe factory would otherwise have saved us from.
+  IDWriteTextLayout *buildLayout(float maxWidth, float maxHeight) const;
+
+  // Applies `maximumNumberOfLines` to a built layout, and reports the height it
+  // is now limited to, or a negative number for "no limit applied". Separate
+  // because DirectWrite has no line-count property: the limit has to be turned
+  // into a height by adding up the line metrics, which means the layout must
+  // already exist.
+  float applyLineLimit(IDWriteTextLayout *layout) const;
+
+  // A styled span, resolved to UTF-16 character positions, which is what
+  // DirectWrite's ranges are counted in. Empty for a single-style paragraph,
+  // where the format alone says everything.
+  struct ResolvedRun {
+    unsigned start = 0;
+    unsigned length = 0;
+    RnTextStyle style;
+  };
+
+  std::string utf8_;
+  std::wstring utf16_;
+  RnTextStyle style_;
+  std::vector<ResolvedRun> runs_;
+  int maximumNumberOfLines_ = 0;
+  IDWriteTextFormat *format_ = nullptr;
+};
+
+} // namespace basalt::win32