basalt-appkit 0.0.0-rc5 → 0.2.0

package/native/appkit/AppKitTextPeer.mm

@@ -4,15 +4,105 @@
 
 // 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.
+// The two properties, on an NSTextView. Unset leaves the platform's own answer
+// alone, which is the whole reason the flag has three states.
+static void RnApplyTextChecking(NSTextView *_Nullable editor,
+                                RnTextChecking spellCheck,
+                                RnTextChecking autoCorrect) {
+  if (editor == nil) {
+    return;
+  }
+  if (spellCheck != RnTextCheckingUnset) {
+    editor.continuousSpellCheckingEnabled = spellCheck == RnTextCheckingOn;
+  }
+  if (autoCorrect != RnTextCheckingUnset) {
+    editor.automaticSpellingCorrectionEnabled = autoCorrect == RnTextCheckingOn;
+  }
+}
+
+// `selectionColor` and `cursorColor`, on the same NSTextView and under the same
+// rule: nil leaves AppKit's own answer alone, which is the third state the
+// props have.
+static void RnApplyEditorColours(NSTextView *_Nullable editor,
+                                 NSColor *_Nullable selection,
+                                 NSColor *_Nullable caret) {
+  if (editor == nil) {
+    return;
+  }
+  if (caret != nil) {
+    editor.insertionPointColor = caret;
+  }
+  if (selection != nil) {
+    // One key of the dictionary rather than the whole of it: the rest is
+    // AppKit's, including how a selection dims when its window loses focus.
+    NSMutableDictionary *attributes = [editor.selectedTextAttributes mutableCopy];
+    if (attributes == nil) {
+      attributes = [NSMutableDictionary dictionary];
+    }
+    attributes[NSBackgroundColorAttributeName] = selection;
+    editor.selectedTextAttributes = attributes;
+  }
+}
+
 @interface RnAppKitTextField : NSTextField
 @property(nonatomic, assign) NSInteger rnTag;
+@property(nonatomic, strong, nullable) NSColor *rnSelectionColour;
+@property(nonatomic, strong, nullable) NSColor *rnCaretColour;
 @property(nonatomic, weak) id<RnAppKitTextPeerOwner> rnOwner;
+@property(nonatomic, assign) RnTextChecking rnSpellCheck;
+@property(nonatomic, assign) RnTextChecking rnAutoCorrect;
+// `contextMenuHidden`. A flag rather than a torn-down menu: AppKit builds the
+// menu on demand, through -menuForEvent:, so refusing there is the one place
+// that covers a right-click and a Control-click both.
+@property(nonatomic, assign) BOOL rnContextMenuHidden;
 @end
 
 @implementation RnAppKitTextField
+- (NSMenu *)menuForEvent:(NSEvent *)event {
+  // `contextMenuHidden`: nil is how a view says it has no context menu, and
+  // AppKit then offers none rather than falling back to a default.
+  if (_rnContextMenuHidden) {
+    return nil;
+  }
+  return [super menuForEvent:event];
+}
+
+// The same refusal, for the menu this field does not own.
+//
+// A focused single-line field is edited through the *window's shared field
+// editor*, a plain NSTextView nobody here subclasses, and that view is the one
+// under the pointer: -menuForEvent: above is never asked, so the flag reached
+// the field and stopped there. Assigning `menu = nil` on the editor does not
+// help either, which a probe established before this was written -- the editor
+// rebuilds its menu inside its own -menuForEvent:.
+//
+// This is the documented way into that rebuild. A field editor's delegate is
+// the control it is editing for, which is this field, and NSTextView asks its
+// delegate to approve the menu it has just built. Returning nil is the whole
+// of it.
+- (NSMenu *)textView:(NSTextView *)view
+                menu:(NSMenu *)menu
+            forEvent:(NSEvent *)event
+             atIndex:(NSUInteger)index {
+  (void)view;
+  (void)event;
+  (void)index;
+  if (_rnContextMenuHidden) {
+    return nil;
+  }
+  return menu;
+}
+
 - (BOOL)becomeFirstResponder {
   const BOOL became = [super becomeFirstResponder];
   if (became) {
+    // The field editor exists now and did not before, which is the only moment
+    // the spell-checking flags can be put on it. See RnPeerSetTextChecking.
+    if ([self.currentEditor isKindOfClass:NSTextView.class]) {
+      RnApplyTextChecking((NSTextView *)self.currentEditor, _rnSpellCheck, _rnAutoCorrect);
+      RnApplyEditorColours(
+          (NSTextView *)self.currentEditor, _rnSelectionColour, _rnCaretColour);
+    }
     [_rnOwner rnFieldDidBecomeFirstResponder:_rnTag];
   }
   return became;
@@ -21,13 +111,63 @@
 
 @interface RnAppKitSecureTextField : NSSecureTextField
 @property(nonatomic, assign) NSInteger rnTag;
+@property(nonatomic, strong, nullable) NSColor *rnSelectionColour;
+@property(nonatomic, strong, nullable) NSColor *rnCaretColour;
 @property(nonatomic, weak) id<RnAppKitTextPeerOwner> rnOwner;
+@property(nonatomic, assign) RnTextChecking rnSpellCheck;
+@property(nonatomic, assign) RnTextChecking rnAutoCorrect;
+// `contextMenuHidden`. A flag rather than a torn-down menu: AppKit builds the
+// menu on demand, through -menuForEvent:, so refusing there is the one place
+// that covers a right-click and a Control-click both.
+@property(nonatomic, assign) BOOL rnContextMenuHidden;
 @end
 
 @implementation RnAppKitSecureTextField
+- (NSMenu *)menuForEvent:(NSEvent *)event {
+  // `contextMenuHidden`: nil is how a view says it has no context menu, and
+  // AppKit then offers none rather than falling back to a default.
+  if (_rnContextMenuHidden) {
+    return nil;
+  }
+  return [super menuForEvent:event];
+}
+
+// The same refusal, for the menu this field does not own.
+//
+// A focused single-line field is edited through the *window's shared field
+// editor*, a plain NSTextView nobody here subclasses, and that view is the one
+// under the pointer: -menuForEvent: above is never asked, so the flag reached
+// the field and stopped there. Assigning `menu = nil` on the editor does not
+// help either, which a probe established before this was written -- the editor
+// rebuilds its menu inside its own -menuForEvent:.
+//
+// This is the documented way into that rebuild. A field editor's delegate is
+// the control it is editing for, which is this field, and NSTextView asks its
+// delegate to approve the menu it has just built. Returning nil is the whole
+// of it.
+- (NSMenu *)textView:(NSTextView *)view
+                menu:(NSMenu *)menu
+            forEvent:(NSEvent *)event
+             atIndex:(NSUInteger)index {
+  (void)view;
+  (void)event;
+  (void)index;
+  if (_rnContextMenuHidden) {
+    return nil;
+  }
+  return menu;
+}
+
 - (BOOL)becomeFirstResponder {
   const BOOL became = [super becomeFirstResponder];
   if (became) {
+    // The field editor exists now and did not before, which is the only moment
+    // the spell-checking flags can be put on it. See RnPeerSetTextChecking.
+    if ([self.currentEditor isKindOfClass:NSTextView.class]) {
+      RnApplyTextChecking((NSTextView *)self.currentEditor, _rnSpellCheck, _rnAutoCorrect);
+      RnApplyEditorColours(
+          (NSTextView *)self.currentEditor, _rnSelectionColour, _rnCaretColour);
+    }
     [_rnOwner rnFieldDidBecomeFirstResponder:_rnTag];
   }
   return became;
@@ -36,11 +176,28 @@
 
 @interface RnAppKitTextView : NSTextView
 @property(nonatomic, assign) NSInteger rnTag;
+@property(nonatomic, strong, nullable) NSColor *rnSelectionColour;
+@property(nonatomic, strong, nullable) NSColor *rnCaretColour;
 @property(nonatomic, weak) id<RnAppKitTextPeerOwner> rnOwner;
 @property(nonatomic, strong, nullable) NSAttributedString *rnPlaceholder;
+@property(nonatomic, assign) RnTextChecking rnSpellCheck;
+@property(nonatomic, assign) RnTextChecking rnAutoCorrect;
+// `contextMenuHidden`. A flag rather than a torn-down menu: AppKit builds the
+// menu on demand, through -menuForEvent:, so refusing there is the one place
+// that covers a right-click and a Control-click both.
+@property(nonatomic, assign) BOOL rnContextMenuHidden;
 @end
 
 @implementation RnAppKitTextView
+- (NSMenu *)menuForEvent:(NSEvent *)event {
+  // `contextMenuHidden`: nil is how a view says it has no context menu, and
+  // AppKit then offers none rather than falling back to a default.
+  if (_rnContextMenuHidden) {
+    return nil;
+  }
+  return [super menuForEvent:event];
+}
+
 - (BOOL)becomeFirstResponder {
   const BOOL became = [super becomeFirstResponder];
   if (became) {
@@ -196,6 +353,156 @@ void RnPeerSetSelection(NSView *peer, NSRange range) {
   }
 }
 
+void RnPeerSetTextChecking(NSView *peer,
+                           RnTextChecking spellCheck,
+                           RnTextChecking autoCorrect) {
+  if (peer == nil) {
+    return;
+  }
+  if (RnPeerIsMultiline(peer)) {
+    // An NSTextView is its own editor, so this is the simple case -- the
+    // request is still remembered, because AppKit may decline it and a test
+    // needs to know what was asked.
+    ((RnAppKitTextView *)peer).rnSpellCheck = spellCheck;
+    ((RnAppKitTextView *)peer).rnAutoCorrect = autoCorrect;
+    RnApplyTextChecking((NSTextView *)peer, spellCheck, autoCorrect);
+    return;
+  }
+  // Remembered first, because a field that is not focused has no editor to put
+  // them on and `becomeFirstResponder` is what applies them then.
+  if ([peer isKindOfClass:RnAppKitTextField.class]) {
+    ((RnAppKitTextField *)peer).rnSpellCheck = spellCheck;
+    ((RnAppKitTextField *)peer).rnAutoCorrect = autoCorrect;
+  } else if ([peer isKindOfClass:RnAppKitSecureTextField.class]) {
+    ((RnAppKitSecureTextField *)peer).rnSpellCheck = spellCheck;
+    ((RnAppKitSecureTextField *)peer).rnAutoCorrect = autoCorrect;
+  }
+  if ([((NSTextField *)peer).currentEditor isKindOfClass:NSTextView.class]) {
+    RnApplyTextChecking(
+        (NSTextView *)((NSTextField *)peer).currentEditor, spellCheck, autoCorrect);
+  }
+}
+
+void RnPeerSetEditorColours(NSView *peer, NSColor *selection, NSColor *caret) {
+  if (peer == nil) {
+    return;
+  }
+  if (RnPeerIsMultiline(peer)) {
+    // Its own editor, so the colours could go straight on -- they are still
+    // remembered, so that reading them back answers what the app asked for
+    // rather than what AppKit currently holds.
+    ((RnAppKitTextView *)peer).rnSelectionColour = selection;
+    ((RnAppKitTextView *)peer).rnCaretColour = caret;
+    RnApplyEditorColours((NSTextView *)peer, selection, caret);
+    return;
+  }
+  // Remembered first, because a field with no focus has no field editor to put
+  // them on and `becomeFirstResponder` is what applies them then.
+  if ([peer isKindOfClass:RnAppKitTextField.class]) {
+    ((RnAppKitTextField *)peer).rnSelectionColour = selection;
+    ((RnAppKitTextField *)peer).rnCaretColour = caret;
+  } else if ([peer isKindOfClass:RnAppKitSecureTextField.class]) {
+    ((RnAppKitSecureTextField *)peer).rnSelectionColour = selection;
+    ((RnAppKitSecureTextField *)peer).rnCaretColour = caret;
+  }
+  if ([((NSTextField *)peer).currentEditor isKindOfClass:NSTextView.class]) {
+    RnApplyEditorColours((NSTextView *)((NSTextField *)peer).currentEditor, selection, caret);
+  }
+}
+
+NSColor *RnPeerSelectionColour(NSView *peer) {
+  if ([peer isKindOfClass:RnAppKitTextView.class]) {
+    return ((RnAppKitTextView *)peer).rnSelectionColour;
+  }
+  if ([peer isKindOfClass:RnAppKitTextField.class]) {
+    return ((RnAppKitTextField *)peer).rnSelectionColour;
+  }
+  if ([peer isKindOfClass:RnAppKitSecureTextField.class]) {
+    return ((RnAppKitSecureTextField *)peer).rnSelectionColour;
+  }
+  return nil;
+}
+
+NSColor *RnPeerCaretColour(NSView *peer) {
+  if ([peer isKindOfClass:RnAppKitTextView.class]) {
+    return ((RnAppKitTextView *)peer).rnCaretColour;
+  }
+  if ([peer isKindOfClass:RnAppKitTextField.class]) {
+    return ((RnAppKitTextField *)peer).rnCaretColour;
+  }
+  if ([peer isKindOfClass:RnAppKitSecureTextField.class]) {
+    return ((RnAppKitSecureTextField *)peer).rnCaretColour;
+  }
+  return nil;
+}
+
+// The remembered request, from whichever peer this is. A multiline view has no
+// need to remember -- it is its own editor -- so its own flags are read back.
+RnTextChecking RnPeerSpellCheck(NSView *peer) {
+  if (peer == nil) {
+    return RnTextCheckingUnset;
+  }
+  if ([peer isKindOfClass:RnAppKitTextField.class]) {
+    return ((RnAppKitTextField *)peer).rnSpellCheck;
+  }
+  if ([peer isKindOfClass:RnAppKitSecureTextField.class]) {
+    return ((RnAppKitSecureTextField *)peer).rnSpellCheck;
+  }
+  if ([peer isKindOfClass:RnAppKitTextView.class]) {
+    return ((RnAppKitTextView *)peer).rnSpellCheck;
+  }
+  return RnTextCheckingUnset;
+}
+
+RnTextChecking RnPeerAutoCorrect(NSView *peer) {
+  if (peer == nil) {
+    return RnTextCheckingUnset;
+  }
+  if ([peer isKindOfClass:RnAppKitTextField.class]) {
+    return ((RnAppKitTextField *)peer).rnAutoCorrect;
+  }
+  if ([peer isKindOfClass:RnAppKitSecureTextField.class]) {
+    return ((RnAppKitSecureTextField *)peer).rnAutoCorrect;
+  }
+  if ([peer isKindOfClass:RnAppKitTextView.class]) {
+    return ((RnAppKitTextView *)peer).rnAutoCorrect;
+  }
+  return RnTextCheckingUnset;
+}
+
+void RnPeerSetContextMenuHidden(NSView *peer, BOOL hidden) {
+  if (peer == nil) {
+    return;
+  }
+  // Every peer class this file makes carries the flag, and they are the only
+  // classes that reach here: a secure field is not an NSTextField subclass of
+  // this one's, so the three are named rather than tested for a common base.
+  if ([peer isKindOfClass:RnAppKitTextView.class]) {
+    ((RnAppKitTextView *)peer).rnContextMenuHidden = hidden;
+    return;
+  }
+  if ([peer isKindOfClass:RnAppKitSecureTextField.class]) {
+    ((RnAppKitSecureTextField *)peer).rnContextMenuHidden = hidden;
+    return;
+  }
+  if ([peer isKindOfClass:RnAppKitTextField.class]) {
+    ((RnAppKitTextField *)peer).rnContextMenuHidden = hidden;
+  }
+}
+
+BOOL RnPeerContextMenuHidden(NSView *peer) {
+  if ([peer isKindOfClass:RnAppKitTextView.class]) {
+    return ((RnAppKitTextView *)peer).rnContextMenuHidden;
+  }
+  if ([peer isKindOfClass:RnAppKitSecureTextField.class]) {
+    return ((RnAppKitSecureTextField *)peer).rnContextMenuHidden;
+  }
+  if ([peer isKindOfClass:RnAppKitTextField.class]) {
+    return ((RnAppKitTextField *)peer).rnContextMenuHidden;
+  }
+  return NO;
+}
+
 void RnPeerSetEditable(NSView *peer, BOOL editable) {
   if (peer == nil) {
     return;

package/native/appkit/AppKitTouchDispatcher.h

@@ -21,10 +21,13 @@
 #include "AppKitMountingManager.h"
 #include "HoverTracker.h"
 #include "PointerButtons.h"
+#include "TextSelection.h"
 
 #include <react/renderer/components/view/TouchEventEmitter.h>
 #include <react/renderer/graphics/Point.h>
 
+#include <utility>
+
 namespace basalt {
 
 // The tag of the React Native view under a point, in the root's coordinates, or
@@ -67,6 +70,15 @@ class AppKitTouchDispatcher {
   // negative coordinate means the pointer left the surface.
   void synthesiseHover(double x, double y);
 
+  // --- Selecting text -------------------------------------------------------
+  //
+  // The AppKit half of what the GTK dispatcher does, in the same three calls
+  // and for the same reasons: a press inside a selectable paragraph is
+  // remembered and nothing else, and the gesture becomes a selection only once
+  // the pointer has moved far enough to be a sweep rather than a tap -- at
+  // which point the touch sequence this was reporting is cancelled. The state
+  // machine is core/TextSelection.h.
+
   // The main-thread half, called by the view that received the mouse event.
   // Public because the Objective-C trampoline has to reach them.
   // `button` decides whether this presses anything. Only the primary one drives
@@ -91,8 +103,37 @@ class AppKitTouchDispatcher {
   void dispatchHoverLeave();
 
  private:
+
+  // The innermost selectable paragraph under a point in root coordinates, and
+  // the character index in its text, or {nil, -1}.
+  std::pair<RnAppKitView *, NSInteger> selectableTextAt(double x, double y) const;
+
+  // The index in `view`'s text nearest a point in *root* coordinates, which is
+  // not the same question: a drag that has left the paragraph still extends the
+  // selection inside it.
+  NSInteger textIndexIn(RnAppKitView *view, double x, double y) const;
+
+  // Pushes the model's range onto the paragraph it belongs to, and takes the
+  // highlight off whatever held one before.
+  void drawSelection();
   enum class TouchKind { Start, Move, End, Cancel };
 
+  // The window stopped being key while the mouse was down.
+  //
+  // React Native expects a touch to end one of two ways, and a press that
+  // simply stops is the shape that leaves a `<Pressable>` highlighted for the
+  // rest of the screen's life: `onPressOut` never runs and the responder is
+  // never released. AppKit has no gesture recogniser to cancel, which is what
+  // the GTK host uses (`GtkGesture::cancelled`); this is the nearest thing, and
+  // it is what happens when the person switches app or a panel takes over
+  // mid-press.
+  //
+  // Observed here rather than in the host's window delegate so that the whole
+  // path has a test: the delegate is in `main_appkit.mm`, which the suite does
+  // not link, and the part worth testing is that the notification reaches the
+  // press.
+  void windowResignedKey(void *window);
+
   // 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.
@@ -118,11 +159,26 @@ class AppKitTouchDispatcher {
   void emitPointerMove(
       facebook::react::Tag target, double originX, double originY, double x, double y);
 
+  // What is selected, which paragraph it is in, and which is holding a
+  // highlight -- the last two differ when a selection moves to another
+  // paragraph, and after a release the highlight outlives the drag.
+  //
+  // Strong references, unlike the GTK side's weak pointers: an NSView is
+  // retained by its superview and these keep a paragraph alive a moment longer
+  // than its unmounting, which is a retain cycle nobody can observe rather than
+  // a dangling pointer. Cleared on press, on release and in the destructor.
+  basalt::TextSelection selection_;
+  RnAppKitView *selectionView_{nil};
+  RnAppKitView *highlightView_{nil};
+
   AppKitMountingManager *mountingManager_;
   RnAppKitView *surfaceRoot_;
   // The Objective-C object the root forwards mouse events to. Held so it
   // outlives the root's weak reference to it.
   id inputTarget_;
+  // The notification observer for a window that stops being key; see
+  // windowResignedKey.
+  id resignObserver_;
 
   // 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

package/native/appkit/AppKitTouchDispatcher.mm

@@ -8,6 +8,7 @@
 #include <react/renderer/components/view/TouchEvent.h>
 
 #include <cstdint>
+#include <string>
 
 // The bridge between AppKit's protocol and the C++ dispatcher. A C++ object
 // cannot conform to an Objective-C protocol, and the root holds its handler
@@ -125,13 +126,53 @@ AppKitTouchDispatcher::AppKitTouchDispatcher(AppKitMountingManager *mountingMana
   // The root's tracking area is only wanted once there is somewhere to send
   // hover, and AppKit will not ask again just because a property changed.
   [surfaceRoot_ updateTrackingAreas];
+
+  // What `Copy` in a menu and Cmd+C copy when a paragraph has a selection.
+  // Neither of those can reach this object -- one is in the platform services
+  // and the other in the application's own key handling -- so this is where
+  // they ask. See core/TextSelection.h.
+  basalt::setSelectedTextProvider([this]() -> std::string {
+    NSString *text = highlightView_ == nil ? nil : [highlightView_ rnSelectedText];
+    return text == nil ? std::string{} : std::string(text.UTF8String);
+  });
+
+  // A press that the window stops being able to finish. Registered with no
+  // object, and filtered on delivery: at construction the root is not in a
+  // window yet, so there is nothing to register *for*.
+  resignObserver_ = [NSNotificationCenter.defaultCenter
+      addObserverForName:NSWindowDidResignKeyNotification
+                  object:nil
+                   queue:nil
+              usingBlock:^(NSNotification *notification) {
+                this->windowResignedKey((__bridge void *)notification.object);
+              }];
+}
+
+void AppKitTouchDispatcher::windowResignedKey(void *window) {
+  // Only this root's window. Another window losing focus is not this press's
+  // business, and with several windows open every one of them would otherwise
+  // cancel every other's touch.
+  if (surfaceRoot_ == nil || surfaceRoot_.window != (__bridge NSWindow *)window) {
+    return;
+  }
+  // A no-op when nothing is down, which is why this needs no state of its own.
+  dispatchTouchCancel();
 }
 
 AppKitTouchDispatcher::~AppKitTouchDispatcher() {
+  if (resignObserver_ != nil) {
+    [NSNotificationCenter.defaultCenter removeObserver:resignObserver_];
+    resignObserver_ = nil;
+  }
   // The root's reference is weak, so it goes nil on its own; clearing the back
   // pointer first means an event already in flight cannot reach a dead object.
   ((RnAppKitInputTarget *)inputTarget_).dispatcher = nullptr;
   inputTarget_ = nil;
+  // The provider holds `this`: a Copy role performed after a reload would
+  // otherwise ask a destroyed dispatcher for the selection.
+  basalt::setSelectedTextProvider(nullptr);
+  selectionView_ = nil;
+  highlightView_ = nil;
 }
 
 void AppKitTouchDispatcher::synthesiseTap(double x, double y) {
@@ -227,6 +268,53 @@ static Tag targetUnder(RnAppKitView *surfaceRoot, double x, double y, NSPoint *o
   return 0;
 }
 
+std::pair<RnAppKitView *, NSInteger> AppKitTouchDispatcher::selectableTextAt(double x,
+                                                                             double y) const {
+  if (surfaceRoot_ == nil) {
+    return {nil, -1};
+  }
+  // From the resolved hit, like every other hit test here, so that a box-none
+  // ancestor that swallows a press swallows a selection too.
+  RnAppKitView *hit = RnAppKitHitTest(surfaceRoot_, x, y);
+  for (NSView *view = hit; view != nil; view = view.superview) {
+    if ([view isKindOfClass:[RnAppKitView class]] && ((RnAppKitView *)view).rnTextSelectable) {
+      RnAppKitView *paragraph = (RnAppKitView *)view;
+      return {paragraph, textIndexIn(paragraph, x, y)};
+    }
+    if (view == surfaceRoot_) {
+      break;
+    }
+  }
+  return {nil, -1};
+}
+
+NSInteger AppKitTouchDispatcher::textIndexIn(RnAppKitView *view, double x, double y) const {
+  if (view == nil || surfaceRoot_ == nil) {
+    return -1;
+  }
+  // AppKit computes the transform, so a scrolled or transformed ancestor counts
+  // -- the same reason targetUnder asks it rather than summing frames.
+  const NSPoint inView = [view convertPoint:NSMakePoint(x, y) fromView:surfaceRoot_];
+  return [view rnTextIndexAtPoint:CGPointMake(inView.x, inView.y)];
+}
+
+void AppKitTouchDispatcher::drawSelection() {
+  // The paragraph that was holding a highlight, when it is not this one: a
+  // press in a second <Text> ends the first one's selection, which is what
+  // every desktop does.
+  if (highlightView_ != nil && highlightView_ != selectionView_) {
+    [highlightView_ setRnTextSelectionStart:0 length:0];
+    highlightView_ = nil;
+  }
+  if (selectionView_ == nil) {
+    return;
+  }
+
+  const basalt::TextSelectionRange range = selection_.range();
+  [selectionView_ setRnTextSelectionStart:range.start length:range.length];
+  highlightView_ = range.empty() ? nil : selectionView_;
+}
+
 void AppKitTouchDispatcher::dispatchTouchStart(double x, double y, basalt::PointerButton button) {
   NSPoint origin = NSZeroPoint;
   const Tag target = targetUnder(surfaceRoot_, x, y, &origin);
@@ -246,6 +334,21 @@ void AppKitTouchDispatcher::dispatchTouchStart(double x, double y, basalt::Point
     return;
   }
 
+  // Selectable text remembers where the press landed and nothing more: a press
+  // is also how a <Pressable> around this text is pressed, so claiming here
+  // would stop every tap on a selectable label. The press *does* clear whatever
+  // was selected, which is how a click dismisses a highlight. See
+  // core/TextSelection.h.
+  {
+    const auto [paragraph, index] = selectableTextAt(x, y);
+    selectionView_ = paragraph;
+    selection_.press(paragraph != nil ? static_cast<Tag>(paragraph.rnTag) : 0,
+                     index < 0 ? 0 : static_cast<int>(index),
+                     Point{.x = static_cast<facebook::react::Float>(x),
+                           .y = static_cast<facebook::react::Float>(y)});
+    drawSelection();
+  }
+
   if (!basalt::gestures().empty()) {
     basalt::gestures().pointerDown(
         hitChain(surfaceRoot_, x, y), x, y, basalt::monotonicMilliseconds());
@@ -261,6 +364,19 @@ void AppKitTouchDispatcher::dispatchTouchStart(double x, double y, basalt::Point
 }
 
 void AppKitTouchDispatcher::dispatchTouchMove(double x, double y) {
+  // A selection that has claimed the pointer owns every move after it, and this
+  // is before the guards below on purpose: claiming *cancelled* the touch, so
+  // `isDown_` is false and `activeTarget_` is zero from then on, and a check
+  // after them would extend a selection exactly once. The gesture recognisers
+  // are not fed either -- they were sent a cancel with the touch.
+  if (selection_.dragging()) {
+    selection_.moveTo(static_cast<int>(textIndexIn(selectionView_, x, y)),
+                      Point{.x = static_cast<facebook::react::Float>(x),
+                            .y = static_cast<facebook::react::Float>(y)});
+    drawSelection();
+    return;
+  }
+
   if (!basalt::gestures().empty()) {
     basalt::gestures().pointerMove(x, y, basalt::monotonicMilliseconds());
   }
@@ -271,6 +387,17 @@ void AppKitTouchDispatcher::dispatchTouchMove(double x, double y) {
   if (!isDown_ || activeTarget_ == 0) {
     return;
   }
+
+  // The move that turns a press inside selectable text into a selection: far
+  // enough from where it started to be a sweep rather than a tap.
+  if (selection_.moveTo(static_cast<int>(textIndexIn(selectionView_, x, y)),
+                        Point{.x = static_cast<facebook::react::Float>(x),
+                              .y = static_cast<facebook::react::Float>(y)})) {
+    drawSelection();
+    dispatchTouchCancel();
+    return;
+  }
+
   if (yieldToGesture(x, y)) {
     return;
   }
@@ -289,12 +416,25 @@ void AppKitTouchDispatcher::dispatchTouchEnd(double x, double y, basalt::Pointer
     }
   }
 
+  // The pointer is up, so a selection stops growing. The highlight stays: a
+  // person lets go and expects the text to stay selected until they click.
+  const bool wasSelecting = selection_.dragging();
+  selection_.release();
+
   // And nothing else for a button that never pressed anything -- there is no
   // touch to end, no gesture to finish and no <Switch> to toggle.
   if (!basalt::isPressButton(button)) {
     return;
   }
 
+  // A selection already cancelled the touch sequence, so there is no touch to
+  // end and nothing to press: the release belongs to the selection.
+  if (wasSelecting) {
+    isDown_ = false;
+    activeTarget_ = 0;
+    return;
+  }
+
   if (!basalt::gestures().empty()) {
     basalt::gestures().pointerUp(x, y, basalt::monotonicMilliseconds());
   }