basalt-appkit 0.0.0-rc5 → 0.2.0

package/native/appkit/AppKitWindowControl.mm

@@ -14,6 +14,8 @@
 #include <vector>
 #include "WindowControl.h"
 
+#import "AppKitAppWindow.h"
+
 #import <Cocoa/Cocoa.h>
 
 namespace basalt {
@@ -21,9 +23,27 @@ namespace basalt {
 namespace {
 
 
-NSWindow *window() {
-  return NSApp.keyWindow != nil ? NSApp.keyWindow : NSApp.mainWindow;
-}
+// The window this process owns, which is a different question from which window
+// has the keyboard.
+//
+// `NSApp.keyWindow` and `NSApp.mainWindow` are both nil whenever the app is not
+// the active one: a background app has no key window and no main window. Asking
+// only those two meant an app that was not frontmost read a *zero* size out of
+// `getBounds()` and had `setSize` silently do nothing.
+//
+// That is worse than it sounds, because the bounds cache is primed once at
+// startup, immediately after `activateIgnoringOtherApps:`, and activation is
+// asynchronous. If the window server had not granted it by then the cache was
+// zeroed, and nothing corrected it: the only thing that writes the cache again
+// is a move or a resize, and a window nobody is using gets neither. An app
+// launched while another window had focus therefore believed it was 0x0 for its
+// whole life, which is how `e2e/window.tsx` found this.
+//
+// GTK had the rule right already -- GtkWindowControl.cpp prefers the active
+// toplevel and falls back to the first visible one -- so this is the same rule
+// rather than a new idea. A panel is skipped: LogBox and the dev menu are
+// windows too, and neither is what an app means by "my window".
+NSWindow *window() { return appWindow(); }
 
 // The height AppKit measures y from. `NSScreen.screens.firstObject` is the
 // primary display, which is the one AppKit's global coordinates are anchored
@@ -35,6 +55,21 @@ CGFloat primaryHeight() {
 
 } // namespace
 
+NSWindow *appWindow() {
+  if (NSApp.keyWindow != nil) {
+    return NSApp.keyWindow;
+  }
+  if (NSApp.mainWindow != nil) {
+    return NSApp.mainWindow;
+  }
+  for (NSWindow *candidate in NSApp.windows) {
+    if (candidate.isVisible && ![candidate isKindOfClass:NSPanel.class]) {
+      return candidate;
+    }
+  }
+  return nil;
+}
+
 std::vector<DisplayInfo> displays() {
   std::vector<DisplayInfo> found;
   @autoreleasepool {

package/native/appkit/ComponentRegistryAppKit.mm

@@ -18,10 +18,13 @@
 
 #include "ComponentRegistry.h"
 #include "ExpoImageComponent.h"
+#include "SafeAreaComponent.h"
+#include "ScreensComponent.h"
 
 #include <react/renderer/componentregistry/ComponentDescriptorProviderRegistry.h>
 
 #include "SkiaPictureViewComponent.h"
+#include "SkiaViewComponent.h"
 #include <react/renderer/components/FBReactNativeSpec/ComponentDescriptors.h>
 #include <react/renderer/components/image/ImageComponentDescriptor.h>
 #include <react/renderer/components/iostextinput/TextInputComponentDescriptor.h>
@@ -41,6 +44,24 @@ ComponentRegistryFactory getDefaultComponentRegistryFactory() {
     static auto providerRegistry = []() {
       auto registry = std::make_shared<ComponentDescriptorProviderRegistry>();
       registry->add(concreteComponentDescriptorProvider<ViewComponentDescriptor>());
+      // react-native-safe-area-context's provider. Registered on every
+      // platform, like expo-image's above: the descriptor is ordinary Fabric
+      // C++ and an app that never mounts one pays a registry entry. Without
+      // it the provider renders its children never, not badly. See
+      // core/SafeAreaComponent.h.
+      registry->add(concreteComponentDescriptorProvider<SafeAreaProviderComponentDescriptor>());
+      // react-native-screens. RNSScreen carries activityState, which is what
+      // hides the screen behind the one in front; the rest are containers that
+      // only need their names known, since an unregistered name becomes
+      // UnimplementedNativeView and carries none of the layout props. See
+      // core/ScreensComponent.h.
+      registry->add(concreteComponentDescriptorProvider<RNSScreenComponentDescriptor>());
+      registry->add(concreteComponentDescriptorProvider<RNSScreenStackComponentDescriptor>());
+      registry->add(concreteComponentDescriptorProvider<RNSScreenContainerComponentDescriptor>());
+      registry->add(concreteComponentDescriptorProvider<RNSScreenNavigationContainerComponentDescriptor>());
+      registry->add(concreteComponentDescriptorProvider<RNSScreenContentWrapperComponentDescriptor>());
+      registry->add(concreteComponentDescriptorProvider<RNSScreenStackHeaderConfigComponentDescriptor>());
+      registry->add(concreteComponentDescriptorProvider<RNSScreenStackHeaderSubviewComponentDescriptor>());
       // Text is three descriptors and only one of them mounts. <Text> becomes a
       // Text node, its string a RawText node, and the outermost <Text> a
       // Paragraph that folds the whole subtree into a single AttributedString.
@@ -61,11 +82,15 @@ ComponentRegistryFactory getDefaultComponentRegistryFactory() {
       // through a TextLayoutManager, which here is the Core Text one.
       // Android's needs fbjni. Its component name is "TextInput".
       registry->add(concreteComponentDescriptorProvider<TextInputComponentDescriptor>());
-      // @shopify/react-native-skia's <Canvas>. Registered whether or not the
-      // build has Skia in it, for the reason the Expo one below gives: it costs
-      // a name in a registry. Without Skia the view mounts and stays empty, and
+      // React Native Skia's <Canvas>, under both of its names: 2.x mounts a
+      // "SkiaPictureView" and 3.x a "SkiaView", and which one an app mounts is
+      // decided by the Skia it installed, which a host binary cannot know
+      // until the app's JavaScript runs. Registered whether or not the build
+      // has Skia in it, for the reason the Expo one below gives: it costs a
+      // name in a registry. Without Skia the view mounts and stays empty, and
       // an app that draws has already failed at getEnforcing('RNSkiaModule').
       registry->add(concreteComponentDescriptorProvider<SkiaPictureViewComponentDescriptor>());
+      registry->add(concreteComponentDescriptorProvider<SkiaViewComponentDescriptor>());
       // expo-image's view. Registered whether or not the build has Expo in it:
       // the descriptor is ordinary Fabric C++, and an app that never renders
       // one pays a registry entry. See core/ExpoImageComponent.h.

package/native/appkit/CoreTextLayout.h

@@ -24,6 +24,9 @@
 
 #import "RnTextLayout.h"
 
+#include "FontFitting.h"
+#include "TextAlignments.h"
+
 #include <react/renderer/attributedstring/AttributedString.h>
 #include <react/renderer/attributedstring/ParagraphAttributes.h>
 #include <react/renderer/attributedstring/TextAttributes.h>
@@ -31,13 +34,72 @@
 namespace basalt {
 
 // Builds a layout for `attributedString`.
+//
+// `fit` is `adjustsFontSizeToFit`'s answer: the ratio every font size is
+// multiplied by and the two bounds it is clamped against. The default is what a
+// paragraph that never asked gets, which changes nothing -- see
+// core/FontFitting.h.
 RnTextLayout *buildTextLayout(const facebook::react::AttributedString &attributedString,
-                              const facebook::react::ParagraphAttributes &paragraphAttributes);
+                              const facebook::react::ParagraphAttributes &paragraphAttributes,
+                              basalt::FontFit fit = {});
+
+// How far this paragraph's fonts have to shrink to fit a box, for
+// `adjustsFontSizeToFit`.
+//
+// The search is core's; this is the half that measures, which means building a
+// layout per probe -- about eight of them -- and is why it runs only for a
+// paragraph that asked. Both the measurement seam and the mounting manager call
+// it, with the constraints and the frame respectively, so the text is painted
+// at the size it was measured at.
+basalt::FontFit textFitScale(const facebook::react::AttributedString &attributedString,
+                             const facebook::react::ParagraphAttributes &paragraphAttributes,
+                             float maxWidth,
+                             float maxHeight);
+
+// One fragment's text with its `textTransform` applied, which has to happen
+// before anything measures the string *and* before anything indexes into it: a
+// transform can change the length -- ß uppercases to SS -- so an attachment
+// after one would otherwise be looked up at the wrong offset. Shared with
+// CoreTextLayoutManager.mm for exactly that reason.
+NSString *transformedFragmentText(const facebook::react::AttributedString::Fragment &fragment,
+                                  NSString *text);
 
 // The attributes for a whole string, for anything that holds its own text
 // rather than a layout built here -- the equivalent of Pango's
 // buildTextAttributes, and what a <TextInput> will need.
+// `directions` is which way the text runs and what `start` and `end` mean,
+// which the relative alignments need; see core/TextAlignments.h. A caller that
+// holds its own text and resolves its own direction -- an NSTextField --
+// passes neither and leaves `natural` to AppKit.
 NSDictionary<NSAttributedStringKey, id> *buildTextAttributes(
-    const facebook::react::TextAttributes &textAttributes);
+    const facebook::react::TextAttributes &textAttributes,
+    basalt::FontFit fit = {},
+    basalt::TextDirections directions = {});
+
+// `fontVariant` in Core Text's vocabulary, which is not OpenType's: Apple's
+// older AAT pairs, a feature type and a selector inside it, as upstream's
+// `RCTFontFeatures` uses.
+//
+// Exposed for the suite rather than for callers. The mapping is the part this
+// platform owns and a wrong selector would be invisible: `[NSFont
+// fontWithDescriptor:]` resolves against a real font and **drops features that
+// font does not have**, so asking the resolved font what it kept measures the
+// machine's fonts rather than this code. The system font has small caps and
+// tabular figures and has neither oldstyle figures nor a twentieth stylistic
+// set, which is how that was found.
+NSArray *fontFeaturesFor(const facebook::react::TextAttributes &textAttributes);
+
+// The desktop's text scale, which on macOS is 1 and is a function anyway.
+//
+// macOS publishes no scalar for this. Accessibility's "Text size" works through
+// the text-style ramp instead: an app opts in by asking
+// `[NSFont preferredFontForTextStyle:options:]` for its fonts, and the system
+// answers a larger font for the style. That is `dynamicTypeRamp`'s shape rather
+// than `fontSizeMultiplier`'s, and it is a different feature; backlog/text.md
+// records it with that call named.
+//
+// So this exists to say so in one place, and to keep the host's wiring the same
+// shape as GTK's, which does have a scale to read.
+float appKitTextScale();
 
 } // namespace basalt