Struct App 

pub struct App {

    pub core: Core,
    pub theme: Theme,
    pub theme_chrome: ThemeChrome,
    pub pending_tasks: Vec<Task<Message>>,
    pub windows: WindowMap,
    pub image_registry: ImageRegistry,
    pub system_theme: Theme,
    pub theme_follows_system: bool,
    pub scale_factor: f32,
    pub registry: WidgetRegistry,
    pub animation_epoch: Option<Instant>,
    pub emitter: EventEmitter,
    pub effect_handler: Box<dyn EffectHandler>,
    pub transition_manager: TransitionManager,
    pub current_modifiers: Modifiers,
    pub codec: Codec,
}

The iced daemon application. Owns the rendering engine, window state, widget registry, and all runtime state needed to translate between the wire protocol and iced’s update/view cycle.

Fields

core: Core

theme: Theme

theme_chrome: ThemeChrome

pending_tasks: Vec<Task<Message>>

Widget ops and effects return iced Tasks, but apply() doesn’t return them. They accumulate here and are drained via Task::batch in update() after apply() returns.

windows: WindowMap

Bidirectional plushie ID <-> iced window ID mapping with per-window state.

image_registry: ImageRegistry

In-memory image handles for use by Image widgets and canvas draw.

system_theme: Theme

Current system theme, tracked via ThemeChanged subscription.

theme_follows_system: bool

True when the app-level theme is “system” (follow OS preference).

scale_factor: f32

Global scale factor multiplier (1.0 = follow OS DPI).

registry: WidgetRegistry

Unified widget registry. All widget types are dispatched through this registry.

animation_epoch: Option<Instant>

Epoch for animation_frame timestamp calculation.

emitter: EventEmitter

Rate-limited event emitter with coalescing.

effect_handler: Box<dyn EffectHandler>

Platform-specific effect handler injected at construction. Native and WASM crates each provide their own EffectHandler implementation.

transition_manager: TransitionManager

Renderer-side animation manager. Tracks transitions, springs, and exit ghosts. Advances on frame ticks and writes interpolated values to SharedState.interpolated_props.

current_modifiers: Modifiers

Current keyboard modifier state, updated on every ModifiersChanged event. Included on all outgoing pointer events.

codec: Codec

Wire protocol codec. Used for encoding stub acks and scripting responses. Stored here so these paths don’t need the global.

Implementations

impl App

pub fn new( registry: WidgetRegistry, effect_handler: Box<dyn EffectHandler>, sink: Arc<SinkMutex>, ) -> Self

pub fn set_codec(&mut self, codec: Codec)

Set the wire protocol codec. Called during startup after codec negotiation. Defaults to MsgPack.

pub fn title_for_window(&self, iced_id: Id) -> String

pub fn theme_for_window(&self, iced_id: Id) -> Theme

pub fn theme_ref_for_window(&self, iced_id: Id) -> &Theme

pub fn theme_chrome_for_window(&self, iced_id: Id) -> ThemeChrome

pub fn scale_factor_for_window(&self, iced_id: Id) -> f32

pub fn emit_subscription( &self, key: &str, captured: bool, event_fn: impl Fn(&str) -> OutgoingEvent, ) -> Task<Message>

Emit a subscription event to all matching entries (specific kind + catch-all SUB_EVENT), filtered by window_id. The event_fn is called once per matching entry with the entry’s tag.

event_fn receives the tag as &str; the OutgoingEvent constructor allocates the owned tag internally via impl Into<String>. Earlier versions cloned the tag at the call site before passing it in.

pub fn emit_subscription_for_window( &self, key: &str, window_id: Option<&str>, captured: bool, event_fn: impl Fn(&str) -> OutgoingEvent, ) -> Task<Message>

Emit a subscription event scoped to a specific window.

pub fn lookup_widget_event_rate(&self, widget_id: &str) -> Option<u32>

pub fn is_widget_disabled_for_interception(&self, widget_id: &str) -> bool

True when the widget at widget_id is declared disabled and is of a type that participates in functional disabled interception.

iced’s native Status::Disabled is style-only: events still reach update() from widgets the user considers disabled. This helper lets the dispatcher swallow events for input-family widgets so disabled: true blocks interaction as every host SDK documents.

Widget types in scope: text_input, text_editor, combo_box, pick_list. Extending coverage to other widgets (e.g. slider) is a future step once their behaviour is audited.

pub fn coalesce_subscription( &mut self, key: &str, captured: bool, event_fn: impl Fn(&str) -> OutgoingEvent, ) -> Task<Message>

Coalesce a subscription event for all matching entries.

pub fn coalesce_subscription_for_window( &mut self, key: &str, window_id: Option<&str>, captured: bool, event_fn: impl Fn(&str) -> OutgoingEvent, ) -> Task<Message>

Coalesce a subscription event scoped to a specific window. Each matching entry gets its own coalesce buffer (keyed by tag) so rate limiting is isolated per subscription entry.

pub fn dispatch_widget_subscription( &mut self, kind: &str, window_id: Option<&str>, msg: &Message, ) -> Task<Message>

Route a Message to every widget with an active subscription for kind (optionally scoped to window_id) and emit the resulting outgoing events.

Fast path: returns Task::none when no widget cares about kind, so handlers can call this unconditionally without cloning message payloads in the common case.

impl App

pub fn apply(&mut self, message: IncomingMessage) -> Result<()>

impl App

pub fn handle_key_pressed( &self, data: KeyEventData, iced_id: Id, ) -> Task<Message>

pub fn handle_key_released( &self, data: KeyEventData, iced_id: Id, ) -> Task<Message>

pub fn handle_modifiers_changed( &mut self, mods: Modifiers, iced_id: Id, captured: bool, ) -> Task<Message>

pub fn handle_cursor_moved( &mut self, pos: Point, iced_id: Id, captured: bool, ) -> Task<Message>

pub fn handle_cursor_entered( &self, iced_id: Id, captured: bool, ) -> Task<Message>

pub fn handle_cursor_left(&self, iced_id: Id, captured: bool) -> Task<Message>

pub fn handle_mouse_button_pressed( &self, button: Button, iced_id: Id, captured: bool, ) -> Task<Message>

pub fn handle_mouse_button_released( &self, button: Button, iced_id: Id, captured: bool, ) -> Task<Message>

pub fn handle_wheel_scrolled( &mut self, delta: ScrollDelta, iced_id: Id, captured: bool, ) -> Task<Message>

pub fn handle_finger_pressed( &self, finger: Finger, pos: Point, iced_id: Id, captured: bool, ) -> Task<Message>

pub fn handle_finger_moved( &mut self, finger: Finger, pos: Point, iced_id: Id, captured: bool, ) -> Task<Message>

pub fn handle_finger_lifted( &self, finger: Finger, pos: Point, iced_id: Id, captured: bool, ) -> Task<Message>

pub fn handle_finger_lost( &self, finger: Finger, pos: Point, iced_id: Id, captured: bool, ) -> Task<Message>

pub fn handle_ime_opened(&self, iced_id: Id, captured: bool) -> Task<Message>

pub fn handle_ime_preedit( &self, text: String, cursor: Option<Range<usize>>, iced_id: Id, captured: bool, ) -> Task<Message>

pub fn handle_ime_commit( &self, text: String, iced_id: Id, captured: bool, ) -> Task<Message>

pub fn handle_ime_closed(&self, iced_id: Id, captured: bool) -> Task<Message>

pub fn handle_window_event(&self, iced_id: Id, evt: Event) -> Task<Message>

impl App

pub fn execute(&mut self, op: RendererOp) -> Task<Message>

Execute a typed renderer operation.

Returns an iced Task for operations that need async completion (focus, scroll, effects, window queries).

impl App

pub fn renderer_subscriptions(&self) -> Subscription<Message>

Build renderer subscriptions (everything except platform-specific input sources like stdin). The binary crate combines this with its own input subscription.

impl App

pub fn update(&mut self, message: Message) -> Task<Message>

pub fn handle_stdin(&mut self, event: StdinEvent) -> Task<Message>

impl App

pub fn view_window(&self, iced_id: Id) -> Element<'_, Message>

Render a single window’s UI tree into iced Elements. Called by the iced daemon for each open window on every frame.

impl App

pub fn handle_widget_op(&mut self, op: &str, payload: &Value) -> Task<Message>

Dispatch a widget operation by name. Called when Core produces a WidgetOp effect. Returns an iced Task for operations that need async completion (focus, scroll, font load).

pub fn handle_image_op( &mut self, op: &str, handle: &str, data: Option<Vec<u8>>, pixels: Option<Vec<u8>>, width: Option<u32>, height: Option<u32>, )

Apply an image operation (create, update, remove) to the in-memory image registry. Emits an error event on failure.

impl App

pub fn dispatch_window_op(&mut self, op: WindowOp) -> Task<Message>

Dispatch a typed WindowOp.

Each variant maps to the appropriate iced window operation. The window id is looked up in self.windows; unknown ids are logged and produce Task::none().

pub fn dispatch_window_query(&mut self, q: WindowQuery) -> Task<Message>

Dispatch a typed WindowQuery. Each variant produces a response event via the emitter sink when the underlying iced task resolves.

pub fn dispatch_system_op(&mut self, op: SystemOp) -> Task<Message>

Dispatch a typed SystemOp.

pub fn dispatch_system_query(&mut self, q: SystemQuery) -> Task<Message>

Dispatch a typed SystemQuery. Responses are emitted via the sink when the underlying iced task resolves.

pub fn sync_windows(&mut self) -> Task<Message>

Compare the set of window nodes in the tree against the currently open windows and open/close as needed.

pub fn window_settings_for(&self, window_id: &str) -> Settings

Build window::Settings from a window node’s props.