fix(ui-macos): build text field cells through cellClass and pad them as CSS does (#11661)

changelog.d/11665-macos-textfield-baseline.md

@@ -0,0 +1,26 @@
+Fixed a macOS `TextField` whose text moved when editing started (#11661).
+`TextField`, `SecureField`, `Text` and `AttributedText` replaced the cell that
+AppKit builds with a new `PerryInsetTextFieldCell`, so that `setPadding` could
+inset their text. The new cell lost the factory setup. `TextField` then set
+its one-line properties again and turned on `usesSingleLineMode`. In that mode
+AppKit draws idle text on the baseline of the system font for the control
+size, so a custom font sat 2pt high at 16pt Helvetica and clipped from about
+20pt. `PerryTextField` and `PerrySecureTextField` now override
+`cellClass`, so `textFieldWithString:` and `labelWithString:` build the inset
+cell with the factory setup. The cell swap, the property restore for labels,
+and the one-line properties are gone. `SecureField` is now one line and
+scrolls, as `TextField` does.
+
+`TextField` and `SecureField` hold one line, as a web `<input>` does, without
+single-line mode. A value set in code drops its line breaks. Typed, pasted and
+dropped text turns each line break into one space. Option-Return and
+Control-Return insert nothing, and Return still submits.
+
+`setPadding` on a `TextField` or `SecureField` now works as CSS padding does
+on the web. A padded field with a bezel or a border moved its text by the
+padding when editing started, because AppKit applied the cell's
+`drawingRectForBounds:` padding to the editing frame as well. The cell now pads
+only the frames that AppKit hands it to draw and to edit, so the padding
+applies once for every border style. `textfieldSetBackgroundColor` paints the
+field's layer, so the background fills the padding too. The cell's own
+background filled only the area inside the padding.

crates/perry-ui-macos/Cargo.toml

@@ -112,6 +112,16 @@ name = "native_textfield_selection"
 path = "tests/native_textfield_selection.rs"
 harness = false
 
+[[test]]
+name = "native_textfield_cell"
+path = "tests/native_textfield_cell.rs"
+harness = false
+
+[[test]]
+name = "native_textfield_newlines"
+path = "tests/native_textfield_newlines.rs"
+harness = false
+
 [[test]]
 name = "native_text_spacing"
 path = "tests/native_text_spacing.rs"

crates/perry-ui-macos/src/srgb.rs

@@ -7,7 +7,20 @@ use objc2_app_kit::NSColor;
 use std::ffi::c_void;
 use std::sync::OnceLock;
 
-type CGColorRef = *mut c_void;
+/// CoreGraphics' opaque colour. A typed pointer encodes as `^{CGColor=}`, the
+/// type CALayer's colour properties declare. If the pointer were `c_void`, it
+/// would encode as `^v`, and a debug build's message check would reject the send.
+#[repr(C)]
+pub struct CGColor {
+    _private: [u8; 0],
+}
+
+unsafe impl objc2::encode::RefEncode for CGColor {
+    const ENCODING_REF: objc2::encode::Encoding =
+        objc2::encode::Encoding::Pointer(&objc2::encode::Encoding::Struct("CGColor", &[]));
+}
+
+type CGColorRef = *mut CGColor;
 type CGColorSpaceRef = *mut c_void;
 
 extern "C" {

crates/perry-ui-macos/src/widgets/attributed_text.rs

@@ -34,8 +34,7 @@ use perry_ffi::copy_string_from_raw as str_from_header;
 pub fn create() -> i64 {
     let mtm = MainThreadMarker::new().expect("perry/ui must run on the main thread");
     let empty = NSString::from_str("");
-    let label = NSTextField::labelWithString(&empty, mtm);
-    super::padding::install_label_cell(&label, mtm);
+    let label = super::text::label(&empty, mtm);
     unsafe {
         let _: () = msg_send![&*label, setTranslatesAutoresizingMaskIntoConstraints: false];
         // Enable wrapping by default — per-range styling is most useful

crates/perry-ui-macos/src/widgets/padding.rs

@@ -1,11 +1,9 @@
-use objc2::rc::Retained;
+use objc2::rc::{Allocated, Retained};
 use objc2::runtime::{AnyClass, AnyObject};
-use objc2::{define_class, msg_send, DefinedClass, MainThreadOnly};
-use objc2_app_kit::{
-    NSColor, NSEvent, NSSecureTextFieldCell, NSText, NSTextField, NSTextFieldCell, NSView,
-};
+use objc2::{define_class, msg_send, DefinedClass};
+use objc2_app_kit::{NSEvent, NSSecureTextFieldCell, NSText, NSTextFieldCell, NSView};
 use objc2_core_foundation::CGRect;
-use objc2_foundation::{MainThreadMarker, NSEdgeInsets, NSObjectProtocol};
+use objc2_foundation::{NSEdgeInsets, NSObjectProtocol, NSString};
 use std::cell::Cell;
 
 mod button;
@@ -51,10 +49,20 @@ define_class!(
     pub struct PerryInsetTextFieldCell;
 
     impl PerryInsetTextFieldCell {
-        #[unsafe(method(drawingRectForBounds:))]
-        fn drawing_rect_for_bounds(&self, bounds: CGRect) -> CGRect {
-            let bounds = inset_rect(bounds, self.ivars().get(), unsafe { self.controlView() }.is_some_and(|view| view.isFlipped()));
-            unsafe { msg_send![super(self), drawingRectForBounds: bounds] }
+        #[unsafe(method_id(initTextCell:))]
+        fn init_text_cell(this: Allocated<Self>, string: &NSString) -> Retained<Self> {
+            let this = this.set_ivars(PerryInsetCellIvars::new());
+            unsafe { msg_send![super(this), initTextCell: string] }
+        }
+
+        // Padding goes on the frames AppKit hands in to draw and to edit, not
+        // in drawingRectForBounds:. AppKit's editing path for a borderless
+        // cell never calls drawingRectForBounds:, so padding there would put
+        // the editing text somewhere other than the idle text.
+        #[unsafe(method(drawInteriorWithFrame:inView:))]
+        fn draw_interior(&self, frame: CGRect, view: &NSView) {
+            let frame = inset_rect(frame, self.ivars().get(), view.isFlipped());
+            unsafe { msg_send![super(self), drawInteriorWithFrame: frame, inView: view] }
         }
 
         #[unsafe(method(cellSizeForBounds:))]
@@ -107,10 +115,20 @@ define_class!(
     pub struct PerryInsetSecureTextFieldCell;
 
     impl PerryInsetSecureTextFieldCell {
-        #[unsafe(method(drawingRectForBounds:))]
-        fn drawing_rect_for_bounds(&self, bounds: CGRect) -> CGRect {
-            let bounds = inset_rect(bounds, self.ivars().get(), unsafe { self.controlView() }.is_some_and(|view| view.isFlipped()));
-            unsafe { msg_send![super(self), drawingRectForBounds: bounds] }
+        #[unsafe(method_id(initTextCell:))]
+        fn init_text_cell(this: Allocated<Self>, string: &NSString) -> Retained<Self> {
+            let this = this.set_ivars(PerryInsetCellIvars::new());
+            unsafe { msg_send![super(this), initTextCell: string] }
+        }
+
+        // Padding goes on the frames AppKit hands in to draw and to edit, not
+        // in drawingRectForBounds:. AppKit's editing path for a borderless
+        // cell never calls drawingRectForBounds:, so padding there would put
+        // the editing text somewhere other than the idle text.
+        #[unsafe(method(drawInteriorWithFrame:inView:))]
+        fn draw_interior(&self, frame: CGRect, view: &NSView) {
+            let frame = inset_rect(frame, self.ivars().get(), view.isFlipped());
+            unsafe { msg_send![super(self), drawInteriorWithFrame: frame, inView: view] }
         }
 
         #[unsafe(method(cellSizeForBounds:))]
@@ -189,51 +207,6 @@ fn padded_size(
     )
 }
 
-pub(crate) fn install_text_field_cell(field: &NSTextField, mtm: MainThreadMarker) {
-    let this = PerryInsetTextFieldCell::alloc(mtm).set_ivars(PerryInsetCellIvars::new());
-    let cell: Retained<PerryInsetTextFieldCell> = unsafe { msg_send![super(this), init] };
-    unsafe {
-        let _: () = msg_send![field, setCell: &*cell];
-    }
-}
-
-pub(crate) fn install_secure_text_field_cell(field: &NSTextField, mtm: MainThreadMarker) {
-    let this = PerryInsetSecureTextFieldCell::alloc(mtm).set_ivars(PerryInsetCellIvars::new());
-    let cell: Retained<PerryInsetSecureTextFieldCell> = unsafe { msg_send![super(this), init] };
-    unsafe {
-        let _: () = msg_send![field, setCell: &*cell];
-    }
-}
-
-/// Install at label creation, before callers apply attributed text or styles.
-/// Keep the factory label's text, font and line-breaking defaults.
-pub(crate) fn install_label_cell(field: &NSTextField, mtm: MainThreadMarker) {
-    // Restore the text as a plain stringValue, never the factory label's
-    // attributedStringValue. An NSTextField holding an attributed string
-    // ignores setTextColor: — the string's baked-in color attribute wins — so
-    // an attributedStringValue here silently defeats textSetColor (#10856).
-    // The font is restored separately below, and labelColor is set explicitly
-    // to keep the label's default appearance.
-    let text = field.stringValue();
-    let font = field.font();
-    let original = field.cell().expect("label has a cell");
-    install_text_field_cell(field, mtm);
-    field.setBezeled(false);
-    field.setBordered(false);
-    field.setEditable(false);
-    field.setSelectable(false);
-    field.setDrawsBackground(false);
-    field.setFont(font.as_deref());
-    field.setStringValue(&text);
-    field.setTextColor(Some(&NSColor::labelColor()));
-    if let Some(cell) = field.cell() {
-        cell.setWraps(original.wraps());
-        cell.setScrollable(original.isScrollable());
-        cell.setUsesSingleLineMode(original.usesSingleLineMode());
-        cell.setLineBreakMode(original.lineBreakMode());
-    }
-}
-
 /// Apply padding to AppKit widgets with a native content-inset mechanism.
 /// Perry's labels and buttons include padding in their native sizing and
 /// drawing paths, without replacing the widget or its target/action.

crates/perry-ui-macos/src/widgets/securefield.rs

@@ -1,10 +1,10 @@
 use crate::ffi::js_string_from_bytes;
 use objc2::rc::Retained;
-use objc2::runtime::{AnyObject, Sel};
-use objc2::{define_class, msg_send, AnyThread, DefinedClass, MainThreadOnly};
-use objc2_app_kit::{NSSecureTextField, NSTextField, NSView};
+use objc2::runtime::{AnyClass, AnyObject, Sel};
+use objc2::{define_class, msg_send, AnyThread, ClassType, DefinedClass};
+use objc2_app_kit::{NSSecureTextField, NSTextField, NSTextView, NSView};
 use objc2_foundation::{
-    MainThreadMarker, NSNotification, NSNotificationCenter, NSObject, NSString,
+    MainThreadMarker, NSNotification, NSNotificationCenter, NSObject, NSRange, NSString,
 };
 use std::cell::RefCell;
 use std::collections::HashMap;
@@ -86,6 +86,62 @@ impl PerrySecureFieldObserver {
     }
 }
 
+define_class!(
+    #[unsafe(super(NSSecureTextField))]
+    #[name = "PerrySecureTextField"]
+    pub struct PerrySecureTextField;
+
+    impl PerrySecureTextField {
+        #[unsafe(method(cellClass))]
+        fn cell_class() -> &'static AnyClass {
+            super::padding::PerryInsetSecureTextFieldCell::class()
+        }
+
+        #[unsafe(method(setStringValue:))]
+        fn set_string_value(&self, value: &NSString) {
+            let value = super::textfield::strip_line_breaks(value);
+            unsafe { msg_send![super(self), setStringValue: &*value] }
+        }
+
+        #[unsafe(method(textView:shouldChangeTextInRange:replacementString:))]
+        fn should_change_text(
+            &self,
+            editor: &NSTextView,
+            range: NSRange,
+            replacement: Option<&NSString>,
+        ) -> bool {
+            match replacement.and_then(super::textfield::replace_line_breaks_with_spaces) {
+                // Inserting the spaced text asks this method again, now with no
+                // line break, so the edit still passes through super.
+                Some(spaced) => {
+                    let _: () = unsafe { msg_send![editor, insertText: &*spaced, replacementRange: range] };
+                    false
+                }
+                None => unsafe {
+                    msg_send![super(self), textView: editor, shouldChangeTextInRange: range, replacementString: replacement]
+                },
+            }
+        }
+
+        #[unsafe(method(textView:doCommandBySelector:))]
+        fn do_command(&self, editor: &NSTextView, command: Sel) -> bool {
+            super::textfield::is_line_break_command(command)
+                || unsafe { msg_send![super(self), textView: editor, doCommandBySelector: command] }
+        }
+    }
+);
+
+/// A one-line secure text field, as `textFieldWithString:` builds it, with an
+/// inset cell so `set_edge_insets` can pad it.
+pub(crate) fn secure_text_field(
+    string: &NSString,
+    _mtm: MainThreadMarker,
+) -> Retained<NSSecureTextField> {
+    let field: Retained<PerrySecureTextField> =
+        unsafe { msg_send![PerrySecureTextField::class(), textFieldWithString: string] };
+    field.into_super()
+}
+
 /// Extract a &str from a *const StringHeader pointer.
 use perry_ffi::copy_string_from_raw as str_from_header;
 
@@ -98,18 +154,8 @@ pub fn create(placeholder_ptr: *const u8, on_change: f64) -> i64 {
     let ns_placeholder = NSString::from_str(&placeholder);
 
     unsafe {
-        let text_field: Retained<NSSecureTextField> = msg_send![
-            NSSecureTextField::alloc(mtm), initWithFrame: objc2_core_foundation::CGRect::new(
-                objc2_core_foundation::CGPoint::new(0.0, 0.0),
-                objc2_core_foundation::CGSize::new(200.0, 22.0),
-            )
-        ];
-
-        let tf_ref: &NSTextField = &Retained::cast_unchecked::<NSTextField>(text_field.clone());
-        super::padding::install_secure_text_field_cell(tf_ref, mtm);
-        tf_ref.setPlaceholderString(Some(&ns_placeholder));
-        tf_ref.setEditable(true);
-        tf_ref.setBezeled(true);
+        let text_field = secure_text_field(&NSString::from_str(""), mtm);
+        text_field.setPlaceholderString(Some(&ns_placeholder));
 
         let view: Retained<NSView> = Retained::cast_unchecked(text_field);
         let handle = super::register_widget(view);

crates/perry-ui-macos/src/widgets/text.rs

@@ -1,5 +1,7 @@
 use crate::srgb;
 use objc2::rc::Retained;
+use objc2::runtime::AnyClass;
+use objc2::{define_class, msg_send, ClassType};
 use objc2_app_kit::{NSTextField, NSView};
 use objc2_foundation::{MainThreadMarker, NSString};
 use std::cell::RefCell;
@@ -125,15 +127,36 @@ pub fn set_line_height(handle: i64, multiple: f64) {
     refresh_spacing(handle);
 }
 
+define_class!(
+    /// A label that shows the line breaks in its value.
+    #[unsafe(super(NSTextField))]
+    #[name = "PerryLabel"]
+    pub struct PerryLabel;
+
+    impl PerryLabel {
+        #[unsafe(method(cellClass))]
+        fn cell_class() -> &'static AnyClass {
+            super::padding::PerryInsetTextFieldCell::class()
+        }
+    }
+);
+
+/// A label, as `labelWithString:` builds it, with an inset cell so
+/// `set_edge_insets` can pad it.
+pub(crate) fn label(string: &NSString, _mtm: MainThreadMarker) -> Retained<NSTextField> {
+    let label: Retained<PerryLabel> =
+        unsafe { msg_send![PerryLabel::class(), labelWithString: string] };
+    label.into_super()
+}
+
 /// Create an NSTextField configured as a non-editable label.
 pub fn create(text_ptr: *const u8) -> i64 {
     let text = unsafe { str_from_header(text_ptr) };
 
     let mtm = MainThreadMarker::new().expect("perry/ui must run on the main thread");
     let ns_string = NSString::from_str(&text);
 
-    let label = NSTextField::labelWithString(&ns_string, mtm);
-    super::padding::install_label_cell(&label, mtm);
+    let label = label(&ns_string, mtm);
     unsafe {
         let _: () = objc2::msg_send![&*label, setAccessibilityLabel: &*ns_string];
         // Disable autoresizing mask so Auto Layout can size this view in NSStackView.