Enum Action 

pub enum Action {
    None,
    LeftClick,
    RightClick,
    MiddleClick,
    MouseBack,
    MouseForward,
    Copy,
    Paste,
    Cut,
    Undo,
    Redo,
    SelectAll,
    Find,
    Save,
    BrowserBack,
    BrowserForward,
    NewTab,
    CloseTab,
    ReopenTab,
    NextTab,
    PrevTab,
    ReloadPage,
    MissionControl,
    AppExpose,
    PreviousDesktop,
    NextDesktop,
    ShowDesktop,
    LaunchpadShow,
    LockScreen,
    Screenshot,
    CaptureRegion,
    PlayPause,
    NextTrack,
    PrevTrack,
    VolumeUp,
    VolumeDown,
    MuteVolume,
    CycleDpiPresets,
    SetDpiPreset(u8),
    ToggleSmartShift,
    ScrollUp,
    ScrollDown,
    HorizontalScrollLeft,
    HorizontalScrollRight,
    CustomShortcut(KeyCombo),
    Sleep,
    TypeText(String),
    RunAppleScript(String),
    RunShellCommand(String),
    Workflow(Vec<WorkflowStep>),
    ShowActionsRing,
    OpenApplication(ApplicationTarget),
    HoldShortcut(KeyCombo),
    TapKeyHoldingModifiers(KeyCombo),
}

What pressing a ButtonId should do.

Serialization uses serde’s default external tagging: unit variants serialize as a bare string ("BrowserBack") and the tuple variant serializes as a single-key table ({ CustomShortcut = "my chord" }).

Stability contract: existing variant names are frozen — they form the on-disk config.toml schema. New variants may be appended freely; removing or renaming a variant requires a schema_version bump and a migration.

This type is pure config data: OS-level event synthesis for each variant lives in the openlogi-inject crate (openlogi_inject::execute), keeping this crate platform- and IO-free.

Variants

None

Suppress the input entirely — the button or wheel direction is captured but no OS event is synthesised, so the physical input does nothing.

LeftClick

Primary mouse button.

RightClick

Secondary mouse button.

MiddleClick

Middle mouse button (wheel click).

MouseBack

Mouse “back” side button (extra button 4). Synthesizes the real mouse button event, which browsers and most apps interpret as “navigate back” natively — unlike Action::BrowserBack, which sends ⌘[ and is ignored by many apps.

MouseForward

Mouse “forward” side button (extra button 5). Native counterpart to Action::MouseBack; see Action::BrowserForward for the ⌘] form.

Copy

Copy the current selection (⌘C / Ctrl+C).

Paste

Paste from the clipboard (⌘V / Ctrl+V).

Cut

Cut the current selection (⌘X / Ctrl+X).

Undo

Undo the last action (⌘Z / Ctrl+Z).

Redo

Redo the last undone action (⌘⇧Z on macOS / Ctrl+Shift+Z on Linux).

Note: Ctrl+Y is the dominant redo shortcut in LibreOffice and many GTK apps. Ctrl+Shift+Z is used here because it mirrors the macOS convention and works in GNOME text fields, browsers, and Electron apps. If Ctrl+Y coverage is needed, a CustomShortcut binding is the escape hatch.

SelectAll

Select all content (⌘A / Ctrl+A).

Find

Open the find / search bar (⌘F / Ctrl+F).

Save

Save the current document (⌘S / Ctrl+S).

BrowserBack

Navigate backward in browser history.

BrowserForward

Navigate forward in browser history.

NewTab

Open a new tab (⌘T / Ctrl+T).

CloseTab

Close the current tab (⌘W / Ctrl+W).

ReopenTab

Reopen the last closed tab (⌘⇧T / Ctrl+Shift+T).

NextTab

Switch to the next tab (⌃⇥ / Ctrl+Tab).

PrevTab

Switch to the previous tab (⌃⇧⇥ / Ctrl+Shift+Tab).

ReloadPage

Reload the current page (⌘R / Ctrl+R).

MissionControl

macOS Mission Control (⌃↑).

AppExpose

macOS App Exposé — all windows for the current app (⌃↓).

PreviousDesktop

Switch to the previous desktop / Space.

NextDesktop

Switch to the next desktop / Space.

ShowDesktop

Show the desktop (hide all windows).

LaunchpadShow

Open Launchpad.

LockScreen

Lock the screen (⌘⌃Q on macOS).

On Linux, calls org.freedesktop.login1.Manager.LockSession($XDG_SESSION_ID) on the system bus (current session only). Falls back to Super+L when $XDG_SESSION_ID is unset or on non-systemd systems.

Screenshot

Capture a screenshot.

CaptureRegion

Capture a selected screen region to the clipboard.

macOS uses Cmd+Shift+Ctrl+4; Windows uses Win+Shift+S. Linux delegates to the desktop environment’s screenshot handler via Print Screen.

PlayPause

Toggle media play/pause.

NextTrack

Skip to the next track.

PrevTrack

Go back to the previous track.

VolumeUp

Increase system volume.

VolumeDown

Decrease system volume.

MuteVolume

Toggle system mute.

CycleDpiPresets

Step through the configured DPI preset list (P1.7).

SetDpiPreset(u8)

Jump to a specific zero-based preset in the device’s DPI preset list. Out-of-range indices clamp to the list length at fire time (P1.7).

ToggleSmartShift

Toggle the HID++ SmartShift ratchet/free-spin wheel mode (P1.1).

ScrollUp

Synthesise a vertical scroll-up tick.

ScrollDown

Synthesise a vertical scroll-down tick.

HorizontalScrollLeft

Synthesise a horizontal scroll-left tick.

HorizontalScrollRight

Synthesise a horizontal scroll-right tick.

CustomShortcut(KeyCombo)

Replay an arbitrary recorded key chord (P1.3).

Holds the structured chord data so openlogi_inject::execute can post the real keystroke (macOS: CGEventPost with the encoded modifier flags). The display field is used by Action::label so the popover shows the user-friendly chord name.

Sleep

Put the computer to sleep. Appended after CustomShortcut because the serde variant index is the wire format (see the stability contract above) — new variants only ever go at the end.

TypeText(String)

Type an arbitrary string by emitting unicode characters (macOS CGEventKeyboardSetUnicodeString). Used for macro text. Power-user escape hatch — excluded from the default catalog.

RunAppleScript(String)

Run an AppleScript via osascript -e <source>. Power-user escape hatch.

RunShellCommand(String)

Run a shell command via /bin/sh -c <command>. Power-user escape hatch.

Workflow(Vec<WorkflowStep>)

Run a timed, ordered sequence of steps — the native, no-code version of “type ‘bite me’, wait 5s, press Enter, wait 5s, type more, Escape”. Each step is one of the power-user actions or a Delay. The sequencer (openlogi-inject) runs them in order, awaiting Delays. Power-user escape hatch — excluded from the default catalog.

ShowActionsRing

Open the configured Actions Ring at the current pointer position. The agent handles the ring session rather than the OS injector.

OpenApplication(ApplicationTarget)

Open an application, folder, filesystem path, or platform URL.

HoldShortcut(KeyCombo)

Hold an arbitrary recorded key chord for the lifetime of its physical button press. This is the push-to-talk counterpart to Action::CustomShortcut, which emits an immediate down/up pair.

Lifecycle-aware runtimes emit the chord’s down edge when the press starts and its up edge for every terminal outcome, including capture cancellation and shutdown. Dispatchers without a release context must degrade this action to a balanced tap rather than leave keys held.

TapKeyHoldingModifiers(KeyCombo)

Hold the chord’s modifiers for the lifetime of the physical press while tapping its ordinary key exactly once, the way a hand does on a keyboard.

This is the shape an application switcher needs. Cmd+Tab steps one window forward and leaves the switcher on screen for as long as Cmd is down. Neither existing variant can express it: Action::CustomShortcut releases Cmd immediately, so the switcher closes again at once, and Action::HoldShortcut holds Tab down too, so key repeat walks the switcher to its last window and parks there.

Lifecycle-aware runtimes emit the modifier down edges plus one tap of the ordinary key when the press starts, and the modifier up edges for every terminal outcome. The tap is skipped while another held chord keeps that same key down, so the other hold is never released early. Dispatchers without a release context degrade this to a balanced tap of the whole chord, exactly as they do for Action::HoldShortcut.

Implementations

impl Action

pub fn label(&self) -> String

Display label for the popover row.

Returns String rather than &str so parameterized variants (e.g. SetDpiPreset(i), CustomShortcut(s)) can build a label that includes their payload.

pub fn translation_key(&self) -> Option<&'static str>

Stable catalog key for a payload-free action label.

Payload-carrying actions return None: their display text needs interpolation or contains user data and cannot be represented by a key alone.

pub fn translation_key_for_label(label: &str) -> Option<&'static str>

Resolve the stable key for a payload-free English action label.

The Actions Ring wire contract carries this English label for compatibility with older helpers. The overlay converts it at the localization boundary rather than changing the wire value.

pub fn category(&self) -> Category

Which Category this action belongs to, used for popover grouping.

pub fn catalog() -> Vec<Action>

All pickable actions in a deterministic order.

Action::CustomShortcut is intentionally excluded — it is opened via “Record shortcut…” (P1.3), not selected from the catalog. Table rows tagged not_pickable are excluded from the catalog the same way.

impl Action

pub fn held_chord(&self) -> Option<(&KeyCombo, HeldKeys)>

The chord whose output must remain down until the originating press ends, together with which of its keys stay down. None for an instantaneous action.

impl Action

pub fn effect(&self) -> Effect<'_>

Classify this action into the platform-neutral Effect IR that openlogi-inject’s backends dispatch on.

This is the single exhaustive match over the full Action vocabulary that a new backend needs — see the module docs.

Trait Implementations

impl AsRef<Action> for RingAction

fn as_ref(&self) -> &Action

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Action

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Action

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Action

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Action

impl From<Action> for Binding

fn from(action: Action) -> Self

Converts to this type from the input type.

impl From<RingAction> for Action

fn from(value: RingAction) -> Self

Converts to this type from the input type.

impl Hash for Action

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Action

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Action

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 Action

impl TryFrom<Action> for RingAction

type Error = RingActionError

The type returned in the event of a conversion error.

fn try_from(raw_value: Action) -> Result<RingAction, Self::Error>

Performs the conversion.