basalt-win32 0.2.2 → 0.2.3

package/native/tests/test_win32_accessibility.cpp

@@ -330,6 +330,83 @@ TEST(accessibility_a_plain_view_claims_no_dialog) {
   EXPECT_EQ(propertyType(provider, UIA_IsDialogPropertyId), VT_EMPTY);
 }
 
+// ---------------------------------------------------------------------------
+// `accessibilityLanguage`, which is the one accessibility prop where this
+// platform does not take the value the app wrote.
+//
+// Every other host publishes the BCP-47 tag verbatim -- AppKit as the
+// `AXLanguage` attribute, and GTK not at all, having no accessible language
+// property. UIA's culture property is an LCID, a number, so the tag has to be
+// converted; `LocaleNameToLCID` is the conversion and these pin that the
+// provider does it rather than answering with the string or with zero.
+//
+// The expected numbers are Windows' own and not invented here: 1036 is fr-FR
+// and 12 is the neutral French. Asserted as `LocaleNameToLCID` reports them,
+// because a hard-coded constant that disagreed with the running system would
+// be testing the wrong thing.
+
+TEST(accessibility_a_language_becomes_a_culture_id) {
+  RnAccessibleInfo info = withRole("text");
+  info.label = "Bonjour";
+  info.language = "fr-FR";
+
+  auto provider = providerFor(info);
+  EXPECT(provider != nullptr);
+  EXPECT_EQ(propertyType(provider, UIA_CulturePropertyId), VT_I4);
+  EXPECT_EQ(longProperty(provider, UIA_CulturePropertyId),
+            static_cast<long>(LocaleNameToLCID(L"fr-FR", LOCALE_ALLOW_NEUTRAL_NAMES)));
+  // Not the system's, which is what a provider that ignored the prop and
+  // answered zero would be claiming.
+  EXPECT(longProperty(provider, UIA_CulturePropertyId) != 0);
+}
+
+// A tag with no region is what an app writes when it means the language rather
+// than a country, and it is the case `LOCALE_ALLOW_NEUTRAL_NAMES` exists for:
+// without the flag this answers nothing for a large share of what apps write.
+TEST(accessibility_a_language_without_a_region_still_converts) {
+  RnAccessibleInfo info = withRole("text");
+  info.language = "fr";
+
+  auto provider = providerFor(info);
+  EXPECT(provider != nullptr);
+  EXPECT_EQ(propertyType(provider, UIA_CulturePropertyId), VT_I4);
+  EXPECT_EQ(longProperty(provider, UIA_CulturePropertyId),
+            static_cast<long>(LocaleNameToLCID(L"fr", LOCALE_ALLOW_NEUTRAL_NAMES)));
+}
+
+// Unset rather than zero, for the reason the dialog property is unset rather
+// than false: zero is a valid LCID meaning the system default, so answering it
+// would say the app asked for the system language when it asked for nothing.
+TEST(accessibility_no_language_leaves_the_culture_unset) {
+  auto provider = providerFor(withRole("text"));
+  EXPECT(provider != nullptr);
+  EXPECT_EQ(propertyType(provider, UIA_CulturePropertyId), VT_EMPTY);
+}
+
+// And the same for a tag this Windows cannot resolve, which is the branch that
+// would otherwise publish zero and call it the app's choice.
+//
+// Over-long rather than merely wrong, and that is deliberate: Windows accepts
+// far more than the tags it has data for -- a well-formed name it does not
+// know can come back as `LOCALE_CUSTOM_UNSPECIFIED` rather than as a failure,
+// and which names those are differs by Windows version. A name longer than
+// `LOCALE_NAME_MAX_LENGTH` is the one input documented to fail everywhere, so
+// it is what pins the branch without the assertion depending on the runner's
+// locale data.
+TEST(accessibility_an_unresolvable_language_leaves_the_culture_unset) {
+  RnAccessibleInfo info = withRole("text");
+  info.language = std::string(LOCALE_NAME_MAX_LENGTH + 10, 'x');
+  // The premise, asserted rather than assumed: if some future Windows resolved
+  // this, the test below would be checking nothing.
+  EXPECT_EQ(LocaleNameToLCID(basalt::win32::widen(info.language).c_str(),
+                             LOCALE_ALLOW_NEUTRAL_NAMES),
+            static_cast<LCID>(0));
+
+  auto provider = providerFor(info);
+  EXPECT(provider != nullptr);
+  EXPECT_EQ(propertyType(provider, UIA_CulturePropertyId), VT_EMPTY);
+}
+
 // ---------------------------------------------------------------------------
 // `accessibilityLabelledBy`, which is the one accessibility prop that is a
 // relation between two views rather than a value on one.

package/native/tests/test_win32_focus.cpp

@@ -90,6 +90,32 @@ TEST(win32_focus_accessible_views_are_the_ones_tab_stops_on) {
   manager.destroySurfaceRoot(kSurfaceId);
 }
 
+// `accessibilityRespondsToUserInteraction`, which React Native documents as
+// blocking the keyboard while leaving the view accessible. On a desktop that
+// is the Tab order; core/KeyboardFocusable.h decides it for all three hosts
+// and this is the wiring.
+TEST(win32_focus_a_view_that_refuses_interaction_is_not_a_tab_stop) {
+  Win32MountingManager manager;
+  RnWin32View *root = manager.createSurfaceRoot(kSurfaceId);
+  root->setFrame(0, 0, 400, 400);
+
+  ShadowView quiet = makeAccessibleView(10, 0, true);
+  auto props = std::make_shared<ViewProps>(*std::static_pointer_cast<const ViewProps>(quiet.props));
+  props->accessibilityRespondsToUserInteraction = false;
+  quiet.props = props;
+
+  mountAll(manager, {quiet, makeAccessibleView(11, 50, true)});
+
+  EXPECT(!manager.viewForTag(10)->focusable());
+  // The view beside it said nothing, and the prop defaults to true: one view
+  // refusing the keyboard must not take its neighbours with it.
+  EXPECT(manager.viewForTag(11)->focusable());
+  // And the dump says so, which is what the cross-host comparison reads.
+  EXPECT(root->describeTree().find("focusable") != std::string::npos);
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
 TEST(win32_focus_tab_visits_focusable_views_in_tree_order_and_wraps) {
   Win32MountingManager manager;
   RnWin32View *root = manager.createSurfaceRoot(kSurfaceId);

package/native/tests/test_win32_textinput.cpp

@@ -179,6 +179,9 @@ struct FieldOptions {
   unsigned int placeholderTextColor{0};
   unsigned int selectionColor{0};
   unsigned int cursorColor{0};
+  // `scrollEnabled`, which defaults to true the way the trait does. Sent only
+  // when false so the other tests' raw props stay as they were.
+  bool scrollEnabled{true};
 };
 
 ShadowView makeField(Tag tag,
@@ -196,6 +199,9 @@ ShadowView makeField(Tag tag,
       "clearTextOnFocus", options.clearTextOnFocus)(
       "selectTextOnFocus", options.selectTextOnFocus)("caretHidden", options.caretHidden)(
       "contextMenuHidden", options.contextMenuHidden);
+  if (!options.scrollEnabled) {
+    raw["scrollEnabled"] = false;
+  }
   if (!options.submitBehavior.empty()) {
     raw["submitBehavior"] = options.submitBehavior;
   }
@@ -889,6 +895,91 @@ TEST(win32_a_multiline_field_is_a_multiline_control) {
   manager->destroySurfaceRoot(kSurfaceId);
 }
 
+// `scrollEnabled: false`, which is that vertical scroll withheld. A
+// creation-time style bit like `ES_MULTILINE` beside it, so the assertions are
+// the same shape.
+TEST(win32_a_field_that_disables_scrolling_has_no_vertical_scroll) {
+  auto manager = makeManager();
+  RnWin32View *root = manager->createSurfaceRoot(kSurfaceId);
+  root->setFrame(0, 0, 800, 600);
+  mount(*manager,
+        kSurfaceId,
+        makeField(10, 20, 30, 200, 120,
+                  {.text = "", .multiline = true, .scrollEnabled = false}));
+  manager->syncTextInputBounds(root);
+
+  HWND control = peerOf(manager->viewForTag(10));
+  EXPECT(control != nullptr);
+  if (control == nullptr) {
+    return;
+  }
+  const LONG_PTR style = GetWindowLongPtr(control, GWL_STYLE);
+  // Still a multiline control: the prop is about scrolling and nothing else.
+  EXPECT((style & ES_MULTILINE) != 0);
+  EXPECT((style & ES_AUTOVSCROLL) == 0);
+  // And it still takes the text, which is the half that makes this a display
+  // decision rather than a limit.
+  type(control, L"a\rb");
+  EXPECT_EQ(textOf(control), std::string("a\r\nb"));
+
+  manager->destroySurfaceRoot(kSurfaceId);
+}
+
+// Only for a multiline field. A single line scrolls sideways through
+// `ES_AUTOHSCROLL`, which React Native's prop says nothing about, so a field
+// that sets it there is unchanged -- and in particular does not lose the
+// horizontal scroll that lets the caret leave the right-hand edge.
+TEST(win32_a_single_line_field_ignores_the_scroll_prop) {
+  auto manager = makeManager();
+  RnWin32View *root = manager->createSurfaceRoot(kSurfaceId);
+  root->setFrame(0, 0, 800, 600);
+  mount(*manager, kSurfaceId, makeField(10, 20, 30, 200, 44, {.scrollEnabled = false}));
+  manager->syncTextInputBounds(root);
+
+  HWND control = peerOf(manager->viewForTag(10));
+  EXPECT(control != nullptr);
+  if (control == nullptr) {
+    return;
+  }
+  EXPECT((GetWindowLongPtr(control, GWL_STYLE) & ES_AUTOHSCROLL) != 0);
+
+  manager->destroySurfaceRoot(kSurfaceId);
+}
+
+// The style cannot be added to a live control, so a field that changes the prop
+// has its peer rebuilt -- the same rule `multiline` follows, and the text comes
+// across for the same reason.
+TEST(win32_changing_scroll_enabled_rebuilds_the_peer) {
+  auto manager = makeManager();
+  RnWin32View *root = manager->createSurfaceRoot(kSurfaceId);
+  root->setFrame(0, 0, 800, 600);
+  const ShadowView scrolling =
+      makeField(10, 20, 30, 200, 120, {.text = "wrapped", .multiline = true});
+  mount(*manager, kSurfaceId, scrolling);
+  manager->syncTextInputBounds(root);
+
+  HWND before = peerOf(manager->viewForTag(10));
+  EXPECT(before != nullptr);
+  EXPECT(before != nullptr && (GetWindowLongPtr(before, GWL_STYLE) & ES_AUTOVSCROLL) != 0);
+
+  update(*manager,
+         scrolling,
+         makeField(10, 20, 30, 200, 120,
+                   {.text = "wrapped", .multiline = true, .scrollEnabled = false}));
+  manager->syncTextInputBounds(root);
+
+  HWND after = peerOf(manager->viewForTag(10));
+  EXPECT(after != nullptr);
+  if (after == nullptr) {
+    return;
+  }
+  EXPECT(after != before);
+  EXPECT((GetWindowLongPtr(after, GWL_STYLE) & ES_AUTOVSCROLL) == 0);
+  EXPECT_EQ(textOf(after), std::string("wrapped"));
+
+  manager->destroySurfaceRoot(kSurfaceId);
+}
+
 // A single-line field still swallows Enter, which is the other half of the same
 // rule and the test that was here before this prop existed.
 TEST(win32_a_single_line_field_is_not_multiline) {

package/native/win32/RnWin32Accessible.cpp

@@ -165,6 +165,33 @@ class AccessibleProvider final : public IRawElementProviderSimple {
         }
         return S_OK;
 
+      case UIA_CulturePropertyId: {
+        // React Native's `accessibilityLanguage`, which UIA takes as an LCID
+        // and not as the BCP-47 tag every other platform speaks: 1036 where
+        // the app wrote "fr-FR". `LocaleNameToLCID` is the documented
+        // conversion and the reason this property can be answered at all.
+        //
+        // `LOCALE_ALLOW_NEUTRAL_NAMES` so a tag with no region -- "fr", which
+        // is what an app writes when it means the language and not a country
+        // -- converts rather than failing. Without it the function rejects
+        // every neutral name, which is a large share of what apps write.
+        //
+        // Left unset when the tag does not convert, which is the honest answer
+        // for a locale this Windows does not know: zero is a valid LCID
+        // meaning the system default, so returning the failure would claim the
+        // app asked for the system language when it asked for something else.
+        if (info_.language.empty()) {
+          return S_OK;
+        }
+        const LCID lcid =
+            LocaleNameToLCID(widen(info_.language).c_str(), LOCALE_ALLOW_NEUTRAL_NAMES);
+        if (lcid != 0) {
+          value->vt = VT_I4;
+          value->lVal = static_cast<long>(lcid);
+        }
+        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

package/native/win32/RnWin32Accessible.h

@@ -80,6 +80,11 @@ struct RnAccessibleInfo {
   // calls an automation id. Not a label -- nothing reads it aloud -- and not
   // `nativeID`, which is how an app names a view to itself.
   std::string testId;
+  // `accessibilityLanguage`, as React Native gave it: a BCP-47 tag such as
+  // "fr-CA". UIA wants a culture *identifier* rather than a tag, so the
+  // conversion happens where the property is answered and not here -- the tag
+  // is what the app wrote and what the other hosts publish verbatim.
+  std::string language;
   // `accessibilityViewIsModal`. UIA calls this a dialog: a client that honours
   // `IsDialog` stops offering what is behind the element, which is the same
   // behaviour ARIA's `aria-modal` and AppKit's `accessibilityModal` ask for.

package/native/win32/RnWin32View.h

@@ -431,6 +431,16 @@ class RnWin32View {
   void setNativeId(std::string nativeId) { nativeId_ = std::move(nativeId); }
   const std::string &nativeId() const { return nativeId_; }
 
+  // What this view will take on a drop, over and above what its `nativeID`
+  // says: a `DropAccepts` mask from core/DragAndDrop.h.
+  //
+  // A second source because a `<TextInput>` declares it with a real prop,
+  // `acceptDragAndDropTypes`, where a plain `<View>` has only the `nativeID`
+  // marker this platform invented. The drop walk reads both, so a field can
+  // accept a drop without being given a magic id.
+  void setDropAccepts(std::uint16_t accepts) { dropAccepts_ = accepts; }
+  std::uint16_t dropAccepts() const { return dropAccepts_; }
+
   // --- Content ---------------------------------------------------------------
 
   // The paragraph this view draws, or null for a view that draws none.
@@ -805,6 +815,7 @@ class RnWin32View {
   bool hasBorders_ = false;
   HWND editablePeer_ = nullptr;
   std::string nativeId_;
+  std::uint16_t dropAccepts_{0};
   int zIndex_ = 0;
   PointerEvents pointerEvents_ = PointerEvents::Auto;
   float hitSlop_[4] = {0.0f, 0.0f, 0.0f, 0.0f};

package/native/win32/Win32AppWindow.h

@@ -0,0 +1,36 @@
+// Which HWND a surface id means.
+//
+// The same seam AppKitAppWindow.h and GtkAppWindow.h describe, written for
+// this toolkit and for the same reason: the registry of open windows is
+// `main_win32.cpp`'s, and everything that resolves one is compiled into the
+// mounting library, which the host links rather than the other way round. So
+// the host installs a lookup at startup and this is what the window module
+// asks.
+//
+// Not installed is the normal case for a test binary: it opens no window, and
+// should not grow a registry to keep compiling. `win32AppWindowFor` falls back
+// to the active window, which is what every caller here did before windows had
+// ids.
+
+#pragma once
+
+#include <react/renderer/core/ReactPrimitives.h>
+
+#include <functional>
+
+#include <windows.h>
+
+namespace basalt {
+
+// The app's own window, by the rule this host has always used: the active
+// window, falling back to the foreground one. UI thread only.
+HWND win32AppWindow();
+
+using Win32AppWindowLookup = std::function<HWND(facebook::react::SurfaceId)>;
+void setWin32AppWindowLookup(Win32AppWindowLookup lookup);
+
+// The window with this surface id, or the app's own for `kAppWindow` and for
+// an id the lookup does not know. UI thread only.
+HWND win32AppWindowFor(facebook::react::SurfaceId window);
+
+} // namespace basalt

package/native/win32/Win32DropTarget.cpp

@@ -490,7 +490,10 @@ facebook::react::Tag dropTargetAt(win32::RnWin32View *root,
   }
   // Deepest first, which is the rule: a drop target inside another wins.
   for (auto it = path.rbegin(); it != path.rend(); ++it) {
-    const std::uint16_t wanted = dropAcceptsFrom((*it)->nativeId());
+    // The `nativeID` marker and the view's own declared kinds, which is how a
+    // <TextInput acceptDragAndDropTypes> joins this walk without an id.
+    const std::uint16_t wanted =
+        static_cast<std::uint16_t>(dropAcceptsFrom((*it)->nativeId()) | (*it)->dropAccepts());
     if (wanted != DropAcceptsNone && (wanted & accepts) != 0) {
       return static_cast<facebook::react::Tag>((*it)->tag());
     }

package/native/win32/Win32MenuBar.cpp

@@ -342,7 +342,9 @@ bool handleMenuCommand(unsigned int command) {
       PostMessageW(window, WM_CLOSE, 0, 0);
       return true;
     case kRoleBase + 12:
-      setWindowFullScreen(!windowBounds().fullScreen);
+      // The app's own window: a menu role acts on the window the menu bar
+      // belongs to, which is that one. See core/WindowControl.h.
+      setWindowFullScreen(kAppWindow, !windowBounds(kAppWindow).fullScreen);
       return true;
     default:
       return false;

package/native/win32/Win32MountingManager.cpp

@@ -1,3 +1,6 @@
+#include "AccessibilityRole.h"
+#include "KeyboardFocusable.h"
+#include "ImagePlaceholder.h"
 #include "Win32MountingManager.h"
 
 #include "BackgroundLayers.h"
@@ -342,6 +345,8 @@ void Win32MountingManager::forgetTag(Tag tag) {
   scrollViews_.remove(tag);
   textInputs_.remove(tag);
   imageUris_.erase(tag);
+  imagePlaceholders_.erase(tag);
+  imageLoaded_.erase(tag);
   switchValues_.erase(tag);
   labels_.forget(tag);
   liveRegions_.forget(tag);
@@ -872,6 +877,9 @@ void Win32MountingManager::applyImage(RnWin32View *view, const ShadowView &shado
   const facebook::react::ImageSource source =
       props->sources.empty() ? facebook::react::ImageSource{} : props->sources.front();
   const std::string uri = source.uri;
+  // `defaultSource`, drawn until the source lands and kept if it never does.
+  // See core/ImagePlaceholder.h for which of the two props this is.
+  const std::string placeholder = basalt::imagePlaceholderUri(*props);
 
   // `tintColor`, applied before the load rather than in its callback: the tint
   // is a prop and the image is a loader's answer, and either can arrive first.
@@ -914,6 +922,8 @@ void Win32MountingManager::applyImage(RnWin32View *view, const ShadowView &shado
     return;
   }
   imageUris_[shadowView.tag] = uri;
+  imagePlaceholders_[shadowView.tag] = placeholder;
+  imageLoaded_.erase(shadowView.tag);
 
   if (uri.empty()) {
     view->setImage(nullptr, fit);
@@ -926,6 +936,38 @@ void Win32MountingManager::applyImage(RnWin32View *view, const ShadowView &shado
   // the change did not take.
   view->setImage(nullptr, fit);
 
+  // Then the placeholder, if the app named one, so the blank box above is as
+  // short as the loader is slow. A bundled asset answers from the cache on
+  // this thread, which makes it the same frame.
+  //
+  // Guarded on the real image not having arrived: both loads are asynchronous
+  // and a slow placeholder must not paint over the image it stood in for.
+  if (!placeholder.empty() && uri != placeholder) {
+    const Tag placeholderTag = shadowView.tag;
+    imageLoader_->load(
+        placeholder,
+        [this, placeholderTag, fit, placeholder](std::shared_ptr<win32::RnWin32Image> image,
+                                                 const std::string &) {
+          if (image == nullptr || imageLoaded_.count(placeholderTag) != 0) {
+            return;
+          }
+          const auto still = imagePlaceholders_.find(placeholderTag);
+          if (still == imagePlaceholders_.end() || still->second != placeholder) {
+            return;
+          }
+          RnWin32View *target = viewForTag(placeholderTag);
+          if (target == nullptr) {
+            return;
+          }
+          target->setImage(image, fit);
+          // The same reason the load callback below calls it: the bytes
+          // arrived on their own clock and only the host has the HWND.
+          if (onDidMount_) {
+            onDidMount_();
+          }
+        });
+  }
+
   // `<Image>`'s load events, which this host emitted none of until 2026-10-10:
   // `onLoadStart`, `onProgress`, `onLoad`, `onError` and `onLoadEnd` all
   // reached JavaScript on the other two hosts and nothing here ever dispatched
@@ -987,7 +1029,20 @@ void Win32MountingManager::applyImage(RnWin32View *view, const ShadowView &shado
         const bool stillWanted =
             target != nullptr && current != imageUris_.end() && current->second == uri;
         if (stillWanted) {
-          target->setImage(image, fit);
+          // A failed load leaves the placeholder where it is rather than
+          // clearing to nothing, which is `RCTImageComponentView`'s behaviour:
+          // a broken remote image shows what the app chose to show instead of
+          // an empty box.
+          const auto standing = imagePlaceholders_.find(tag);
+          const bool keepPlaceholder = image == nullptr &&
+                                       standing != imagePlaceholders_.end() &&
+                                       !standing->second.empty();
+          if (image != nullptr) {
+            imageLoaded_.insert(tag);
+          }
+          if (!keepPlaceholder) {
+            target->setImage(image, fit);
+          }
           applyAnimation(target, uri);
           // The screen is stale and no transaction is coming: the bytes arrived
           // on their own clock, after the mount that asked for them. On GTK and
@@ -1044,8 +1099,22 @@ win32::RnAccessibleFlag toFlag(bool value) {
 std::string effectiveRole(const ShadowView &shadowView) {
   if (const auto props =
           std::dynamic_pointer_cast<const facebook::react::AccessibilityProps>(shadowView.props)) {
-    if (!props->accessibilityRole.empty()) {
-      return props->accessibilityRole;
+    const std::string asked = basalt::accessibilityRoleName(*props);
+    if (!asked.empty()) {
+      return asked;
+    }
+  }
+  // Then the paragraph's own fragments, which is where a nested <Text>'s role
+  // lands: `TextAttributes` carries one per run, and a paragraph every fragment
+  // of which agrees *is* that role. Before the inference below, so a paragraph
+  // whose runs all say "header" is a header rather than generic text. See
+  // core/AccessibilityRole.h for why agreement and not the first one.
+  if (const auto state =
+          std::dynamic_pointer_cast<const facebook::react::ConcreteState<facebook::react::ParagraphState>>(
+              shadowView.state)) {
+    const std::string fragments = basalt::fragmentRoleName(state->getData().attributedString);
+    if (!fragments.empty()) {
+      return fragments;
     }
   }
   if (shadowView.componentName != nullptr) {
@@ -1085,6 +1154,9 @@ void Win32MountingManager::applyAccessibility(RnWin32View *view, const ShadowVie
   info.testId = props->testId;
   // `accessibilityViewIsModal`, which UIA calls a dialog.
   info.modal = props->accessibilityViewIsModal;
+  // `accessibilityLanguage`, as the BCP-47 tag the app wrote. The conversion
+  // to the LCID UIA wants happens where the culture property is answered.
+  info.language = props->accessibilityLanguage;
 
   const auto &state = props->accessibilityState;
   if (state.has_value()) {
@@ -1140,7 +1212,7 @@ void Win32MountingManager::applyAccessibility(RnWin32View *view, const ShadowVie
   // that cannot be operated rather than stopping on one that does nothing.
   const basalt::ControlState control = basalt::controlStateOf(shadowView);
   const bool isControl = control.kind == basalt::ControlKind::Switch && !control.disabled;
-  view->setFocusable((props->accessible || isControl) && !props->accessibilityElementsHidden);
+  view->setFocusable(basalt::keyboardFocusable(*props, isControl));
 }
 
 void Win32MountingManager::applyLayoutMetrics(RnWin32View *view, const ShadowView &shadowView) {

package/native/win32/Win32MountingManager.h

@@ -34,6 +34,7 @@
 #include <functional>
 #include <string>
 #include <unordered_map>
+#include <unordered_set>
 
 namespace basalt {
 
@@ -190,6 +191,10 @@ class Win32MountingManager final : public facebook::react::IMountingManager,
   // changed only layout does not restart the load and make the image flicker
   // whenever its parent resizes. Both other platforms keep the same map.
   std::unordered_map<facebook::react::Tag, std::string> imageUris_;
+  // `defaultSource` per view, and which views have their real image. See
+  // core/ImagePlaceholder.h.
+  std::unordered_map<facebook::react::Tag, std::string> imagePlaceholders_;
+  std::unordered_set<facebook::react::Tag> imageLoaded_;
 
   // Scroll offsets, the unthrottled state write-back, the wheel and the
   // commands. Constructed with a lookup into this object's own emitter registry

package/native/win32/Win32TextInput.cpp

@@ -1,6 +1,7 @@
 #include "Win32TextInput.h"
 
 #include "DirectWriteLayout.h"
+#include "DragAndDrop.h"
 #include "TextChecking.h"
 #include "Win32PeerClip.h"
 #include "Win32InputScopes.h"
@@ -134,8 +135,29 @@ void Win32TextInputManager::update(RnWin32View *view, const ShadowView &shadowVi
   // that still behaves as one line. So a field that changes the prop has its
   // peer rebuilt, which is rare enough to be worth the simplicity: React Native
   // apps choose multiline per field rather than toggling it.
+  // `acceptDragAndDropTypes`: the kinds this field will take on a drop, which
+  // makes it a drop target in the sense core/DragAndDrop.h means. Android
+  // implements the prop as a filter over the platform's own drop handling and
+  // this is that filter: a list naming only text refuses a dragged file, so
+  // the cursor says no before the drop rather than the app rejecting it after.
+  //
+  // Cleared when the prop goes away, which is the case a field that stops
+  // accepting must not keep accepting.
+  if (view != nullptr) {
+    view->setDropAccepts(props != nullptr && props->acceptDragAndDropTypes.has_value()
+                             ? dropAcceptsFromTypes(*props->acceptDragAndDropTypes)
+                             : DropAcceptsNone);
+  }
+
   const bool multiline = props != nullptr && props->multiline;
-  if (entry.control != nullptr && multiline != entry.multiline) {
+  // `scrollEnabled`, the other creation-time style bit. React Native documents
+  // it as multiline-only -- a single line scrolls sideways through
+  // `ES_AUTOHSCROLL` and the prop says nothing about that -- so it is only
+  // compared for a multiline field, and a single-line one that sets it does
+  // not get its peer rebuilt for nothing.
+  const bool scrollEnabled = props == nullptr || props->traits.scrollEnabled;
+  const bool scrollChanged = multiline && scrollEnabled != entry.scrollEnabled;
+  if (entry.control != nullptr && (multiline != entry.multiline || scrollChanged)) {
     const bool hadFocus = GetFocus() == entry.control;
     destroyPeer(entry);
     entry.view = view;
@@ -161,9 +183,18 @@ void Win32TextInputManager::update(RnWin32View *view, const ShadowView &shadowVi
     // scroll is what lets the caret leave the bottom of the box. No `WS_VSCROLL`
     // on purpose -- a scrollbar inside a styled field is a Win32 scrollbar
     // drawn over a React Native background, and neither other host shows one.
+    //
+    // `scrollEnabled: false` is that vertical scroll withheld, which is what
+    // the prop asks for: the field stops following the caret past the bottom
+    // of the box and the text below is simply not shown. An EDIT without
+    // `ES_AUTOVSCROLL` still accepts the text -- it is a display decision and
+    // not a limit, which is the same distinction `maxLength` is on the other
+    // side of.
     entry.multiline = multiline;
+    entry.scrollEnabled = scrollEnabled;
     const DWORD style = WS_CHILD | WS_CLIPSIBLINGS | ES_LEFT
-        | (multiline ? (ES_MULTILINE | ES_AUTOVSCROLL) : ES_AUTOHSCROLL);
+        | (multiline ? (ES_MULTILINE | (scrollEnabled ? ES_AUTOVSCROLL : 0u))
+                     : ES_AUTOHSCROLL);
     entry.control = CreateWindowEx(0,
                                    L"EDIT",
                                    L"",

package/native/win32/Win32TextInput.h

@@ -264,6 +264,11 @@ class Win32TextInputManager {
     // created and cannot be added afterwards, so this is what a change in the
     // prop is compared against: a field that switches has its peer rebuilt.
     bool multiline{false};
+    // `scrollEnabled`, which is part of the same creation-time decision as
+    // `multiline`: it is the `ES_AUTOVSCROLL` style bit, read when the window
+    // is made. Remembered so a change rebuilds the peer the way a change of
+    // `multiline` does.
+    bool scrollEnabled{true};
 
     // Yoga resolves border and padding into contentInsets, so the same twelve
     // points mean the same thing in a field as in a <View>. Applied by placing

package/native/win32/Win32WindowControl.cpp

@@ -21,17 +21,40 @@
 // scale factor. GetDpiForWindow would answer for the window's monitor only.
 #include <shellscalingapi.h>
 
+#include "Win32AppWindow.h"
+
 namespace basalt {
 
 namespace {
 
+// The window a call means, which is the lookup's answer where there is one.
+HWND window(facebook::react::SurfaceId id) { return win32AppWindowFor(id); }
+
+Win32AppWindowLookup &lookup() {
+  static Win32AppWindowLookup value;
+  return value;
+}
+
+} // namespace
 
-HWND window() {
+HWND win32AppWindow() {
   HWND active = GetActiveWindow();
   return active != nullptr ? active : GetForegroundWindow();
 }
 
-} // namespace
+void setWin32AppWindowLookup(Win32AppWindowLookup value) { lookup() = std::move(value); }
+
+HWND win32AppWindowFor(facebook::react::SurfaceId id) {
+  if (id != kAppWindow && lookup()) {
+    if (HWND found = lookup()(id)) {
+      return found;
+    }
+    // An id nobody knows is the app's own window rather than nothing: a window
+    // that closed between a render and the call after it is the ordinary way
+    // to get here. See AppKitAppWindow.h, which says the same.
+  }
+  return win32AppWindow();
+}
 
 // Every monitor, through the callback API that is the only way to ask.
 //
@@ -99,9 +122,9 @@ PointerPosition pointerPosition() {
   return where;
 }
 
-WindowBounds windowBounds() {
+WindowBounds windowBounds(facebook::react::SurfaceId id) {
   WindowBounds bounds;
-  HWND target = window();
+  HWND target = window(id);
   if (target == nullptr) {
     return bounds;
   }
@@ -138,8 +161,8 @@ WindowBounds windowBounds() {
   return bounds;
 }
 
-void setWindowSize(double width, double height) {
-  HWND target = window();
+void setWindowSize(facebook::react::SurfaceId id, double width, double height) {
+  HWND target = window(id);
   if (target == nullptr || width <= 0.0 || height <= 0.0) {
     return;
   }
@@ -160,8 +183,8 @@ void setWindowSize(double width, double height) {
                SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
 }
 
-void setWindowPosition(double x, double y) {
-  HWND target = window();
+void setWindowPosition(facebook::react::SurfaceId id, double x, double y) {
+  HWND target = window(id);
   if (target == nullptr) {
     return;
   }
@@ -174,8 +197,8 @@ void setWindowPosition(double x, double y) {
                SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
 }
 
-void centerWindow() {
-  HWND target = window();
+void centerWindow(facebook::react::SurfaceId id) {
+  HWND target = window(id);
   if (target == nullptr) {
     return;
   }
@@ -200,8 +223,8 @@ void centerWindow() {
   SetWindowPos(target, nullptr, x, y, 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
 }
 
-void setWindowFullScreen(bool fullScreen) {
-  HWND target = window();
+void setWindowFullScreen(facebook::react::SurfaceId id, bool fullScreen) {
+  HWND target = window(id);
   if (target == nullptr) {
     return;
   }
@@ -252,7 +275,7 @@ void setWindowFullScreen(bool fullScreen) {
 }
 
 void applyWindowSizeLimits() {
-  HWND target = window();
+  HWND target = win32AppWindow();
   if (target == nullptr) {
     return;
   }
@@ -275,7 +298,7 @@ void applyWindowSizeLimits() {
 }
 
 void setWindowResizable(bool resizable) {
-  HWND target = window();
+  HWND target = win32AppWindow();
   if (target == nullptr) {
     return;
   }
@@ -303,7 +326,7 @@ void setWindowResizable(bool resizable) {
 }
 
 void setWindowAlwaysOnTop(bool alwaysOnTop) {
-  HWND target = window();
+  HWND target = win32AppWindow();
   if (target == nullptr) {
     return;
   }

package/native/win32/Win32WindowModule.cpp

@@ -96,24 +96,19 @@ Win32WindowModule::Win32WindowModule(std::shared_ptr<facebook::react::CallInvoke
   // The window's geometry, the same way the title bar's metrics go out: a
   // device event, so `useWindow()` can hand an app live bounds rather than a
   // snapshot it has to remember to refresh.
-  setWindowBoundsListener([this](const WindowBounds &bounds) {
-    emitDeviceEvent(kWindowBoundsEvent, [bounds](Runtime &runtime, std::vector<Value> &args) {
-      Object object(runtime);
-      object.setProperty(runtime, "x", bounds.x);
-      object.setProperty(runtime, "y", bounds.y);
-      object.setProperty(runtime, "width", bounds.width);
-      object.setProperty(runtime, "height", bounds.height);
-      object.setProperty(runtime, "fullScreen", bounds.fullScreen);
-      object.setProperty(runtime, "maximized", bounds.maximized);
-      args.emplace_back(Value(runtime, object));
-    });
-  });
+  setWindowBoundsListener(
+      [this](facebook::react::SurfaceId window, const WindowBounds &bounds) {
+        emitDeviceEvent(kWindowBoundsEvent,
+                        [window, bounds](Runtime &runtime, std::vector<Value> &args) {
+                          args.emplace_back(windowBoundsPayload(runtime, window, bounds));
+                        });
+      });
 
   // And ask for the bounds once, now that something is listening. The host
   // primes the cache when its window appears, but this module is built lazily
   // -- the first time JavaScript asks for it -- so an app that mounts before
   // then would read a window of no size and never be told otherwise.
-  postToUiThread([] { notifyWindowBoundsChanged(); });
+  postToUiThread([] { notifyWindowBoundsChanged(resolveWindow(kAppWindow)); });
 }
 
 Win32WindowModule::~Win32WindowModule() {

package/native/win32/main_win32.cpp

@@ -65,6 +65,7 @@
 #endif
 #include "Win32Packaging.h"
 #include "PointerButtons.h"
+#include "Win32AppWindow.h"
 #include "WindowControl.h"
 #include "SystemLocale.h"
 #include "WindowHost.h"
@@ -1457,7 +1458,12 @@ LRESULT CALLBACK hostProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)
     // it needs its own case: WM_SIZE would never arrive, and `center()` would
     // look like it had done nothing.
     case WM_MOVE:
-      basalt::notifyWindowBoundsChanged();
+      // Which window moved. `self` is null for the messages CreateWindowEx
+      // sends before the window is in the list, and a move among those is not
+      // one an app can see.
+      if (self != nullptr) {
+        basalt::notifyWindowBoundsChanged(self->surfaceId);
+      }
       return 0;
 
     // `AppState`: whether this application is the one in front. Windows sends
@@ -1505,8 +1511,8 @@ LRESULT CALLBACK hostProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)
         }
         // The window moved or was resized, which `useWindow()` hands an app as live
         // bounds. Here rather than in a watcher of its own: this is already the one
-        // place that learns it.
-        basalt::notifyWindowBoundsChanged();
+        // place that learns it, and it already knows which window it was.
+        basalt::notifyWindowBoundsChanged(self->surfaceId);
         // The inspector covers the main window, so it resizes with it -- and
         // only with it: an error is about the app rather than about a window.
         if (gHost.logBoxRoot != nullptr && self->surfaceId == kSurfaceId) {
@@ -2141,11 +2147,14 @@ facebook::react::SurfaceId openHostWindow(const NewWindowOptions &options) {
 
   gHost.reactHost->startSurface(surfaceId,
                                 options.component,
-                                options.props,
+                                windowRootProps(options, surfaceId),
                                 constraintsFor(width, height),
                                 layoutContextFor(gHost.scaleFactor));
   ShowWindow(made->window, SW_SHOW);
   UpdateWindow(made->window);
+  // Prime this window's bounds the way the main window's are primed at
+  // startup; see the call beside that one.
+  basalt::notifyWindowBoundsChanged(surfaceId);
   std::fprintf(stderr,
                "opened window %d for module %s\n",
                static_cast<int>(surfaceId),
@@ -2369,10 +2378,18 @@ int main(int argc, char **argv) {
   // being visible.
   gHost.mountingManager->setOnDidMount(syncPeersAndRepaint);
 
+  // How the window module finds a window by id, and which one a call that
+  // names none means. See Win32AppWindow.h.
+  basalt::setWin32AppWindowLookup([](facebook::react::SurfaceId surfaceId) -> HWND {
+    HostWindow *found = gHost.windowFor(surfaceId);
+    return found == nullptr ? nullptr : found->window;
+  });
+  basalt::setAppWindowId(kSurfaceId);
+
   // Prime the bounds cache, which `getBounds()` answers from: without this an
   // app's first render sees a window of no size, and only a later resize
   // corrects it. See core/WindowBoundsCache.cpp.
-  basalt::notifyWindowBoundsChanged();
+  basalt::notifyWindowBoundsChanged(kSurfaceId);
 
   // And the display list, for the same reason and off the same seam: an app
   // asking which screens exist before anything has been plugged or unplugged

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "basalt-win32",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "The Windows view layer for basalt-core: a Win32 and Direct2D view layer, a Fabric mounting manager, and a host. Everything behind them is in basalt-core.",
   "license": "MIT",
   "repository": {
@@ -22,6 +22,6 @@
     "react-native": "*"
   },
   "dependencies": {
-    "basalt-core": "0.2.2"
+    "basalt-core": "0.2.3"
   }
 }