basalt-core 0.0.0-rc5

package/native/core/ColorScheme.cpp

@@ -0,0 +1,105 @@
+#include "ColorScheme.h"
+
+#include <mutex>
+#include <unordered_map>
+
+namespace basalt {
+
+namespace {
+
+struct Registry {
+  std::mutex mutex;
+  bool hasOverride{false};
+  ColorScheme override{ColorScheme::Light};
+  int nextToken{1};
+  std::unordered_map<int, ColorSchemeObserver> observers;
+};
+
+Registry &registry() {
+  static Registry instance;
+  return instance;
+}
+
+} // namespace
+
+const char *colorSchemeName(ColorScheme scheme) {
+  return scheme == ColorScheme::Dark ? "dark" : "light";
+}
+
+ColorScheme effectiveColorScheme() {
+  {
+    Registry &state = registry();
+    const std::lock_guard<std::mutex> lock(state.mutex);
+    if (state.hasOverride) {
+      return state.override;
+    }
+  }
+  // Outside the lock: a platform's answer may take a trip to the window server,
+  // and holding the lock across that would serialise every reader behind it.
+  return systemColorScheme();
+}
+
+void setColorSchemeOverride(const std::string &scheme) {
+  if (scheme.empty()) {
+    clearColorSchemeOverride();
+    return;
+  }
+
+  {
+    Registry &state = registry();
+    const std::lock_guard<std::mutex> lock(state.mutex);
+    state.hasOverride = true;
+    state.override = scheme == "dark" ? ColorScheme::Dark : ColorScheme::Light;
+  }
+  notifyColorSchemeChanged();
+}
+
+void clearColorSchemeOverride() {
+  {
+    Registry &state = registry();
+    const std::lock_guard<std::mutex> lock(state.mutex);
+    if (!state.hasOverride) {
+      return;
+    }
+    state.hasOverride = false;
+  }
+  notifyColorSchemeChanged();
+}
+
+int addColorSchemeObserver(ColorSchemeObserver observer) {
+  Registry &state = registry();
+  const std::lock_guard<std::mutex> lock(state.mutex);
+  const int token = state.nextToken++;
+  state.observers.emplace(token, std::move(observer));
+  return token;
+}
+
+void removeColorSchemeObserver(int token) {
+  Registry &state = registry();
+  const std::lock_guard<std::mutex> lock(state.mutex);
+  state.observers.erase(token);
+}
+
+void notifyColorSchemeChanged() {
+  const ColorScheme scheme = effectiveColorScheme();
+
+  // Copied under the lock and called outside it: an observer emits into
+  // JavaScript, which can re-enter here -- `Appearance.setColorScheme` called
+  // from a change handler is a perfectly ordinary thing for an app to do.
+  std::vector<ColorSchemeObserver> observers;
+  {
+    Registry &state = registry();
+    const std::lock_guard<std::mutex> lock(state.mutex);
+    observers.reserve(state.observers.size());
+    for (const auto &[token, observer] : state.observers) {
+      (void)token;
+      observers.push_back(observer);
+    }
+  }
+
+  for (const auto &observer : observers) {
+    observer(scheme);
+  }
+}
+
+} // namespace basalt

package/native/core/ColorScheme.h

@@ -0,0 +1,59 @@
+// Whether the system is in light or dark mode.
+//
+// The fourth seam a desktop platform owes, after fonts, the text layout manager
+// and the component registry. Everything about `Appearance` *except* the answer
+// is portable -- the module, the JavaScript-side override, the listener list,
+// the event -- and the answer is two functions.
+//
+// Split this way because the interesting part is not reading the setting, it is
+// that React Native's `Appearance.setColorScheme` lets JavaScript override it
+// process-wide, and that the override has to win over the system for every
+// later read. Putting that in core means neither platform can get it subtly
+// different.
+
+#pragma once
+
+#include <functional>
+#include <string>
+
+namespace basalt {
+
+enum class ColorScheme { Light, Dark };
+
+// --- What a platform provides ----------------------------------------------
+
+// What the operating system currently says. Called on any thread.
+ColorScheme systemColorScheme();
+
+// Starts watching for changes, calling `notifyColorSchemeChanged` when the
+// system setting moves. Called once, on the main thread, from the host.
+//
+// A platform that cannot watch may do nothing: `getColorScheme` still answers
+// correctly, and only live switching is lost.
+void startObservingColorScheme();
+
+// --- What core provides ------------------------------------------------------
+
+// The scheme an app should use: the override if one was set, the system
+// otherwise.
+ColorScheme effectiveColorScheme();
+
+// `Appearance.setColorScheme`. Passing nullopt-equivalent -- an empty string
+// from JavaScript -- clears the override and hands control back to the system.
+void setColorSchemeOverride(const std::string &scheme);
+void clearColorSchemeOverride();
+
+// Called by a platform's observer when the system setting changes. Notifies
+// every listener, unless an override is in force -- in which case nothing an
+// app can see has changed.
+void notifyColorSchemeChanged();
+
+// Listeners. The token is what removes one; the module holds one for its life.
+using ColorSchemeObserver = std::function<void(ColorScheme)>;
+int addColorSchemeObserver(ColorSchemeObserver observer);
+void removeColorSchemeObserver(int token);
+
+// "light" or "dark", as React Native's JavaScript spells them.
+const char *colorSchemeName(ColorScheme scheme);
+
+} // namespace basalt

package/native/core/ComponentRegistry.h

@@ -0,0 +1,30 @@
+// Which components a platform supports — a seam, not a list.
+//
+// `getDefaultComponentRegistryFactory()` is declared by ReactCommon and
+// deliberately *not* defined there: no .cpp in the whole tree implements it.
+// Each host supplies its own, and in doing so declares what its platform can
+// actually put on screen. Fantom has a version registering the full set.
+//
+// This used to be one shared definition, on the reasonable-looking grounds that
+// a descriptor is portable C++ and registering one costs nothing. Linking the
+// macOS mounting manager disproved that. Registering ParagraphComponentDescriptor
+// constructs a `TextLayoutManager`, whose implementation this build deliberately
+// replaces per platform -- Pango on Linux -- so a platform that has no text
+// engine yet does not fail to render text, it fails to link. Which is the right
+// failure, and is why the registry belongs beside the platform rather than in
+// core.
+//
+// So each platform defines this function in its own translation unit:
+//
+//   gtk/ComponentRegistryGtk.cpp   View, Paragraph, Text, RawText, Image,
+//                                  ScrollView, TextInput
+//   mac/ComponentRegistryAppKit.mm    View
+//
+// and the set it registers must match what that platform's mounting manager
+// answers `hasComponent` for. They are two statements of the same fact, and
+// when they disagree the registry wins and builds shadow nodes nothing can
+// mount -- which renders as blank rectangles rather than as an error.
+
+#pragma once
+
+#include <react/renderer/componentregistry/ComponentDescriptorFactory.h>

package/native/core/ControlMetrics.h

@@ -0,0 +1,37 @@
+// How big a control is, on every desktop.
+//
+// Separate from DesktopControls.h, which is where everything else about a
+// control lives, for one reason: the Windows view layer draws its own switch
+// and its own spinner and deliberately does not link React Native -- the demo
+// and half its tests build a view tree with no Fabric anywhere -- so it cannot
+// include a header that pulls in ShadowView. It can include this, which is four
+// numbers and nothing else. FocusRing.h is here for the same reason.
+//
+// Constants rather than each toolkit's intrinsic size, so that a layout built
+// against one desktop is the same on the other two. A GtkSwitch and an NSSwitch
+// are both smaller than this, and a screen that fits on a Mac and reflows on
+// Linux is the failure this project exists to avoid.
+
+#pragma once
+
+namespace basalt {
+
+// React Native's <Switch> size on iOS, which is what app layouts are written
+// against -- and what SwitchShadowNode::measureContent answers, since React
+// Native's only <Switch> shadow node measures by instantiating a UISwitch.
+inline constexpr float kSwitchWidth = 51.0F;
+inline constexpr float kSwitchHeight = 31.0F;
+
+// <ActivityIndicator>'s two sizes. React Native's JavaScript also writes these
+// into the view's style, so these are for the drawing rather than the layout --
+// which is exactly why they have to agree with it.
+inline constexpr float kSpinnerSmall = 20.0F;
+inline constexpr float kSpinnerLarge = 36.0F;
+
+// React DevTools' overlay outline, in points. The same on every platform so
+// that a screenshot of an inspected element is the same picture from any of
+// them. Here rather than in DebuggingOverlay.h for the reason this file exists:
+// a view layer draws it and does not link React Native.
+inline constexpr float kHighlightBorderWidth = 2.0F;
+
+} // namespace basalt