Struct CommandSet 

pub struct CommandSet {
    available: Vec<Command>,
    writability: Writability,
    viewing: Viewing,
    history: History,
}

The frame’s available commands, in the canonical presentation order the selection overlay renders them in.

Fields

available: Vec<Command>

writability: Writability

Applied by Self::push, so the withholding happens once instead of at each of the thirty-odd sites that offer a command.

viewing: Viewing

history: History

Which kind of entry undo and redo stand over, since that is what says whether they write.

Implementations

impl CommandSet

pub fn available(ctx: &CommandContext<'_, '_>) -> Self

fn nudges(&mut self, headings: &[Heading])

The arrow keys’ moves, which draw no control of their own.

fn selection_commands(&mut self, sel: &Deletable, data: &Drawing<'_>)

fn editor_commands(&mut self, sel: &Deletable, data: &Drawing<'_>)

The in-place label editors the selection can open — the same tools the double-click path arms. Palette-only: none has an overlay button.

fn offer_editor( &mut self, data: &Drawing<'_>, id: CommandId, label: &'static str, target: EditTarget, )

Offered where the editor would open now. The command names the field, not the editor, so dispatch builds the editor again against the drawing as it then stands.

fn block_commands(&mut self, rid: BlockId, data: &Drawing<'_>)

fn push(&mut self, id: CommandId, label: &'static str, act: impl Into<Act>)

fn push_by_name_only( &mut self, id: CommandId, label: &'static str, act: impl Into<Act>, )

Available to name — a chord, the palette’s text field, a script’s command step — but not rendered as a control. The accent and I/O values are the case this exists for: nine colours and three directions are a picker’s job on screen, and nine more buttons would bury the selection bar, but each still has to be sayable or a script could not set one.

fn offer( &mut self, id: CommandId, label: &'static str, act: Act, rendered: Rendered, )

The one gate every command passes through. A read-only session marks the writing half of the registry withheld here — not at the call sites — and every door that invokes (a chord, the palette, a script’s command step, a click) skips a withheld command, so keeping it around for the overlay to draw disabled cannot make it reachable.

fn allows(&self, id: CommandId) -> bool

Whether id survives the frame’s two read-only questions. They are two questions — a container this session may not write, and a past rev on the canvas — with one answer: nothing writes the document through the lens. The way out of it is Return or a Save-as, and a Save-as writes a file, never this log. Undo and redo go with the rest when they author — they would act on the head nobody is looking at — and stay when they do not.

fn writes(&self, id: CommandId) -> bool

Whether id would write this frame. Undo and redo answer with the kind of entry they stand over: taking back a camera move restores a camera and touches no log, so it survives both the lens and a container this session may not write. Every other command answers from its own identity.

pub fn iter(&self) -> impl Iterator<Item = &Command>

The invocable commands to render. Everything else is reachable by name through Self::take.

pub fn iter_drawn(&self) -> impl Iterator<Item = &Command>

Every command that draws a control, the withheld ones included — the selection overlay’s view, which renders those disabled rather than leaving a hole where a control was.

pub fn iter_all(&self) -> impl Iterator<Item = &Command>

Every command this frame offers, drawn or not — what a front end that carries the whole registry across a seam reads, so a chord bound to a by-name-only command still resolves there.

pub fn contains(&self, id: CommandId) -> bool

pub fn get(&self, id: CommandId) -> Option<&Command>

pub fn take(&mut self, id: CommandId) -> Option<Act>

Consume what id does, to perform it. At most one command fires per frame, so taking moves it out rather than cloning it. A withheld command cannot be taken, however it was named.

Trait Implementations

impl<'de> Deserialize<'de> for CommandSet

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for CommandSet

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for CommandSet

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for CommandSet