@spec advance_frame(timestamp :: non_neg_integer()) :: %Toddy.Command{
  payload: term(),
  type: term()
}

Advance the animation clock by one frame in headless/test mode.

Sends an advance_frame message to the renderer with the given timestamp (monotonic milliseconds). If on_animation_frame is subscribed, the renderer emits an animation_frame event back.

This is a test/headless-only command. In normal daemon mode the renderer drives animation frames from the display vsync.

Example

Toddy.Command.advance_frame(16)

@spec allow_automatic_tabbing(enabled :: boolean()) :: %Toddy.Command{
  payload: term(),
  type: term()
}

Sets whether the system can automatically organize windows into tabs.

This is a macOS-specific setting. On other platforms it is a no-op. See: https://developer.apple.com/documentation/appkit/nswindow/1646657-allowsautomaticwindowtabbing

@spec announce(text :: String.t()) :: t()

Triggers a screen reader announcement without a visible widget.

The text is immediately announced by assistive technology as a live-region assertion. Useful for status updates, error messages, and other dynamic content that should be announced but doesn't need to be visually displayed.

Example

Command.announce("File saved successfully")
Command.announce("3 search results found")

@spec async(fun :: fun(), event_tag :: atom()) :: %Toddy.Command{
  payload: term(),
  type: term()
}

Run fun asynchronously in a Task. When it returns, the runtime dispatches %Toddy.Event.Async{tag: event_tag, result: result} through update/2.

@spec batch(commands :: t() | [t()]) :: %Toddy.Command{payload: term(), type: term()}

Issue multiple commands. Commands in the batch execute concurrently.

Accepts a single command, a list of commands, or a nested list -- anything List.wrap/1 can normalize.

@spec cancel(event_tag :: atom()) :: %Toddy.Command{payload: term(), type: term()}

Cancel a running async or stream command by its tag.

If the task has already completed, this is a no-op. The runtime tracks running tasks by their event tag and terminates the associated process.

Example

Command.cancel(:file_import)

@spec clear_images() :: %Toddy.Command{payload: term(), type: term()}

Clears all in-memory images.

@spec close_window(window_id :: window_id()) :: %Toddy.Command{
  payload: term(),
  type: term()
}

Close the window identified by window_id.

@spec create_image(handle :: String.t(), data :: binary()) :: %Toddy.Command{
  payload: term(),
  type: term()
}

Creates an in-memory image from encoded PNG/JPEG bytes.

The raw binary is stored as-is in the command payload. The protocol layer handles format-specific encoding (native binary for msgpack, base64 for JSON).

@spec create_image(
  handle :: String.t(),
  width :: pos_integer(),
  height :: pos_integer(),
  pixels :: binary()
) :: %Toddy.Command{payload: term(), type: term()}

Creates an in-memory image from raw RGBA pixel data.

The raw binary is stored as-is in the command payload. The protocol layer handles format-specific encoding (native binary for msgpack, base64 for JSON).

@spec delete_image(handle :: String.t()) :: %Toddy.Command{
  payload: term(),
  type: term()
}

Deletes an in-memory image by handle name.

@spec disable_mouse_passthrough(window_id :: window_id()) :: %Toddy.Command{
  payload: term(),
  type: term()
}

Disable mouse passthrough on a window.

@spec done(value :: term(), msg_fn :: (term() -> term())) :: %Toddy.Command{
  payload: term(),
  type: term()
}

Wraps an already-resolved value in a command. The runtime immediately dispatches msg_fn.(value) through update/2 without spawning a task.

Useful for lifting a pure value into the command pipeline.

@spec drag_resize_window(window_id :: window_id(), direction :: atom() | String.t()) ::
  %Toddy.Command{
    payload: term(),
    type: term()
  }

Start drag-resizing the window from the given edge/corner direction.

@spec drag_window(window_id :: window_id()) :: %Toddy.Command{
  payload: term(),
  type: term()
}

Start dragging the window.

@spec enable_mouse_passthrough(window_id :: window_id()) :: %Toddy.Command{
  payload: term(),
  type: term()
}

Enable mouse passthrough on a window (clicks pass through to windows below).

@spec exit() :: %Toddy.Command{payload: term(), type: term()}

Exit the application.

@spec extension_command(node_id :: String.t(), op :: String.t(), payload :: map()) ::
  %Toddy.Command{
    payload: term(),
    type: term()
  }

Send a command to a native extension widget.

Extension commands bypass the normal tree update / diff / patch cycle and are delivered directly to the target extension widget on the Rust side.

@spec extension_commands(commands :: [{String.t(), String.t(), map()}]) ::
  %Toddy.Command{
    payload: term(),
    type: term()
  }

Send a batch of extension commands (processed in one cycle).

Each command in the list is a {node_id, op, payload} tuple.

@spec find_focused(tag :: atom()) :: %Toddy.Command{payload: term(), type: term()}

Queries which widget currently has focus.

The result arrives in update/2 as %System{type: :find_focused, tag: tag, data: %{"focused" => "..." | nil}}.

Note: if no widget is focused, the "focused" field may be nil.

@spec focus(widget_id :: widget_id()) :: %Toddy.Command{payload: term(), type: term()}

Focus the widget identified by widget_id.

@spec focus_next() :: %Toddy.Command{payload: term(), type: term()}

Move focus to the next focusable widget.

@spec focus_previous() :: %Toddy.Command{payload: term(), type: term()}

Move focus to the previous focusable widget.

@spec gain_focus(window_id :: window_id()) :: %Toddy.Command{
  payload: term(),
  type: term()
}

Give focus to a window.

@spec get_mode(window_id :: window_id(), tag :: event_tag()) :: %Toddy.Command{
  payload: term(),
  type: term()
}

Query the current window mode (windowed, fullscreen, hidden). Result arrives as an effect response keyed by window ID.

@spec get_scale_factor(window_id :: window_id(), tag :: event_tag()) ::
  %Toddy.Command{
    payload: term(),
    type: term()
  }

Query the window's current scale factor (DPI scaling). Result arrives as an effect response keyed by window ID.

@spec get_system_info(tag :: event_tag()) :: %Toddy.Command{
  payload: term(),
  type: term()
}

Query system information (OS, CPU, memory, graphics).

The result arrives in update/2 as {:system_info, tag, info} where tag is the stringified event tag and info is a map with keys: "system_name", "system_kernel", "system_version", "system_short_version", "cpu_brand", "cpu_cores", "memory_total", "memory_used", "graphics_backend", "graphics_adapter".

System info is always available (the sysinfo iced feature is enabled unconditionally).

Example

def update(model, %Toddy.Event.Widget{type: :click, id: "sys_info"}) do
  {model, Toddy.Command.get_system_info(:sys_info)}
end

def update(model, {:system_info, "sys_info", info}) do
  %{model | system: info}
end

@spec get_system_theme(tag :: event_tag()) :: %Toddy.Command{
  payload: term(),
  type: term()
}

Query the current system theme (light/dark mode).

The result arrives in update/2 as {:system_theme, tag, mode} where tag is the stringified event tag and mode is "light", "dark", or "none" (when no system preference is detected). Returns "none" on Linux systems without a desktop environment. Apps should provide a theme fallback.

Example

def update(model, %Toddy.Event.Widget{type: :click, id: "check_theme"}) do
  {model, Toddy.Command.get_system_theme(:theme_result)}
end

def update(model, {:system_theme, "theme_result", mode}) do
  %{model | theme_mode: mode}
end

@spec get_window_position(window_id :: window_id(), tag :: event_tag()) ::
  %Toddy.Command{
    payload: term(),
    type: term()
  }

Query the position of a window. Result arrives as {tag, {x, y}}.

@spec get_window_size(window_id :: window_id(), tag :: event_tag()) :: %Toddy.Command{
  payload: term(),
  type: term()
}

Query the size of a window. Result arrives as {tag, {width, height}}.

@spec is_maximized(window_id :: window_id(), tag :: event_tag()) :: %Toddy.Command{
  payload: term(),
  type: term()
}

Query whether a window is maximized. Result arrives as {tag, boolean}.

@spec is_minimized(window_id :: window_id(), tag :: event_tag()) :: %Toddy.Command{
  payload: term(),
  type: term()
}

Query whether a window is minimized. Result arrives as {tag, boolean}.

@spec list_images(tag :: atom()) :: %Toddy.Command{payload: term(), type: term()}

Lists all in-memory image handles.

The result arrives in update/2 as %System{type: :image_list, tag: tag, data: %{"handles" => [...]}}.

@spec load_font(data :: binary()) :: %Toddy.Command{payload: term(), type: term()}

Loads a font at runtime from binary data.

The font data should be the raw bytes of a TrueType (.ttf) or OpenType (.otf) font file. Once loaded, the font can be referenced by name in widget font props.

Example

font_data = File.read!("path/to/CustomFont.ttf")
Toddy.Command.load_font(font_data)

@spec maximize_window(window_id :: window_id(), maximized :: boolean()) ::
  %Toddy.Command{
    payload: term(),
    type: term()
  }

Maximize or restore a window.

@spec minimize_window(window_id :: window_id(), minimized :: boolean()) ::
  %Toddy.Command{
    payload: term(),
    type: term()
  }

Minimize or restore a window.

@spec monitor_size(window_id :: window_id(), tag :: event_tag()) :: %Toddy.Command{
  payload: term(),
  type: term()
}

Query the monitor size for the display containing a window. Result arrives as an effect response with {width, height} or null if the monitor cannot be determined.

@spec move_cursor_to(widget_id :: widget_id(), position :: non_neg_integer()) ::
  %Toddy.Command{
    payload: term(),
    type: term()
  }

Move the text cursor to a specific position.

@spec move_cursor_to_end(widget_id :: widget_id()) :: %Toddy.Command{
  payload: term(),
  type: term()
}

Move the text cursor to the end of the input.

@spec move_cursor_to_front(widget_id :: widget_id()) :: %Toddy.Command{
  payload: term(),
  type: term()
}

Move the text cursor to the front of the input.

@spec move_window(window_id :: window_id(), x :: number(), y :: number()) ::
  %Toddy.Command{
    payload: term(),
    type: term()
  }

Move a window to the given position.

@spec none() :: %Toddy.Command{payload: term(), type: term()}

A no-op command. Returned implicitly when update/2 returns a bare model.

@spec pane_close(pane_grid_id :: widget_id(), pane_id :: term()) :: %Toddy.Command{
  payload: term(),
  type: term()
}

Close a pane in the pane grid.

@spec pane_maximize(pane_grid_id :: widget_id(), pane_id :: term()) :: %Toddy.Command{
  payload: term(),
  type: term()
}

Maximize a pane in the pane grid.

@spec pane_restore(pane_grid_id :: widget_id()) :: %Toddy.Command{
  payload: term(),
  type: term()
}

Restore all panes from maximized state.

@spec pane_split(
  pane_grid_id :: widget_id(),
  pane_id :: term(),
  axis :: atom() | String.t(),
  new_pane_id :: term()
) :: %Toddy.Command{payload: term(), type: term()}

Split a pane in the pane grid along the given axis.

@spec pane_swap(pane_grid_id :: widget_id(), pane_a :: term(), pane_b :: term()) ::
  %Toddy.Command{
    payload: term(),
    type: term()
  }

Swap two panes in the pane grid.

@spec raw_id(window_id :: window_id(), tag :: event_tag()) :: %Toddy.Command{
  payload: term(),
  type: term()
}

Query the raw platform window ID (e.g. X11 window ID, HWND). Result arrives as an effect response keyed by window ID.

@spec request_user_attention(window_id :: window_id(), urgency :: atom() | nil) ::
  %Toddy.Command{
    payload: term(),
    type: term()
  }

Request user attention for a window. Urgency can be :informational or :critical.

@spec resize_window(window_id :: window_id(), width :: number(), height :: number()) ::
  %Toddy.Command{
    payload: term(),
    type: term()
  }

Resize a window to the given dimensions.

@spec screenshot(window_id :: window_id(), tag :: event_tag()) :: %Toddy.Command{
  payload: term(),
  type: term()
}

Take a screenshot of a window. Result arrives as a tagged event.

@spec scroll_by(widget_id :: widget_id(), x :: float(), y :: float()) ::
  %Toddy.Command{
    payload: term(),
    type: term()
  }

Scroll the widget by a relative offset.

@spec scroll_to(widget_id :: widget_id(), offset :: term()) :: %Toddy.Command{
  payload: term(),
  type: term()
}

Scroll the widget identified by widget_id to offset.

@spec select_all(widget_id :: widget_id()) :: %Toddy.Command{
  payload: term(),
  type: term()
}

Select all text in the widget identified by widget_id.

@spec select_range(
  widget_id :: widget_id(),
  start_pos :: non_neg_integer(),
  end_pos :: non_neg_integer()
) :: %Toddy.Command{payload: term(), type: term()}

Select a range of text in the input.

@spec send_after(delay_ms :: non_neg_integer(), event :: term()) :: %Toddy.Command{
  payload: term(),
  type: term()
}

Send event through update/2 after delay_ms milliseconds.

@spec set_icon(
  window_id :: window_id(),
  rgba_data :: binary(),
  width :: pos_integer(),
  height :: pos_integer()
) :: %Toddy.Command{payload: term(), type: term()}

Sets the window icon from raw RGBA pixel data.

The rgba_data must be a binary of width * height * 4 bytes (one byte each for R, G, B, A per pixel, row-major). The raw binary is stored as-is in the command payload. The protocol layer handles format-specific encoding (native binary for msgpack via Msgpax.Bin, base64 for JSON).

Example

icon_data = File.read!("icon_32x32.rgba")
Toddy.Command.set_icon("main", icon_data, 32, 32)

@spec set_max_size(window_id :: window_id(), width :: number(), height :: number()) ::
  %Toddy.Command{
    payload: term(),
    type: term()
  }

Set the maximum size of a window.

@spec set_min_size(window_id :: window_id(), width :: number(), height :: number()) ::
  %Toddy.Command{
    payload: term(),
    type: term()
  }

Set the minimum size of a window.

@spec set_resizable(window_id :: window_id(), resizable :: boolean()) ::
  %Toddy.Command{
    payload: term(),
    type: term()
  }

Set whether a window is resizable.

@spec set_resize_increments(
  window_id :: window_id(),
  width :: number() | nil,
  height :: number() | nil
) :: %Toddy.Command{payload: term(), type: term()}

Sets the resize increment size for a window.

When set, the window will only resize in multiples of the given width and height. Pass nil for both to clear the constraint. Useful for terminal emulators and grid-aligned apps.

@spec set_window_level(window_id :: window_id(), level :: atom() | String.t()) ::
  %Toddy.Command{
    payload: term(),
    type: term()
  }

Set window stacking level (:normal, :always_on_top, :always_on_bottom).

On Wayland, window stacking is compositor-controlled and this command may be silently ignored.

@spec set_window_mode(window_id :: window_id(), mode :: atom() | String.t()) ::
  %Toddy.Command{
    payload: term(),
    type: term()
  }

Set window mode (windowed, fullscreen, etc.).

@spec show_system_menu(window_id :: window_id()) :: %Toddy.Command{
  payload: term(),
  type: term()
}

Show the system menu for a window.

@spec snap_to(widget_id :: widget_id(), x :: float(), y :: float()) :: %Toddy.Command{
  payload: term(),
  type: term()
}

Snap the scrollable widget to an absolute offset.

@spec snap_to_end(widget_id :: widget_id()) :: %Toddy.Command{
  payload: term(),
  type: term()
}

Snap the scrollable widget to the end of its content.

@spec stream(fun :: (fun() -> term()), event_tag :: atom()) :: %Toddy.Command{
  payload: term(),
  type: term()
}

Run fun as a streaming async task. The function receives an emit callback that sends intermediate results to update/2 as %Toddy.Event.Stream{tag: event_tag, value: value}. The function's final return value is delivered as %Toddy.Event.Async{tag: event_tag, result: result}.

This is sugar over spawning a process manually. You can achieve the same thing with bare Task and send/2 if you prefer direct Elixir patterns.

Example

Command.stream(fn emit ->
  for chunk <- File.stream!("big.csv") do
    emit.({:chunk, process(chunk)})
  end
  :done
end, :file_import)

@spec toggle_decorations(window_id :: window_id()) :: %Toddy.Command{
  payload: term(),
  type: term()
}

Toggle window decorations (title bar, borders).

@spec toggle_maximize(window_id :: window_id()) :: %Toddy.Command{
  payload: term(),
  type: term()
}

Toggle window maximized state.

@spec tree_hash(tag :: atom()) :: %Toddy.Command{payload: term(), type: term()}

Computes a SHA-256 hash of the renderer's current tree state.

The result arrives in update/2 as %System{type: :tree_hash, tag: tag, data: %{"hash" => "..."}}.

@spec update_image(handle :: String.t(), data :: binary()) :: %Toddy.Command{
  payload: term(),
  type: term()
}

Updates an existing in-memory image with new encoded PNG/JPEG bytes.

The raw binary is stored as-is in the command payload. The protocol layer handles format-specific encoding (native binary for msgpack, base64 for JSON).

@spec update_image(
  handle :: String.t(),
  width :: pos_integer(),
  height :: pos_integer(),
  pixels :: binary()
) :: %Toddy.Command{payload: term(), type: term()}

Updates an existing in-memory image with new raw RGBA pixel data.

The raw binary is stored as-is in the command payload. The protocol layer handles format-specific encoding (native binary for msgpack, base64 for JSON).