basalt-win32 0.0.0-rc5

package/native/win32/RnWin32Accessible.cpp

@@ -0,0 +1,258 @@
+#include "RnWin32Accessible.h"
+
+#include "Win32Strings.h"
+
+#include <windows.h>
+
+// WIN32_LEAN_AND_MEAN keeps combaseapi.h out of windows.h, and that is where the
+// `interface` macro lives -- without it UIAutomationCore.h fails on its own
+// first typedef, which reads as a broken SDK rather than a missing include.
+#include <objbase.h>
+
+#include <uiautomation.h>
+
+#include <atomic>
+#include <unordered_map>
+
+namespace basalt::win32 {
+namespace {
+
+// React Native's role vocabulary, mapped onto UIA control types. The names are
+// exactly the ones `GtkMountingManager.cpp` accepts, in the same order, because
+// a role this platform silently ignores and GTK honours is a difference no test
+// comparing two trees would catch -- both print React Native's own string.
+//
+// Three of them are approximations UIA forces, and they are worth naming rather
+// than leaving to be rediscovered. UIA has no switch, so a switch is a checkbox
+// with a toggle state, which is what Narrator reads sensibly. It has no heading
+// control type either -- headings are a *property*, UIA_HeadingLevelPropertyId,
+// on a text element -- so "header" is text. And "alert" is not a control type
+// at all in UIA; it is an event, so the nearest honest resting place is a group
+// until there is a live-region implementation to raise it from.
+const std::unordered_map<std::string, long> &roleTable() {
+  static const std::unordered_map<std::string, long> kRoles = {
+      {"button", UIA_ButtonControlTypeId},
+      {"togglebutton", UIA_ButtonControlTypeId},
+      {"link", UIA_HyperlinkControlTypeId},
+      {"search", UIA_EditControlTypeId},
+      {"image", UIA_ImageControlTypeId},
+      {"imagebutton", UIA_ButtonControlTypeId},
+      {"text", UIA_TextControlTypeId},
+      {"header", UIA_TextControlTypeId},
+      {"adjustable", UIA_SliderControlTypeId},
+      {"alert", UIA_GroupControlTypeId},
+      {"checkbox", UIA_CheckBoxControlTypeId},
+      {"combobox", UIA_ComboBoxControlTypeId},
+      {"menu", UIA_MenuControlTypeId},
+      {"menubar", UIA_MenuBarControlTypeId},
+      {"menuitem", UIA_MenuItemControlTypeId},
+      {"progressbar", UIA_ProgressBarControlTypeId},
+      {"radio", UIA_RadioButtonControlTypeId},
+      {"radiogroup", UIA_GroupControlTypeId},
+      {"scrollbar", UIA_ScrollBarControlTypeId},
+      {"spinbutton", UIA_SpinnerControlTypeId},
+      {"switch", UIA_CheckBoxControlTypeId},
+      {"tab", UIA_TabItemControlTypeId},
+      {"tablist", UIA_TabControlTypeId},
+      {"list", UIA_ListControlTypeId},
+      {"grid", UIA_DataGridControlTypeId},
+      {"toolbar", UIA_ToolBarControlTypeId},
+      {"tooltip", UIA_ToolTipControlTypeId},
+  };
+  return kRoles;
+}
+
+BSTR toBstr(const std::string &text) {
+  const std::wstring wide = widen(text);
+  return SysAllocStringLen(wide.c_str(), static_cast<UINT>(wide.size()));
+}
+
+// The property half of a UIA provider.
+//
+// ProviderOptions_ServerSideProvider because this lives in the process that
+// owns the UI, which is the only arrangement that makes sense for a host that
+// draws its own views.
+class AccessibleProvider final : public IRawElementProviderSimple {
+ public:
+  explicit AccessibleProvider(const RnAccessibleInfo &info) : info_(info) {}
+
+  // --- IUnknown ---
+
+  ULONG STDMETHODCALLTYPE AddRef() override { return ++references_; }
+
+  ULONG STDMETHODCALLTYPE Release() override {
+    const ULONG remaining = --references_;
+    if (remaining == 0) {
+      delete this;
+    }
+    return remaining;
+  }
+
+  HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void **object) override {
+    if (object == nullptr) {
+      return E_INVALIDARG;
+    }
+    if (riid == __uuidof(IUnknown) || riid == __uuidof(IRawElementProviderSimple)) {
+      *object = static_cast<IRawElementProviderSimple *>(this);
+      AddRef();
+      return S_OK;
+    }
+    *object = nullptr;
+    return E_NOINTERFACE;
+  }
+
+  // --- IRawElementProviderSimple ---
+
+  HRESULT STDMETHODCALLTYPE get_ProviderOptions(ProviderOptions *options) override {
+    if (options == nullptr) {
+      return E_INVALIDARG;
+    }
+    *options = ProviderOptions_ServerSideProvider;
+    return S_OK;
+  }
+
+  // The control patterns -- Toggle, SelectionItem, ExpandCollapse, Invoke --
+  // land with the host, because a pattern that reports a state but cannot be
+  // driven is worse than none: it tells a screen reader the control can be
+  // operated and then does nothing. The *states* are answered as properties
+  // below, which is read-only and honest.
+  HRESULT STDMETHODCALLTYPE GetPatternProvider(PATTERNID, IUnknown **provider) override {
+    if (provider == nullptr) {
+      return E_INVALIDARG;
+    }
+    *provider = nullptr;
+    return S_OK;
+  }
+
+  HRESULT STDMETHODCALLTYPE GetPropertyValue(PROPERTYID property, VARIANT *value) override {
+    if (value == nullptr) {
+      return E_INVALIDARG;
+    }
+    VariantInit(value);
+
+    switch (property) {
+      case UIA_ControlTypePropertyId:
+        value->vt = VT_I4;
+        value->lVal = controlTypeForRole(info_.role);
+        return S_OK;
+
+      case UIA_NamePropertyId:
+        if (!info_.label.empty()) {
+          value->vt = VT_BSTR;
+          value->bstrVal = toBstr(info_.label);
+        }
+        return S_OK;
+
+      case UIA_HelpTextPropertyId:
+        // React Native's `accessibilityHint` is "what happens if you do this",
+        // which is what UIA calls help text. AppKit puts it in the
+        // accessibility description and GTK in the description property; all
+        // three are the same idea under three names.
+        if (!info_.hint.empty()) {
+          value->vt = VT_BSTR;
+          value->bstrVal = toBstr(info_.hint);
+        }
+        return S_OK;
+
+      case UIA_IsEnabledPropertyId:
+        // Unset means enabled, which is UIA's default and React Native's.
+        value->vt = VT_BOOL;
+        value->boolVal =
+            info_.state.disabled == RnAccessibleFlag::True ? VARIANT_FALSE : VARIANT_TRUE;
+        return S_OK;
+
+      case UIA_ToggleToggleStatePropertyId:
+        // The property mirror of the Toggle pattern, so the state is reportable
+        // before the pattern exists. Left empty when unset, because
+        // ToggleState_Off is a claim that this is an unchecked checkbox.
+        if (info_.state.checked != RnAccessibleFlag::Unset) {
+          value->vt = VT_I4;
+          value->lVal = info_.state.checked == RnAccessibleFlag::True ? ToggleState_On
+                                                                     : ToggleState_Off;
+        }
+        return S_OK;
+
+      case UIA_SelectionItemIsSelectedPropertyId:
+        if (info_.state.selected != RnAccessibleFlag::Unset) {
+          value->vt = VT_BOOL;
+          value->boolVal =
+              info_.state.selected == RnAccessibleFlag::True ? VARIANT_TRUE : VARIANT_FALSE;
+        }
+        return S_OK;
+
+      case UIA_ExpandCollapseExpandCollapseStatePropertyId:
+        if (info_.state.expanded != RnAccessibleFlag::Unset) {
+          value->vt = VT_I4;
+          value->lVal = info_.state.expanded == RnAccessibleFlag::True
+                            ? ExpandCollapseState_Expanded
+                            : ExpandCollapseState_Collapsed;
+        }
+        return S_OK;
+
+      case UIA_IsOffscreenPropertyId:
+        value->vt = VT_BOOL;
+        value->boolVal = info_.hidden ? VARIANT_TRUE : VARIANT_FALSE;
+        return S_OK;
+
+      case UIA_IsControlElementPropertyId:
+      case UIA_IsContentElementPropertyId:
+        value->vt = VT_BOOL;
+        value->boolVal = VARIANT_TRUE;
+        return S_OK;
+
+      default:
+        break;
+    }
+
+    // VT_EMPTY, which is UIA's "I have no opinion, use the default". Returning
+    // an error here instead makes a screen reader treat the whole element as
+    // broken rather than as quiet.
+    return S_OK;
+  }
+
+  // Null because these views are not native Windows controls: there is no
+  // HWND-based provider underneath to defer to. The host's fragment root is
+  // where the one real HWND enters the picture.
+  HRESULT STDMETHODCALLTYPE
+  get_HostRawElementProvider(IRawElementProviderSimple **provider) override {
+    if (provider == nullptr) {
+      return E_INVALIDARG;
+    }
+    *provider = nullptr;
+    return S_OK;
+  }
+
+ private:
+  ~AccessibleProvider() = default;
+
+  RnAccessibleInfo info_;
+  std::atomic<ULONG> references_{1};
+};
+
+} // namespace
+
+long controlTypeForRole(const std::string &role) {
+  const auto &table = roleTable();
+  const auto it = table.find(role);
+  return it == table.end() ? UIA_GroupControlTypeId : it->second;
+}
+
+bool roleIsPresentational(const std::string &role) {
+  return role == "none" || role == "presentation";
+}
+
+bool isAccessibilityElement(const RnAccessibleInfo &info) {
+  if (info.hidden || roleIsPresentational(info.role)) {
+    return false;
+  }
+  return !info.role.empty() || !info.label.empty() || !info.hint.empty();
+}
+
+IRawElementProviderSimple *createAccessibleProvider(const RnAccessibleInfo &info) {
+  if (!isAccessibilityElement(info)) {
+    return nullptr;
+  }
+  return new AccessibleProvider(info);
+}
+
+} // namespace basalt::win32

package/native/win32/RnWin32Accessible.h

@@ -0,0 +1,91 @@
+// What a screen reader is told about a view.
+//
+// This is the one place Windows is structurally different from the other two
+// desktops rather than differently spelled. GTK and AppKit both take
+// accessibility as *properties on a view*: `gtk_accessible_update_property`,
+// `setAccessibilityRole:`. UI Automation inverts that -- it asks a *provider*
+// object questions, and the provider answers by property id. So where the other
+// two mounting managers push, this one has to be ready to be pulled.
+//
+// The consequence worth knowing: a GTK role is construct-only, which is why
+// `docs/DECISIONS.md` records that `accessibilityRole` cannot change after
+// mount there. Nothing here has that constraint, because nothing is baked into
+// a widget class -- the provider reads the current value each time it is asked.
+// This platform can therefore do something GTK cannot, and the mounting manager
+// should not copy GTK's restriction when it arrives.
+//
+// What is here is the property half, which is all of it that can exist before
+// there is an HWND: UIA's tree navigation needs a fragment root, and a fragment
+// root is a window. `IRawElementProviderFragment` and the `Toggle`,
+// `SelectionItem` and `ExpandCollapse` *patterns* therefore land with the host.
+// The states those patterns expose are answerable now, because UIA mirrors each
+// of them as a plain property id, and that is what these answer.
+
+#pragma once
+
+#include <string>
+
+struct IRawElementProviderSimple;
+
+namespace basalt::win32 {
+
+// Each state is a tri-state on purpose. Leaving `checked` unset is not the same
+// as setting it false: a view that never mentions being checked is not an
+// unchecked checkbox, and a screen reader should not read it as one. Both other
+// platforms make the same distinction.
+enum class RnAccessibleFlag {
+  Unset,
+  False,
+  True,
+};
+
+struct RnAccessibleState {
+  RnAccessibleFlag disabled = RnAccessibleFlag::Unset;
+  RnAccessibleFlag checked = RnAccessibleFlag::Unset;
+  RnAccessibleFlag selected = RnAccessibleFlag::Unset;
+  RnAccessibleFlag expanded = RnAccessibleFlag::Unset;
+  RnAccessibleFlag busy = RnAccessibleFlag::Unset;
+};
+
+// Everything a view carries for assistive technology. Held by the view as plain
+// data; the provider below reads it.
+struct RnAccessibleInfo {
+  // React Native's own role string -- "button", "image", "text" -- not a UIA
+  // control type. The mapping is a platform decision and belongs beside the
+  // platform, and the string is what `describeTree` reports, so the three
+  // hosts' trees compare without one of them speaking UIA's vocabulary and
+  // another speaking GTK's.
+  std::string role;
+  std::string label;
+  std::string hint;
+  RnAccessibleState state;
+  // accessible={false} and accessibilityElementsHidden.
+  bool hidden = false;
+};
+
+// The UIA control type for a React Native role name, or
+// UIA_GroupControlTypeId for one this platform does not recognise.
+//
+// A fallback rather than a guess: a wrong control type is worse than a vague
+// one, because it makes a view announce itself as something it is not. Both
+// other platforms fall back the same way.
+long controlTypeForRole(const std::string &role);
+
+// True for "none" and "presentation", which mean "do not report this at all".
+bool roleIsPresentational(const std::string &role);
+
+// True when this view should appear to a screen reader. A plain <View> with no
+// role, no label and no hint is scaffolding, and a tree full of untyped groups
+// is worse for a screen reader user than a tree without them.
+bool isAccessibilityElement(const RnAccessibleInfo &info);
+
+// A UI Automation provider over one view's RnAccessibleInfo, for the property
+// half of the interface. Returns null when the view is not an accessibility
+// element. The caller owns a reference and must Release it.
+//
+// The provider copies the info rather than pointing at the view: UIA can ask
+// its questions from another thread and long after the view is gone, and a
+// dangling read there is a crash inside somebody's screen reader.
+IRawElementProviderSimple *createAccessibleProvider(const RnAccessibleInfo &info);
+
+} // namespace basalt::win32

package/native/win32/RnWin32Image.cpp

@@ -0,0 +1,265 @@
+#include "RnWin32Image.h"
+
+#include "Win32Clip.h"
+
+#include <windows.h>
+
+#include <d2d1.h>
+#include <wincodec.h>
+#include <wrl/client.h>
+
+#include <algorithm>
+
+using Microsoft::WRL::ComPtr;
+
+namespace basalt::win32 {
+namespace {
+
+bool ensureCom() {
+  const HRESULT hr = CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED);
+  return SUCCEEDED(hr) || hr == RPC_E_CHANGED_MODE;
+}
+
+IWICImagingFactory *wicFactory() {
+  // Every call, not only the first: decoding happens on whichever worker thread
+  // the image loader put it on, and COM is per-thread. The factory itself is
+  // agile -- WIC registers it "Both" -- so one instance serves every thread,
+  // but a thread that has never called CoInitializeEx cannot use it.
+  // CoInitializeEx on an already-initialised thread returns S_FALSE and costs
+  // nothing.
+  if (!ensureCom()) {
+    return nullptr;
+  }
+  static IWICImagingFactory *factory = [] {
+    IWICImagingFactory *created = nullptr;
+    CoCreateInstance(
+        CLSID_WICImagingFactory, nullptr, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&created));
+    return created;
+  }();
+  return factory;
+}
+
+} // namespace
+
+const char *imageFitName(RnImageFit fit) {
+  switch (fit) {
+    case RnImageFit::Contain:
+      return "contain";
+    case RnImageFit::Stretch:
+      return "stretch";
+    case RnImageFit::Center:
+      return "center";
+    case RnImageFit::Repeat:
+      return "repeat";
+    case RnImageFit::Cover:
+      break;
+  }
+  return "cover";
+}
+
+std::shared_ptr<RnWin32Image>
+RnWin32Image::fromPixels(unsigned width, unsigned height, const uint8_t *bgra) {
+  IWICImagingFactory *factory = wicFactory();
+  if (factory == nullptr || bgra == nullptr || width == 0 || height == 0) {
+    return nullptr;
+  }
+
+  const UINT stride = width * 4;
+  ComPtr<IWICBitmap> bitmap;
+  if (FAILED(factory->CreateBitmapFromMemory(width,
+                                             height,
+                                             GUID_WICPixelFormat32bppPBGRA,
+                                             stride,
+                                             stride * height,
+                                             const_cast<BYTE *>(bgra),
+                                             bitmap.GetAddressOf()))) {
+    return nullptr;
+  }
+
+  auto image = std::shared_ptr<RnWin32Image>(new RnWin32Image());
+  image->bitmap_ = bitmap.Detach();
+  image->width_ = width;
+  image->height_ = height;
+  return image;
+}
+
+std::shared_ptr<RnWin32Image> RnWin32Image::fromEncodedBytes(const uint8_t *data, size_t size) {
+  IWICImagingFactory *factory = wicFactory();
+  if (factory == nullptr || data == nullptr || size == 0) {
+    return nullptr;
+  }
+
+  // A stream over the caller's bytes. WIC copies what it needs during
+  // CreateBitmapFromSource below, so the caller's buffer does not have to
+  // outlive this function.
+  ComPtr<IWICStream> stream;
+  if (FAILED(factory->CreateStream(stream.GetAddressOf())) ||
+      FAILED(stream->InitializeFromMemory(const_cast<BYTE *>(data), static_cast<DWORD>(size)))) {
+    return nullptr;
+  }
+
+  ComPtr<IWICBitmapDecoder> decoder;
+  if (FAILED(factory->CreateDecoderFromStream(
+          stream.Get(), nullptr, WICDecodeMetadataCacheOnLoad, decoder.GetAddressOf()))) {
+    return nullptr;
+  }
+
+  ComPtr<IWICBitmapFrameDecode> frame;
+  if (FAILED(decoder->GetFrame(0, frame.GetAddressOf()))) {
+    return nullptr;
+  }
+
+  // Whatever the file was, Direct2D wants premultiplied BGRA.
+  ComPtr<IWICFormatConverter> converter;
+  if (FAILED(factory->CreateFormatConverter(converter.GetAddressOf())) ||
+      FAILED(converter->Initialize(frame.Get(),
+                                   GUID_WICPixelFormat32bppPBGRA,
+                                   WICBitmapDitherTypeNone,
+                                   nullptr,
+                                   0.0,
+                                   WICBitmapPaletteTypeCustom))) {
+    return nullptr;
+  }
+
+  ComPtr<IWICBitmap> bitmap;
+  if (FAILED(factory->CreateBitmapFromSource(
+          converter.Get(), WICBitmapCacheOnLoad, bitmap.GetAddressOf()))) {
+    return nullptr;
+  }
+
+  UINT width = 0;
+  UINT height = 0;
+  if (FAILED(bitmap->GetSize(&width, &height)) || width == 0 || height == 0) {
+    return nullptr;
+  }
+
+  auto image = std::shared_ptr<RnWin32Image>(new RnWin32Image());
+  image->bitmap_ = bitmap.Detach();
+  image->width_ = width;
+  image->height_ = height;
+  return image;
+}
+
+RnWin32Image::~RnWin32Image() {
+  if (deviceBitmap_ != nullptr) {
+    deviceBitmap_->Release();
+  }
+  if (bitmap_ != nullptr) {
+    bitmap_->Release();
+  }
+}
+
+void RnWin32Image::draw(ID2D1RenderTarget *target,
+                        float boxWidth,
+                        float boxHeight,
+                        RnImageFit fit,
+                        const float *tint) const {
+  if (target == nullptr || bitmap_ == nullptr || boxWidth <= 0.0f || boxHeight <= 0.0f) {
+    return;
+  }
+
+  if (deviceBitmap_ == nullptr || deviceTarget_ != target) {
+    if (deviceBitmap_ != nullptr) {
+      deviceBitmap_->Release();
+      deviceBitmap_ = nullptr;
+    }
+    ID2D1Bitmap *created = nullptr;
+    if (FAILED(target->CreateBitmapFromWicBitmap(bitmap_, nullptr, &created))) {
+      return;
+    }
+    deviceBitmap_ = created;
+    deviceTarget_ = target;
+  }
+
+  const float imageWidth = static_cast<float>(width_);
+  const float imageHeight = static_cast<float>(height_);
+
+  // The same arithmetic rn_view_snapshot does on GTK, in the same order, so the
+  // three desktops crop and centre identically. A picture is the only thing
+  // that would catch a divergence here, which is why test_win32_image.cpp reads
+  // pixels rather than checking the destination rect.
+  D2D1_RECT_F destination = D2D1::RectF(0.0f, 0.0f, boxWidth, boxHeight);
+  if (fit != RnImageFit::Stretch) {
+    float scale = 1.0f;
+    switch (fit) {
+      case RnImageFit::Contain:
+        scale = std::min(boxWidth / imageWidth, boxHeight / imageHeight);
+        break;
+      case RnImageFit::Cover:
+        scale = std::max(boxWidth / imageWidth, boxHeight / imageHeight);
+        break;
+      case RnImageFit::Center:
+        // Centred at natural size, but never larger than the frame -- which is
+        // what React Native's `center` does.
+        scale = std::min(1.0f, std::min(boxWidth / imageWidth, boxHeight / imageHeight));
+        break;
+      case RnImageFit::Repeat:
+        // One tile, at natural size. Where the tiles go is decided below.
+        break;
+      case RnImageFit::Stretch:
+        break;
+    }
+    const float drawnWidth = imageWidth * scale;
+    const float drawnHeight = imageHeight * scale;
+    // From the top left for `repeat`, which is what CSS does: the whole tiles
+    // start at the origin and the partial one is at the far edge.
+    const float x = fit == RnImageFit::Repeat ? 0.0f : (boxWidth - drawnWidth) / 2.0f;
+    const float y = fit == RnImageFit::Repeat ? 0.0f : (boxHeight - drawnHeight) / 2.0f;
+    destination = D2D1::RectF(x, y, x + drawnWidth, y + drawnHeight);
+  }
+
+  // cover and center can put pixels outside the frame, and an <Image> never
+  // paints beyond its own box on iOS or Android. A geometry clip rather than an
+  // axis-aligned one, because an <Image> inside a rotated view is not exotic;
+  // see Win32Clip.h.
+  const bool needsClip =
+      fit == RnImageFit::Cover || fit == RnImageFit::Center || fit == RnImageFit::Repeat;
+  {
+    const ScopedGeometryClip clip(needsClip ? target : nullptr,
+                                  D2D1::RectF(0.0f, 0.0f, boxWidth, boxHeight),
+                                  0.0f);
+    if (fit == RnImageFit::Repeat) {
+      // A bitmap brush in wrap mode, which is Direct2D's tiling: the brush
+      // repeats the bitmap across whatever is filled, and the clip above is
+      // what stops it at the view's edge.
+      //
+      // Nearest-neighbour on purpose. The default is linear, which blends the
+      // last column of one tile into the first of the next and leaves a seam
+      // on every boundary -- visible on exactly the small, sharp images people
+      // tile.
+      Microsoft::WRL::ComPtr<ID2D1BitmapBrush> brush;
+      const D2D1_BITMAP_BRUSH_PROPERTIES properties = D2D1::BitmapBrushProperties(
+          D2D1_EXTEND_MODE_WRAP,
+          D2D1_EXTEND_MODE_WRAP,
+          D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR);
+      // The four-argument form on the interface itself rather than one of
+      // d2d1.h's inline reference overloads, so which one is selected is not a
+      // thing to be wrong about.
+      if (SUCCEEDED(target->CreateBitmapBrush(
+              deviceBitmap_, &properties, nullptr, brush.GetAddressOf()))) {
+        target->FillRectangle(D2D1::RectF(0.0f, 0.0f, boxWidth, boxHeight), brush.Get());
+      }
+    } else if (tint != nullptr) {
+      // The bitmap becomes an opacity mask and the brush is what is painted.
+      // Direct2D requires aliased antialiasing for a mask whose content is
+      // graphics rather than text, and refuses the call otherwise -- so the
+      // mode is changed for the one draw and put back.
+      Microsoft::WRL::ComPtr<ID2D1SolidColorBrush> brush;
+      const D2D1_COLOR_F color = D2D1::ColorF(tint[0], tint[1], tint[2], tint[3]);
+      if (SUCCEEDED(target->CreateSolidColorBrush(color, brush.GetAddressOf()))) {
+        const D2D1_ANTIALIAS_MODE previous = target->GetAntialiasMode();
+        target->SetAntialiasMode(D2D1_ANTIALIAS_MODE_ALIASED);
+        target->FillOpacityMask(deviceBitmap_,
+                                brush.Get(),
+                                D2D1_OPACITY_MASK_CONTENT_GRAPHICS,
+                                &destination,
+                                nullptr);
+        target->SetAntialiasMode(previous);
+      }
+    } else {
+      target->DrawBitmap(deviceBitmap_, destination);
+    }
+  }
+}
+
+} // namespace basalt::win32