Struct druid::Command

pub struct Command { /* private fields */ }

An arbitrary command.

A Command consists of a Selector, that indicates what the command is and what type of payload it carries, as well as the actual payload.

If the payload can’t or shouldn’t be cloned, wrapping it with SingleUse allows you to take the payload. The SingleUse docs give an example on how to do this.

Generic payloads can be achieved with Selector<Box<dyn Any>>. In this case it could make sense to use utility functions to construct such commands in order to maintain as much static typing as possible. The EventCtx::new_window method is an example of this.

Examples

use druid::{Command, Selector, Target};

let selector = Selector::new("process_rows");
let rows = vec![1, 3, 10, 12];
let command = selector.with(rows);

assert_eq!(command.get(selector), Some(&vec![1, 3, 10, 12]));

Implementations

impl Command

pub fn new<T: Any>( selector: Selector<T>, payload: T, target: impl Into<Target> ) -> Self

Create a new Command with a payload and a Target.

Selector::with should be used to create Commands more conveniently.

If you do not need a payload, Selector implements Into<Command>.

pub fn to(self, target: impl Into<Target>) -> Self

Set the Command’s Target.

Command::target can be used to get the current Target.

pub fn target(&self) -> Target

Returns the Command’s Target.

Command::to can be used to change the Target.

pub fn is<T>(&self, selector: Selector<T>) -> bool

Returns true if self matches this selector.

Examples found in repository

examples/identity.rs (line 111)

    fn event(
        &mut self,
        child: &mut Label<u64>,
        ctx: &mut EventCtx,
        event: &Event,
        data: &mut u64,
        env: &Env,
    ) {
        match event {
            Event::Command(cmd) if cmd.is(INCREMENT) => *data += 1,
            _ => child.event(ctx, event, data, env),
        }
    }

examples/multiwin.rs (line 159)

    fn command(
        &mut self,
        ctx: &mut DelegateCtx,
        _target: Target,
        cmd: &Command,
        data: &mut State,
        _env: &Env,
    ) -> Handled {
        if cmd.is(sys_cmds::NEW_FILE) {
            let new_win = WindowDesc::new(ui_builder())
                .menu(make_menu)
                .window_size((data.selected as f64 * 100.0 + 300.0, 500.0));
            ctx.new_window(new_win);
            Handled::Yes
        } else {
            Handled::No
        }
    }

pub fn get<T: Any>(&self, selector: Selector<T>) -> Option<&T>

Returns Some(&T) (this Command’s payload) if the selector matches.

Returns None when self.is(selector) == false.

Alternatively you can check the selector with is and then use get_unchecked.

Panics

Panics when the payload has a different type, than what the selector is supposed to carry. This can happen when two selectors with different types but the same key are used.

Examples found in repository

examples/blocking_function.rs (line 94)

    fn command(
        &mut self,
        _ctx: &mut DelegateCtx,
        _target: Target,
        cmd: &Command,
        data: &mut AppState,
        _env: &Env,
    ) -> Handled {
        if let Some(number) = cmd.get(FINISH_SLOW_FUNCTION) {
            // If the command we received is `FINISH_SLOW_FUNCTION` handle the payload.
            data.processing = false;
            data.value = *number;
            Handled::Yes
        } else {
            Handled::No
        }
    }

examples/markdown_preview.rs (line 83)

    fn command(
        &mut self,
        _ctx: &mut DelegateCtx,
        _target: Target,
        cmd: &Command,
        _data: &mut T,
        _env: &Env,
    ) -> Handled {
        if let Some(url) = cmd.get(OPEN_LINK) {
            #[cfg(not(target_arch = "wasm32"))]
            open::that_in_background(url);
            #[cfg(target_arch = "wasm32")]
            tracing::warn!("opening link({}) not supported on web yet.", url);
            Handled::Yes
        } else {
            Handled::No
        }
    }

examples/open_save.rs (line 85)

    fn command(
        &mut self,
        _ctx: &mut DelegateCtx,
        _target: Target,
        cmd: &Command,
        data: &mut String,
        _env: &Env,
    ) -> Handled {
        if let Some(file_info) = cmd.get(commands::SAVE_FILE_AS) {
            if let Err(e) = std::fs::write(file_info.path(), &data[..]) {
                println!("Error writing file: {e}");
            }
            return Handled::Yes;
        }
        if let Some(file_info) = cmd.get(commands::OPEN_FILE) {
            match std::fs::read_to_string(file_info.path()) {
                Ok(s) => {
                    let first_line = s.lines().next().unwrap_or("");
                    *data = first_line.to_owned();
                }
                Err(e) => {
                    println!("Error opening file: {e}");
                }
            }
            return Handled::Yes;
        }
        Handled::No
    }

pub fn get_unchecked<T: Any>(&self, selector: Selector<T>) -> &T

Returns a reference to this Command’s payload.

If the selector has already been checked with is, then get_unchecked can be used safely. Otherwise you should use get instead.

Panics

Panics when self.is(selector) == false.

Panics when the payload has a different type, than what the selector is supposed to carry. This can happen when two selectors with different types but the same key are used.

Trait Implementations

impl Clone for Command

fn clone(&self) -> Command

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Command

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

Formats the value using the given formatter.

impl From<Selector<()>> for Command

fn from(selector: Selector) -> Command

Converts to this type from the input type.