Is there a way to grab the keyboard?

[bryonbaker]

I cannot find any doco or feature that lets Rabbit Remote Control grab the keyboard of the local machine so you can use special jeys such as the Super key in linux. Is there a way?

[KangLin]

Currently, special keys like Super cannot be captured on Linux. On Windows, they can be captured. However, some system shortcuts will still be triggered. This is all because the system processes these keys and does not pass them up to the application layer.

[bryonbaker]

It is possible. Remmina can do it. The question is “how do they do it? :) “

[KangLin]

It uses GTK, captured from system messages. The specific implementation can be studied later when there's time. You can directly ask its developer. Let me know the results.

[KangLin]

@antenore Please tell me how to implement it.

[KangLin]

@bryonbaker Solution: Disable desktop shortcuts. see: 14cc8a6

[KangLin]

Disabling the relevant desktop shortcuts through the system settings allows the application to capture all keys. However, restoring the desktop shortcuts requires a restart. Therefore, this method is not perfect.

[KangLin]

• libxcb: Cannot capture desktop shortcut keys

• Wayland implements disabling desktop shortcut keys:
  https://wayland.app/protocols/keyboard-shortcuts-inhibit-unstable-v1

• libX11:
  XCB_LEAVE_NOTIFY is triggered when reaching the window border and moving out of the window, and XCB_ENTER_NOTIFY is triggered when leaving the title bar and entering the window. Therefore, you can call XGrabKeyboard when entering, and XUnGrabKeyboard when leaving.

  • https://stackoverflow.com/questions/14555703/x11-unable-to-move-window-after-xgrabkeyboard
  • https://stackoverflow.com/questions/23430995/redirect-keyboard-input-with-xgrabkey-or-xgrabkeyboard

• evdev: can capture all keys, but it need root privilege

[KangLin]

libxcb and evdev

• main.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>
#include <errno.h>

/* XCB相关头文件 */
#include <xcb/xcb.h>
#include <xcb/xcb_keysyms.h>
#include <xcb/xproto.h>

/* Linux输入子系统头文件 */
#include <linux/input.h>
#include <fcntl.h>
#include <sys/ioctl.h>

#define MAX_DEVICES 10

volatile sig_atomic_t running = 1;

void signal_handler(int sig) {
    running = 0;
    printf("\n收到信号 %d，正在退出...\n", sig);
}

/* ========== XCB 键盘事件处理 ========== */

typedef struct {
    xcb_connection_t *conn;
    xcb_screen_t *screen;
    xcb_window_t window;
    xcb_key_symbols_t *keysyms;
} xcb_context_t;

void print_modifier_state(uint16_t state) {
    printf("修饰键状态: ");
    if (state & XCB_MOD_MASK_SHIFT) printf("Shift ");
    if (state & XCB_MOD_MASK_LOCK) printf("CapsLock ");
    if (state & XCB_MOD_MASK_CONTROL) printf("Ctrl ");
    if (state & XCB_MOD_MASK_1) printf("Alt ");
    if (state & XCB_MOD_MASK_2) printf("NumLock ");
    if (state & XCB_MOD_MASK_3) printf("ScrollLock ");
    if (state & XCB_MOD_MASK_4) printf("Super ");
    if (state & XCB_MOD_MASK_5) printf("Hyper ");
    printf("\n");
}

int is_super_keysym(xcb_keysym_t keysym) {
    return (keysym == 0xFFEB || keysym == 0xFFEC ||  /* Super_L, Super_R */
            keysym == 0xFFED || keysym == 0xFFEE);   /* Hyper_L, Hyper_R */
}

void handle_xcb_key_event(xcb_generic_event_t *event, xcb_context_t *ctx) {
    uint8_t response_type = event->response_type & ~0x80;
    
    if (response_type == XCB_KEY_PRESS || response_type == XCB_KEY_RELEASE) {
        xcb_key_press_event_t *key_event = (xcb_key_press_event_t *)event;
        const char *event_type = (response_type == XCB_KEY_PRESS) ? "按下" : "释放";
        
        /* 获取键符号 */
        xcb_keysym_t sym = xcb_key_symbols_get_keysym(ctx->keysyms, key_event->detail, 0);
        
        printf("键盘事件 - 窗口: 0x%08x, 键码: %3d, 事件: %s", 
               key_event->event, key_event->detail, event_type);
        
        if (sym != XCB_NO_SYMBOL) {
            printf(", 键符号: 0x%04X", sym);
            
            if (is_super_keysym(sym)) {
                printf(" [SUPER键]");
            }
            
            /* 打印可打印字符 */
            if (sym >= 0x20 && sym <= 0x7E) {
                printf(", 字符: '%c'", (char)sym);
            }
        }
        
        printf("\n");
        
        /* 打印修饰键状态 */
        print_modifier_state(key_event->state);
        
        /* 特别检测Super键组合 */
        if (key_event->state & XCB_MOD_MASK_4) {
            printf(">>> Super键被按下 <<<\n");
        }
    }
}

int grab_keyboard(xcb_context_t *ctx) {
    /* 抓取键盘以确保接收所有事件 */
    xcb_grab_keyboard_cookie_t grab_cookie;
    xcb_grab_keyboard_reply_t *grab_reply;
    
    grab_cookie = xcb_grab_keyboard(ctx->conn, 1, ctx->window, XCB_CURRENT_TIME, 
                                   XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC);
    grab_reply = xcb_grab_keyboard_reply(ctx->conn, grab_cookie, NULL);
    
    if (!grab_reply) {
        fprintf(stderr, "键盘抓取失败\n");
        return -1;
    }
    
    if (grab_reply->status != XCB_GRAB_STATUS_SUCCESS) {
        fprintf(stderr, "键盘抓取被拒绝，状态: %d\n", grab_reply->status);
        free(grab_reply);
        return -1;
    }
    
    printf("键盘抓取成功\n");
    free(grab_reply);
    return 0;
}

int init_xcb_context(xcb_context_t *ctx) {
    /* 连接X服务器 */
    ctx->conn = xcb_connect(NULL, NULL);
    if (xcb_connection_has_error(ctx->conn)) {
        fprintf(stderr, "错误: 无法连接到X服务器\n");
        return -1;
    }
    
    /* 获取屏幕 */
    const xcb_setup_t *setup = xcb_get_setup(ctx->conn);
    xcb_screen_iterator_t screen_iter = xcb_setup_roots_iterator(setup);
    ctx->screen = screen_iter.data;
    
    if (!ctx->screen) {
        fprintf(stderr, "错误: 无法获取屏幕\n");
        xcb_disconnect(ctx->conn);
        return -1;
    }
    
    /* 创建透明窗口 */
    ctx->window = xcb_generate_id(ctx->conn);
    
    uint32_t mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;
    uint32_t values[2];
    values[0] = ctx->screen->white_pixel;
    values[1] = XCB_EVENT_MASK_KEY_PRESS | XCB_EVENT_MASK_KEY_RELEASE |
                XCB_EVENT_MASK_FOCUS_CHANGE;
    
    xcb_create_window(ctx->conn,
                     XCB_COPY_FROM_PARENT,
                     ctx->window,
                     ctx->screen->root,
                     0, 0, 1, 1,  // 最小化窗口
                     0,
                     XCB_WINDOW_CLASS_INPUT_OUTPUT,
                     ctx->screen->root_visual,
                     mask, values);
    
    /* 设置窗口名称 */
    const char *title = "Keyboard Listener";
    xcb_change_property(ctx->conn, XCB_PROP_MODE_REPLACE, ctx->window,
                       XCB_ATOM_WM_NAME, XCB_ATOM_STRING, 8,
                       strlen(title), title);
    
    /* 映射窗口 */
    xcb_map_window(ctx->conn, ctx->window);
    xcb_flush(ctx->conn);
    
    /* 初始化keysyms */
    ctx->keysyms = xcb_key_symbols_alloc(ctx->conn);
    if (!ctx->keysyms) {
        fprintf(stderr, "无法分配keysyms\n");
        return -1;
    }
    
    printf("XCB上下文初始化成功\n");
    printf("屏幕: %dx%d\n", ctx->screen->width_in_pixels, ctx->screen->height_in_pixels);
    
    return 0;
}

void xcb_keyboard_listener() {
    xcb_context_t ctx;
    
    printf("=== XCB 键盘事件监听 ===\n");
    
    if (init_xcb_context(&ctx) != 0) {
        return;
    }
    
    /* 尝试抓取键盘 */
    if (grab_keyboard(&ctx) != 0) {
        printf("注意: 键盘抓取失败，可能无法捕获所有事件\n");
    }
    
    printf("开始监听键盘事件...\n");
    printf("按 Ctrl+C 退出\n");
    printf("请点击窗口使其获得焦点，然后开始按键测试\n\n");
    
    /* 事件循环 */
    while (running) {
        xcb_generic_event_t *event = xcb_poll_for_event(ctx.conn);
        
        if (event) {
            handle_xcb_key_event(event, &ctx);
            free(event);
        } else {
            usleep(10000); // 10ms
        }
    }
    
    /* 清理 */
    xcb_key_symbols_free(ctx.keysyms);
    xcb_destroy_window(ctx.conn, ctx.window);
    xcb_disconnect(ctx.conn);
}

/* ========== evdev 原始事件处理 ========== */

typedef struct {
    int fd;
    char name[256];
} keyboard_device_t;

int find_keyboard_devices(keyboard_device_t *devices, int max_devices) {
    int count = 0;
    char path[64];
    
    for (int i = 0; i < 32; i++) {
        if (count >= max_devices) break;
        
        snprintf(path, sizeof(path), "/dev/input/event%d", i);
        int fd = open(path, O_RDONLY | O_NONBLOCK);
        if (fd == -1) continue;
        
        /* 检查设备能力 */
        unsigned long evbit = 0;
        if (ioctl(fd, EVIOCGBIT(0, sizeof(evbit)), &evbit) == -1) {
            close(fd);
            continue;
        }
        
        /* 检查是否为键盘设备 */
        if (evbit & (1 << EV_KEY)) {
            /* 获取设备名称 */
            char name[256] = "Unknown";
            if (ioctl(fd, EVIOCGNAME(sizeof(name)), name) == -1) {
                strcpy(name, "Unknown");
            }
            
            /* 检查是否支持按键事件 */
            unsigned long keybit[KEY_MAX/8/sizeof(long) + 1] = {0};
            if (ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(keybit)), keybit) != -1) {
                /* 检查是否有字母键或数字键，避免误判鼠标等设备 */
                if ((keybit[KEY_A/8/sizeof(long)] & (1 << (KEY_A % (8*sizeof(long))))) ||
                    (keybit[KEY_1/8/sizeof(long)] & (1 << (KEY_1 % (8*sizeof(long)))))) {
                    
                    devices[count].fd = fd;
                    strncpy(devices[count].name, name, sizeof(devices[count].name) - 1);
                    devices[count].name[sizeof(devices[count].name) - 1] = '\0';
                    count++;
                    
                    printf("找到键盘设备: %s (%s)\n", path, name);
                } else {
                    close(fd);
                }
            } else {
                close(fd);
            }
        } else {
            close(fd);
        }
    }
    
    return count;
}

const char* get_key_name(int code) {
    /* 常见键码映射 */
    switch (code) {
        case KEY_ESC: return "Esc";
        case KEY_1: return "1"; case KEY_2: return "2"; case KEY_3: return "3";
        case KEY_4: return "4"; case KEY_5: return "5"; case KEY_6: return "6";
        case KEY_7: return "7"; case KEY_8: return "8"; case KEY_9: return "9";
        case KEY_0: return "0";
        case KEY_Q: return "Q"; case KEY_W: return "W"; case KEY_E: return "E";
        case KEY_R: return "R"; case KEY_T: return "T"; case KEY_Y: return "Y";
        case KEY_U: return "U"; case KEY_I: return "I"; case KEY_O: return "O";
        case KEY_P: return "P"; case KEY_A: return "A"; case KEY_S: return "S";
        case KEY_D: return "D"; case KEY_F: return "F"; case KEY_G: return "G";
        case KEY_H: return "H"; case KEY_J: return "J"; case KEY_K: return "K";
        case KEY_L: return "L"; case KEY_Z: return "Z"; case KEY_X: return "X";
        case KEY_C: return "C"; case KEY_V: return "V"; case KEY_B: return "B";
        case KEY_N: return "N"; case KEY_M: return "M";
        case KEY_SPACE: return "Space";
        case KEY_ENTER: return "Enter";
        case KEY_BACKSPACE: return "Backspace";
        case KEY_TAB: return "Tab";
        case KEY_LEFTSHIFT: return "LeftShift";
        case KEY_RIGHTSHIFT: return "RightShift";
        case KEY_LEFTCTRL: return "LeftCtrl";
        case KEY_RIGHTCTRL: return "RightCtrl";
        case KEY_LEFTALT: return "LeftAlt";
        case KEY_RIGHTALT: return "RightAlt";
        case KEY_LEFTMETA: return "LeftSuper";
        case KEY_RIGHTMETA: return "RightSuper";
        case KEY_CAPSLOCK: return "CapsLock";
        case KEY_NUMLOCK: return "NumLock";
        case KEY_SCROLLLOCK: return "ScrollLock";
        case KEY_UP: return "Up";
        case KEY_DOWN: return "Down";
        case KEY_LEFT: return "Left";
        case KEY_RIGHT: return "Right";
        case KEY_F1: return "F1"; case KEY_F2: return "F2"; case KEY_F3: return "F3";
        case KEY_F4: return "F4"; case KEY_F5: return "F5"; case KEY_F6: return "F6";
        case KEY_F7: return "F7"; case KEY_F8: return "F8"; case KEY_F9: return "F9";
        case KEY_F10: return "F10"; case KEY_F11: return "F11"; case KEY_F12: return "F12";
        default: return NULL;
    }
}

void handle_evdev_event(const struct input_event *ev, const char *device_name) {
    static int left_super = 0, right_super = 0;
    
    if (ev->type == EV_KEY) {
        const char *key_name = get_key_name(ev->code);
        const char *state_str = "";
        
        switch (ev->value) {
            case 0: state_str = "释放"; break;
            case 1: state_str = "按下"; break;
            case 2: state_str = "重复"; break;
        }
        
        printf("设备: %-20s 键: %-12s (码: %3d) 状态: %s", 
               device_name, 
               key_name ? key_name : "Unknown", 
               ev->code, 
               state_str);
        
        /* 特殊处理Super键 */
        if (ev->code == KEY_LEFTMETA) {
            left_super = (ev->value > 0);
            printf(" [左Super]");
        } else if (ev->code == KEY_RIGHTMETA) {
            right_super = (ev->value > 0);
            printf(" [右Super]");
        }
        
        /* 显示Super键组合 */
        if ((left_super || right_super) && ev->value == 1 && key_name) {
            printf(" [Super+%s]", key_name);
        }
        
        printf("\n");
    }
}

void evdev_raw_listener() {
    keyboard_device_t devices[MAX_DEVICES];
    int device_count;
    
    printf("=== evdev 原始键盘事件监听 ===\n");
    
    if (geteuid() != 0) {
        printf("警告: 非root用户可能无法访问所有输入设备\n");
        printf("建议使用: sudo %s --evdev\n", "shotcuts");
    }
    
    device_count = find_keyboard_devices(devices, MAX_DEVICES);
    if (device_count == 0) {
        fprintf(stderr, "错误: 未找到任何键盘设备\n");
        return;
    }
    
    printf("找到 %d 个键盘设备，开始监听...\n", device_count);
    printf("按 Ctrl+C 退出\n\n");
    
    /* 事件循环 */
    while (running) {
        for (int i = 0; i < device_count; i++) {
            struct input_event ev;
            ssize_t n;
            
            while ((n = read(devices[i].fd, &ev, sizeof(ev))) > 0) {
                if (n == sizeof(ev)) {
                    handle_evdev_event(&ev, devices[i].name);
                }
            }
            
            if (n == -1 && errno != EAGAIN) {
                fprintf(stderr, "设备 %s 读取错误: %s\n", 
                       devices[i].name, strerror(errno));
            }
        }
        
        usleep(10000); // 10ms
    }
    
    /* 清理 */
    for (int i = 0; i < device_count; i++) {
        close(devices[i].fd);
    }
}

/* ========== 主程序 ========== */

void print_usage(const char *program_name) {
    printf("用法: %s [选项]\n", program_name);
    printf("选项:\n");
    printf("  --xcb       使用XCB方法监听键盘事件（默认）\n");
    printf("  --evdev     使用evdev方法直接监听输入设备\n");
    printf("  --help      显示此帮助信息\n");
    printf("\n");
    printf("说明:\n");
    printf("  XCB方法:    需要X服务器，可以获取键符号信息\n");
    printf("  evdev方法:  直接访问输入设备，需要root权限，更底层\n");
}

int main(int argc, char *argv[]) {
    int use_evdev = 0;
    
    /* 设置信号处理 */
    signal(SIGINT, signal_handler);
    signal(SIGTERM, signal_handler);
    
    /* 解析命令行参数 */
    if (argc > 1) {
        if (strcmp(argv[1], "--evdev") == 0) {
            use_evdev = 1;
        } else if (strcmp(argv[1], "--xcb") == 0) {
            use_evdev = 0;
        } else if (strcmp(argv[1], "--help") == 0) {
            print_usage(argv[0]);
            return 0;
        } else {
            fprintf(stderr, "错误: 未知选项 %s\n", argv[1]);
            print_usage(argv[0]);
            return 1;
        }
    }
    
    printf("键盘事件监听器启动\n");
    printf("正在初始化...\n");
    
    if (use_evdev) {
        evdev_raw_listener();
    } else {
        xcb_keyboard_listener();
    }
    
    printf("程序退出\n");
    return 0;
}

• CMakeLists.txt

cmake_minimum_required(VERSION 3.16)

project(shotcuts LANGUAGES C)
set(CMAKE_C_STANDARD 11)

# 查找必要的包
find_package(PkgConfig REQUIRED)
pkg_check_modules(XCB REQUIRED xcb xcb-keysyms)

# 添加可执行文件
add_executable(shotcuts main.c)
# 链接库
target_link_libraries(shotcuts ${XCB_LIBRARIES})

# 设置编译器选项
target_compile_options(shotcuts PRIVATE -Wall -Wextra)

include(GNUInstallDirs)
install(TARGETS shotcuts
    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
)

[antenore]

@KangLin sorry I missed this notification, and I don't work on Remmina since more than 2 years now.

The sort answer is that in Qt, is a pain on the xxx, in GTK this were done using a GTK grab function, that steals all the input events.

In Qt, I believe, you can do this in different ways...

1. Override methods like keyPressEvent() and keyReleaseEvent() in your widget.
2. Use installEventFilter() on a QObject to monitor events for other objects before they are processed.
3. Use a Global Event Filter Install an event filter on the QApplication or QCoreApplication object. Capturing events for the entire application before any widget sees them.

The third solution may be the best bet, but it's quite complex

1. Create a Filter Class: Design a class that inherits from QObject and overrides the eventFilter() function.
2. Install the Filter: Create an instance of your filter and install it on the application object using qApp->installEventFilter(yourFilterObject).
3. Process Key Events: Inside the eventFilter(), check for QEvent::KeyPress and QEvent::KeyRelease events. You can then extract information and send it to your remote server.

The methods described above primarily capture keys only when your Qt application is the active, focused window . The OS/window manager will still intercept keys when another application has focus.
· System-Level Global Hook: To capture keys even when your app is not in focus (a true global hook), you must use platform-specific native APIs outside of Qt. This is more complex

I hope this help!!! And sorry I didn't read the full thread 😢

[KangLin]

Thanks to @antenore for the reply.
Currently, I am using the third solution. Qt uses libxcb at the lower level, but based on current tests, libxcb cannot capture desktop hotkeys. So for now, there is no complete solution.