Struct TextInput 

pub struct TextInput {

    pub asset_id: AssetId,
    pub font: Option<FontHandle>,
    pub content: String,
    pub placeholder: String,
    pub x: f32,
    pub y: f32,
    pub width: f32,
    pub height: f32,
    pub scale: f32,
    pub text_color: [f32; 3],
    pub placeholder_color: [f32; 3],
    pub background: [f32; 4],
    pub caret_color: [f32; 3],
    pub corner_radius: f32,
    pub padding: f32,
    pub max_len: u32,
    pub visible: bool,
    pub fit: SpriteFit,
    pub screen: Option<AssetId>,
    pub focused: bool,
    pub ghost: String,
    pub caret: usize,
}

An editable single-line text field drawn as a UI overlay.

A filled rounded box showing the typed content (or a dimmer placeholder while empty), plus a caret when the field holds keyboard focus. The engine gives focus to the field the cursor clicks, appends the characters typed that frame, and moves or edits at the caret with the arrow / Home / End / Backspace / Delete keys. Read content back to use what the player typed; set it to pre-fill the field.

Like other overlay elements it belongs to a Screen resolved from the naming convention (<screen>_*), or is always shown when it has none.

TextInput {
    placeholder: "Enter your name".into(),
    x: 400.0,
    y: 300.0,
    width: 480.0,
    height: 48.0,
    max_len: 24,
    ..Default::default()
};

Fields

asset_id: AssetId

Asset identity; injected via inject_name. Not part of args.

font: Option<FontHandle>

The Font used to render the field’s text. Unset draws with the engine’s built-in face at its native 24px.

content: String

The current text. Edited in place as the player types; set an initial value here to pre-fill the field.

placeholder: String

Dimmer prompt shown while content is empty and the field is unfocused.

x: f32

Left edge in screen pixels from the window’s top-left.

y: f32

Top edge in screen pixels from the window’s top-left.

width: f32

Field width in screen pixels.

height: f32

Field height in screen pixels.

scale: f32

Uniform scale applied on top of the font’s size_px (24 for the built-in face). 1.0 = native size.

text_color: [f32; 3]

Linear-space RGB colour of the typed text.

placeholder_color: [f32; 3]

Linear-space RGB colour of the placeholder prompt.

background: [f32; 4]

RGBA fill of the field’s background box, each channel in [0, 1].

caret_color: [f32; 3]

Linear-space RGB colour of the caret bar.

corner_radius: f32

Corner rounding radius of the background box, in field pixels.

padding: f32

Inner horizontal inset from the box edge to the text, in pixels.

max_len: u32

Maximum number of characters accepted. 0 means no limit.

visible: bool

When false the field is skipped each frame and cannot take focus.

fit: SpriteFit

How a screen-owned field maps from the reference canvas to the window when their aspect ratios differ (matches Sprite’s fit).

screen: Option<AssetId>

Screen this field belongs to. Resolved automatically from the naming convention (<screen>_*); you don’t set this directly. None means the field is always visible.

focused: bool

Runtime keyboard-focus flag, set by the engine while this is the active field. Not authored and not serialized to a blob.

ghost: String

Runtime inline-completion suffix, drawn in the placeholder colour after the typed content while the field holds focus. Set by whoever drives the field (e.g. an autocomplete); never edited by typing. Not authored and not serialized to a blob.

caret: usize

Runtime caret position as a character index into content. Not authored and not serialized to a blob.

Trait Implementations

impl Clone for TextInput

fn clone(&self) -> TextInput

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Component for TextInput

const NAME: &'static str = "TextInput"

The registry name a world authors this component under.

fn inject_name(&mut self, id: AssetId)

Called after construction to inject the asset’s identity from the blob def. Only meaningful for components that look themselves up by id at runtime. The default implementation does nothing.

fn from_baked(bytes: &[u8]) -> Result<Self, CnResult>

Reconstruct this component from a blob record, whose bytes are the serialized runtime component (cook already ran the asset -> component translation). The default rejects: runtime-only components are never stored in a blob, so only loadable types provide an implementation.

fn inject_locator(&mut self, _locator: PayloadLocator)

Called after construction to inject the payload locator from the blob def. Only meaningful for components with a compiled payload. The default implementation does nothing (correct for most components).

impl ComponentSlot for TextInput

const DISCRIMINANT: u8

The component type’s stable id, used as its ComponentId.

fn slot(s: &ComponentStorage) -> &Column<Self>

Borrow this type’s column out of the storage.

fn slot_mut(s: &mut ComponentStorage) -> &mut Column<Self>

Mutably borrow this type’s column out of the storage.

impl Debug for TextInput

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

Formats the value using the given formatter.

impl Default for TextInput

fn default() -> TextInput

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for TextInput

where TextInput: Default,

fn deserialize<__D>( __deserializer: __D, ) -> Result<TextInput, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<TextInput> for ComponentAsset

fn from(c: TextInput) -> Self

Converts to this type from the input type.

impl RuntimeComponent for TextInput

impl Serialize for TextInput

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.