basalt-win32 0.0.0-rc5

package/native/win32/Win32TouchDispatcher.h

@@ -0,0 +1,153 @@
+// Win32 mouse messages into React Native's touch events.
+//
+// React Native's Pressability -- what backs <Pressable>, <TouchableOpacity> and
+// every onPress in an app -- runs on the responder system in JavaScript, and the
+// responder system is fed by touchstart/touchmove/touchend. So a pointer on a
+// desktop is reported here as a single touch point, which is also what React
+// Native for Windows and macOS do. W3C pointer events exist alongside these and
+// are only consulted for hover, behind a feature flag.
+//
+// Deliberately the same shape as the GTK and AppKit dispatchers, down to the
+// state machine and the event construction, because the part that is easy to
+// get subtly different -- which touches are in `touches` versus
+// `changedTouches`, and which view a gesture is reported against -- is not
+// about the toolkit at all. If the three ever diverge, an app's onPress will
+// fire on two desktops and not the third.
+//
+// What is different here is what the toolkit does *not* provide. GTK has
+// `gtk_widget_pick` and AppKit has `-hitTest:`, so on those two the dispatcher
+// asks the toolkit which widget was pressed. A Win32 view is a plain C++
+// object with no window of its own, so the whole of hit testing is this
+// project's: `hitTest` in RnWin32View.h, which this calls. The same is true of
+// capture -- AppKit and GTK route the drag to the widget that took the press
+// for free, and here the host has to call SetCapture.
+
+#pragma once
+
+#include "HoverTracker.h"
+#include "PointerButtons.h"
+#include "RnWin32View.h"
+#include "Win32MountingManager.h"
+
+#include <react/renderer/components/view/TouchEventEmitter.h>
+#include <react/renderer/graphics/Point.h>
+
+namespace basalt {
+
+// The tag of the React Native view under a point, in the surface root's
+// coordinates, or 0 if the point hits nothing. The view-tree half of this is
+// `win32::hitTest`, which lives in the view layer and needs no React Native.
+facebook::react::Tag hitTestTag(win32::RnWin32View *root, double x, double y);
+
+class Win32TouchDispatcher {
+ public:
+  Win32TouchDispatcher(Win32MountingManager *mountingManager,
+                       win32::RnWin32View *surfaceRoot);
+
+  Win32TouchDispatcher(const Win32TouchDispatcher &) = delete;
+  Win32TouchDispatcher &operator=(const Win32TouchDispatcher &) = delete;
+  Win32TouchDispatcher(Win32TouchDispatcher &&) = delete;
+  Win32TouchDispatcher &operator=(Win32TouchDispatcher &&) = delete;
+
+  // The surface root can be replaced after a surface restart; the dispatcher
+  // outlives it because the host owns both and tears them down together.
+  //
+  // The hover state goes with it. Every tag in the old tree is about to stop
+  // existing, and a leave dispatched at one of them would be a lookup of an
+  // emitter that is gone.
+  void setSurfaceRoot(win32::RnWin32View *surfaceRoot) {
+    surfaceRoot_ = surfaceRoot;
+    hover_.forget();
+  }
+
+  // Synthesises a press and release at a point in surface-root coordinates,
+  // entering at the same place the window procedure does.
+  //
+  // This exists because the input path is otherwise untestable in automation:
+  // synthesising a real mouse event on Windows means SendInput, which moves the
+  // actual cursor and so cannot run beside anything else on the machine. It
+  // skips Win32's event delivery and nothing else, so it proves hit testing,
+  // emitter lookup and event-beat delivery, but not that Windows routes clicks
+  // here.
+  void synthesiseTap(double x, double y);
+  // The same, with a button. BASALT_TEST_SECONDARY_TAP is what needs it: a
+  // right-click cannot be injected any other way, and it is the one click whose
+  // whole point is that it does *not* press what it lands on.
+  void synthesiseTap(double x, double y, basalt::PointerButton button);
+
+  // A press, a run of moves, and a release. The same reason as synthesiseTap,
+  // one step further: a gesture recogniser cannot be exercised by a tap at all
+  // -- a pan is defined by the movement between the two -- so a drag has to be
+  // injectable for anything about it to be provable outside a person's hand.
+  void synthesiseDrag(double fromX, double fromY, double toX, double toY, int steps);
+
+  // Moves the pointer without pressing it, which is what produces hover. Same
+  // reason as the two above, and the same entry point WM_MOUSEMOVE uses. A
+  // negative coordinate means the pointer left the window.
+  void synthesiseHover(double x, double y);
+
+  // The UI-thread half, called by the host's window procedure. Coordinates are
+  // client-area pixels, which are the surface root's own coordinates: the host
+  // sizes the root to the client rectangle, so the two spaces are the same one.
+  // `button` decides whether this presses anything. Only the primary one drives
+  // the touch model; a secondary or middle click produces a pointer event and
+  // nothing else. See core/PointerButtons.h.
+  void dispatchTouchStart(double x, double y, basalt::PointerButton button);
+  void dispatchTouchMove(double x, double y);
+  void dispatchTouchEnd(double x, double y, basalt::PointerButton button);
+  void dispatchTouchCancel();
+
+  // The hover half. Separate from dispatchTouchMove because the two answer
+  // different questions about the same WM_MOUSEMOVE: the touch model asks which
+  // view the finger went down on, and hover asks which views the cursor is
+  // inside right now.
+  void dispatchHover(double x, double y);
+  void dispatchHoverLeave();
+
+  // Whether a press is outstanding. The host reads this to decide whether a
+  // WM_MOUSEMOVE is a drag worth reporting and whether to release capture.
+  bool isDown() const { return isDown_; }
+
+ private:
+  enum class TouchKind { Start, Move, End, Cancel };
+
+  // Hands the pointer to a gesture recogniser that has activated, cancelling
+  // React Native's touch. True when that happened, which means the caller has
+  // nothing left to report.
+  bool yieldToGesture(double x, double y);
+
+  // Builds the TouchEvent for the current gesture. React Native wants three
+  // lists -- all touches, the ones that changed, and the ones that started on
+  // the event target -- which with one pointer are the same list, except on
+  // touchend where nothing is touching any more.
+  void emit(TouchKind kind, facebook::react::Tag target, double x, double y);
+
+  // A pointerMove at the view under the cursor. The only pointer event a host
+  // emits for hover; see core/HoverTracker.h.
+  // A press or a release as a pointer event, which is the only form a
+  // non-primary click arrives in.
+  void emitPointerButton(bool down,
+                         facebook::react::Tag target,
+                         double originX,
+                         double originY,
+                         double x,
+                         double y,
+                         basalt::PointerButton button);
+  void emitPointerMove(
+      facebook::react::Tag target, double originX, double originY, double x, double y);
+
+  Win32MountingManager *mountingManager_;
+  win32::RnWin32View *surfaceRoot_;
+
+  // The view a gesture started on. React Native reports every touch in a
+  // gesture against the target it began on, even after the pointer leaves that
+  // view, because that is what the responder system expects.
+  facebook::react::Tag activeTarget_{0};
+  bool isDown_{false};
+
+  // Where the cursor was, so that enter and leave can be told from over and
+  // out. See core/HoverTracker.h.
+  HoverTracker hover_;
+};
+
+} // namespace basalt

package/native/win32/Win32UiThread.h

@@ -0,0 +1,27 @@
+// The UI thread, as a thing that can be installed and asked about.
+//
+// `core/PlatformServices.h` declares `postToUiThread` and `isUiThread`, which
+// is all the shared half needs. Windows needs two more facts that are not
+// portable enough to belong there: something has to *create* the message-only
+// window the posting goes through, and callers occasionally have to know
+// whether one exists at all.
+//
+// The second is not a nicety. With no window installed `postToUiThread` runs
+// its work inline, which is correct for the harness and the tests -- there is
+// one thread and no loop to post to -- and quietly wrong for work posted from a
+// worker, because "inline" then means "on the worker". Anything that would
+// otherwise hand cross-thread work to a loop that does not exist should ask
+// first and stay on one thread instead.
+
+#pragma once
+
+namespace basalt {
+
+// Called by the host from the thread that owns its message loop, before React
+// Native starts. Idempotent.
+void installUiThread();
+
+// Whether `postToUiThread` will actually marshal, rather than running inline.
+bool hasUiThread();
+
+} // namespace basalt

package/native/win32/Win32WindowControl.cpp

@@ -0,0 +1,329 @@
+// The Windows half of core/WindowControl.h.
+//
+// The only one of the three where the coordinates already agree with React
+// Native's -- top-left origin, y growing downwards -- and the only one where
+// every function can be answered honestly.
+//
+// What it does have to be careful about is the difference between a window's
+// frame and its client area. `GetWindowRect` is the frame, including the border
+// and the title bar; `setWindowSize` is given the size an app wants, and an app
+// asking for 900x700 means its own content. So the size is adjusted outwards by
+// whatever the frame costs, which is what `AdjustWindowRectEx` is for -- and
+// which a window with a hidden title bar costs nothing for, so the same call
+// answers both cases.
+
+#include <vector>
+#include "WindowControl.h"
+
+#include <windows.h>
+
+// After windows.h, which it depends on: GetDpiForMonitor, for a per-display
+// scale factor. GetDpiForWindow would answer for the window's monitor only.
+#include <shellscalingapi.h>
+
+namespace basalt {
+
+namespace {
+
+
+HWND window() {
+  HWND active = GetActiveWindow();
+  return active != nullptr ? active : GetForegroundWindow();
+}
+
+} // namespace
+
+// Every monitor, through the callback API that is the only way to ask.
+//
+// `MONITORINFOEXW` carries both rectangles -- `rcMonitor` is the glass and
+// `rcWork` is what the taskbar leaves -- which is why the work area needs no
+// second call here and cannot be had at all on GTK.
+//
+// The coordinates are already what this platform means by desktop
+// coordinates: Windows anchors them at the primary monitor's top-left and
+// grows down, which is the convention the other two are converted into.
+std::vector<DisplayInfo> displays() {
+  std::vector<DisplayInfo> found;
+  EnumDisplayMonitors(
+      nullptr,
+      nullptr,
+      [](HMONITOR monitor, HDC, LPRECT, LPARAM data) -> BOOL {
+        auto *out = reinterpret_cast<std::vector<DisplayInfo> *>(data);
+        MONITORINFOEXW info{};
+        info.cbSize = sizeof(info);
+        if (!GetMonitorInfoW(monitor, &info)) {
+          return TRUE;
+        }
+
+        DisplayInfo entry;
+        entry.x = info.rcMonitor.left;
+        entry.y = info.rcMonitor.top;
+        entry.width = info.rcMonitor.right - info.rcMonitor.left;
+        entry.height = info.rcMonitor.bottom - info.rcMonitor.top;
+        entry.workX = info.rcWork.left;
+        entry.workY = info.rcWork.top;
+        entry.workWidth = info.rcWork.right - info.rcWork.left;
+        entry.workHeight = info.rcWork.bottom - info.rcWork.top;
+
+        // 96 DPI is 100%, which is what makes this a ratio rather than a
+        // number of dots. A display at 150% answers 144 and reports 1.5.
+        UINT dpiX = 96;
+        UINT dpiY = 96;
+        if (SUCCEEDED(GetDpiForMonitor(monitor, MDT_EFFECTIVE_DPI, &dpiX, &dpiY)) && dpiX > 0) {
+          entry.scaleFactor = static_cast<double>(dpiX) / 96.0;
+        }
+        entry.primary = (info.dwFlags & MONITORINFOF_PRIMARY) != 0;
+
+        // Primary first, to match the order the other hosts report and the
+        // order the header promises. EnumDisplayMonitors does not guarantee
+        // one.
+        if (entry.primary) {
+          out->insert(out->begin(), entry);
+        } else {
+          out->push_back(entry);
+        }
+        return TRUE;
+      },
+      reinterpret_cast<LPARAM>(&found));
+  return found;
+}
+
+PointerPosition pointerPosition() {
+  PointerPosition where;
+  POINT point{};
+  if (GetCursorPos(&point)) {
+    where.x = point.x;
+    where.y = point.y;
+    where.known = true;
+  }
+  return where;
+}
+
+WindowBounds windowBounds() {
+  WindowBounds bounds;
+  HWND target = window();
+  if (target == nullptr) {
+    return bounds;
+  }
+
+  RECT frame{};
+  if (GetWindowRect(target, &frame)) {
+    bounds.x = frame.left;
+    bounds.y = frame.top;
+  }
+  // The client area, which is what an app laid out and what the other two
+  // hosts report: a frame's size includes a border the app never drew in.
+  RECT client{};
+  if (GetClientRect(target, &client)) {
+    bounds.width = client.right - client.left;
+    bounds.height = client.bottom - client.top;
+  }
+
+  bounds.maximized = IsZoomed(target) != FALSE;
+
+  // Full screen is not a state Windows has; it is a window with no border
+  // filling a monitor, which is how every application does it. So the question
+  // is asked the way the answer is made: no title bar, and exactly the size of
+  // the monitor it is on.
+  if (const HMONITOR monitor = MonitorFromWindow(target, MONITOR_DEFAULTTONEAREST)) {
+    MONITORINFO info{};
+    info.cbSize = sizeof(info);
+    if (GetMonitorInfoW(monitor, &info)) {
+      const LONG style = GetWindowLongW(target, GWL_STYLE);
+      bounds.fullScreen = (style & WS_OVERLAPPEDWINDOW) == 0 &&
+          frame.left == info.rcMonitor.left && frame.top == info.rcMonitor.top &&
+          frame.right == info.rcMonitor.right && frame.bottom == info.rcMonitor.bottom;
+    }
+  }
+  return bounds;
+}
+
+void setWindowSize(double width, double height) {
+  HWND target = window();
+  if (target == nullptr || width <= 0.0 || height <= 0.0) {
+    return;
+  }
+  // Outwards from the client size the app asked for to the frame size Windows
+  // positions. A borderless window adjusts by nothing, so this is right for
+  // both title-bar styles.
+  RECT desired{0, 0, static_cast<LONG>(width), static_cast<LONG>(height)};
+  const LONG style = GetWindowLongW(target, GWL_STYLE);
+  const LONG exStyle = GetWindowLongW(target, GWL_EXSTYLE);
+  AdjustWindowRectEx(&desired, static_cast<DWORD>(style), FALSE, static_cast<DWORD>(exStyle));
+
+  SetWindowPos(target,
+               nullptr,
+               0,
+               0,
+               desired.right - desired.left,
+               desired.bottom - desired.top,
+               SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
+}
+
+void setWindowPosition(double x, double y) {
+  HWND target = window();
+  if (target == nullptr) {
+    return;
+  }
+  SetWindowPos(target,
+               nullptr,
+               static_cast<int>(x),
+               static_cast<int>(y),
+               0,
+               0,
+               SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
+}
+
+void centerWindow() {
+  HWND target = window();
+  if (target == nullptr) {
+    return;
+  }
+  RECT frame{};
+  if (!GetWindowRect(target, &frame)) {
+    return;
+  }
+  // The work area of the monitor the window is on, not the primary one and not
+  // the whole monitor: centring into the space the taskbar leaves is what a
+  // person means, and what every other application does.
+  const HMONITOR monitor = MonitorFromWindow(target, MONITOR_DEFAULTTONEAREST);
+  MONITORINFO info{};
+  info.cbSize = sizeof(info);
+  if (monitor == nullptr || !GetMonitorInfoW(monitor, &info)) {
+    return;
+  }
+
+  const LONG width = frame.right - frame.left;
+  const LONG height = frame.bottom - frame.top;
+  const LONG x = info.rcWork.left + ((info.rcWork.right - info.rcWork.left) - width) / 2;
+  const LONG y = info.rcWork.top + ((info.rcWork.bottom - info.rcWork.top) - height) / 2;
+  SetWindowPos(target, nullptr, x, y, 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
+}
+
+void setWindowFullScreen(bool fullScreen) {
+  HWND target = window();
+  if (target == nullptr) {
+    return;
+  }
+
+  // Where the window was before it filled the screen, so that leaving puts it
+  // back. One window, so one saved rect; see core/WindowControl.h on that
+  // limit.
+  static RECT restore{};
+  static LONG restoreStyle = 0;
+
+  const LONG style = GetWindowLongW(target, GWL_STYLE);
+  const bool already = (style & WS_OVERLAPPEDWINDOW) == 0;
+  if (already == fullScreen) {
+    return;
+  }
+
+  if (fullScreen) {
+    GetWindowRect(target, &restore);
+    restoreStyle = style;
+
+    const HMONITOR monitor = MonitorFromWindow(target, MONITOR_DEFAULTTONEAREST);
+    MONITORINFO info{};
+    info.cbSize = sizeof(info);
+    if (monitor == nullptr || !GetMonitorInfoW(monitor, &info)) {
+      return;
+    }
+    SetWindowLongW(target, GWL_STYLE, style & ~WS_OVERLAPPEDWINDOW);
+    // The whole monitor rather than its work area: filling the screen means
+    // over the taskbar, which is the difference between this and maximising.
+    SetWindowPos(target,
+                 HWND_TOP,
+                 info.rcMonitor.left,
+                 info.rcMonitor.top,
+                 info.rcMonitor.right - info.rcMonitor.left,
+                 info.rcMonitor.bottom - info.rcMonitor.top,
+                 SWP_NOOWNERZORDER | SWP_FRAMECHANGED);
+    return;
+  }
+
+  SetWindowLongW(target, GWL_STYLE, restoreStyle != 0 ? restoreStyle : (style | WS_OVERLAPPEDWINDOW));
+  SetWindowPos(target,
+               nullptr,
+               restore.left,
+               restore.top,
+               restore.right - restore.left,
+               restore.bottom - restore.top,
+               SWP_NOZORDER | SWP_NOOWNERZORDER | SWP_FRAMECHANGED);
+}
+
+void applyWindowSizeLimits() {
+  HWND target = window();
+  if (target == nullptr) {
+    return;
+  }
+  // Nothing to set. Windows asks rather than being told: WM_GETMINMAXINFO
+  // arrives whenever the window manager wants the answer, and the host replies
+  // from `windowSizeLimits()`. All this does is make it ask again, so that a
+  // limit set while the window is already too big takes effect now rather than
+  // the next time somebody drags a corner.
+  RECT frame{};
+  if (!GetWindowRect(target, &frame)) {
+    return;
+  }
+  SetWindowPos(target,
+               nullptr,
+               frame.left,
+               frame.top,
+               frame.right - frame.left,
+               frame.bottom - frame.top,
+               SWP_NOZORDER | SWP_NOOWNERZORDER | SWP_NOACTIVATE | SWP_FRAMECHANGED);
+}
+
+void setWindowResizable(bool resizable) {
+  HWND target = window();
+  if (target == nullptr) {
+    return;
+  }
+  LONG style = GetWindowLongW(target, GWL_STYLE);
+  // The sizing border and the maximise button together. Leaving the button on a
+  // window that cannot be sized would be an enabled control that does nothing,
+  // which is the same mistake as a greyed-out one that works.
+  if (resizable) {
+    style |= (WS_THICKFRAME | WS_MAXIMIZEBOX);
+  } else {
+    style &= ~(WS_THICKFRAME | WS_MAXIMIZEBOX);
+  }
+  SetWindowLongW(target, GWL_STYLE, style);
+  // SWP_FRAMECHANGED, or the border is recalculated only the next time
+  // something else moves the window -- so the style changes and the frame does
+  // not, until it suddenly does.
+  SetWindowPos(target,
+               nullptr,
+               0,
+               0,
+               0,
+               0,
+               SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_NOOWNERZORDER | SWP_NOACTIVATE |
+                   SWP_FRAMECHANGED);
+}
+
+void setWindowAlwaysOnTop(bool alwaysOnTop) {
+  HWND target = window();
+  if (target == nullptr) {
+    return;
+  }
+  SetWindowPos(target,
+               alwaysOnTop ? HWND_TOPMOST : HWND_NOTOPMOST,
+               0,
+               0,
+               0,
+               0,
+               SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
+}
+
+WindowCapabilities windowCapabilities() {
+  WindowCapabilities capabilities;
+  capabilities.position = true;
+  capabilities.minimumSize = true;
+  capabilities.maximumSize = true;
+  capabilities.resizable = true;
+  capabilities.alwaysOnTop = true;
+  return capabilities;
+}
+
+} // namespace basalt