basalt-appkit 0.0.0-rc5

package/native/appkit/AppKitTextPeer.mm

@@ -0,0 +1,353 @@
+#import "AppKitTextPeer.h"
+
+#import <objc/runtime.h>
+
+// Both peers report gaining focus the same way, and neither superclass does it
+// for us. See the protocol's header comment for why only the gaining half.
+@interface RnAppKitTextField : NSTextField
+@property(nonatomic, assign) NSInteger rnTag;
+@property(nonatomic, weak) id<RnAppKitTextPeerOwner> rnOwner;
+@end
+
+@implementation RnAppKitTextField
+- (BOOL)becomeFirstResponder {
+  const BOOL became = [super becomeFirstResponder];
+  if (became) {
+    [_rnOwner rnFieldDidBecomeFirstResponder:_rnTag];
+  }
+  return became;
+}
+@end
+
+@interface RnAppKitSecureTextField : NSSecureTextField
+@property(nonatomic, assign) NSInteger rnTag;
+@property(nonatomic, weak) id<RnAppKitTextPeerOwner> rnOwner;
+@end
+
+@implementation RnAppKitSecureTextField
+- (BOOL)becomeFirstResponder {
+  const BOOL became = [super becomeFirstResponder];
+  if (became) {
+    [_rnOwner rnFieldDidBecomeFirstResponder:_rnTag];
+  }
+  return became;
+}
+@end
+
+@interface RnAppKitTextView : NSTextView
+@property(nonatomic, assign) NSInteger rnTag;
+@property(nonatomic, weak) id<RnAppKitTextPeerOwner> rnOwner;
+@property(nonatomic, strong, nullable) NSAttributedString *rnPlaceholder;
+@end
+
+@implementation RnAppKitTextView
+- (BOOL)becomeFirstResponder {
+  const BOOL became = [super becomeFirstResponder];
+  if (became) {
+    [_rnOwner rnFieldDidBecomeFirstResponder:_rnTag];
+  }
+  return became;
+}
+
+// An NSTextView has no placeholder, so it is drawn. Over the top of whatever
+// the view drew, which is nothing when the field is empty, and only when it
+// is empty -- the one case a placeholder means anything.
+- (void)drawRect:(NSRect)dirtyRect {
+  [super drawRect:dirtyRect];
+  if (_rnPlaceholder == nil || self.string.length > 0) {
+    return;
+  }
+  // The same origin the first line of real text would take, so the placeholder
+  // does not shift when the user starts typing.
+  [_rnPlaceholder drawAtPoint:NSMakePoint(self.textContainerInset.width +
+                                              self.textContainer.lineFragmentPadding,
+                                          self.textContainerInset.height)];
+}
+
+// Going from empty to one character, and back, changes whether the placeholder
+// should be there at all -- and AppKit has no reason to know that.
+- (void)didChangeText {
+  [super didChangeText];
+  self.needsDisplay = YES;
+}
+@end
+
+NSView *RnPeerNew(BOOL multiline, BOOL secure, NSInteger tag, id owner, id delegate) {
+  if (multiline) {
+    RnAppKitTextView *view = [[RnAppKitTextView alloc] initWithFrame:NSZeroRect];
+    view.rnTag = tag;
+    view.rnOwner = owner;
+    view.delegate = (id<NSTextViewDelegate>)delegate;
+
+    // The RnAppKitView behind it draws the background, border and corner
+    // radius from React Native's style props, so the peer paints none of its
+    // own -- the same reason the single-line field is unbezeled.
+    view.drawsBackground = NO;
+    view.focusRingType = NSFocusRingTypeNone;
+    // No insets of its own: the view already places the peer inside the
+    // content inset Yoga resolved.
+    view.textContainerInset = NSZeroSize;
+    view.textContainer.lineFragmentPadding = 0;
+    // Wrap rather than run off the side. The measured box is already tall
+    // enough for the wrapped text, because the shadow node measures a
+    // multiline input against the real constraints.
+    view.textContainer.widthTracksTextView = YES;
+    view.horizontallyResizable = NO;
+    view.verticallyResizable = YES;
+    // Plain text: React Native styles the whole field through props, and rich
+    // text would let a paste bring its own font in.
+    view.richText = NO;
+    view.allowsUndo = YES;
+    return view;
+  }
+
+  NSTextField *field;
+  if (secure) {
+    RnAppKitSecureTextField *secureField =
+        [[RnAppKitSecureTextField alloc] initWithFrame:NSZeroRect];
+    secureField.rnTag = tag;
+    secureField.rnOwner = owner;
+    field = secureField;
+  } else {
+    RnAppKitTextField *plain = [[RnAppKitTextField alloc] initWithFrame:NSZeroRect];
+    plain.rnTag = tag;
+    plain.rnOwner = owner;
+    field = plain;
+  }
+
+  // One line, and clipped rather than wrapped. An NSTextField wraps by default
+  // once its text outruns its width, which is not what a single-line
+  // <TextInput> does anywhere else -- it scrolls horizontally. Invisible until
+  // a field holds more than it can show, which is why it survived this long.
+  field.usesSingleLineMode = YES;
+  field.lineBreakMode = NSLineBreakByClipping;
+  field.cell.scrollable = YES;
+  field.cell.wraps = NO;
+
+  field.bordered = NO;
+  field.bezeled = NO;
+  field.drawsBackground = NO;
+  field.focusRingType = NSFocusRingTypeNone;
+  field.delegate = (id<NSTextFieldDelegate>)delegate;
+  // Return has to reach doCommandBySelector: rather than being swallowed as a
+  // "do nothing" action, which is what an NSTextField with no target does.
+  field.target = nil;
+  field.action = nullptr;
+  return field;
+}
+
+BOOL RnPeerIsMultiline(NSView *peer) {
+  return peer != nil && [peer isKindOfClass:[NSTextView class]];
+}
+
+NSString *RnPeerText(NSView *peer) {
+  if (peer == nil) {
+    return @"";
+  }
+  if (RnPeerIsMultiline(peer)) {
+    NSString *text = ((NSTextView *)peer).string;
+    return text != nil ? text : @"";
+  }
+  NSString *value = ((NSTextField *)peer).stringValue;
+  return value != nil ? value : @"";
+}
+
+void RnPeerSetText(NSView *peer, NSString *text) {
+  if (peer == nil) {
+    return;
+  }
+  NSString *value = text != nil ? text : @"";
+  if (RnPeerIsMultiline(peer)) {
+    ((NSTextView *)peer).string = value;
+    return;
+  }
+  ((NSTextField *)peer).stringValue = value;
+}
+
+NSRange RnPeerSelection(NSView *peer) {
+  if (peer == nil) {
+    return NSMakeRange(0, 0);
+  }
+  if (RnPeerIsMultiline(peer)) {
+    // An NSTextView is its own editor, so the selection is always available --
+    // which is the one place multiline is simpler than single line here.
+    return ((NSTextView *)peer).selectedRange;
+  }
+  NSTextField *field = (NSTextField *)peer;
+  if (NSText *editor = field.currentEditor) {
+    return editor.selectedRange;
+  }
+  return NSMakeRange(field.stringValue.length, 0);
+}
+
+void RnPeerSetSelection(NSView *peer, NSRange range) {
+  if (peer == nil) {
+    return;
+  }
+  if (RnPeerIsMultiline(peer)) {
+    NSTextView *view = (NSTextView *)peer;
+    const NSUInteger length = view.string.length;
+    const NSUInteger location = MIN(range.location, length);
+    [view setSelectedRange:NSMakeRange(location, MIN(range.length, length - location))];
+    return;
+  }
+  if (NSText *editor = ((NSTextField *)peer).currentEditor) {
+    editor.selectedRange = range;
+  }
+}
+
+void RnPeerSetEditable(NSView *peer, BOOL editable) {
+  if (peer == nil) {
+    return;
+  }
+  if (RnPeerIsMultiline(peer)) {
+    NSTextView *view = (NSTextView *)peer;
+    view.editable = editable;
+    view.selectable = YES;
+    return;
+  }
+  NSTextField *field = (NSTextField *)peer;
+  field.editable = editable;
+  field.selectable = YES;
+}
+
+void RnPeerSetTextStyle(NSView *peer, NSFont *font, NSColor *colour, NSTextAlignment alignment) {
+  if (peer == nil) {
+    return;
+  }
+  if (RnPeerIsMultiline(peer)) {
+    NSTextView *view = (NSTextView *)peer;
+    if (font != nil) {
+      view.font = font;
+    }
+    if (colour != nil) {
+      view.textColor = colour;
+    }
+    view.alignment = alignment;
+    // What typing continues in. Without it the font and colour apply to what
+    // is there and the next character reverts to the system default.
+    NSMutableDictionary *typing = [NSMutableDictionary dictionary];
+    if (font != nil) {
+      typing[NSFontAttributeName] = font;
+    }
+    if (colour != nil) {
+      typing[NSForegroundColorAttributeName] = colour;
+    }
+    view.typingAttributes = typing;
+    return;
+  }
+  NSTextField *field = (NSTextField *)peer;
+  if (font != nil) {
+    field.font = font;
+  }
+  if (colour != nil) {
+    field.textColor = colour;
+  }
+  field.alignment = alignment;
+}
+
+void RnPeerSetPlaceholder(NSView *peer, NSAttributedString *placeholder) {
+  if (peer == nil) {
+    return;
+  }
+  if (RnPeerIsMultiline(peer)) {
+    RnAppKitTextView *view = (RnAppKitTextView *)peer;
+    view.rnPlaceholder = placeholder;
+    view.needsDisplay = YES;
+    return;
+  }
+  ((NSTextField *)peer).placeholderAttributedString = placeholder;
+}
+
+NSAttributedString *RnPeerPlaceholder(NSView *peer) {
+  if (peer == nil) {
+    return nil;
+  }
+  if (RnPeerIsMultiline(peer)) {
+    return ((RnAppKitTextView *)peer).rnPlaceholder;
+  }
+  return ((NSTextField *)peer).placeholderAttributedString;
+}
+
+// A formatter that refuses anything longer than the limit. NSTextField has no
+// maximum length of its own, and a formatter is what AppKit offers instead --
+// it is consulted on every edit, which is exactly the hook needed.
+@interface RnAppKitLengthFormatter : NSFormatter
+@property(nonatomic, assign) NSInteger maxLength;
+@end
+
+@implementation RnAppKitLengthFormatter
+- (NSString *)stringForObjectValue:(id)object {
+  return [object isKindOfClass:[NSString class]] ? object : nil;
+}
+
+- (BOOL)getObjectValue:(out id *)object
+             forString:(NSString *)string
+      errorDescription:(out NSString **)error {
+  if (object != nullptr) {
+    *object = string;
+  }
+  return YES;
+}
+
+- (BOOL)isPartialStringValid:(NSString *)partial
+            newEditingString:(NSString **)newString
+            errorDescription:(NSString **)error {
+  if (_maxLength <= 0 || (NSInteger)partial.length <= _maxLength) {
+    return YES;
+  }
+  // NO with no replacement: the edit is refused and what was there stays.
+  if (newString != nullptr) {
+    *newString = nil;
+  }
+  if (error != nullptr) {
+    *error = nil;
+  }
+  return NO;
+}
+@end
+
+void RnPeerSetMaxLength(NSView *peer, NSInteger maxLength) {
+  if (peer == nil) {
+    return;
+  }
+  if (RnPeerIsMultiline(peer)) {
+    // Stored, and read back by the delegate through RnPeerAllowsChange. An
+    // NSTextView has no formatter.
+    objc_setAssociatedObject(peer, @selector(RnPeerSetMaxLength), @(maxLength),
+                             OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+    return;
+  }
+
+  NSTextField *field = (NSTextField *)peer;
+  if (maxLength <= 0) {
+    field.formatter = nil;
+    return;
+  }
+  RnAppKitLengthFormatter *formatter = [[RnAppKitLengthFormatter alloc] init];
+  formatter.maxLength = maxLength;
+  field.formatter = formatter;
+}
+
+BOOL RnPeerAllowsChange(NSView *peer, NSRange range, NSString *replacement) {
+  if (peer == nil || !RnPeerIsMultiline(peer)) {
+    return YES;
+  }
+  NSNumber *limit = objc_getAssociatedObject(peer, @selector(RnPeerSetMaxLength));
+  const NSInteger maxLength = limit != nil ? limit.integerValue : 0;
+  if (maxLength <= 0) {
+    return YES;
+  }
+  const NSInteger current = (NSInteger)((NSTextView *)peer).string.length;
+  const NSInteger after = current - (NSInteger)range.length + (NSInteger)replacement.length;
+  return after <= maxLength;
+}
+
+NSResponder *RnPeerEditor(NSView *peer) {
+  if (peer == nil) {
+    return nil;
+  }
+  // An NSTextView is the editor; an NSTextField borrows one from the window
+  // and only while it has focus.
+  return RnPeerIsMultiline(peer) ? (NSResponder *)peer : ((NSTextField *)peer).currentEditor;
+}

package/native/appkit/AppKitTitleBar.h

@@ -0,0 +1,90 @@
+// The window's title bar on macOS: its title, its colours, and whether the
+// system draws it or the app does.
+//
+// The same two styles Win32TitleBar.h describes, and AppKit happens to offer
+// both directly:
+//
+// - Native style. The window keeps its title bar, which sits *outside* the
+//   content view -- so it takes nothing from the app and every metric is zero,
+//   exactly as on Windows. Colours are the window's background plus a
+//   transparent title bar, which is how AppKit lets a caption take an app's
+//   colour at all; there is no per-element caption colour the way DWM has one.
+//
+// - Hidden style. NSWindowStyleMaskFullSizeContentView puts the content view
+//   under the title bar, so the app's content reaches the top of the window.
+//   The traffic lights stay -- the system keeps drawing them, which is the
+//   macOS counterpart of the host painting caption buttons on Windows -- and
+//   the metrics say how much room to leave for them.
+//
+// Main thread only, like the window. The BasaltWindow module posts here.
+
+#pragma once
+
+#import <Cocoa/Cocoa.h>
+
+#include <cstdint>
+#include <functional>
+#include <optional>
+#include <string>
+
+namespace basalt {
+
+enum class TitleBarStyle { Native, Hidden };
+
+// What JavaScript is told, in points -- which are the surface root's units on
+// this host. All zero while the style is native, because the system's title bar
+// is outside the content view and takes nothing from the app.
+struct TitleBarMetrics {
+  double height{0};
+  double buttonsWidth{0};
+  TitleBarStyle style{TitleBarStyle::Native};
+};
+
+class AppKitTitleBar {
+ public:
+  // The window to talk to. Held weakly: the title bar outlives nothing.
+  void attach(NSWindow *window);
+
+  void setTitle(std::optional<std::string> title);
+  // 0xAARRGGBB as processColor produces, or nullopt for the system's own.
+  void setColors(std::optional<uint32_t> background,
+                 std::optional<uint32_t> text,
+                 std::optional<uint32_t> border);
+  void setStyle(TitleBarStyle style);
+
+  // What the caption buttons do, for an app that draws its own.
+  //
+  // The system's buttons work without any of this -- they are the system's --
+  // but a header the app drew has no way to act on itself otherwise, which
+  // makes the hidden style a picture of a title bar rather than one.
+  void minimize();
+  void toggleMaximize();
+  void close();
+  // Begins a window drag from the pointer's current position, which is what a
+  // caption does when you press it and move. Wanted for the same reason:
+  // without it an app-drawn header cannot move its own window.
+  void startDrag();
+
+  TitleBarMetrics metrics() const;
+
+  // Called whenever the metrics change, so JavaScript can re-lay-out. Cleared
+  // by the module's destructor.
+  void setMetricsListener(std::function<void(const TitleBarMetrics &)> listener);
+
+ private:
+  void apply();
+  void notify();
+
+  __weak NSWindow *window_{nil};
+  std::optional<std::string> title_;
+  std::optional<uint32_t> background_;
+  std::optional<uint32_t> text_;
+  std::optional<uint32_t> border_;
+  TitleBarStyle style_{TitleBarStyle::Native};
+  std::function<void(const TitleBarMetrics &)> listener_;
+};
+
+// The one per process, as the window is.
+AppKitTitleBar &titleBar();
+
+} // namespace basalt

package/native/appkit/AppKitTitleBar.mm

@@ -0,0 +1,186 @@
+#import "AppKitTitleBar.h"
+
+#include <cstdint>
+#include <functional>
+
+namespace basalt {
+
+namespace {
+
+NSColor *colorFrom(uint32_t argb) {
+  // processColor's 0xAARRGGBB. sRGB explicitly, for the reason every other
+  // colour on this host is: letting AppKit pick a device space shifts it on a
+  // wide-gamut display, and the same app on Linux would not shift.
+  return [NSColor colorWithSRGBRed:((argb >> 16) & 0xFF) / 255.0
+                             green:((argb >> 8) & 0xFF) / 255.0
+                              blue:(argb & 0xFF) / 255.0
+                             alpha:((argb >> 24) & 0xFF) / 255.0];
+}
+
+// Whether a colour is dark enough to want light text over it. The same
+// question DWMWA_USE_IMMERSIVE_DARK_MODE answers on Windows, asked here
+// because AppKit has no caption text colour: the appearance decides it.
+bool isDark(uint32_t argb) {
+  const double r = ((argb >> 16) & 0xFF) / 255.0;
+  const double g = ((argb >> 8) & 0xFF) / 255.0;
+  const double b = (argb & 0xFF) / 255.0;
+  // Rec. 601 luma, which is what every "is this dark" check uses and is close
+  // enough for a binary decision.
+  return (0.299 * r + 0.587 * g + 0.114 * b) < 0.5;
+}
+
+} // namespace
+
+void AppKitTitleBar::attach(NSWindow *window) {
+  window_ = window;
+  apply();
+}
+
+void AppKitTitleBar::setTitle(std::optional<std::string> title) {
+  title_ = std::move(title);
+  apply();
+}
+
+void AppKitTitleBar::setColors(std::optional<uint32_t> background,
+                               std::optional<uint32_t> text,
+                               std::optional<uint32_t> border) {
+  background_ = background;
+  text_ = text;
+  border_ = border;
+  apply();
+}
+
+void AppKitTitleBar::setStyle(TitleBarStyle style) {
+  if (style_ == style) {
+    return;
+  }
+  style_ = style;
+  apply();
+  notify();
+}
+
+void AppKitTitleBar::minimize() {
+  [window_ miniaturize:nil];
+}
+
+void AppKitTitleBar::toggleMaximize() {
+  // `zoom:` rather than a maximised flag: on macOS the green button toggles
+  // between the window's frame and the "best" one for the screen, and there is
+  // no maximised state to set.
+  [window_ zoom:nil];
+}
+
+void AppKitTitleBar::close() {
+  // performClose: rather than close:, so the delegate gets its say and the
+  // window closes the way the red button closes it.
+  [window_ performClose:nil];
+}
+
+void AppKitTitleBar::startDrag() {
+  NSWindow *window = window_;
+  if (window == nil) {
+    return;
+  }
+  // The event currently being handled, which is the press that started this.
+  // AppKit takes over the drag from there and runs it until the mouse is
+  // released.
+  NSEvent *event = NSApp.currentEvent;
+  if (event != nil) {
+    [window performWindowDragWithEvent:event];
+  }
+}
+
+TitleBarMetrics AppKitTitleBar::metrics() const {
+  TitleBarMetrics result;
+  result.style = style_;
+  if (style_ == TitleBarStyle::Native) {
+    // The system's title bar is outside the content view, so it costs the app
+    // nothing and there is nothing to report.
+    return result;
+  }
+
+  NSWindow *window = window_;
+  if (window == nil) {
+    return result;
+  }
+
+  // What the content view gained by extending under the title bar, which is
+  // exactly what the app has to leave clear.
+  //
+  // Not `contentRectForFrameRect:`: with NSWindowStyleMaskFullSizeContentView
+  // the content rect *is* the frame, so that difference is zero and says the
+  // title bar costs nothing -- which is true of the window and false of the
+  // app. `contentLayoutRect` is the part not covered by the title bar, which
+  // is the question actually being asked.
+  result.height = NSHeight(window.contentView.frame) - NSHeight(window.contentLayoutRect);
+
+  // The traffic lights, from where they actually are rather than from a
+  // constant: their size and spacing are the system's to change.
+  NSButton *close = [window standardWindowButton:NSWindowCloseButton];
+  NSButton *zoom = [window standardWindowButton:NSWindowZoomButton];
+  if (close != nil && zoom != nil) {
+    const NSRect closeFrame = close.frame;
+    const NSRect zoomFrame = zoom.frame;
+    // From the window's left edge to the far side of the last button, which is
+    // the width an app has to keep clear -- the buttons sit at the left on
+    // macOS, where Windows puts them at the right.
+    result.buttonsWidth = NSMaxX(zoomFrame) + NSMinX(closeFrame);
+  }
+  return result;
+}
+
+void AppKitTitleBar::setMetricsListener(std::function<void(const TitleBarMetrics &)> listener) {
+  listener_ = std::move(listener);
+}
+
+void AppKitTitleBar::apply() {
+  NSWindow *window = window_;
+  if (window == nil) {
+    return;
+  }
+
+  if (title_.has_value()) {
+    NSString *value = [NSString stringWithUTF8String:title_->c_str()];
+    window.title = value != nil ? value : @"";
+  }
+
+  const bool hidden = style_ == TitleBarStyle::Hidden;
+  window.titlebarAppearsTransparent = hidden || background_.has_value();
+  // The title text would otherwise sit over the app's own content.
+  window.titleVisibility = hidden ? NSWindowTitleHidden : NSWindowTitleVisible;
+
+  if (hidden) {
+    window.styleMask |= NSWindowStyleMaskFullSizeContentView;
+  } else {
+    window.styleMask &= ~NSWindowStyleMaskFullSizeContentView;
+  }
+
+  if (background_.has_value()) {
+    window.backgroundColor = colorFrom(*background_);
+    // AppKit has no caption *text* colour: the window's appearance decides it.
+    // So a dark caption gets the dark appearance, which is the same decision
+    // Windows makes through DWMWA_USE_IMMERSIVE_DARK_MODE -- and honouring an
+    // explicit textColor beyond that is not something AppKit offers.
+    const bool wantsLight = text_.has_value() ? !isDark(*text_) : isDark(*background_);
+    window.appearance = [NSAppearance appearanceNamed:wantsLight ? NSAppearanceNameDarkAqua
+                                                                 : NSAppearanceNameAqua];
+  }
+
+  // `border` has no AppKit equivalent. A window's edge is the system's, and
+  // there is no DWMWA_BORDER_COLOR here -- recorded rather than silently
+  // dropped, so the asymmetry is visible where it is decided.
+  (void)border_;
+}
+
+void AppKitTitleBar::notify() {
+  if (listener_) {
+    listener_(metrics());
+  }
+}
+
+AppKitTitleBar &titleBar() {
+  static AppKitTitleBar instance;
+  return instance;
+}
+
+} // namespace basalt