OpenLogi Actions Catalog: Complete Guide to All 34+ Configurable Button Actions

OpenLogi exposes 34 default pickable actions—from mouse clicks and media controls to system commands—defined in the Action enum within crates/openlogi-core/src/binding/action.rs, with additional power-user variants available for custom shortcuts and automation workflows.

OpenLogi is an open-source input customization framework written in Rust that remaps mouse buttons, wheels, and gestures. The OpenLogi actions catalog acts as the source of truth for every bindable operation, storing both payload-free UI pickable actions and advanced programmable variants requiring parameters.

The Core Action Enum

All configurable actions originate from the Action enum located in openlogi-core/src/binding/action.rs. This file implements the stability contract for on-disk configuration, ensuring that the deterministic ordering of action variants keeps TOML config files consistent across versions.

Catalog Generation via Macro

The default UI catalog is auto-generated by the for_each_unit_action! macro inside the same file. This macro iterates over payload-free actions (those requiring no extra data), attaching metadata including human-readable labels, i18n translation keys, logical categories from category.rs, and icon names used by the Actions Ring pop-over UI.

Default Action Categories

The catalog generation produces 34 pickable variants grouped into eight logical categories. These appear in the UI picker and can be bound directly in configuration files.

Mouse Actions

Standard pointer operations for button remapping:

• LeftClick, RightClick, MiddleClick
• MouseBack, MouseForward

Editing Commands

Clipboard and text manipulation utilities:

• Copy, Paste, Cut
• Undo, Redo
• SelectAll, Find, Save

Browser and Tab Management

Web navigation and tab lifecycle controls:

• BrowserBack, BrowserForward
• NewTab, CloseTab, ReopenTab
• NextTab, PrevTab, ReloadPage

Window and Desktop Navigation

macOS-style space and window management:

• MissionControl, AppExpose
• PreviousDesktop, NextDesktop
• ShowDesktop, LaunchpadShow

System Controls

Power and utility commands:

• LockScreen, Screenshot, CaptureRegion
• Sleep, ShowActionsRing
• None (no-op)

Media Controls

Audio playback and volume management:

• PlayPause, NextTrack, PrevTrack
• VolumeUp, VolumeDown, MuteVolume

DPI Hardware Controls

Mouse-specific hardware adjustments:

• CycleDpiPresets
• ToggleSmartShift

Scroll Directions

Explicit scroll wheel bindings:

• ScrollUp, ScrollDown
• HorizontalScrollLeft, HorizontalScrollRight

Power-User and Payload Actions

Beyond the 34 pickable variants, the Action enum includes advanced actions requiring parameters. These are marked not_pickable in the macro or carry data payloads, making them accessible only through the "Record shortcut…" or "Run command…" advanced UIs, or programmatically via the Rust API.

Custom Input and Automation

Inject arbitrary input or literal text:

• CustomShortcut(KeyCombo) – Dispatches an arbitrary key chord
• HoldShortcut(KeyCombo) – Presses and holds modifier keys
• TypeText(String) – Inputs literal UTF-8 text

System Integration

Execute external scripts and applications:

• RunAppleScript(String) – Executes AppleScript code
• RunShellCommand(String) – Spawns shell processes
• OpenApplication(ApplicationTarget) – Launches specific app bundles

Workflow Sequencing

Complex stateful operations:

• SetDpiPreset(u8) – Switches to a specific DPI profile index
• Workflow(Vec<WorkflowStep>)) – Chains multiple atomic actions into a single button press

Working with the Catalog Programmatically

The Action::catalog() method returns a Vec<Action> containing all pickable variants in their canonical order.

Listing Available Actions

use openlogi_core::binding::Action;

fn main() {
    let catalog = Action::catalog();
    
    for action in catalog {
        println!(
            "{} – {} ({:?})",
            action.label(),
            action.translation_key().unwrap_or("custom"),
            action.category()
        );
    }
}

Filtering by Category

use openlogi_core::binding::{Action, Category};

fn get_media_actions() -> Vec<Action> {
    Action::catalog()
        .into_iter()
        .filter(|a| a.category() == Category::Media)
        .collect()
}

Configuration Examples

TOML Configuration File

Bind actions to logical buttons in ~/.config/openlogi/config.toml. The action string matches the variant's translation key as mapped by Action::translation_key_for_label:

[[bindings]]
button = "Button1"
action = "Copy"

[[bindings]]
button = "Button2"
action = "MissionControl"

[[bindings]]
button = "ScrollRight"
action = "NextTab"

Advanced Power-User Setup

For actions not in the default catalog, instantiate them directly in Rust:

use openlogi_core::binding::{Action, KeyCombo};

// Create a custom shortcut action
let custom = Action::CustomShortcut(
    KeyCombo::from_string("Ctrl+Shift+X")
);

// Execute via the injection interface
openlogi_inject::execute(&custom);

Summary

• The OpenLogi actions catalog contains 34 default payload-free actions available in the UI picker, covering Mouse, Editing, Browser, System, Media, and Scroll categories.
• Actions are defined in the Action enum in openlogi-core/src/binding/action.rs and surfaced via the for_each_unit_action! macro.
• Advanced variants like CustomShortcut, RunShellCommand, and Workflow support complex automation but require parameter payloads.
• The catalog maintains a stability contract ensuring that action indices remain consistent for TOML configuration files across software updates.

Frequently Asked Questions

Why are some actions missing from the UI picker?

Actions requiring additional data (payloads) such as TypeText(String) or RunAppleScript(String) are excluded from the picker because they need user-supplied parameters. The for_each_unit_action! macro marks these as not_pickable, making them accessible only through the advanced "Record shortcut…" dialog or programmatic APIs.

How do I bind a custom keyboard shortcut in OpenLogi?

Use the CustomShortcut variant with a KeyCombo payload. In the TOML configuration, this typically requires using the advanced configuration interface to record the chord, or programmatically defining the action in Rust using Action::CustomShortcut(KeyCombo::from_string("Cmd+Shift+T")).

Where is the action catalog defined in the source code?

The canonical definition resides in crates/openlogi-core/src/binding/action.rs. This file contains the Action enum, the Action::catalog() method, and the for_each_unit_action! macro that generates the deterministic listing of pickable actions.

How does OpenLogi maintain configuration file stability?

According to the source comments in action.rs, the catalog adheres to a stability contract where the Action::catalog() method returns variants in a deterministic order derived from the macro iteration. This ensures that TOML configuration files using action labels remain valid across updates, as the internal indexing remains consistent.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}