1.0.5 - fix ui not visible on some kde plasma wayland systems

README.md

@@ -7,13 +7,15 @@ 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`).\
-If you are running another distro then you can run `sudo ./install.sh`, but you need to manually install the dependencies, as described below.
+If you are running another distro then you can run `sudo ./install.sh`, but you need to manually install the dependencies, as described below.\
+You can also install gpu screen recorder (the gtk gui version) from [flathub](https://flathub.org/apps/details/com.dec05eba.gpu_screen_recorder). This flatpak includes both this UI and gpu-screen-recorder so no need to install that first.
 
 # Dependencies
 GPU Screen Recorder UI uses meson build system so you need to install `meson` to build GPU Screen Recorder UI.
@@ -22,6 +24,7 @@ GPU Screen Recorder UI uses meson build system so you need to install `meson` to
 These are the dependencies needed to build GPU Screen Recorder UI:
 
 * x11 (libx11, libxrandr, libxrender, libxcomposite, libxfixes, libxi)
+* libxcursor
 * libglvnd (which provides libgl, libglx and libegl)
 * linux-api-headers
 
@@ -31,6 +34,12 @@ There are also additional dependencies needed at runtime:
 * [GPU Screen Recorder](https://git.dec05eba.com/gpu-screen-recorder/)
 * [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"
+
 # License
 This software is licensed under GPL3.0-only. Files under `fonts/` directory belong to the Noto Sans Google fonts project and they are licensed under `SIL Open Font License`.
 
@@ -47,5 +56,6 @@ If you want to donate you can donate via bitcoin or monero.
 * Monero: 4An9kp2qW1C9Gah7ewv4JzcNFQ5TAX7ineGCqXWK6vQnhsGGcRpNgcn8r9EC3tMcgY7vqCKs3nSRXhejMHBaGvFdN2egYet
 
 # Known issues
-* Some games receive mouse input while the UI is open
 * 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.

TODO

@@ -1,12 +1,4 @@
-setcap nice for good performance when opening overlay when game is running below 60 fps.
-Maybe grab cursor with xi, as that will prevent games from detecting movement with xi2 api.
-
-Fullscreen on wayland doesn't render windows behind because it's a compositor optimization, to not draw anything behind (only draw the window directly without compositing).
-Fix this by drawing the window smaller, or have two windows (left and right half monitor width).
-Maybe change design to have black triangles appear and get larger until they fill the screen, with even spaces being left with no triangles.
-    Exclude triangles from a diagonal line across the screen.
-    Have buttons appear slanted in 3D.
-    All of these things should be done with vertex buffer, for real 3D.
+setcap nice for good performance when opening overlay when game is running below 60 fps (on amd).
 
 WAYLAND_DISPLAY gamescope-0, DISPLAY=:1 (gamescope xwayland)
 
@@ -47,7 +39,7 @@ Add global setting. In that setting there should be an option to enable/disable
 
 Add profiles and hotkey to switch between profiles (show notification when switching profile).
 
-Fix first frame being black.
+Fix first frame being black when running without a compositor.
 
 Add support for systray.
 
@@ -70,24 +62,17 @@ On nvidia check if suspend fix is applied. If not, show a popup asking the user
 
 Show warning when using steam deck or when trying to capture hevc/av1 on amd (the same warnings as gpu screen recorder gtk).
 
-Add option to capture application audio. This should show a popup where you can use one of the available applications or a custom one and choose to record that application or all applications except that one.
-
 Add profile option. Convert view to profile, add an option at the bottom that says "Edit profiles..." which should show a popup where you can create/remove profiles. New profiles should always be in advanced view.
 
 Verify monitor/audio when starting recording. Give an error if the options are no longer valid.
 
-Get focused window when opening gsr-ui and pass that to the save replay script, to ignore gsr-ui when getting game name.
-
-gsr ui window has _NET_WM_STATE _NET_WM_STATE_ABOVE, not _NET_WM_STATE_FULLSCREEN
+gsr ui window has _NET_WM_STATE _NET_WM_STATE_ABOVE, not _NET_WM_STATE_FULLSCREEN.
 
 For replay on fullscreen detect focused fullscreen window by checking if the window size is the same as the monitor size instead of _NET_WM_STATE_FULLSCREEN.
 
-Add audio devices/app refresh button.
-
 Play camera shutter sound when saving recording. When another sound when starting recording.
 
 Some games such as "The Finals" crashes/freezes when they lose focus when running them on x11 on a laptop with prime setup and the monitor runs on the iGPU while the game runs on the dGPU.
-Try to reproduce this and if it happens try grab cursor and keyboard instead of setting gsr ui focus and make gsr ui click through like gsr notify. This might fix the issue.
 
 Run `systemctl status --user gpu-screen-recorder` when starting recording and give a notification warning if it returns 0 (running). Or run pidof gpu-screen-recorder.
 
@@ -95,8 +80,6 @@ Add option to select which gpu to record with, or list all monitors and automati
 
 Test global hotkeys with azerty instead of qwerty.
 
-Fix cursor grab not working in owlboy, need to use xigrab.
-
 Dont allow autostart of replay if capture option is window recording (when window recording is added).
 
 Use global shortcuts desktop portal protocol on wayland when available.
@@ -109,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>/.
 
@@ -117,6 +100,15 @@ All steam game names by ID are available at https://api.steampowered.com/ISteamA
 
 Dont put widget position to int position when scrolling. This makes the UI jitter when it's coming to a halt.
 
-Show a popup asking if the user wants to add the program to system startup when launching the program, with a dismiss option and "Do not show again".
+Show warning if another instance of gpu screen recorder is already running when starting recording?
 
-Show warning if another instance of gpu screen recorder is already running when starting recording?
+Keyboard leds get turned off when stopping gsr-global-hotkeys (for example numlock). The numlock key has to be pressed twice again to make it look correct to match its state.
+
+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 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.

include/Config.hpp

@@ -25,7 +25,7 @@ namespace gsr {
         int32_t video_height = 0;
         int32_t fps = 60;
         int32_t video_bitrate = 15000;
-        bool merge_audio_tracks = true;
+        bool merge_audio_tracks = true; // Currently unused for streaming because all known streaming sites only support 1 audio track
         bool application_audio_invert = false;
         bool change_video_resolution = false;
         std::vector<std::string> audio_tracks;
@@ -43,6 +43,7 @@ namespace gsr {
     struct MainConfig {
         int32_t config_file_version = 0;
         bool software_encoding_warning_shown = false;
+        std::string hotkeys_enable_option = "enable_hotkeys";
         std::string tint_color;
     };
 

include/GlobalHotkeysLinux.hpp

@@ -7,7 +7,12 @@
 namespace gsr {
     class GlobalHotkeysLinux : public GlobalHotkeys {
     public:
-        GlobalHotkeysLinux();
+        enum class GrabType {
+            ALL,
+            VIRTUAL
+        };
+
+        GlobalHotkeysLinux(GrabType grab_type);
         GlobalHotkeysLinux(const GlobalHotkeysLinux&) = delete;
         GlobalHotkeysLinux& operator=(const GlobalHotkeysLinux&) = delete;
         ~GlobalHotkeysLinux() override;
@@ -20,5 +25,6 @@ namespace gsr {
         int pipes[2];
         FILE *read_file = nullptr;
         std::unordered_map<std::string, GlobalHotkeyCallback> bound_actions_by_id;
+        GrabType grab_type;
     };
 }

include/Overlay.hpp

@@ -58,6 +58,8 @@ namespace gsr {
         bool is_open() const;
         bool should_exit(std::string &reason) const;
         void exit();
+
+        const Config& get_config() const;
     private:
         void xi_setup();
         void handle_xi_events();
@@ -65,7 +67,6 @@ namespace gsr {
         void grab_mouse_and_keyboard();
         void xi_setup_fake_cursor();
         void xi_grab_all_devices();
-        void xi_warp_pointer(mgl::vec2i position);
 
         void close_gpu_screen_recorder_output();
 
@@ -124,7 +125,6 @@ namespace gsr {
         mgl::Texture cursor_texture;
         mgl::Sprite cursor_sprite;
         mgl::vec2i cursor_hotspot;
-        bool cursor_drawn = false;
 
         WindowTexture window_texture;
         PageStack page_stack;
@@ -166,5 +166,8 @@ namespace gsr {
 
         bool do_exit = false;
         std::string exit_reason;
+
+        mgl::vec2i window_size = { 1280, 720 };
+        mgl::vec2i window_pos = { 0, 0 };
     };
 }

include/Process.hpp

@@ -21,5 +21,5 @@ namespace gsr {
     // This works the same as |exec_program_get_stdout|, except on flatpak where this runs the program on the
     // host machine with flatpak-spawn --host
     int exec_program_on_host_get_stdout(const char **args, std::string &result);
-    pid_t pidof(const char *process_name);
+    pid_t pidof(const char *process_name, pid_t ignore_pid);
 }

include/Rpc.hpp

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <stddef.h>
+#include <functional>
+#include <unordered_map>
+#include <string>
+
+typedef struct _IO_FILE FILE;
+
+namespace gsr {
+    using RpcCallback = std::function<void(const std::string &name)>;
+
+    class Rpc {
+    public:
+        Rpc() = default;
+        Rpc(const Rpc&) = delete;
+        Rpc& operator=(const Rpc&) = delete;
+        ~Rpc();
+
+        bool create(const char *name);
+        bool open(const char *name);
+        bool write(const char *str, size_t size);
+        void poll();
+
+        bool add_handler(const std::string &name, RpcCallback callback);
+    private:
+        bool open_filepath(const char *filepath);
+    private:
+        int fd = 0;
+        FILE *file = nullptr;
+        std::string fifo_filepath;
+        std::unordered_map<std::string, RpcCallback> handlers_by_name;
+    };
+}

include/gui/GlobalSettingsPage.hpp

@@ -31,6 +31,7 @@ namespace gsr {
     private:
         std::unique_ptr<Subsection> create_appearance_subsection(ScrollablePage *parent_page);
         std::unique_ptr<Subsection> create_startup_subsection(ScrollablePage *parent_page);
+        std::unique_ptr<Subsection> create_hotkey_subsection(ScrollablePage *parent_page);
         std::unique_ptr<Button> create_exit_program_button();
         std::unique_ptr<Button> create_go_back_to_old_ui_button();
         std::unique_ptr<Subsection> create_application_options_subsection(ScrollablePage *parent_page);
@@ -43,5 +44,6 @@ namespace gsr {
         PageStack *page_stack = nullptr;
         RadioButton *tint_color_radio_button_ptr = nullptr;
         RadioButton *startup_radio_button_ptr = nullptr;
+        RadioButton *enable_hotkeys_radio_button_ptr = nullptr;
     };
 }

include/gui/RadioButton.hpp

@@ -27,7 +27,8 @@ namespace gsr {
 
         mgl::vec2f get_size() override;
 
-        std::function<void(const std::string &text, const std::string &id)> on_selection_changed;
+        // Return false to revert the change
+        std::function<bool(const std::string &text, const std::string &id)> on_selection_changed;
     private:
         void update_if_dirty();
     private:

include/gui/SettingsPage.hpp

@@ -69,7 +69,7 @@ namespace gsr {
         std::unique_ptr<Widget> create_audio_track_section();
         std::unique_ptr<Widget> create_audio_section();
         std::unique_ptr<List> create_video_quality_box();
-        std::unique_ptr<Entry> create_video_bitrate_entry();
+        std::unique_ptr<List> create_video_bitrate_entry();
         std::unique_ptr<List> create_video_bitrate();
         std::unique_ptr<ComboBox> create_color_range_box();
         std::unique_ptr<List> create_color_range();
@@ -97,9 +97,11 @@ namespace gsr {
         std::unique_ptr<List> create_replay_time();
         std::unique_ptr<RadioButton> create_start_replay_automatically();
         std::unique_ptr<CheckBox> create_save_replay_in_game_folder();
-        std::unique_ptr<Label> create_estimated_file_size();
-        void update_estimated_file_size();
+        std::unique_ptr<Label> create_estimated_replay_file_size();
+        void update_estimated_replay_file_size();
         std::unique_ptr<CheckBox> create_save_recording_in_game_folder();
+        std::unique_ptr<Label> create_estimated_record_file_size();
+        void update_estimated_record_file_size();
         void add_replay_widgets();
         void add_record_widgets();
 

meson.build

@@ -1,4 +1,4 @@
-project('gsr-ui', ['c', 'cpp'], version : '1.0.0', default_options : ['warning_level=2', 'cpp_std=c++17'], subproject_dir : 'depends')
+project('gsr-ui', ['c', 'cpp'], version : '1.0.5', default_options : ['warning_level=2', 'cpp_std=c++17'], subproject_dir : 'depends')
 
 if get_option('buildtype') == 'debug'
     add_project_arguments('-g3', language : ['c', 'cpp'])
@@ -38,6 +38,7 @@ src = [
     'src/Overlay.cpp',
     'src/GlobalHotkeysX11.cpp',
     'src/GlobalHotkeysLinux.cpp',
+    'src/Rpc.cpp',
     'src/main.cpp',
 ]
 
@@ -57,6 +58,7 @@ executable(
         dependency('xcomposite'),
         dependency('xfixes'),
         dependency('xi'),
+        dependency('xcursor'),
     ],
     cpp_args : '-DGSR_UI_RESOURCES_PATH="' + gsr_ui_resources_path + '"',
 )
@@ -72,6 +74,14 @@ executable(
     install : true
 )
 
+executable(
+    'gsr-ui-cli',
+    [
+        'tools/gsr-ui-cli/main.c'
+    ],
+    install : true
+)
+
 install_subdir('images', install_dir : gsr_ui_resources_path)
 install_subdir('fonts', install_dir : gsr_ui_resources_path)
 

project.conf

@@ -1,7 +1,7 @@
 [package]
 name = "gsr-ui"
 type = "executable"
-version = "1.0.0"
+version = "1.0.5"
 platforms = ["posix"]
 
 [lang.cpp]
@@ -13,4 +13,5 @@ ignore_dirs = ["build", "tools"]
 [dependencies]
 xcomposite = ">=0"
 xfixes = ">=0"
-xi = ">=0"
+xi = ">=0"
+xcursor = ">=1"

src/Config.cpp

@@ -58,6 +58,7 @@ namespace gsr {
         return {
             {"main.config_file_version", &config.main_config.config_file_version},
             {"main.software_encoding_warning_shown", &config.main_config.software_encoding_warning_shown},
+            {"main.hotkeys_enable_option", &config.main_config.hotkeys_enable_option},
             {"main.tint_color", &config.main_config.tint_color},
 
             {"streaming.record_options.record_area_option", &config.streaming_config.record_options.record_area_option},

src/GlobalHotkeysLinux.cpp

@@ -9,7 +9,15 @@
 #define PIPE_WRITE 1
 
 namespace gsr {
-    GlobalHotkeysLinux::GlobalHotkeysLinux() {
+    static const char* grab_type_to_arg(GlobalHotkeysLinux::GrabType grab_type) {
+        switch(grab_type) {
+            case GlobalHotkeysLinux::GrabType::ALL:     return "--all";
+            case GlobalHotkeysLinux::GrabType::VIRTUAL: return "--virtual";
+        }
+        return "--all";
+    }
+
+    GlobalHotkeysLinux::GlobalHotkeysLinux(GrabType grab_type) : grab_type(grab_type) {
         for(int i = 0; i < 2; ++i) {
             pipes[i] = -1;
         }
@@ -32,6 +40,7 @@ namespace gsr {
     }
 
     bool GlobalHotkeysLinux::start() {
+        const char *grab_type_arg = grab_type_to_arg(grab_type);
         const bool inside_flatpak = getenv("FLATPAK_ID") != NULL;
         const char *user_homepath = getenv("HOME");
         if(!user_homepath)
@@ -61,14 +70,14 @@ namespace gsr {
             }
 
             if(inside_flatpak) {
-                const char *args[] = { "flatpak-spawn", "--host", "--", gsr_global_hotkeys_flatpak, NULL };
+                const char *args[] = { "flatpak-spawn", "--host", "--", gsr_global_hotkeys_flatpak, grab_type_arg, nullptr };
                 execvp(args[0], (char* const*)args);
             } else {
-                const char *args[] = { "gsr-global-hotkeys", NULL };
+                const char *args[] = { "gsr-global-hotkeys", grab_type_arg, nullptr };
                 execvp(args[0], (char* const*)args);
             }
 
-            perror("execvp");
+            perror("gsr-global-hotkeys");
             _exit(127);
         } else { /* parent */
             process_id = pid;
@@ -89,7 +98,7 @@ namespace gsr {
     }
 
     bool GlobalHotkeysLinux::bind_action(const std::string &id, GlobalHotkeyCallback callback) {
-        return bound_actions_by_id.insert(std::make_pair(id, callback)).second;
+        return bound_actions_by_id.insert(std::make_pair(id, std::move(callback))).second;
     }
 
     void GlobalHotkeysLinux::poll_events() {
@@ -103,20 +112,23 @@ namespace gsr {
             return;
         }
 
+        std::string action;
         char buffer[256];
         while(true) {
             char *line = fgets(buffer, sizeof(buffer), read_file);
             if(!line)
                 break;
 
-            const int line_len = strlen(line);
+            int line_len = strlen(line);
             if(line_len == 0)
                 continue;
 
-            if(line[line_len - 1] == '\n')
+            if(line[line_len - 1] == '\n') {
                 line[line_len - 1] = '\0';
+                --line_len;
+            }
 
-            const std::string action = line;
+            action = line;
             auto it = bound_actions_by_id.find(action);
             if(it != bound_actions_by_id.end())
                 it->second(action);

src/Overlay.cpp

@@ -29,6 +29,7 @@
 #include <X11/extensions/Xfixes.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/extensions/shape.h>
+#include <X11/Xcursor/Xcursor.h>
 #include <mglpp/system/Rect.hpp>
 #include <mglpp/window/Event.hpp>
 
@@ -45,6 +46,15 @@ namespace gsr {
         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:
@@ -70,17 +80,17 @@ namespace gsr {
         return texture;
     }
 
-    static bool texture_from_x11_cursor(XFixesCursorImage *x11_cursor_image, bool *visible, mgl::vec2i *hotspot, mgl::Texture &texture) {
+    static bool texture_from_x11_cursor(XcursorImage *x11_cursor_image, bool *visible, mgl::vec2i *hotspot, mgl::Texture &texture) {
         uint8_t *cursor_data = NULL;
         uint8_t *out = NULL;
-        const unsigned long *pixels = NULL;
+        const unsigned int *pixels = NULL;
         *visible = false;
 
         if(!x11_cursor_image)
-            goto err;
+            return false;
 
         if(!x11_cursor_image->pixels)
-            goto err;
+            return false;
 
         hotspot->x = x11_cursor_image->xhot;
         hotspot->y = x11_cursor_image->yhot;
@@ -88,12 +98,12 @@ namespace gsr {
         pixels = x11_cursor_image->pixels;
         cursor_data = (uint8_t*)malloc((int)x11_cursor_image->width * (int)x11_cursor_image->height * 4);
         if(!cursor_data)
-            goto err;
+            return false;
 
         out = cursor_data;
         /* Un-premultiply alpha */
-        for(int y = 0; y < x11_cursor_image->height; ++y) {
-            for(int x = 0; x < x11_cursor_image->width; ++x) {
+        for(uint32_t y = 0; y < x11_cursor_image->height; ++y) {
+            for(uint32_t x = 0; x < x11_cursor_image->width; ++x) {
                 uint32_t pixel = *pixels++;
                 uint8_t *in = (uint8_t*)&pixel;
                 uint8_t alpha = in[3];
@@ -114,13 +124,7 @@ namespace gsr {
 
         texture.load_from_memory(cursor_data, x11_cursor_image->width, x11_cursor_image->height, MGL_IMAGE_FORMAT_RGBA);
         free(cursor_data);
-        XFree(x11_cursor_image);
         return true;
-
-        err:
-        if(x11_cursor_image)
-            XFree(x11_cursor_image);
-        return false;
     }
 
     static char hex_value_to_str(uint8_t v) {
@@ -299,6 +303,16 @@ 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;
@@ -431,9 +445,6 @@ namespace gsr {
         top_bar_background({0.0f, 0.0f}),
         close_button_widget({0.0f, 0.0f})
     {
-        // TODO:
-        //xi_setup();
-
         key_bindings[0].key_event.code = mgl::Keyboard::Escape;
         key_bindings[0].key_event.alt = false;
         key_bindings[0].key_event.control = false;
@@ -470,8 +481,6 @@ namespace gsr {
             notification_process = -1;
         }
 
-        close_gpu_screen_recorder_output();
-
         if(gpu_screen_recorder_process > 0) {
             kill(gpu_screen_recorder_process, SIGINT);
             int status;
@@ -482,10 +491,8 @@ namespace gsr {
             gpu_screen_recorder_process = -1;
         }
 
-        free(xi_input_xev);
-        free(xi_output_xev);
-        if(xi_display)
-            XCloseDisplay(xi_display);
+        close_gpu_screen_recorder_output();
+        deinit_color_theme();
     }
 
     void Overlay::xi_setup() {
@@ -509,6 +516,7 @@ namespace gsr {
         unsigned char mask[XIMaskLen(XI_LASTEVENT)];
         memset(mask, 0, sizeof(mask));
         XISetMask(mask, XI_Motion);
+        //XISetMask(mask, XI_RawMotion);
         XISetMask(mask, XI_ButtonPress);
         XISetMask(mask, XI_ButtonRelease);
         XISetMask(mask, XI_KeyPress);
@@ -567,8 +575,8 @@ namespace gsr {
                     xi_output_xev->xmotion.display = display;
                     xi_output_xev->xmotion.window = window->get_system_handle();
                     xi_output_xev->xmotion.subwindow = window->get_system_handle();
-                    xi_output_xev->xmotion.x = de->event_x;
-                    xi_output_xev->xmotion.y = de->event_y;
+                    xi_output_xev->xmotion.x = de->root_x - window_pos.x;
+                    xi_output_xev->xmotion.y = de->root_y - window_pos.y;
                     xi_output_xev->xmotion.x_root = de->root_x;
                     xi_output_xev->xmotion.y_root = de->root_y;
                     //xi_output_xev->xmotion.state = // modifiers // TODO:
@@ -580,8 +588,8 @@ namespace gsr {
                     xi_output_xev->xbutton.display = display;
                     xi_output_xev->xbutton.window = window->get_system_handle();
                     xi_output_xev->xbutton.subwindow = window->get_system_handle();
-                    xi_output_xev->xbutton.x = de->event_x;
-                    xi_output_xev->xbutton.y = de->event_y;
+                    xi_output_xev->xbutton.x = de->root_x - window_pos.x;
+                    xi_output_xev->xbutton.y = de->root_y - window_pos.y;
                     xi_output_xev->xbutton.x_root = de->root_x;
                     xi_output_xev->xbutton.y_root = de->root_y;
                     //xi_output_xev->xbutton.state = // modifiers // TODO:
@@ -594,8 +602,8 @@ namespace gsr {
                     xi_output_xev->xkey.display = display;
                     xi_output_xev->xkey.window = window->get_system_handle();
                     xi_output_xev->xkey.subwindow = window->get_system_handle();
-                    xi_output_xev->xkey.x = de->event_x;
-                    xi_output_xev->xkey.y = de->event_y;
+                    xi_output_xev->xkey.x = de->root_x - window_pos.x;
+                    xi_output_xev->xkey.y = de->root_y - window_pos.y;
                     xi_output_xev->xkey.x_root = de->root_x;
                     xi_output_xev->xkey.y_root = de->root_y;
                     xi_output_xev->xkey.state = de->mods.effective;
@@ -694,12 +702,6 @@ namespace gsr {
         page_stack.draw(*window, mgl::vec2f(0.0f, 0.0f));
 
         if(cursor_texture.is_valid()) {
-            if(!cursor_drawn) {
-                cursor_drawn = true;
-                XFixesHideCursor(xi_display, DefaultRootWindow(xi_display));
-                XFlush(xi_display);
-            }
-
             cursor_sprite.set_position((window->get_mouse_position() - cursor_hotspot).to_vec2f());
             window->draw(cursor_sprite);
         }
@@ -737,13 +739,32 @@ namespace gsr {
         if(!xi_display)
             return;
 
-        XFixesShowCursor(xi_display, DefaultRootWindow(xi_display));
+        XFixesHideCursor(xi_display, DefaultRootWindow(xi_display));
         XFlush(xi_display);
 
+        // TODO: XCURSOR_SIZE and XCURSOR_THEME environment variables
+        const char *cursor_theme = XcursorGetTheme(xi_display);
+        if(!cursor_theme) {
+            //fprintf(stderr, "Warning: failed to get cursor theme, using \"default\" theme instead\n");
+            cursor_theme = "default";
+        }
+
+        int cursor_size = XcursorGetDefaultSize(xi_display);
+        if(cursor_size <= 1)
+            cursor_size = 24;
+
+        XcursorImage *cursor_image = XcursorShapeLoadImage(XC_left_ptr, cursor_theme, cursor_size);
+        if(!cursor_image) {
+            fprintf(stderr, "Error: failed to get cursor\n");
+            return;
+        }
+
         bool cursor_visible = false;
-        texture_from_x11_cursor(XFixesGetCursorImage(xi_display), &cursor_visible, &cursor_hotspot, cursor_texture);
+        texture_from_x11_cursor(cursor_image, &cursor_visible, &cursor_hotspot, cursor_texture);
         if(cursor_texture.is_valid())
             cursor_sprite.set_texture(&cursor_texture);
+
+        XcursorImageDestroy(cursor_image);
     }
 
     void Overlay::xi_grab_all_devices() {
@@ -755,38 +776,22 @@ namespace gsr {
         if(!info)
             return;
 
-        for (int i = 0; i < num_devices; ++i) {
-            const XIDeviceInfo *dev = &info[i];
-            XIEventMask masks[1];
-            unsigned char mask0[XIMaskLen(XI_LASTEVENT)];
-            memset(mask0, 0, sizeof(mask0));
-            XISetMask(mask0, XI_Motion);
-            XISetMask(mask0, XI_ButtonPress);
-            XISetMask(mask0, XI_ButtonRelease);
-            XISetMask(mask0, XI_KeyPress);
-            XISetMask(mask0, XI_KeyRelease);
-            masks[0].deviceid = dev->deviceid;
-            masks[0].mask_len = sizeof(mask0);
-            masks[0].mask = mask0;
-            XIGrabDevice(xi_display, dev->deviceid, window->get_system_handle(), CurrentTime, None, XIGrabModeAsync, XIGrabModeAsync, XIOwnerEvents, masks);
-        }
-
-        XFlush(xi_display);
-        XIFreeDeviceInfo(info);
-    }
-
-    void Overlay::xi_warp_pointer(mgl::vec2i position) {
-        if(!xi_display)
-            return;
-
-        int num_devices = 0;
-        XIDeviceInfo *info = XIQueryDevice(xi_display, XIAllDevices, &num_devices);
-        if(!info)
-            return;
+        unsigned char mask[XIMaskLen(XI_LASTEVENT)];
+        memset(mask, 0, sizeof(mask));
+        XISetMask(mask, XI_Motion);
+        //XISetMask(mask, XI_RawMotion);
+        XISetMask(mask, XI_ButtonPress);
+        XISetMask(mask, XI_ButtonRelease);
+        XISetMask(mask, XI_KeyPress);
+        XISetMask(mask, XI_KeyRelease);
 
         for (int i = 0; i < num_devices; ++i) {
             const XIDeviceInfo *dev = &info[i];
-            XIWarpPointer(xi_display, dev->deviceid, DefaultRootWindow(xi_display), DefaultRootWindow(xi_display), 0, 0, 0, 0, position.x, position.y);
+            XIEventMask xi_masks;
+            xi_masks.deviceid = dev->deviceid;
+            xi_masks.mask_len = sizeof(mask);
+            xi_masks.mask = mask;
+            XIGrabDevice(xi_display, dev->deviceid, window->get_system_handle(), CurrentTime, None, XIGrabModeAsync, XIGrabModeAsync, XIOwnerEvents, &xi_masks);
         }
 
         XFlush(xi_display);
@@ -810,8 +815,8 @@ namespace gsr {
         // a fullscreen window for the ui.
         const bool prevent_game_minimizing = gsr_info.system_info.display_server != DisplayServer::WAYLAND || !is_focused_application_wayland(display);
 
-        mgl::vec2i window_size = { 1280, 720 };
-        mgl::vec2i window_pos = { 0, 0 };
+        window_size = { 1280, 720 };
+        window_pos = { 0, 0 };
 
         mgl::Window::CreateParams window_create_params;
         window_create_params.size = window_size;
@@ -822,7 +827,9 @@ namespace gsr {
         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;
+        // 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.render_api = MGL_RENDER_API_EGL;
 
         if(!window->create("gsr ui", window_create_params))
@@ -842,11 +849,13 @@ 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 monitor_position_query_value = gsr_info.system_info.display_server == DisplayServer::WAYLAND ? create_window_get_center_position(display) : mgl::vec2i(win->cursor_position.x, win->cursor_position.y);
+        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};
@@ -856,6 +865,9 @@ namespace gsr {
         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;
+
         update_compositor_texture(focused_monitor);
 
         top_bar_text = mgl::Text("GPU Screen Recorder", get_theme().top_bar_font);
@@ -1032,6 +1044,11 @@ namespace gsr {
             return true;
         };
 
+        // 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))
+            xi_setup();
+
         //window->set_fullscreen(true);
         if(gsr_info.system_info.display_server == DisplayServer::X11)
             make_window_click_through(display, window->get_system_handle());
@@ -1045,7 +1062,7 @@ namespace gsr {
             XFreeCursor(display, default_cursor);
             default_cursor = 0;
         }
-        default_cursor = XCreateFontCursor(display, XC_arrow);
+        default_cursor = XCreateFontCursor(display, XC_left_ptr);
         XFlush(display);
 
         grab_mouse_and_keyboard();
@@ -1107,10 +1124,6 @@ namespace gsr {
         XFlush(display);
 
         if(xi_display) {
-            // TODO: Only show cursor if it wasn't hidden before the ui was shown
-            cursor_drawn = false;
-            //XFixesShowCursor(xi_display, DefaultRootWindow(xi_display));
-            //XFlush(xi_display);
             cursor_texture.clear();
             cursor_sprite.set_texture(nullptr);
         }
@@ -1123,29 +1136,45 @@ namespace gsr {
         visible = false;
         drawn_first_frame = false;
 
-        if(window) {
-            const mgl::vec2i new_cursor_position = mgl::vec2i(window->internal_window()->pos.x, window->internal_window()->pos.y) + window->get_mouse_position();
-            window->set_visible(false);
-            window.reset();
+        if(xi_input_xev) {
+            free(xi_input_xev);
+            xi_input_xev = nullptr;
+        }
 
-            if(xi_display) {
-                XFlush(display);
+        if(xi_output_xev) {
+            free(xi_output_xev);
+            xi_output_xev = nullptr;
+        }
+
+        if(xi_display) {
+            XCloseDisplay(xi_display);
+            xi_display = nullptr;
+
+            if(window) {
+                mgl_context *context = mgl_get_context();
+                Display *display = (Display*)context->connection;
+
+                const mgl::vec2i new_cursor_position = mgl::vec2i(window->internal_window()->pos.x, window->internal_window()->pos.y) + window->get_mouse_position();
                 XWarpPointer(display, DefaultRootWindow(display), DefaultRootWindow(display), 0, 0, 0, 0, new_cursor_position.x, new_cursor_position.y);
                 XFlush(display);
-                //xi_warp_pointer(new_cursor_position);
 
-                XFixesShowCursor(xi_display, DefaultRootWindow(xi_display));
-                XFlush(xi_display);
+                XFixesShowCursor(display, DefaultRootWindow(display));
+                XFlush(display);
             }
         }
 
+        if(window) {
+            window->set_visible(false);
+            window.reset();
+        }
+
         deinit_theme();
     }
 
     void Overlay::toggle_show() {
         if(visible) {
             //hide();
-            // We dont want to hide immediately because hide is called in event callback, in which it destroys the window.
+            // We dont want to hide immediately because hide is called in mgl event callback, in which it destroys the mgl window.
             // Instead remove all pages and wait until next iteration to close the UI (which happens when there are no pages to render).
             while(!page_stack.empty()) {
                 page_stack.pop();
@@ -1211,7 +1240,7 @@ namespace gsr {
         const char *notification_type_str = notification_type_to_string(notification_type);
         if(notification_type_str) {
             notification_args[9] = "--icon";
-            notification_args[10] = "record",
+            notification_args[10] = notification_type_str;
             notification_args[11] = nullptr;
         } else {
             notification_args[9] = nullptr;
@@ -1241,6 +1270,10 @@ namespace gsr {
         do_exit = true;
     }
 
+    const Config& Overlay::get_config() const {
+        return config;
+    }
+
     void Overlay::update_notification_process_status() {
         if(notification_process <= 0)
             return;
@@ -1306,12 +1339,18 @@ namespace gsr {
         truncate_string(focused_window_name, 20);
         std::string text;
         switch(notification_type) {
-            case NotificationType::RECORD:
+            case NotificationType::RECORD: {
+                if(!config.record_config.show_video_saved_notifications)
+                    return;
                 text = "Saved recording to '" + focused_window_name + "/" + video_filename + "'";
                 break;
-            case NotificationType::REPLAY:
+            }
+            case NotificationType::REPLAY: {
+                if(!config.replay_config.show_replay_saved_notifications)
+                    return;
                 text = "Saved replay to '" + focused_window_name + "/" + video_filename + "'";
                 break;
+            }
             case NotificationType::NONE:
             case NotificationType::STREAM:
                 break;
@@ -1973,11 +2012,11 @@ namespace gsr {
             "-fm", framerate_mode.c_str(),
             "-encoder", encoder,
             "-f", fps.c_str(),
-            "-f", fps.c_str(),
             "-v", "no",
             "-o", url.c_str()
         };
 
+        config.streaming_config.record_options.merge_audio_tracks = true;
         add_common_gpu_screen_recorder_args(args, config.streaming_config.record_options, audio_tracks, video_bitrate, region, audio_tracks_merged);
 
         args.push_back(nullptr);
@@ -2016,8 +2055,10 @@ namespace gsr {
             return false;
 
         bool window_texture_loaded = false;
-        const Window focused_window = get_focused_window(display, WindowCaptureType::FOCUSED);
-        if(is_window_fullscreen_on_monitor(display, focused_window, monitor) && focused_window)
+        Window focused_window = get_focused_window(display, WindowCaptureType::CURSOR);
+        if(!focused_window)
+            focused_window = get_focused_window(display, WindowCaptureType::FOCUSED);
+        if(focused_window && is_window_fullscreen_on_monitor(display, focused_window, monitor))
             window_texture_loaded = window_texture_init(&window_texture, display, mgl_window_get_egl_display(window->internal_window()), focused_window, egl_funcs) == 0;
 
         if(window_texture_loaded && window_texture.texture_id) {

src/Process.cpp

@@ -59,7 +59,7 @@ namespace gsr {
             const pid_t second_child = vfork();
             if(second_child == 0) { // child
                 execvp(args[0], (char* const*)args);
-                perror("execvp");
+                perror(args[0]);
                 _exit(127);
             } else if(second_child != -1) {
                 // TODO:
@@ -98,7 +98,7 @@ namespace gsr {
             close(fds[PIPE_WRITE]);
 
             execvp(args[0], (char* const*)args);
-            perror("execvp");
+            perror(args[0]);
             _exit(127);
         } else { /* parent */
             close(fds[PIPE_WRITE]);
@@ -206,7 +206,7 @@ namespace gsr {
         return false;
     }
 
-    pid_t pidof(const char *process_name) {
+    pid_t pidof(const char *process_name, pid_t ignore_pid) {
         pid_t result = -1;
         DIR *dir = opendir("/proc");
         if(!dir)
@@ -222,8 +222,11 @@ namespace gsr {
 
             snprintf(cmdline_filepath, sizeof(cmdline_filepath), "/proc/%s/cmdline", entry->d_name);
             if(read_cmdline_arg0(cmdline_filepath, arg0, sizeof(arg0)) && strcmp(process_name, arg0) == 0) {
-                result = atoi(entry->d_name);
-                break;
+                const pid_t pid = atoi(entry->d_name);
+                if(pid != ignore_pid) {
+                    result = pid;
+                    break;
+                }
             }
         }
 

src/Rpc.cpp

@@ -0,0 +1,133 @@
+#include "../include/Rpc.hpp"
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <limits.h>
+#include <string.h>
+#include <errno.h>
+#include <sys/stat.h>
+#include <sys/fcntl.h>
+
+namespace gsr {
+    static void get_runtime_filepath(char *buffer, size_t buffer_size, const char *filename) {
+        char dir[PATH_MAX];
+
+        const char *runtime_dir = getenv("XDG_RUNTIME_DIR");
+        if(runtime_dir)
+            snprintf(dir, sizeof(dir), "%s", runtime_dir);
+        else
+            snprintf(dir, sizeof(dir), "/run/user/%d", geteuid());
+
+        if(access(dir, F_OK) != 0)
+            snprintf(dir, sizeof(dir), "/tmp");
+
+        snprintf(buffer, buffer_size, "%s/%s", dir, filename);
+    }
+
+    Rpc::~Rpc() {
+        if(fd > 0)
+            close(fd);
+
+        if(file)
+            fclose(file);
+
+        if(!fifo_filepath.empty())
+            remove(fifo_filepath.c_str());
+    }
+
+    bool Rpc::create(const char *name) {
+        if(file) {
+            fprintf(stderr, "Error: Rpc::create: already created/opened\n");
+            return false;
+        }
+
+        char fifo_filepath_tmp[PATH_MAX];
+        get_runtime_filepath(fifo_filepath_tmp, sizeof(fifo_filepath_tmp), name);
+        fifo_filepath = fifo_filepath_tmp;
+        remove(fifo_filepath.c_str());
+
+        if(mkfifo(fifo_filepath.c_str(), 0600) != 0) {
+            fprintf(stderr, "Error: mkfifo failed, error: %s, %s\n", strerror(errno), fifo_filepath.c_str());
+            return false;
+        }
+
+        if(!open_filepath(fifo_filepath.c_str())) {
+            remove(fifo_filepath.c_str());
+            fifo_filepath.clear();
+            return false;
+        }
+
+        return true;
+    }
+
+    bool Rpc::open(const char *name) {
+        if(file) {
+            fprintf(stderr, "Error: Rpc::open: already created/opened\n");
+            return false;
+        }
+
+        char fifo_filepath_tmp[PATH_MAX];
+        get_runtime_filepath(fifo_filepath_tmp, sizeof(fifo_filepath_tmp), name);
+        return open_filepath(fifo_filepath_tmp);
+    }
+
+    bool Rpc::open_filepath(const char *filepath) {
+        fd = ::open(filepath, O_RDWR | O_NONBLOCK);
+        if(fd <= 0)
+            return false;
+
+        file = fdopen(fd, "r+");
+        if(!file) {
+            close(fd);
+            fd = 0;
+            return false;
+        }
+        fd = 0;
+        return true;
+    }
+
+    bool Rpc::write(const char *str, size_t size) {
+        if(!file) {
+            fprintf(stderr, "Error: Rpc::write: fifo not created/opened yet\n");
+            return false;
+        }
+
+        ssize_t offset = 0;
+        while(offset < (ssize_t)size) {
+            const ssize_t bytes_written = fwrite(str + offset, 1, size - offset, file);
+            fflush(file);
+            if(bytes_written > 0)
+                offset += bytes_written;
+        }
+        return true;
+    }
+
+    void Rpc::poll() {
+        if(!file) {
+            //fprintf(stderr, "Error: Rpc::poll: fifo not created/opened yet\n");
+            return;
+        }
+
+        std::string name;
+        char line[1024];
+        while(fgets(line, sizeof(line), file)) {
+            int line_len = strlen(line);
+            if(line_len == 0)
+                continue;
+
+            if(line[line_len - 1] == '\n') {
+                line[line_len - 1] = '\0';
+                --line_len;
+            }
+
+            name = line;
+            auto it = handlers_by_name.find(name);
+            if(it != handlers_by_name.end())
+                it->second(name);
+        }
+    }
+
+    bool Rpc::add_handler(const std::string &name, RpcCallback callback) {
+        return handlers_by_name.insert(std::make_pair(name, std::move(callback))).second;
+    }
+}

src/WindowUtils.cpp

@@ -29,19 +29,56 @@ namespace gsr {
         return window_has_atom(dpy, window, net_wm_state_atom) || window_has_atom(dpy, window, wm_state_atom);
     }
 
+    static Window window_get_target_window_child(Display *display, Window window) {
+        if(window == None)
+            return None;
+
+        if(window_is_user_program(display, window))
+            return window;
+
+        Window root;
+        Window parent;
+        Window *children = nullptr;
+        unsigned int num_children = 0;
+        if(!XQueryTree(display, window, &root, &parent, &children, &num_children) || !children)
+            return None;
+
+        Window found_window = None;
+        for(int i = num_children - 1; i >= 0; --i) {
+            if(children[i] && window_is_user_program(display, children[i])) {
+                found_window = children[i];
+                goto finished;
+            }
+        }
+
+        for(int i = num_children - 1; i >= 0; --i) {
+            if(children[i]) {
+                Window win = window_get_target_window_child(display, children[i]);
+                if(win) {
+                    found_window = win;
+                    goto finished;
+                }
+            }
+        }
+
+        finished:
+        XFree(children);
+        return found_window;
+    }
+
     static Window get_window_at_cursor_position(Display *dpy) {
         Window root_window = None;
         Window window = None;
         int dummy_i;
         unsigned int dummy_u;
-        int cursor_pos_x = 0;
-        int cursor_pos_y = 0;
-        XQueryPointer(dpy, DefaultRootWindow(dpy), &root_window, &window, &dummy_i, &dummy_i, &cursor_pos_x, &cursor_pos_y, &dummy_u);
+        XQueryPointer(dpy, DefaultRootWindow(dpy), &root_window, &window, &dummy_i, &dummy_i, &dummy_i, &dummy_i, &dummy_u);
+        if(window)
+            window = window_get_target_window_child(dpy, window);
         return window;
     }
 
     Window get_focused_window(Display *dpy, WindowCaptureType cap_type) {
-        const Atom net_active_window_atom = XInternAtom(dpy, "_NET_ACTIVE_WINDOW", False);
+        //const Atom net_active_window_atom = XInternAtom(dpy, "_NET_ACTIVE_WINDOW", False);
         Window focused_window = None;
 
         if(cap_type == WindowCaptureType::FOCUSED) {
@@ -52,10 +89,14 @@ namespace gsr {
             // unsigned char *data = NULL;
             // XGetWindowProperty(dpy, DefaultRootWindow(dpy), net_active_window_atom, 0, 1, False, XA_WINDOW, &type, &format, &num_items, &bytes_left, &data);
 
-            // fprintf(stderr, "focused window: %p\n", (void*)data);
-
             // if(type == XA_WINDOW && num_items == 1 && data)
-            //     return *(Window*)data;
+            //     focused_window = *(Window*)data;
+
+            // if(data)
+            //     XFree(data);
+
+            // if(focused_window)
+            //     return focused_window;
 
             int revert_to = 0;
             XGetInputFocus(dpy, &focused_window, &revert_to);
@@ -64,7 +105,7 @@ namespace gsr {
         }
 
         focused_window = get_window_at_cursor_position(dpy);
-        if(focused_window && focused_window != DefaultRootWindow(dpy) && window_is_user_program(dpy, focused_window))
+        if(focused_window && focused_window != DefaultRootWindow(dpy))
             return focused_window;
 
         return None;
@@ -72,7 +113,7 @@ namespace gsr {
 
     static char* get_window_title(Display *dpy, Window window) {
         const Atom net_wm_name_atom = XInternAtom(dpy, "_NET_WM_NAME", False);
-        const Atom wm_name_atom = XInternAtom(dpy, "_NET_WM_NAME", False);
+        const Atom wm_name_atom = XInternAtom(dpy, "WM_NAME", False);
         const Atom utf8_string_atom = XInternAtom(dpy, "UTF8_STRING", False);
 
         Atom type = None;
@@ -135,6 +176,7 @@ namespace gsr {
         char *window_title = get_window_title(dpy, focused_window);
         if(window_title) {
             result = string_string(window_title);
+            XFree(window_title);
             return result;
         }
 

src/gui/GlobalSettingsPage.cpp

@@ -55,6 +55,7 @@ namespace gsr {
                 get_color_theme().tint_color = mgl::Color(118, 185, 0);
             else if(id == "intel")
                 get_color_theme().tint_color = mgl::Color(8, 109, 183);
+            return true;
         };
         list->add_widget(std::move(tint_color_radio_button));
         return std::make_unique<Subsection>("Appearance", std::move(list), mgl::vec2f(parent_page->get_inner_size().x, 0.0f));
@@ -62,10 +63,11 @@ namespace gsr {
 
     std::unique_ptr<Subsection> GlobalSettingsPage::create_startup_subsection(ScrollablePage *parent_page) {
         auto list = std::make_unique<List>(List::Orientation::VERTICAL);
-        auto startup_radio_button = std::make_unique<RadioButton>(&get_theme().body_font, RadioButton::Orientation::VERTICAL);
+        list->add_widget(std::make_unique<Label>(&get_theme().body_font, "Start program on system startup?", get_color_theme().text_color));
+        auto startup_radio_button = std::make_unique<RadioButton>(&get_theme().body_font, RadioButton::Orientation::HORIZONTAL);
         startup_radio_button_ptr = startup_radio_button.get();
-        startup_radio_button->add_item("Don't start this program on system startup", "dont_start_on_system_startup");
-        startup_radio_button->add_item("Start this program on system startup", "start_on_system_startup");
+        startup_radio_button->add_item("Yes", "start_on_system_startup");
+        startup_radio_button->add_item("No", "dont_start_on_system_startup");
         startup_radio_button->on_selection_changed = [&](const std::string&, const std::string &id) {
             bool enable = false;
             if(id == "dont_start_on_system_startup")
@@ -73,18 +75,44 @@ namespace gsr {
             else if(id == "start_on_system_startup")
                 enable = true;
             else
-                return;
+                return false;
 
             const char *args[] = { "systemctl", enable ? "enable" : "disable", "--user", "gpu-screen-recorder-ui", nullptr };
             std::string stdout_str;
             const int exit_status = exec_program_on_host_get_stdout(args, stdout_str);
             if(on_startup_changed)
                 on_startup_changed(enable, exit_status);
+            return exit_status == 0;
         };
         list->add_widget(std::move(startup_radio_button));
         return std::make_unique<Subsection>("Startup", std::move(list), mgl::vec2f(parent_page->get_inner_size().x, 0.0f));
     }
 
+    std::unique_ptr<Subsection> GlobalSettingsPage::create_hotkey_subsection(ScrollablePage *parent_page) {
+        const bool inside_flatpak = getenv("FLATPAK_ID") != NULL;
+
+        auto enable_hotkeys_radio_button = std::make_unique<RadioButton>(&get_theme().body_font, RadioButton::Orientation::VERTICAL);
+        enable_hotkeys_radio_button_ptr = enable_hotkeys_radio_button.get();
+        enable_hotkeys_radio_button->add_item("Enable hotkeys", "enable_hotkeys");
+        if(!inside_flatpak)
+            enable_hotkeys_radio_button->add_item("Disable hotkeys", "disable_hotkeys");
+        enable_hotkeys_radio_button->add_item("Only grab virtual devices (supports input remapping software)", "enable_hotkeys_virtual_devices");
+        enable_hotkeys_radio_button->on_selection_changed = [&](const std::string&, const std::string &id) {
+            if(!on_click_exit_program_button)
+                return true;
+
+            if(id == "enable_hotkeys")
+                on_click_exit_program_button("restart");
+            else if(id == "disable_hotkeys")
+                on_click_exit_program_button("restart");
+            else if(id == "enable_hotkeys_virtual_devices")
+                on_click_exit_program_button("restart");
+
+            return true;
+        };
+        return std::make_unique<Subsection>("Hotkeys", std::move(enable_hotkeys_radio_button), mgl::vec2f(parent_page->get_inner_size().x, 0.0f));
+    }
+
     std::unique_ptr<Button> GlobalSettingsPage::create_exit_program_button() {
         auto exit_program_button = std::make_unique<Button>(&get_theme().body_font, "Exit program", mgl::vec2f(0.0f, 0.0f), mgl::Color(0, 0, 0, 120));
         exit_program_button->on_click = [&]() {
@@ -105,7 +133,6 @@ namespace gsr {
 
     std::unique_ptr<Subsection> GlobalSettingsPage::create_application_options_subsection(ScrollablePage *parent_page) {
         const bool inside_flatpak = getenv("FLATPAK_ID") != NULL;
-
         auto list = std::make_unique<List>(List::Orientation::HORIZONTAL);
         list->add_widget(create_exit_program_button());
         if(inside_flatpak)
@@ -120,6 +147,7 @@ namespace gsr {
         settings_list->set_spacing(0.018f);
         settings_list->add_widget(create_appearance_subsection(scrollable_page.get()));
         settings_list->add_widget(create_startup_subsection(scrollable_page.get()));
+        settings_list->add_widget(create_hotkey_subsection(scrollable_page.get()));
         settings_list->add_widget(create_application_options_subsection(scrollable_page.get()));
         scrollable_page->add_widget(std::move(settings_list));
 
@@ -140,10 +168,13 @@ namespace gsr {
         std::string stdout_str;
         const int exit_status = exec_program_on_host_get_stdout(args, stdout_str);
         startup_radio_button_ptr->set_selected_item(exit_status == 0 ? "start_on_system_startup" : "dont_start_on_system_startup", false, false);
+
+        enable_hotkeys_radio_button_ptr->set_selected_item(config.main_config.hotkeys_enable_option, false, false);
     }
 
     void GlobalSettingsPage::save() {
         config.main_config.tint_color = tint_color_radio_button_ptr->get_selected_id();
+        config.main_config.hotkeys_enable_option = enable_hotkeys_radio_button_ptr->get_selected_id();
         save_config(config);
     }
 }

src/gui/RadioButton.cpp

@@ -35,12 +35,12 @@ namespace gsr {
 
                 const bool mouse_inside = mgl::FloatRect(draw_pos, item_size).contains(mgl::vec2f(event.mouse_button.x, event.mouse_button.y));
                 if(mouse_inside) {
-                    const size_t prev_selected_item = selected_item;
+                    if(selected_item != i && on_selection_changed) {
+                        if(!on_selection_changed(item.text.get_string(), item.id))
+                            return false;
+                    }
+
                     selected_item = i;
-
-                    if(selected_item != prev_selected_item && on_selection_changed)
-                        on_selection_changed(item.text.get_string(), item.id);
-
                     return false;
                 }
 
@@ -158,12 +158,12 @@ namespace gsr {
         for(size_t i = 0; i < items.size(); ++i) {
             auto &item = items[i];
             if(item.id == id) {
-                const size_t prev_selected_item = selected_item;
+                if(trigger_event && (trigger_event_even_if_selection_not_changed || selected_item != i) && on_selection_changed) {
+                    if(!on_selection_changed(item.text.get_string(), item.id))
+                        break;
+                }
+
                 selected_item = i;
-
-                if(trigger_event && (trigger_event_even_if_selection_not_changed || selected_item != prev_selected_item) && on_selection_changed)
-                    on_selection_changed(item.text.get_string(), item.id);
-
                 break;
             }
         }

src/gui/SettingsPage.cpp

@@ -304,7 +304,8 @@ namespace gsr {
     std::unique_ptr<Widget> SettingsPage::create_audio_section() {
         auto audio_device_section_list = std::make_unique<List>(List::Orientation::VERTICAL);
         audio_device_section_list->add_widget(create_audio_track_section());
-        audio_device_section_list->add_widget(create_merge_audio_tracks_checkbox());
+        if(type != Type::STREAM)
+            audio_device_section_list->add_widget(create_merge_audio_tracks_checkbox());
         audio_device_section_list->add_widget(create_application_audio_invert_checkbox());
         audio_device_section_list->add_widget(create_audio_codec());
         return std::make_unique<Subsection>("Audio", std::move(audio_device_section_list), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f));
@@ -338,11 +339,27 @@ namespace gsr {
         return list;
     }
 
-    std::unique_ptr<Entry> SettingsPage::create_video_bitrate_entry() {
+    std::unique_ptr<List> SettingsPage::create_video_bitrate_entry() {
+        auto list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER);
         auto video_bitrate_entry = std::make_unique<Entry>(&get_theme().body_font, "15000", (int)(get_theme().body_font.get_character_size() * 4.0f));
         video_bitrate_entry->validate_handler = create_entry_validator_integer_in_range(1, 500000);
         video_bitrate_entry_ptr = video_bitrate_entry.get();
-        return video_bitrate_entry;
+        list->add_widget(std::move(video_bitrate_entry));
+
+        if(type == Type::STREAM) {
+            auto size_mb_label = std::make_unique<Label>(&get_theme().body_font, "1.92MB", get_color_theme().text_color);
+            Label *size_mb_label_ptr = size_mb_label.get();
+            list->add_widget(std::move(size_mb_label));
+
+            video_bitrate_entry_ptr->on_changed = [size_mb_label_ptr](const std::string &text) {
+                const double video_bitrate_mb_per_seconds = (double)atoi(text.c_str()) / 1000LL / 8LL * 1.024;
+                char buffer[32];
+                snprintf(buffer, sizeof(buffer), "%.2fMB", video_bitrate_mb_per_seconds);
+                size_mb_label_ptr->set_text(buffer);
+            };
+        }
+
+        return list;
     }
 
     std::unique_ptr<List> SettingsPage::create_video_bitrate() {
@@ -387,20 +404,20 @@ namespace gsr {
             video_codec_box->add_item("H264", "h264");
         if(gsr_info->supported_video_codecs.hevc)
             video_codec_box->add_item("HEVC", "hevc");
+        if(gsr_info->supported_video_codecs.hevc_10bit)
+            video_codec_box->add_item("HEVC (10 bit, reduces banding)", "hevc_10bit");
+        if(gsr_info->supported_video_codecs.hevc_hdr)
+            video_codec_box->add_item("HEVC (HDR)", "hevc_hdr");
         if(gsr_info->supported_video_codecs.av1)
             video_codec_box->add_item("AV1", "av1");
+        if(gsr_info->supported_video_codecs.av1_10bit)
+            video_codec_box->add_item("AV1 (10 bit, reduces banding)", "av1_10bit");
+        if(gsr_info->supported_video_codecs.av1_hdr)
+            video_codec_box->add_item("AV1 (HDR)", "av1_hdr");
         if(gsr_info->supported_video_codecs.vp8)
             video_codec_box->add_item("VP8", "vp8");
         if(gsr_info->supported_video_codecs.vp9)
             video_codec_box->add_item("VP9", "vp9");
-        if(gsr_info->supported_video_codecs.hevc_hdr)
-            video_codec_box->add_item("HEVC (HDR)", "hevc_hdr");
-        if(gsr_info->supported_video_codecs.hevc_10bit)
-            video_codec_box->add_item("HEVC (10 bit, reduces banding)", "hevc_10bit");
-        if(gsr_info->supported_video_codecs.av1_hdr)
-            video_codec_box->add_item("AV1 (HDR)", "av1_hdr");
-        if(gsr_info->supported_video_codecs.av1_10bit)
-            video_codec_box->add_item("AV1 (10 bit, reduces banding)", "av1_10bit");
         if(gsr_info->supported_video_codecs.h264_software)
             video_codec_box->add_item("H264 Software Encoder (Slow, not recommended)", "h264_software");
         video_codec_box_ptr = video_codec_box.get();
@@ -516,6 +533,7 @@ namespace gsr {
             video_resolution_list_ptr->set_visible(!focused_selected && change_video_resolution_checkbox_ptr->is_checked());
             change_video_resolution_checkbox_ptr->set_visible(!focused_selected);
             restore_portal_session_list_ptr->set_visible(portal_selected);
+            return true;
         };
 
         change_video_resolution_checkbox_ptr->on_changed = [this](bool checked) {
@@ -530,6 +548,8 @@ namespace gsr {
 
             if(estimated_file_size_ptr)
                 estimated_file_size_ptr->set_visible(custom_selected);
+
+            return true;
         };
         video_quality_box_ptr->on_selection_changed("", video_quality_box_ptr->get_selected_id());
 
@@ -644,16 +664,16 @@ namespace gsr {
         return checkbox;
     }
 
-    std::unique_ptr<Label> SettingsPage::create_estimated_file_size() {
-        auto label = std::make_unique<Label>(&get_theme().body_font, "Estimated video max file size in RAM: 5.23MB", get_color_theme().text_color);
+    std::unique_ptr<Label> SettingsPage::create_estimated_replay_file_size() {
+        auto label = std::make_unique<Label>(&get_theme().body_font, "Estimated video max file size in RAM: 57.60MB", get_color_theme().text_color);
         estimated_file_size_ptr = label.get();
         return label;
     }
 
-    void SettingsPage::update_estimated_file_size() {
+    void SettingsPage::update_estimated_replay_file_size() {
         const int64_t replay_time_seconds = atoi(replay_time_entry_ptr->get_text().c_str());
         const int64_t video_bitrate_bps = atoi(video_bitrate_entry_ptr->get_text().c_str()) * 1000LL / 8LL;
-        const double video_filesize_mb = ((double)replay_time_seconds * (double)video_bitrate_bps) / 1024.0 / 1024.0;
+        const double video_filesize_mb = ((double)replay_time_seconds * (double)video_bitrate_bps) / 1000.0 / 1000.0 * 1.024;
 
         char buffer[512];
         snprintf(buffer, sizeof(buffer), "Estimated video max file size in RAM: %.2fMB", video_filesize_mb);
@@ -667,7 +687,7 @@ namespace gsr {
         file_info_data_list->add_widget(create_container_section());
         file_info_data_list->add_widget(create_replay_time());
         file_info_list->add_widget(std::move(file_info_data_list));
-        file_info_list->add_widget(create_estimated_file_size());
+        file_info_list->add_widget(create_estimated_replay_file_size());
         settings_list_ptr->add_widget(std::make_unique<Subsection>("File info", std::move(file_info_list), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f)));
 
         auto general_list = std::make_unique<List>(List::Orientation::VERTICAL);
@@ -705,15 +725,16 @@ namespace gsr {
             framerate_mode_list_ptr->set_visible(advanced_view);
             notifications_subsection_ptr->set_visible(advanced_view);
             settings_scrollable_page_ptr->reset_scroll();
+            return true;
         };
         view_radio_button_ptr->on_selection_changed("Simple", "simple");
 
         replay_time_entry_ptr->on_changed = [this](const std::string&) {
-            update_estimated_file_size();
+            update_estimated_replay_file_size();
         };
 
         video_bitrate_entry_ptr->on_changed = [this](const std::string&) {
-            update_estimated_file_size();
+            update_estimated_replay_file_size();
         };
     }
 
@@ -725,11 +746,29 @@ namespace gsr {
         return checkbox;
     }
 
+    std::unique_ptr<Label> SettingsPage::create_estimated_record_file_size() {
+        auto label = std::make_unique<Label>(&get_theme().body_font, "Estimated video file size per minute (excluding audio): 345.60MB", get_color_theme().text_color);
+        estimated_file_size_ptr = label.get();
+        return label;
+    }
+
+    void SettingsPage::update_estimated_record_file_size() {
+        const int64_t video_bitrate_bps = atoi(video_bitrate_entry_ptr->get_text().c_str()) * 1000LL / 8LL;
+        const double video_filesize_mb_per_minute = (60.0 * (double)video_bitrate_bps) / 1000.0 / 1000.0 * 1.024;
+
+        char buffer[512];
+        snprintf(buffer, sizeof(buffer), "Estimated video file size per minute (excluding audio): %.2fMB", video_filesize_mb_per_minute);
+        estimated_file_size_ptr->set_text(buffer);
+    }
+
     void SettingsPage::add_record_widgets() {
-        auto file_list = std::make_unique<List>(List::Orientation::HORIZONTAL);
-        file_list->add_widget(create_save_directory("Directory to save the video:"));
-        file_list->add_widget(create_container_section());
-        settings_list_ptr->add_widget(std::make_unique<Subsection>("File info", std::move(file_list), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f)));
+        auto file_info_list = std::make_unique<List>(List::Orientation::VERTICAL);
+        auto file_info_data_list = std::make_unique<List>(List::Orientation::HORIZONTAL);
+        file_info_data_list->add_widget(create_save_directory("Directory to save the video:"));
+        file_info_data_list->add_widget(create_container_section());
+        file_info_list->add_widget(std::move(file_info_data_list));
+        file_info_list->add_widget(create_estimated_record_file_size());
+        settings_list_ptr->add_widget(std::make_unique<Subsection>("File info", std::move(file_info_list), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f)));
 
         auto general_list = std::make_unique<List>(List::Orientation::VERTICAL);
         general_list->add_widget(create_save_recording_in_game_folder());
@@ -760,8 +799,13 @@ namespace gsr {
             framerate_mode_list_ptr->set_visible(advanced_view);
             notifications_subsection_ptr->set_visible(advanced_view);
             settings_scrollable_page_ptr->reset_scroll();
+            return true;
         };
         view_radio_button_ptr->on_selection_changed("Simple", "simple");
+
+        video_bitrate_entry_ptr->on_changed = [this](const std::string&) {
+            update_estimated_record_file_size();
+        };
     }
 
     std::unique_ptr<ComboBox> SettingsPage::create_streaming_service_box() {
@@ -860,6 +904,7 @@ namespace gsr {
             container_list_ptr->set_visible(custom_option);
             twitch_stream_key_entry_ptr->set_visible(twitch_option);
             youtube_stream_key_entry_ptr->set_visible(youtube_option);
+            return true;
         };
         streaming_service_box_ptr->on_selection_changed("Twitch", "twitch");
 
@@ -872,6 +917,7 @@ namespace gsr {
             framerate_mode_list_ptr->set_visible(advanced_view);
             notifications_subsection_ptr->set_visible(advanced_view);
             settings_scrollable_page_ptr->reset_scroll();
+            return true;
         };
         view_radio_button_ptr->on_selection_changed("Simple", "simple");
     }
@@ -962,7 +1008,8 @@ namespace gsr {
 
     void SettingsPage::load_common(RecordOptions &record_options) {
         record_area_box_ptr->set_selected_item(record_options.record_area_option);
-        merge_audio_tracks_checkbox_ptr->set_checked(record_options.merge_audio_tracks);
+        if(merge_audio_tracks_checkbox_ptr)
+            merge_audio_tracks_checkbox_ptr->set_checked(record_options.merge_audio_tracks);
         application_audio_invert_checkbox_ptr->set_checked(record_options.application_audio_invert);
         change_video_resolution_checkbox_ptr->set_checked(record_options.change_video_resolution);
         load_audio_tracks(record_options);
@@ -1083,7 +1130,8 @@ namespace gsr {
         record_options.video_height = atoi(video_height_entry_ptr->get_text().c_str());
         record_options.fps = atoi(framerate_entry_ptr->get_text().c_str());
         record_options.video_bitrate = atoi(video_bitrate_entry_ptr->get_text().c_str());
-        record_options.merge_audio_tracks = merge_audio_tracks_checkbox_ptr->is_checked();
+        if(merge_audio_tracks_checkbox_ptr)
+            record_options.merge_audio_tracks = merge_audio_tracks_checkbox_ptr->is_checked();
         record_options.application_audio_invert = application_audio_invert_checkbox_ptr->is_checked();
         record_options.change_video_resolution = change_video_resolution_checkbox_ptr->is_checked();
         save_audio_tracks(record_options.audio_tracks, audio_track_list_ptr);

src/main.cpp

@@ -1,10 +1,10 @@
 #include "../include/GsrInfo.hpp"
-#include "../include/Theme.hpp"
 #include "../include/Overlay.hpp"
 #include "../include/GlobalHotkeysX11.hpp"
 #include "../include/GlobalHotkeysLinux.hpp"
 #include "../include/gui/Utils.hpp"
 #include "../include/Process.hpp"
+#include "../include/Rpc.hpp"
 
 #include <unistd.h>
 #include <signal.h>
@@ -95,8 +95,8 @@ static std::unique_ptr<gsr::GlobalHotkeysX11> register_x11_hotkeys(gsr::Overlay
     return global_hotkeys;
 }
 
-static std::unique_ptr<gsr::GlobalHotkeysLinux> register_linux_hotkeys(gsr::Overlay *overlay) {
-    auto global_hotkeys = std::make_unique<gsr::GlobalHotkeysLinux>();
+static std::unique_ptr<gsr::GlobalHotkeysLinux> register_linux_hotkeys(gsr::Overlay *overlay, gsr::GlobalHotkeysLinux::GrabType grab_type) {
+    auto global_hotkeys = std::make_unique<gsr::GlobalHotkeysLinux>(grab_type);
     if(!global_hotkeys->start())
         fprintf(stderr, "error: failed to start global hotkeys\n");
 
@@ -133,6 +133,43 @@ static std::unique_ptr<gsr::GlobalHotkeysLinux> register_linux_hotkeys(gsr::Over
     return global_hotkeys;
 }
 
+static void rpc_add_commands(gsr::Rpc *rpc, gsr::Overlay *overlay) {
+    rpc->add_handler("show_ui", [overlay](const std::string &name) {
+        fprintf(stderr, "rpc command executed: %s\n", name.c_str());
+        overlay->show();
+    });
+
+    rpc->add_handler("toggle-show", [overlay](const std::string &name) {
+        fprintf(stderr, "rpc command executed: %s\n", name.c_str());
+        overlay->toggle_show();
+    });
+
+    rpc->add_handler("toggle-record", [overlay](const std::string &name) {
+        fprintf(stderr, "rpc command executed: %s\n", name.c_str());
+        overlay->toggle_record();
+    });
+
+    rpc->add_handler("toggle-pause", [overlay](const std::string &name) {
+        fprintf(stderr, "rpc command executed: %s\n", name.c_str());
+        overlay->toggle_pause();
+    });
+
+    rpc->add_handler("toggle-stream", [overlay](const std::string &name) {
+        fprintf(stderr, "rpc command executed: %s\n", name.c_str());
+        overlay->toggle_stream();
+    });
+
+    rpc->add_handler("toggle-replay", [overlay](const std::string &name) {
+        fprintf(stderr, "rpc command executed: %s\n", name.c_str());
+        overlay->toggle_replay();
+    });
+
+    rpc->add_handler("replay-save", [overlay](const std::string &name) {
+        fprintf(stderr, "rpc command executed: %s\n", name.c_str());
+        overlay->save_replay();
+    });
+}
+
 static bool is_gsr_ui_virtual_keyboard_running() {
     FILE *f = fopen("/proc/bus/input/devices", "rb");
     if(!f)
@@ -192,17 +229,19 @@ int main(int argc, char **argv) {
 
     // TODO: This is a shitty method to detect if multiple instances of gsr-ui is running but this will work properly even in flatpak
     // that uses pid sandboxing. Replace this with a better method once we no longer rely on linux global hotkeys on some platform.
-    if(is_gsr_ui_virtual_keyboard_running()) {
-        const char *args[] = { "gsr-notify", "--text", "Another instance of GPU Screen Recorder UI is already running.\nPress Alt+Z to open the UI.", "--timeout", "5.0", "--icon-color", "ff0000", "--bg-color", "ff0000", nullptr };
-        gsr::exec_program_daemonized(args);
+    // TODO: This method doesn't work when disabling hotkeys and the method below with pidof gsr-ui doesn't work in flatpak.
+    // What do? creating a pid file doesn't work in flatpak either.
+    if(is_gsr_ui_virtual_keyboard_running() || gsr::pidof("gsr-ui", getpid()) != -1) {
+        gsr::Rpc rpc;
+        if(rpc.open("gsr-ui") && rpc.write("show_ui\n", 8)) {
+            fprintf(stderr, "Error: another instance of gsr-ui is already running, opening that one instead\n");
+        } else {
+            fprintf(stderr, "Error: failed to send command to running gsr-ui instance, user will have to open the UI manually with Alt+Z\n");
+            const char *args[] = { "gsr-notify", "--text", "Another instance of GPU Screen Recorder UI is already running.\nPress Alt+Z to open the UI.", "--timeout", "5.0", "--icon-color", "ff0000", "--bg-color", "ff0000", nullptr };
+            gsr::exec_program_daemonized(args);
+        }
         return 1;
     }
-    // const pid_t gsr_ui_pid = gsr::pidof("gsr-ui");
-    // if(gsr_ui_pid != -1) {
-    //     const char *args[] = { "gsr-notify", "--text", "Another instance of GPU Screen Recorder UI is already running", "--timeout", "5.0", "--icon-color", "ff0000", "--bg-color", "ff0000", nullptr };
-    //     gsr::exec_program_daemonized(args);
-    //     return 1;
-    // }
 
     // Cant get window texture when prime-run is used
     disable_prime_run();
@@ -265,22 +304,21 @@ int main(int argc, char **argv) {
     fprintf(stderr, "Info: gsr ui is now ready, waiting for inputs. Press alt+z to show/hide the overlay\n");
 
     auto overlay = std::make_unique<gsr::Overlay>(resources_path, std::move(gsr_info), std::move(capture_options), egl_funcs);
-
-    // std::unique_ptr<gsr::GlobalHotkeys> global_hotkeys = nullptr;
-    // if(display_server == gsr::DisplayServer::X11) {
-    //     global_hotkeys = register_x11_hotkeys(overlay.get());
-    //     if(!global_hotkeys) {
-    //         fprintf(stderr, "Info: failed to register some x11 hotkeys because they are registered by another program. Will use linux hotkeys instead\n");
-    //         global_hotkeys = register_linux_hotkeys(overlay.get());
-    //     }
-    // } else {
-    //     global_hotkeys = register_linux_hotkeys(overlay.get());
-    // }
-    std::unique_ptr<gsr::GlobalHotkeys> global_hotkeys = register_linux_hotkeys(overlay.get());
-
     if(launch_action == LaunchAction::LAUNCH_SHOW)
         overlay->show();
 
+    auto rpc = std::make_unique<gsr::Rpc>();
+    if(!rpc->create("gsr-ui"))
+        fprintf(stderr, "Error: Failed to create rpc, commands won't be received\n");
+
+    rpc_add_commands(rpc.get(), overlay.get());
+
+    std::unique_ptr<gsr::GlobalHotkeys> global_hotkeys = nullptr;
+    if(overlay->get_config().main_config.hotkeys_enable_option == "enable_hotkeys")
+        global_hotkeys = register_linux_hotkeys(overlay.get(), gsr::GlobalHotkeysLinux::GrabType::ALL);
+    else if(overlay->get_config().main_config.hotkeys_enable_option == "enable_hotkeys_virtual_devices")
+        global_hotkeys = register_linux_hotkeys(overlay.get(), gsr::GlobalHotkeysLinux::GrabType::VIRTUAL);
+
     // TODO: Add hotkeys in Overlay when using x11 global hotkeys. The hotkeys in Overlay should duplicate each key that is used for x11 global hotkeys.
 
     std::string exit_reason;
@@ -290,7 +328,11 @@ int main(int argc, char **argv) {
         const double frame_delta_seconds = frame_delta_clock.restart();
         gsr::set_frame_delta_seconds(frame_delta_seconds);
 
-        global_hotkeys->poll_events();
+        rpc->poll();
+
+        if(global_hotkeys)
+            global_hotkeys->poll_events();
+
         overlay->handle_events(global_hotkeys.get());
         if(!overlay->draw()) {
             std::this_thread::sleep_for(std::chrono::milliseconds(100));
@@ -299,15 +341,18 @@ int main(int argc, char **argv) {
     }
 
     fprintf(stderr, "Info: shutting down!\n");
+    rpc.reset();
+    if(global_hotkeys)
+        global_hotkeys.reset();
     overlay.reset();
-    gsr::deinit_theme();
-    gsr::deinit_color_theme();
     mgl_deinit();
-    global_hotkeys.reset();
 
     if(exit_reason == "back-to-old-ui") {
         const char *args[] = { "gpu-screen-recorder-gtk", "use-old-ui", nullptr };
         execvp(args[0], (char* const*)args);
+    } else if(exit_reason == "restart") {
+        const char *args[] = { "gsr-ui", "launch-show", nullptr };
+        execvp(args[0], (char* const*)args);
     }
 
     return 0;

tools/gsr-global-hotkeys/keyboard_event.c

@@ -165,7 +165,8 @@ 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,
                 //   shift_pressed ? "yes" : "no", ctrl_pressed ? "yes" : "no", alt_pressed ? "yes" : "no", meta_pressed ? "yes" : "no");
@@ -174,8 +175,10 @@ static void keyboard_event_process_input_event_data(keyboard_event *self, event_
                     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;
 
@@ -213,11 +216,41 @@ static bool keyboard_event_has_event_with_dev_input_fd(keyboard_event *self, int
     return false;
 }
 
+/* TODO: Is there a more efficient way to do this? */
+static bool dev_input_is_virtual(int dev_input_id) {
+    DIR *dir = opendir("/sys/devices/virtual/input");
+    if(!dir)
+        return false;
+
+    bool is_virtual = false;
+    char virtual_input_filepath[1024];
+    for(;;) {
+        struct dirent *entry = readdir(dir);
+        if(!entry)
+            break;
+
+        if(strncmp(entry->d_name, "input", 5) != 0)
+            continue;
+
+        snprintf(virtual_input_filepath, sizeof(virtual_input_filepath), "/sys/devices/virtual/input/%s/event%d", entry->d_name, dev_input_id);
+        if(access(virtual_input_filepath, F_OK) == 0) {
+            is_virtual = true;
+            break;
+        }
+    }
+
+    closedir(dir);
+    return is_virtual;
+}
+
 static bool keyboard_event_try_add_device_if_keyboard(keyboard_event *self, const char *dev_input_filepath) {
     const int dev_input_id = get_dev_input_id_from_filepath(dev_input_filepath);
     if(dev_input_id == -1)
         return false;
 
+    if(self->grab_type == KEYBOARD_GRAB_TYPE_VIRTUAL && !dev_input_is_virtual(dev_input_id))
+        return false;
+
     if(keyboard_event_has_event_with_dev_input_fd(self, dev_input_id))
         return false;
 
@@ -373,10 +406,11 @@ 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) {
+bool keyboard_event_init(keyboard_event *self, bool poll_stdout_error, bool exclusive_grab, keyboard_grab_type grab_type) {
     memset(self, 0, sizeof(*self));
     self->stdout_event_index = -1;
     self->hotplug_event_index = -1;
+    self->grab_type = grab_type;
 
     if(exclusive_grab) {
         self->uinput_fd = setup_virtual_keyboard_input(GSR_UI_VIRTUAL_KEYBOARD_NAME);

tools/gsr-global-hotkeys/keyboard_event.h

@@ -18,10 +18,11 @@
 #define MAX_EVENT_POLLS 32
 
 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 {
@@ -36,6 +37,11 @@ typedef struct {
     int num_keys_pressed;
 } event_extra_data;
 
+typedef enum {
+    KEYBOARD_GRAB_TYPE_ALL,
+    KEYBOARD_GRAB_TYPE_VIRTUAL
+} keyboard_grab_type;
+
 typedef struct {
     struct pollfd event_polls[MAX_EVENT_POLLS];      /* Current size is |num_event_polls| */
     event_extra_data event_extra_data[MAX_EVENT_POLLS]; /* Current size is |num_event_polls| */
@@ -45,6 +51,7 @@ typedef struct {
     int hotplug_event_index;
     int uinput_fd;
     bool stdout_failed;
+    keyboard_grab_type grab_type;
 
     hotplug_event hotplug_ev;
 
@@ -62,7 +69,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);
+bool keyboard_event_init(keyboard_event *self, bool poll_stdout_error, bool exclusive_grab, keyboard_grab_type grab_type);
 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

@@ -3,6 +3,7 @@
 /* C stdlib */
 #include <stdio.h>
 #include <stdint.h>
+#include <string.h>
 
 /* POSIX */
 #include <unistd.h>
@@ -15,12 +16,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) {
@@ -37,7 +38,32 @@ static bool on_key_callback(uint32_t key, uint32_t modifiers, int press_status,
     return true;
 }
 
-int main(void) {
+static void usage(void) {
+    fprintf(stderr, "usage: gsr-global-hotkeys [--all|--virtual]\n");
+    fprintf(stderr, "OPTIONS:\n");
+    fprintf(stderr, "  --all        Grab all devices.\n");
+    fprintf(stderr, "  --virtual    Grab all virtual devices only.\n");
+}
+
+int main(int argc, char **argv) {
+    keyboard_grab_type grab_type = KEYBOARD_GRAB_TYPE_ALL;
+    if(argc == 2) {
+        const char *grab_type_arg = argv[1];
+        if(strcmp(grab_type_arg, "--all") == 0) {
+            grab_type = KEYBOARD_GRAB_TYPE_ALL;
+        } else if(strcmp(grab_type_arg, "--virtual") == 0) {
+            grab_type = KEYBOARD_GRAB_TYPE_VIRTUAL;
+        } else {
+            fprintf(stderr, "Error: expected --all or --virtual, got %s\n", grab_type_arg);
+            usage();
+            return 1;
+        }
+    } else if(argc != 1) {
+        fprintf(stderr, "Error: expected 0 or 1 arguments, got %d argument(s)\n", argc);
+        usage();
+        return 1;
+    }
+
     const uid_t user_id = getuid();
     if(geteuid() != 0) {
         if(setuid(0) == -1) {
@@ -47,7 +73,7 @@ int main(void) {
     }
 
     keyboard_event keyboard_ev;
-    if(!keyboard_event_init(&keyboard_ev, true, true)) {
+    if(!keyboard_event_init(&keyboard_ev, true, true, grab_type)) {
         fprintf(stderr, "Error: failed to setup hotplugging and no keyboard input devices were found\n");
         setuid(user_id);
         return 1;

tools/gsr-ui-cli/main.c

@@ -0,0 +1,105 @@
+#include <limits.h>
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+static void get_runtime_filepath(char *buffer, size_t buffer_size, const char *filename) {
+    char dir[PATH_MAX];
+
+    const char *runtime_dir = getenv("XDG_RUNTIME_DIR");
+    if(runtime_dir)
+        snprintf(dir, sizeof(dir), "%s", runtime_dir);
+    else
+        snprintf(dir, sizeof(dir), "/run/user/%d", geteuid());
+
+    if(access(dir, F_OK) != 0)
+        snprintf(dir, sizeof(dir), "/tmp");
+
+    snprintf(buffer, buffer_size, "%s/%s", dir, filename);
+}
+
+/* Assumes |str| size is less than 256 */
+static void fifo_write_all(int file_fd, const char *str) {
+    char command[256];
+    const ssize_t command_size = snprintf(command, sizeof(command), "%s\n", str);
+    if(command_size >= (ssize_t)sizeof(command)) {
+        fprintf(stderr, "Error: command too long: %s\n", str);
+        return;
+    }
+
+    ssize_t offset = 0;
+    while(offset < (ssize_t)command_size) {
+        const ssize_t bytes_written = write(file_fd, str + offset, command_size - offset);
+        if(bytes_written > 0)
+            offset += bytes_written;
+    }
+}
+
+static void usage(void) {
+    printf("usage: gsr-ui-cli <command>\n");
+    printf("Run commands on the running gsr-ui instance.\n");
+    printf("\n");
+    printf("COMMANDS:\n");
+    printf("  toggle-show      Show/hide the UI.\n");
+    printf("  toggle-record    Start/stop recording.\n");
+    printf("  toggle-pause     Pause/unpause recording. Only applies to regular recording.\n");
+    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");
+    exit(1);
+}
+
+static bool is_valid_command(const char *command) {
+    const char *commands[] = {
+        "toggle-show",
+        "toggle-record",
+        "toggle-pause",
+        "toggle-stream",
+        "toggle-replay",
+        "replay-save",
+        NULL
+    };
+
+    for(int i = 0; commands[i]; ++i) {
+        if(strcmp(command, commands[i]) == 0)
+            return true;
+    }
+
+    return false;
+}
+
+int main(int argc, char **argv) {
+    if(argc != 2) {
+        printf("Error: expected 1 argument, %d provided\n", argc - 1);
+        usage();
+    }
+
+    const char *command = argv[1];
+    if(strcmp(command, "-h") == 0 || strcmp(command, "--help") == 0)
+        usage();
+
+    if(!is_valid_command(command)) {
+        fprintf(stderr, "Error: invalid command: \"%s\"\n", command);
+        usage();
+    }
+
+    char fifo_filepath[PATH_MAX];
+    get_runtime_filepath(fifo_filepath, sizeof(fifo_filepath), "gsr-ui");
+    const int fifo_fd = open(fifo_filepath, O_RDWR | O_NONBLOCK);
+    if(fifo_fd <= 0) {
+        fprintf(stderr, "Error: failed to open fifo file %s. Maybe gsr-ui is not running?\n", fifo_filepath);
+        exit(2);
+    }
+
+    fifo_write_all(fifo_fd, command);
+    close(fifo_fd);
+    return 0;
+}