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),
    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.

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.