basalt-win32 0.2.1 → 0.2.3

package/native/win32/Win32RunLoopObserver.cpp

@@ -4,28 +4,49 @@
 
 #include <react/utils/RunLoopObserverManager.h>
 
+#include <chrono>
+
 namespace basalt {
 
-int runMessageLoopWithBeat(
-    std::shared_ptr<facebook::react::RunLoopObserverManager> manager) {
+int runMessageLoop(const std::function<void()> &beat) {
   MSG message{};
+
   for (;;) {
-    // Drain everything queued before beating. Beating between each message
-    // would be correct but wasteful, and beating *after* the queue is empty is
-    // what "BeforeWaiting" means -- the frame has settled, and whatever the
-    // messages produced is now worth flushing to JavaScript in one go.
+    // Drain what is queued before beating. Beating between each message would
+    // be correct but wasteful, and beating *after* the queue is empty is what
+    // "BeforeWaiting" means -- the frame has settled, and whatever the messages
+    // produced is now worth flushing to JavaScript in one go.
+    //
+    // Bounded, though: "after the queue is empty" is a moment that never comes
+    // in an app that paints continuously, and an event waiting for it waits
+    // forever. See the header for what that cost -- a button that usually
+    // worked.
+    auto since = std::chrono::steady_clock::now();
+    int drained = 0;
     while (PeekMessageW(&message, nullptr, 0, 0, PM_REMOVE)) {
       if (message.message == WM_QUIT) {
         return static_cast<int>(message.wParam);
       }
       TranslateMessage(&message);
       DispatchMessageW(&message);
-    }
 
-    if (manager != nullptr) {
-      manager->onRender();
+      // The count is checked first because it is free, and the clock only
+      // every `kBeatEveryMessages` messages, so a busy drain does not spend
+      // itself in `steady_clock::now`.
+      if (++drained < kBeatEveryMessages) {
+        continue;
+      }
+      drained = 0;
+      const auto now = std::chrono::steady_clock::now();
+      if (now - since < std::chrono::milliseconds(kBeatEveryMs)) {
+        continue;
+      }
+      since = now;
+      beat();
     }
 
+    beat();
+
     // Block until something arrives. MsgWaitForMultipleObjectsEx rather than
     // GetMessage, because the beat above may itself have posted work -- a mount
     // marshalled from the JS thread arrives as a posted message -- and
@@ -45,4 +66,13 @@ int runMessageLoopWithBeat(
   }
 }
 
+int runMessageLoopWithBeat(
+    std::shared_ptr<facebook::react::RunLoopObserverManager> manager) {
+  return runMessageLoop([&manager] {
+    if (manager != nullptr) {
+      manager->onRender();
+    }
+  });
+}
+
 } // namespace basalt

package/native/win32/Win32RunLoopObserver.h

@@ -24,9 +24,32 @@
 //
 // So this is a loop rather than an observer, and the host calls it instead of
 // writing its own.
+//
+// ## "Until it comes up empty" is not enough on its own
+//
+// That rule assumes the queue eventually comes up empty, and in a real app it
+// does not. kino's editor, whose preview is a Skia `<Canvas>`, posts work from
+// the JavaScript thread around 250 times a second and invalidates its window
+// around 120 -- so `PeekMessage` keeps answering, the drain keeps draining,
+// and the beat below it waits for a gap that never comes. The queue is a
+// treadmill and the beat is at the end of it.
+//
+// What that looks like from outside is the worst kind of bug: a button that
+// usually works. The touch was hit-tested, the emitter was found, the event
+// was enqueued -- and then sat in the queue until some accident of timing let
+// the loop reach the bottom. Measured on that app, one scripted tap in three
+// did nothing at all, and a real click, which lands later in a run and under
+// more load, did nothing far more often than that.
+//
+// So the drain is bounded: the beat also happens every `kBeatEveryMs` and
+// every `kBeatEveryMessages`, whichever comes first. Neither number is a
+// tuning parameter to get right -- they are an upper bound on how long an
+// event may sit, and the cost of beating early is one pass over an empty
+// queue.
 
 #pragma once
 
+#include <functional>
 #include <memory>
 
 namespace facebook::react {
@@ -35,8 +58,24 @@ class RunLoopObserverManager;
 
 namespace basalt {
 
-// Runs until WM_QUIT, inducing the beat each time the queue empties. Returns
-// the exit code from WM_QUIT.
+// How long an event may wait, and how many messages may go by, before the
+// beat happens whether or not the queue has emptied. Eight milliseconds is
+// half a frame at sixty hertz: an event enqueued at the worst moment still
+// reaches JavaScript inside the frame it belongs to.
+inline constexpr unsigned kBeatEveryMs = 8;
+inline constexpr int kBeatEveryMessages = 64;
+
+// Runs until WM_QUIT, calling `beat` each time the queue empties -- and, on a
+// queue that does not empty, at least every `kBeatEveryMs`. Returns the exit
+// code from WM_QUIT.
+//
+// The beat is a parameter rather than the manager itself because the bound
+// above is the whole point of this file and a test needs to be able to count
+// beats. `beat` may post WM_QUIT, which is how a test ends the loop.
+int runMessageLoop(const std::function<void()> &beat);
+
+// The host's own entry point: the loop above, beating React Native's event
+// queue. A null manager runs the loop with nothing to beat.
 int runMessageLoopWithBeat(std::shared_ptr<facebook::react::RunLoopObserverManager> manager);
 
 } // namespace basalt

package/native/win32/Win32ScrollView.cpp

@@ -6,6 +6,7 @@
 #include <utility>
 
 #include "PlatformServices.h"
+#include "Win32UiTimer.h"
 
 #include <react/renderer/components/scrollview/ScrollEvent.h>
 #include <react/renderer/components/scrollview/ScrollViewEventEmitter.h>
@@ -437,34 +438,6 @@ void Win32ScrollViewManager::endWheelDrag(Tag tag, std::uint64_t generation) {
 // Offset, events and state
 // ---------------------------------------------------------------------------
 
-namespace {
-
-// Which manager and view a timer is animating. A TIMERPROC carries no state, so
-// the id is the key -- and the map is the reason `stopAnimation` must run before
-// an entry goes, exactly as the display link does on AppKit.
-std::unordered_map<UINT_PTR, std::pair<Win32ScrollViewManager *, facebook::react::Tag>> &
-animations() {
-  static std::unordered_map<UINT_PTR, std::pair<Win32ScrollViewManager *, facebook::react::Tag>>
-      value;
-  return value;
-}
-
-} // namespace
-
-void CALLBACK Win32ScrollViewManager::onAnimationTimer(HWND /*hwnd*/,
-                                                       UINT /*message*/,
-                                                       UINT_PTR id,
-                                                       DWORD now) {
-  const auto it = animations().find(id);
-  if (it == animations().end()) {
-    KillTimer(nullptr, id);
-    return;
-  }
-  Win32ScrollViewManager *manager = it->second.first;
-  const facebook::react::Tag tag = it->second.second;
-  manager->advanceAnimation(tag, static_cast<double>(now) / 1000.0);
-}
-
 void Win32ScrollViewManager::scrollTowards(Entry &entry, double x, double y, bool animated) {
   stopAnimation(entry);
   if (!animated || !entry.animation.start(entry.offsetX, entry.offsetY, x, y)) {
@@ -474,14 +447,21 @@ void Win32ScrollViewManager::scrollTowards(Entry &entry, double x, double y, boo
   // Sixteen milliseconds: this host's choreographer runs on a timer of the same
   // period, and matching it keeps a scroll and an animation stepping together
   // rather than beating against each other.
-  entry.animationTimer = SetTimer(nullptr, 0, 16, onAnimationTimer);
+  //
+  // The callback carries the tag rather than being looked up from a timer id,
+  // which is what a TIMERPROC forced and what the map here used to be for.
+  const facebook::react::Tag tag = entry.tag;
+  entry.animationTimer = scheduleUiTimer(16, true, [this, tag] {
+    advanceAnimation(tag, static_cast<double>(GetTickCount64()) / 1000.0);
+  });
   if (entry.animationTimer == 0) {
+    // No loop to animate on -- the unit tests, which install none. Land on the
+    // target rather than sit half-way to it forever.
     entry.animation.stop();
     applyOffset(entry, x, y, true);
     return;
   }
   entry.animationLastMillis = 0;
-  animations()[entry.animationTimer] = {this, entry.tag};
 }
 
 bool Win32ScrollViewManager::settleOnSnapPoint(Entry &entry, double velocityY) {
@@ -500,8 +480,9 @@ bool Win32ScrollViewManager::settleOnSnapPoint(Entry &entry, double velocityY) {
 void Win32ScrollViewManager::stopAnimation(Entry &entry) {
   entry.animation.stop();
   if (entry.animationTimer != 0) {
-    KillTimer(nullptr, entry.animationTimer);
-    animations().erase(entry.animationTimer);
+    // Called from inside the animation's own callback when the scroll
+    // finishes, which `cancelUiTimer` is written to accept.
+    cancelUiTimer(entry.animationTimer);
     entry.animationTimer = 0;
   }
 }

package/native/win32/Win32ScrollView.h

@@ -153,11 +153,13 @@ class Win32ScrollViewManager {
 
     // An animated `scrollTo`. Windows models no fling -- a wheel supplies no
     // velocity -- but an animated scroll is given its target, so the argument
-    // that rules out momentum does not rule this out. Driven by a thread timer,
-    // which needs no window: the scroll manager has a tag, not an HWND.
+    // that rules out momentum does not rule this out. Driven by a
+    // win32/Win32UiTimer.h timer rather than by `SetTimer`, for the reason
+    // that header gives: a WM_TIMER at sixty hertz stops arriving in an app
+    // that repaints continuously, which is to say mid-scroll.
     ScrollSnapConfig snap;
     ScrollAnimation animation;
-    UINT_PTR animationTimer{0};
+    std::uint64_t animationTimer{0};
     unsigned long long animationLastMillis{0};
 
     std::shared_ptr<const facebook::react::ScrollViewShadowNode::ConcreteState> state;
@@ -236,9 +238,6 @@ class Win32ScrollViewManager {
   void stopAnimation(Entry &entry);
   void advanceAnimation(facebook::react::Tag tag, double seconds);
 
-  // The timer procedure cannot carry a pointer, so it looks the animation up by
-  // timer id. Static because `SetTimer` calls a plain function.
-  static void CALLBACK onAnimationTimer(HWND hwnd, UINT message, UINT_PTR id, DWORD now);
   void emitScrollEvent(Entry &entry, const char *which);
   void writeStateOffset(const Entry &entry);
 

package/native/win32/Win32SkiaPeer.h

@@ -1,4 +1,25 @@
-// The Win32 half of a `<Canvas>`: a raster surface drawn in the paint walk.
+// The Win32 half of a `<Canvas>`: a surface drawn in the paint walk.
+//
+// ## Two implementations, one pair of functions
+//
+// Both generations of react-native-skia answer to the two functions at the
+// bottom of this file, and they are never both linked: the 2.x one is
+// `Win32SkiaPeer.cpp` beside this header, compiled when core's cmake/Skia.cmake
+// found a 2.x install, and the 3.x one is basalt-skia's
+// `win32/BasaltSkiaCanvasWin32.cpp`, compiled when it found a 3.x one.
+// cmake/Skia.cmake refuses a 3.x install by version, so exactly one definition
+// of each exists. Win32MountingManager.cpp calls them under a guard that
+// covers either, the way the AppKit one does -- see AppKitSkiaPeer.h, which is
+// this arrangement on the other host.
+//
+// They differ in the component they answer to, which is 3.x's rename: a 2.x
+// `<Canvas>` mounts a `SkiaPictureView` and a 3.x one a `SkiaView`. Both
+// descriptors are registered on all three hosts.
+//
+// What follows describes the 2.x one. The 3.x one reaches the same place by a
+// different route -- it renders on the GPU through Dawn and D3D12 and reads
+// the frame back, rather than rasterising on the CPU -- and for the same
+// reason, which is the next paragraph. BasaltSkiaCanvasWin32.h has its half.
 //
 // The other two hosts give the package a layer of its own -- a CAMetalLayer on
 // macOS, a GL surface on GTK -- and let it present straight to the compositor.
@@ -39,9 +60,10 @@ namespace win32 {
 class RnWin32View;
 }
 
-// Gives `view` a Skia canvas if `shadowView` is a SkiaPictureView, updating its
-// size if it already has one. False when the component is something else, so
-// the caller can treat this as a filter rather than asking twice.
+// Gives `view` a Skia canvas if `shadowView` is a canvas view -- a
+// SkiaPictureView on 2.x, a SkiaView on 3.x -- updating its size if it
+// already has one. False when the component is something else, so the caller
+// can treat this as a filter rather than asking twice.
 //
 // `requestRepaint` is how a picture pushed from JavaScript reaches the screen.
 // Windows repaints on demand, so rendering a frame into the surface changes

package/native/win32/Win32TextInput.cpp

@@ -1,7 +1,9 @@
 #include "Win32TextInput.h"
 
 #include "DirectWriteLayout.h"
+#include "DragAndDrop.h"
 #include "TextChecking.h"
+#include "Win32PeerClip.h"
 #include "Win32InputScopes.h"
 #include "Win32Strings.h"
 
@@ -64,61 +66,37 @@ COLORREF toColorRef(const float components[4]) {
   return RGB(channel(components[0]), channel(components[1]), channel(components[2]));
 }
 
-// A view's rectangle in the surface root's coordinates, and whether any of it is
-// still visible.
+// Where a peer is placed and what of it is still the peer's: see
+// win32/Win32PeerClip.h, which is the whole of the geometry. It lives there
+// rather than here so that it can be tested against a view tree with no window
+// and no React Native, the same split Win32TitleBarLayout made.
 //
 // Translation only: an EDIT is a window and a window cannot be rotated, so a
 // transformed field's peer sits where the untransformed one would. That is a
 // real difference from the painted view behind it, and there is no cheap fix --
 // see the header.
-//
-// Visibility is the other half. A child window is not clipped by anything in
-// the React tree, so a field scrolled out of its list would otherwise go on
-// being drawn over the list's neighbours. Any clipping ancestor that the
-// rectangle has left entirely hides it.
-bool peerRect(RnWin32View *view, RnWin32View *root, RECT &out) {
-  if (view == nullptr || root == nullptr) {
-    return false;
-  }
 
-  double x = 0.0;
-  double y = 0.0;
-  const double width = view->frame().width;
-  const double height = view->frame().height;
+RECT intersectRects(const RECT &a, const RECT &b) {
+  return RECT{std::max(a.left, b.left),
+              std::max(a.top, b.top),
+              std::min(a.right, b.right),
+              std::min(a.bottom, b.bottom)};
+}
 
-  for (RnWin32View *current = view; current != nullptr; current = current->parent()) {
-    if (current->hidden()) {
-      return false;
-    }
-    if (current == root) {
-      break;
-    }
-    x += current->frame().x;
-    y += current->frame().y;
+RECT offsetBy(const RECT &rect, LONG dx, LONG dy) {
+  return RECT{rect.left + dx, rect.top + dy, rect.right + dx, rect.bottom + dy};
+}
 
-    RnWin32View *parent = current->parent();
-    if (parent == nullptr) {
-      // Detached: between a Remove and its Delete, or never inserted. Not on
-      // screen either way.
+bool sameShape(const std::vector<RECT> &a, const std::vector<RECT> &b) {
+  if (a.size() != b.size()) {
+    return false;
+  }
+  for (size_t i = 0; i < a.size(); i++) {
+    if (a[i].left != b[i].left || a[i].top != b[i].top || a[i].right != b[i].right ||
+        a[i].bottom != b[i].bottom) {
       return false;
     }
-    x -= parent->scrollX();
-    y -= parent->scrollY();
-
-    if (parent->clipsChildren()) {
-      // In the parent's own coordinates the box is 0..width, 0..height, and
-      // (x, y) is where this view now sits relative to it.
-      if (x + width <= 0 || y + height <= 0 || x >= parent->frame().width ||
-          y >= parent->frame().height) {
-        return false;
-      }
-    }
   }
-
-  out.left = static_cast<LONG>(std::lround(x));
-  out.top = static_cast<LONG>(std::lround(y));
-  out.right = out.left + static_cast<LONG>(std::lround(width));
-  out.bottom = out.top + static_cast<LONG>(std::lround(height));
   return true;
 }
 
@@ -157,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;
@@ -184,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"",
@@ -596,6 +604,9 @@ void Win32TextInputManager::destroyPeer(Entry &entry) {
     DestroyWindow(entry.control);
     entry.control = nullptr;
   }
+  // The window took the region with it, and a rebuilt peer -- which is what a
+  // field switching to multiline gets -- starts without one.
+  entry.regionShape.clear();
   if (entry.font != nullptr) {
     DeleteObject(entry.font);
     entry.font = nullptr;
@@ -630,11 +641,12 @@ void Win32TextInputManager::syncBounds(RnWin32View *root) {
     if (entry.control == nullptr) {
       continue;
     }
-    RECT rect{};
-    if (!peerRect(entry.view, root, rect)) {
+    const win32::PeerClip placement = win32::peerClip(entry.view, root);
+    if (!placement.visible) {
       ShowWindow(entry.control, SW_HIDE);
       continue;
     }
+    RECT rect = placement.bounds;
 
     // Inside the content insets, so that `paddingHorizontal` on a field means
     // what it means on a <View>. GTK allocates its GtkText inside the same
@@ -673,6 +685,74 @@ void Win32TextInputManager::syncBounds(RnWin32View *root) {
       continue;
     }
 
+    // What of the control is still the control's, in its own coordinates: the
+    // part of it inside every clipping ancestor, less everything painted over
+    // it. See Win32PeerClip.h -- this is the half that turns those rectangles
+    // into the one thing USER32 understands, which is a window region.
+    //
+    // The first piece is what is left of the control, and each one after it is
+    // taken out.
+    std::vector<RECT> shape;
+    const RECT visible = offsetBy(intersectRects(placement.clip, rect), -rect.left, -rect.top);
+    if (visible.right > visible.left && visible.bottom > visible.top) {
+      shape.push_back(visible);
+      for (const RECT &occluder : placement.occluders) {
+        const RECT over = offsetBy(intersectRects(occluder, rect), -rect.left, -rect.top);
+        if (over.right > over.left && over.bottom > over.top) {
+          shape.push_back(over);
+        }
+      }
+    }
+
+    // Whole and unobstructed is the common case and gets no region at all:
+    // `SetWindowRgn` redraws the control, and this runs after every wheel
+    // notch, so a field in a list being scrolled would otherwise be told to
+    // redraw sixty times a second for a shape that has not changed.
+    HRGN region = nullptr;
+    const bool whole = shape.size() == 1 && shape[0].left == 0 && shape[0].top == 0 &&
+        shape[0].right == rect.right - rect.left && shape[0].bottom == rect.bottom - rect.top;
+    if (whole) {
+      shape.clear();
+    } else if (!shape.empty()) {
+      // The system owns the region once it is handed over, so the pieces taken
+      // out of it are deleted here and the result is not.
+      region = CreateRectRgn(shape[0].left, shape[0].top, shape[0].right, shape[0].bottom);
+      for (size_t i = 1; i < shape.size(); i++) {
+        HRGN piece = CreateRectRgn(shape[i].left, shape[i].top, shape[i].right, shape[i].bottom);
+        CombineRgn(region, region, piece, RGN_DIFF);
+        DeleteObject(piece);
+      }
+      RECT box{};
+      if (GetRgnBox(region, &box) == NULLREGION) {
+        // The pieces swallowed it: the field is wholly behind something rather
+        // than partly, which is what a modal over a pane looks like.
+        DeleteObject(region);
+        region = nullptr;
+        shape.clear();
+        ShowWindow(entry.control, SW_HIDE);
+        entry.regionShape.clear();
+        SetWindowRgn(entry.control, nullptr, FALSE);
+        // And it does not keep the keyboard. A field left focused behind a
+        // modal swallows every key the modal wanted, Escape included, so the
+        // sheet that covered it cannot be closed -- the same bug as the field
+        // being visible over the modal, one layer further in. The question does
+        // not arise on the other two desktops: a field there is a widget, and a
+        // widget that is not drawn is not in the focus chain.
+        if (GetFocus() == entry.control) {
+          moveFocusToHost();
+        }
+        continue;
+      }
+    } else {
+      // Out of sight behind a clipping ancestor, which `placement.visible`
+      // catches when it is complete and this catches when the control's own
+      // strip is what fell outside.
+      ShowWindow(entry.control, SW_HIDE);
+      entry.regionShape.clear();
+      SetWindowRgn(entry.control, nullptr, FALSE);
+      continue;
+    }
+
     SetWindowPos(entry.control,
                  nullptr,
                  rect.left,
@@ -680,6 +760,17 @@ void Win32TextInputManager::syncBounds(RnWin32View *root) {
                  rect.right - rect.left,
                  rect.bottom - rect.top,
                  SWP_NOZORDER | SWP_NOACTIVATE | SWP_SHOWWINDOW);
+
+    if (sameShape(shape, entry.regionShape)) {
+      if (region != nullptr) {
+        DeleteObject(region);
+      }
+      continue;
+    }
+    entry.regionShape = shape;
+    // A null region removes the one the control had, which is what a field
+    // that has come back into the clear needs.
+    SetWindowRgn(entry.control, region, TRUE);
   }
 }
 

package/native/win32/Win32TextInput.h

@@ -29,11 +29,13 @@
 //     mutation arrives at all. `syncBounds` is that, and the host calls it after
 //     every transaction and every wheel.
 //
-//   - **It is always on top.** Child windows paint above whatever Direct2D drew,
-//     in an order the React tree has no say in. A field cannot be covered by a
-//     later sibling, and it does not clip to a scrolled ancestor -- it is hidden
-//     when it leaves the ancestor's box instead, which is close enough to look
-//     right and is not the same thing.
+//   - **It would be on top of everything.** Child windows paint above whatever
+//     Direct2D drew, in an order the React tree has no say in, so a field
+//     neither clips to a scrolled ancestor nor can be covered by a later
+//     sibling. `SetWindowRgn` is where the missing order goes, and working the
+//     region out from the tree is `Win32PeerClip.h`; `syncBounds` installs it.
+//     What is still not possible is a transform, because a window cannot be
+//     rotated -- see docs/backlog/platform-windows.md.
 //
 //   - **Its events arrive at the parent.** EN_CHANGE, EN_SETFOCUS and
 //     EN_KILLFOCUS are WM_COMMAND notifications to the host window, and the
@@ -110,9 +112,11 @@ class Win32TextInputManager {
                        const std::string &name,
                        const folly::dynamic &args);
 
-  // Moves every peer to where its view now is, in client coordinates, and hides
-  // the ones that have gone out of sight. Called after each transaction and
-  // each scroll: a child window does not follow a view that has no widget.
+  // Moves every peer to where its view now is, in client coordinates, clips it
+  // to what the tree leaves of it, and hides the ones that have gone out of
+  // sight or behind something. Called after each transaction and each scroll:
+  // a child window does not follow a view that has no widget, and the region
+  // it is clipped to changes with every one of them. See Win32PeerClip.h.
   void syncBounds(win32::RnWin32View *root);
 
   // WM_COMMAND from the host: EN_CHANGE, EN_SETFOCUS, EN_KILLFOCUS. True when
@@ -260,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
@@ -273,6 +282,17 @@ class Win32TextInputManager {
     // is set to so that the text sits in the middle of the field.
     LONG lineHeight{0};
 
+    // The window region last installed, as the rectangles it was built from in
+    // the control's own coordinates: the visible box first, then each piece
+    // taken out of it. Empty means no region, which is a whole unobstructed
+    // field -- the common case, and the one worth not touching.
+    //
+    // Held because `SetWindowRgn` redraws the control, and `syncBounds` runs
+    // after every transaction and every wheel notch: a field in a list being
+    // scrolled would be told to redraw on every one of them for a region that
+    // has not changed. See `syncBounds` and Win32PeerClip.h.
+    std::vector<RECT> regionShape;
+
     // The input scope last installed for `keyboardType`, and whether one has
     // been. `SetInputScope` replaces the window's whole scope list, so it is
     // called on a change rather than on every props update -- a controlled

package/native/win32/Win32UiThread.h

@@ -24,4 +24,15 @@ void installUiThread();
 // Whether `postToUiThread` will actually marshal, rather than running inline.
 bool hasUiThread();
 
+// Takes it down again, and runs anything still queued on the calling thread so
+// that nothing posted is lost. For tests, and this is the one that needs it:
+// react-native-skia 3.x records a frame on a thread pool of its own and asks
+// the UI thread to present it, and the producer holds a lock across that ask.
+// Run inline -- which is what posting with no window installed means on a
+// worker, exactly as the note above warns -- it re-enters the producer on the
+// thread that already holds the lock, and the suite dies with no message. So
+// the canvas test installs a real loop, pumps it, and puts things back for the
+// tests after it, which are written against the inline behaviour.
+void uninstallUiThread();
+
 } // namespace basalt