aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--README.md10
-rw-r--r--TODO8
m---------depends/mglpp0
-rw-r--r--include/WindowUtils.hpp5
-rw-r--r--meson.build2
-rw-r--r--project.conf2
-rw-r--r--src/Overlay.cpp137
-rw-r--r--src/WindowUtils.cpp274
-rw-r--r--tools/gsr-global-hotkeys/keyboard_event.c88
-rw-r--r--tools/gsr-global-hotkeys/keyboard_event.h32
-rw-r--r--tools/gsr-global-hotkeys/main.c87
-rw-r--r--tools/gsr-ui-cli/main.c1
12 files changed, 503 insertions, 143 deletions
diff --git a/README.md b/README.md
index e5ee4ea..7bd2d88 100644
--- a/README.md
+++ b/README.md
@@ -7,9 +7,10 @@ Note: This software is still in early alpha. Expect bugs, and please report any
You can report an issue by emailing the issue to dec05eba@protonmail.com.
# Usage
-Run `gsr-ui` and press `Alt+Z` to show/hide the UI. You can start the overlay UI at system startup by running `systemctl enable --now --user gpu-screen-recorder-ui`.
+Run `gsr-ui` and press `Left Alt+Z` to show/hide the UI. You can start the overlay UI at system startup by running `systemctl enable --now --user gpu-screen-recorder-ui`.
There is also an option in the settings to enable/disable starting the program on system startup. This option only works on systems that use systemd.
-You have to manually add `gsr-ui` to system startup on systems that uses another init system.
+You have to manually add `gsr-ui` to system startup on systems that uses another init system.\
+A program called `gsr-ui-cli` is also installed when installing this software. This can be used to remotely control the UI. Run `gsr-ui-cli --help` to list the available commands.
# Installation
If you are using an Arch Linux based distro then you can find gpu screen recorder ui on aur under the name gpu-screen-recorder-ui (`yay -S gpu-screen-recorder-ui`).\
@@ -34,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 Alt+Y instead of 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"
@@ -56,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 Alt+Y instead of 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. \ No newline at end of file
diff --git a/TODO b/TODO
index 66903dd..f2acbc4 100644
--- a/TODO
+++ b/TODO
@@ -92,7 +92,7 @@ Move ui hover code from ::draw to ::on_event, to properly handle widget event st
Save audio devices by name instead of id. This is more robust since audio id can change(?).
-Improve linux global hotkeys startup time by parsing /proc/bus/input/devices instead of ioctl.
+Improve linux global hotkeys startup time by parsing /proc/bus/input/devices instead of ioctl. <- Do this!
We can get the name of the running steam game without x11 by listing processes and finding the one that runs a program called "reaper" with the arguments SteamLaunch AppId=<number>. The binary comes after the -- argument, get the name of the game by parsing out name from that, in the format steamapps/common/<name>/.
@@ -107,4 +107,8 @@ Keyboard leds get turned off when stopping gsr-global-hotkeys (for example numlo
Implement hotkey changing in global settings by getting mgl key events. During this time gsr-global-hotkey would either need to be paused or add code in the callback handler for the existing hotkeys since they are grabbing hotkeys.
This can only be done after gsr-global-hotkeys properly handle different keyboard layouts to make sure mgl keys match gsr-global-hotkey keys.
-Re-enable hotkey enable/disable section for flatpak. \ No newline at end of file
+Re-enable hotkey disable option for flatpak.
+
+Make gsr-ui flatpak systemd work nicely with non-flatpak gsr-ui. Maybe change ExecStart to do flatpak run ... || gsr-ui, but make it run as a shell command first with /bin/sh -c "".
+
+When enabling X11 global hotkey again only grab lalt, not ralt. \ No newline at end of file
diff --git a/depends/mglpp b/depends/mglpp
-Subproject 3c33f0f8136a8cd3844c9dc087daabf16443fa4
+Subproject 1ce8b2de75f334696bc3b0037160ce3623c46e7
diff --git a/include/WindowUtils.hpp b/include/WindowUtils.hpp
index e647785..d17c0fd 100644
--- a/include/WindowUtils.hpp
+++ b/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);
} \ No newline at end of file
diff --git a/meson.build b/meson.build
index c6b26d7..0409ecc 100644
--- a/meson.build
+++ b/meson.build
@@ -1,4 +1,4 @@
-project('gsr-ui', ['c', 'cpp'], version : '1.0.4', 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'])
diff --git a/project.conf b/project.conf
index 79d965b..13be6d0 100644
--- a/project.conf
+++ b/project.conf
@@ -1,7 +1,7 @@
[package]
name = "gsr-ui"
type = "executable"
-version = "1.0.4"
+version = "1.0.6"
platforms = ["posix"]
[lang.cpp]
diff --git a/src/Overlay.cpp b/src/Overlay.cpp
index dd16243..aa14e3b 100644
--- a/src/Overlay.cpp
+++ b/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,24 +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.window_type = MGL_WINDOW_TYPE_NORMAL;
+ 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 = (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))
@@ -847,20 +762,20 @@ namespace gsr {
mgl_window *win = window->internal_window();
if(win->num_monitors == 0) {
fprintf(stderr, "gsr warning: no monitors found, not showing overlay\n");
+ window.reset();
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;
@@ -1043,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);
diff --git a/src/WindowUtils.cpp b/src/WindowUtils.cpp
index 057e95f..7631e4d 100644
--- a/src/WindowUtils.cpp
+++ b/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;
+ }
} \ No newline at end of file
diff --git a/tools/gsr-global-hotkeys/keyboard_event.c b/tools/gsr-global-hotkeys/keyboard_event.c
index 79e7f17..bcfd616 100644
--- a/tools/gsr-global-hotkeys/keyboard_event.c
+++ b/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;
@@ -165,21 +217,24 @@ static void keyboard_event_process_input_event_data(keyboard_event *self, event_
default: {
const bool shift_pressed = self->lshift_button_state == KEYBOARD_BUTTON_PRESSED || self->rshift_button_state == KEYBOARD_BUTTON_PRESSED;
const bool ctrl_pressed = self->lctrl_button_state == KEYBOARD_BUTTON_PRESSED || self->rctrl_button_state == KEYBOARD_BUTTON_PRESSED;
- const bool alt_pressed = self->lalt_button_state == KEYBOARD_BUTTON_PRESSED || self->ralt_button_state == KEYBOARD_BUTTON_PRESSED;
+ 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)
modifiers |= KEYBOARD_MODKEY_SHIFT;
if(ctrl_pressed)
modifiers |= KEYBOARD_MODKEY_CTRL;
- if(alt_pressed)
- modifiers |= KEYBOARD_MODKEY_ALT;
+ if(lalt_pressed)
+ modifiers |= KEYBOARD_MODKEY_LALT;
+ if(ralt_pressed)
+ modifiers |= KEYBOARD_MODKEY_RALT;
if(meta_pressed)
modifiers |= KEYBOARD_MODKEY_SUPER;
- if(!callback(event.code, modifiers, event.value, userdata))
+ if(!callback(keycode, modifiers, event.value, userdata))
return;
break;
@@ -403,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);
@@ -487,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;
diff --git a/tools/gsr-global-hotkeys/keyboard_event.h b/tools/gsr-global-hotkeys/keyboard_event.h
index 5310aca..9904237 100644
--- a/tools/gsr-global-hotkeys/keyboard_event.h
+++ b/tools/gsr-global-hotkeys/keyboard_event.h
@@ -17,11 +17,32 @@
#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_ALT = 1 << 0,
- KEYBOARD_MODKEY_SUPER = 1 << 1,
- KEYBOARD_MODKEY_CTRL = 1 << 2,
- KEYBOARD_MODKEY_SHIFT = 1 << 3
+ KEYBOARD_MODKEY_LALT = 1 << 0,
+ KEYBOARD_MODKEY_RALT = 1 << 2,
+ KEYBOARD_MODKEY_SUPER = 1 << 3,
+ KEYBOARD_MODKEY_CTRL = 1 << 4,
+ KEYBOARD_MODKEY_SHIFT = 1 << 5
} keyboard_modkeys;
typedef enum {
@@ -51,6 +72,7 @@ typedef struct {
int uinput_fd;
bool stdout_failed;
keyboard_grab_type grab_type;
+ x11_context x_context;
hotplug_event hotplug_ev;
@@ -68,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 */
diff --git a/tools/gsr-global-hotkeys/main.c b/tools/gsr-global-hotkeys/main.c
index 6f057a7..b64d60f 100644
--- a/tools/gsr-global-hotkeys/main.c
+++ b/tools/gsr-global-hotkeys/main.c
@@ -7,6 +7,7 @@
/* POSIX */
#include <unistd.h>
+#include <dlfcn.h>
typedef struct {
uint32_t key;
@@ -16,12 +17,12 @@ typedef struct {
#define NUM_GLOBAL_HOTKEYS 6
static global_hotkey global_hotkeys[NUM_GLOBAL_HOTKEYS] = {
- { .key = KEY_Z, .modifiers = KEYBOARD_MODKEY_ALT, .action = "show_hide" },
- { .key = KEY_F9, .modifiers = KEYBOARD_MODKEY_ALT, .action = "record" },
- { .key = KEY_F7, .modifiers = KEYBOARD_MODKEY_ALT, .action = "pause" },
- { .key = KEY_F8, .modifiers = KEYBOARD_MODKEY_ALT, .action = "stream" },
- { .key = KEY_F10, .modifiers = KEYBOARD_MODKEY_ALT | KEYBOARD_MODKEY_SHIFT, .action = "replay_start" },
- { .key = KEY_F10, .modifiers = KEYBOARD_MODKEY_ALT, .action = "replay_save" }
+ { .key = KEY_Z, .modifiers = KEYBOARD_MODKEY_LALT, .action = "show_hide" },
+ { .key = KEY_F9, .modifiers = KEYBOARD_MODKEY_LALT, .action = "record" },
+ { .key = KEY_F7, .modifiers = KEYBOARD_MODKEY_LALT, .action = "pause" },
+ { .key = KEY_F8, .modifiers = KEYBOARD_MODKEY_LALT, .action = "stream" },
+ { .key = KEY_F10, .modifiers = KEYBOARD_MODKEY_LALT | KEYBOARD_MODKEY_SHIFT, .action = "replay_start" },
+ { .key = KEY_F10, .modifiers = KEYBOARD_MODKEY_LALT, .action = "replay_save" }
};
static bool on_key_callback(uint32_t key, uint32_t modifiers, int press_status, void *userdata) {
@@ -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;
diff --git a/tools/gsr-ui-cli/main.c b/tools/gsr-ui-cli/main.c
index e30867b..bcb5c81 100644
--- a/tools/gsr-ui-cli/main.c
+++ b/tools/gsr-ui-cli/main.c
@@ -50,6 +50,7 @@ static void usage(void) {
printf(" toggle-stream Start/stop streaming.\n");
printf(" toggle-replay Start/stop replay.\n");
printf(" replay-save Save replay.\n");
+ printf("\n");
printf("EXAMPLES:\n");
printf(" gsr-ui-cli toggle-show\n");
printf(" gsr-ui-cli toggle-record\n");
generated by cgit v1.2.3 (git 2.25.1) at 2025-01-08 07:27:40 +0000