basalt-win32 0.2.1 → 0.2.2

package/native/win32/Win32TextInput.cpp

@@ -2,6 +2,7 @@
 
 #include "DirectWriteLayout.h"
 #include "TextChecking.h"
+#include "Win32PeerClip.h"
 #include "Win32InputScopes.h"
 #include "Win32Strings.h"
 
@@ -64,61 +65,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;
 }
 
@@ -596,6 +573,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 +610,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 +654,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 +729,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
@@ -273,6 +277,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

package/native/win32/Win32UiTimer.cpp

@@ -0,0 +1,139 @@
+#include "Win32UiTimer.h"
+
+#include <windows.h>
+
+#include "PlatformServices.h"
+#include "Win32UiThread.h"
+
+#include <mutex>
+#include <unordered_map>
+#include <utility>
+
+namespace basalt {
+namespace {
+
+struct Entry {
+  std::function<void()> callback;
+  PTP_TIMER handle = nullptr;
+  bool repeating = false;
+};
+
+struct Registry {
+  std::mutex mutex;
+  std::unordered_map<UiTimerId, Entry> timers;
+  UiTimerId next = 1;
+};
+
+Registry &registry() {
+  static Registry instance;
+  return instance;
+}
+
+// Closing a thread-pool timer is three calls and the order is not optional:
+// stop it, wait out a callback that may already be running on a pool thread,
+// and only then release the handle. Skipping the wait is the classic way to
+// free a timer out from under its own callback.
+//
+// Called with the registry lock *not* held: the wait blocks until a pool
+// thread leaves `onExpiry`, and `onExpiry` takes that lock.
+void closeTimer(PTP_TIMER handle) {
+  if (handle == nullptr) {
+    return;
+  }
+  SetThreadpoolTimer(handle, nullptr, 0, 0);
+  WaitForThreadpoolTimerCallbacks(handle, TRUE);
+  CloseThreadpoolTimer(handle);
+}
+
+// On the UI thread, one delay later. Everything about the timer is re-read
+// here rather than captured, because the gap between the pool thread posting
+// this and the loop running it is exactly when a cancel arrives.
+void deliver(UiTimerId id) {
+  std::function<void()> callback;
+  PTP_TIMER finished = nullptr;
+  {
+    std::lock_guard<std::mutex> lock(registry().mutex);
+    const auto found = registry().timers.find(id);
+    if (found == registry().timers.end()) {
+      return;
+    }
+    callback = found->second.callback;
+    if (!found->second.repeating) {
+      // Out of the table before the callback runs, so that a one-shot which
+      // schedules its successor cannot collide with itself, and so that a
+      // `cancelUiTimer` on this id from inside the callback is the no-op the
+      // header promises.
+      finished = found->second.handle;
+      registry().timers.erase(found);
+    }
+  }
+  closeTimer(finished);
+  callback();
+}
+
+VOID CALLBACK onExpiry(PTP_CALLBACK_INSTANCE /*instance*/, PVOID context, PTP_TIMER /*timer*/) {
+  const auto id = static_cast<UiTimerId>(reinterpret_cast<std::uintptr_t>(context));
+  // Nothing is read here: the pool thread's only job is to say when. Which is
+  // also why the id travels rather than a pointer -- the entry may be gone by
+  // the time this lands.
+  postToUiThread([id] { deliver(id); });
+}
+
+} // namespace
+
+UiTimerId scheduleUiTimer(unsigned delayMs, bool repeating, std::function<void()> callback) {
+  // See the header: with no loop to post to, a timer has nowhere to arrive,
+  // and pretending otherwise would run the callback on a pool thread.
+  if (!hasUiThread() || callback == nullptr) {
+    return 0;
+  }
+
+  UiTimerId id = 0;
+  {
+    std::lock_guard<std::mutex> lock(registry().mutex);
+    id = registry().next++;
+  }
+
+  PTP_TIMER handle = CreateThreadpoolTimer(
+      onExpiry, reinterpret_cast<PVOID>(static_cast<std::uintptr_t>(id)), nullptr);
+  if (handle == nullptr) {
+    return 0;
+  }
+
+  {
+    std::lock_guard<std::mutex> lock(registry().mutex);
+    registry().timers[id] = Entry{std::move(callback), handle, repeating};
+  }
+
+  // Negative is relative, in hundred-nanosecond units, which is the one piece
+  // of this API that reads like a mistake and is not.
+  LARGE_INTEGER relative{};
+  relative.QuadPart = -static_cast<LONGLONG>(delayMs) * 10000;
+  FILETIME due{};
+  due.dwLowDateTime = relative.LowPart;
+  due.dwHighDateTime = static_cast<DWORD>(relative.HighPart);
+  SetThreadpoolTimer(handle, &due, repeating ? static_cast<DWORD>(delayMs) : 0, 0);
+  return id;
+}
+
+void cancelUiTimer(UiTimerId id) {
+  if (id == 0) {
+    return;
+  }
+  PTP_TIMER handle = nullptr;
+  {
+    std::lock_guard<std::mutex> lock(registry().mutex);
+    const auto found = registry().timers.find(id);
+    if (found == registry().timers.end()) {
+      return;
+    }
+    handle = found->second.handle;
+    registry().timers.erase(found);
+  }
+  // Outside the lock, because the wait inside waits for `onExpiry` to finish
+  // and `onExpiry` wants the lock. A delivery already posted to the loop is
+  // harmless: `deliver` looks the id up and finds nothing.
+  closeTimer(handle);
+}
+
+} // namespace basalt

package/native/win32/Win32UiTimer.h

@@ -0,0 +1,65 @@
+// A delay that arrives, in an app that is busy drawing.
+//
+// `SetTimer` is the obvious way to wait on Windows and it is not a reliable
+// one. `WM_TIMER` is not posted: it is *synthesised* by `GetMessage` and
+// `PeekMessage`, and only when the queue holds nothing else at all. It ranks
+// below posted messages, below input, and -- the part that matters here --
+// below `WM_PAINT`. An app that repaints whenever something changes is fine.
+// An app that repaints continuously never gives the queue the empty moment a
+// `WM_TIMER` needs, and its timers simply stop.
+//
+// That is not hypothetical and it is not rare. Measured on kino, an editor
+// whose preview is a Skia `<Canvas>`: 120 `WM_PAINT` and 250 marshalled work
+// items a second while *idle*, and six `WM_TIMER` in twenty-five seconds. A
+// 250ms poll fired four times and then never again; a one-shot quit never
+// fired at all, so every automated run of that app had to be killed. The
+// other two desktops have no such ordering -- a CFRunLoop timer and a GLib
+// source are both ordinary sources with no paint above them -- so this is a
+// place where the Windows host was quietly worse than its peers rather than
+// differently spelled.
+//
+// So the waiting happens off the UI thread, on a thread-pool timer, and the
+// delivery is `postToUiThread` -- a posted message, which outranks both paint
+// and timer, and which is the path every mount already takes. The callback
+// still runs on the UI thread, which is the only property any caller wanted
+// from `SetTimer` in the first place.
+//
+// ## Without a UI thread
+//
+// Nothing is delivered. A host installs the message-only window before React
+// Native starts; the unit tests do not, because they have no loop. Under
+// `SetTimer` that already meant "never fires" -- a `WM_TIMER` with nobody to
+// dispatch it -- and keeping it that way is what lets the suite go on testing
+// the code around these timers without growing a scheduler. A test that wants
+// one installs a loop and pumps it, as the Skia canvas test does.
+
+#pragma once
+
+#include <cstdint>
+#include <functional>
+
+namespace basalt {
+
+// What `scheduleUiTimer` hands back. Zero is "nothing was scheduled", which
+// `cancelUiTimer` accepts, so a caller can keep one of these in a field and
+// cancel it without asking whether it ever started.
+using UiTimerId = std::uint64_t;
+
+// Runs `callback` on the UI thread after `delayMs`, and every `delayMs`
+// after that when `repeating`.
+//
+// The period is a floor rather than a promise, exactly as `SetTimer`'s was:
+// the work is posted, so it arrives after whatever the loop is already
+// holding. What is different is that it arrives.
+UiTimerId scheduleUiTimer(unsigned delayMs, bool repeating, std::function<void()> callback);
+
+// Stops it. Safe on an id that already fired, on one that was never
+// scheduled, and on the running timer's own id from inside its callback --
+// which is how a one-shot that reschedules itself is written.
+//
+// Returns having waited for any delivery already in flight on a pool thread,
+// so a caller may destroy what the callback captured. It must be called from
+// the UI thread, which every caller here is on.
+void cancelUiTimer(UiTimerId id);
+
+} // namespace basalt