iOS: Implement UITextInput so multi-stage IMEs (CJK) work

The `WinitView` on iOS previously adopted only `UIKeyInput` (plus
the trait-only `UITextInputTraits`). Per Apple's docs that's enough
for plain ASCII keypresses, but multi-stage input methods — Chinese
pinyin, Japanese kana, Korean hangul, Vietnamese, etc. — require the
view to also adopt the `UITextInput` protocol:

  https://developer.apple.com/documentation/uikit/uitextinput

> Multi-stage input methods, such as Chinese, Japanese, Korean, and
> Thai are excluded from classes that adopt only the UIKeyInput
> protocol, but if a class also adopts the UITextInput protocol,
> those input methods are then available.

Without `UITextInput`, the iOS soft keyboard silently drops every
keypress while pinyin / kana / hangul is selected, so users on the
simulator or device see a completely unresponsive text input. This
affects every downstream toolkit using winit on iOS; we noticed it
via slint-ui/slint#4698.

This is the master-branch port of the same fix applied to v0.30.x
in #4592 — same logic, adapted to the `winit-uikit` crate split,
`define_class!`, `#[unsafe(method_id(...))]`, and the `winit-core`
event type layout.

What this PR does:

* Adds a new `winit-uikit/src/ime.rs` module with two small `NSObject`
  subclasses `WinitTextPosition` / `WinitTextRange`, each carrying a
  character offset (positions are opaque to UIKit, so a simple `i64`
  wrapper is enough), and an `ImeState` holding the current marked
  text + selection.
* Adopts `UITextInput` on `WinitView`:
  - `setMarkedText:selectedRange:` → `WindowEvent::Ime(Ime::Preedit(...))`
  - `unmarkText` → `Ime::Commit(prev) + Preedit("", None)` (so that
    e.g. typing `n` and then tapping `123` keeps `n` in the field
    instead of silently dropping it, matching how UIKit's own
    `UITextField` behaves)
  - `replaceRange:withText:` (the typical pinyin / kana commit path)
    → `WindowEvent::Ime(Ime::Commit(...))`
  - The other 20+ required methods are minimal but correct stubs
    that model the document as just the current marked string —
    that's sufficient because committed text lives on the
    application side and only flows back out via the existing
    `Ime::Commit` path.
* Implements `baseWritingDirectionForPosition:inDirection:` and
  `setBaseWritingDirection:forRange:` as plain selectors. The
  protocol marks them required at runtime even though the Rust
  binding for `NSWritingDirection` is gated on the `NSText` feature,
  so they're declared outside the `UITextInput` impl block to avoid
  pulling that feature in.

Tested in the iPhone 17 Pro simulator with iOS 26.3 (system
zh_Hans-Pinyin keyboard):

* Without the patch: tapping any letter on the pinyin keyboard has
  no visible effect; candidate bar stays empty.
* With the patch: tapping letters opens the candidate bar populated
  with real hanzi (e.g. tapping `n` yields 你 / 能 / 年 …), the
  preedit text shows up inline in the focused text input with the
  usual iOS highlight, and selecting a candidate (or pressing the
  spacebar to commit the first one) inserts the chosen hanzi into
  the text input.
* ASCII input via `UIKeyInput.insertText:` and backspace via
  `deleteBackward` continue to work unchanged.

Author: biancheng-net

winit-uikit/src/ime.rs

@@ -0,0 +1,121 @@
+//! Helpers for the iOS `UITextInput` protocol implementation.
+//!
+//! UIKit requires that anything which can be the target of a multi-stage
+//! (CJK) input method adopt `UITextInput`, which talks in terms of opaque
+//! `UITextPosition` / `UITextRange` objects. iOS will call back into our view
+//! with these objects, so we need concrete subclasses we can downcast and read
+//! offsets from.
+//!
+//! We treat the "document" that `UITextInput` sees as just the current marked
+//! (preedit) text — outside of an active composition we report an empty
+//! document. The committed text lives on the application side; we only forward
+//! `Ime::Preedit` / `Ime::Commit` events.
+
+use std::cell::Cell;
+
+use objc2::rc::Retained;
+use objc2::runtime::NSObjectProtocol;
+use objc2::{DefinedClass, MainThreadMarker, MainThreadOnly, define_class, msg_send};
+use objc2_foundation::NSObject;
+use objc2_ui_kit::{UITextPosition, UITextRange};
+
+/// State that the view tracks for an active IME composition.
+///
+/// `marked_text` is the current preedit string. `selected_range` is the
+/// selection inside that preedit string (start/end in UTF-8 byte offsets,
+/// matching what `Ime::Preedit` expects).
+#[derive(Default)]
+pub(crate) struct ImeState {
+    pub(crate) marked_text: String,
+    pub(crate) selected_range: (usize, usize),
+}
+
+impl ImeState {
+    pub(crate) fn is_marked(&self) -> bool {
+        !self.marked_text.is_empty()
+    }
+
+    pub(crate) fn marked_len_chars(&self) -> usize {
+        self.marked_text.chars().count()
+    }
+}
+
+pub(crate) struct WinitTextPositionState {
+    offset: Cell<i64>,
+}
+
+define_class!(
+    /// `UITextPosition` subclass carrying a character offset into the marked text.
+    #[unsafe(super(UITextPosition, NSObject))]
+    #[thread_kind = MainThreadOnly]
+    #[name = "WinitTextPosition"]
+    #[ivars = WinitTextPositionState]
+    pub(crate) struct WinitTextPosition;
+);
+
+impl WinitTextPosition {
+    pub(crate) fn new(mtm: MainThreadMarker, offset: i64) -> Retained<Self> {
+        let this = mtm.alloc().set_ivars(WinitTextPositionState { offset: Cell::new(offset) });
+        unsafe { msg_send![super(this), init] }
+    }
+
+    pub(crate) fn offset(&self) -> i64 {
+        self.ivars().offset.get()
+    }
+}
+
+pub(crate) struct WinitTextRangeState {
+    start: Cell<i64>,
+    end: Cell<i64>,
+}
+
+define_class!(
+    /// `UITextRange` subclass holding a `[start, end)` interval of character
+    /// offsets into the marked text.
+    #[unsafe(super(UITextRange, NSObject))]
+    #[thread_kind = MainThreadOnly]
+    #[name = "WinitTextRange"]
+    #[ivars = WinitTextRangeState]
+    pub(crate) struct WinitTextRange;
+
+    impl WinitTextRange {
+        #[unsafe(method(isEmpty))]
+        fn is_empty(&self) -> bool {
+            self.ivars().start.get() == self.ivars().end.get()
+        }
+
+        #[unsafe(method_id(start))]
+        fn start_position(&self) -> Retained<UITextPosition> {
+            let mtm = MainThreadMarker::new().expect("WinitTextRange used off the main thread");
+            let p = WinitTextPosition::new(mtm, self.ivars().start.get());
+            Retained::into_super(p)
+        }
+
+        #[unsafe(method_id(end))]
+        fn end_position(&self) -> Retained<UITextPosition> {
+            let mtm = MainThreadMarker::new().expect("WinitTextRange used off the main thread");
+            let p = WinitTextPosition::new(mtm, self.ivars().end.get());
+            Retained::into_super(p)
+        }
+    }
+);
+
+impl WinitTextRange {
+    pub(crate) fn new(mtm: MainThreadMarker, start: i64, end: i64) -> Retained<Self> {
+        let this = mtm
+            .alloc()
+            .set_ivars(WinitTextRangeState { start: Cell::new(start), end: Cell::new(end) });
+        unsafe { msg_send![super(this), init] }
+    }
+
+    pub(crate) fn start_offset(&self) -> i64 {
+        self.ivars().start.get()
+    }
+
+    pub(crate) fn end_offset(&self) -> i64 {
+        self.ivars().end.get()
+    }
+}
+
+unsafe impl NSObjectProtocol for WinitTextPosition {}
+unsafe impl NSObjectProtocol for WinitTextRange {}

winit-uikit/src/lib.rs

@@ -102,6 +102,7 @@
 
 mod app_state;
 mod event_loop;
+mod ime;
 mod monitor;
 mod view;
 mod view_controller;