basalt-win32 0.2.0 → 0.2.2

package/native/win32/Win32PeerClip.cpp

@@ -0,0 +1,153 @@
+#include "Win32PeerClip.h"
+
+#include "RnWin32View.h"
+
+#include <algorithm>
+#include <cmath>
+
+namespace basalt::win32 {
+
+namespace {
+
+RECT boxOf(double x, double y, double width, double height) {
+  RECT rect{};
+  rect.left = static_cast<LONG>(std::lround(x));
+  rect.top = static_cast<LONG>(std::lround(y));
+  rect.right = rect.left + static_cast<LONG>(std::lround(width));
+  rect.bottom = rect.top + static_cast<LONG>(std::lround(height));
+  return rect;
+}
+
+bool isEmpty(const RECT &rect) {
+  return rect.right <= rect.left || rect.bottom <= rect.top;
+}
+
+RECT intersect(const RECT &a, const RECT &b) {
+  RECT out{};
+  out.left = std::max(a.left, b.left);
+  out.top = std::max(a.top, b.top);
+  out.right = std::min(a.right, b.right);
+  out.bottom = std::min(a.bottom, b.bottom);
+  if (isEmpty(out)) {
+    return RECT{0, 0, 0, 0};
+  }
+  return out;
+}
+
+// Whether this view puts something over the whole of its own box.
+//
+// A background colour with any alpha at all, and nothing else -- see the
+// header for why the bar is "not transparent" rather than "opaque", and why a
+// transformed view is left alone instead of being approximated by its bounding
+// box.
+bool covers(const RnWin32View *view) {
+  if (!view->hasBackgroundColor() || view->hasTransform()) {
+    return false;
+  }
+  if (view->opacity() <= 0.0f) {
+    return false;
+  }
+  return view->backgroundColor()[3] > 0.0f;
+}
+
+struct Walk {
+  const RnWin32View *target{nullptr};
+  PeerClip *out{nullptr};
+  // Set when the target has been reached, which is what divides the tree into
+  // "painted before it", which cannot cover it, and "painted after it", which
+  // can. One flag is enough because painting order is a single sequence.
+  bool seen{false};
+};
+
+// `origin` is where this view's parent puts its children, already scrolled.
+void visit(RnWin32View *view, double originX, double originY, const RECT &clip, Walk &walk) {
+  if (view == nullptr || view->hidden()) {
+    return;
+  }
+
+  const double x = originX + view->frame().x;
+  const double y = originY + view->frame().y;
+  const RECT box = boxOf(x, y, view->frame().width, view->frame().height);
+
+  if (view == walk.target) {
+    const RECT visible = intersect(box, clip);
+    if (isEmpty(visible)) {
+      return;
+    }
+    walk.out->visible = true;
+    walk.out->bounds = box;
+    walk.out->clip = visible;
+    // Its own subtree is not walked: a child of a `<TextInput>` is inside the
+    // field rather than over it, and the field has none in any real tree.
+    walk.seen = true;
+    return;
+  }
+
+  if (walk.seen && covers(view)) {
+    const RECT over = intersect(box, clip);
+    if (!isEmpty(over)) {
+      walk.out->occluders.push_back(over);
+    }
+  }
+
+  RECT childClip = clip;
+  if (view->clipsChildren()) {
+    childClip = intersect(clip, box);
+    if (isEmpty(childClip)) {
+      // Nothing inside can be seen, and nothing inside can cover anything
+      // either -- but the target may still be in there, and if it is then it is
+      // off screen, which is what not finding it already means.
+      return;
+    }
+  }
+
+  const double childX = x - view->scrollX();
+  const double childY = y - view->scrollY();
+  for (RnWin32View *child : view->childrenInPaintOrder()) {
+    visit(child, childX, childY, childClip, walk);
+  }
+}
+
+} // namespace
+
+PeerClip peerClip(RnWin32View *view, RnWin32View *root) {
+  PeerClip result{};
+  if (view == nullptr || root == nullptr) {
+    return result;
+  }
+
+  // The root's own frame is not part of these coordinates: the surface root is
+  // the client area, and a peer's position is measured from its top-left. So
+  // the walk starts inside it rather than at it, which also means a `view` that
+  // *is* the root is not a field and comes back invisible.
+  if (root->hidden()) {
+    return result;
+  }
+
+  // Unbounded unless the root says otherwise, which is the rule every other
+  // ancestor is under. Clipping to the client area regardless would be defen-
+  // sible and is not done here: a surface that has never been laid out has a
+  // zero frame, and "every field is invisible" is a worse answer than "a field
+  // outside the window is placed outside the window", which USER32 handles.
+  constexpr LONG kUnbounded = 1 << 28;
+  RECT clip{-kUnbounded, -kUnbounded, kUnbounded, kUnbounded};
+  if (root->clipsChildren()) {
+    clip = boxOf(0.0, 0.0, root->frame().width, root->frame().height);
+    if (isEmpty(clip)) {
+      return result;
+    }
+  }
+  Walk walk{view, &result, false};
+  const double childX = -static_cast<double>(root->scrollX());
+  const double childY = -static_cast<double>(root->scrollY());
+  for (RnWin32View *child : root->childrenInPaintOrder()) {
+    visit(child, childX, childY, clip, walk);
+  }
+
+  if (!result.visible) {
+    return PeerClip{};
+  }
+  return result;
+}
+
+} // namespace basalt::win32

package/native/win32/Win32PeerClip.h

@@ -0,0 +1,92 @@
+// Where a child-window peer is allowed to paint.
+//
+// A `<TextInput>` on this host is a real EDIT control, so it is a child window
+// rather than something Direct2D draws. That buys the IME, the clipboard and
+// every binding a Windows user expects, and it costs the one thing every other
+// view gets for free: a place in the painting order. A child window is drawn by
+// USER32 after the parent's client area, so it sits above everything the React
+// tree drew, whatever the tree says. Two things follow, and a person sees both:
+//
+//   - A field in a `<ScrollView>` does not clip to it. Scroll the list until
+//     the field is half out and the half that should be gone goes on being
+//     drawn over the list's neighbour.
+//   - A field cannot be covered. Open a modal over a pane that has one and the
+//     field floats on top of the modal, at full brightness, still editable.
+//
+// Both are the same missing fact -- which pixels of the field are still the
+// field's -- and Windows has somewhere to put it: `SetWindowRgn`. A window with
+// a region is displayed only inside it, and clicks outside it fall through to
+// the parent. So the job is to work the region out from the view tree, which is
+// what this file is: pure geometry over `RnWin32View`, with no window, no
+// control and no React Native in it, so that it can be tested with none of
+// them.
+//
+// ## What counts as covering it
+//
+// Clipping is exact: a clipping ancestor's box is a rectangle and the
+// intersection of rectangles is the answer.
+//
+// Occlusion is not, and cannot be. The right behaviour for a field under
+// kino's modal scrim -- `#000000A0` over the whole window -- is for the field
+// to be *dimmed*, and a child window cannot be dimmed by something painted into
+// its parent: the two are composited by USER32, in that order, with no blend to
+// take part in. The choice is therefore between showing the field undimmed and
+// hiding it, and hiding it is the better wrong answer: an undimmed field over a
+// modal is the bug people report, while a field that goes quiet under a scrim
+// reads as part of the modal.
+//
+// So anything painted after the field that is not fully transparent counts as
+// covering it. That is deliberately more eager than "opaque": a 63%-black
+// backdrop blends to something no child window can match, so there is nothing
+// to be gained by letting it show through at 100%.
+//
+// What does *not* count: a view with no background at all, which is every
+// layout wrapper in a real tree and the reason this rule produces no false
+// positives in practice, and a transformed view, whose box is not a rectangle
+// in these coordinates and which is therefore left alone rather than guessed
+// at. A `<Text>` drawn over a field is also left alone -- glyphs are not a box.
+//
+// ## Transforms
+//
+// Ignored throughout, as `Win32TextInputManager` already ignores them when it
+// places the peer: a window cannot be rotated, so a transformed field's peer
+// sits where the untransformed one would, and clipping it to a rotated
+// ancestor's bounding box would only move the error around.
+
+#pragma once
+
+#include <windows.h>
+
+#include <vector>
+
+namespace basalt::win32 {
+
+class RnWin32View;
+
+// Where `view`'s peer may paint, all in the surface root's coordinates.
+struct PeerClip {
+  // False when the view is not on screen at all: hidden, detached, or scrolled
+  // entirely out of a clipping ancestor. Nothing else in the struct means
+  // anything then.
+  bool visible{false};
+
+  // The view's own box, unclipped. This is where the control goes -- a control
+  // narrowed to its visible part would lay its text out in the wrong width.
+  RECT bounds{};
+
+  // `bounds` narrowed by every clipping ancestor. Never empty when `visible`.
+  RECT clip{};
+
+  // Boxes painted after the view that cover part of it, already narrowed to
+  // their own clipping ancestors. Each is taken out of the region.
+  std::vector<RECT> occluders{};
+};
+
+// Walks the tree from `root` once, in painting order, and answers for `view`.
+//
+// `root` is the surface root, whose coordinates are the window's client
+// coordinates on this host. A view that is not under `root` comes back
+// invisible, which is what a peer between a Remove and its Delete looks like.
+PeerClip peerClip(RnWin32View *view, RnWin32View *root);
+
+} // namespace basalt::win32

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