basalt-win32 0.2.1 → 0.2.2

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>
@@ -326,6 +328,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 +606,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();

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/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_; }

package/native/win32/Win32AnimationChoreographer.cpp

@@ -1,31 +1,17 @@
 #include "Win32AnimationChoreographer.h"
 
-#include <windows.h>
+#include "Win32UiTimer.h"
 
 #include <chrono>
 
 namespace basalt {
 namespace {
 
-// Roughly sixty hertz. SetTimer's resolution is the message queue's -- it
-// cannot do better than about ten to sixteen milliseconds and it coalesces --
-// so this is an upper bound on the frame rate rather than a promise of one.
-// See the header for what would be needed to do it properly.
-constexpr UINT kFrameIntervalMs = 16;
-
-// SetTimer's callback carries the timer id and nothing else, so the
-// choreographer has to be found from it. One host means one choreographer, and
-// a map would be pretending otherwise.
-Win32AnimationChoreographer *&currentChoreographer() {
-  static Win32AnimationChoreographer *instance = nullptr;
-  return instance;
-}
-
-void CALLBACK onTimer(HWND, UINT, UINT_PTR, DWORD) {
-  if (auto *choreographer = currentChoreographer()) {
-    choreographer->onFrame();
-  }
-}
+// Roughly sixty hertz. The delay is a floor rather than a promise -- the frame
+// is posted to the loop and arrives behind whatever the loop is already
+// holding -- so this is an upper bound on the frame rate. See the header for
+// what would be needed to do it properly.
+constexpr unsigned kFrameIntervalMs = 16;
 
 } // namespace
 
@@ -37,28 +23,25 @@ void Win32AnimationChoreographer::resume() {
   if (running_.exchange(true)) {
     return;
   }
-  currentChoreographer() = this;
-  // A timer with no window: the callback is delivered as WM_TIMER to the
-  // thread's queue and dispatched by the loop, which means it lands on the UI
-  // thread like everything else and needs no synchronisation of its own.
-  timer_ = static_cast<std::uintptr_t>(SetTimer(nullptr, 0, kFrameIntervalMs, onTimer));
+  // Not `SetTimer`. A sixty-hertz WM_TIMER is exactly the arrangement that
+  // stops working in an app that repaints continuously, which is to say in
+  // every app with an animation worth running. See win32/Win32UiTimer.h.
+  timer_ = scheduleUiTimer(kFrameIntervalMs, true, [this] { onFrame(); });
 }
 
 void Win32AnimationChoreographer::pause() {
   if (!running_.exchange(false)) {
     return;
   }
-  if (timer_ != 0) {
-    KillTimer(nullptr, static_cast<UINT_PTR>(timer_));
-    timer_ = 0;
-  }
+  // Before this returns, nothing of ours is still in flight: `cancelUiTimer`
+  // waits out a delivery already on a pool thread, which is what makes the
+  // `this` captured above safe to destroy afterwards.
+  cancelUiTimer(timer_);
+  timer_ = 0;
 }
 
 void Win32AnimationChoreographer::detach() {
   pause();
-  if (currentChoreographer() == this) {
-    currentChoreographer() = nullptr;
-  }
 }
 
 void Win32AnimationChoreographer::onFrame() {

package/native/win32/Win32AnimationChoreographer.h

@@ -12,8 +12,8 @@
 // own thread, because DwmFlush blocks, and a blocked UI thread is worse than a
 // slightly wrong frame interval.
 //
-// So this is a multimedia timer at sixty hertz, and it is worth being clear
-// that this is a placeholder rather than a design. `docs/BACKLOG.md` already
+// So this is a timer at sixty hertz, and it is worth being clear that this is
+// a placeholder rather than a design. `docs/BACKLOG.md` already
 // records that worklets and Reanimated run on a sixteen-millisecond timer on
 // *both* other desktops for a related reason -- each platform's display link
 // belongs to React Native's own choreographer and pauses when React Native has
@@ -52,10 +52,13 @@ class Win32AnimationChoreographer final : public facebook::react::AnimationChore
 
  private:
   std::atomic<bool> running_{false};
-  // A UINT_PTR from SetTimer, held as an integer so this header needs no
-  // windows.h -- which would otherwise reach every translation unit that
-  // constructs a host.
-  std::uintptr_t timer_{0};
+  // A `basalt::UiTimerId` rather than a `SetTimer` handle, and not for
+  // tidiness: WM_TIMER ranks below WM_PAINT, so on this timer an app that
+  // repaints continuously -- anything with a `<Canvas>` -- stopped getting
+  // animation frames at all. See win32/Win32UiTimer.h. Held as a plain
+  // integer so this header needs no windows.h, which would otherwise reach
+  // every translation unit that constructs a host.
+  std::uint64_t timer_{0};
 };
 
 } // namespace basalt

package/native/win32/Win32Cursors.cpp

@@ -244,20 +244,6 @@ HCURSOR cursorFromArt(const Art &art, int hotX, int hotY) {
   return cursor;
 }
 
-// `%SystemRoot%\Cursors\aero_link.cur`, the shell's own shortcut cursor, which
-// is the one of the six Windows ships as a file with a name rather than as an
-// ordinal inside a DLL. Null when it is not there, and the caller draws its own.
-HCURSOR cursorFromSystemFile(const wchar_t *leaf) {
-  wchar_t path[MAX_PATH]{};
-  const UINT length = GetWindowsDirectoryW(path, MAX_PATH);
-  if (length == 0 || length >= MAX_PATH) {
-    return nullptr;
-  }
-  std::wstring full(path);
-  full += L"\\Cursors\\";
-  full += leaf;
-  return LoadCursorFromFileW(full.c_str());
-}
 
 HCURSOR drawnCursorFor(const std::string &keyword) {
   if (keyword == "copy") {
@@ -267,9 +253,19 @@ HCURSOR drawnCursorFor(const std::string &keyword) {
     return cursorFromArt(contextMenuArt(), 0, 0);
   }
   if (keyword == "alias") {
-    if (HCURSOR shipped = cursorFromSystemFile(L"aero_link.cur")) {
-      return shipped;
-    }
+    // Drawn, like the other five, and not `%SystemRoot%\Cursors\aero_link.cur`.
+    //
+    // That file was preferred here on the reasoning that a real name beats an
+    // unnamed ordinal inside shell32, which is sound and is still why nothing
+    // else reaches into the shell. What it missed is what the file contains:
+    // on Windows 11 aero_link.cur is "Link Select", the pointing hand -- the
+    // same cursor `pointer` already gets from IDC_HAND. So `alias` and
+    // `pointer` came back pixel for pixel identical, and CSS means two
+    // different things by them.
+    //
+    // The art below is the shape `alias` is supposed to be: an arrow with the
+    // shortcut badge turning up and to the right. It was already written and
+    // never ran, because the file always loaded.
     return cursorFromArt(aliasArt(), 0, 0);
   }
   if (keyword == "cell") {

package/native/win32/Win32MountingManager.cpp

@@ -15,7 +15,10 @@
 #include "PlatformServices.h"
 #include "UIManagerAccess.h"
 
-#ifdef BASALT_HAS_SKIA
+// Either Skia: the 2.x peer in this package or the 3.x one in basalt-skia,
+// which share this header's two functions and are never both linked. See
+// Win32SkiaPeer.h.
+#if defined(BASALT_HAS_SKIA) || BASALT_HAS_SKIA_GRAPHITE
 #include "Win32SkiaPeer.h"
 #endif
 
@@ -343,7 +346,7 @@ void Win32MountingManager::forgetTag(Tag tag) {
   labels_.forget(tag);
   liveRegions_.forget(tag);
   liveRegionLabels_.erase(tag);
-#ifdef BASALT_HAS_SKIA
+#if defined(BASALT_HAS_SKIA) || BASALT_HAS_SKIA_GRAPHITE
   // Unregisters the canvas. This is the one moment a view is known to be
   // finished with, and a canvas left registered is a surface the package will
   // keep rendering into for a tag nothing will ever draw again.
@@ -360,7 +363,7 @@ void Win32MountingManager::updateView(RnWin32View *view, const ShadowView &shado
   applyText(view, shadowView);
   applyImage(view, shadowView);
   applyAccessibility(view, shadowView);
-#ifdef BASALT_HAS_SKIA
+#if defined(BASALT_HAS_SKIA) || BASALT_HAS_SKIA_GRAPHITE
   // After applyProps, which is what puts nativeID on the view -- a canvas
   // registers itself by that id and cannot attach before it is there. The size
   // it reads comes from the shadow view rather than from the frame