basalt-win32 0.0.0-rc5

package/native/win32/Win32WindowModule.cpp

@@ -0,0 +1,209 @@
+#include "Win32WindowModule.h"
+
+#include "WindowControl.h"
+#include "WindowMethods.h"
+#include "PlatformServices.h"
+#include "Win32TitleBar.h"
+
+#include <windows.h>
+
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace basalt {
+
+namespace {
+
+using facebook::jsi::Object;
+using facebook::jsi::Runtime;
+using facebook::jsi::String;
+using facebook::jsi::Value;
+using facebook::react::TurboModule;
+
+constexpr const char *kMetricsChangedEvent = "basaltTitleBarMetricsChanged";
+
+// processColor's 0xAARRGGBB number, as the COLORREF DWM takes, or nullopt for
+// anything that is not a number -- which is how JavaScript asks for the
+// system's colour back. The alpha is dropped: a caption is opaque.
+std::optional<COLORREF> colorArgument(const Value *args, size_t count, size_t index) {
+  if (index >= count || !args[index].isNumber()) {
+    return std::nullopt;
+  }
+  const auto argb = static_cast<uint32_t>(static_cast<int64_t>(args[index].asNumber()));
+  return RGB((argb >> 16) & 0xFF, (argb >> 8) & 0xFF, argb & 0xFF);
+}
+
+Value metricsValue(Runtime &runtime, const TitleBarMetrics &metrics) {
+  Object object(runtime);
+  object.setProperty(runtime, "height", static_cast<double>(metrics.height));
+  object.setProperty(runtime, "buttonsWidth", static_cast<double>(metrics.buttonsWidth));
+  object.setProperty(runtime,
+                     "style",
+                     String::createFromAscii(
+                         runtime, metrics.style == TitleBarStyle::Hidden ? "hidden" : "native"));
+  return Value(runtime, object);
+}
+
+} // namespace
+
+Win32WindowModule::Win32WindowModule(std::shared_ptr<facebook::react::CallInvoker> jsInvoker)
+    : TurboModule(kModuleName, std::move(jsInvoker)) {
+  methodMap_["setTitle"] = MethodMetadata{1, setTitle};
+  methodMap_["setTitleBarColors"] = MethodMetadata{3, setTitleBarColors};
+  methodMap_["setTitleBarStyle"] = MethodMetadata{1, setTitleBarStyle};
+  methodMap_["getTitleBarMetrics"] = MethodMetadata{0, getTitleBarMetrics};
+  // The caption's actions, under the names and in the order GtkWindowModule
+  // and AppKitWindowModule already use. src/useWindow.ts calls each one
+  // optionally -- NativeWindow?.minimize?.() -- so a host that leaves them out
+  // does not fail, it silently does nothing, which is how these were missing
+  // here while working on the other two desktops.
+  methodMap_["minimize"] = MethodMetadata{0, minimize};
+  methodMap_["toggleMaximize"] = MethodMetadata{0, toggleMaximize};
+  methodMap_["close"] = MethodMetadata{0, closeWindow};
+  methodMap_["startWindowDrag"] = MethodMetadata{0, startWindowDrag};
+  // A window's geometry. The bodies are in core/WindowMethods.h, written once:
+  // nothing about reading two numbers or shaping the answer differs per
+  // desktop, and three copies would be three chances to drift.
+  methodMap_["setSize"] = MethodMetadata{2, windowSetSize};
+  methodMap_["setPosition"] = MethodMetadata{2, windowSetPosition};
+  methodMap_["center"] = MethodMetadata{0, windowCenter};
+  methodMap_["setFullScreen"] = MethodMetadata{1, windowSetFullScreen};
+  // How big it may be, whether it may be resized at all, and whether it floats.
+  // Not every desktop does every one of these; `getCapabilities` is how an app
+  // finds out rather than guessing. See core/WindowControl.h.
+  methodMap_["setMinimumSize"] = MethodMetadata{2, windowSetMinimumSize};
+  methodMap_["setMaximumSize"] = MethodMetadata{2, windowSetMaximumSize};
+  methodMap_["setResizable"] = MethodMetadata{1, windowSetResizable};
+  methodMap_["setAlwaysOnTop"] = MethodMetadata{1, windowSetAlwaysOnTop};
+  methodMap_["getCapabilities"] = MethodMetadata{0, windowGetCapabilities};
+  methodMap_["getBounds"] = MethodMetadata{0, windowGetBounds};
+  // What a NativeEventEmitter over this module calls; the events go out as
+  // device events either way.
+  methodMap_["addListener"] = MethodMetadata{1, noop};
+  methodMap_["removeListeners"] = MethodMetadata{1, noop};
+
+  // Cleared in the destructor, the same arrangement AppearanceModule has with
+  // its colour scheme observer.
+  titleBar().setMetricsListener([this](const TitleBarMetrics &metrics) {
+    emitDeviceEvent(kMetricsChangedEvent, [metrics](Runtime &runtime, std::vector<Value> &args) {
+      args.emplace_back(metricsValue(runtime, metrics));
+    });
+  });
+
+  // The window's geometry, the same way the title bar's metrics go out: a
+  // device event, so `useWindow()` can hand an app live bounds rather than a
+  // snapshot it has to remember to refresh.
+  setWindowBoundsListener([this](const WindowBounds &bounds) {
+    emitDeviceEvent(kWindowBoundsEvent, [bounds](Runtime &runtime, std::vector<Value> &args) {
+      Object object(runtime);
+      object.setProperty(runtime, "x", bounds.x);
+      object.setProperty(runtime, "y", bounds.y);
+      object.setProperty(runtime, "width", bounds.width);
+      object.setProperty(runtime, "height", bounds.height);
+      object.setProperty(runtime, "fullScreen", bounds.fullScreen);
+      object.setProperty(runtime, "maximized", bounds.maximized);
+      args.emplace_back(Value(runtime, object));
+    });
+  });
+
+  // And ask for the bounds once, now that something is listening. The host
+  // primes the cache when its window appears, but this module is built lazily
+  // -- the first time JavaScript asks for it -- so an app that mounts before
+  // then would read a window of no size and never be told otherwise.
+  postToUiThread([] { notifyWindowBoundsChanged(); });
+}
+
+Win32WindowModule::~Win32WindowModule() {
+  titleBar().setMetricsListener(nullptr);
+  setWindowBoundsListener(nullptr);
+}
+
+Value Win32WindowModule::setTitle(Runtime &runtime,
+                                  TurboModule & /*module*/,
+                                  const Value *args,
+                                  size_t count) {
+  std::optional<std::string> title;
+  if (count > 0 && args[0].isString()) {
+    title = args[0].getString(runtime).utf8(runtime);
+  }
+  postToUiThread([title = std::move(title)]() mutable { titleBar().setTitle(std::move(title)); });
+  return Value::undefined();
+}
+
+Value Win32WindowModule::setTitleBarColors(Runtime & /*runtime*/,
+                                           TurboModule & /*module*/,
+                                           const Value *args,
+                                           size_t count) {
+  const auto caption = colorArgument(args, count, 0);
+  const auto text = colorArgument(args, count, 1);
+  const auto border = colorArgument(args, count, 2);
+  postToUiThread([caption, text, border] { titleBar().setColors(caption, text, border); });
+  return Value::undefined();
+}
+
+Value Win32WindowModule::setTitleBarStyle(Runtime &runtime,
+                                          TurboModule & /*module*/,
+                                          const Value *args,
+                                          size_t count) {
+  const bool hidden =
+      count > 0 && args[0].isString() && args[0].getString(runtime).utf8(runtime) == "hidden";
+  postToUiThread([hidden] {
+    titleBar().setStyle(hidden ? TitleBarStyle::Hidden : TitleBarStyle::Native);
+  });
+  return Value::undefined();
+}
+
+Value Win32WindowModule::getTitleBarMetrics(Runtime &runtime,
+                                            TurboModule & /*module*/,
+                                            const Value * /*args*/,
+                                            size_t /*count*/) {
+  return metricsValue(runtime, titleBar().metrics());
+}
+
+// The four below are GtkWindowModule's bodies with the toolkit swapped: the
+// work is one call on the UI thread, and the shape is identical on purpose, so
+// that a reader comparing the three hosts sees the same thing three times
+// rather than three arrangements of it.
+Value Win32WindowModule::minimize(Runtime & /*runtime*/,
+                                  TurboModule & /*module*/,
+                                  const Value * /*args*/,
+                                  size_t /*count*/) {
+  postToUiThread([] { titleBar().minimize(); });
+  return Value::undefined();
+}
+
+Value Win32WindowModule::toggleMaximize(Runtime & /*runtime*/,
+                                        TurboModule & /*module*/,
+                                        const Value * /*args*/,
+                                        size_t /*count*/) {
+  postToUiThread([] { titleBar().toggleMaximize(); });
+  return Value::undefined();
+}
+
+Value Win32WindowModule::closeWindow(Runtime & /*runtime*/,
+                                     TurboModule & /*module*/,
+                                     const Value * /*args*/,
+                                     size_t /*count*/) {
+  postToUiThread([] { titleBar().close(); });
+  return Value::undefined();
+}
+
+Value Win32WindowModule::startWindowDrag(Runtime & /*runtime*/,
+                                         TurboModule & /*module*/,
+                                         const Value * /*args*/,
+                                         size_t /*count*/) {
+  postToUiThread([] { titleBar().startDrag(); });
+  return Value::undefined();
+}
+
+Value Win32WindowModule::noop(Runtime & /*runtime*/,
+                              TurboModule & /*module*/,
+                              const Value * /*args*/,
+                              size_t /*count*/) {
+  return Value::undefined();
+}
+
+} // namespace basalt

package/native/win32/Win32WindowModule.h

@@ -0,0 +1,72 @@
+// BasaltWindow: the window's title bar, reached from JavaScript.
+//
+// basalt-core's src/TitleBar.js is the API over this -- useTitleBar,
+// <TitleBar>, useTitleBarMetrics -- and Win32TitleBar is what it drives. A
+// module with no React Native spec, written the way the gesture handler one
+// is, because it is this platform's own and there is no spec for it to follow.
+//
+// Every method is called on the JavaScript thread and posts its request to the
+// UI thread, where the window lives. getTitleBarMetrics answers from a copy the
+// title bar keeps under a lock, and "basaltTitleBarMetricsChanged" is emitted
+// whenever that copy changes.
+
+#pragma once
+
+#include <ReactCommon/TurboModule.h>
+
+#include <memory>
+
+namespace basalt {
+
+class Win32WindowModule : public facebook::react::TurboModule {
+ public:
+  static constexpr const char *kModuleName = "BasaltWindow";
+
+  explicit Win32WindowModule(std::shared_ptr<facebook::react::CallInvoker> jsInvoker);
+  ~Win32WindowModule() override;
+
+ private:
+  static facebook::jsi::Value setTitle(facebook::jsi::Runtime &runtime,
+                                       facebook::react::TurboModule &module,
+                                       const facebook::jsi::Value *args,
+                                       size_t count);
+  static facebook::jsi::Value setTitleBarColors(facebook::jsi::Runtime &runtime,
+                                                facebook::react::TurboModule &module,
+                                                const facebook::jsi::Value *args,
+                                                size_t count);
+  static facebook::jsi::Value setTitleBarStyle(facebook::jsi::Runtime &runtime,
+                                               facebook::react::TurboModule &module,
+                                               const facebook::jsi::Value *args,
+                                               size_t count);
+  static facebook::jsi::Value getTitleBarMetrics(facebook::jsi::Runtime &runtime,
+                                                 facebook::react::TurboModule &module,
+                                                 const facebook::jsi::Value *args,
+                                                 size_t count);
+  // The caption's four actions. GtkWindowModule and AppKitWindowModule
+  // register the same four under the same names; this host registered none of
+  // them, so useWindow().minimize() and .close() were silent no-ops here while
+  // working on the other two desktops -- and useCloseRequest could refuse a
+  // close and then not be able to honour agreeing to it.
+  static facebook::jsi::Value minimize(facebook::jsi::Runtime &runtime,
+                                       facebook::react::TurboModule &module,
+                                       const facebook::jsi::Value *args,
+                                       size_t count);
+  static facebook::jsi::Value toggleMaximize(facebook::jsi::Runtime &runtime,
+                                             facebook::react::TurboModule &module,
+                                             const facebook::jsi::Value *args,
+                                             size_t count);
+  static facebook::jsi::Value closeWindow(facebook::jsi::Runtime &runtime,
+                                          facebook::react::TurboModule &module,
+                                          const facebook::jsi::Value *args,
+                                          size_t count);
+  static facebook::jsi::Value startWindowDrag(facebook::jsi::Runtime &runtime,
+                                              facebook::react::TurboModule &module,
+                                              const facebook::jsi::Value *args,
+                                              size_t count);
+  static facebook::jsi::Value noop(facebook::jsi::Runtime &runtime,
+                                   facebook::react::TurboModule &module,
+                                   const facebook::jsi::Value *args,
+                                   size_t count);
+};
+
+} // namespace basalt

package/native/win32/demo_layout_win32.cpp

@@ -0,0 +1,232 @@
+// The Windows view layer, driven by hand-written frames.
+//
+// The same standing-in-for-Fabric exercise as gtk/demo_layout_gtk.cpp and
+// appkit/demo_layout_appkit.mm, with the same boxes at the same coordinates, so
+// the three platforms can be compared directly rather than by eye. Builds and
+// runs without React Native's C++ core, which keeps the paint and placement
+// path verifiable on its own.
+//
+// Three modes. BASALT_DUMP_TREE prints the tree and exits. BASALT_SNAPSHOT=<png>
+// renders the hierarchy offscreen and writes it, which is the mode that proves
+// anything: the tree dump would look identical whether the transform
+// composition works or not, because it prints the frames that were set rather
+// than where they landed. Neither needs a window. Without either, it opens one.
+//
+// A console subsystem rather than a GUI one, deliberately: BASALT_DUMP_TREE has
+// to reach a pipe, and `scripts/compare_hosts.sh` is what reads it.
+
+#include "RnWin32View.h"
+#include "Win32Snapshot.h"
+
+#include <windows.h>
+
+#include <d2d1.h>
+#include <wrl/client.h>
+
+#include <cstdio>
+#include <cstdlib>
+#include <memory>
+#include <string>
+#include <vector>
+
+using Microsoft::WRL::ComPtr;
+using basalt::win32::RnWin32View;
+
+namespace {
+
+// The demo owns its views. In the real thing the mounting registry does; a view
+// never owns its children, which is what makes Fabric's detach-without-destroy
+// structural rather than a reference count to get right.
+std::vector<std::unique_ptr<RnWin32View>> g_views;
+
+RnWin32View *makeBox(int32_t tag,
+                     float x,
+                     float y,
+                     float w,
+                     float h,
+                     float r,
+                     float g,
+                     float b,
+                     float a) {
+  auto view = std::make_unique<RnWin32View>(tag);
+  view->setFrame(x, y, w, h);
+  view->setBackgroundColor(r, g, b, a, true);
+  RnWin32View *raw = view.get();
+  g_views.push_back(std::move(view));
+  return raw;
+}
+
+RnWin32View *buildTree() {
+  RnWin32View *root = makeBox(1, 0, 0, 640, 420, 0.12f, 0.13f, 0.16f, 1.0f);
+
+  // A row of children, absolutely placed the way Yoga would have resolved them.
+  RnWin32View *a = makeBox(2, 32, 32, 240, 160, 0.30f, 0.55f, 0.95f, 1.0f);
+  RnWin32View *b = makeBox(3, 296, 32, 240, 160, 0.95f, 0.45f, 0.35f, 1.0f);
+  RnWin32View *c = makeBox(4, 32, 224, 504, 140, 0.35f, 0.80f, 0.55f, 1.0f);
+
+  root->insertChild(a, 0);
+  root->insertChild(b, 1);
+  root->insertChild(c, 2);
+
+  // Nested child, to prove coordinates are parent-relative. Win32 and React
+  // Native agree on a top-left origin, so unlike the AppKit side there is no
+  // flip for this to catch -- what it catches here is a transform composed in
+  // the wrong order, which puts it 24 units from the wrong edge just as surely.
+  RnWin32View *nested = makeBox(5, 24, 24, 120, 90, 1.0f, 1.0f, 1.0f, 0.85f);
+  a->insertChild(nested, 0);
+
+  // Half-opacity child, to prove the opacity layer. Distinct from the alpha
+  // above: that one is a translucent colour, this one is a translucent view.
+  RnWin32View *faded = makeBox(6, 24, 24, 160, 90, 0.1f, 0.1f, 0.1f, 1.0f);
+  faded->setOpacity(0.4f);
+  c->insertChild(faded, 0);
+
+  return root;
+}
+
+// --- The window ------------------------------------------------------------
+//
+// One HWND for the whole tree. See RnWin32View.h for why a view is not a
+// window; this is the other half of that decision, and it is what the host will
+// grow into.
+
+struct DemoWindow {
+  RnWin32View *root = nullptr;
+  ComPtr<ID2D1Factory> factory;
+  ComPtr<ID2D1HwndRenderTarget> target;
+};
+
+bool ensureTarget(DemoWindow *demo, HWND hwnd) {
+  if (demo->target) {
+    return true;
+  }
+  RECT client{};
+  GetClientRect(hwnd, &client);
+  const D2D1_SIZE_U size = D2D1::SizeU(static_cast<UINT32>(client.right - client.left),
+                                       static_cast<UINT32>(client.bottom - client.top));
+  if (size.width == 0 || size.height == 0) {
+    return false;
+  }
+  return SUCCEEDED(demo->factory->CreateHwndRenderTarget(
+      D2D1::RenderTargetProperties(), D2D1::HwndRenderTargetProperties(hwnd, size), &demo->target));
+}
+
+LRESULT CALLBACK windowProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam) {
+  auto *demo = reinterpret_cast<DemoWindow *>(GetWindowLongPtr(hwnd, GWLP_USERDATA));
+
+  switch (message) {
+    case WM_CREATE: {
+      auto *create = reinterpret_cast<CREATESTRUCT *>(lparam);
+      SetWindowLongPtr(hwnd, GWLP_USERDATA, reinterpret_cast<LONG_PTR>(create->lpCreateParams));
+      return 0;
+    }
+
+    case WM_SIZE:
+      if (demo != nullptr && demo->target) {
+        demo->target->Resize(D2D1::SizeU(LOWORD(lparam), HIWORD(lparam)));
+      }
+      return 0;
+
+    case WM_PAINT: {
+      PAINTSTRUCT paint{};
+      BeginPaint(hwnd, &paint);
+      if (demo != nullptr && ensureTarget(demo, hwnd)) {
+        demo->target->BeginDraw();
+        demo->target->Clear(D2D1::ColorF(D2D1::ColorF::Black));
+        demo->target->SetTransform(D2D1::Matrix3x2F::Identity());
+        demo->root->paint(demo->target.Get());
+        // A lost device is reported here and nowhere else. Dropping the target
+        // is the whole recovery: the next WM_PAINT rebuilds it.
+        if (demo->target->EndDraw() == D2DERR_RECREATE_TARGET) {
+          demo->target.Reset();
+        }
+      }
+      EndPaint(hwnd, &paint);
+      return 0;
+    }
+
+    case WM_DESTROY:
+      PostQuitMessage(0);
+      return 0;
+
+    default:
+      break;
+  }
+  return DefWindowProc(hwnd, message, wparam, lparam);
+}
+
+int runWindow(RnWin32View *root) {
+  DemoWindow demo;
+  demo.root = root;
+  if (FAILED(D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, demo.factory.GetAddressOf()))) {
+    std::fputs("could not create a Direct2D factory\n", stderr);
+    return 1;
+  }
+
+  const HINSTANCE instance = GetModuleHandle(nullptr);
+  WNDCLASSEX windowClass{};
+  windowClass.cbSize = sizeof(windowClass);
+  windowClass.style = CS_HREDRAW | CS_VREDRAW;
+  windowClass.lpfnWndProc = windowProc;
+  windowClass.hInstance = instance;
+  windowClass.hCursor = LoadCursor(nullptr, IDC_ARROW);
+  windowClass.lpszClassName = L"BasaltDemoLayout";
+  if (RegisterClassEx(&windowClass) == 0) {
+    std::fputs("could not register the window class\n", stderr);
+    return 1;
+  }
+
+  // The client area is the surface, so the window is grown by whatever the
+  // frame costs. Getting this wrong scales the whole tree by a few per cent,
+  // which is exactly the kind of difference a cross-host comparison is for.
+  RECT wanted{0, 0, static_cast<LONG>(root->frame().width),
+              static_cast<LONG>(root->frame().height)};
+  AdjustWindowRect(&wanted, WS_OVERLAPPEDWINDOW, FALSE);
+
+  const HWND hwnd = CreateWindowEx(0,
+                                   windowClass.lpszClassName,
+                                   L"basalt-core \x2014 Windows layout skeleton",
+                                   WS_OVERLAPPEDWINDOW,
+                                   CW_USEDEFAULT,
+                                   CW_USEDEFAULT,
+                                   wanted.right - wanted.left,
+                                   wanted.bottom - wanted.top,
+                                   nullptr,
+                                   nullptr,
+                                   instance,
+                                   &demo);
+  if (hwnd == nullptr) {
+    std::fputs("could not create the window\n", stderr);
+    return 1;
+  }
+
+  ShowWindow(hwnd, SW_SHOWNORMAL);
+  UpdateWindow(hwnd);
+
+  MSG message{};
+  while (GetMessage(&message, nullptr, 0, 0) > 0) {
+    TranslateMessage(&message);
+    DispatchMessage(&message);
+  }
+  return static_cast<int>(message.wParam);
+}
+
+} // namespace
+
+int main(int argc, char **argv) {
+  (void)argc;
+  (void)argv;
+
+  RnWin32View *root = buildTree();
+
+  if (std::getenv("BASALT_DUMP_TREE") != nullptr) {
+    std::fputs(root->describeTree().c_str(), stdout);
+    return 0;
+  }
+
+  if (const char *snapshotPath = std::getenv("BASALT_SNAPSHOT")) {
+    return basalt::win32::writeSnapshot(*root, snapshotPath) ? 0 : 1;
+  }
+
+  return runWindow(root);
+}