Enum Action

pub enum Action<T> {
    Output(T),
    LoadFont {
        bytes: Cow<'static, [u8]>,
        channel: Sender<Result<(), Error>>,
    },
    Widget(Box<dyn Operation>),
    Clipboard(Action),
    Window(Action),
    System(Action),
    Image(Action),
    Reload,
    Exit,
    Dnd(DndAction),
    PlatformSpecific(Action),
}

An action that the iced runtime can perform.

Variants

Output(T)

Output some value.

LoadFont

Load a font from its bytes.

Fields

bytes: Cow<'static, [u8]>

The bytes of the font to load.

channel: Sender<Result<(), Error>>

The channel to send back the load result.

Widget(Box<dyn Operation>)

Run a widget operation.

Clipboard(Action)

Run a clipboard action.

Window(Action)

Run a window action.

System(Action)

Run a system action.

Image(Action)

An image action.

Reload

Recreate all user interfaces and redraw all windows.

Exit

Exits the runtime.

This will normally close any application windows and terminate the runtime loop.

Dnd(DndAction)

Run a Dnd action.

PlatformSpecific(Action)

Run a platform specific action

Implementations

impl<T> Action<T>

pub fn widget(operation: impl Operation + 'static) -> Action<T>

Creates a new Action::Widget with the given widget::Operation.

Trait Implementations

impl<T> Debug for Action<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Sink<Action<T>> for Proxy<T>

where T: 'static,

type Error = SendError

The type of value produced by the sink when an error occurs.

fn poll_ready( self: Pin<&mut Proxy<T>>, cx: &mut Context<'_>, ) -> Poll<Result<(), <Proxy<T> as Sink<Action<T>>>::Error>>

Attempts to prepare the Sink to receive a value.

fn start_send( self: Pin<&mut Proxy<T>>, action: Action<T>, ) -> Result<(), <Proxy<T> as Sink<Action<T>>>::Error>

Begin the process of sending a value to the sink. Each call to this function must be preceded by a successful call to poll_ready which returned Poll::Ready(Ok(())).

fn poll_flush( self: Pin<&mut Proxy<T>>, cx: &mut Context<'_>, ) -> Poll<Result<(), <Proxy<T> as Sink<Action<T>>>::Error>>

Flush any remaining output from this sink.

fn poll_close( self: Pin<&mut Proxy<T>>, _cx: &mut Context<'_>, ) -> Poll<Result<(), <Proxy<T> as Sink<Action<T>>>::Error>>

Flush any remaining output and close this sink, if necessary.