Linux Gnome Terminal（Cinnamon桌面）下C++程序实现全按键捕获及终端/桌面快捷键覆盖的技术问询

Alright, let's break down how to solve this problem—capturing standalone modifier keys (Alt/Shift/Ctrl) and overriding system/terminal shortcuts like F11 in a C++ app running in Gnome Terminal on Cinnamon. This isn't trivial because terminal emulators and desktop environments usually hoard key events before they reach your app, but we can use lower-level Linux APIs to get around that.

Normal terminal input methods (like getch() or read()) won't work here—they can't capture standalone modifier keys, and terminal shortcuts (like F11 for fullscreen) are intercepted before your app sees them. We have two main paths depending on whether your Cinnamon session uses X11 or Wayland:

1. X11 Session (Most Common for Cinnamon) #

X11 lets you directly grab key events either globally or for a specific window (like your terminal). This is the easiest way to override shortcuts and capture modifiers.

Step 1: Capture Keys with X11 API #

You'll need to link against the X11 library (-lX11 when compiling) and use functions like XGrabKey to intercept events before they reach the terminal or desktop.

Here's a working example that captures standalone modifiers and overrides F11:

#include <X11/Xlib.h>
#include <X11/keysym.h>
#include <iostream>
#include <cstdlib>
#include <unistd.h>

int main() {
    // Connect to the X display
    Display* display = XOpenDisplay(nullptr);
    if (!display) {
        std::cerr << "Failed to connect to X display" << std::endl;
        return 1;
    }

    // Option 1: Grab keys globally (affects entire system)
    // Window target_window = DefaultRootWindow(display);

    // Option 2: Grab keys ONLY for your terminal window (better for non-global overrides)
    char* terminal_window_id = getenv("WINDOWID");
    if (!terminal_window_id) {
        std::cerr << "Could not detect terminal window ID" << std::endl;
        XCloseDisplay(display);
        return 1;
    }
    Window target_window = strtoul(terminal_window_id, nullptr, 10);

    // Grab standalone modifier keys (adjust masks if your system uses different modifiers)
    XGrabKey(display, XKeysymToKeycode(display, XK_Alt_L), Mod1Mask, target_window, 
             True, GrabModeAsync, GrabModeAsync);
    XGrabKey(display, XKeysymToKeycode(display, XK_Shift_L), ShiftMask, target_window, 
             True, GrabModeAsync, GrabModeAsync);
    XGrabKey(display, XKeysymToKeycode(display, XK_Control_L), ControlMask, target_window, 
             True, GrabModeAsync, GrabModeAsync);
    
    // Override terminal's F11 fullscreen shortcut
    XGrabKey(display, XKeysymToKeycode(display, XK_F11), 0, target_window, 
             True, GrabModeAsync, GrabModeAsync);

    // Listen for key events
    XEvent ev;
    while (true) {
        XNextEvent(display, &ev);
        if (ev.type == KeyPress) {
            KeySym keysym = XLookupKeysym(&ev.xkey, 0);
            std::cout << "\nCaptured key: ";
            switch(keysym) {
                case XK_Alt_L: std::cout << "Left Alt (standalone)"; break;
                case XK_Shift_L: std::cout << "Left Shift (standalone)"; break;
                case XK_Control_L: std::cout << "Left Ctrl (standalone)"; break;
                case XK_F11: std::cout << "F11 (overrode terminal fullscreen!)"; break;
                default: std::cout << "Unknown key"; break;
            }
        }
    }

    // Cleanup (you'll want to add signal handlers to call this on exit)
    XUngrabKey(display, AnyKey, AnyModifier, target_window);
    XCloseDisplay(display);
    return 0;
}

Key Notes for X11: #

• Compile with: g++ your_app.cpp -o your_app -lX11
• Use Option 2 (terminal window grab) unless you truly need global key capture—it's less invasive.
• Modifier masks (like Mod1Mask) can vary by system. Use xmodmap in your terminal to check which mask maps to Alt/Shift/Ctrl on your setup.
• Always release grabs on exit (add signal handlers for SIGINT/SIGTERM to avoid leaving your system in a wonky state).

2. Wayland Session (Newer Cinnamon Installs) #

Wayland blocks direct global key grabs for security reasons, so we need a different approach. Two options here:

Option A: Use libinput (Requires Root) #

libinput lets you read raw input events directly from /dev/input devices. You'll need root access to access these devices.

Example snippet:

#include <libinput.h>
#include <unistd.h>
#include <iostream>
#include <fcntl.h>

static int open_restricted(const char *path, int flags, void *data) {
    int fd = open(path, flags);
    return fd < 0 ? -errno : fd;
}

static void close_restricted(int fd, void *data) {
    close(fd);
}

const struct libinput_interface interface = {
    .open_restricted = open_restricted,
    .close_restricted = close_restricted,
};

int main() {
    // Create libinput context
    struct libinput *li = libinput_path_create_context(&interface, nullptr);
    if (!li) {
        std::cerr << "Failed to initialize libinput" << std::endl;
        return 1;
    }

    // Add your keyboard device (find with `ls /dev/input/`—look for eventX labeled as keyboard)
    if (libinput_path_add_device(li, "/dev/input/event3") != 0) {
        std::cerr << "Failed to add keyboard device" << std::endl;
        libinput_unref(li);
        return 1;
    }

    // Listen for key events
    while (true) {
        libinput_dispatch(li);
        struct libinput_event *ev;
        while ((ev = libinput_get_event(li))) {
            if (libinput_event_get_type(ev) == LIBINPUT_EVENT_KEYBOARD_KEY) {
                auto kev = libinput_event_get_keyboard_event(ev);
                uint32_t key_code = libinput_event_keyboard_get_key(kev);
                auto state = libinput_event_keyboard_get_key_state(kev);

                if (state == LIBINPUT_KEY_STATE_PRESSED) {
                    std::cout << "\nCaptured key code: " << key_code;
                    switch(key_code) {
                        case 56: std::cout << " (Left Alt)"; break;
                        case 50: std::cout << " (Left Shift)"; break;
                        case 29: std::cout << " (Left Ctrl)"; break;
                        case 87: std::cout << " (F11—overrode shortcut!)"; break;
                    }
                }
            }
            libinput_event_destroy(ev);
        }
        usleep(10000);
    }

    libinput_unref(li);
    return 0;
}

• Compile with: g++ your_app.cpp -o your_app -llibinput
• Run with sudo ./your_app (required for device access)
• Key codes vary by keyboard—use evtest to map keys to their codes on your hardware.

Option B: Cinnamon Desktop API (Non-Root) #

If you don't want root access, you can use Cinnamon's GSettings to override terminal shortcuts (like F11) and register custom global shortcuts. This won't capture standalone modifiers directly, but it's a non-invasive way to override specific shortcuts.

Example command to disable terminal's F11 shortcut:

gsettings set org.gnome.Terminal.Legacy.Keybindings:/org/gnome/terminal/legacy/keybindings/ full-screen ''

You can call this from your C++ app using system() or popen() on startup, then restore it on exit.

Critical Considerations #

• Always clean up after your app: Release X11 grabs, restore terminal settings, or revert GChanges to avoid breaking the user's system.
• Test in your specific Cinnamon environment—modifier masks and key codes can vary between setups.
• For terminal-only capture, avoid global grabs to respect the user's system workflow.

内容的提问来源于stack exchange，提问作者TungstenX