basalt-win32 0.2.1 → 0.2.3

package/native/tests/test_win32_run_loop.cpp

@@ -0,0 +1,122 @@
+// The message loop, and the one thing it has to get right that is not
+// obvious. See win32/Win32RunLoopObserver.h.
+
+#include "TestHarness.h"
+
+#include "Win32RunLoopObserver.h"
+
+#include <windows.h>
+
+#include <chrono>
+
+namespace {
+
+constexpr UINT kFlood = WM_APP + 11;
+
+// A message-only window whose only message reposts itself, so the queue is
+// never observed empty. `flooding` ends it, since a message still in the
+// queue when the loop stops would be pumped by whatever runs next.
+bool gFlooding = true;
+long gFlooded = 0;
+
+LRESULT CALLBACK floodProc(HWND hwnd, UINT message, WPARAM w, LPARAM l) {
+  if (message == kFlood) {
+    gFlooded++;
+    // A ceiling, so that a loop which never beats fails rather than hangs:
+    // the beat is what stops the flood and posts WM_QUIT, and a regression
+    // here is precisely a beat that never happens.
+    if (gFlooded > 50000) {
+      gFlooding = false;
+    }
+    if (gFlooding) {
+      PostMessageW(hwnd, kFlood, 0, 0);
+    }
+    return 0;
+  }
+  return DefWindowProcW(hwnd, message, w, l);
+}
+
+HWND makeFloodWindow() {
+  WNDCLASSEXW windowClass{};
+  windowClass.cbSize = sizeof(windowClass);
+  windowClass.lpfnWndProc = floodProc;
+  windowClass.hInstance = GetModuleHandleW(nullptr);
+  windowClass.lpszClassName = L"BasaltRunLoopFloodTest";
+  RegisterClassExW(&windowClass);
+  return CreateWindowExW(0,
+                         L"BasaltRunLoopFloodTest",
+                         L"",
+                         0,
+                         0,
+                         0,
+                         0,
+                         0,
+                         HWND_MESSAGE,
+                         nullptr,
+                         GetModuleHandleW(nullptr),
+                         nullptr);
+}
+
+void dropFloodWindow(HWND window) {
+  gFlooding = false;
+  DestroyWindow(window);
+  UnregisterClassW(L"BasaltRunLoopFloodTest", GetModuleHandleW(nullptr));
+  // Whatever is left of the flood, so the next test's pump does not inherit
+  // it.
+  MSG message;
+  while (PeekMessageW(&message, nullptr, 0, 0, PM_REMOVE)) {
+  }
+}
+
+} // namespace
+
+TEST(run_loop_beats_once_when_the_queue_empties) {
+  int beats = 0;
+  PostMessageW(nullptr, WM_NULL, 0, 0);
+  const int code = basalt::runMessageLoop([&beats] {
+    beats++;
+    PostQuitMessage(7);
+  });
+  EXPECT_EQ(code, 7);
+  EXPECT_EQ(beats, 1);
+}
+
+TEST(run_loop_beats_on_a_queue_that_never_empties) {
+  // The regression this file exists for.
+  //
+  // The loop drains before it beats, which is what "BeforeWaiting" means and
+  // what React Native's event queue is flushed by. An app that paints
+  // continuously -- kino, whose preview is a Skia `<Canvas>`: 120 WM_PAINT
+  // and 250 posted work items a second while idle -- never lets the drain
+  // finish, so the beat never ran and events sat in the queue. What that
+  // looked like from outside was a button that usually worked: one scripted
+  // tap in three did nothing, and a real click rather more often than that.
+  //
+  // Without the bound in the loop this test does not fail slowly. It never
+  // beats at all, so it never posts WM_QUIT, and the deadline below is the
+  // only thing that ends it.
+  gFlooding = true;
+  gFlooded = 0;
+  HWND window = makeFloodWindow();
+  EXPECT(window != nullptr);
+  PostMessageW(window, kFlood, 0, 0);
+
+  int beats = 0;
+  const auto deadline = std::chrono::steady_clock::now() + std::chrono::seconds(2);
+  basalt::runMessageLoop([&] {
+    beats++;
+    // Several, so this is about a loop that keeps beating rather than one
+    // that beat once on the way in.
+    if (beats >= 4 || std::chrono::steady_clock::now() > deadline) {
+      gFlooding = false;
+      PostQuitMessage(0);
+    }
+  });
+
+  EXPECT(beats >= 4);
+  // ...and the flood really was running, so the beats above happened in spite
+  // of it rather than after it ran out.
+  EXPECT(gFlooded > 100);
+
+  dropFloodWindow(window);
+}

package/native/tests/test_win32_textinput.cpp

@@ -33,6 +33,8 @@
 
 #include <cstdint>
 #include <memory>
+#include <optional>
+#include <sstream>
 #include <string>
 #include <utility>
 #include <vector>
@@ -177,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,
@@ -194,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;
   }
@@ -326,6 +334,34 @@ RECT rectOf(HWND control) {
   return rect;
 }
 
+// The window region installed on a control, as the box around it, in the
+// control's own coordinates. Absent when the control has no region at all,
+// which is what a whole unobstructed field gets.
+//
+// An empty box -- `0,0 0,0` -- is a region with nothing in it, which is a
+// field that is entirely behind something.
+std::optional<RECT> regionBoxOf(HWND control) {
+  HRGN region = CreateRectRgn(0, 0, 0, 0);
+  const int kind = GetWindowRgn(control, region);
+  std::optional<RECT> box;
+  // GDI's `ERROR` is zero, and the name is not reachable here: this build
+  // defines GLOG_NO_ABBREVIATED_SEVERITIES, which is what keeps glog from
+  // fighting wingdi.h over it, and wingdi.h's own definition loses to it.
+  if (kind != 0) {
+    RECT rect{0, 0, 0, 0};
+    GetRgnBox(region, &rect);
+    box = rect;
+  }
+  DeleteObject(region);
+  return box;
+}
+
+std::string describeRect(const RECT &rect) {
+  std::ostringstream out;
+  out << rect.left << "," << rect.top << " " << rect.right << "," << rect.bottom;
+  return out.str();
+}
+
 } // namespace
 
 // A mounted field gets a real control, and the host's window is its parent.
@@ -576,6 +612,84 @@ TEST(win32_a_peer_scrolled_out_of_view_is_hidden) {
   manager->destroySurfaceRoot(kSurfaceId);
 }
 
+// Half out of its list is half drawn, which hiding it entirely was never the
+// same as. A window region is what says so to USER32; see Win32PeerClip.h.
+//
+// The field is multiline so that the control fills its box exactly -- a
+// single-line peer is a strip the height of one line, centred, and these
+// numbers would then be the font's.
+TEST(win32_a_peer_half_out_of_its_list_is_clipped_to_it) {
+  auto manager = makeManager();
+  RnWin32View *root = manager->createSurfaceRoot(kSurfaceId);
+  root->setFrame(0, 0, 800, 600);
+  mount(*manager, kSurfaceId, makeView(10, 0, 0, 400, 100));
+  manager->viewForTag(10)->setClipsChildren(true);
+  mount(*manager, 10, makeField(11, 0, 60, 200, 80, {.multiline = true}));
+  manager->syncTextInputBounds(root);
+
+  HWND control = peerOf(manager->viewForTag(11));
+  EXPECT_EQ(describeRect(rectOf(control)), std::string("0,60 200,140"));
+  // The list ends at y=100, so the bottom 40 of the field is not the field's.
+  const auto clipped = regionBoxOf(control);
+  EXPECT(clipped.has_value());
+  EXPECT_EQ(describeRect(clipped.value_or(RECT{})), std::string("0,0 200,40"));
+
+  // Scrolled until it is wholly inside, the region goes away rather than
+  // becoming the whole control: SetWindowRgn redraws, and a field in a list
+  // being scrolled would otherwise be told to on every notch.
+  manager->viewForTag(10)->setScrollOffset(0, 60);
+  manager->syncTextInputBounds(root);
+  EXPECT(!regionBoxOf(control).has_value());
+
+  manager->destroySurfaceRoot(kSurfaceId);
+}
+
+// A field cannot be covered by anything the tree paints after it, because the
+// peer is a child window and USER32 draws those last. Open a modal over a pane
+// with a field in it and the field floats on top of the modal, still editable.
+// Taking the modal's box out of the region is what stops that.
+TEST(win32_a_peer_under_something_painted_later_is_cut_away) {
+  auto manager = makeManager();
+  RnWin32View *root = manager->createSurfaceRoot(kSurfaceId);
+  root->setFrame(0, 0, 800, 600);
+  // The backdrop is mounted first and the field second, and both go in at
+  // index 0 -- so the children end up [field, backdrop] and the backdrop is
+  // painted after, which is where an overlay sits in a React tree.
+  mount(*manager, kSurfaceId, makeView(10, 0, 0, 800, 600));
+  mount(*manager, kSurfaceId, makeField(11, 0, 0, 200, 80, {.multiline = true}));
+  manager->syncTextInputBounds(root);
+
+  HWND control = peerOf(manager->viewForTag(11));
+  // A layout wrapper with no background of its own covers nothing, which is
+  // most of a real tree and the reason this rule is quiet in one.
+  EXPECT(!regionBoxOf(control).has_value());
+
+  // kino's modal scrim: #000000A0 over the whole window. Translucent counts --
+  // a child window cannot be dimmed by paint, so the choice is between showing
+  // it undimmed and hiding it, and hiding it is the better wrong answer.
+  manager->viewForTag(10)->setBackgroundColor(0.0f, 0.0f, 0.0f, 0.63f, true);
+  manager->syncTextInputBounds(root);
+  // Wholly behind it is hidden rather than given a region with nothing in it:
+  // the two look the same and only one of them stops Windows thinking there is
+  // a window there.
+  EXPECT(!IsWindowVisible(control));
+  EXPECT(!regionBoxOf(control).has_value());
+
+  // Half over it leaves the other half.
+  manager->viewForTag(10)->setFrame(0, 40, 800, 600);
+  manager->syncTextInputBounds(root);
+  const auto half = regionBoxOf(control);
+  EXPECT(half.has_value());
+  EXPECT_EQ(describeRect(half.value_or(RECT{})), std::string("0,0 200,40"));
+
+  // And once the modal closes the region goes with it.
+  manager->viewForTag(10)->setBackgroundColor(0.0f, 0.0f, 0.0f, 0.0f, false);
+  manager->syncTextInputBounds(root);
+  EXPECT(!regionBoxOf(control).has_value());
+
+  manager->destroySurfaceRoot(kSurfaceId);
+}
+
 // focus, blur and setTextAndSelection, which arrive through dispatchCommand.
 TEST(win32_the_commands_reach_the_control) {
   auto manager = makeManager();
@@ -781,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/tests/test_win32_ui_timer.cpp

@@ -0,0 +1,195 @@
+// Timers that arrive, including under the one condition that broke the ones
+// before them. See win32/Win32UiTimer.h.
+
+#include "TestHarness.h"
+
+#include "Win32UiThread.h"
+#include "Win32UiTimer.h"
+
+#include <windows.h>
+
+#include <chrono>
+#include <functional>
+#include <thread>
+
+namespace {
+
+// A real message loop for the duration of one test. Without one there is
+// nothing to post to, `scheduleUiTimer` declines, and every assertion below
+// would be about the declining rather than about the timer.
+struct ScopedUiThread {
+  ScopedUiThread() { basalt::installUiThread(); }
+  ~ScopedUiThread() { basalt::uninstallUiThread(); }
+  ScopedUiThread(const ScopedUiThread &) = delete;
+  ScopedUiThread &operator=(const ScopedUiThread &) = delete;
+};
+
+// Pumps until `ready`, or until the deadline. Returns whether it came true.
+//
+// The inner drain is bounded rather than "until the queue is empty", which
+// the real loop can afford and this cannot: one test here feeds the queue a
+// message that reposts itself, and an unbounded drain never comes back out.
+bool pumpUntil(const std::function<bool()> &ready) {
+  const auto deadline = std::chrono::steady_clock::now() + std::chrono::seconds(5);
+  while (std::chrono::steady_clock::now() < deadline) {
+    MSG message;
+    for (int drained = 0; drained < 64; drained++) {
+      if (!PeekMessageW(&message, nullptr, 0, 0, PM_REMOVE)) {
+        break;
+      }
+      TranslateMessage(&message);
+      DispatchMessageW(&message);
+    }
+    if (ready()) {
+      return true;
+    }
+    std::this_thread::sleep_for(std::chrono::milliseconds(1));
+  }
+  return false;
+}
+
+} // namespace
+
+TEST(ui_timer_fires_once_after_its_delay) {
+  ScopedUiThread loop;
+  int fired = 0;
+  const basalt::UiTimerId timer = basalt::scheduleUiTimer(10, false, [&fired] { fired++; });
+  EXPECT(timer != 0);
+  EXPECT(pumpUntil([&fired] { return fired > 0; }));
+  // And exactly once: a one-shot that repeated would be found by nothing else
+  // here, because every other assertion is satisfied by the first call.
+  const auto until = std::chrono::steady_clock::now() + std::chrono::milliseconds(120);
+  pumpUntil([&until] { return std::chrono::steady_clock::now() > until; });
+  EXPECT_EQ(fired, 1);
+  basalt::cancelUiTimer(timer);
+}
+
+TEST(ui_timer_repeats_until_it_is_cancelled) {
+  ScopedUiThread loop;
+  int fired = 0;
+  const basalt::UiTimerId timer = basalt::scheduleUiTimer(5, true, [&fired] { fired++; });
+  EXPECT(timer != 0);
+  EXPECT(pumpUntil([&fired] { return fired >= 3; }));
+  basalt::cancelUiTimer(timer);
+  const int afterCancel = fired;
+  const auto until = std::chrono::steady_clock::now() + std::chrono::milliseconds(80);
+  pumpUntil([&until] { return std::chrono::steady_clock::now() > until; });
+  EXPECT_EQ(fired, afterCancel);
+}
+
+TEST(ui_timer_can_be_cancelled_from_inside_its_own_callback) {
+  // How a repeating animation ends: the last frame stops the thing that
+  // delivered it. `cancelUiTimer` waits out a pool-thread delivery, so doing
+  // this on the wrong thread would deadlock rather than misbehave.
+  ScopedUiThread loop;
+  int fired = 0;
+  basalt::UiTimerId timer = 0;
+  timer = basalt::scheduleUiTimer(5, true, [&fired, &timer] {
+    fired++;
+    if (fired == 2) {
+      basalt::cancelUiTimer(timer);
+    }
+  });
+  EXPECT(pumpUntil([&fired] { return fired >= 2; }));
+  const auto until = std::chrono::steady_clock::now() + std::chrono::milliseconds(80);
+  pumpUntil([&until] { return std::chrono::steady_clock::now() > until; });
+  EXPECT_EQ(fired, 2);
+}
+
+TEST(ui_timer_arrives_on_a_queue_that_never_empties) {
+  // The whole reason this file exists.
+  //
+  // `WM_TIMER` is not posted. It is *synthesised* by `PeekMessage`, and only
+  // once the queue holds nothing else -- below posted messages, below input,
+  // below `WM_PAINT`. A loop that always has something to do therefore never
+  // gives a `WM_TIMER` the gap it needs, and every `SetTimer` in the host
+  // simply stopped. That is the ordinary condition of a real app: measured on
+  // kino, whose preview is a Skia `<Canvas>`, 120 `WM_PAINT` and 250 posted
+  // work items a second while idle, against six `WM_TIMER` in twenty-five
+  // seconds.
+  //
+  // Reproduced here with a message that reposts itself, which is the same
+  // queue condition as the painting without needing a window on screen.
+  ScopedUiThread loop;
+
+  constexpr UINT kFlood = WM_APP + 7;
+  static long flooded = 0;
+  static long ticked = 0;
+  // Cleared before the window goes, so the self-reposting message stops
+  // rather than outliving this test in the queue the next one pumps.
+  static bool flooding = true;
+  flooded = 0;
+  ticked = 0;
+  flooding = true;
+
+  WNDCLASSEXW windowClass{};
+  windowClass.cbSize = sizeof(windowClass);
+  windowClass.lpfnWndProc = [](HWND hwnd, UINT message, WPARAM w, LPARAM l) -> LRESULT {
+    if (message == kFlood) {
+      flooded++;
+      // Posted again before this one is finished with, so the queue is never
+      // observed empty. Which is the condition under test.
+      if (flooding) {
+        PostMessageW(hwnd, kFlood, 0, 0);
+      }
+      return 0;
+    }
+    if (message == WM_TIMER) {
+      ticked++;
+      return 0;
+    }
+    return DefWindowProcW(hwnd, message, w, l);
+  };
+  windowClass.hInstance = GetModuleHandleW(nullptr);
+  windowClass.lpszClassName = L"BasaltUiTimerBusyTest";
+  RegisterClassExW(&windowClass);
+  HWND window = CreateWindowExW(0,
+                                L"BasaltUiTimerBusyTest",
+                                L"",
+                                0,
+                                0,
+                                0,
+                                0,
+                                0,
+                                HWND_MESSAGE,
+                                nullptr,
+                                GetModuleHandleW(nullptr),
+                                nullptr);
+  EXPECT(window != nullptr);
+  PostMessageW(window, kFlood, 0, 0);
+
+  // The platform's own timer, for the comparison. Ten milliseconds, so a
+  // working one would fire many times over what follows.
+  SetTimer(window, 1, 10, nullptr);
+
+  int fired = 0;
+  const basalt::UiTimerId timer = basalt::scheduleUiTimer(10, false, [&fired] { fired++; });
+  EXPECT(pumpUntil([&fired] { return fired > 0; }));
+
+  // The flood really did run, so the pass above means the timer arrived
+  // through a busy queue rather than through a quiet one.
+  EXPECT(flooded > 100);
+  // ...and the comparison. If this ever starts firing, Windows has changed
+  // its message priorities and this whole file is worth re-reading rather
+  // than the assertion being worth relaxing.
+  EXPECT_EQ(static_cast<int>(ticked), 0);
+
+  flooding = false;
+  KillTimer(window, 1);
+  basalt::cancelUiTimer(timer);
+  DestroyWindow(window);
+  UnregisterClassW(L"BasaltUiTimerBusyTest", GetModuleHandleW(nullptr));
+}
+
+TEST(ui_timer_declines_when_there_is_no_loop_to_post_to) {
+  // No ScopedUiThread. Delivering here would mean running the callback on a
+  // thread pool, which is how the rest of this suite -- written against
+  // inline posting on one thread -- would start failing at random.
+  int fired = 0;
+  EXPECT_EQ(static_cast<int>(basalt::scheduleUiTimer(1, false, [&fired] { fired++; })), 0);
+  std::this_thread::sleep_for(std::chrono::milliseconds(30));
+  EXPECT_EQ(fired, 0);
+  // And cancelling nothing is allowed, which is what lets a caller keep one
+  // id in a field and cancel it without asking whether it ever started.
+  basalt::cancelUiTimer(0);
+}

package/native/win32/PlatformServicesWin32.cpp

@@ -116,6 +116,22 @@ bool hasUiThread() {
   return uiThread().window != nullptr;
 }
 
+void uninstallUiThread() {
+  HWND window = uiThread().window;
+  if (window == nullptr) {
+    return;
+  }
+  // Cleared before the window is destroyed, so that anything posted from
+  // another thread between these two lines runs inline rather than through a
+  // PostMessage to a handle that is going away.
+  uiThread().window = nullptr;
+  uiThread().threadId = std::thread::id{};
+  DestroyWindow(window);
+  // And whatever was queued and never pumped, which is now nobody's: running
+  // it here is what the no-window path would have done with it anyway.
+  drainPendingWork();
+}
+
 bool isUiThread() {
   // With no UI thread installed there is only one thread that matters, so
   // saying yes is both true and what keeps the tests from marshalling into a

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

@@ -160,6 +160,13 @@ class RnWin32View {
   // as transparent black: a view with no background does not paint at all.
   void setBackgroundColor(float red, float green, float blue, float alpha, bool hasColor);
   bool hasBackgroundColor() const { return hasBackgroundColor_; }
+  // The four components, in the order they were set. Only meaningful when
+  // `hasBackgroundColor()`; a view without one has never written them.
+  //
+  // Read by Win32PeerClip, which has to know whether a view painted over a
+  // `<TextInput>` covers it, and that is the alpha. Painting itself does not
+  // need the accessor -- it is a member and reads the array directly.
+  const float *backgroundColor() const { return backgroundColor_; }
 
   void setOpacity(float opacity);
   float opacity() const { return opacity_; }
@@ -424,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.
@@ -798,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};