Enum Effect 

pub enum Effect<'a> {
    None,
    Click(MouseButton),
    Shortcut(Shortcut),
    Key(&'a KeyCombo),
    Scroll {
        dx: i8,
        dy: i8,
    },
    Media(MediaKey),
    Native(NativeAction),
    Script(Script<'a>),
    Text(&'a str),
    AgentSide,
}

What firing an Action should do, independent of platform.

openlogi_inject’s per-OS backends match on this instead of on Action directly.

Variants

None

Suppress the input entirely: no OS event at all.

Click(MouseButton)

Synthesise a physical mouse button click.

Shortcut(Shortcut)

Fire a named shortcut. Each backend maps this to its own platform chord (or, for the rare shortcut with no chord at all on some OS, a dedicated native code path) — see that backend’s combo table.

Key(&'a KeyCombo)

Press an already-resolved keyboard chord: a user-recorded Action::CustomShortcut, or a workflow’s PressKey step.

Scroll

Synthesise one scroll tick. dx/dy are unit direction (-1/0/1); each backend applies its own tick magnitude.

Fields

dx: i8

Horizontal direction: -1 left, 1 right, 0 none.

dy: i8

Vertical direction: -1 down, 1 up, 0 none.

Media(MediaKey)

Fire a media/volume key. Every backend reaches these through a dedicated OS mechanism rather than an ordinary keyboard chord.

Native(NativeAction)

A window-manager or power action with no shared cross-platform chord — each backend has its own dedicated handling, which may be a debug-logged no-op where the OS has no equivalent at all.

Script(Script<'a>)

A power-user scripting escape hatch.

Text(&'a str)

Type this text via unicode input.

AgentSide

Handled entirely by the agent/hook layer — DPI presets, SmartShift, the Actions Ring, and launching an application. The injector logs and does nothing.

Action::OpenApplication is included here even though openlogi_inject::execute does open it: that happens in the platform-independent dispatcher before a backend ever sees the action (the config target is opened via the opener crate, not through any per-OS synthesis path), so from a backend’s point of view it is exactly as much a no-op as the DPI actions.

Trait Implementations

impl<'a> Clone for Effect<'a>

fn clone(&self) -> Effect<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Copy for Effect<'a>

impl<'a> Debug for Effect<'a>

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

Formats the value using the given formatter.

impl<'a> Eq for Effect<'a>

impl<'a> PartialEq for Effect<'a>

fn eq(&self, other: &Effect<'a>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<'a> StructuralPartialEq for Effect<'a>