Global shortcut hook on linux

Prelude

Global shortcut term means that you can set certain operation on some keyboard combination wherever you are in the system.

When you are a programmer on Windows and want to implement some feature on Linux it almost always makes you angry. Just because they are very different systems. In this article, I'll tell about how to implement global hotkeys on Linux. Maybe I'll save your time :)

Where to start

In Unix systems, there is no internal hook system for a keyboard. So you can't just register / unregister global hotkey. But on Linux, you can use XServer to implement the hook

In common we need two functions: XGrabKey and XUngrabKey. Our program has to monitor the state of a keyboard. And it will do it in a while-cycle so we have to create also thread for this operation.

Also, you might want to make the code more universal. In that case, we'll create an extended class of TThread with our needs.

Actual code

unit Hotkey;

{$mode objfpc}{$H+}

interface

uses
  Classes, SysUtils, xlib, x;

type

TCallback = procedure;

TModifier = (NoModifier, KeyShift, KeyControl, KeyAlt);

{ THotkeyThread }

THotkeyThread = class(TThread)
  private
    fDisplay: PDisplay;
    fRoot: TWindow;
    fEvent: TXEvent;
    fCallback: TCallback;
    fKeycode: TKeyCode;
    fModifier: word;
    procedure Grab;
    procedure Ungrab;
    procedure Callback;
  protected
    procedure Execute; override;
  public
    constructor Create(ACallback: TCallback; AKey: PChar; AModifier: TModifier;
      CreateSuspended: boolean);
    destructor Destroy; override;
  end;

implementation

{ THotkeyThread }

procedure THotkeyThread.Grab;
begin
  XGrabKey(fDisplay, fKeycode, AnyModifier, fRoot, 1, GrabModeAsync, GrabModeAsync);
end;

procedure THotkeyThread.Ungrab;
begin
  XUngrabKey(fDisplay, fKeycode, AnyModifier, fRoot);
end;

procedure THotkeyThread.Callback;
begin
  fCallback();
end;

procedure THotkeyThread.Execute;
begin
  while (not Terminated) do
    begin
    if XPending(fDisplay) > 0 then
    begin
      XNextEvent(fDisplay, @fEvent);

if (fEvent.xkey.state and (ShiftMask or ControlMask or Mod1Mask or Mod4Mask)) =
        fModifier then
        case fEvent._type of
          KeyPress:
          begin
            Ungrab;
            Synchronize(@Callback);
          end;
          KeyRelease:
          begin
            Grab;
          end
          else
          begin
            Ungrab;
            // Just resending event because it's not our keycode
            XSendEvent(fDisplay, fRoot, True, fEvent.xkey._type, @fEvent);
            Grab;
          end;
        end
      else
      begin
        Ungrab;
        // Just resending event because it's not our keycode
        XSendEvent(fDisplay, fRoot, True, fEvent.xkey._type, @fEvent);
        Grab;
      end;
    end else sleep(100);
    end;
end;

constructor THotkeyThread.Create(ACallback: TCallback; AKey: PChar;
  AModifier: TModifier; CreateSuspended: boolean);
begin
  inherited Create(CreateSuspended);

FreeOnTerminate := False;
  fDisplay := XOpenDisplay(nil);
  fCallback := ACallback;
  fKeycode := XKeysymToKeycode(fDisplay, XStringToKeysym(AKey));

case AModifier of
    NoModifier: fModifier := 0;
    KeyShift: fModifier := ShiftMask;
    KeyControl: fModifier := ControlMask;
    KeyAlt: fModifier := Mod1Mask;
  end;

if (fDisplay = nil) then
  begin
    raise Exception.Create('Cannot open display');
  end;

fRoot := DefaultRootWindow(fDisplay);
  Grab;
  XSelectInput(fDisplay, fRoot, KeyPressMask or KeyReleaseMask);
end;

destructor THotkeyThread.Destroy;
begin
  Ungrab;
  XCloseDisplay(fDisplay);
  inherited Destroy;
end;

end.

And now we can use our unit like this:

Thanks!