Struct ImeState 

pub struct ImeState {
    pub active: bool,
    pub editing: EditingState,
    pub caret: Option<Rect>,
    pub content_type: ImeContentType,
    pub suppress_soft_keyboard: bool,
}

The event-pass/IME-surface EditingState — see this module’s own docs for the split against text::EditingState, frust_text::editor’s distinct, byte-indexed type. ImeContentType is the input-purpose hint an editable widget publishes on its ImeState so a shell can lock a secret field’s keyboard down. The IME-relevant surface a focused editable widget publishes for the shell.

Written by the focused widget through EventCtx::publish_ime_state, it bubbles up the focus chain and is stored on crate::app::RenderRoot, where the shell reads it via crate::app::RenderRoot::ime_state to drive the platform IME (winit set_ime_cursor_area, Android updateSelection, iOS inputDelegate). See the module docs for the index boundary rule.

editing carries the real text, even for a secret field

content_type marks a field secret; it does not redact editing. That is deliberate: this struct is one half of a bidirectional state-sync mirror (see docs/CODE_STANDARDS.md’s state-sync rule) — the platform keeps a local Editable/UITextInput mirror seeded from these exact fields and hands a whole reconciled EditingState back through ImeEvent::ApplyEditingState. Publishing redacted or masked text would desynchronize that mirror (the platform would compute deletions/replacements against text the widget does not have, and would echo the mask back as the field’s new value), and it would not close the leak anyway: the keyboard process is where the characters originate. What a hint does close is the suggestion strip reading the field’s text and the IME persisting it to a learned-word dictionary.

Residual exposure: the plaintext still crosses the FFI seam into the platform IME. A hostile or non-compliant third-party keyboard can read it. That is unavoidable on both mobile platforms short of not using the platform IME at all. As partial mitigation, this type’s fmt::Debug redacts the text whenever the content type is secret, so a trace log never carries it.

Fields

active: bool

Whether the focused widget currently wants IME active.

editing: EditingState

The current editing state (UTF-16 indexed at this shell-facing surface).

caret: Option<Rect>

The caret rectangle in logical coordinates, for IME candidate placement.

content_type: ImeContentType

What kind of content the field holds, so the shell can configure the platform IME. Defaults to ImeContentType::Normal — a field that says nothing behaves exactly as it did before this hint existed.

suppress_soft_keyboard: bool

Whether the field wants the platform input surface without an on-screen keyboard.

A field whose text cannot be changed is still focusable and copyable (Material 3 and Apple’s HIG both keep it so), and copying is exactly what needs the surface: the web overlay <input>’s DOM copy listener, Android’s InputConnection and iOS’s first responder are each the route a clipboard verb travels, and all three exist only while active holds. What such a field does not need is somewhere to type — so this asks the shell to keep the surface wired and suppress the soft keyboard it would otherwise raise.

Defaults to false — a field that says nothing behaves exactly as it did before this hint existed. It says nothing about an inactive surface (there is no keyboard up to suppress), and a shell with no on-screen keyboard of its own has nothing to do for it.

Trait Implementations

impl Clone for ImeState

fn clone(&self) -> ImeState

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ImeState

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Hand-written so a secret field’s text never reaches a log.

Everything except EditingState::text prints as derived; for a secret content_type the text is replaced by <redacted> (no length, which would itself leak).

impl Default for ImeState

fn default() -> ImeState

A cleared, inactive surface with no hint — what a container publishes when it stops routing to an editable child.

impl PartialEq for ImeState

fn eq(&self, other: &ImeState) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for ImeState