Struct EditableText 

pub struct EditableText {
    pub editor: PlainEditor<TextBrush>,
    pub pending_edits: Vec<TextEdit>,
    pub pending_paste: Option<ClipboardRead>,
    pub cursor_width: f32,
    pub cursor_blink_period: Duration,
    pub max_characters: Option<usize>,
    pub visible_lines: Option<f32>,
    pub visible_width: Option<f32>,
    pub allow_newlines: bool,
}

A plain-text text input field.

Please see this module docs for more details on usage and functionality.

Note that text editing operations are trickier than they might first appear, due to the complexities of Unicode text handling.

As a result, we store an internal PlainEditor instance, which manages both the text content and the cursor position, and provides methods for applying text edits and cursor movements correctly according to Unicode rules.

Fields

editor: PlainEditor<TextBrush>

A parley::PlainEditor, tracking both the text content and cursor position.

This serves as an analogue to ComputedTextBlock for editable text.

In most cases, you should queue text edits via the EditableText::queue_edit method instead of directly manipulating the editor, and then allow the apply_text_edits system to apply the edits at the appropriate time in the update cycle.

Note that many more complex editing operations require working with PlainEditor::driver. These operations should generally be batched together to avoid redundant layout work.

pending_edits: Vec<TextEdit>

Text edit actions that have been requested but not yet applied.

These edits are processed in first-in, first-out order.

pending_paste: Option<ClipboardRead>

A paste operation that is awaiting clipboard I/O.

On platforms where system clipboard reads are asynchronous (currently wasm32), a TextEdit::Paste may not resolve in the same frame it was queued.

While this field is Some, apply_pending_edits waits for this to resolve, rather than draining further edits, so that everything after the paste stays correctly ordered behind it.

cursor_width: f32

Cursor width, relative to font size

cursor_blink_period: Duration

Cursor blink period in seconds.

max_characters: Option<usize>

Maximum number of characters the text input can contain.

Edits which would cause the length to exceed the maximum are ignored. Does not stop setting a string longer than the maximum using set_text.

visible_lines: Option<f32>

Sets the input’s height in number of visible lines.

visible_width: Option<f32>

Sets the input’s width in number of visible glyphs. For proportional fonts the final size is the given value times the “0” advance width.

allow_newlines: bool

Allow new lines

Implementations

impl EditableText

pub fn new(initial_text: impl AsRef<str>) -> Self

Creates a new EditableText with its buffer already containing some initial text and its cursor positioned at the end.

pub fn editor(&self) -> &PlainEditor<TextBrush>

Access the internal PlainEditor.

pub fn editor_mut(&mut self) -> &mut PlainEditor<TextBrush>

Mutably access the internal PlainEditor.

pub fn value(&self) -> SplitString<'_>

Get the current text input as a SplitString.

A SplitString can be converted into a String using to_string if needed.

pub fn queue_edit(&mut self, edit: TextEdit)

Queue a TextEdit action to be applied later by the apply_text_edits system.

pub fn apply_pending_edits( &mut self, font_context: &mut FontContext, layout_context: &mut LayoutContext<TextBrush>, clipboard: &mut Clipboard, char_filter: impl Fn(char) -> bool, )

Applies all TextEdits in pending_edits immediately, updating the PlainEditor text / cursor state accordingly.

FontContext should be gathered from the FontCx resource, and LayoutContext should be gathered from the LayoutCx resource.

On platforms with async clipboard reads (wasm32), a TextEdit::Paste whose contents aren’t yet available acts as a barrier: this call parks the in-flight read on EditableText and leaves the remaining edits queued in order. Each subsequent frame re-polls the read, and processing resumes once it resolves. On native targets clipboard reads are synchronous, so this barrier collapses.

pub fn clear(&mut self)

Clears the input’s text buffer and any pending edits.

Also drops any in-flight paste. The underlying clipboard read task will still complete, but its result is discarded.

pub fn is_composing(&self) -> bool

Is the IME currently composing text for this input?

Some behavior (e.g. “submit on Enter”) may want to be suppressed while the IME is active to avoid interrupting the user’s composition.

Trait Implementations

impl Clone for EditableText

fn clone(&self) -> EditableText

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Component for EditableText

where Self: Send + Sync + 'static,

Required Components: TextLayout, TextFont, TextColor, LineHeight, FontHinting, EditableTextGeneration.

A component’s Required Components are inserted whenever it is inserted. Note that this will also insert the required components of the required components, recursively, in depth-first order.

const STORAGE_TYPE: StorageType = bevy_ecs::component::StorageType::Table

A constant indicating the storage type used for this component.

type Mutability = Mutable

A marker type to assist Bevy with determining if this component is mutable, or immutable. Mutable components will have Component<Mutability = Mutable>, while immutable components will instead have Component<Mutability = Immutable>.

fn register_required_components( _requiree: ComponentId, required_components: &mut RequiredComponentsRegistrator<'_, '_>, )

Registers required components.

fn clone_behavior() -> ComponentCloneBehavior

Called when registering this component, allowing to override clone function (or disable cloning altogether) for this component.

fn relationship_accessor() -> Option<ComponentRelationshipAccessor<Self>>

Returns ComponentRelationshipAccessor required for working with relationships in dynamic contexts.

fn on_add() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_add ComponentHook for this Component if one is defined.

fn on_insert() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_insert ComponentHook for this Component if one is defined.

fn on_discard() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_discard ComponentHook for this Component if one is defined.

fn on_remove() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_remove ComponentHook for this Component if one is defined.

fn on_despawn() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_despawn ComponentHook for this Component if one is defined.

fn map_entities<E>(_this: &mut Self, _mapper: &mut E)

where E: EntityMapper,

Maps the entities on this component using the given EntityMapper. This is used to remap entities in contexts like scenes and entity cloning. When deriving Component, this is populated by annotating fields containing entities with #[entities]

impl Default for EditableText

fn default() -> Self

Returns the “default value” for a type.