1.0.6

README.md

@@ -35,8 +35,6 @@ There are also additional dependencies needed at runtime:
 * [GPU Screen Recorder Notification](https://git.dec05eba.com/gpu-screen-recorder-notification/)
 
 ## Program behavior notes
-At the moment different keyboard layouts are not supported. The physical layout of keys are used for global hotkeys. If your Z and Y keys are swapped for example then you need to press Left Alt+Y instead of Left Alt+Z to open/hide the UI.\
-If you experience this issue then please email dec05eba@protonmail.com to get it fixed.\
 This program has to grab all keyboards and create a virtual keyboard (`gsr-ui virtual keyboard`) to make global hotkeys work on all Wayland compositors.
 This might cause issues for you if you use input remapping software. To workaround this you can go into settings and select "Only grab virtual devices"
 
@@ -57,5 +55,4 @@ If you want to donate you can donate via bitcoin or monero.
 
 # Known issues
 * When the UI is open the wallpaper is shown instead of the game on Hyprland and Sway. This is an issue with Hyprland and Sway. It cant be fixed until the UI is redesigned to not be a fullscreen overlay.
-* Different keyboard layouts are not supported at the moment. The physical layout of keys are used for global hotkeys. If your Z and Y keys are swapped for example then you need to press Left Alt+Y instead of Left Alt+Z to open/hide the UI. If you experience this issue then please email dec05eba@protonmail.com to get it fixed.
-* The mouse position can sometimes shift when opening the UI.
+* Opening the UI when a game is fullscreened can mess up the game window a bit on Hyprland and Sway. I believe this is an issue in Hyprland and Sway.

include/WindowUtils.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <mglpp/system/vec.hpp>
 #include <string>
 #include <X11/Xlib.h>
 
@@ -11,4 +12,8 @@ namespace gsr {
 
     Window get_focused_window(Display *dpy, WindowCaptureType cap_type);
     std::string get_focused_window_name(Display *dpy, WindowCaptureType window_capture_type);
+    mgl::vec2i get_cursor_position(Display *dpy, Window *window);
+    mgl::vec2i create_window_get_center_position(Display *display);
+    std::string get_window_manager_name(Display *display);
+    bool is_compositor_running(Display *dpy, int screen);
 }

meson.build

@@ -1,4 +1,4 @@
-project('gsr-ui', ['c', 'cpp'], version : '1.0.5', default_options : ['warning_level=2', 'cpp_std=c++17'], subproject_dir : 'depends')
+project('gsr-ui', ['c', 'cpp'], version : '1.0.6', default_options : ['warning_level=2', 'cpp_std=c++17'], subproject_dir : 'depends')
 
 if get_option('buildtype') == 'debug'
     add_project_arguments('-g3', language : ['c', 'cpp'])

project.conf

@@ -1,7 +1,7 @@
 [package]
 name = "gsr-ui"
 type = "executable"
-version = "1.0.5"
+version = "1.0.6"
 platforms = ["posix"]
 
 [lang.cpp]

src/Overlay.cpp

@@ -42,19 +42,6 @@ namespace gsr {
     static const double force_window_on_top_timeout_seconds = 1.0;
     static const double replay_status_update_check_timeout_seconds = 1.0;
 
-    static bool is_focused_application_wayland(Display *dpy) {
-        return get_focused_window(dpy, WindowCaptureType::FOCUSED) == 0;
-    }
-
-    static bool is_cursor_hovering_application_wayland(Display *dpy) {
-        Window root_window = None;
-        Window window = None;
-        int dummy_i;
-        unsigned int dummy_u;
-        XQueryPointer(dpy, DefaultRootWindow(dpy), &root_window, &window, &dummy_i, &dummy_i, &dummy_i, &dummy_i, &dummy_u);
-        return window == None;
-    }
-
     static mgl::Texture texture_from_ximage(XImage *img) {
         uint8_t *texture_data = (uint8_t*)malloc(img->width * img->height * 3);
         // TODO:
@@ -303,91 +290,6 @@ namespace gsr {
         return &win->monitors[0];
     }
 
-    static mgl::vec2i get_cursor_position(Display *dpy) {
-        Window root_window = None;
-        Window window = None;
-        int dummy_i;
-        unsigned int dummy_u;
-        mgl::vec2i root_pos;
-        XQueryPointer(dpy, DefaultRootWindow(dpy), &root_window, &window, &root_pos.x, &root_pos.y, &dummy_i, &dummy_i, &dummy_u);
-        return root_pos;
-    }
-
-    static mgl::vec2i create_window_get_center_position(Display *display) {
-        const int size = 16;
-        XSetWindowAttributes window_attr;
-        window_attr.event_mask = StructureNotifyMask;
-        window_attr.background_pixel = 0;
-        const Window window = XCreateWindow(display, DefaultRootWindow(display), 0, 0, size, size, 0, CopyFromParent, InputOutput, CopyFromParent, CWBackPixel | CWEventMask, &window_attr);
-        if(!window)
-            return {0, 0};
-
-        const Atom net_wm_window_type_atom = XInternAtom(display, "_NET_WM_WINDOW_TYPE", False);
-        const Atom net_wm_window_type_notification_atom = XInternAtom(display, "_NET_WM_WINDOW_TYPE_NOTIFICATION", False);
-        const Atom net_wm_window_type_utility = XInternAtom(display, "_NET_WM_WINDOW_TYPE_UTILITY", False);
-        const Atom net_wm_window_opacity = XInternAtom(display, "_NET_WM_WINDOW_OPACITY", False);
-
-        const Atom window_type_atoms[2] = {
-            net_wm_window_type_notification_atom,
-            net_wm_window_type_utility
-        };
-        XChangeProperty(display, window, net_wm_window_type_atom, XA_ATOM, 32, PropModeReplace, (const unsigned char*)window_type_atoms, 2L);
-
-        const double alpha = 0.0;
-        const unsigned long opacity = (unsigned long)(0xFFFFFFFFul * alpha);
-        XChangeProperty(display, window, net_wm_window_opacity, XA_CARDINAL, 32, PropModeReplace, (unsigned char *)&opacity, 1L);
-
-        XSizeHints *size_hints = XAllocSizeHints();
-        size_hints->width = size;
-        size_hints->min_width = size;
-        size_hints->max_width = size;
-        size_hints->height = size;
-        size_hints->min_height = size;
-        size_hints->max_height = size;
-        size_hints->flags = PSize | PMinSize | PMaxSize;
-        XSetWMNormalHints(display, window, size_hints);
-        XFree(size_hints);
-
-        XMapWindow(display, window);
-        XFlush(display);
-
-        const int x_fd = XConnectionNumber(display);
-        mgl::vec2i window_pos;
-        XEvent xev;
-        while(true) {
-            struct pollfd poll_fd;
-            poll_fd.fd = x_fd;
-            poll_fd.events = POLLIN;
-            poll_fd.revents = 0;
-            const int fds_ready = poll(&poll_fd, 1, 1000);
-            if(fds_ready == 0) {
-                fprintf(stderr, "Error: timed out waiting for ConfigureNotify after XCreateWindow\n");
-                break;
-            } else if(fds_ready == -1 || !(poll_fd.revents & POLLIN)) {
-                continue;
-            }
-
-            XNextEvent(display, &xev);
-            if(xev.type == ConfigureNotify) {
-                window_pos.x = xev.xconfigure.x + xev.xconfigure.width / 2;
-                window_pos.y = xev.xconfigure.y + xev.xconfigure.height / 2;
-                break;
-            }
-        }
-
-        XDestroyWindow(display, window);
-        XFlush(display);
-
-        return window_pos;
-    }
-
-    static bool is_compositor_running(Display *dpy, int screen) {
-        char prop_name[20];
-        snprintf(prop_name, sizeof(prop_name), "_NET_WM_CM_S%d", screen);
-        Atom prop_atom = XInternAtom(dpy, prop_name, False);
-        return XGetSelectionOwner(dpy, prop_atom) != None;
-    }
-
     static std::string get_power_supply_online_filepath() {
         std::string result;
         const char *paths[] = {
@@ -810,26 +712,37 @@ namespace gsr {
         mgl_context *context = mgl_get_context();
         Display *display = (Display*)context->connection;
 
+        const std::string wm_name = get_window_manager_name(display);
+        const bool is_kwin = wm_name == "KWin";
+
+        // The cursor position is wrong on wayland if an x11 window is not focused. On wayland we instead create a window and get the position where the wayland compositor puts it
+        Window x11_cursor_window = None;
+        const mgl::vec2i cursor_position = get_cursor_position(display, &x11_cursor_window);
+        const mgl::vec2i monitor_position_query_value = (x11_cursor_window || gsr_info.system_info.display_server != DisplayServer::WAYLAND) ? cursor_position : create_window_get_center_position(display);
+
         // Wayland doesn't allow XGrabPointer/XGrabKeyboard when a wayland application is focused.
         // If the focused window is a wayland application then don't use override redirect and instead create
         // a fullscreen window for the ui.
-        const bool prevent_game_minimizing = gsr_info.system_info.display_server != DisplayServer::WAYLAND || !is_focused_application_wayland(display);
+        const bool prevent_game_minimizing = gsr_info.system_info.display_server != DisplayServer::WAYLAND || x11_cursor_window;
 
-        window_size = { 1280, 720 };
+        window_size = { 32, 32 };
         window_pos = { 0, 0 };
 
         mgl::Window::CreateParams window_create_params;
         window_create_params.size = window_size;
-        window_create_params.min_size = window_size;
-        window_create_params.max_size = window_size;
+        if(prevent_game_minimizing) {
+            window_create_params.min_size = window_size;
+            window_create_params.max_size = window_size;
+        }
         window_create_params.position = window_pos;
-        window_create_params.hidden = true;
+        window_create_params.hidden = prevent_game_minimizing;
         window_create_params.override_redirect = prevent_game_minimizing;
         window_create_params.background_color = bg_color;
         window_create_params.support_alpha = true;
+        window_create_params.hide_decorations = true;
         // MGL_WINDOW_TYPE_DIALOG is needed for kde plasma wayland in some cases, otherwise the window will pop up on another activity
         // or may not be visible at all
-        window_create_params.window_type = MGL_WINDOW_TYPE_DIALOG;
+        window_create_params.window_type = (is_kwin && gsr_info.system_info.display_server == DisplayServer::WAYLAND) ? MGL_WINDOW_TYPE_DIALOG : MGL_WINDOW_TYPE_NORMAL;
         window_create_params.render_api = MGL_RENDER_API_EGL;
 
         if(!window->create("gsr ui", window_create_params))
@@ -853,17 +766,16 @@ namespace gsr {
             return;
         }
 
-        // The cursor position is wrong on wayland if an x11 window is not focused. On wayland we instead create a window and get the position where the wayland compositor puts it
-        const mgl::vec2i cursor_position = get_cursor_position(display);
-        const mgl::vec2i monitor_position_query_value = gsr_info.system_info.display_server == DisplayServer::WAYLAND ? create_window_get_center_position(display) : cursor_position;
         const mgl_monitor *focused_monitor = find_monitor_at_position(*window, monitor_position_query_value);
         window_pos = {focused_monitor->pos.x, focused_monitor->pos.y};
         window_size = {focused_monitor->size.x, focused_monitor->size.y};
         get_theme().set_window_size(window_size);
 
-        window->set_size(window_size);
-        window->set_size_limits(window_size, window_size);
-        window->set_position(window_pos);
+        if(prevent_game_minimizing) {
+            window->set_size(window_size);
+            window->set_size_limits(window_size, window_size);
+            window->set_position(window_pos);
+        }
 
         win->cursor_position.x = cursor_position.x - window_pos.x;
         win->cursor_position.y = cursor_position.y - window_pos.y;
@@ -1046,7 +958,7 @@ namespace gsr {
 
         // The focused application can be an xwayland application but the cursor can hover over a wayland application.
         // This is even the case when hovering over the titlebar of the xwayland application.
-        if(!is_cursor_hovering_application_wayland(display))
+        if(prevent_game_minimizing)
             xi_setup();
 
         //window->set_fullscreen(true);

src/WindowUtils.cpp

@@ -7,8 +7,31 @@
 #include <stdbool.h>
 #include <stdio.h>
 #include <string.h>
+#include <poll.h>
+
+#define MAX_PROPERTY_VALUE_LEN 4096
 
 namespace gsr {
+    static unsigned char* window_get_property(Display *dpy, Window window, Atom property_type, const char *property_name, unsigned int *property_size) {
+        Atom ret_property_type = None;
+        int ret_format = 0;
+        unsigned long num_items = 0;
+        unsigned long num_remaining_bytes = 0;
+        unsigned char *data = nullptr;
+        const Atom atom = XInternAtom(dpy, property_name, False);
+        if(XGetWindowProperty(dpy, window, atom, 0, MAX_PROPERTY_VALUE_LEN / 4, False, property_type, &ret_property_type, &ret_format, &num_items, &num_remaining_bytes, &data) != Success || !data) {
+            return nullptr;
+        }
+
+        if(ret_property_type != property_type) {
+            XFree(data);
+            return nullptr;
+        }
+
+        *property_size = (ret_format / (32 / sizeof(long))) * num_items;
+        return data;
+    }
+
     static bool window_has_atom(Display *dpy, Window window, Atom atom) {
         Atom type;
         unsigned long len, bytes_left;
@@ -160,7 +183,7 @@ namespace gsr {
         return str;
     }
 
-    static std::string string_string(const char *str) {
+    static std::string strip_strip(const char *str) {
         int len = 0;
         str = strip(str, &len);
         return std::string(str, len);
@@ -175,7 +198,7 @@ namespace gsr {
         // Window title is not always ideal (for example for a browser), but for games its pretty much required
         char *window_title = get_window_title(dpy, focused_window);
         if(window_title) {
-            result = string_string(window_title);
+            result = strip_strip(window_title);
             XFree(window_title);
             return result;
         }
@@ -183,10 +206,255 @@ namespace gsr {
         XClassHint class_hint = {nullptr, nullptr};
         XGetClassHint(dpy, focused_window, &class_hint);
         if(class_hint.res_class) {
-            result = string_string(class_hint.res_class);
+            result = strip_strip(class_hint.res_class);
             return result;
         }
 
         return result;
     }
+
+    mgl::vec2i get_cursor_position(Display *dpy, Window *window) {
+        Window root_window = None;
+        *window = None;
+        int dummy_i;
+        unsigned int dummy_u;
+        mgl::vec2i root_pos;
+        XQueryPointer(dpy, DefaultRootWindow(dpy), &root_window, window, &root_pos.x, &root_pos.y, &dummy_i, &dummy_i, &dummy_u);
+
+        // This dumb shit is done to satisfy gnome wayland. Only set |window| if a valid x11 window is focused
+        if(window) {
+            XWindowAttributes attr;
+            if(XGetWindowAttributes(dpy, *window, &attr) && attr.override_redirect)
+                *window = None;
+
+            int revert_to = 0;
+            Window input_focus_window = None;
+            if(XGetInputFocus(dpy, &input_focus_window, &revert_to)) {
+                if(input_focus_window) {
+                    if(XGetWindowAttributes(dpy, input_focus_window, &attr) && attr.override_redirect)
+                        *window = None;
+                } else {
+                    *window = None;
+                }
+            }
+        }
+
+        return root_pos;
+    }
+
+    typedef struct {
+        unsigned long flags;
+        unsigned long functions;
+        unsigned long decorations;
+        long input_mode;
+        unsigned long status;
+    } MotifHints;
+
+    #define MWM_HINTS_DECORATIONS   2
+
+    #define MWM_DECOR_NONE          0
+    #define MWM_DECOR_ALL           1
+
+    static void window_set_decorations_visible(Display *display, Window window, bool visible) {
+        const Atom motif_wm_hints_atom = XInternAtom(display, "_MOTIF_WM_HINTS", False);
+        MotifHints motif_hints;
+        memset(&motif_hints, 0, sizeof(motif_hints));
+        motif_hints.flags = MWM_HINTS_DECORATIONS;
+        motif_hints.decorations = visible ? MWM_DECOR_ALL : MWM_DECOR_NONE;
+        XChangeProperty(display, window, motif_wm_hints_atom, motif_wm_hints_atom, 32, PropModeReplace, (unsigned char*)&motif_hints, sizeof(motif_hints) / sizeof(long));
+    }
+
+    static bool create_window_get_center_position_kde(Display *display, mgl::vec2i &position) {
+        const int size = 1;
+        XSetWindowAttributes window_attr;
+        window_attr.event_mask = StructureNotifyMask;
+        window_attr.background_pixel = 0;
+        const Window window = XCreateWindow(display, DefaultRootWindow(display), 0, 0, size, size, 0, CopyFromParent, InputOutput, CopyFromParent, CWBackPixel | CWEventMask, &window_attr);
+        if(!window)
+            return false;
+
+        const Atom net_wm_window_type_atom = XInternAtom(display, "_NET_WM_WINDOW_TYPE", False);
+        const Atom net_wm_window_type_notification_atom = XInternAtom(display, "_NET_WM_WINDOW_TYPE_NOTIFICATION", False);
+        const Atom net_wm_window_type_utility = XInternAtom(display, "_NET_WM_WINDOW_TYPE_UTILITY", False);
+        const Atom net_wm_window_opacity = XInternAtom(display, "_NET_WM_WINDOW_OPACITY", False);
+
+        const Atom window_type_atoms[2] = {
+            net_wm_window_type_notification_atom,
+            net_wm_window_type_utility
+        };
+        XChangeProperty(display, window, net_wm_window_type_atom, XA_ATOM, 32, PropModeReplace, (const unsigned char*)window_type_atoms, 2L);
+
+        const double alpha = 0.0;
+        const unsigned long opacity = (unsigned long)(0xFFFFFFFFul * alpha);
+        XChangeProperty(display, window, net_wm_window_opacity, XA_CARDINAL, 32, PropModeReplace, (unsigned char *)&opacity, 1L);
+
+        window_set_decorations_visible(display, window, false);
+
+        XSizeHints *size_hints = XAllocSizeHints();
+        size_hints->width = size;
+        size_hints->height = size;
+        size_hints->min_width = size;
+        size_hints->min_height = size;
+        size_hints->max_width = size;
+        size_hints->max_height = size;
+        size_hints->flags = PSize | PMinSize | PMaxSize;
+        XSetWMNormalHints(display, window, size_hints);
+        XFree(size_hints);
+
+        XMapWindow(display, window);
+        XFlush(display);
+
+        bool got_data = false;
+        const int x_fd = XConnectionNumber(display);
+        XEvent xev;
+        while(true) {
+            struct pollfd poll_fd;
+            poll_fd.fd = x_fd;
+            poll_fd.events = POLLIN;
+            poll_fd.revents = 0;
+            const int fds_ready = poll(&poll_fd, 1, 1000);
+            if(fds_ready == 0) {
+                fprintf(stderr, "Error: timed out waiting for ConfigureNotify after XCreateWindow\n");
+                break;
+            } else if(fds_ready == -1 || !(poll_fd.revents & POLLIN)) {
+                continue;
+            }
+
+            XNextEvent(display, &xev);
+            if(xev.type == ConfigureNotify && xev.xconfigure.window == window) {
+                got_data = xev.xconfigure.x > 0 && xev.xconfigure.y > 0;
+                position.x = xev.xconfigure.x + xev.xconfigure.width / 2;
+                position.y = xev.xconfigure.y + xev.xconfigure.height / 2;
+                break;
+            }
+        }
+
+        XDestroyWindow(display, window);
+        XFlush(display);
+
+        return got_data;
+    }
+
+    static bool create_window_get_center_position_gnome(Display *display, mgl::vec2i &position) {
+        const int size = 32;
+        XSetWindowAttributes window_attr;
+        window_attr.event_mask = StructureNotifyMask | ExposureMask;
+        window_attr.background_pixel = 0;
+        const Window window = XCreateWindow(display, DefaultRootWindow(display), 0, 0, size, size, 0, CopyFromParent, InputOutput, CopyFromParent, CWBackPixel | CWEventMask, &window_attr);
+        if(!window)
+            return false;
+
+        const Atom net_wm_window_opacity = XInternAtom(display, "_NET_WM_WINDOW_OPACITY", False);
+        const double alpha = 0.0;
+        const unsigned long opacity = (unsigned long)(0xFFFFFFFFul * alpha);
+        XChangeProperty(display, window, net_wm_window_opacity, XA_CARDINAL, 32, PropModeReplace, (unsigned char *)&opacity, 1L);
+
+        window_set_decorations_visible(display, window, false);
+
+        XSizeHints *size_hints = XAllocSizeHints();
+        size_hints->width = size;
+        size_hints->height = size;
+        size_hints->min_width = size;
+        size_hints->min_height = size;
+        size_hints->max_width = size;
+        size_hints->max_height = size;
+        size_hints->flags = PSize | PMinSize | PMaxSize;
+        XSetWMNormalHints(display, window, size_hints);
+        XFree(size_hints);
+
+        XMapWindow(display, window);
+        XFlush(display);
+
+        bool got_data = false;
+        const int x_fd = XConnectionNumber(display);
+        XEvent xev;
+        while(true) {
+            struct pollfd poll_fd;
+            poll_fd.fd = x_fd;
+            poll_fd.events = POLLIN;
+            poll_fd.revents = 0;
+            const int fds_ready = poll(&poll_fd, 1, 1000);
+            if(fds_ready == 0) {
+                fprintf(stderr, "Error: timed out waiting for MapNotify/ConfigureNotify after XCreateWindow\n");
+                break;
+            } else if(fds_ready == -1 || !(poll_fd.revents & POLLIN)) {
+                continue;
+            }
+
+            XNextEvent(display, &xev);
+            if(xev.type == MapNotify && xev.xmap.window == window) {
+                int x = 0;
+                int y = 0;
+                Window w = None;
+                XTranslateCoordinates(display, window, DefaultRootWindow(display), 0, 0, &x, &y, &w);
+
+                got_data = x > 0 && y > 0;
+                position.x = x + size / 2;
+                position.y = y + size / 2;
+                if(got_data)
+                    break;
+            } else if(xev.type == ConfigureNotify && xev.xconfigure.window == window) {
+                got_data = xev.xconfigure.x > 0 && xev.xconfigure.y > 0;
+                position.x = xev.xconfigure.x + xev.xconfigure.width / 2;
+                position.y = xev.xconfigure.y + xev.xconfigure.height / 2;
+                if(got_data)
+                    break;
+            }
+        }
+
+        XDestroyWindow(display, window);
+        XFlush(display);
+
+        return got_data;
+    }
+
+    mgl::vec2i create_window_get_center_position(Display *display) {
+        mgl::vec2i pos;
+        if(!create_window_get_center_position_kde(display, pos)) {
+            pos.x = 0;
+            pos.y = 0;
+            create_window_get_center_position_gnome(display, pos);
+        }
+        return pos;
+    }
+
+    std::string get_window_manager_name(Display *display) {
+        std::string wm_name;
+        unsigned int property_size = 0;
+        Window window = None;
+
+        unsigned char *net_supporting_wm_check = window_get_property(display, DefaultRootWindow(display), XA_WINDOW, "_NET_SUPPORTING_WM_CHECK", &property_size);
+        if(net_supporting_wm_check) {
+            if(property_size == 8)
+                window = *(Window*)net_supporting_wm_check;
+            XFree(net_supporting_wm_check);
+        }
+
+        if(!window) {
+            unsigned char *win_supporting_wm_check = window_get_property(display, DefaultRootWindow(display), XA_WINDOW, "_WIN_SUPPORTING_WM_CHECK", &property_size);
+            if(win_supporting_wm_check) {
+                if(property_size == 8)
+                    window = *(Window*)win_supporting_wm_check;
+                XFree(win_supporting_wm_check);
+            }
+        }
+
+        if(!window)
+            return wm_name;
+
+        char *window_title = get_window_title(display, window);
+        if(window_title) {
+            wm_name = strip_strip(window_title);
+            XFree(window_title);
+        }
+
+        return wm_name;
+    }
+
+    bool is_compositor_running(Display *dpy, int screen) {
+        char prop_name[20];
+        snprintf(prop_name, sizeof(prop_name), "_NET_WM_CM_S%d", screen);
+        Atom prop_atom = XInternAtom(dpy, prop_name, False);
+        return XGetSelectionOwner(dpy, prop_atom) != None;
+    }
 }

tools/gsr-global-hotkeys/keyboard_event.c

@@ -25,6 +25,24 @@
 
 #define KEY_STATES_SIZE (KEY_MAX/8 + 1)
 
+#define KEYCODE_TO_XKB_KEYCODE(key) ((key) + 8)
+
+#define XK_Shift_L                       0xffe1  /* Left shift */
+#define XK_Shift_R                       0xffe2  /* Right shift */
+#define XK_Control_L                     0xffe3  /* Left control */
+#define XK_Control_R                     0xffe4  /* Right control */
+#define XK_Alt_L                         0xffe9  /* Left alt */
+#define XK_Alt_R                         0xffea  /* Right alt */
+#define XK_Super_L                       0xffeb  /* Left super */
+#define XK_Super_R                       0xffec  /* Right super */
+
+#define XK_z                             0x007a
+#define XK_F7                            0xffc4
+#define XK_F8                            0xffc5
+#define XK_F9                            0xffc6
+#define XK_F10                           0xffc7
+#define XK_F11                           0xffc8
+
 static inline int count_num_bits_set(unsigned char c) {
     int n = 0;
     n += (c & 1);
@@ -117,6 +135,35 @@ static void keyboard_event_process_key_state_change(keyboard_event *self, struct
     }
 }
 
+static uint32_t keycode_to_keysym(keyboard_event *self, uint16_t keycode) {
+    const unsigned long xkb_keycode = KEYCODE_TO_XKB_KEYCODE(keycode);
+    if(self->x_context.display && self->x_context.XKeycodeToKeysym && xkb_keycode <= 255)
+        return self->x_context.XKeycodeToKeysym(self->x_context.display, xkb_keycode, 0);
+    else
+        return 0;
+}
+
+/* TODO: Support more keys when needed */
+static uint32_t keysym_to_keycode(uint32_t keysym) {
+    switch(keysym) {
+        case XK_Control_L:  return KEY_LEFTCTRL;
+        case XK_Shift_L:    return KEY_LEFTSHIFT;
+        case XK_Alt_L:      return KEY_LEFTALT;
+        case XK_Super_L:    return KEY_LEFTMETA;
+        case XK_Control_R:  return KEY_RIGHTCTRL;
+        case XK_Shift_R:    return KEY_RIGHTSHIFT;
+        case XK_Alt_R:      return KEY_RIGHTALT;
+        case XK_Super_R:    return KEY_RIGHTMETA;
+        case XK_z:          return KEY_Z;
+        case XK_F7:         return KEY_F7;
+        case XK_F8:         return KEY_F8;
+        case XK_F9:         return KEY_F9;
+        case XK_F10:        return KEY_F10;
+        case XK_F11:        return KEY_F11;
+        default:            return 0;
+    }
+}
+
 static void keyboard_event_process_input_event_data(keyboard_event *self, event_extra_data *extra_data, int fd, key_callback callback, void *userdata) {
     struct input_event event;
     if(read(fd, &event, sizeof(event)) != sizeof(event)) {
@@ -137,7 +184,12 @@ static void keyboard_event_process_input_event_data(keyboard_event *self, event_
     if(event.type == EV_KEY) {
         keyboard_event_process_key_state_change(self, event, extra_data, fd);
 
-        switch(event.code) {
+        uint32_t keycode = event.code;
+        const uint32_t keysym = keycode_to_keysym(self, event.code);
+        if(keysym)
+            keycode = keysym_to_keycode(keysym);
+
+        switch(keycode) {
             case KEY_LEFTSHIFT:
                 self->lshift_button_state = event.value >= 1 ? KEYBOARD_BUTTON_PRESSED : KEYBOARD_BUTTON_RELEASED;
                 break;
@@ -168,7 +220,7 @@ static void keyboard_event_process_input_event_data(keyboard_event *self, event_
                 const bool lalt_pressed = self->lalt_button_state == KEYBOARD_BUTTON_PRESSED;
                 const bool ralt_pressed = self->ralt_button_state == KEYBOARD_BUTTON_PRESSED;
                 const bool meta_pressed = self->lmeta_button_state == KEYBOARD_BUTTON_PRESSED || self->rmeta_button_state == KEYBOARD_BUTTON_PRESSED;
-                //fprintf(stderr, "pressed key: %d, state: %d, shift: %s, ctrl: %s, alt: %s, meta: %s\n", event.code, event.value,
+                //fprintf(stderr, "pressed key: %d, state: %d, shift: %s, ctrl: %s, alt: %s, meta: %s\n", keycode, event.value,
                 //   shift_pressed ? "yes" : "no", ctrl_pressed ? "yes" : "no", alt_pressed ? "yes" : "no", meta_pressed ? "yes" : "no");
                 uint32_t modifiers = 0;
                 if(shift_pressed)
@@ -182,7 +234,7 @@ static void keyboard_event_process_input_event_data(keyboard_event *self, event_
                 if(meta_pressed)
                     modifiers |= KEYBOARD_MODKEY_SUPER;
 
-                if(!callback(event.code, modifiers, event.value, userdata))
+                if(!callback(keycode, modifiers, event.value, userdata))
                     return;
 
                 break;
@@ -406,11 +458,12 @@ static int setup_virtual_keyboard_input(const char *name) {
     return fd;
 }
 
-bool keyboard_event_init(keyboard_event *self, bool poll_stdout_error, bool exclusive_grab, keyboard_grab_type grab_type) {
+bool keyboard_event_init(keyboard_event *self, bool poll_stdout_error, bool exclusive_grab, keyboard_grab_type grab_type, x11_context x_context) {
     memset(self, 0, sizeof(*self));
     self->stdout_event_index = -1;
     self->hotplug_event_index = -1;
     self->grab_type = grab_type;
+    self->x_context = x_context;
 
     if(exclusive_grab) {
         self->uinput_fd = setup_virtual_keyboard_input(GSR_UI_VIRTUAL_KEYBOARD_NAME);
@@ -490,7 +543,25 @@ static void on_device_added_callback(const char *devname, void *userdata) {
     keyboard_event_try_add_device_if_keyboard(keyboard_ev, dev_input_filepath);
 }
 
+#define MappingNotify 34
+
+static void keyboard_event_poll_x11_events(keyboard_event *self) {
+    if(!self->x_context.display || !self->x_context.XPending || !self->x_context.XNextEvent || !self->x_context.XRefreshKeyboardMapping)
+        return;
+
+    XEvent xev;
+    while(self->x_context.XPending(self->x_context.display)) {
+        xev.type = 0;
+        self->x_context.XNextEvent(self->x_context.display, &xev);
+        if(xev.type == MappingNotify)
+            self->x_context.XRefreshKeyboardMapping(xev.data);
+    }
+}
+
 void keyboard_event_poll_events(keyboard_event *self, int timeout_milliseconds, key_callback callback, void *userdata) {
+    /* TODO: Add the x11 connection to the below poll? */
+    keyboard_event_poll_x11_events(self);
+
     if(poll(self->event_polls, self->num_event_polls, timeout_milliseconds) <= 0)
         return;
 

tools/gsr-global-hotkeys/keyboard_event.h

@@ -17,6 +17,26 @@
 
 #define MAX_EVENT_POLLS 32
 
+typedef struct {
+    union {
+        int type;
+        unsigned char data[192];
+    };
+} XEvent;
+
+typedef unsigned long (*XKeycodeToKeysym_FUNC)(void *display, unsigned char keycode, int index);
+typedef int (*XPending_FUNC)(void *display);
+typedef int (*XNextEvent_FUNC)(void *display, XEvent *event_return);
+typedef int (*XRefreshKeyboardMapping_FUNC)(void* event_map);
+
+typedef struct {
+    void *display;
+    XKeycodeToKeysym_FUNC XKeycodeToKeysym;
+    XPending_FUNC XPending;
+    XNextEvent_FUNC XNextEvent;
+    XRefreshKeyboardMapping_FUNC XRefreshKeyboardMapping;
+} x11_context;
+
 typedef enum {
     KEYBOARD_MODKEY_LALT   = 1 << 0,
     KEYBOARD_MODKEY_RALT   = 1 << 2,
@@ -52,6 +72,7 @@ typedef struct {
     int uinput_fd;
     bool stdout_failed;
     keyboard_grab_type grab_type;
+    x11_context x_context;
 
     hotplug_event hotplug_ev;
 
@@ -69,7 +90,7 @@ typedef struct {
 /* Return true to allow other applications to receive the key input (when using exclusive grab) */
 typedef bool (*key_callback)(uint32_t key, uint32_t modifiers, int press_status, void *userdata);
 
-bool keyboard_event_init(keyboard_event *self, bool poll_stdout_error, bool exclusive_grab, keyboard_grab_type grab_type);
+bool keyboard_event_init(keyboard_event *self, bool poll_stdout_error, bool exclusive_grab, keyboard_grab_type grab_type, x11_context x_context);
 void keyboard_event_deinit(keyboard_event *self);
 
 /* If |timeout_milliseconds| is -1 then wait until an event is received */

tools/gsr-global-hotkeys/main.c

@@ -7,6 +7,7 @@
 
 /* POSIX */
 #include <unistd.h>
+#include <dlfcn.h>
 
 typedef struct {
     uint32_t key;
@@ -45,6 +46,76 @@ static void usage(void) {
     fprintf(stderr, "  --virtual    Grab all virtual devices only.\n");
 }
 
+typedef void* (*XOpenDisplay_FUNC)(const char*);
+typedef int (*XErrorHandler_FUNC)(void *display, void* error_event);
+typedef XErrorHandler_FUNC (*XSetErrorHandler_FUNC)(XErrorHandler_FUNC handler);
+
+static int x_ignore_error(void *display, void *ee) {
+    (void)display;
+    (void)ee;
+    return 0;
+}
+
+static x11_context setup_x11_context(void) {
+    x11_context x_context = {0};
+    XSetErrorHandler_FUNC XSetErrorHandler = NULL;
+
+    void *x11_lib = dlopen("libX11.so.6", RTLD_LAZY);
+    if(!x11_lib) {
+        fprintf(stderr, "Warning: dlopen libX11.so.6 failed\n");
+        return x_context;
+    }
+
+    XOpenDisplay_FUNC XOpenDisplay = dlsym(x11_lib, "XOpenDisplay");
+    if(!XOpenDisplay) {
+        fprintf(stderr, "Warning: dlsym XOpenDisplay failed\n");
+        goto fail;
+    }
+
+    x_context.XKeycodeToKeysym = dlsym(x11_lib, "XKeycodeToKeysym");
+    if(!x_context.XKeycodeToKeysym) {
+        fprintf(stderr, "Warning: dlsym XKeycodeToKeysym failed\n");
+        goto fail;
+    }
+
+    x_context.XPending = dlsym(x11_lib, "XPending");
+    if(!x_context.XPending) {
+        fprintf(stderr, "Warning: dlsym XPending failed\n");
+        goto fail;
+    }
+
+    x_context.XNextEvent = dlsym(x11_lib, "XNextEvent");
+    if(!x_context.XNextEvent) {
+        fprintf(stderr, "Warning: dlsym XNextEvent failed\n");
+        goto fail;
+    }
+
+    x_context.XRefreshKeyboardMapping = dlsym(x11_lib, "XRefreshKeyboardMapping");
+    if(!x_context.XRefreshKeyboardMapping) {
+        fprintf(stderr, "Warning: dlsym XRefreshKeyboardMapping failed\n");
+        goto fail;
+    }
+
+    x_context.display = XOpenDisplay(NULL);
+    if(!x_context.display) {
+        fprintf(stderr, "Warning: XOpenDisplay failed\n");
+        goto fail;
+    }
+
+    XSetErrorHandler = dlsym(x11_lib, "XSetErrorHandler");
+    if(XSetErrorHandler)
+        XSetErrorHandler(x_ignore_error);
+    else
+        fprintf(stderr, "Warning: dlsym XSetErrorHandler failed\n");
+
+    return x_context;
+
+    fail:
+    memset(&x_context, 0, sizeof(x_context));
+    dlclose(x11_lib);
+    return x_context;
+}
+
 int main(int argc, char **argv) {
     keyboard_grab_type grab_type = KEYBOARD_GRAB_TYPE_ALL;
     if(argc == 2) {
@@ -64,6 +135,8 @@ int main(int argc, char **argv) {
         return 1;
     }
 
+    x11_context x_context = setup_x11_context();
+
     const uid_t user_id = getuid();
     if(geteuid() != 0) {
         if(setuid(0) == -1) {
@@ -73,7 +146,7 @@ int main(int argc, char **argv) {
     }
 
     keyboard_event keyboard_ev;
-    if(!keyboard_event_init(&keyboard_ev, true, true, grab_type)) {
+    if(!keyboard_event_init(&keyboard_ev, true, true, grab_type, x_context)) {
         fprintf(stderr, "Error: failed to setup hotplugging and no keyboard input devices were found\n");
         setuid(user_id);
         return 1;