MouseKeyHook

To detect keyboard and mouse activity globally (even when your application is in the background), use Hook.GlobalEvents() to obtain an IKeyboardMouseEvents instance.

If you only want to capture events occurring within your own application, use Hook.AppEvents() instead.

Lifecycle Management:

• Subscribe: Attach event handlers to the IKeyboardMouseEvents instance.
• Unsubscribe: Detach event handlers and call .Dispose() on the hook instance to release resources.

private IKeyboardMouseEvents m_GlobalHook;

public void Subscribe()
{
    // Use Hook.AppEvents() for application-only hooks
    m_GlobalHook = Hook.GlobalEvents();

    m_GlobalHook.MouseDownExt += GlobalHookMouseDownExt;
    m_GlobalHook.KeyPress += GlobalHookKeyPress;
}

private void GlobalHookKeyPress(object sender, KeyPressEventArgs e)
{
    Console.WriteLine("KeyPress: \t{0}", e.KeyChar);
}

private void GlobalHookMouseDownExt(object sender, MouseEventExtArgs e)
{
    Console.WriteLine("MouseDown: \t{0}; \t System Timestamp: \t{1}", e.Button, e.Timestamp);
}

public void Unsubscribe()
{
    m_GlobalHook.MouseDownExt -= GlobalHookMouseDownExt;
    m_GlobalHook.KeyPress -= GlobalHookKeyPress;

    // It is recommended to dispose it
    m_GlobalHook.Dispose();
}

Once combinations are defined, you must map them to Action objects (methods with void return and no arguments, or trivial lambdas).

To start listening, use Hook.GlobalEvents().OnCombination(assignment). The assignment parameter accepts an IEnumerable<KeyValuePair<Combination, Action>>, meaning you can pass a Dictionary<Combination, Action> or a collection that allows multiple actions per combination.

Use Hook.GlobalEvents() to listen to all keyboard events from all applications, or Hook.AppEvents() to limit listening to events originating from your own application.

// 1. Define combinations
var undo = Combination.FromString("Control+Z");

// 2. Define actions
Action actionUndo = DoSomething;
void DoSomething() => Console.WriteLine("You pressed UNDO");

// 3. Assign and start
var assignment = new Dictionary<Combination, Action>
{
    {undo, actionUndo}
};

Hook.GlobalEvents().OnCombination(assignment);

To detect a series of key presses (e.g., Escape,Escape,Escape), use the Sequence class. A sequence is treated as a series of combinations, defined as a comma-separated list of combination strings.

Map sequences to actions using Hook.GlobalEvents().OnSequence(assignment).

Note on overlapping sequences: If you define overlapping sequences (e.g., A,B,C and B,C), the library follows the "longest sequence matches" rule. If the user types A,B,C, only the action for the longest sequence (A,B,C) will fire; the shorter sequence (B,C) will be ignored.

// 1. Define sequences
var exitVim = Sequence.FromString("Shift+Z,Z");
var rename = Sequence.FromString("Control+R,R");
var exitReally = Sequence.FromString("Escape,Escape,Escape");

// 2. Define actions and assignment
var assignment = new Dictionary<Sequence, Action>
{
    {exitVim, () => Console.WriteLine("No!")},
    {rename, () => Console.WriteLine("rename2")},
    {exitReally, () => Console.WriteLine("Ok.")},
};

// 3. Start listening
Hook.GlobalEvents().OnSequence(assignment);

A HotKeySet defines a specific combination of keys that trigger events. You can use RegisterExclusiveOrKey to specify that certain keys in the set should be treated as an 'OR' condition (e.g., LShiftKey OR RShiftKey) rather than an 'AND' condition.

Rules for XOR keys:

1. The xorKeys array must be a subset of the primary keys provided to the HotKeySet constructor.
2. If RegisterExclusiveOrKey returns Keys.None, the registration failed (likely because the subset was not contained within the original set).

Events available on HotKeySet:

• OnHotKeysDownOnce: Fired the first time the key combination is pressed.
• OnHotKeysDownHold: Fired repeatedly as long as the keys are held down (but not on the initial press).
• OnHotKeysUp: Fired when any key from the set is released.

// Define keys: T and (LShift OR RShift)
HotKeySet hks = new HotKeySet(new[] { Keys.T, Keys.LShiftKey, Keys.RShiftKey });

// Register LShiftKey and RShiftKey as an OR subset
if (hks.RegisterExclusiveOrKey(new[] { Keys.LShiftKey, Keys.RShiftKey }) != Keys.None)
{
    // Success
}

// Subscribe to events
hks.OnHotKeysDownOnce += MyDownOnceHandler;
hks.OnHotKeysDownHold += MyDownHoldHandler;
hks.OnHotKeysUp += MyKeyUpHandler;