Enum EditCommand 

pub enum EditCommand {
    Copy,
    Cut,
    Paste(String),
    SelectAll,
}

The clipboard/selection command vocabulary, flat-re-exported from frust-core::event (and also available through authoring::EditCommand).

InputEvent::EditCommand delivers one of EditCommand::Copy, EditCommand::Cut, EditCommand::Paste or EditCommand::SelectAll down the focus chain, already decoded by the shell from the platform’s own gesture — Cmd+C on macOS, Ctrl+C or Ctrl+Insert elsewhere, a hardware clipboard key, an Android ACTION_PROCESS_TEXT, an iOS edit-menu tap — so app and design-system code never decodes a chord itself.

Lifted flat rather than left inside authoring for CursorIcon’s reason: a design system’s own context menu or toolbar builder names these verbs in its public API without being a widget author. Paste carries its text because the shell has already read the host clipboard; its Debug redacts that text, since a paste payload can be a password or a token. A semantic clipboard / selection command delivered to the focused editable.

The decoded form of a platform gesture, not the gesture itself: a shell resolves Cmd+C / Ctrl+C / NamedKey::Copy / Ctrl+Insert / an Android ACTION_PROCESS_TEXT / an iOS edit-menu tap into one of these variants and dispatches it as InputEvent::EditCommand, so no widget has to know which chord means copy on which OS. Every widget sees the same four verbs.

Why paste carries its text and copy does not

The clipboard itself lives in the shell (only the shell has a host clipboard to talk to), and the two directions are deliberately asymmetric:

• Copy / Cut carry nothing — the widget owns the selection, so it answers by writing its own text into the pass’s clipboard slot (EventCtx::write_clipboard), which the shell drains and hands to the host.
• Paste carries the text — the shell owns the host clipboard, so by the time the command reaches the tree the read has already happened. A widget that wants a paste it did not receive asks for one (EventCtx::request_paste) and the shell answers with this variant.

Refusal is the widget’s call

Nothing here is a permission: a read-only or secret field is free to ignore a Copy/Cut it does not want to honour, and a widget with no selection simply reports EventResult::Ignored. The vocabulary states what was asked for.

Exhaustive on purpose (no #[non_exhaustive]): these four verbs are the whole clipboard contract, and a widget matching on them should be told by the compiler if that ever stops being true.

Variants

Copy

Copy the current selection to the host clipboard, leaving the document unchanged. A widget answers by calling EventCtx::write_clipboard.

Cut

Copy the current selection and delete it. A widget answers by calling EventCtx::write_clipboard and mutating its own text — the shell sees one clipboard write either way (see that method’s last-writer rule).

Paste(String)

Replace the current selection with this text (insert it at the caret when there is no selection). Already read from the host clipboard by the shell.

SelectAll

Select the widget’s entire content — the selection half of this vocabulary, carried here because it arrives through the same platform chords and edit menus as the other three.

Trait Implementations

impl Clone for EditCommand

fn clone(&self) -> EditCommand

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EditCommand

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

Hand-written so pasted text never reaches a log.

ImeState’s reason, one step earlier in the pipeline (see its Debug): a paste payload is arbitrary host-clipboard content — a password manager’s fill, a copied token, a recovery phrase — and unlike an IME surface there is no content-type hint to key the decision off, because the clipboard has no owner to state one. So the payload is unconditionally replaced by <redacted> (no length, which would itself leak), and the variant name still prints so a trace stays readable.

impl Eq for EditCommand

impl PartialEq for EditCommand

fn eq(&self, other: &EditCommand) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for EditCommand