Fix leds getting unset when closing the program

let gsr choose video codec automatically for us when using auto (prefer h264, then hevc and then av1),
fallback to software encoding in gsr ui if none of them are available.

.gitignore

@@ -4,3 +4,5 @@ compile_commands.json
 
 **/xdg-output-unstable-v1-client-protocol.h
 **/xdg-output-unstable-v1-protocol.c
+
+depends/.wraplock

README.md

@@ -4,17 +4,17 @@
 A fullscreen overlay UI for [GPU Screen Recorder](https://git.dec05eba.com/gpu-screen-recorder/about/) in the style of ShadowPlay.\
 The application is currently primarly designed for X11 but it can run on Wayland as well through XWayland, with some caveats because of Wayland limitations.
 
-# Usage
-You can start the overlay UI and make it start automatically on system startup by running `systemctl enable --now --user gpu-screen-recorder-ui`.
-Alternatively you can run `gsr-ui` and go into settings and enable start on system startup setting.\
-Press `Left Alt+Z` to show/hide the UI. Go into settings to view all of the different hotkeys configured.\
-If you use a non-systemd distro and want to start the UI on system startup then you have to manually add `gsr-ui` to your system startup script.\
-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.\
-You can also install gpu screen recorder 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.
+You can also install gpu screen recorder from [flathub](https://flathub.org/apps/details/com.dec05eba.gpu_screen_recorder) which includes this UI.
+
+# Usage
+Press `Left Alt+Z` to show/hide the UI. Go into settings (the icon on the right) to view all of the different hotkeys configured.\
+You can start the overlay UI and make it start automatically on system startup by running `systemctl enable --now --user gpu-screen-recorder-ui`.
+Alternatively you can run `gsr-ui` and go into settings and enable start on system startup setting.\
+If you use a non-systemd distro and want to start the UI on system startup then you have to manually add `gsr-ui launch-daemon` to your system startup script.\
+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.
 
 # Dependencies
 GPU Screen Recorder UI uses meson build system so you need to install `meson` to build GPU Screen Recorder UI.
@@ -22,14 +22,13 @@ GPU Screen Recorder UI uses meson build system so you need to install `meson` to
 ## Build dependencies
 These are the dependencies needed to build GPU Screen Recorder UI:
 
-* x11 (libx11, libxrandr, libxrender, libxcomposite, libxfixes, libxext, libxi)
-* libxcursor
+* x11 (libx11, libxrandr, libxrender, libxcomposite, libxfixes, libxext, libxi, libxcursor)
 * libglvnd (which provides libgl, libglx and libegl)
 * linux-api-headers
 * libpulse (libpulse-simple)
 * libdrm
-* wayland-client
-* wayland-scanner
+* wayland (wayland-client, wayland-egl, wayland-scanner)
+* setcap (libcap)
 
 ## Runtime dependencies
 There are also additional dependencies needed at runtime:
@@ -38,14 +37,17 @@ There are also additional dependencies needed at runtime:
 * [GPU Screen Recorder Notification](https://git.dec05eba.com/gpu-screen-recorder-notification/)
 
 ## Program behavior notes
-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"
+By default this program has to grab all keyboards and creates 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 keyboard remapping software. To workaround this you can go into settings and select "Yes, but only grab virtual devices" or "Yes, but don't grab devices".\
+If you use keyboard remapping software such as keyd then make sure to make it ignore "gsr-ui virtual keyboard" (dec0:5eba device id), otherwise your keyboard can get locked
+as gpu screen recorder tries to grab keys and keyd grabs gpu screen recorder, leading to a lock.\
+If you are stuck in such a lock where you cant press and keyboard keys you can press (left) ctrl+shift+alt+esc to close gpu screen recorder and remove it from system startup.
 
 # 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`.\
 `images/default.cur` it part of the [Adwaita icon theme](https://gitlab.gnome.org/GNOME/adwaita-icon-theme/-/tree/master) which is licensed under `CC BY-SA 3.0`.\
 The controller buttons under `images/` were created by [Julio Cacko](https://juliocacko.itch.io/free-input-prompts) and they are licensed under `CC0 1.0 Universal`.\
-The PlayStation logo under `images/` was created by [ArksDigital](https://arks.itch.io/ps4-buttons) and it's are licensed under `CC BY 4.0`.
+The PlayStation logo under `images/` was created by [ArksDigital](https://arks.itch.io/ps4-buttons) and it's licensed under `CC BY 4.0`.
 
 # Reporting bugs, contributing patches, questions or donation
 See [https://git.dec05eba.com/?p=about](https://git.dec05eba.com/?p=about).\
@@ -59,9 +61,18 @@ I'm looking for somebody that can create sound effects for the notifications.
 ![](https://dec05eba.com/images/settings_page.jpg)
 
 # Known issues
-* When the UI is open the wallpaper is shown instead of the game on Hyprland. This is an issue with Hyprland. It cant be fixed until the UI is redesigned to not be a fullscreen overlay.
-* Opening the UI when a game is fullscreened can mess up the game window a bit on Hyprland. I believe this is an issue with Hyprland.
+* When the UI is open the wallpaper is shown instead of the game on Hyprland. This is an issue with Hyprland. It cant be fixed until the UI is redesigned to not be a fullscreen overlay. Change your waybar dock mode to "dock" in its config to fix this.
+* Opening the UI when a game is fullscreen can mess up the game window a bit on Hyprland. This is an issue with Hyprland. Change your waybar dock mode to "dock" in its config to fix this.
+* The background of the UI is black when opening the UI while a Wayland application is focused on COSMIC. This is an issue with COSMIC.
+* Unable to close the region selection with escape key while a Wayland application is focused on COSMIC. This is an issue with COSMIC.
 
 # FAQ
 ## I get an error when trying to start the gpu-screen-recorder-ui.service systemd service
 If you have previously used the flatpak version of GPU Screen Recorder with the new UI then the non-flatpak version of the systemd service will conflict with that. Run `gsr-ui` to fix that.
+## I use a non-qwerty keyboard layout and I have an issue with incorrect keys registered in the software
+This is a KDE Plasma Wayland issue. Use `setxkbmap <language>` command, for example `setxkbmap se` to make sure X11 applications (such as this one) gets updated to use your languages keyboard layout.
+## "Save to clipboard" option doesn't work for screenshots
+Some Wayland compositors don't support copying images on the clipboard between X11 and Wayland applications. GPU Screen Recorder UI is an X11 application. It can't be done properly on Wayland
+since Wayland doesn't support a non-focused application from setting the clipboard, so it can't work with GPU Screen Recorder hotkey usage. Use X11 if you want a functioning desktop.
+## The controller hotkey and steam overlap (home button brings up steam overlay)
+You can either disable the steam overlay or in steam click Steam->Settings->Controller and then click "Begin Test" under "Test Device Inputs". Click on "Setup Device Inputs" and configure controller buttons there and when you get to the home button press X to unbind it from steam.

TODO

@@ -12,10 +12,6 @@ Handle events in draw function because the render position of elements is availa
 
 Add nvidia overclock option.
 
-Add support for window selection in capture.
-
-Add option to record the focused monitor. This works on wayland too when using kms capture since we can get cursor position without root and see which monitor (crtc) the cursor is on. Or use create_window_get_center_position.
-
 Filechooser should have the option to select list view, search bar and common folders/mounted drives on the left side for quick navigation. Also a button to create a new directory.
 
 Restart replay on system start if monitor resolution changes.
@@ -29,8 +25,6 @@ Have different modes. Overlay, window and side menu. Overlay can be used on x11,
 
 Show navigation breadcrumbs for settings and deeper navigation (such as selecting a directory to save videos).
 
-Add option to hide stream key like a password input.
-
 Add global setting. In that setting there should be an option to enable/disable gsr-ui from system startup (the systemd service).
 
 Add profiles and hotkey to switch between profiles (show notification when switching profile).
@@ -39,8 +33,6 @@ Fix first frame being black when running without a compositor.
 
 Add support for systray.
 
-Add option to take screenshot.
-
 Move event callbacks to a global list instead of std::function object in each widget. This reduces the size of widgets,
     since most widgets wont have the event callback set.
     This event callback would pass the widget as an argument.
@@ -74,8 +66,6 @@ Run `systemctl status --user gpu-screen-recorder` when starting recording and gi
 
 Add option to select which gpu to record with, or list all monitors and automatically use the gpu associated with the monitor. Do the same in gtk application.
 
-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.
 
 Support CJK.
@@ -94,15 +84,10 @@ Dont put widget position to int position when scrolling. This makes the UI jitte
 
 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.
-
 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.
 
-When adding window capture only add it to recording and streaming and do the window selection when recording starts, to make it more ergonomic with hotkeys.
-    If hotkey for recording/streaming start is pressed on the button for start is clicked then hide the ui if it's visible and show the window selection option (cursor).
-
 Show an error that prime run will be disabled when using desktop portal capture option. This can cause issues as the user may have selected a video codec option that isn't available on their iGPU but is available on the prime-run dGPU.
 
 For keyboards that report supporting mice the keyboard grab will be delayed until any key has been pressed (and then released), see: https://github.com/dec05eba/gpu-screen-recorder-issues/issues/97
@@ -113,16 +98,13 @@ Check if "modprobe uinput" is needed on some systems (old fedora?).
 Add recording timer to see duration of recording/streaming.
 
 Make folder with window name work when using gamescope. Gamescope runs x11 itself so to get the window name inside that we have to connect to the gamescope X11 server (DISPLAY=:1 on x11 and DISPLAY=:2 on wayland, but not always).
+    Detect if the window is gamescope automatically (WM_CLASS = "gamescope") and get the x11 display automatically and connect to it to get the application its running.
+    This seems to only be an issue on wayland? the window title of the gamescope/steam bigpicture mode is the title of the game on x11, so it works automatically on x11.
 
 When clicking on current directory in file manager show a dropdown menu where you can select common directories (HOME, Videos, Downloads and mounted drives) for quick navigation. Maybe even button to search.
 
 Maybe change gsr-ui startup retry time in the systemd service, from 5 seconds to 2 seconds.
 
-Add support for window capture. This should not prompt for window selection directly but instead prompt for window selection when recording starts and hide the ui first.
-    For screenshots window capture should exist but "follow focused" option should not exist.
-
-Improve audio design. It should have a button to add/remove audio tracks and button to add audio into each audio track separately and "record audio from all applications except the selected ones" for each audio track. Then also remove the "merge audio tracks" option.
-
 Make it possible to take a screenshot through a button in the ui instead of having to use hotkey.
 
 Handle failing to save a replay. gsr should output "failed to save replay, or something like that" to make it possible to detect that.
@@ -143,14 +125,10 @@ Make inactive buttons gray (in dropdown boxes and in the front page with save, e
 
 Add option to do screen-direct recording. But make it clear that it should not be used, except for gsync on x11 nvidia.
 
-Add window capture option (for x11).
-
 Add systray for recording status.
 
 Add a desktop icon when gsr-ui has a window mode option (which should be the default launch option).
 
-Use /dev/input/eventN (or /dev/hidrawN) instead of /dev/input/jsN for joystick input.
-
 Verify if cursor tracker monitor name is always correct. It uses the wayland monitor name for recording, but gpu screen recorder uses a custom name created from the drm connector name.
 
 Notification with the focused monitor (with CursorTrackerWayland) assumes that the x11 monitor name is the same as the drm monitor name. Same for find_monitor_by_name.
@@ -158,3 +136,112 @@ Notification with the focused monitor (with CursorTrackerWayland) assumes that t
 If CursorTrackerWayland fails then fallback to getting focused monitor by window creation trick. Need to take into consideration prime laptop with dGPU that controls external monitors which cant be captured (different /dev/dri/card device).
     Maybe automatically switch to recording with the device that controls the monitor.
     In that case also add all monitors available to capture in the capture list and automatically choose the gpu that controls the monitor.
+
+Support cjk font. Use fc-match to find the location of the font. This also works in flatpak, in which case the fonts are in /run/host/..., where it lists system fonts.
+
+Keyboard layout is incorrect on wayland when using kde plasma keyboard settings to setup multiple keyboards, for example when changing to french.
+    Text input is correct, but hotkey is incorrect.
+    Need to use "setxkbmap fr" as well.
+    This happens only when grabbing keyboard (gsr-global-hotkeys). Same thing is seen with xev.
+
+Getting focused monitor on wayland doesn't work when vrr is enabled. This is because it uses software cursor instead (at least on kde plasma wayland).
+    Right now it falls back to create window & getting window position trick if there is no cursor visible (or a software cursor) and one monitor has vrr enabled.
+        Remove this when linux & wayland supports vrr with hardware cursor plane.
+    Find out another way to get cursor position on wayland.
+    This was fixed in linux 6.11 and in kde plasma in this commit: https://invent.kde.org/plasma/kwin/-/merge_requests/7582/diffs.
+
+Add option to start recording/replay/stream after the notification has disappeared. Show "Starting recording on this monitor in 3 seconds".
+    See if we can use hardware overlay plane instead somehow.
+
+When using wayland for mgl try using wlr-layer-shell and set layer to overlay and keyboard interactivity to exclusive. Do something similar for notifications.
+
+When starting gsr-ui remove any temporary replay disk data that has possibly remained from a crash, by looking for all folders that starts with gsr-replay and end with .gsr, in the replay directory.
+
+Add restart program button, in global settings. It should do almost the same thing as exit program, execept execv gsr-ui.
+
+When gpu screen recorder ui can run as a regular window (and supports tray icon and global shortcut portal) remove gpu screen recorder gtk. Then all error checking needs to be moved from that project to this project.
+    May need support for multi windows, or create a small project to display dialogs.
+
+Add a bug report page that automatically includes system info (make this clear to the user).
+    Do this by sending the report to a custom server that stores that data.
+    The server should limit reports per IP to prevent spam.
+
+Make it possible to change controller hotkeys. Also read from /dev/input/eventN instead of /dev/input/jsN. This is readable for controllers.
+
+Show message that replay/streaming has to be restarted if recording settings are changed while replay/streaming is ongoing.
+
+Support vector graphics. Maybe support svg, rendering it to a texture for better performance.
+
+Support freetype for text rendering. Maybe load freetype as runtime (with dlopen) and use that when available and fallback to stb_freetype if not available.
+
+Show .webm container option. It's currently chosen automatically if vp8/vp9 is chosen. The available containers should automatically switch depending on the video codec.
+
+In settings show audio levels for each audio. Maybe show audio level image beside the audio name in the dropdown box and switch to a different image (have 3-4 different images for each level) depending on the volume.
+
+Only use fake cursor on wayland if the focused x11 window is fullscreen.
+
+Create window as a real overlay window, using layer shell protocol, when possible. This will however minimize windows on floating wms. Check if this can be fixed somehow, or only use layer shell in tiling wms.
+
+Add timeout option for screenshots.
+
+Add a window that shows a warning for wayland users, that wayland doesn't support this software and if they experience issues then they should use x11 instead.
+
+Add a window that shows a warning if gpu video encoding isn't supported.
+
+Disable system notifications when recording. Does the notification dbus interface support pausing notifications?
+
+Disable hotkeys if virtual keyboard is found (either at startup or after running), if grab type if not virtual. Show a notification if that happens that hotkeys have been disabled.
+    Detect if keyboard is locked by listening to gsr-ui virtual keyboard events and if no event is received after pressing a key (when writing to it after receiving input from another keyboard)
+    then remove the keyboard grab and show a message or something.
+        This can happen if the gsr-ui virtual keyboard is grabbed by some other software.
+        Maybe this can be fixed automatically by grabbing gsr-ui virtual keyboard and releasing it just before we write to it and then release it again.
+        But wont keyboard remapping software grab the keyboard first if they detect it quickly?
+            If we fail to grab it because some other software did then dont grab any keyboards nor gsr-ui virtual keyboards, just listen to them.
+
+Support localization.
+
+Add option to not capture cursor in screenshot when doing region/window capture.
+
+Window selection doesn't work when a window is fullscreen on x11.
+
+Make it possible to change replay duration of the "save 1 min" and "save 10 min" by adding them to the replay settings as options.
+
+If replay duration is set below the "save 1 min" or "save 10 min" then gray them out and when hovering over those buttons
+    show a tooltip that says that those buttons cant be used because the replay duration in replay settings is set to a lower value than that (and display the replay duration there).
+
+The UI is unusable on a vertical monitor.
+
+Steam overlay interfers with controller input in gsr ui. Maybe move controller handling the gsr-global-hotkeys to do a grab on the controller, to only give the key input to gsr ui.
+
+For joysticks (gamepads) create a virtual device for each one (/dev/uinput) that has the same vendor, product and name. This is to make sure that it behaves the same way in applications since applications
+    access joysticks directly through /dev/input/eventN or /dev/input/jsN. It needs the same number of buttons and pretend to be a controller of the same time, for example a ps4 controller
+    so that games automatically display ps4 buttons if supported.
+    This also allows us to copy event bits and other data from the device instead of saying we support everything.
+    This should fix the issue of not being able to write to /dev/uinput with ABS_X event bit set.
+    Maybe do this for regular keyboard inputs as well?
+
+Use generic icons for controller input in settings and allow configuring them.
+
+Add option to include game name in file name (video and screenshot). Replace / with space.
+
+Check if the focused window is on top on x11 when choosing to take screenshot or show the window as the background of the overlay.
+
+Convert clipboard image to requested type (from jpg to png for example).
+
+Save clipboard image with wayland on wayland. Some wayland compositors (such as hyprland, budgie and maybe more (wlroots based ones?)) don't support copying clipboard image data from x11 applications to wayland applications.
+    This can be done because retarded wayland only supports setting clipboard when the application has focus. This doesn't work with hotkey screenshot use.
+    This is specifically an issue when using wl_data_device_manager, which is a standard protocol. It can be done when using wlr specific protocol.
+
+When gsr supports pausing recording done in replay/streaming session then add support for that in gsr-ui as well.
+
+Add recording timer when recording to show for how long we have been recording for. Maybe the same for live streaming and replay.
+
+Add option to trim video in the ui. Show a list of all videos recorded so you dont have to navigate to them (maybe add option to manually navigate to a video as well). Maybe use mpv to view it (embedded) in the ui and trim regions (multiple) and ffmpeg command to trim it.
+
+Show the currently recorded capture in the ui, to preview if everything looks ok. This is also good for webcam overlay. Do this when gsr supports rpc, which would also include an option to get a fd to the capture texture.
+
+Show a question mark beside options. When hovering the question mark show a tooltip that explains the options.
+
+Remove all mgl::Clock usage in Overlay. We only need to get the time once per update in Overlay::handle_events. Also get time in other places outside handle_events.
+
+Handle stopping replay/stream when recording is running (show notification that the video is saved and move the video to folder with game name).

extra/gpu-screen-recorder-ui.service

@@ -2,7 +2,7 @@
 Description=GPU Screen Recorder UI Service
 
 [Service]
-ExecStart=gsr-ui
+ExecStart=gsr-ui launch-daemon
 KillSignal=SIGINT
 Restart=on-failure
 RestartSec=5s

include/ClipboardFile.hpp

@@ -0,0 +1,60 @@
+#pragma once
+
+#include <string>
+#include <thread>
+#include <mutex>
+#include <vector>
+#include <X11/Xlib.h>
+
+namespace gsr {
+    struct ClipboardCopy {
+        Window requestor = None;
+        uint64_t file_offset = 0;
+        Atom property = None;
+        Atom requestor_target = None;
+    };
+
+    class ClipboardFile {
+    public:
+        enum class FileType {
+            JPG,
+            PNG
+        };
+
+        ClipboardFile();
+        ~ClipboardFile();
+        ClipboardFile(const ClipboardFile&) = delete;
+        ClipboardFile& operator=(const ClipboardFile&) = delete;
+
+        // Set this to an empty string to unset clipboard
+        void set_current_file(const std::string &filepath, FileType file_type);
+    private:
+        bool file_type_matches_request_atom(FileType file_type, Atom request_atom);
+        const char* file_type_clipboard_get_name(Atom request_atom);
+        const char* file_type_get_name(FileType file_type);
+        void send_clipboard_start(XSelectionRequestEvent *xselectionrequest);
+        void transfer_clipboard_data(XSelectionRequestEvent *xselectionrequest, ClipboardCopy *clipboard_copy);
+        ClipboardCopy* get_clipboard_copy_by_requestor(Window requestor);
+        void remove_clipboard_copy(Window requestor);
+    private:
+        Display *dpy = nullptr;
+        Window clipboard_window = None;
+        int file_fd = -1;
+        uint64_t file_size = 0;
+        FileType file_type = FileType::JPG;
+
+        Atom incr_atom = None;
+        Atom targets_atom = None;
+        Atom clipboard_atom = None;
+        Atom image_jpg_atom = None;
+        Atom image_jpeg_atom = None;
+        Atom image_png_atom = None;
+
+        std::thread event_thread;
+        std::mutex mutex;
+        bool running = true;
+
+        std::vector<ClipboardCopy> clipboard_copies;
+        bool should_clear_selection = false;
+    };
+}

include/Config.hpp

@@ -6,7 +6,7 @@
 #include <vector>
 #include <optional>
 
-#define GSR_CONFIG_FILE_VERSION 1
+#define GSR_CONFIG_FILE_VERSION 2
 
 namespace gsr {
     struct SupportedCaptureOptions;
@@ -30,6 +30,14 @@ namespace gsr {
         std::string to_string(bool spaces = true, bool modifier_side = true) const;
     };
 
+    struct AudioTrack {
+        std::vector<std::string> audio_inputs; // ids
+        bool application_audio_invert = false;
+
+        bool operator==(const AudioTrack &other) const;
+        bool operator!=(const AudioTrack &other) const;
+    };
+
     struct RecordOptions {
         std::string record_area_option = "screen";
         int32_t record_area_width = 0;
@@ -37,28 +45,34 @@ namespace gsr {
         int32_t video_width = 0;
         int32_t video_height = 0;
         int32_t fps = 60;
-        int32_t video_bitrate = 15000;
-        bool merge_audio_tracks = true; // Currently unused for streaming because all known streaming sites only support 1 audio track
-        bool application_audio_invert = false;
+        int32_t video_bitrate = 8000;
+        bool merge_audio_tracks = true; // TODO: Remove in the future
+        bool application_audio_invert = false; // TODO: Remove in the future
         bool change_video_resolution = false;
-        std::vector<std::string> audio_tracks;
+        std::vector<std::string> audio_tracks; // ids, TODO: Remove in the future
+        std::vector<AudioTrack> audio_tracks_list;
         std::string color_range = "limited";
         std::string video_quality = "very_high";
         std::string video_codec = "auto";
         std::string audio_codec = "opus";
-        std::string framerate_mode = "vfr";
+        std::string framerate_mode = "auto";
         bool advanced_view = false;
         bool overclock = false;
         bool record_cursor = true;
         bool restore_portal_session = true;
+
+        bool show_notifications = true;
+        bool use_led_indicator = false;
     };
 
     struct MainConfig {
         int32_t config_file_version = GSR_CONFIG_FILE_VERSION;
         bool software_encoding_warning_shown = false;
+        bool wayland_warning_shown = false;
         std::string hotkeys_enable_option = "enable_hotkeys";
         std::string joystick_hotkeys_enable_option = "disable_hotkeys";
         std::string tint_color;
+        std::string notification_speed = "normal";
         ConfigHotkey show_hide_hotkey;
     };
 
@@ -70,18 +84,22 @@ namespace gsr {
         std::string stream_key;
     };
 
+    struct RumbleStreamConfig {
+        std::string stream_key;
+    };
+
     struct CustomStreamConfig {
         std::string url;
+        std::string key;
         std::string container = "flv";
     };
 
     struct StreamingConfig {
         RecordOptions record_options;
-        bool show_streaming_started_notifications = true;
-        bool show_streaming_stopped_notifications = true;
         std::string streaming_service = "twitch";
         YoutubeStreamConfig youtube;
         TwitchStreamConfig twitch;
+        RumbleStreamConfig rumble;
         CustomStreamConfig custom;
         ConfigHotkey start_stop_hotkey;
     };
@@ -89,8 +107,6 @@ namespace gsr {
     struct RecordConfig {
         RecordOptions record_options;
         bool save_video_in_game_folder = false;
-        bool show_recording_started_notifications = true;
-        bool show_video_saved_notifications = true;
         std::string save_directory;
         std::string container = "mp4";
         ConfigHotkey start_stop_hotkey;
@@ -102,14 +118,14 @@ namespace gsr {
         std::string turn_on_replay_automatically_mode = "dont_turn_on_automatically";
         bool save_video_in_game_folder = false;
         bool restart_replay_on_save = false;
-        bool show_replay_started_notifications = true;
-        bool show_replay_stopped_notifications = true;
-        bool show_replay_saved_notifications = true;
         std::string save_directory;
         std::string container = "mp4";
         int32_t replay_time = 60;
+        std::string replay_storage = "ram";
         ConfigHotkey start_stop_hotkey;
         ConfigHotkey save_hotkey;
+        ConfigHotkey save_1_min_hotkey;
+        ConfigHotkey save_10_min_hotkey;
     };
 
     struct ScreenshotConfig {
@@ -123,10 +139,13 @@ namespace gsr {
         bool restore_portal_session = true;
 
         bool save_screenshot_in_game_folder = false;
-        bool show_screenshot_saved_notifications = true;
+        bool save_screenshot_to_clipboard = false;
+        bool show_notifications = true;
+        bool use_led_indicator = false;
         std::string save_directory;
         ConfigHotkey take_screenshot_hotkey;
         ConfigHotkey take_screenshot_region_hotkey;
+        ConfigHotkey take_screenshot_window_hotkey; // Or desktop portal, on wayland
     };
 
     struct Config {

include/CursorTracker/CursorTrackerWayland.hpp

@@ -34,6 +34,7 @@ namespace gsr {
         std::vector<WaylandOutput> monitors;
         struct zxdg_output_manager_v1 *xdg_output_manager = nullptr;
     private:
+        void clear_monitors();
         void set_monitor_outputs_from_xdg_output(struct wl_display *dpy);
     private:
         int drm_fd = -1;

include/GlobalHotkeys/GlobalHotkeysJoystick.hpp

@@ -1,11 +1,13 @@
 #pragma once
 
 #include "GlobalHotkeys.hpp"
-#include "Hotplug.hpp"
+#include "../Hotplug.hpp"
 #include <unordered_map>
 #include <thread>
+#include <mutex>
+#include <condition_variable>
 #include <poll.h>
-#include <linux/joystick.h>
+#include <linux/input.h>
 
 namespace gsr {
     static constexpr int max_js_poll_fd = 16;
@@ -21,6 +23,8 @@ namespace gsr {
         bool start();
         // Currently valid ids:
         // save_replay
+        // save_1_min_replay
+        // save_10_min_replay
         // take_screenshot
         // toggle_record
         // toggle_replay
@@ -28,8 +32,10 @@ namespace gsr {
         bool bind_action(const std::string &id, GlobalHotkeyCallback callback) override;
         void poll_events() override;
     private:
+        void close_fds();
         void read_events();
-        void process_js_event(int fd, js_event &event);
+        void process_input_event(int fd, input_event &event);
+        void add_all_joystick_devices();
         bool add_device(const char *dev_input_filepath, bool print_error = true);
         bool remove_device(const char *dev_input_filepath);
         bool remove_poll_fd(int index);
@@ -43,6 +49,11 @@ namespace gsr {
         std::unordered_map<std::string, GlobalHotkeyCallback> bound_actions_by_id;
         std::thread read_thread;
 
+        std::thread close_fd_thread;
+        std::vector<int> fds_to_close;
+        std::mutex close_fd_mutex;
+        std::condition_variable close_fd_cv;
+
         pollfd poll_fd[max_js_poll_fd];
         ExtraData extra_data[max_js_poll_fd];
         int num_poll_fd = 0;
@@ -56,6 +67,8 @@ namespace gsr {
         bool right_pressed = false;
 
         bool save_replay = false;
+        bool save_1_min_replay = false;
+        bool save_10_min_replay = false;
         bool take_screenshot = false;
         bool toggle_record = false;
         bool toggle_replay = false;

include/GlobalHotkeys/GlobalHotkeysLinux.hpp

@@ -9,7 +9,8 @@ namespace gsr {
     public:
         enum class GrabType {
             ALL,
-            VIRTUAL
+            VIRTUAL,
+            NO_GRAB
         };
 
         GlobalHotkeysLinux(GrabType grab_type);
@@ -21,6 +22,10 @@ namespace gsr {
         bool bind_key_press(Hotkey hotkey, const std::string &id, GlobalHotkeyCallback callback) override;
         void unbind_all_keys() override;
         void poll_events() override;
+
+        std::function<void()> on_gsr_ui_virtual_keyboard_grabbed;
+    private:
+        void close_fds();
     private:
         pid_t process_id = 0;
         int read_pipes[2];

include/LedIndicator.hpp

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <sys/types.h>
+#include <mglpp/system/Clock.hpp>
+
+namespace gsr {
+    class LedIndicator {
+    public:
+        LedIndicator();
+        LedIndicator(const LedIndicator&) = delete;
+        LedIndicator& operator=(const LedIndicator&) = delete;
+        ~LedIndicator();
+
+        void set_led(bool enabled);
+        void blink();
+        void update();
+    private:
+        bool run_gsr_global_hotkeys_set_leds(bool enabled);
+        void update_led(bool new_state);
+    private:
+        pid_t gsr_global_hotkeys_pid = -1;
+        bool led_indicator_on = false;
+        bool led_enabled = false;
+        bool perform_blink = false;
+        mgl::Clock blink_timer;
+    };
+}

include/Overlay.hpp

@@ -6,10 +6,13 @@
 #include "Config.hpp"
 #include "window_texture.h"
 #include "WindowUtils.hpp"
-#include "GlobalHotkeysJoystick.hpp"
+#include "GlobalHotkeys/GlobalHotkeysJoystick.hpp"
 #include "AudioPlayer.hpp"
 #include "RegionSelector.hpp"
-#include "CursorTracker.hpp"
+#include "WindowSelector.hpp"
+#include "ClipboardFile.hpp"
+#include "LedIndicator.hpp"
+#include "CursorTracker/CursorTracker.hpp"
 
 #include <mglpp/window/Window.hpp>
 #include <mglpp/window/Event.hpp>
@@ -40,6 +43,22 @@ namespace gsr {
         SCREENSHOT
     };
 
+    enum class NotificationLevel {
+        INFO,
+        ERROR,
+    };
+
+    enum class ScreenshotForceType {
+        NONE,
+        REGION,
+        WINDOW
+    };
+
+    enum class NotificationSpeed {
+        NORMAL,
+        FAST
+    };
+
     class Overlay {
     public:
         Overlay(std::string resources_path, GsrInfo gsr_info, SupportedCaptureOptions capture_options, egl_functions egl_funcs);
@@ -52,28 +71,41 @@ namespace gsr {
         bool draw();
 
         void show();
-        void hide();
+        void hide_next_frame();
         void toggle_show();
         void toggle_record();
         void toggle_pause();
         void toggle_stream();
         void toggle_replay();
         void save_replay();
+        void save_replay_1_min();
+        void save_replay_10_min();
         void take_screenshot();
         void take_screenshot_region();
-        void show_notification(const char *str, double timeout_seconds, mgl::Color icon_color, mgl::Color bg_color, NotificationType notification_type, const char *capture_target = nullptr);
+        void take_screenshot_window();
+        void show_notification(const char *str, double timeout_seconds, mgl::Color icon_color, mgl::Color bg_color, NotificationType notification_type, const char *capture_target = nullptr, NotificationLevel notification_level = NotificationLevel::INFO);
         bool is_open() const;
         bool should_exit(std::string &reason) const;
         void exit();
+        void go_back_to_old_ui();
 
         const Config& get_config() const;
 
         void unbind_all_keyboard_hotkeys();
         void rebind_all_keyboard_hotkeys();
+
+        void set_notification_speed(NotificationSpeed notification_speed);
+
+        bool global_hotkeys_ungrab_keyboard = false;
     private:
+        void update_upause_status();
+
+        void hide();
+
         void handle_keyboard_mapping_event();
         void on_event(mgl::Event &event);
 
+        void recreate_global_hotkeys(const char *hotkey_option);
         void create_frontpage_ui_components();
         void xi_setup();
         void handle_xi_events();
@@ -83,10 +115,12 @@ namespace gsr {
 
         void close_gpu_screen_recorder_output();
 
+        double get_time_passed_in_replay_buffer_seconds();
         void update_notification_process_status();
         void save_video_in_current_game_directory(const char *video_filepath, NotificationType notification_type);
         void on_replay_saved(const char *replay_saved_filepath);
-        void update_gsr_replay_save();
+        void process_gsr_output();
+        void on_gsr_process_error(int exit_code, NotificationType notification_type);
         void update_gsr_process_status();
         void update_gsr_screenshot_process_status();
 
@@ -95,7 +129,7 @@ namespace gsr {
         void update_power_supply_status();
         void update_system_startup_status();
 
-        void on_stop_recording(int exit_code);
+        void on_stop_recording(int exit_code, const std::string &video_filepath);
 
         void update_ui_recording_paused();
         void update_ui_recording_unpaused();
@@ -109,11 +143,14 @@ namespace gsr {
         void update_ui_replay_started();
         void update_ui_replay_stopped();
 
+        void prepare_gsr_output_for_reading();
         void on_press_save_replay();
-        bool on_press_start_replay(bool disable_notification, bool finished_region_selection);
-        void on_press_start_record(bool finished_region_selection);
-        void on_press_start_stream(bool finished_region_selection);
-        void on_press_take_screenshot(bool finished_region_selection, bool force_region_capture);
+        void on_press_save_replay_1_min_replay();
+        void on_press_save_replay_10_min_replay();
+        bool on_press_start_replay(bool disable_notification, bool finished_selection);
+        void on_press_start_record(bool finished_selection);
+        void on_press_start_stream(bool finished_selection);
+        void on_press_take_screenshot(bool finished_selection, ScreenshotForceType force_type);
         bool update_compositor_texture(const Monitor &monitor);
 
         std::string get_capture_target(const std::string &capture_target, const SupportedCaptureOptions &capture_options);
@@ -132,6 +169,7 @@ namespace gsr {
         GsrInfo gsr_info;
         egl_functions egl_funcs;
         Config config;
+        Config current_recording_config;
 
         bool visible = false;
 
@@ -168,6 +206,8 @@ namespace gsr {
 
         RecordingStatus recording_status = RecordingStatus::NONE;
         bool paused = false;
+        mgl::Clock paused_clock;
+        double paused_total_time_seconds = 0.0;
 
         mgl::Clock replay_status_update_clock;
         std::string power_supply_online_filepath;
@@ -196,24 +236,41 @@ namespace gsr {
 
         std::unique_ptr<GlobalHotkeys> global_hotkeys = nullptr;
         std::unique_ptr<GlobalHotkeysJoystick> global_hotkeys_js = nullptr;
-        Display *x11_mapping_display = nullptr;
+        Display *x11_dpy = nullptr;
         XEvent x11_mapping_xev;
 
         mgl::Clock replay_save_clock;
         bool replay_save_show_notification = false;
         ReplayStartupMode replay_startup_mode = ReplayStartupMode::TURN_ON_AT_SYSTEM_STARTUP;
         bool try_replay_startup = true;
+        bool replay_recording = false;
+        int replay_save_duration_min = 0;
+        mgl::Clock replay_duration_clock;
+        double replay_saved_duration_sec = 0.0;
+        bool replay_restart_on_save = false;
+
+        mgl::Clock recording_duration_clock;
 
         AudioPlayer audio_player;
+    
         RegionSelector region_selector;
         bool start_region_capture = false;
         std::function<void()> on_region_selected;
 
+        WindowSelector window_selector;
+        bool start_window_capture = false;
+        std::function<void()> on_window_selected;
+
         std::string recording_capture_target;
-        std::string replay_capture_target;
         std::string screenshot_capture_target;
 
         std::unique_ptr<CursorTracker> cursor_tracker;
         mgl::Clock cursor_tracker_update_clock;
+
+        bool hide_ui = false;
+        double notification_duration_multiplier = 1.0;
+        ClipboardFile clipboard_file;
+
+        std::unique_ptr<LedIndicator> led_indicator = nullptr;
     };
 }

include/RegionSelector.hpp

@@ -26,7 +26,6 @@ namespace gsr {
 
         bool failed() const;
         bool poll_events();
-        bool is_selected() const;
         bool take_selection();
         bool take_canceled();
         Region get_selection() const;

include/Rpc.hpp

@@ -4,31 +4,47 @@
 #include <functional>
 #include <unordered_map>
 #include <string>
+#include <poll.h>
 
-typedef struct _IO_FILE FILE;
+#define GSR_RPC_MAX_CONNECTIONS 8
+#define GSR_RPC_MAX_POLLS (1 + GSR_RPC_MAX_CONNECTIONS) /* +1 to include the socket_fd itself for accept */
+#define GSR_RPC_MAX_MESSAGE_SIZE 128
 
 namespace gsr {
     using RpcCallback = std::function<void(const std::string &name)>;
 
+    enum class RpcOpenResult {
+        OK,
+        CONNECTION_REFUSED,
+        ERROR
+    };
+
     class Rpc {
     public:
-        Rpc() = default;
+        struct PollData {
+            char buffer[GSR_RPC_MAX_MESSAGE_SIZE];
+            int buffer_size = 0;
+        };
+
+        Rpc();
         Rpc(const Rpc&) = delete;
         Rpc& operator=(const Rpc&) = delete;
         ~Rpc();
 
         bool create(const char *name);
-        bool open(const char *name);
+        RpcOpenResult 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);
+        void handle_client_data(int client_fd, PollData &poll_data);
     private:
-        int fd = 0;
-        FILE *file = nullptr;
-        std::string fifo_filepath;
+        int socket_fd = 0;
+        std::string socket_filepath;
+        struct pollfd polls[GSR_RPC_MAX_POLLS];
+        PollData polls_data[GSR_RPC_MAX_POLLS];
+        int num_polls = 0;
         std::unordered_map<std::string, RpcCallback> handlers_by_name;
     };
 }

include/SafeVector.hpp

@@ -1,8 +1,15 @@
 #pragma once
 
 #include <vector>
-#include <memory>
 #include <functional>
+#include <assert.h>
+#include "gui/Widget.hpp"
+
+template <typename T>
+struct SafeVectorItem {
+    T item;
+    bool alive = false;
+};
 
 // A vector that can be modified while iterating
 template <typename T>
@@ -10,64 +17,84 @@ class SafeVector {
 public:
     using PointerType = typename std::pointer_traits<T>::element_type*;
 
+    SafeVector() = default;
+    SafeVector(const SafeVector&) = delete;
+    SafeVector& operator=(const SafeVector&) = delete;
+    ~SafeVector() {
+        clear();
+    }
+
     void push_back(T item) {
-        data.push_back(std::move(item));
+        data.push_back({std::move(item), true});
+        ++num_items_alive;
     }
 
     // Safe to call when vector is empty
     // TODO: Make this iterator safe
     void pop_back() {
-        if(!data.empty())
+        if(!data.empty()) {
+            gsr::add_widget_to_remove(std::move(data.back().item));
             data.pop_back();
+            --num_items_alive;
+        }
     }
 
     // Might not remove the data immediately if inside for_each loop.
     // In that case the item is removed at the end of the loop.
     void remove(PointerType item_to_remove) {
-        if(for_each_depth == 0)
+        if(for_each_depth == 0) {
             remove_item(item_to_remove);
-        else
-            remove_queue.push_back(item_to_remove);
+            return;
+        }
+
+        SafeVectorItem<T> *item = get_item(item_to_remove);
+        if(item && item->alive) {
+            item->alive = false;
+            --num_items_alive;
+            has_items_to_remove = true;
+        }
     }
 
     // Safe to call when vector is empty, in which case it returns nullptr
     T* back() {
-        if(data.empty())
-            return nullptr;
-        else
-            return &data.back();
+        for(auto it = data.rbegin(), end = data.rend(); it != end; ++it) {
+            if(it->alive)
+                return &it->item;
+        }
+        return nullptr;
     }
 
     // TODO: Make this iterator safe
     void clear() {
+        for(auto &item : data) {
+            gsr::add_widget_to_remove(std::move(item.item));
+        }
         data.clear();
-        remove_queue.clear();
+        num_items_alive = 0;
     }
 
     // Return true from |callback| to continue. This function returns false if |callback| returned false
-    bool for_each(std::function<bool(T &t)> callback) {
+    bool for_each(std::function<bool(T &t)> callback, bool include_dead = false) {
         bool result = true;
         ++for_each_depth;
 
         for(size_t i = 0; i < data.size(); ++i) {
-            result = callback(data[i]);
-            if(!result)
-                break;
+            if(data[i].alive || include_dead) {
+                result = callback(data[i].item);
+                if(!result)
+                    break;
+            }
         }
 
         --for_each_depth;
-        if(for_each_depth == 0) {
-            for(PointerType item_to_remove : remove_queue) {
-                remove_item(item_to_remove);
-            }
-            remove_queue.clear();
-        }
+        if(for_each_depth == 0)
+            remove_dead_items();
 
         return result;
     }
 
     // Return true from |callback| to continue. This function returns false if |callback| returned false
-    bool for_each_reverse(std::function<bool(T &t)> callback) {
+    bool for_each_reverse(std::function<bool(T &t)> callback, bool include_dead = false) {
         bool result = true;
         ++for_each_depth;
 
@@ -80,50 +107,84 @@ public:
             if(i < 0)
                 break;
 
-            result = callback(data[i]);
-            if(!result)
-                break;
+            if(data[i].alive || include_dead) {
+                result = callback(data[i].item);
+                if(!result)
+                    break;
+            }
 
             --i;
         }
 
         --for_each_depth;
-        if(for_each_depth == 0) {
-            for(PointerType item_to_remove : remove_queue) {
-                remove_item(item_to_remove);
-            }
-            remove_queue.clear();
-        }
+        if(for_each_depth == 0)
+            remove_dead_items();
 
         return result;
     }
 
     T& operator[](size_t index) {
-        return data[index];
+        assert(index < data.size());
+        return data[index].item;
     }
 
     const T& operator[](size_t index) const {
-        return data[index];
+        assert(index < data.size());
+        return data[index].item;
     }
 
     size_t size() const {
-        return data.size();
+        return (size_t)num_items_alive;
     }
 
     bool empty() const {
-        return data.empty();
+        return num_items_alive == 0;
+    }
+
+    void replace_item(PointerType item_to_replace, T new_item) {
+        SafeVectorItem<T> *item = get_item(item_to_replace);
+        if(item->alive) {
+            gsr::add_widget_to_remove(std::move(item->item));
+            item->item = std::move(new_item);
+        }
     }
 private:
     void remove_item(PointerType item_to_remove) {
         for(auto it = data.begin(), end = data.end(); it != end; ++it) {
-            if(&*(*it) == item_to_remove) {
+            if(&*(it->item) == item_to_remove) {
+                gsr::add_widget_to_remove(std::move(it->item));
                 data.erase(it);
+                --num_items_alive;
                 return;
             }
         }
     }
+
+    SafeVectorItem<T>* get_item(PointerType item_to_remove) {
+        for(auto &item : data) {
+            if(&*(item.item) == item_to_remove)
+                return &item;
+        }
+        return nullptr;
+    }
+
+    void remove_dead_items() {
+        if(!has_items_to_remove)
+            return;
+
+        for(auto it = data.begin(); it != data.end();) {
+            if(it->alive) {
+                ++it;
+            } else {
+                gsr::add_widget_to_remove(std::move(it->item));
+                it = data.erase(it);
+            }
+        }
+        has_items_to_remove = false;
+    }
 private:
-    std::vector<T> data;
-    std::vector<PointerType> remove_queue;
+    std::vector<SafeVectorItem<T>> data;
     int for_each_depth = 0;
+    int num_items_alive = 0;
+    bool has_items_to_remove = false;
 };

include/Theme.hpp

@@ -28,6 +28,7 @@ namespace gsr {
         mgl::Texture combobox_arrow_texture;
         mgl::Texture settings_texture;
         mgl::Texture settings_small_texture;
+        mgl::Texture settings_extra_small_texture;
         mgl::Texture folder_texture;
         mgl::Texture up_arrow_texture;
         mgl::Texture replay_button_texture;
@@ -42,6 +43,9 @@ namespace gsr {
         mgl::Texture pause_texture;
         mgl::Texture save_texture;
         mgl::Texture screenshot_texture;
+        mgl::Texture trash_texture;
+        mgl::Texture masked_texture;
+        mgl::Texture unmasked_texture;
 
         mgl::Texture ps4_home_texture;
         mgl::Texture ps4_options_texture;
@@ -49,6 +53,8 @@ namespace gsr {
         mgl::Texture ps4_dpad_down_texture;
         mgl::Texture ps4_dpad_left_texture;
         mgl::Texture ps4_dpad_right_texture;
+        mgl::Texture ps4_cross_texture;
+        mgl::Texture ps4_triangle_texture;
 
         double double_click_timeout_seconds = 0.4;
 

include/Utils.hpp

@@ -14,6 +14,9 @@ namespace gsr {
     using StringSplitCallback = std::function<bool(std::string_view line)>;
 
     void string_split_char(std::string_view str, char delimiter, StringSplitCallback callback_func);
+    bool starts_with(std::string_view str, const char *substr);
+    bool ends_with(std::string_view str, const char *substr);
+    std::string strip(const std::string &str);
 
     std::string get_home_dir();
     std::string get_config_dir();

include/WindowSelector.hpp

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <X11/Xlib.h>
+
+#include <mglpp/graphics/Color.hpp>
+
+namespace gsr {
+    class WindowSelector {
+    public:
+        WindowSelector();
+        WindowSelector(const WindowSelector&) = delete;
+        WindowSelector& operator=(const WindowSelector&) = delete;
+        ~WindowSelector();
+
+        bool start(mgl::Color border_color);
+        void stop();
+        bool is_started() const;
+
+        bool failed() const;
+        bool poll_events();
+        bool take_selection();
+        bool take_canceled();
+        Window get_selection() const;
+    private:
+        Display *dpy = nullptr;
+        Cursor crosshair_cursor = None;
+        Colormap border_window_colormap = None;
+        Window border_window = None;
+        Window selected_window = None;
+        bool selected = false;
+        bool canceled = false;
+    };
+}

include/WindowUtils.hpp

@@ -24,6 +24,7 @@ namespace gsr {
     std::string get_window_name_at_position(Display *dpy, mgl::vec2i position, Window ignore_window);
     std::string get_window_name_at_cursor_position(Display *dpy, Window ignore_window);
     void set_window_size_not_resizable(Display *dpy, Window window, int width, int height);
+    Window window_get_target_window_child(Display *display, Window window);
     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);

include/gui/ComboBox.hpp

@@ -19,7 +19,9 @@ namespace gsr {
         void draw(mgl::Window &window, mgl::vec2f offset) override;
 
         void add_item(const std::string &text, const std::string &id);
+        // The item can only be selected if it's enabled
         void set_selected_item(const std::string &id, bool trigger_event = true, bool trigger_event_even_if_selection_not_changed = true);
+        void set_item_enabled(const std::string &id, bool enabled);
         const std::string& get_selected_id() const;
 
         mgl::vec2f get_size() override;
@@ -36,6 +38,7 @@ namespace gsr {
             mgl::Text text;
             std::string id;
             mgl::vec2f position;
+            bool enabled = true;
         };
 
         mgl::vec2f max_size;

include/gui/DropdownButton.hpp

@@ -21,6 +21,7 @@ namespace gsr {
         void set_item_label(const std::string &id, const std::string &new_label);
         void set_item_icon(const std::string &id, mgl::Texture *texture);
         void set_item_description(const std::string &id, const std::string &new_description);
+        void set_item_enabled(const std::string &id, bool enabled);
 
         void set_description(std::string description_text);
         void set_activated(bool activated);
@@ -36,6 +37,7 @@ namespace gsr {
             mgl::Text description_text;
             mgl::Texture *icon_texture = nullptr;
             std::string id;
+            bool enabled = true;
         };
 
         std::vector<Item> items;

include/gui/Entry.hpp

@@ -4,13 +4,31 @@
 #include <functional>
 
 #include <mglpp/graphics/Color.hpp>
-#include <mglpp/graphics/Text.hpp>
+#include <mglpp/graphics/Text32.hpp>
+#include <mglpp/graphics/Rectangle.hpp>
 
 namespace gsr {
-    using EntryValidateHandler = std::function<bool(std::string &str)>;
+    class Entry;
+
+    enum class EntryValidateHandlerResult {
+        DENY,
+        ALLOW,
+        REPLACED
+    };
+    using EntryValidateHandler = std::function<EntryValidateHandlerResult(Entry &entry, const std::u32string &str)>;
+
+    struct CaretIndexPos {
+        int index;
+        mgl::vec2f pos;
+    };
 
     class Entry : public Widget {
     public:
+        enum class Direction {
+            LEFT,
+            RIGHT
+        };
+
         Entry(mgl::Font *font, const char *text, float max_width);
         Entry(const Entry&) = delete;
         Entry& operator=(const Entry&) = delete;
@@ -20,8 +38,11 @@ namespace gsr {
 
         mgl::vec2f get_size() override;
 
-        void set_text(std::string str);
-        const std::string& get_text() const;
+        EntryValidateHandlerResult set_text(const std::string &str);
+        std::string get_text() const;
+
+        void set_masked(bool masked);
+        bool is_masked() const;
 
         // Return false to specify that the string should not be accepted. This reverts the string back to its previous value.
         // The input can be changed by changing the input parameter and returning true.
@@ -29,10 +50,31 @@ namespace gsr {
 
         std::function<void(const std::string &text)> on_changed;
     private:
-        mgl::Text text;
+        // Also updates the cursor position
+        void replace_text(size_t index, size_t size, const std::u32string &replacement);
+        void move_caret_word(Direction direction, size_t max_codepoints);
+        EntryValidateHandlerResult set_text_internal(std::u32string str);
+        void draw_caret(mgl::Window &window, mgl::vec2f draw_pos, mgl::vec2f caret_size);
+        void draw_caret_selection(mgl::Window &window, mgl::vec2f draw_pos, mgl::vec2f caret_size);
+        CaretIndexPos find_closest_caret_index_by_position(mgl::vec2f position);
+    private:
+        struct Caret {
+            float offset_x = 0.0f;
+            int index = 0;
+        };
+
+        mgl::Rectangle background;
+        mgl::Text32 text;
+        mgl::Text32 masked_text;
         float max_width;
         bool selected = false;
-        float caret_offset_x = 0.0f;
+        bool selecting_text = false;
+        bool selecting_with_keyboard = false;
+        bool show_selection = false;
+        bool masked = false;
+        Caret caret;
+        Caret selection_start_caret;
+        float text_overflow = 0.0f;
     };
 
     EntryValidateHandler create_entry_validator_integer_in_range(int min, int max);

include/gui/GlobalSettingsPage.hpp

@@ -22,11 +22,14 @@ namespace gsr {
         NONE,
         REPLAY_START_STOP,
         REPLAY_SAVE,
+        REPLAY_SAVE_1_MIN,
+        REPLAY_SAVE_10_MIN,
         RECORD_START_STOP,
         RECORD_PAUSE_UNPAUSE,
         STREAM_START_STOP,
         TAKE_SCREENSHOT,
         TAKE_SCREENSHOT_REGION,
+        TAKE_SCREENSHOT_WINDOW,
         SHOW_HIDE
     };
 
@@ -56,17 +59,21 @@ namespace gsr {
         std::unique_ptr<RadioButton> create_enable_joystick_hotkeys_button();
         std::unique_ptr<List> create_show_hide_hotkey_options();
         std::unique_ptr<List> create_replay_hotkey_options();
+        std::unique_ptr<List> create_replay_partial_save_hotkey_options();
         std::unique_ptr<List> create_record_hotkey_options();
         std::unique_ptr<List> create_stream_hotkey_options();
         std::unique_ptr<List> create_screenshot_hotkey_options();
         std::unique_ptr<List> create_screenshot_region_hotkey_options();
+        std::unique_ptr<List> create_screenshot_window_hotkey_options();
         std::unique_ptr<List> create_hotkey_control_buttons();
         std::unique_ptr<Subsection> create_keyboard_hotkey_subsection(ScrollablePage *parent_page);
         std::unique_ptr<Subsection> create_controller_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<List> create_notification_speed();
         std::unique_ptr<Subsection> create_application_options_subsection(ScrollablePage *parent_page);
         std::unique_ptr<Subsection> create_application_info_subsection(ScrollablePage *parent_page);
+        std::unique_ptr<Subsection> create_donate_subsection(ScrollablePage *parent_page);
         void add_widgets();
 
         Button* configure_hotkey_get_button_by_active_type();
@@ -89,12 +96,16 @@ namespace gsr {
 
         Button *turn_replay_on_off_button_ptr = nullptr;
         Button *save_replay_button_ptr = nullptr;
+        Button *save_replay_1_min_button_ptr = nullptr;
+        Button *save_replay_10_min_button_ptr = nullptr;
         Button *start_stop_recording_button_ptr = nullptr;
         Button *pause_unpause_recording_button_ptr = nullptr;
         Button *start_stop_streaming_button_ptr = nullptr;
         Button *take_screenshot_button_ptr = nullptr;
         Button *take_screenshot_region_button_ptr = nullptr;
+        Button *take_screenshot_window_button_ptr = nullptr;
         Button *show_hide_button_ptr = nullptr;
+        RadioButton *notification_speed_button_ptr = nullptr;
 
         ConfigHotkey configure_config_hotkey;
         ConfigureHotkeyType configure_hotkey_type = ConfigureHotkeyType::NONE;

include/gui/List.hpp

@@ -21,19 +21,20 @@ namespace gsr {
         List(Orientation orientation, Alignment content_alignment = Alignment::START);
         List(const List&) = delete;
         List& operator=(const List&) = delete;
+        virtual ~List() override;
 
         bool on_event(mgl::Event &event, mgl::Window &window, mgl::vec2f offset) override;
         void draw(mgl::Window &window, mgl::vec2f offset) override;
 
-        //void remove_child_widget(Widget *widget) override;
-
         void add_widget(std::unique_ptr<Widget> widget);
         void remove_widget(Widget *widget);
+        void replace_widget(Widget *widget, std::unique_ptr<Widget> new_widget);
         void clear();
         // Return true from |callback| to continue
         void for_each_child_widget(std::function<bool(std::unique_ptr<Widget> &widget)> callback);
         // Returns nullptr if index is invalid
         Widget* get_child_widget_by_index(size_t index) const;
+        size_t get_num_children() const;
 
         void set_spacing(float spacing);
 

include/gui/Page.hpp

@@ -10,13 +10,11 @@ namespace gsr {
         Page() = default;
         Page(const Page&) = delete;
         Page& operator=(const Page&) = delete;
-        virtual ~Page() = default;
+        virtual ~Page() override;
 
         virtual void on_navigate_to_page() {}
         virtual void on_navigate_away_from_page() {}
 
-        //void remove_child_widget(Widget *widget) override;
-
         virtual void add_widget(std::unique_ptr<Widget> widget);
     protected:
         SafeVector<std::unique_ptr<Widget>> widgets;

include/gui/RadioButton.hpp

@@ -23,7 +23,8 @@ namespace gsr {
 
         void add_item(const std::string &text, const std::string &id);
         void set_selected_item(const std::string &id, bool trigger_event = true, bool trigger_event_even_if_selection_not_changed = true);
-        const std::string get_selected_id() const;
+        const std::string& get_selected_id() const;
+        const std::string& get_selected_text() const;
 
         mgl::vec2f get_size() override;
 

include/gui/ScreenshotSettingsPage.hpp

@@ -26,7 +26,6 @@ namespace gsr {
     private:
         std::unique_ptr<ComboBox> create_record_area_box();
         std::unique_ptr<Widget> create_record_area();
-        std::unique_ptr<List> create_select_window();
         std::unique_ptr<Entry> create_image_width_entry();
         std::unique_ptr<Entry> create_image_height_entry();
         std::unique_ptr<List> create_image_resolution();
@@ -43,8 +42,11 @@ namespace gsr {
         std::unique_ptr<List> create_image_format_section();
         std::unique_ptr<Widget> create_file_info_section();
         std::unique_ptr<CheckBox> create_save_screenshot_in_game_folder();
+        std::unique_ptr<CheckBox> create_save_screenshot_to_clipboard();
+        std::unique_ptr<Widget> create_notifications();
+        std::unique_ptr<Widget> create_led_indicator();
         std::unique_ptr<Widget> create_general_section();
-        std::unique_ptr<Widget> create_notifications_section();
+        std::unique_ptr<Widget> create_screenshot_indicator_section();
         std::unique_ptr<Widget> create_settings();
         void add_widgets();
 
@@ -56,7 +58,6 @@ namespace gsr {
 
         GsrPage *content_page_ptr = nullptr;
         ScrollablePage *settings_scrollable_page_ptr = nullptr;
-        List *select_window_list_ptr = nullptr;
         List *image_resolution_list_ptr = nullptr;
         List *restore_portal_session_list_ptr = nullptr;
         List *color_range_list_ptr = nullptr;
@@ -71,7 +72,9 @@ namespace gsr {
         ComboBox *image_format_box_ptr = nullptr;
         Button *save_directory_button_ptr = nullptr;
         CheckBox *save_screenshot_in_game_folder_checkbox_ptr = nullptr;
-        CheckBox *show_screenshot_saved_notification_checkbox_ptr = nullptr;
+        CheckBox *save_screenshot_to_clipboard_checkbox_ptr = nullptr;
+        CheckBox *show_notification_checkbox_ptr = nullptr;
+        CheckBox *led_indicator_checkbox_ptr = nullptr;
 
         PageStack *page_stack = nullptr;
     };

include/gui/ScrollablePage.hpp

@@ -12,6 +12,7 @@ namespace gsr {
         ScrollablePage(mgl::vec2f size);
         ScrollablePage(const ScrollablePage&) = delete;
         ScrollablePage& operator=(const ScrollablePage&) = delete;
+        virtual ~ScrollablePage() override;
 
         bool on_event(mgl::Event &event, mgl::Window &window, mgl::vec2f offset) override;
         void draw(mgl::Window &window, mgl::vec2f offset) override;

include/gui/SettingsPage.hpp

@@ -18,6 +18,12 @@ namespace gsr {
     class ScrollablePage;
     class Label;
     class LineSeparator;
+    class Subsection;
+
+    enum class AudioDeviceType {
+        OUTPUT,
+        INPUT
+    };
 
     class SettingsPage : public StaticPage {
     public:
@@ -40,7 +46,6 @@ namespace gsr {
         std::unique_ptr<RadioButton> create_view_radio_button();
         std::unique_ptr<ComboBox> create_record_area_box();
         std::unique_ptr<Widget> create_record_area();
-        std::unique_ptr<List> create_select_window();
         std::unique_ptr<Entry> create_area_width_entry();
         std::unique_ptr<Entry> create_area_height_entry();
         std::unique_ptr<List> create_area_size();
@@ -53,20 +58,22 @@ namespace gsr {
         std::unique_ptr<List> create_restore_portal_session_section();
         std::unique_ptr<Widget> create_change_video_resolution_section();
         std::unique_ptr<Widget> create_capture_target_section();
-        std::unique_ptr<ComboBox> create_audio_device_selection_combobox();
-        std::unique_ptr<Button> create_remove_audio_device_button(List *audio_device_list_ptr);
-        std::unique_ptr<List> create_audio_device();
-        std::unique_ptr<Button> create_add_audio_device_button();
-        std::unique_ptr<ComboBox> create_application_audio_selection_combobox();
-        std::unique_ptr<List> create_application_audio();
-        std::unique_ptr<List> create_custom_application_audio();
-        std::unique_ptr<Button> create_add_application_audio_button();
-        std::unique_ptr<Button> create_add_custom_application_audio_button();
-        std::unique_ptr<List> create_add_audio_buttons();
-        std::unique_ptr<List> create_audio_track_track_section();
-        std::unique_ptr<CheckBox> create_split_audio_checkbox();
+        std::unique_ptr<ComboBox> create_audio_device_selection_combobox(AudioDeviceType device_type);
+        std::unique_ptr<Button> create_remove_audio_device_button(List *audio_input_list_ptr, List *audio_device_list_ptr);
+        std::unique_ptr<List> create_audio_device(AudioDeviceType device_type, List *audio_input_list_ptr);
+        std::unique_ptr<Button> create_add_audio_track_button();
+        std::unique_ptr<Button> create_add_audio_output_device_button(List *audio_input_list_ptr);
+        std::unique_ptr<Button> create_add_audio_input_device_button(List *audio_input_list_ptr);
+        std::unique_ptr<ComboBox> create_application_audio_selection_combobox(List *application_audio_row);
+        std::unique_ptr<List> create_application_audio(List *audio_input_list_ptr);
+        std::unique_ptr<List> create_custom_application_audio(List *audio_input_list_ptr);
+        std::unique_ptr<Button> create_add_application_audio_button(List *audio_input_list_ptr);
+        std::unique_ptr<List> create_add_audio_buttons(List *audio_input_list_ptr);
+        std::unique_ptr<List> create_audio_input_section();
         std::unique_ptr<CheckBox> create_application_audio_invert_checkbox();
-        std::unique_ptr<Widget> create_audio_track_section();
+        std::unique_ptr<List> create_audio_track_title_and_remove(Subsection *audio_track_subsection, const char *title);
+        std::unique_ptr<Subsection> create_audio_track_section(Widget *parent_widget);
+        std::unique_ptr<List> create_audio_track_section_list();
         std::unique_ptr<Widget> create_audio_section();
         std::unique_ptr<List> create_video_quality_box();
         std::unique_ptr<List> create_video_bitrate_entry();
@@ -95,24 +102,30 @@ namespace gsr {
         std::unique_ptr<List> create_container_section();
         std::unique_ptr<List> create_replay_time_entry();
         std::unique_ptr<List> create_replay_time();
+        std::unique_ptr<List> create_replay_storage();
         std::unique_ptr<RadioButton> create_start_replay_automatically();
         std::unique_ptr<CheckBox> create_save_replay_in_game_folder();
         std::unique_ptr<CheckBox> create_restart_replay_on_save();
         std::unique_ptr<Label> create_estimated_replay_file_size();
-        void update_estimated_replay_file_size();
+        void update_estimated_replay_file_size(const std::string &replay_storage_type);
         void update_replay_time_text();
         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();
+        std::unique_ptr<CheckBox> create_led_indicator(const char *type);
+        std::unique_ptr<CheckBox> create_notifications(const char *type);
+        std::unique_ptr<List> create_indicator(const char *type);
         void add_replay_widgets();
         void add_record_widgets();
 
         std::unique_ptr<ComboBox> create_streaming_service_box();
         std::unique_ptr<List> create_streaming_service_section();
         std::unique_ptr<List> create_stream_key_section();
-        std::unique_ptr<List> create_stream_url_section();
+        std::unique_ptr<List> create_stream_custom_url();
+        std::unique_ptr<List> create_stream_custom_key();
+        std::unique_ptr<List> create_stream_custom_section();
         std::unique_ptr<ComboBox> create_stream_container_box();
-        std::unique_ptr<List> create_stream_container_section();
+        std::unique_ptr<List> create_stream_container();
         void add_stream_widgets();
 
         void load_audio_tracks(const RecordOptions &record_options);
@@ -125,6 +138,8 @@ namespace gsr {
         void save_replay();
         void save_record();
         void save_stream();
+
+        void view_changed(bool advanced_view);
     private:
         Type type;
         Config &config;
@@ -136,7 +151,6 @@ namespace gsr {
         GsrPage *content_page_ptr = nullptr;
         ScrollablePage *settings_scrollable_page_ptr = nullptr;
         List *settings_list_ptr = nullptr;
-        List *select_window_list_ptr = nullptr;
         List *area_size_list_ptr = nullptr;
         List *video_resolution_list_ptr = nullptr;
         List *restore_portal_session_list_ptr = nullptr;
@@ -152,11 +166,6 @@ namespace gsr {
         Entry *framerate_entry_ptr = nullptr;
         Entry *video_bitrate_entry_ptr = nullptr;
         List *video_bitrate_list_ptr = nullptr;
-        List *audio_track_list_ptr = nullptr;
-        Button *add_application_audio_button_ptr = nullptr;
-        Button *add_custom_application_audio_button_ptr = nullptr;
-        CheckBox *split_audio_checkbox_ptr = nullptr;
-        CheckBox *application_audio_invert_checkbox_ptr = nullptr;
         CheckBox *change_video_resolution_checkbox_ptr = nullptr;
         ComboBox *color_range_box_ptr = nullptr;
         ComboBox *video_quality_box_ptr = nullptr;
@@ -169,26 +178,25 @@ namespace gsr {
         ComboBox *container_box_ptr = nullptr;
         ComboBox *streaming_service_box_ptr = nullptr;
         List *stream_key_list_ptr = nullptr;
-        List *stream_url_list_ptr = nullptr;
-        List *container_list_ptr = nullptr;
+        List *custom_stream_list_ptr = nullptr;
         CheckBox *save_replay_in_game_folder_ptr = nullptr;
         CheckBox *restart_replay_on_save = nullptr;
         Label *estimated_file_size_ptr = nullptr;
-        CheckBox *show_replay_started_notification_checkbox_ptr = nullptr;
-        CheckBox *show_replay_stopped_notification_checkbox_ptr = nullptr;
-        CheckBox *show_replay_saved_notification_checkbox_ptr = nullptr;
         CheckBox *save_recording_in_game_folder_ptr = nullptr;
-        CheckBox *show_recording_started_notification_checkbox_ptr = nullptr;
-        CheckBox *show_video_saved_notification_checkbox_ptr = nullptr;
-        CheckBox *show_streaming_started_notification_checkbox_ptr = nullptr;
-        CheckBox *show_streaming_stopped_notification_checkbox_ptr = nullptr;
         Button *save_directory_button_ptr = nullptr;
         Entry *twitch_stream_key_entry_ptr = nullptr;
         Entry *youtube_stream_key_entry_ptr = nullptr;
+        Entry *rumble_stream_key_entry_ptr = nullptr;
         Entry *stream_url_entry_ptr = nullptr;
+        Entry *stream_key_entry_ptr = nullptr;
         Entry *replay_time_entry_ptr = nullptr;
+        RadioButton *replay_storage_button_ptr = nullptr;
         Label *replay_time_label_ptr = nullptr;
         RadioButton *turn_on_replay_automatically_mode_ptr = nullptr;
+        Subsection *audio_section_ptr = nullptr;
+        List *audio_track_section_list_ptr = nullptr;
+        CheckBox *led_indicator_checkbox_ptr = nullptr;
+        CheckBox *show_notification_checkbox_ptr = nullptr;
 
         PageStack *page_stack = nullptr;
     };

include/gui/Subsection.hpp

@@ -11,15 +11,20 @@ namespace gsr {
         Subsection(const char *title, std::unique_ptr<Widget> inner_widget, mgl::vec2f size);
         Subsection(const Subsection&) = delete;
         Subsection& operator=(const Subsection&) = delete;
+        virtual ~Subsection() override;
 
         bool on_event(mgl::Event &event, mgl::Window &window, mgl::vec2f offset) override;
         void draw(mgl::Window &window, mgl::vec2f offset) override;
 
         mgl::vec2f get_size() override;
         mgl::vec2f get_inner_size() override;
+
+        Widget* get_inner_widget();
+        void set_bg_color(mgl::Color color);
     private:
         Label label;
         std::unique_ptr<Widget> inner_widget;
         mgl::vec2f size;
+        mgl::Color bg_color{25, 30, 34};
     };
 }

include/gui/Utils.hpp

@@ -2,6 +2,7 @@
 
 #include <mglpp/system/vec.hpp>
 #include <mglpp/graphics/Color.hpp>
+#include <mglpp/window/Window.hpp>
 
 namespace mgl {
     class Window;
@@ -14,4 +15,5 @@ namespace gsr {
     void set_frame_delta_seconds(double frame_delta);
     mgl::vec2f scale_keep_aspect_ratio(mgl::vec2f from, mgl::vec2f to);
     mgl::vec2f clamp_keep_aspect_ratio(mgl::vec2f from, mgl::vec2f to);
+    mgl::Scissor scissor_get_sub_area(mgl::Scissor parent, mgl::Scissor child);
 }

include/gui/Widget.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <mglpp/system/vec.hpp>
+#include <memory>
 
 namespace mgl {
     class Event;
@@ -31,8 +32,6 @@ namespace gsr {
         virtual void draw(mgl::Window &window, mgl::vec2f offset) = 0;
         virtual void set_position(mgl::vec2f position);
 
-        //virtual void remove_child_widget(Widget *widget) { (void)widget; }
-
         virtual mgl::vec2f get_position() const;
         virtual mgl::vec2f get_size() = 0;
         // This can be different from get_size, for example with ScrollablePage this excludes the margins
@@ -46,6 +45,8 @@ namespace gsr {
 
         void set_visible(bool visible);
 
+        Widget* get_parent_widget();
+
         void *userdata = nullptr;
     protected:
         void set_widget_as_selected_in_parent();
@@ -61,4 +62,7 @@ namespace gsr {
 
         bool visible = true;
     };
+
+    void add_widget_to_remove(std::unique_ptr<Widget> widget);
+    void remove_widgets_to_be_removed();
 }

meson.build

@@ -1,4 +1,6 @@
-project('gsr-ui', ['c', 'cpp'], version : '1.3.3', default_options : ['warning_level=2', 'cpp_std=c++17'], subproject_dir : 'depends')
+project('gsr-ui', ['c', 'cpp'], version : '1.8.0', default_options : ['warning_level=2', 'cpp_std=c++17'], subproject_dir : 'depends')
+
+add_project_arguments('-D_FILE_OFFSET_BITS=64', language : ['c', 'cpp'])
 
 if get_option('buildtype') == 'debug'
     add_project_arguments('-g3', language : ['c', 'cpp'])
@@ -32,20 +34,23 @@ src = [
     'src/gui/GlobalSettingsPage.cpp',
     'src/gui/GsrPage.cpp',
     'src/gui/Subsection.cpp',
+    'src/GlobalHotkeys/GlobalHotkeysX11.cpp',
+    'src/GlobalHotkeys/GlobalHotkeysLinux.cpp',
+    'src/GlobalHotkeys/GlobalHotkeysJoystick.cpp',
+    'src/CursorTracker/CursorTrackerX11.cpp',
+    'src/CursorTracker/CursorTrackerWayland.cpp',
     'src/Utils.cpp',
     'src/WindowUtils.cpp',
     'src/RegionSelector.cpp',
+    'src/WindowSelector.cpp',
     'src/Config.cpp',
     'src/GsrInfo.cpp',
     'src/Process.cpp',
     'src/Overlay.cpp',
-    'src/GlobalHotkeysX11.cpp',
-    'src/GlobalHotkeysLinux.cpp',
-    'src/GlobalHotkeysJoystick.cpp',
-    'src/CursorTrackerX11.cpp',
-    'src/CursorTrackerWayland.cpp',
     'src/AudioPlayer.cpp',
     'src/Hotplug.cpp',
+    'src/ClipboardFile.cpp',
+    'src/LedIndicator.cpp',
     'src/Rpc.cpp',
     'src/main.cpp',
 ]
@@ -61,7 +66,7 @@ datadir = get_option('datadir')
 gsr_ui_resources_path = join_paths(prefix, datadir, 'gsr-ui')
 
 add_project_arguments('-DGSR_UI_VERSION="' + meson.project_version() + '"', language: ['c', 'cpp'])
-add_project_arguments('-DGSR_FLATPAK_VERSION="5.3.0"', language: ['c', 'cpp'])
+add_project_arguments('-DGSR_FLATPAK_VERSION="5.8.5"', language: ['c', 'cpp'])
 
 executable(
     meson.project_name(),
@@ -75,6 +80,7 @@ executable(
         dependency('xext'),
         dependency('xi'),
         dependency('xcursor'),
+        dependency('xrandr'),
         dependency('libpulse-simple'),
         dependency('libdrm'),
         dependency('wayland-client'),
@@ -88,6 +94,7 @@ executable(
         'tools/gsr-global-hotkeys/hotplug.c',
         'tools/gsr-global-hotkeys/keyboard_event.c',
         'tools/gsr-global-hotkeys/keys.c',
+        'tools/gsr-global-hotkeys/leds.c',
         'tools/gsr-global-hotkeys/main.c'
     ],
     c_args : '-fstack-protector-all',

project.conf

@@ -1,7 +1,7 @@
 [package]
 name = "gsr-ui"
 type = "executable"
-version = "1.3.3"
+version = "1.8.0"
 platforms = ["posix"]
 
 [lang.cpp]
@@ -10,12 +10,16 @@ version = "c++17"
 [config]
 ignore_dirs = ["build", "tools"]
 
+[define]
+_FILE_OFFSET_BITS = "64"
+
 [dependencies]
 xcomposite = ">=0"
 xfixes = ">=0"
 xext = ">=0"
 xi = ">=0"
 xcursor = ">=1"
+xrandr = ">=0.5"
 libpulse-simple = ">=0"
 libdrm = ">=2"
 wayland-client = ">=1"

src/ClipboardFile.cpp

@@ -0,0 +1,299 @@
+#include "../include/ClipboardFile.hpp"
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+#include <inttypes.h>
+#include <poll.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <X11/Xatom.h>
+
+#define FORMAT_I64 "%" PRIi64
+#define FORMAT_U64 "%" PRIu64
+
+namespace gsr {
+    ClipboardFile::ClipboardFile() {
+        dpy = XOpenDisplay(nullptr);
+        if(!dpy) {
+            fprintf(stderr, "gsr ui: error: ClipboardFile: failed to connect to the X11 server\n");
+            return;
+        }
+
+        clipboard_window = XCreateSimpleWindow(dpy, DefaultRootWindow(dpy), 0, 0, 8, 8, 0, 0, 0);
+        if(!clipboard_window) {
+            fprintf(stderr, "gsr ui: error: ClipboardFile: failed to create clipboard window\n");
+            XCloseDisplay(dpy);
+            dpy = nullptr;
+            return;
+        }
+
+        incr_atom = XInternAtom(dpy, "INCR", False);
+        targets_atom = XInternAtom(dpy, "TARGETS", False);
+        clipboard_atom = XInternAtom(dpy, "CLIPBOARD", False);
+        image_jpg_atom = XInternAtom(dpy, "image/jpg", False);
+        image_jpeg_atom = XInternAtom(dpy, "image/jpeg", False);
+        image_png_atom = XInternAtom(dpy, "image/png", False);
+
+        event_thread = std::thread([&]() {
+            pollfd poll_fds[1];
+            poll_fds[0].fd = ConnectionNumber(dpy);
+            poll_fds[0].events = POLLIN;
+            poll_fds[0].revents = 0;
+
+            XEvent xev;
+            while(running) {
+                poll(poll_fds, 1, 100);
+                while(XPending(dpy)) {
+                    XNextEvent(dpy, &xev);
+                    switch(xev.type) {
+                        case SelectionClear: {
+                            should_clear_selection = true;
+                            if(clipboard_copies.empty()) {
+                                should_clear_selection = false;
+                                set_current_file("", file_type);
+                            }
+                            break;
+                        }
+                        case SelectionRequest:
+                            send_clipboard_start(&xev.xselectionrequest);
+                            break;
+                        case PropertyNotify: {
+                            if(xev.xproperty.state == PropertyDelete) {
+                                std::lock_guard<std::mutex> lock(mutex);
+                                ClipboardCopy *clipboard_copy = get_clipboard_copy_by_requestor(xev.xproperty.window);
+                                if(!clipboard_copy || xev.xproperty.atom != clipboard_copy->property)
+                                    return;
+
+                                XSelectionRequestEvent xselectionrequest;
+                                xselectionrequest.display = xev.xproperty.display;;
+                                xselectionrequest.requestor = xev.xproperty.window;
+                                xselectionrequest.selection = clipboard_atom;
+                                xselectionrequest.target = clipboard_copy->requestor_target;
+                                xselectionrequest.property = clipboard_copy->property;
+                                xselectionrequest.time = xev.xproperty.time;
+                                transfer_clipboard_data(&xselectionrequest, clipboard_copy);
+                            }
+                            break;
+                        }
+                    }
+                }
+            }
+        });
+    }
+
+    ClipboardFile::~ClipboardFile() {
+        running = false;
+        if(event_thread.joinable())
+            event_thread.join();
+
+        if(file_fd > 0)
+            close(file_fd);
+
+        if(dpy) {
+            XDestroyWindow(dpy, clipboard_window);
+            XCloseDisplay(dpy);
+        }
+    }
+
+    bool ClipboardFile::file_type_matches_request_atom(FileType file_type, Atom request_atom) {
+        switch(file_type) {
+            case FileType::JPG:
+                return request_atom == image_jpg_atom || request_atom == image_jpeg_atom;
+            case FileType::PNG:
+                return request_atom == image_png_atom;
+        }
+        return false;
+    }
+
+    const char* ClipboardFile::file_type_clipboard_get_name(Atom request_atom) {
+        if(request_atom == image_jpg_atom)
+            return "image/jpg";
+        else if(request_atom == image_jpeg_atom)
+            return "image/jpeg";
+        else if(request_atom == image_png_atom)
+            return "image/png";
+        return "Unknown";
+    }
+
+    const char* ClipboardFile::file_type_get_name(FileType file_type) {
+        switch(file_type) {
+            case FileType::JPG:
+                return "image/jpeg";
+            case FileType::PNG:
+                return "image/png";
+        }
+        return "Unknown";
+    }
+
+    void ClipboardFile::send_clipboard_start(XSelectionRequestEvent *xselectionrequest) {
+        std::lock_guard<std::mutex> lock(mutex);
+        if(file_fd <= 0) {
+            fprintf(stderr, "gsr ui: warning: ClipboardFile::send_clipboard: requestor window " FORMAT_I64 " tried to get clipboard from us but we don't have any clipboard file open\n", (int64_t)xselectionrequest->requestor);
+            return;
+        }
+
+        if(xselectionrequest->selection != clipboard_atom) {
+            fprintf(stderr, "gsr ui: warning: ClipboardFile::send_clipboard: requestor window " FORMAT_I64 " tried to non-clipboard selection from us\n", (int64_t)xselectionrequest->requestor);
+            return;
+        }
+
+        XSelectionEvent selection_event;
+        selection_event.type = SelectionNotify;
+        selection_event.display = xselectionrequest->display;
+        selection_event.requestor = xselectionrequest->requestor;
+        selection_event.selection = xselectionrequest->selection;
+        selection_event.property = xselectionrequest->property;
+        selection_event.time = xselectionrequest->time;
+        selection_event.target = xselectionrequest->target;
+
+        if(xselectionrequest->target == targets_atom) {
+            int num_targets = 1;
+            Atom targets[4];
+            targets[0] = targets_atom;
+
+            switch(file_type) {
+                case FileType::JPG:
+                    num_targets = 4;
+                    targets[1] = image_jpg_atom;
+                    targets[2] = image_jpeg_atom;
+                    targets[3] = image_png_atom;
+                    break;
+                case FileType::PNG:
+                    num_targets = 2;
+                    targets[1] = image_png_atom;
+                    targets[2] = image_jpg_atom;
+                    targets[3] = image_jpeg_atom;
+                    break;
+            }
+
+            XChangeProperty(dpy, selection_event.requestor, selection_event.property, XA_ATOM, 32, PropModeReplace, (unsigned char*)targets, num_targets);
+        } else if(xselectionrequest->target == image_jpg_atom || xselectionrequest->target == image_jpeg_atom || xselectionrequest->target == image_png_atom) {
+            // TODO: Convert image to requested image type. Right now sending a jpg file when a png file is requested works ok in browsers (discord and element)
+            if(!file_type_matches_request_atom(file_type, xselectionrequest->target)) {
+                const char *expected_file_type = file_type_get_name(file_type);
+                fprintf(stderr, "gsr ui: warning: ClipboardFile::send_clipboard: requestor window " FORMAT_I64 " tried to request clipboard of type %s, but %s was expected. Ignoring requestor and sending as %s\n", (int64_t)xselectionrequest->requestor, file_type_clipboard_get_name(xselectionrequest->target), expected_file_type, expected_file_type);
+                //return;
+            }
+
+            ClipboardCopy *clipboard_copy = get_clipboard_copy_by_requestor(xselectionrequest->requestor);
+            if(!clipboard_copy) {
+                clipboard_copies.push_back({ xselectionrequest->requestor, 0 });
+                clipboard_copy = &clipboard_copies.back();
+            }
+
+            *clipboard_copy = { xselectionrequest->requestor, 0 };
+            clipboard_copy->property = selection_event.property;
+            clipboard_copy->requestor_target = selection_event.target;
+            XSelectInput(dpy, selection_event.requestor, PropertyChangeMask);
+
+            const long lower_bound = std::min((uint64_t)1<<16, file_size);
+            XChangeProperty(dpy, selection_event.requestor, selection_event.property, incr_atom, 32, PropModeReplace, (const unsigned char*)&lower_bound, 1);
+        } else {
+            char *target_clipboard_name = XGetAtomName(dpy, xselectionrequest->target);
+            fprintf(stderr, "gsr ui: warning: ClipboardFile::send_clipboard: requestor window " FORMAT_I64 " tried to request clipboard of type %s, expected TARGETS, image/jpg, image/jpeg or image/png\n", (int64_t)xselectionrequest->requestor, target_clipboard_name ? target_clipboard_name : "Unknown");
+            if(target_clipboard_name)
+                XFree(target_clipboard_name);
+            selection_event.property = None;
+        }
+
+        XSendEvent(dpy, selection_event.requestor, False, NoEventMask, (XEvent*)&selection_event);
+        XFlush(dpy);
+    }
+
+    void ClipboardFile::transfer_clipboard_data(XSelectionRequestEvent *xselectionrequest, ClipboardCopy *clipboard_copy) {
+        uint8_t file_buffer[1<<16];
+        ssize_t file_bytes_read = 0;
+
+        if(lseek(file_fd, clipboard_copy->file_offset, SEEK_SET) == -1) {
+            fprintf(stderr, "gsr ui: error: ClipboardFile::send_clipboard: failed to seek in clipboard file to offset " FORMAT_U64 " for requestor window " FORMAT_I64 ", error: %s\n", (uint64_t)clipboard_copy->file_offset, (int64_t)xselectionrequest->requestor, strerror(errno));
+            clipboard_copy->file_offset = 0;
+            // TODO: Cancel transfer
+            return;
+        }
+
+        file_bytes_read = read(file_fd, file_buffer, sizeof(file_buffer));
+        if(file_bytes_read < 0) {
+            fprintf(stderr, "gsr ui: error: ClipbaordFile::send_clipboard: failed to read data from offset " FORMAT_U64 " for requestor window " FORMAT_I64 ", error: %s\n", (uint64_t)clipboard_copy->file_offset, (int64_t)xselectionrequest->requestor, strerror(errno));
+            clipboard_copy->file_offset = 0;
+            // TODO: Cancel transfer
+            return;
+        }
+
+        XChangeProperty(dpy, xselectionrequest->requestor, xselectionrequest->property, xselectionrequest->target, 8, PropModeReplace, (const unsigned char*)file_buffer, file_bytes_read);
+        XSendEvent(dpy, xselectionrequest->requestor, False, NoEventMask, (XEvent*)xselectionrequest);
+        XFlush(dpy);
+
+        clipboard_copy->file_offset += file_bytes_read;
+        if(file_bytes_read == 0)
+            remove_clipboard_copy(clipboard_copy->requestor);
+    }
+
+    ClipboardCopy* ClipboardFile::get_clipboard_copy_by_requestor(Window requestor) {
+        for(ClipboardCopy &clipboard_copy : clipboard_copies) {
+            if(clipboard_copy.requestor == requestor)
+                return &clipboard_copy;
+        }
+        return nullptr;
+    }
+
+    void ClipboardFile::remove_clipboard_copy(Window requestor) {
+        for(auto it = clipboard_copies.begin(), end = clipboard_copies.end(); it != end; ++it) {
+            if(it->requestor == requestor) {
+                clipboard_copies.erase(it);
+                XSelectInput(dpy, requestor, 0);
+
+                if(clipboard_copies.empty() && should_clear_selection) {
+                    should_clear_selection = false;
+                    set_current_file("", file_type);
+                }
+                return;
+            }
+        }
+    }
+
+    void ClipboardFile::set_current_file(const std::string &filepath, FileType file_type) {
+        if(!dpy)
+            return;
+
+        std::lock_guard<std::mutex> lock(mutex);
+        for(ClipboardCopy &clipboard_copy : clipboard_copies) {
+            XSelectInput(dpy, clipboard_copy.requestor, 0);
+        }
+        clipboard_copies.clear();
+
+        if(filepath.empty()) {
+            if(file_fd > 0) {
+                close(file_fd);
+                file_fd = -1;
+            }
+            file_size = 0;
+            return;
+        }
+
+        if(file_fd > 0) {
+            close(file_fd);
+            file_fd = -1;
+            file_size = 0;
+        }
+
+        file_fd = open(filepath.c_str(), O_RDONLY);
+        if(file_fd <= 0) {
+            fprintf(stderr, "gsr ui: error: ClipboardFile::set_current_file: failed to open file %s, error: %s\n", filepath.c_str(), strerror(errno));
+            return;
+        }
+
+        struct stat64 stat;
+        if(fstat64(file_fd, &stat) == -1) {
+            fprintf(stderr, "gsr ui: error: ClipboardFile::set_current_file: failed to get file size for file %s, error: %s\n", filepath.c_str(), strerror(errno));
+            close(file_fd);
+            file_fd = -1;
+            return;
+        }
+        file_size = stat.st_size;
+        this->file_type = file_type;
+
+        XSetSelectionOwner(dpy, clipboard_atom, clipboard_window, CurrentTime);
+        XFlush(dpy);
+    }
+}

src/Config.cpp

@@ -1,7 +1,7 @@
 #include "../include/Config.hpp"
 #include "../include/Utils.hpp"
 #include "../include/GsrInfo.hpp"
-#include "../include/GlobalHotkeys.hpp"
+#include "../include/GlobalHotkeys/GlobalHotkeys.hpp"
 #include <variant>
 #include <limits.h>
 #include <inttypes.h>
@@ -15,6 +15,8 @@
 #define FORMAT_U32 "%" PRIu32
 
 namespace gsr {
+    static const std::string_view add_audio_track_tag = "[add_audio_track]";
+
     static std::vector<mgl::Keyboard::Key> hotkey_modifiers_to_mgl_keys(uint32_t modifiers) {
         std::vector<mgl::Keyboard::Key> result;
         if(modifiers & HOTKEY_MOD_LCTRL)
@@ -82,8 +84,8 @@ namespace gsr {
 
             modifier_str = mgl::Keyboard::key_to_string(modifier_key);
             if(!modifier_side) {
-                string_remove_all(modifier_str, "Left");
-                string_remove_all(modifier_str, "Right");
+                string_remove_all(modifier_str, "Left ");
+                string_remove_all(modifier_str, "Right ");
             }
             result += modifier_str;
         }
@@ -101,6 +103,14 @@ namespace gsr {
         return result;
     }
 
+    bool AudioTrack::operator==(const AudioTrack &other) const {
+        return audio_inputs == other.audio_inputs && application_audio_invert == other.application_audio_invert;
+    }
+
+    bool AudioTrack::operator!=(const AudioTrack &other) const {
+        return !operator==(other);
+    }
+
     Config::Config(const SupportedCaptureOptions &capture_options) {
         const std::string default_videos_save_directory = get_videos_dir();
         const std::string default_pictures_save_directory = get_pictures_dir();
@@ -108,17 +118,17 @@ namespace gsr {
         set_hotkeys_to_default();
 
         streaming_config.record_options.video_quality = "custom";
-        streaming_config.record_options.audio_tracks.push_back("default_output");
-        streaming_config.record_options.video_bitrate = 15000;
+        streaming_config.record_options.audio_tracks_list.push_back({std::vector<std::string>{"default_output"}, false});
+        streaming_config.record_options.video_bitrate = 8000;
 
         record_config.save_directory = default_videos_save_directory;
-        record_config.record_options.audio_tracks.push_back("default_output");
-        record_config.record_options.video_bitrate = 45000;
+        record_config.record_options.audio_tracks_list.push_back({std::vector<std::string>{"default_output"}, false});
+        record_config.record_options.video_bitrate = 40000;
 
         replay_config.record_options.video_quality = "custom";
         replay_config.save_directory = default_videos_save_directory;
-        replay_config.record_options.audio_tracks.push_back("default_output");
-        replay_config.record_options.video_bitrate = 45000;
+        replay_config.record_options.audio_tracks_list.push_back({std::vector<std::string>{"default_output"}, false});
+        replay_config.record_options.video_bitrate = 40000;
 
         screenshot_config.save_directory = default_pictures_save_directory;
 
@@ -138,9 +148,12 @@ namespace gsr {
 
         replay_config.start_stop_hotkey = {mgl::Keyboard::F10, HOTKEY_MOD_LALT | HOTKEY_MOD_LSHIFT};
         replay_config.save_hotkey = {mgl::Keyboard::F10, HOTKEY_MOD_LALT};
+        replay_config.save_1_min_hotkey = {mgl::Keyboard::F11, HOTKEY_MOD_LALT};
+        replay_config.save_10_min_hotkey = {mgl::Keyboard::F12, HOTKEY_MOD_LALT};
 
         screenshot_config.take_screenshot_hotkey = {mgl::Keyboard::Printscreen, 0};
         screenshot_config.take_screenshot_region_hotkey = {mgl::Keyboard::Printscreen, HOTKEY_MOD_LCTRL};
+        screenshot_config.take_screenshot_window_hotkey = {mgl::Keyboard::Printscreen, HOTKEY_MOD_LSHIFT};
 
         main_config.show_hide_hotkey = {mgl::Keyboard::Z, HOTKEY_MOD_LALT};
     }
@@ -152,15 +165,17 @@ namespace gsr {
         return KeyValue{line.substr(0, space_index), line.substr(space_index + 1)};
     }
 
-    using ConfigValue = std::variant<bool*, std::string*, int32_t*, ConfigHotkey*, std::vector<std::string>*>;
+    using ConfigValue = std::variant<bool*, std::string*, int32_t*, ConfigHotkey*, std::vector<std::string>*, std::vector<AudioTrack>*>;
 
     static std::map<std::string_view, ConfigValue> get_config_options(Config &config) {
         return {
             {"main.config_file_version", &config.main_config.config_file_version},
             {"main.software_encoding_warning_shown", &config.main_config.software_encoding_warning_shown},
+            {"main.wayland_warning_shown", &config.main_config.wayland_warning_shown},
             {"main.hotkeys_enable_option", &config.main_config.hotkeys_enable_option},
             {"main.joystick_hotkeys_enable_option", &config.main_config.joystick_hotkeys_enable_option},
             {"main.tint_color", &config.main_config.tint_color},
+            {"main.notification_speed", &config.main_config.notification_speed},
             {"main.show_hide_hotkey", &config.main_config.show_hide_hotkey},
 
             {"streaming.record_options.record_area_option", &config.streaming_config.record_options.record_area_option},
@@ -174,6 +189,7 @@ namespace gsr {
             {"streaming.record_options.application_audio_invert", &config.streaming_config.record_options.application_audio_invert},
             {"streaming.record_options.change_video_resolution", &config.streaming_config.record_options.change_video_resolution},
             {"streaming.record_options.audio_track", &config.streaming_config.record_options.audio_tracks},
+            {"streaming.record_options.audio_track_item", &config.streaming_config.record_options.audio_tracks_list},
             {"streaming.record_options.color_range", &config.streaming_config.record_options.color_range},
             {"streaming.record_options.video_quality", &config.streaming_config.record_options.video_quality},
             {"streaming.record_options.codec", &config.streaming_config.record_options.video_codec},
@@ -183,12 +199,14 @@ namespace gsr {
             {"streaming.record_options.overclock", &config.streaming_config.record_options.overclock},
             {"streaming.record_options.record_cursor", &config.streaming_config.record_options.record_cursor},
             {"streaming.record_options.restore_portal_session", &config.streaming_config.record_options.restore_portal_session},
-            {"streaming.show_streaming_started_notifications", &config.streaming_config.show_streaming_started_notifications},
-            {"streaming.show_streaming_stopped_notifications", &config.streaming_config.show_streaming_stopped_notifications},
+            {"streaming.record_options.show_notifications", &config.streaming_config.record_options.show_notifications},
+            {"streaming.record_options.use_led_indicator", &config.streaming_config.record_options.use_led_indicator},
             {"streaming.service", &config.streaming_config.streaming_service},
             {"streaming.youtube.key", &config.streaming_config.youtube.stream_key},
             {"streaming.twitch.key", &config.streaming_config.twitch.stream_key},
+            {"streaming.rumble.key", &config.streaming_config.rumble.stream_key},
             {"streaming.custom.url", &config.streaming_config.custom.url},
+            {"streaming.custom.key", &config.streaming_config.custom.key},
             {"streaming.custom.container", &config.streaming_config.custom.container},
             {"streaming.start_stop_hotkey", &config.streaming_config.start_stop_hotkey},
 
@@ -203,6 +221,7 @@ namespace gsr {
             {"record.record_options.application_audio_invert", &config.record_config.record_options.application_audio_invert},
             {"record.record_options.change_video_resolution", &config.record_config.record_options.change_video_resolution},
             {"record.record_options.audio_track", &config.record_config.record_options.audio_tracks},
+            {"record.record_options.audio_track_item", &config.record_config.record_options.audio_tracks_list},
             {"record.record_options.color_range", &config.record_config.record_options.color_range},
             {"record.record_options.video_quality", &config.record_config.record_options.video_quality},
             {"record.record_options.codec", &config.record_config.record_options.video_codec},
@@ -212,9 +231,9 @@ namespace gsr {
             {"record.record_options.overclock", &config.record_config.record_options.overclock},
             {"record.record_options.record_cursor", &config.record_config.record_options.record_cursor},
             {"record.record_options.restore_portal_session", &config.record_config.record_options.restore_portal_session},
+            {"record.record_options.show_notifications", &config.record_config.record_options.show_notifications},
+            {"record.record_options.use_led_indicator", &config.record_config.record_options.use_led_indicator},
             {"record.save_video_in_game_folder", &config.record_config.save_video_in_game_folder},
-            {"record.show_recording_started_notifications", &config.record_config.show_recording_started_notifications},
-            {"record.show_video_saved_notifications", &config.record_config.show_video_saved_notifications},
             {"record.save_directory", &config.record_config.save_directory},
             {"record.container", &config.record_config.container},
             {"record.start_stop_hotkey", &config.record_config.start_stop_hotkey},
@@ -231,6 +250,7 @@ namespace gsr {
             {"replay.record_options.application_audio_invert", &config.replay_config.record_options.application_audio_invert},
             {"replay.record_options.change_video_resolution", &config.replay_config.record_options.change_video_resolution},
             {"replay.record_options.audio_track", &config.replay_config.record_options.audio_tracks},
+            {"replay.record_options.audio_track_item", &config.replay_config.record_options.audio_tracks_list},
             {"replay.record_options.color_range", &config.replay_config.record_options.color_range},
             {"replay.record_options.video_quality", &config.replay_config.record_options.video_quality},
             {"replay.record_options.codec", &config.replay_config.record_options.video_codec},
@@ -240,17 +260,19 @@ namespace gsr {
             {"replay.record_options.overclock", &config.replay_config.record_options.overclock},
             {"replay.record_options.record_cursor", &config.replay_config.record_options.record_cursor},
             {"replay.record_options.restore_portal_session", &config.replay_config.record_options.restore_portal_session},
+            {"replay.record_options.show_notifications", &config.replay_config.record_options.show_notifications},
+            {"replay.record_options.use_led_indicator", &config.replay_config.record_options.use_led_indicator},
             {"replay.turn_on_replay_automatically_mode", &config.replay_config.turn_on_replay_automatically_mode},
             {"replay.save_video_in_game_folder", &config.replay_config.save_video_in_game_folder},
             {"replay.restart_replay_on_save", &config.replay_config.restart_replay_on_save},
-            {"replay.show_replay_started_notifications", &config.replay_config.show_replay_started_notifications},
-            {"replay.show_replay_stopped_notifications", &config.replay_config.show_replay_stopped_notifications},
-            {"replay.show_replay_saved_notifications", &config.replay_config.show_replay_saved_notifications},
             {"replay.save_directory", &config.replay_config.save_directory},
             {"replay.container", &config.replay_config.container},
             {"replay.time", &config.replay_config.replay_time},
+            {"replay.replay_storage", &config.replay_config.replay_storage},
             {"replay.start_stop_hotkey", &config.replay_config.start_stop_hotkey},
             {"replay.save_hotkey", &config.replay_config.save_hotkey},
+            {"replay.save_1_min_hotkey", &config.replay_config.save_1_min_hotkey},
+            {"replay.save_10_min_hotkey", &config.replay_config.save_10_min_hotkey},
 
             {"screenshot.record_area_option", &config.screenshot_config.record_area_option},
             {"screenshot.image_width", &config.screenshot_config.image_width},
@@ -261,10 +283,13 @@ namespace gsr {
             {"screenshot.record_cursor", &config.screenshot_config.record_cursor},
             {"screenshot.restore_portal_session", &config.screenshot_config.restore_portal_session},
             {"screenshot.save_screenshot_in_game_folder", &config.screenshot_config.save_screenshot_in_game_folder},
-            {"screenshot.show_screenshot_saved_notifications", &config.screenshot_config.show_screenshot_saved_notifications},
+            {"screenshot.save_screenshot_to_clipboard", &config.screenshot_config.save_screenshot_to_clipboard},
+            {"screenshot.show_notifications", &config.screenshot_config.show_notifications},
+            {"screenshot.use_led_indicator", &config.screenshot_config.use_led_indicator},
             {"screenshot.save_directory", &config.screenshot_config.save_directory},
             {"screenshot.take_screenshot_hotkey", &config.screenshot_config.take_screenshot_hotkey},
-            {"screenshot.take_screenshot_region_hotkey", &config.screenshot_config.take_screenshot_region_hotkey}
+            {"screenshot.take_screenshot_region_hotkey", &config.screenshot_config.take_screenshot_region_hotkey},
+            {"screenshot.take_screenshot_window_hotkey", &config.screenshot_config.take_screenshot_window_hotkey}
         };
     }
 
@@ -291,6 +316,9 @@ namespace gsr {
             } else if(std::holds_alternative<std::vector<std::string>*>(it.second)) {
                 if(*std::get<std::vector<std::string>*>(it.second) != *std::get<std::vector<std::string>*>(it_other->second))
                     return false;
+            } else if(std::holds_alternative<std::vector<AudioTrack>*>(it.second)) {
+                if(*std::get<std::vector<AudioTrack>*>(it.second) != *std::get<std::vector<AudioTrack>*>(it_other->second))
+                    return false;
             } else {
                 assert(false);
             }
@@ -302,6 +330,17 @@ namespace gsr {
         return !operator==(other);
     }
 
+    static void populate_new_audio_track_from_old(RecordOptions &record_options) {
+        if(record_options.merge_audio_tracks) {
+            record_options.audio_tracks_list.push_back({std::move(record_options.audio_tracks), record_options.application_audio_invert});
+        } else {
+            for(const std::string &audio_input : record_options.audio_tracks) {
+                record_options.audio_tracks_list.push_back({std::vector<std::string>{audio_input}, record_options.application_audio_invert});
+            }
+        }
+        record_options.audio_tracks.clear();
+    }
+
     std::optional<Config> read_config(const SupportedCaptureOptions &capture_options) {
         std::optional<Config> config;
 
@@ -313,10 +352,15 @@ namespace gsr {
         }
 
         config = Config(capture_options);
+
         config->streaming_config.record_options.audio_tracks.clear();
         config->record_config.record_options.audio_tracks.clear();
         config->replay_config.record_options.audio_tracks.clear();
 
+        config->streaming_config.record_options.audio_tracks_list.clear();
+        config->record_config.record_options.audio_tracks_list.clear();
+        config->replay_config.record_options.audio_tracks_list.clear();
+
         auto config_options = get_config_options(config.value());
 
         string_split_char(file_content, '\n', [&](std::string_view line) {
@@ -355,6 +399,23 @@ namespace gsr {
             } else if(std::holds_alternative<std::vector<std::string>*>(it->second)) {
                 std::string array_value(key_value->value);
                 std::get<std::vector<std::string>*>(it->second)->push_back(std::move(array_value));
+            } else if(std::holds_alternative<std::vector<AudioTrack>*>(it->second)) {
+                const size_t space_index = key_value->value.find(' ');
+                if(space_index == std::string_view::npos) {
+                    fprintf(stderr, "Warning: Invalid config option value for %.*s\n", (int)key_value->key.size(), key_value->key.data());
+                    return true;
+                }
+
+                const bool application_audio_invert = key_value->value.substr(0, space_index) == "true";
+                const std::string_view audio_input = key_value->value.substr(space_index + 1);
+                std::vector<AudioTrack> &audio_tracks = *std::get<std::vector<AudioTrack>*>(it->second);
+
+                if(audio_input == add_audio_track_tag) {
+                    audio_tracks.push_back({std::vector<std::string>{}, application_audio_invert});
+                } else if(!audio_tracks.empty()) {
+                    audio_tracks.back().application_audio_invert = application_audio_invert;
+                    audio_tracks.back().audio_inputs.emplace_back(audio_input);
+                }
             } else {
                 assert(false);
             }
@@ -362,11 +423,16 @@ namespace gsr {
             return true;
         });
 
-        if(config->main_config.config_file_version != GSR_CONFIG_FILE_VERSION) {
-            fprintf(stderr, "Info: the config file is outdated, resetting it\n");
-            config = std::nullopt;
+        if(config->main_config.config_file_version == 1) {
+            populate_new_audio_track_from_old(config->streaming_config.record_options);
+            populate_new_audio_track_from_old(config->record_config.record_options);
+            populate_new_audio_track_from_old(config->replay_config.record_options);
         }
 
+        config->streaming_config.record_options.audio_tracks.clear();
+        config->record_config.record_options.audio_tracks.clear();
+        config->replay_config.record_options.audio_tracks.clear();
+
         return config;
     }
 
@@ -402,9 +468,17 @@ namespace gsr {
                 const ConfigHotkey *config_hotkey = std::get<ConfigHotkey*>(it.second);
                     fprintf(file, "%.*s " FORMAT_I64 " " FORMAT_U32 "\n", (int)it.first.size(), it.first.data(), config_hotkey->key, config_hotkey->modifiers);
             } else if(std::holds_alternative<std::vector<std::string>*>(it.second)) {
-                std::vector<std::string> *array = std::get<std::vector<std::string>*>(it.second);
-                for(const std::string &value : *array) {
-                    fprintf(file, "%.*s %s\n", (int)it.first.size(), it.first.data(), value.c_str());
+                std::vector<std::string> *audio_inputs = std::get<std::vector<std::string>*>(it.second);
+                for(const std::string &audio_input : *audio_inputs) {
+                    fprintf(file, "%.*s %s\n", (int)it.first.size(), it.first.data(), audio_input.c_str());
+                }
+            } else if(std::holds_alternative<std::vector<AudioTrack>*>(it.second)) {
+                std::vector<AudioTrack> *audio_tracks = std::get<std::vector<AudioTrack>*>(it.second);
+                for(const AudioTrack &audio_track : *audio_tracks) {
+                    fprintf(file, "%.*s %s %.*s\n", (int)it.first.size(), it.first.data(), audio_track.application_audio_invert ? "true" : "false", (int)add_audio_track_tag.size(), add_audio_track_tag.data());
+                    for(const std::string &audio_input : audio_track.audio_inputs) {
+                        fprintf(file, "%.*s %s %s\n", (int)it.first.size(), it.first.data(), audio_track.application_audio_invert ? "true" : "false", audio_input.c_str());
+                    }
                 }
             } else {
                 assert(false);

src/CursorTracker/CursorTrackerWayland.cpp

@@ -1,4 +1,4 @@
-#include "../include/CursorTrackerWayland.hpp"
+#include "../../include/CursorTracker/CursorTrackerWayland.hpp"
 #include <string.h>
 #include <unistd.h>
 #include <fcntl.h>
@@ -9,14 +9,8 @@
 
 namespace gsr {
     static const int MAX_CONNECTORS = 32;
-    static const int CONNECTOR_TYPE_COUNTS = 32;
     static const uint32_t plane_property_all = 0xF;
 
-    typedef struct {
-        int type;
-        int count;
-    } drm_connector_type_count;
-
     typedef enum {
         PLANE_PROPERTY_CRTC_X      = 1 << 0,
         PLANE_PROPERTY_CRTC_Y      = 1 << 1,
@@ -27,19 +21,20 @@ namespace gsr {
     typedef struct {
         uint64_t crtc_id;
         mgl::vec2i size;
+        bool vrr_enabled;
     } drm_connector;
 
     typedef struct {
         drm_connector connectors[MAX_CONNECTORS];
         int num_connectors;
+        bool has_any_crtc_with_vrr_enabled;
     } drm_connectors;
 
     /* Returns plane_property_mask */
-    static uint32_t plane_get_properties(int drm_fd, uint32_t plane_id, int *crtc_x, int *crtc_y, int *crtc_id, bool *is_cursor) {
+    static uint32_t plane_get_properties(int drm_fd, uint32_t plane_id, int *crtc_x, int *crtc_y, int *crtc_id) {
         *crtc_x = 0;
         *crtc_y = 0;
         *crtc_id = 0;
-        *is_cursor = false;
 
         uint32_t property_mask = 0;
 
@@ -80,8 +75,8 @@ namespace gsr {
         return property_mask;
     }
 
-    static bool connector_get_property_by_name(int drm_fd, drmModeConnectorPtr props, const char *name, uint64_t *result) {
-        for(int i = 0; i < props->count_props; ++i) {
+    static bool get_drm_property_by_name(int drm_fd, drmModeObjectPropertiesPtr props, const char *name, uint64_t *result) {
+        for(uint32_t i = 0; i < props->count_props; ++i) {
             drmModePropertyPtr prop = drmModeGetProperty(drm_fd, props->props[i]);
             if(!prop)
                 continue;
@@ -96,20 +91,12 @@ namespace gsr {
         return false;
     }
 
-    static drm_connector_type_count* drm_connector_types_get_index(drm_connector_type_count *type_counts, int *num_type_counts, int connector_type) {
-        for(int i = 0; i < *num_type_counts; ++i) {
-            if(type_counts[i].type == connector_type)
-                return &type_counts[i];
-        }
-
-        if(*num_type_counts == CONNECTOR_TYPE_COUNTS)
-            return NULL;
-
-        const int index = *num_type_counts;
-        type_counts[index].type = connector_type;
-        type_counts[index].count = 0;
-        ++*num_type_counts;
-        return &type_counts[index];
+    static bool connector_get_property_by_name(int drm_fd, drmModeConnectorPtr props, const char *name, uint64_t *result) {
+        drmModeObjectProperties properties;
+        properties.count_props = (uint32_t)props->count_props;
+        properties.props = props->props;
+        properties.prop_values = props->prop_values;
+        return get_drm_property_by_name(drm_fd, &properties, name, result);
     }
 
     // Note: this monitor name logic is kept in sync with gpu screen recorder
@@ -119,27 +106,23 @@ namespace gsr {
         if(!resources)
             return result;
 
-        drm_connector_type_count type_counts[CONNECTOR_TYPE_COUNTS];
-        int num_type_counts = 0;
-
         for(int i = 0; i < resources->count_connectors; ++i) {
             uint64_t connector_crtc_id = 0;
             drmModeConnectorPtr connector = drmModeGetConnectorCurrent(drm_fd, resources->connectors[i]);
             if(!connector)
                 continue;
 
-            drm_connector_type_count *connector_type = drm_connector_types_get_index(type_counts, &num_type_counts, connector->connector_type);
             const char *connection_name = drmModeGetConnectorTypeName(connector->connector_type);
-            if(connector_type)
-                ++connector_type->count;
+            if(!connection_name)
+                goto next;
 
             if(connector->connection != DRM_MODE_CONNECTED)
                 goto next;
 
-            if(connector_type && connector_get_property_by_name(drm_fd, connector, "CRTC_ID", &connector_crtc_id) && connector_crtc_id == crtc_id) {
+            if(connector_get_property_by_name(drm_fd, connector, "CRTC_ID", &connector_crtc_id) && connector_crtc_id == crtc_id) {
                 result = connection_name;
                 result += "-";
-                result += std::to_string(connector_type->count);
+                result += std::to_string(connector->connector_type_id);
                 drmModeFreeConnector(connector);
                 break;
             }
@@ -325,7 +308,7 @@ namespace gsr {
     };
 
     /* Returns nullptr if not found */
-    static const drm_connector* get_drm_connector_by_crtc_id(const drm_connectors *connectors, uint32_t crtc_id) {
+    static drm_connector* get_drm_connector_by_crtc_id(drm_connectors *connectors, uint32_t crtc_id) {
         for(int i = 0; i < connectors->num_connectors; ++i) {
             if(connectors->connectors[i].crtc_id == crtc_id)
                 return &connectors->connectors[i];
@@ -335,6 +318,8 @@ namespace gsr {
 
     static void get_drm_connectors(int drm_fd, drm_connectors *drm_connectors) {
         drm_connectors->num_connectors = 0;
+        drm_connectors->has_any_crtc_with_vrr_enabled = false;
+
         drmModeResPtr resources = drmModeGetResources(drm_fd);
         if(!resources)
             return;
@@ -350,23 +335,59 @@ namespace gsr {
             uint64_t crtc_id = 0;
             connector_get_property_by_name(drm_fd, connector, "CRTC_ID", &crtc_id);
             if(crtc_id == 0)
-                goto next;
+                goto next_connector;
 
             crtc = drmModeGetCrtc(drm_fd, crtc_id);
             if(!crtc)
-                goto next;
+                goto next_connector;
 
             drm_connectors->connectors[drm_connectors->num_connectors].crtc_id = crtc_id;
             drm_connectors->connectors[drm_connectors->num_connectors].size = mgl::vec2i{(int)crtc->width, (int)crtc->height};
+            drm_connectors->connectors[drm_connectors->num_connectors].vrr_enabled = false;
             ++drm_connectors->num_connectors;
 
-            next:
+            next_connector:
             if(crtc)
                 drmModeFreeCrtc(crtc);
 
             if(connector)
                 drmModeFreeConnector(connector);
         }
+
+        for(int i = 0; i < resources->count_crtcs; ++i) {
+            drmModeCrtcPtr crtc = nullptr;
+            drmModeObjectPropertiesPtr properties = nullptr;
+            uint64_t vrr_enabled = 0;
+            drm_connector *connector = nullptr;
+
+            crtc = drmModeGetCrtc(drm_fd, resources->crtcs[i]);
+            if(!crtc)
+                continue;
+
+            properties = drmModeObjectGetProperties(drm_fd, crtc->crtc_id, DRM_MODE_OBJECT_CRTC);
+            if(!properties)
+                goto next_crtc;
+
+            if(!get_drm_property_by_name(drm_fd, properties, "VRR_ENABLED", &vrr_enabled))
+                goto next_crtc;
+
+            connector = get_drm_connector_by_crtc_id(drm_connectors, crtc->crtc_id);
+            if(!connector)
+                goto next_crtc;
+
+            if(vrr_enabled) {
+                connector->vrr_enabled = true;
+                drm_connectors->has_any_crtc_with_vrr_enabled = true;
+            }
+
+            next_crtc:
+            if(properties)
+                drmModeFreeObjectProperties(properties);
+
+            if(crtc)
+                drmModeFreeCrtc(crtc);
+        }
+
         drmModeFreeResources(resources);
     }
 
@@ -382,6 +403,7 @@ namespace gsr {
     }
 
     CursorTrackerWayland::~CursorTrackerWayland() {
+        clear_monitors();
         if(drm_fd > 0)
             close(drm_fd);
     }
@@ -392,19 +414,20 @@ namespace gsr {
 
         drm_connectors connectors;
         connectors.num_connectors = 0;
+        connectors.has_any_crtc_with_vrr_enabled = false;
         get_drm_connectors(drm_fd, &connectors);
 
         drmModePlaneResPtr planes = drmModeGetPlaneResources(drm_fd);
         if(!planes)
             return;
 
+        bool found_cursor = false;
         for(uint32_t i = 0; i < planes->count_planes; ++i) {
             drmModePlanePtr plane = nullptr;
             const drm_connector *connector = nullptr;
             int crtc_x = 0;
             int crtc_y = 0;
             int crtc_id = 0;
-            bool is_cursor = false;
             uint32_t property_mask = 0;
 
             plane = drmModeGetPlane(drm_fd, planes->planes[i]);
@@ -414,7 +437,7 @@ namespace gsr {
             if(!plane->fb_id)
                 goto next;
 
-            property_mask = plane_get_properties(drm_fd, planes->planes[i], &crtc_x, &crtc_y, &crtc_id, &is_cursor);
+            property_mask = plane_get_properties(drm_fd, planes->planes[i], &crtc_x, &crtc_y, &crtc_id);
             if(property_mask != plane_property_all || crtc_id <= 0)
                 goto next;
 
@@ -426,6 +449,7 @@ namespace gsr {
                 latest_cursor_position.x = crtc_x;
                 latest_cursor_position.y = crtc_y;
                 latest_crtc_id = crtc_id;
+                found_cursor = true;
                 drmModeFreePlane(plane);
                 break;
             }
@@ -434,6 +458,11 @@ namespace gsr {
             drmModeFreePlane(plane);
         }
 
+        // On kde plasma wayland (and possibly other wayland compositors) it uses a software cursor only for the monitors with vrr enabled.
+        // In that case we cant know the cursor location and we instead want to fallback to getting focused monitor by using the hack of creating a window and getting the position.
+        if(!found_cursor && latest_crtc_id > 0 && connectors.has_any_crtc_with_vrr_enabled)
+            latest_crtc_id = -1;
+
         drmModeFreePlaneResources(planes);
     }
 
@@ -452,6 +481,21 @@ namespace gsr {
         wl_display_roundtrip(dpy);
     }
 
+    void CursorTrackerWayland::clear_monitors() {
+        for(WaylandOutput &monitor : monitors) {
+            if(monitor.output) {
+                wl_output_destroy(monitor.output);
+                monitor.output = nullptr;
+            }
+
+            if(monitor.xdg_output) {
+                zxdg_output_v1_destroy(monitor.xdg_output);
+                monitor.xdg_output = nullptr;
+            }
+        }
+        monitors.clear();
+    }
+
     std::optional<CursorInfo> CursorTrackerWayland::get_latest_cursor_info() {
         if(drm_fd <= 0 || latest_crtc_id == -1)
             return std::nullopt;
@@ -466,7 +510,7 @@ namespace gsr {
             return std::nullopt;
         }
 
-        monitors.clear();
+        clear_monitors();
         struct wl_registry *registry = wl_display_get_registry(dpy);
         wl_registry_add_listener(registry, &registry_listener, this);
 
@@ -480,22 +524,13 @@ namespace gsr {
 
         mgl::vec2i cursor_position = latest_cursor_position;
         const WaylandOutput *wayland_monitor = get_wayland_monitor_by_name(monitors, monitor_name);
-        if(!wayland_monitor)
+        if(!wayland_monitor) {
+            clear_monitors();
             return std::nullopt;
+        }
 
         cursor_position = wayland_monitor->pos + latest_cursor_position;
-        for(WaylandOutput &monitor : monitors) {
-            if(monitor.output) {
-                wl_output_destroy(monitor.output);
-                monitor.output = nullptr;
-            }
-
-            if(monitor.xdg_output) {
-                zxdg_output_v1_destroy(monitor.xdg_output);
-                monitor.xdg_output = nullptr;
-            }
-        }
-        monitors.clear();
+        clear_monitors();
 
         if(xdg_output_manager) {
             zxdg_output_manager_v1_destroy(xdg_output_manager);

src/CursorTracker/CursorTrackerX11.cpp

@@ -1,5 +1,5 @@
-#include "../include/CursorTrackerX11.hpp"
-#include "../include/WindowUtils.hpp"
+#include "../../include/CursorTracker/CursorTrackerX11.hpp"
+#include "../../include/WindowUtils.hpp"
 
 namespace gsr {
     CursorTrackerX11::CursorTrackerX11(Display *dpy) : dpy(dpy) {

src/GlobalHotkeys/GlobalHotkeysJoystick.cpp

@@ -1,28 +1,50 @@
-#include "../include/GlobalHotkeysJoystick.hpp"
+#include "../../include/GlobalHotkeys/GlobalHotkeysJoystick.hpp"
 #include <string.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <unistd.h>
+#include <dirent.h>
 #include <sys/eventfd.h>
 
 namespace gsr {
     static constexpr int button_pressed = 1;
-    static constexpr int options_button = 9;
-    static constexpr int playstation_button = 10;
-    static constexpr int axis_up_down = 7;
-    static constexpr int axis_left_right = 6;
 
     // Returns -1 on error
-    static int get_js_dev_input_id_from_filepath(const char *dev_input_filepath) {
-        if(strncmp(dev_input_filepath, "/dev/input/js", 13) != 0)
+    static int get_dev_input_event_id_from_filepath(const char *dev_input_filepath) {
+        if(strncmp(dev_input_filepath, "/dev/input/event", 16) != 0)
             return -1;
 
         int dev_input_id = -1;
-        if(sscanf(dev_input_filepath + 13, "%d", &dev_input_id) == 1)
+        if(sscanf(dev_input_filepath + 16, "%d", &dev_input_id) == 1)
             return dev_input_id;
         return -1;
     }
 
+    static inline bool supports_key(unsigned char *key_bits, unsigned int key) {
+        return key_bits[key/8] & (1 << (key % 8));
+    }
+
+    static bool supports_joystick_keys(unsigned char *key_bits) {
+        const int keys[7] = { BTN_A, BTN_B, BTN_X, BTN_Y, BTN_SELECT, BTN_START, BTN_SELECT };
+        for(int i = 0; i < 7; ++i) {
+            if(supports_key(key_bits, keys[i]))
+                return true;
+        }
+        return false;
+    }
+
+    static bool is_input_device_joystick(int input_fd) {
+        unsigned long evbit = 0;
+        ioctl(input_fd, EVIOCGBIT(0, sizeof(evbit)), &evbit);
+        if((evbit & (1 << EV_SYN)) && (evbit & (1 << EV_KEY))) {
+            unsigned char key_bits[KEY_MAX/8 + 1];
+            memset(key_bits, 0, sizeof(key_bits));
+            ioctl(input_fd, EVIOCGBIT(EV_KEY, sizeof(key_bits)), &key_bits);
+            return supports_joystick_keys(key_bits);
+        }
+        return false;
+    }
+
     GlobalHotkeysJoystick::~GlobalHotkeysJoystick() {
         if(event_fd > 0) {
             const uint64_t exit = 1;
@@ -32,11 +54,22 @@ namespace gsr {
         if(read_thread.joinable())
             read_thread.join();
 
-        if(event_fd > 0)
+        if(event_fd > 0) {
             close(event_fd);
+            event_fd = 0;
+        }
+
+        close_fd_cv.notify_one();
+        if(close_fd_thread.joinable())
+            close_fd_thread.join();
+
+        for(int fd : fds_to_close) {
+            close(fd);
+        }
 
         for(int i = 0; i < num_poll_fd; ++i) {
-            close(poll_fd[i].fd);
+            if(poll_fd[i].fd > 0)
+                close(poll_fd[i].fd);
         }
     }
 
@@ -74,16 +107,10 @@ namespace gsr {
             ++num_poll_fd;
         }
 
-        char dev_input_path[128];
-        for(int i = 0; i < 8; ++i) {
-            snprintf(dev_input_path, sizeof(dev_input_path), "/dev/input/js%d", i);
-            add_device(dev_input_path, false);
-        }
-
-        if(num_poll_fd == 0)
-            fprintf(stderr, "Info: no joysticks found, assuming they might be connected later\n");
+        add_all_joystick_devices();
 
         read_thread = std::thread(&GlobalHotkeysJoystick::read_events, this);
+        close_fd_thread = std::thread(&GlobalHotkeysJoystick::close_fds, this);
         return true;
     }
 
@@ -104,6 +131,20 @@ namespace gsr {
                 it->second("save_replay");
         }
 
+        if(save_1_min_replay) {
+            save_1_min_replay = false;
+            auto it = bound_actions_by_id.find("save_1_min_replay");
+            if(it != bound_actions_by_id.end())
+                it->second("save_1_min_replay");
+        }
+
+        if(save_10_min_replay) {
+            save_10_min_replay = false;
+            auto it = bound_actions_by_id.find("save_10_min_replay");
+            if(it != bound_actions_by_id.end())
+                it->second("save_10_min_replay");
+        }
+
         if(take_screenshot) {
             take_screenshot = false;
             auto it = bound_actions_by_id.find("take_screenshot");
@@ -133,14 +174,39 @@ namespace gsr {
         }
     }
 
+    // Retarded linux takes very long time to close /dev/input/eventN files, even though they are virtual and opened read-only
+    void GlobalHotkeysJoystick::close_fds() {
+        std::vector<int> current_fds_to_close;
+        while(event_fd > 0) {
+            {
+                std::unique_lock<std::mutex> lock(close_fd_mutex);
+                close_fd_cv.wait(lock, [this]{ return !fds_to_close.empty() || event_fd <= 0; });
+            }
+
+            {
+                std::lock_guard<std::mutex> lock(close_fd_mutex);
+                current_fds_to_close = std::move(fds_to_close);
+                fds_to_close.clear();
+            }
+
+            for(int fd : current_fds_to_close) {
+                close(fd);
+            }
+            current_fds_to_close.clear();
+        }
+    }
+
     void GlobalHotkeysJoystick::read_events() {
-        js_event event;
+        input_event event;
         while(poll(poll_fd, num_poll_fd, -1) > 0) {
             for(int i = 0; i < num_poll_fd; ++i) {
                 if(poll_fd[i].revents & (POLLHUP|POLLERR|POLLNVAL)) {
                     if(i == event_index)
                         goto done;
 
+                    char dev_input_filepath[256];
+                    snprintf(dev_input_filepath, sizeof(dev_input_filepath), "/dev/input/event%d", extra_data[i].dev_input_id);
+                    fprintf(stderr, "Info: removed joystick: %s\n", dev_input_filepath);
                     if(remove_poll_fd(i))
                         --i; // This item was removed so we want to repeat the same index to continue to the next item
 
@@ -154,25 +220,20 @@ namespace gsr {
                     goto done;
                 } else if(i == hotplug_poll_index) {
                     hotplug.process_event_data(poll_fd[i].fd, [&](HotplugAction hotplug_action, const char *devname) {
-                        char dev_input_filepath[1024];
-                        snprintf(dev_input_filepath, sizeof(dev_input_filepath), "/dev/%s", devname);
                         switch(hotplug_action) {
                             case HotplugAction::ADD: {
-                                // Cant open the /dev/input device immediately or it fails.
-                                // TODO: Remove this hack when a better solution is found.
-                                usleep(50 * 1000);
-                                add_device(dev_input_filepath);
+                                add_device(devname, false);
                                 break;
                             }
                             case HotplugAction::REMOVE: {
-                                if(remove_device(dev_input_filepath))
+                                if(remove_device(devname))
                                     --i; // This item was removed so we want to repeat the same index to continue to the next item
                                 break;
                             }
                         }
                     });
                 } else {
-                    process_js_event(poll_fd[i].fd, event);
+                    process_input_event(poll_fd[i].fd, event);
                 }
             }
         }
@@ -181,28 +242,44 @@ namespace gsr {
         ;
     }
 
-    void GlobalHotkeysJoystick::process_js_event(int fd, js_event &event) {
+    void GlobalHotkeysJoystick::process_input_event(int fd, input_event &event) {
         if(read(fd, &event, sizeof(event)) != sizeof(event))
             return;
 
-        if((event.type & JS_EVENT_BUTTON) == JS_EVENT_BUTTON) {
-            if(event.number == playstation_button)
-                playstation_button_pressed = event.value == button_pressed;
-            else if(playstation_button_pressed && event.number == options_button && event.value == button_pressed)
-                toggle_show = true;
-        } else if((event.type & JS_EVENT_AXIS) == JS_EVENT_AXIS && playstation_button_pressed) {
-            const int trigger_threshold = 16383;
+        if(event.type == EV_KEY) {
+            switch(event.code) {
+                case BTN_MODE: {
+                    playstation_button_pressed = (event.value == button_pressed);
+                    break;
+                }
+                case BTN_START: {
+                    if(playstation_button_pressed && event.value == button_pressed)
+                        toggle_show = true;
+                    break;
+                }
+                case BTN_SOUTH: {
+                    if(playstation_button_pressed && event.value == button_pressed)
+                        save_1_min_replay = true;
+                    break;
+                }
+                case BTN_NORTH: {
+                    if(playstation_button_pressed && event.value == button_pressed)
+                        save_10_min_replay = true;
+                    break;
+                }
+            }
+        } else if(event.type == EV_ABS && playstation_button_pressed) {
             const bool prev_up_pressed = up_pressed;
             const bool prev_down_pressed = down_pressed;
             const bool prev_left_pressed = left_pressed;
             const bool prev_right_pressed = right_pressed;
 
-            if(event.number == axis_up_down) {
-                up_pressed = event.value <= -trigger_threshold;
-                down_pressed = event.value >= trigger_threshold;
-            } else if(event.number == axis_left_right) {
-                left_pressed = event.value <= -trigger_threshold;
-                right_pressed = event.value >= trigger_threshold;
+            if(event.code == ABS_HAT0Y) {
+                up_pressed = event.value == -1;
+                down_pressed = event.value == 1;
+            } else if(event.code == ABS_HAT0X) {
+                left_pressed = event.value == -1;
+                right_pressed = event.value == 1;
             }
 
             if(up_pressed && !prev_up_pressed)
@@ -216,13 +293,36 @@ namespace gsr {
         }
     }
 
+    void GlobalHotkeysJoystick::add_all_joystick_devices() {
+        DIR *dir = opendir("/dev/input");
+        if(!dir) {
+            fprintf(stderr, "Error: failed to open /dev/input, error: %s\n", strerror(errno));
+            return;
+        }
+
+        char dev_input_filepath[1024];
+        for(;;) {
+            struct dirent *entry = readdir(dir);
+            if(!entry)
+                break;
+
+            if(strncmp(entry->d_name, "event", 5) != 0)
+                continue;
+
+            snprintf(dev_input_filepath, sizeof(dev_input_filepath), "/dev/input/%s", entry->d_name);
+            add_device(dev_input_filepath, false);
+        }
+
+        closedir(dir);
+    }
+
     bool GlobalHotkeysJoystick::add_device(const char *dev_input_filepath, bool print_error) {
         if(num_poll_fd >= max_js_poll_fd) {
             fprintf(stderr, "Warning: failed to add joystick device %s, too many joysticks have been added\n", dev_input_filepath);
             return false;
         }
 
-        const int dev_input_id = get_js_dev_input_id_from_filepath(dev_input_filepath);
+        const int dev_input_id = get_dev_input_event_id_from_filepath(dev_input_filepath);
         if(dev_input_id == -1)
             return false;
 
@@ -233,6 +333,15 @@ namespace gsr {
             return false;
         }
 
+        if(!is_input_device_joystick(fd)) {
+            {
+                std::lock_guard<std::mutex> lock(close_fd_mutex);
+                fds_to_close.push_back(fd);
+            }
+            close_fd_cv.notify_one();
+            return false;
+        }
+
         poll_fd[num_poll_fd] = {
             fd,
             POLLIN,
@@ -243,13 +352,15 @@ namespace gsr {
             dev_input_id
         };
 
+        //const DeviceId device_id = joystick_get_device_id(dev_input_filepath);
+
         ++num_poll_fd;
         fprintf(stderr, "Info: added joystick: %s\n", dev_input_filepath);
         return true;
     }
 
     bool GlobalHotkeysJoystick::remove_device(const char *dev_input_filepath) {
-        const int dev_input_id = get_js_dev_input_id_from_filepath(dev_input_filepath);
+        const int dev_input_id = get_dev_input_event_id_from_filepath(dev_input_filepath);
         if(dev_input_id == -1)
             return false;
 
@@ -265,7 +376,14 @@ namespace gsr {
         if(index < 0 || index >= num_poll_fd)
             return false;
 
-        close(poll_fd[index].fd);
+        if(poll_fd[index].fd > 0) {
+            {
+                std::lock_guard<std::mutex> lock(close_fd_mutex);
+                fds_to_close.push_back(poll_fd[index].fd);
+            }
+            close_fd_cv.notify_one();
+        }
+
         for(int i = index + 1; i < num_poll_fd; ++i) {
             poll_fd[i - 1] = poll_fd[i];
             extra_data[i - 1] = extra_data[i];

src/GlobalHotkeys/GlobalHotkeysLinux.cpp

@@ -1,5 +1,4 @@
-#include "../include/GlobalHotkeysLinux.hpp"
-#include <signal.h>
+#include "../../include/GlobalHotkeys/GlobalHotkeysLinux.hpp"
 #include <sys/wait.h>
 #include <fcntl.h>
 #include <limits.h>
@@ -20,6 +19,7 @@ namespace gsr {
         switch(grab_type) {
             case GlobalHotkeysLinux::GrabType::ALL:     return "--all";
             case GlobalHotkeysLinux::GrabType::VIRTUAL: return "--virtual";
+            case GlobalHotkeysLinux::GrabType::NO_GRAB: return "--no-grab";
         }
         return "--all";
     }
@@ -71,22 +71,42 @@ namespace gsr {
     }
 
     GlobalHotkeysLinux::~GlobalHotkeysLinux() {
-        for(int i = 0; i < 2; ++i) {
-            if(read_pipes[i] > 0)
-                close(read_pipes[i]);
-
-            if(write_pipes[i] > 0)
-                close(write_pipes[i]);
+        if(write_pipes[PIPE_WRITE] > 0) {
+            char command[32];
+            const int command_size = snprintf(command, sizeof(command), "exit\n");
+            if(write(write_pipes[PIPE_WRITE], command, command_size) != command_size) {
+                fprintf(stderr, "Error: GlobalHotkeysLinux::~GlobalHotkeysLinux: failed to write command to gsr-global-hotkeys, error: %s\n", strerror(errno));
+                close_fds();
+            }
+        } else {
+            close_fds();
         }
 
-        if(read_file)
-            fclose(read_file);
-
         if(process_id > 0) {
-            kill(process_id, SIGKILL);
             int status;
             waitpid(process_id, &status, 0);
         }
+
+        close_fds();
+    }
+
+    void GlobalHotkeysLinux::close_fds() {
+        for(int i = 0; i < 2; ++i) {
+            if(read_pipes[i] > 0) {
+                close(read_pipes[i]);
+                read_pipes[i] = -1;
+            }
+
+            if(write_pipes[i] > 0) {
+                close(write_pipes[i]);
+                write_pipes[i] = -1;
+            }
+        }
+
+        if(read_file) {
+            fclose(read_file);
+            read_file = nullptr;
+        }
     }
 
     bool GlobalHotkeysLinux::start() {
@@ -251,6 +271,8 @@ namespace gsr {
             auto it = bound_actions_by_id.find(action);
             if(it != bound_actions_by_id.end())
                 it->second(action);
+            else if(on_gsr_ui_virtual_keyboard_grabbed && action == "gsr-ui-virtual-keyboard-grabbed")
+                on_gsr_ui_virtual_keyboard_grabbed();
         }
     }
 }

src/GlobalHotkeys/GlobalHotkeysX11.cpp

@@ -1,4 +1,4 @@
-#include "../include/GlobalHotkeysX11.hpp"
+#include "../../include/GlobalHotkeys/GlobalHotkeysX11.hpp"
 #include <X11/keysym.h>
 #include <mglpp/window/Event.hpp>
 #include <assert.h>

src/GsrInfo.cpp

@@ -175,11 +175,6 @@ namespace gsr {
         CAPTURE_OPTIONS
     };
 
-    static bool starts_with(std::string_view str, const char *substr) {
-        size_t len = strlen(substr);
-        return str.size() >= len && memcmp(str.data(), substr, len) == 0;
-    }
-
     GsrInfoExitStatus get_gpu_screen_recorder_info(GsrInfo *gsr_info) {
         *gsr_info = GsrInfo{};
 

src/Hotplug.cpp

@@ -59,10 +59,9 @@ namespace gsr {
 
     /* TODO: This assumes SUBSYSTEM= is output before DEVNAME=, is that always true? */
     void Hotplug::parse_netlink_data(const char *line, const HotplugEventCallback &callback) {
-        const char *at_symbol = strchr(line, '@');
-        if(at_symbol) {
-            event_is_add = strncmp(line, "add@", 4) == 0;
-            event_is_remove = strncmp(line, "remove@", 7) == 0;
+        if(strncmp(line, "ACTION=", 7) == 0) {
+            event_is_add = strncmp(line+7, "add", 3) == 0;
+            event_is_remove = strncmp(line+7, "remove", 6) == 0;
             subsystem_is_input = false;
         } else if(event_is_add || event_is_remove) {
             if(strcmp(line, "SUBSYSTEM=input") == 0)

src/LedIndicator.cpp

@@ -0,0 +1,93 @@
+#include "../include/LedIndicator.hpp"
+
+#include <unistd.h>
+#include <sys/wait.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+namespace gsr {
+    LedIndicator::LedIndicator() {
+        run_gsr_global_hotkeys_set_leds(false);
+    }
+
+    LedIndicator::~LedIndicator() {
+        run_gsr_global_hotkeys_set_leds(false);
+        if(gsr_global_hotkeys_pid > 0) {
+            int status;
+            waitpid(gsr_global_hotkeys_pid, &status, 0);
+        }
+    }
+
+    void LedIndicator::set_led(bool enabled) {
+        led_enabled = enabled;
+        perform_blink = false;
+    }
+
+    void LedIndicator::blink() {
+        perform_blink = true;
+        blink_timer.restart();
+    }
+
+    bool LedIndicator::run_gsr_global_hotkeys_set_leds(bool enabled) {
+        if(gsr_global_hotkeys_pid > 0) {
+            int status;
+            if(waitpid(gsr_global_hotkeys_pid, &status, WNOHANG) == 0) {
+                // Still running
+                return false;
+            }
+            gsr_global_hotkeys_pid = -1;
+        }
+
+        const bool inside_flatpak = getenv("FLATPAK_ID") != NULL;
+        const char *user_homepath = getenv("HOME");
+        if(!user_homepath)
+            user_homepath = "/tmp";
+
+        gsr_global_hotkeys_pid = vfork();
+        if(gsr_global_hotkeys_pid == -1) {
+            fprintf(stderr, "Error: LedIndicator::run_gsr_global_hotkeys_set_leds: failed to fork\n");
+            return false;
+        } else if(gsr_global_hotkeys_pid == 0) { // Child
+            if(inside_flatpak) {
+                const char *args[] = { "flatpak-spawn", "--host", "/var/lib/flatpak/app/com.dec05eba.gpu_screen_recorder/current/active/files/bin/kms-server-proxy", "launch-gsr-global-hotkeys", user_homepath, "--set-led", "Scroll Lock", enabled ? "on" : "off", nullptr };
+                execvp(args[0], (char* const*)args);
+            } else {
+                const char *args[] = { "gsr-global-hotkeys", "--set-led", "Scroll Lock", enabled ? "on" : "off", nullptr };
+                execvp(args[0], (char* const*)args);
+            }
+
+            perror("gsr-global-hotkeys");
+            _exit(127);
+            return true;
+        } else { // Parent
+            return true;
+        }
+    }
+
+    void LedIndicator::update_led(bool new_state) {
+        if(new_state == led_indicator_on)
+            return;
+
+        if(run_gsr_global_hotkeys_set_leds(new_state))
+            led_indicator_on = new_state;
+    }
+
+    void LedIndicator::update() {
+        if(perform_blink) {
+            const double blink_elapsed_sec = blink_timer.get_elapsed_time_seconds();
+            if(blink_elapsed_sec < 0.2) {
+                update_led(false);
+            } else if(blink_elapsed_sec < 0.4) {
+                update_led(true);
+            } else if(blink_elapsed_sec < 0.6) {
+                update_led(false);
+            } else if(blink_elapsed_sec < 0.8) {
+                update_led(true);
+            } else {
+                perform_blink = false;
+            }
+        } else {
+            update_led(led_enabled);
+        }
+    }
+}

src/Process.cpp

@@ -130,8 +130,6 @@ namespace gsr {
                 exit_status = -1;
                 break;
             }
-
-            buffer[bytes_read] = '\0';
             result.append(buffer, bytes_read);
         }
 
@@ -178,11 +176,21 @@ namespace gsr {
         }
     }
 
+    static const char *get_basename(const char *path, int size) {
+        for(int i = size - 1; i >= 0; --i) {
+            if(path[i] == '/')
+                return path + i + 1;
+        }
+        return path;
+    }
+
     // |output_buffer| should be at least PATH_MAX in size
     bool read_cmdline_arg0(const char *filepath, char *output_buffer, int output_buffer_size) {
         output_buffer[0] = '\0';
 
+        const char *arg0_start = NULL;
         const char *arg0_end = NULL;
+        int arg0_size = 0;
         int fd = open(filepath, O_RDONLY);
         if(fd == -1)
             return false;
@@ -192,13 +200,16 @@ namespace gsr {
         if(bytes_read == -1)
             goto err;
 
-        arg0_end = (const char*)memchr(buffer, '\0', bytes_read);
+        arg0_start = buffer;
+        arg0_end = (const char*)memchr(arg0_start, '\0', bytes_read);
         if(!arg0_end)
             goto err;
 
-        if((arg0_end - buffer) + 1 <= output_buffer_size) {
-            memcpy(output_buffer, buffer, arg0_end - buffer);
-            output_buffer[arg0_end - buffer] = '\0';
+        arg0_start = get_basename(arg0_start, arg0_end - arg0_start);
+        arg0_size = arg0_end - arg0_start;
+        if(arg0_size + 1 <= output_buffer_size) {
+            memcpy(output_buffer, arg0_start, arg0_size);
+            output_buffer[arg0_size] = '\0';
             close(fd);
             return true;
         }

src/RegionSelector.cpp

@@ -208,7 +208,7 @@ namespace gsr {
         window_attr.background_pixel = is_wayland ? 0 : border_color_x11;
         window_attr.border_pixel = 0;
         window_attr.override_redirect = true;
-        window_attr.event_mask = StructureNotifyMask | PointerMotionMask;
+        window_attr.event_mask = StructureNotifyMask | PointerMotionMask | ButtonPressMask | ButtonReleaseMask;
         window_attr.colormap = region_window_colormap;
 
         Screen *screen = XDefaultScreenOfDisplay(dpy);
@@ -366,10 +366,6 @@ namespace gsr {
         return true;
     }
 
-    bool RegionSelector::is_selected() const {
-        return selected;
-    }
-
     bool RegionSelector::take_selection() {
         const bool result = selected;
         selected = false;

src/Rpc.cpp

@@ -5,11 +5,12 @@
 #include <limits.h>
 #include <string.h>
 #include <errno.h>
-#include <sys/stat.h>
-#include <fcntl.h>
+#include <poll.h>
+#include <sys/socket.h>
+#include <sys/un.h>
 
 namespace gsr {
-    static void get_runtime_filepath(char *buffer, size_t buffer_size, const char *filename) {
+    static void get_socket_filepath(char *buffer, size_t buffer_size, const char *filename) {
         char dir[PATH_MAX];
 
         const char *runtime_dir = getenv("XDG_RUNTIME_DIR");
@@ -24,78 +25,117 @@ namespace gsr {
         snprintf(buffer, buffer_size, "%s/%s", dir, filename);
     }
 
+    static int create_socket(const char *name, struct sockaddr_un *addr, std::string &socket_filepath) {
+        char socket_filepath_tmp[PATH_MAX];
+        get_socket_filepath(socket_filepath_tmp, sizeof(socket_filepath_tmp), name);
+        socket_filepath = socket_filepath_tmp;
+
+        memset(addr, 0, sizeof(*addr));
+        if(strlen(name) > sizeof(addr->sun_path))
+            return false;
+
+        addr->sun_family = AF_UNIX;
+        snprintf(addr->sun_path, sizeof(addr->sun_path), "%s", socket_filepath.c_str());
+
+        return socket(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK, 0);
+    }
+
+    Rpc::Rpc() {
+        num_polls = 0;
+    }
+
     Rpc::~Rpc() {
-        if(fd > 0)
-            close(fd);
+        if(socket_fd > 0)
+            close(socket_fd);
 
-        if(file)
-            fclose(file);
-
-        if(!fifo_filepath.empty())
-            remove(fifo_filepath.c_str());
+        if(!socket_filepath.empty())
+            unlink(socket_filepath.c_str());
     }
 
     bool Rpc::create(const char *name) {
-        if(file) {
+        if(socket_fd > 0) {
             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());
+        struct sockaddr_un addr;
+        socket_fd = create_socket(name, &addr, socket_filepath);
+        if(socket_fd <= 0) {
+            fprintf(stderr, "Error: Rpc::create: failed to create socket, error: %s\n", strerror(errno));
             return false;
         }
 
-        if(!open_filepath(fifo_filepath.c_str())) {
-            remove(fifo_filepath.c_str());
-            fifo_filepath.clear();
+        unlink(socket_filepath.c_str());
+
+        if(bind(socket_fd, (struct sockaddr*)&addr, sizeof(addr)) == -1) {
+            const int err = errno;
+            close(socket_fd);
+            socket_fd = 0;
+
+            fprintf(stderr, "Error: Rpc::create: failed to bind, error: %s\n", strerror(err));
             return false;
         }
 
+        if(listen(socket_fd, GSR_RPC_MAX_CONNECTIONS) == -1) {
+            const int err = errno;
+            close(socket_fd);
+            socket_fd = 0;
+
+            fprintf(stderr, "Error: Rpc::create: failed to listen, error: %s\n", strerror(err));
+            return false;
+        }
+
+        polls[0].fd = socket_fd;
+        polls[0].events = POLLIN;
+        polls[0].revents = 0;
+        ++num_polls;
+
         return true;
     }
 
-    bool Rpc::open(const char *name) {
-        if(file) {
+    RpcOpenResult Rpc::open(const char *name) {
+        if(socket_fd > 0) {
             fprintf(stderr, "Error: Rpc::open: already created/opened\n");
-            return false;
+            return RpcOpenResult::ERROR;
         }
 
-        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;
+        struct sockaddr_un addr;
+        socket_fd = create_socket(name, &addr, socket_filepath);
+        socket_filepath.clear(); /* We dont want to delete the socket on exit as the client */
+        if(socket_fd <= 0) {
+            fprintf(stderr, "Error: Rpc::open: failed to create socket, error: %s\n", strerror(errno));
+            return RpcOpenResult::ERROR;
         }
-        fd = 0;
-        return true;
+
+        while(true) {
+            if(connect(socket_fd, (struct sockaddr*)&addr, sizeof(addr)) == -1) {
+                const int err = errno;
+                if(err == EWOULDBLOCK) {
+                    usleep(10 * 1000);
+                } else {
+                    close(socket_fd);
+                    socket_fd = 0;
+                    if(err != ENOENT && err != ECONNREFUSED)
+                        fprintf(stderr, "Error: Rpc::create: failed to connect, error: %s\n", strerror(err));
+                    return RpcOpenResult::ERROR;
+                }
+            } else {
+                break;
+            }
+        }
+
+        return RpcOpenResult::OK;
     }
 
     bool Rpc::write(const char *str, size_t size) {
-        if(!file) {
-            fprintf(stderr, "Error: Rpc::write: fifo not created/opened yet\n");
+        if(socket_fd <= 0) {
+            fprintf(stderr, "Error: Rpc::write: unix domain socket 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);
+            const ssize_t bytes_written = ::write(socket_fd, str + offset, size - offset);
             if(bytes_written > 0)
                 offset += bytes_written;
         }
@@ -103,30 +143,73 @@ namespace gsr {
     }
 
     void Rpc::poll() {
-        if(!file) {
-            //fprintf(stderr, "Error: Rpc::poll: fifo not created/opened yet\n");
+        if(socket_fd <= 0) {
+            //fprintf(stderr, "Error: Rpc::poll: unix domain socket 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;
+        while(::poll(polls, num_polls, 0) > 0) {
+            for(int i = 0; i < num_polls; ++i) {
+                if(polls[i].fd == socket_fd) {
+                    if(polls[i].revents & (POLLERR|POLLHUP)) {
+                        close(socket_fd);
+                        socket_fd = 0;
+                        return;
+                    }
 
-            if(line[line_len - 1] == '\n') {
-                line[line_len - 1] = '\0';
-                --line_len;
+                    const int client_fd = accept(socket_fd, NULL, NULL);
+                    if(num_polls >= GSR_RPC_MAX_POLLS) {
+                        if(errno != EWOULDBLOCK)
+                            fprintf(stderr, "Error: Rpc::poll: unable to accept more clients, error: %s\n", strerror(errno));
+                    } else {
+                        polls[num_polls].fd = client_fd;
+                        polls[num_polls].events = POLLIN;
+                        polls[num_polls].revents = 0;
+                        ++num_polls;
+                    }
+                    continue;
+                }
+
+                if(polls[i].revents & POLLIN)
+                    handle_client_data(polls[i].fd, polls_data[i]);
+
+                if(polls[i].revents & (POLLERR|POLLHUP)) {
+                    close(polls[i].fd);
+                    polls[i] = polls[num_polls - 1];
+
+                    memcpy(polls_data[i].buffer, polls_data[num_polls - 1].buffer, polls_data[num_polls - 1].buffer_size);
+                    polls_data[i].buffer_size = polls_data[num_polls - 1].buffer_size;
+
+                    --num_polls;
+                    --i;
+                }
             }
-
-            name = line;
-            auto it = handlers_by_name.find(name);
-            if(it != handlers_by_name.end())
-                it->second(name);
         }
     }
 
+    void Rpc::handle_client_data(int client_fd, PollData &poll_data) {
+        char *write_buffer = poll_data.buffer + poll_data.buffer_size;
+        const ssize_t num_bytes_read = read(client_fd, write_buffer, sizeof(poll_data.buffer) - poll_data.buffer_size);
+        if(num_bytes_read <= 0)
+            return;
+
+        poll_data.buffer_size += num_bytes_read;
+        const char *newline_p = (const char*)memchr(write_buffer, '\n', num_bytes_read);
+        if(!newline_p)
+            return;
+
+        const size_t command_size = newline_p - poll_data.buffer;
+        std::string name;
+        name.assign(poll_data.buffer, command_size);
+        memmove(poll_data.buffer, newline_p + 1, poll_data.buffer_size - (command_size + 1));
+        poll_data.buffer_size -= (command_size + 1);
+
+        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/Theme.cpp

@@ -63,73 +63,91 @@ namespace gsr {
         if(!theme->title_font_file.load((resources_path + "fonts/NotoSans-Bold.ttf").c_str(), mgl::MemoryMappedFile::LoadOptions{true, false}))
             goto error;
 
-        if(!theme->combobox_arrow_texture.load_from_file((resources_path + "images/combobox_arrow.png").c_str()))
+        if(!theme->combobox_arrow_texture.load_from_file((resources_path + "images/combobox_arrow.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
 
         if(!theme->settings_texture.load_from_file((resources_path + "images/settings.png").c_str()))
             goto error;
 
-        if(!theme->settings_small_texture.load_from_file((resources_path + "images/settings_small.png").c_str()))
+        if(!theme->settings_small_texture.load_from_file((resources_path + "images/settings_small.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
 
-        if(!theme->folder_texture.load_from_file((resources_path + "images/folder.png").c_str()))
+        if(!theme->settings_extra_small_texture.load_from_file((resources_path + "images/settings_extra_small.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
 
-        if(!theme->up_arrow_texture.load_from_file((resources_path + "images/up_arrow.png").c_str()))
+        if(!theme->folder_texture.load_from_file((resources_path + "images/folder.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
 
-        if(!theme->replay_button_texture.load_from_file((resources_path + "images/replay.png").c_str()))
+        if(!theme->up_arrow_texture.load_from_file((resources_path + "images/up_arrow.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
 
-        if(!theme->record_button_texture.load_from_file((resources_path + "images/record.png").c_str()))
+        if(!theme->replay_button_texture.load_from_file((resources_path + "images/replay.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
 
-        if(!theme->stream_button_texture.load_from_file((resources_path + "images/stream.png").c_str()))
+        if(!theme->record_button_texture.load_from_file((resources_path + "images/record.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
 
-        if(!theme->close_texture.load_from_file((resources_path + "images/cross.png").c_str()))
+        if(!theme->stream_button_texture.load_from_file((resources_path + "images/stream.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
+            goto error;
+
+        if(!theme->close_texture.load_from_file((resources_path + "images/cross.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
 
         if(!theme->logo_texture.load_from_file((resources_path + "images/gpu_screen_recorder_logo.png").c_str()))
             goto error;
 
-        if(!theme->checkbox_circle_texture.load_from_file((resources_path + "images/checkbox_circle.png").c_str()))
+        if(!theme->checkbox_circle_texture.load_from_file((resources_path + "images/checkbox_circle.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
 
-        if(!theme->checkbox_background_texture.load_from_file((resources_path + "images/checkbox_background.png").c_str()))
+        if(!theme->checkbox_background_texture.load_from_file((resources_path + "images/checkbox_background.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
 
-        if(!theme->play_texture.load_from_file((resources_path + "images/play.png").c_str()))
+        if(!theme->play_texture.load_from_file((resources_path + "images/play.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
 
-        if(!theme->stop_texture.load_from_file((resources_path + "images/stop.png").c_str()))
+        if(!theme->stop_texture.load_from_file((resources_path + "images/stop.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
 
-        if(!theme->pause_texture.load_from_file((resources_path + "images/pause.png").c_str()))
+        if(!theme->pause_texture.load_from_file((resources_path + "images/pause.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
 
-        if(!theme->save_texture.load_from_file((resources_path + "images/save.png").c_str()))
+        if(!theme->save_texture.load_from_file((resources_path + "images/save.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
 
-        if(!theme->screenshot_texture.load_from_file((resources_path + "images/screenshot.png").c_str()))
+        if(!theme->screenshot_texture.load_from_file((resources_path + "images/screenshot.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
 
-        if(!theme->ps4_home_texture.load_from_file((resources_path + "images/ps4_home.png").c_str(), mgl::Texture::LoadOptions{false, false, true}))
+        if(!theme->trash_texture.load_from_file((resources_path + "images/trash.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
 
-        if(!theme->ps4_options_texture.load_from_file((resources_path + "images/ps4_options.png").c_str(), mgl::Texture::LoadOptions{false, false, true}))
+        if(!theme->masked_texture.load_from_file((resources_path + "images/masked.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
 
-        if(!theme->ps4_dpad_up_texture.load_from_file((resources_path + "images/ps4_dpad_up.png").c_str(), mgl::Texture::LoadOptions{false, false, true}))
+        if(!theme->unmasked_texture.load_from_file((resources_path + "images/unmasked.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
 
-        if(!theme->ps4_dpad_down_texture.load_from_file((resources_path + "images/ps4_dpad_down.png").c_str(), mgl::Texture::LoadOptions{false, false, true}))
+        if(!theme->ps4_home_texture.load_from_file((resources_path + "images/ps4_home.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
+            goto error;
+
+        if(!theme->ps4_options_texture.load_from_file((resources_path + "images/ps4_options.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
+            goto error;
+
+        if(!theme->ps4_dpad_up_texture.load_from_file((resources_path + "images/ps4_dpad_up.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
+            goto error;
+
+        if(!theme->ps4_dpad_down_texture.load_from_file((resources_path + "images/ps4_dpad_down.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
         
-        if(!theme->ps4_dpad_left_texture.load_from_file((resources_path + "images/ps4_dpad_left.png").c_str(), mgl::Texture::LoadOptions{false, false, true}))
+        if(!theme->ps4_dpad_left_texture.load_from_file((resources_path + "images/ps4_dpad_left.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
 
-        if(!theme->ps4_dpad_right_texture.load_from_file((resources_path + "images/ps4_dpad_right.png").c_str(), mgl::Texture::LoadOptions{false, false, true}))
+        if(!theme->ps4_dpad_right_texture.load_from_file((resources_path + "images/ps4_dpad_right.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
+            goto error;
+
+        if(!theme->ps4_cross_texture.load_from_file((resources_path + "images/ps4_cross.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
+            goto error;
+
+        if(!theme->ps4_triangle_texture.load_from_file((resources_path + "images/ps4_triangle.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
 
         return true;

src/Utils.cpp

@@ -22,6 +22,38 @@ namespace gsr {
         }
     }
 
+    bool starts_with(std::string_view str, const char *substr) {
+        size_t len = strlen(substr);
+        return str.size() >= len && memcmp(str.data(), substr, len) == 0;
+    }
+
+    bool ends_with(std::string_view str, const char *substr) {
+        size_t len = strlen(substr);
+        return str.size() >= len && memcmp(str.data() + str.size() - len, substr, len) == 0;
+    }
+
+    std::string strip(const std::string &str) {
+        int start_index = 0;
+        int str_len = str.size();
+
+        for(int i = 0; i < str_len; ++i) {
+            if(str[i] != ' ') {
+                start_index += i;
+                str_len -= i;
+                break;
+            }
+        }
+
+        for(int i = str_len - 1; i >= 0; --i) {
+            if(str[i] != ' ') {
+                str_len = i + 1;
+                break;
+            }
+        }
+
+        return str.substr(start_index, str_len);
+    }
+
     std::string get_home_dir() {
         const char *home_dir = getenv("HOME");
         if(!home_dir) {

src/WindowSelector.cpp

@@ -0,0 +1,229 @@
+#include "../include/WindowSelector.hpp"
+#include "../include/WindowUtils.hpp"
+
+#include <stdio.h>
+#include <string.h>
+
+#include <X11/extensions/shape.h>
+#include <X11/cursorfont.h>
+#include <X11/keysym.h>
+
+namespace gsr {
+    static const int rectangle_border_size = 2;
+
+    static int max_int(int a, int b) {
+        return a >= b ? a : b;
+    }
+
+    static void set_region_rectangle(Display *dpy, Window window, int x, int y, int width, int height, int border_size) {
+        if(width < 0) {
+            x += width;
+            width = abs(width);
+        }
+
+        if(height < 0) {
+            y += height;
+            height = abs(height);
+        }
+
+        XRectangle rectangles[] = {
+            {
+                (short)max_int(0, x),                              (short)max_int(0, y),
+                (unsigned short)max_int(0, border_size),           (unsigned short)max_int(0, height)
+            }, // Left
+            {
+                (short)max_int(0, x + width - border_size),        (short)max_int(0, y),
+                (unsigned short)max_int(0, border_size),           (unsigned short)max_int(0, height)
+            }, // Right
+            {
+                (short)max_int(0, x + border_size),                (short)max_int(0, y),
+                (unsigned short)max_int(0, width - border_size*2), (unsigned short)max_int(0, border_size)
+            }, // Top
+            {
+                (short)max_int(0, x + border_size),                (short)max_int(0, y + height - border_size),
+                (unsigned short)max_int(0, width - border_size*2), (unsigned short)max_int(0, border_size)
+            }, // Bottom
+        };
+        XShapeCombineRectangles(dpy, window, ShapeBounding, 0, 0, rectangles, 4, ShapeSet, Unsorted);
+        XFlush(dpy);
+    }
+
+    static unsigned long mgl_color_to_x11_color(mgl::Color color) {
+        if(color.a == 0)
+            return 0;
+        return ((uint32_t)color.a << 24) | (((uint32_t)color.r * color.a / 0xFF) << 16) | (((uint32_t)color.g * color.a / 0xFF) << 8) | ((uint32_t)color.b * color.a / 0xFF);
+    }
+
+    static Window get_cursor_window(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 window;
+    }
+
+    static void get_window_geometry(Display *dpy, Window window, mgl::vec2i &pos, mgl::vec2i &size) {
+        Window root_window;
+        int x = 0;
+        int y = 0;
+        unsigned int w = 0;
+        unsigned int h = 0;
+        unsigned int dummy_border, dummy_depth;
+        XGetGeometry(dpy, window, &root_window, &x, &y, &w, &h, &dummy_border, &dummy_depth);
+        pos.x = x;
+        pos.y = y;
+        size.x = w;
+        size.y = h;
+    }
+
+    WindowSelector::WindowSelector() {
+        
+    }
+
+    WindowSelector::~WindowSelector() {
+        stop();
+    }
+
+    bool WindowSelector::start(mgl::Color border_color) {
+        if(dpy)
+            return false;
+
+        const unsigned long border_color_x11 = mgl_color_to_x11_color(border_color);
+        dpy = XOpenDisplay(nullptr);
+        if(!dpy) {
+            fprintf(stderr, "Error: WindowSelector::start: failed to connect to the X11 server\n");
+            return false;
+        }
+
+        const Window cursor_window = get_cursor_window(dpy);
+        mgl::vec2i cursor_window_pos, cursor_window_size;
+        get_window_geometry(dpy, cursor_window, cursor_window_pos, cursor_window_size);
+
+        XVisualInfo vinfo;
+        memset(&vinfo, 0, sizeof(vinfo));
+        XMatchVisualInfo(dpy, DefaultScreen(dpy), 32, TrueColor, &vinfo);
+        border_window_colormap = XCreateColormap(dpy, DefaultRootWindow(dpy), vinfo.visual, AllocNone);
+
+        XSetWindowAttributes window_attr;
+        window_attr.background_pixel = border_color_x11;
+        window_attr.border_pixel = 0;
+        window_attr.override_redirect = true;
+        window_attr.event_mask = StructureNotifyMask | PointerMotionMask | ButtonPressMask | ButtonReleaseMask;
+        window_attr.colormap = border_window_colormap;
+
+        Screen *screen = XDefaultScreenOfDisplay(dpy);
+        border_window = XCreateWindow(dpy, DefaultRootWindow(dpy), 0, 0, XWidthOfScreen(screen), XHeightOfScreen(screen), 0,
+            vinfo.depth, InputOutput, vinfo.visual, CWBackPixel | CWBorderPixel | CWOverrideRedirect | CWEventMask | CWColormap, &window_attr);
+        if(!border_window) {
+            fprintf(stderr, "Error: WindowSelector::start: failed to create region window\n");
+            stop();
+            return false;
+        }
+        set_window_size_not_resizable(dpy, border_window, XWidthOfScreen(screen), XHeightOfScreen(screen));
+        if(cursor_window && cursor_window != DefaultRootWindow(dpy))
+            set_region_rectangle(dpy, border_window, cursor_window_pos.x, cursor_window_pos.y, cursor_window_size.x, cursor_window_size.y, rectangle_border_size);
+        else
+            set_region_rectangle(dpy, border_window, 0, 0, 0, 0, 0);
+        make_window_click_through(dpy, border_window);
+        XMapWindow(dpy, border_window);
+
+        crosshair_cursor = XCreateFontCursor(dpy, XC_crosshair);
+        XGrabPointer(dpy, DefaultRootWindow(dpy), True, PointerMotionMask | ButtonPressMask | ButtonReleaseMask | ButtonMotionMask, GrabModeAsync, GrabModeAsync, None, crosshair_cursor, CurrentTime);
+        XGrabKeyboard(dpy, DefaultRootWindow(dpy), True, GrabModeAsync, GrabModeAsync, CurrentTime);
+        XFlush(dpy);
+
+        selected = false;
+        canceled = false;
+        selected_window = None;
+        return true;
+    }
+
+    void WindowSelector::stop() {
+        if(!dpy)
+            return;
+
+        XUngrabPointer(dpy, CurrentTime);
+        XUngrabKeyboard(dpy, CurrentTime);
+
+        if(border_window_colormap) {
+            XFreeColormap(dpy, border_window_colormap);
+            border_window_colormap = 0;
+        }
+
+        if(border_window) {
+            XDestroyWindow(dpy, border_window);
+            border_window = 0;
+        }
+
+        if(crosshair_cursor) {
+            XFreeCursor(dpy, crosshair_cursor);
+            crosshair_cursor = None;
+        }
+
+        XFlush(dpy);
+        XCloseDisplay(dpy);
+        dpy = nullptr;
+    }
+
+    bool WindowSelector::is_started() const {
+        return dpy != nullptr;
+    }
+
+    bool WindowSelector::failed() const {
+        return !dpy;
+    }
+
+    bool WindowSelector::poll_events() {
+        if(!dpy || selected)
+            return false;
+
+        XEvent xev;
+        while(XPending(dpy)) {
+            XNextEvent(dpy, &xev);
+
+            if(xev.type == MotionNotify) {
+                const Window motion_window = xev.xmotion.subwindow;
+                mgl::vec2i motion_window_pos, motion_window_size;
+                get_window_geometry(dpy, motion_window, motion_window_pos, motion_window_size);
+                if(motion_window && motion_window != DefaultRootWindow(dpy))
+                    set_region_rectangle(dpy, border_window, motion_window_pos.x, motion_window_pos.y, motion_window_size.x, motion_window_size.y, rectangle_border_size);
+                else
+                    set_region_rectangle(dpy, border_window, 0, 0, 0, 0, 0);
+                XFlush(dpy);
+            } else if(xev.type == ButtonRelease && xev.xbutton.button == Button1) {
+                selected_window = xev.xbutton.subwindow;
+                const Window clicked_window_real = window_get_target_window_child(dpy, selected_window);
+                if(clicked_window_real)
+                    selected_window = clicked_window_real;
+                selected = true;
+
+                stop();
+                break;
+            } else if(xev.type == KeyRelease && XKeycodeToKeysym(dpy, xev.xkey.keycode, 0) == XK_Escape) {
+                canceled = true;
+                selected = false;
+                stop();
+                break;
+            }
+        }
+        return true;
+    }
+
+    bool WindowSelector::take_selection() {
+        const bool result = selected;
+        selected = false;
+        return result;
+    }
+
+    bool WindowSelector::take_canceled() {
+        const bool result = canceled;
+        canceled = false;
+        return result;
+    }
+
+    Window WindowSelector::get_selection() const {
+        return selected_window;
+    }
+}

src/WindowUtils.cpp

@@ -1,10 +1,12 @@
 #include "../include/WindowUtils.hpp"
+#include "../include/Utils.hpp"
 
 #include <X11/Xatom.h>
 #include <X11/Xutil.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/extensions/Xfixes.h>
 #include <X11/extensions/shapeconst.h>
+#include <X11/extensions/Xrandr.h>
 
 #include <mglpp/system/Utf8.hpp>
 
@@ -61,7 +63,7 @@ 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) {
+    Window window_get_target_window_child(Display *display, Window window) {
         if(window == None)
             return None;
 
@@ -211,28 +213,6 @@ namespace gsr {
         return result;
     }
 
-    static std::string strip(const std::string &str) {
-        int start_index = 0;
-        int str_len = str.size();
-
-        for(int i = 0; i < str_len; ++i) {
-            if(str[i] != ' ') {
-                start_index += i;
-                str_len -= i;
-                break;
-            }
-        }
-
-        for(int i = str_len - 1; i >= 0; --i) {
-            if(str[i] != ' ') {
-                str_len = i + 1;
-                break;
-            }
-        }
-
-        return str.substr(start_index, str_len);
-    }
-
     std::string get_focused_window_name(Display *dpy, WindowCaptureType window_capture_type) {
         std::string result;
         const Window focused_window = get_focused_window(dpy, window_capture_type);
@@ -518,14 +498,21 @@ namespace gsr {
         return XGetSelectionOwner(dpy, prop_atom) != None;
     }
 
-    static void get_monitors_callback(const mgl_monitor *monitor, void *userdata) {
-        std::vector<Monitor> *monitors = (std::vector<Monitor>*)userdata;
-        monitors->push_back({mgl::vec2i(monitor->pos.x, monitor->pos.y), mgl::vec2i(monitor->size.x, monitor->size.y), std::string(monitor->name)});
-    }
-
     std::vector<Monitor> get_monitors(Display *dpy) {
         std::vector<Monitor> monitors;
-        mgl_for_each_active_monitor_output(dpy, get_monitors_callback, &monitors);
+        int nmonitors = 0;
+        XRRMonitorInfo *monitor_info = XRRGetMonitors(dpy, DefaultRootWindow(dpy), True, &nmonitors);
+        if(monitor_info) {
+            for(int i = 0; i < nmonitors; ++i) {
+                char *monitor_name = XGetAtomName(dpy, monitor_info[i].name);
+                if(!monitor_name)
+                    continue;
+
+                monitors.push_back({mgl::vec2i(monitor_info[i].x, monitor_info[i].y), mgl::vec2i(monitor_info[i].width, monitor_info[i].height), std::string(monitor_name)});
+                XFree(monitor_name);
+            }
+            XRRFreeMonitors(monitor_info);
+        }
         return monitors;
     }
 

src/gui/Button.cpp

@@ -63,7 +63,7 @@ namespace gsr {
             window.draw(sprite);
 
             const int padding_icon_right = padding_right_icon_scale * get_button_height();
-            text.set_position((sprite.get_position() + mgl::vec2f(sprite.get_size().x + padding_icon_right, sprite.get_size().y * 0.5f - text.get_bounds().size.y * 0.5f)).floor());
+            text.set_position((sprite.get_position() + mgl::vec2f(sprite.get_size().x + padding_icon_right, sprite.get_size().y * 0.5f - text.get_bounds().size.y * 0.52f)).floor());
             window.draw(text);
         } else {
             text.set_position((draw_pos + item_size * 0.5f - text.get_bounds().size * 0.5f).floor());

src/gui/ComboBox.cpp

@@ -36,7 +36,7 @@ namespace gsr {
                 for(size_t i = 0; i < items.size(); ++i) {
                     Item &item = items[i];
                     item_size.y = padding_top + item.text.get_bounds().size.y + padding_bottom;
-                    if(mgl::FloatRect(item.position, item_size).contains(mouse_pos)) {
+                    if(mgl::FloatRect(item.position, item_size).contains(mouse_pos) && item.enabled) {
                         const size_t prev_selected_item = selected_item;
                         selected_item = i;
                         show_dropdown = false;
@@ -85,7 +85,7 @@ namespace gsr {
 
     void ComboBox::add_item(const std::string &text, const std::string &id) {
         items.push_back({mgl::Text(text, *font), id, {0.0f, 0.0f}});
-        items.back().text.set_max_width(font->get_character_size() * 22); // TODO: Make a proper solution
+        items.back().text.set_max_width(font->get_character_size() * 20); // TODO: Make a proper solution
         //items.back().text.set_max_rows(1);
         dirty = true;
     }
@@ -93,7 +93,7 @@ namespace gsr {
     void ComboBox::set_selected_item(const std::string &id, bool trigger_event, bool trigger_event_even_if_selection_not_changed) {
         for(size_t i = 0; i < items.size(); ++i) {
             auto &item = items[i];
-            if(item.id == id) {
+            if(item.id == id && item.enabled) {
                 const size_t prev_selected_item = selected_item;
                 selected_item = i;
                 dirty = true;
@@ -106,6 +106,22 @@ namespace gsr {
         }
     }
 
+    void ComboBox::set_item_enabled(const std::string &id, bool enabled) {
+        for(size_t i = 0; i < items.size(); ++i) {
+            auto &item = items[i];
+            if(item.id == id) {
+                item.enabled = enabled;
+                item.text.set_color(item.enabled ? mgl::Color(255, 255, 255, 255) : mgl::Color(255, 255, 255, 80));
+                if(selected_item == i) {
+                    selected_item = 0;
+                    show_dropdown = false;
+                    dirty = true;
+                }
+                return;
+            }
+        }
+    }
+
     const std::string& ComboBox::get_selected_id() const {
         if(items.empty()) {
             static std::string dummy;
@@ -150,7 +166,7 @@ namespace gsr {
             Item &item = items[i];
             item_size.y = padding_top + item.text.get_bounds().size.y + padding_bottom;
 
-            if(!cursor_inside) {
+            if(!cursor_inside && item.enabled) {
                 cursor_inside = mgl::FloatRect(items_draw_pos, item_size).contains(mouse_pos);
                 if(cursor_inside) {
                     mgl::Rectangle item_background(items_draw_pos.floor(), item_size.floor());

src/gui/DropdownButton.cpp

@@ -110,6 +110,14 @@ namespace gsr {
             window.draw(rect);
         }
 
+        if(activated) {
+            description.set_color(get_color_theme().tint_color);
+            icon_sprite.set_color(get_color_theme().tint_color);
+        } else {
+            description.set_color(mgl::Color(150, 150, 150));
+            icon_sprite.set_color(mgl::Color(255, 255, 255));
+        }
+
         const int text_margin = size.y * 0.085;
 
         const auto title_bounds = title.get_bounds();
@@ -148,7 +156,7 @@ namespace gsr {
                     window.draw(separator);
                 }
 
-                if(mouse_inside_item == -1) {
+                if(mouse_inside_item == -1 && item.enabled) {
                     const bool inside = mgl::FloatRect(item_position, item_size).contains({ (float)mouse_pos.x, (float)mouse_pos.y });
                     if(inside) {
                         draw_rectangle_outline(window, item_position, item_size, get_color_theme().tint_color, border_size);
@@ -161,16 +169,18 @@ namespace gsr {
                     mgl::Sprite icon(item.icon_texture);
                     icon.set_height((int)(item_size.y * 0.4f));
                     icon.set_position((item_position + mgl::vec2f(padding_left, item_size.y * 0.5f - icon.get_size().y * 0.5f)).floor());
+                    icon.set_color(item.enabled ? mgl::Color(255, 255, 255, 255) : mgl::Color(255, 255, 255, 80));
                     window.draw(icon);
                     icon_offset = icon.get_size().x + icon_spacing;
                 }
 
                 item.text.set_position((item_position + mgl::vec2f(padding_left + icon_offset, item_size.y * 0.5f - text_bounds.size.y * 0.5f)).floor());
+                item.text.set_color(item.enabled ? mgl::Color(255, 255, 255, 255) : mgl::Color(255, 255, 255, 80));
                 window.draw(item.text);
 
                 const auto description_bounds = item.description_text.get_bounds();
                 item.description_text.set_position((item_position + mgl::vec2f(item_size.x - description_bounds.size.x - padding_right, item_size.y * 0.5f - description_bounds.size.y * 0.5f)).floor());
-                item.description_text.set_color(mgl::Color(255, 255, 255, 120));
+                item.description_text.set_color(item.enabled ? mgl::Color(255, 255, 255, 120) : mgl::Color(255, 255, 255, 40));
                 window.draw(item.description_text);
 
                 item_position.y += item_size.y;
@@ -179,6 +189,10 @@ namespace gsr {
     }
 
     void DropdownButton::add_item(const std::string &text, const std::string &id, const std::string &description) {
+        for(auto &item : items) {
+            if(item.id == id)
+                return;
+        }
         items.push_back({mgl::Text(text, *title_font), mgl::Text(description, *description_font), nullptr, id});
         dirty = true;
     }
@@ -210,6 +224,15 @@ namespace gsr {
         }
     }
 
+    void DropdownButton::set_item_enabled(const std::string &id, bool enabled) {
+        for(auto &item : items) {
+            if(item.id == id) {
+                item.enabled = enabled;
+                return;
+            }
+        }
+    }
+
     void DropdownButton::set_description(std::string description_text) {
         description.set_string(std::move(description_text));
     }
@@ -219,14 +242,6 @@ namespace gsr {
             return;
 
         this->activated = activated;
-
-        if(activated) {
-            description.set_color(get_color_theme().tint_color);
-            icon_sprite.set_color(get_color_theme().tint_color);
-        } else {
-            description.set_color(mgl::Color(150, 150, 150));
-            icon_sprite.set_color(mgl::Color(255, 255, 255));
-        }
     }
 
     void DropdownButton::update_if_dirty() {

src/gui/Entry.cpp

@@ -1,12 +1,12 @@
 #include "../../include/gui/Entry.hpp"
 #include "../../include/gui/Utils.hpp"
 #include "../../include/Theme.hpp"
-#include <mglpp/graphics/Rectangle.hpp>
 #include <mglpp/window/Window.hpp>
 #include <mglpp/window/Event.hpp>
 #include <mglpp/system/FloatRect.hpp>
 #include <mglpp/system/Utf8.hpp>
 #include <optional>
+#include <string.h>
 
 namespace gsr {
     static const float padding_top_scale = 0.004629f;
@@ -16,8 +16,20 @@ namespace gsr {
     static const float border_scale = 0.0015f;
     static const float caret_width_scale = 0.001f;
 
-    Entry::Entry(mgl::Font *font, const char *text, float max_width) : text("", *font), max_width(max_width) {
+    static void string_replace_all(std::string &str, char old_char, char new_char) {
+        for(char &c : str) {
+            if(c == old_char)
+                c = new_char;
+        }
+    }
+
+    Entry::Entry(mgl::Font *font, const char *text, float max_width) :
+        text(std::u32string(), *font),
+        masked_text(std::u32string(), *font),
+        max_width(max_width)
+    {
         this->text.set_color(get_color_theme().text_color);
+        this->masked_text.set_color(get_color_theme().text_color);
         set_text(text);
     }
 
@@ -25,25 +37,133 @@ namespace gsr {
         if(!visible)
             return true;
 
+        mgl::Text32 &active_text = masked ? masked_text : text;
+
         if(event.type == mgl::Event::MouseButtonPressed && event.mouse_button.button == mgl::Mouse::Left) {
-            selected = mgl::FloatRect(position + offset, get_size()).contains({ (float)event.mouse_button.x, (float)event.mouse_button.y });
-        } else if(event.type == mgl::Event::KeyPressed && selected) {
-            if(event.key.code == mgl::Keyboard::Backspace && !text.get_string().empty()) {
-                std::string str = text.get_string();
-                const size_t prev_index = mgl::utf8_get_start_of_codepoint((const unsigned char*)str.c_str(), str.size(), str.size());
-                str.erase(prev_index, std::string::npos);
-                set_text(std::move(str));
-            } else if(event.key.code == mgl::Keyboard::V && event.key.control) {
-                std::string clipboard_text = window.get_clipboard_string();
-                std::string str = text.get_string();
-                str += clipboard_text;
-                set_text(std::move(str));
+            const mgl::vec2f mouse_pos = { (float)event.mouse_button.x, (float)event.mouse_button.y };
+            selected = mgl::FloatRect(position + offset, get_size()).contains(mouse_pos);
+            if(selected) {
+                selecting_text = true;
+
+                const auto caret_index_mouse = find_closest_caret_index_by_position(mouse_pos);
+                caret.index = caret_index_mouse.index;
+                caret.offset_x = caret_index_mouse.pos.x - active_text.get_position().x;
+                selection_start_caret = caret;
+                show_selection = true;
+            } else {
+                selecting_text = false;
+                selecting_with_keyboard = false;
+                show_selection = false;
             }
-        } else if(event.type == mgl::Event::TextEntered && selected && event.text.codepoint >= 32) {
-            std::string str = text.get_string();
-            str.append(event.text.str, event.text.size);
-            set_text(std::move(str));
+        } else if(event.type == mgl::Event::MouseButtonReleased && event.mouse_button.button == mgl::Mouse::Left) {
+            selecting_text = false;
+            if(caret.index == selection_start_caret.index)
+                show_selection = false;
+        } else if(event.type == mgl::Event::MouseMoved && selected) {
+            if(selecting_text) {
+                const auto caret_index_mouse = find_closest_caret_index_by_position(mgl::vec2f(event.mouse_move.x, event.mouse_move.y));
+                caret.index = caret_index_mouse.index;
+                caret.offset_x = caret_index_mouse.pos.x - active_text.get_position().x;
+                return false;
+            }
+        } else if(event.type == mgl::Event::KeyPressed && selected) {
+            int selection_start_byte = caret.index;
+            int selection_end_byte = caret.index;
+            if(show_selection) {
+                selection_start_byte = std::min(caret.index, selection_start_caret.index);
+                selection_end_byte = std::max(caret.index, selection_start_caret.index);
+            }
+
+            if(event.key.code == mgl::Keyboard::Backspace) {
+                if(selection_start_byte == selection_end_byte && caret.index > 0)
+                    selection_start_byte -= 1;
+
+                replace_text(selection_start_byte, selection_end_byte - selection_start_byte, std::u32string());
+            } else if(event.key.code == mgl::Keyboard::Delete) {
+                if(selection_start_byte == selection_end_byte && caret.index < (int)active_text.get_string().size())
+                    selection_end_byte += 1;
+
+                replace_text(selection_start_byte, selection_end_byte - selection_start_byte, std::u32string());
+            } else if(event.key.code == mgl::Keyboard::C && event.key.control) {
+                const size_t selection_num_bytes = selection_end_byte - selection_start_byte;
+                if(selection_num_bytes > 0)
+                    window.set_clipboard(mgl::utf32_to_utf8(text.get_string().substr(selection_start_byte, selection_num_bytes)));
+            } else if(event.key.code == mgl::Keyboard::V && event.key.control) {
+                std::string clipboard_string = window.get_clipboard_string();
+                string_replace_all(clipboard_string, '\n', ' ');
+                replace_text(selection_start_byte, selection_end_byte - selection_start_byte, mgl::utf8_to_utf32(clipboard_string));
+            } else if(event.key.code == mgl::Keyboard::A && event.key.control) {
+                selection_start_caret.index = 0;
+                selection_start_caret.offset_x = 0.0f;
+
+                caret.index = active_text.get_string().size();
+                // TODO: Optimize
+                caret.offset_x = active_text.find_character_pos(caret.index).x - active_text.get_position().x;
+
+                show_selection = true;
+            } else if(event.key.code == mgl::Keyboard::Left) {
+                if(!selecting_with_keyboard && show_selection)
+                    show_selection = false;
+                else
+                    move_caret_word(Direction::LEFT, event.key.control ? 999999 : 1);
+
+                if(!selecting_with_keyboard) {
+                    selection_start_caret = caret;
+                    show_selection = false;
+                }
+            } else if(event.key.code == mgl::Keyboard::Right) {
+                if(!selecting_with_keyboard && show_selection)
+                    show_selection = false;
+                else
+                    move_caret_word(Direction::RIGHT, event.key.control ? 999999 : 1);
+
+                if(!selecting_with_keyboard) {
+                    selection_start_caret = caret;
+                    show_selection = false;
+                }
+            } else if(event.key.code == mgl::Keyboard::Home) {
+                caret.index = 0;
+                caret.offset_x = 0.0f;
+
+                if(!selecting_with_keyboard) {
+                    selection_start_caret = caret;
+                    show_selection = false;
+                }
+            } else if(event.key.code == mgl::Keyboard::End) {
+                caret.index = active_text.get_string().size();
+                // TODO: Optimize
+                caret.offset_x = active_text.find_character_pos(caret.index).x - active_text.get_position().x;
+
+                if(!selecting_with_keyboard) {
+                    selection_start_caret = caret;
+                    show_selection = false;
+                }
+            } else if(event.key.code == mgl::Keyboard::LShift || event.key.code == mgl::Keyboard::RShift) {
+                if(!show_selection)
+                    selection_start_caret = caret;
+                selecting_with_keyboard = true;
+                show_selection = true;
+            }
+
+            return false;
+        } else if(event.type == mgl::Event::KeyReleased && selected) {
+            if(event.key.code == mgl::Keyboard::LShift || event.key.code == mgl::Keyboard::RShift) {
+                selecting_with_keyboard = false;
+            }
+
+            return false;
+        } else if(event.type == mgl::Event::TextEntered && selected && event.text.codepoint >= 32 && event.text.codepoint != 127) {
+            int selection_start_byte = caret.index;
+            int selection_end_byte = caret.index;
+            if(show_selection) {
+                selection_start_byte = std::min(caret.index, selection_start_caret.index);
+                selection_end_byte = std::max(caret.index, selection_start_caret.index);
+            }
+
+            replace_text(selection_start_byte, selection_end_byte - selection_start_byte, mgl::utf8_to_utf32((const unsigned char*)event.text.str, event.text.size));
+            return false;
         }
+
         return true;
     }
 
@@ -54,26 +174,91 @@ namespace gsr {
         const mgl::vec2f draw_pos = position + offset;
 
         const int padding_top = padding_top_scale * get_theme().window_height;
+        const int padding_bottom = padding_bottom_scale * get_theme().window_height;
         const int padding_left = padding_left_scale * get_theme().window_height;
+        const int padding_right = padding_right_scale * get_theme().window_height;
 
-        mgl::Rectangle background(get_size());
+        mgl::Text32 &active_text = masked ? masked_text : text;
+
+        background.set_size(get_size());
         background.set_position(draw_pos.floor());
         background.set_color(selected ? mgl::Color(0, 0, 0, 255) : mgl::Color(0, 0, 0, 120));
         window.draw(background);
 
+        const int caret_width = std::max(1.0f, caret_width_scale * get_theme().window_height);
+        const mgl::vec2f caret_size = mgl::vec2f(caret_width, active_text.get_bounds().size.y).floor();
+
+        const float overflow_left = (caret.offset_x + padding_left) - (padding_left + text_overflow);
+        if(overflow_left < 0.0f)
+            text_overflow += overflow_left;
+
+        const float overflow_right = (caret.offset_x + padding_left) - (background.get_size().x - padding_right);
+        if(overflow_right - text_overflow > 0.0f)
+            text_overflow = overflow_right;
+
+        active_text.set_position((draw_pos + mgl::vec2f(padding_left, get_size().y * 0.5f - active_text.get_bounds().size.y * 0.5f) - mgl::vec2f(text_overflow, 0.0f)).floor());
+
+        const auto text_bounds = active_text.get_bounds();
+        const bool text_larger_than_background = text_bounds.size.x > (background.get_size().x - padding_left - padding_right);
+        const float text_overflow_right = (text_bounds.position.x + text_bounds.size.x) - (background.get_position().x + background.get_size().x - padding_right);
+        if(text_larger_than_background) {
+            if(text_overflow_right < 0.0f) {
+                text_overflow += text_overflow_right;
+                active_text.set_position(active_text.get_position() + mgl::vec2f(-text_overflow_right, 0.0f));
+            }
+        } else {
+            active_text.set_position(active_text.get_position() + mgl::vec2f(-text_overflow, 0.0f));
+            text_overflow = 0.0f;
+        }
+
         if(selected) {
             const int border_size = std::max(1.0f, border_scale * get_theme().window_height);
             draw_rectangle_outline(window, draw_pos.floor(), get_size().floor(), get_color_theme().tint_color, border_size);
-
-            const int caret_width = std::max(1.0f, caret_width_scale * get_theme().window_height);
-            mgl::Rectangle caret({(float)caret_width, text.get_bounds().size.y});
-            caret.set_position((draw_pos + mgl::vec2f(padding_left + caret_offset_x, padding_top)).floor());
-            caret.set_color(mgl::Color(255, 255, 255));
-            window.draw(caret);
+            draw_caret(window, draw_pos, caret_size);
         }
 
-        text.set_position((draw_pos + mgl::vec2f(padding_left, get_size().y * 0.5f - text.get_bounds().size.y * 0.5f)).floor());
-        window.draw(text);
+        const mgl::Scissor parent_scissor = window.get_scissor();
+        const mgl::Scissor scissor = scissor_get_sub_area(parent_scissor,
+            mgl::Scissor{
+                (background.get_position() + mgl::vec2f(padding_left, padding_top)).to_vec2i(),
+                (background.get_size() - mgl::vec2f(padding_left + padding_right, padding_top + padding_bottom)).to_vec2i()
+            });
+        window.set_scissor(scissor);
+
+        window.draw(active_text);
+
+        if(show_selection)
+            draw_caret_selection(window, draw_pos, caret_size);
+
+        window.set_scissor(parent_scissor);
+    }
+
+    void Entry::draw_caret(mgl::Window &window, mgl::vec2f draw_pos, mgl::vec2f caret_size) {
+        const int padding_top = padding_top_scale * get_theme().window_height;
+        const int padding_left = padding_left_scale * get_theme().window_height;
+
+        mgl::Rectangle caret_rect(caret_size);
+        mgl::vec2f caret_draw_pos = draw_pos + mgl::vec2f(padding_left + caret.offset_x - text_overflow, padding_top);
+        caret_rect.set_position(caret_draw_pos.floor());
+        caret_rect.set_color(mgl::Color(255, 255, 255));
+        window.draw(caret_rect);
+    }
+
+    void Entry::draw_caret_selection(mgl::Window &window, mgl::vec2f draw_pos, mgl::vec2f caret_size) {
+        if(selection_start_caret.index == caret.index)
+            return;
+
+        const int padding_top = padding_top_scale * get_theme().window_height;
+        const int padding_left = padding_left_scale * get_theme().window_height;
+        const int caret_width = std::max(1.0f, caret_width_scale * get_theme().window_height);
+        const int offset = caret.index < selection_start_caret.index ? caret_width : 0;
+
+        mgl::Rectangle caret_selection_rect(mgl::vec2f(std::abs(selection_start_caret.offset_x - caret.offset_x) - offset, caret_size.y).floor());
+        caret_selection_rect.set_position((draw_pos + mgl::vec2f(padding_left + std::min(caret.offset_x, selection_start_caret.offset_x) - text_overflow + offset, padding_top)).floor());
+        mgl::Color caret_select_color = get_color_theme().tint_color;
+        caret_select_color.a = 100;
+        caret_selection_rect.set_color(caret_select_color);
+        window.draw(caret_selection_rect);
     }
 
     mgl::vec2f Entry::get_size() {
@@ -85,24 +270,157 @@ namespace gsr {
         return { max_width, text.get_bounds().size.y + padding_top + padding_bottom };
     }
 
-    void Entry::set_text(std::string str) {
-        if(!validate_handler || validate_handler(str)) {
-            text.set_string(std::move(str));
-            caret_offset_x = text.find_character_pos(99999).x - this->text.get_position().x;
-            if(on_changed)
-                on_changed(text.get_string());
+    void Entry::move_caret_word(Direction direction, size_t max_codepoints) {
+        mgl::Text32 &active_text = masked ? masked_text : text;
+        const int dir_step = direction == Direction::LEFT ? -1 : 1;
+        const int num_delimiter_chars = 15;
+        const char delimiter_chars[num_delimiter_chars + 1] = " \t\n/.,:;\\[](){}";
+        const char32_t *text_str = active_text.get_string().data();
+
+        int num_non_delimiter_chars_found = 0;
+
+        for(size_t i = 0; i < max_codepoints; ++i) {
+            const uint32_t codepoint = text_str[caret.index];
+
+            const bool is_delimiter_char = codepoint < 127 && !!memchr(delimiter_chars, codepoint, num_delimiter_chars);
+            if(is_delimiter_char) {
+                if(num_non_delimiter_chars_found > 0)
+                    break;
+            } else {
+                ++num_non_delimiter_chars_found;
+            }
+
+            if(caret.index + dir_step < 0 || caret.index + dir_step > (int)active_text.get_string().size())
+                break;
+
+            caret.index += dir_step;
         }
+
+        // TODO: Move right by some characters instead of calculating every character to caret index
+        caret.offset_x = active_text.find_character_pos(caret.index).x - active_text.get_position().x;
     }
 
-    const std::string& Entry::get_text() const {
-        return text.get_string();
+    EntryValidateHandlerResult Entry::set_text(const std::string &str) {
+        EntryValidateHandlerResult validate_result = set_text_internal(mgl::utf8_to_utf32(str));
+        if(validate_result == EntryValidateHandlerResult::ALLOW) {
+            mgl::Text32 &active_text = masked ? masked_text : text;
+            caret.index = active_text.get_string().size();
+            // TODO: Optimize
+            caret.offset_x = active_text.find_character_pos(caret.index).x - active_text.get_position().x;
+            selection_start_caret = caret;
+
+            selecting_text = false;
+            selecting_with_keyboard = false;
+            show_selection = false;
+        }
+        return validate_result;
+    }
+
+    EntryValidateHandlerResult Entry::set_text_internal(std::u32string str) {
+        EntryValidateHandlerResult validate_result = EntryValidateHandlerResult::ALLOW;
+        if(validate_handler)
+            validate_result = validate_handler(*this, str);
+
+        if(validate_result == EntryValidateHandlerResult::ALLOW) {
+            text.set_string(std::move(str));
+            if(masked)
+                masked_text.set_string(std::u32string(text.get_string().size(), '*'));
+            // TODO: Call callback with utf32 instead?
+            if(on_changed)
+                on_changed(mgl::utf32_to_utf8(text.get_string()));
+        }
+
+        return validate_result;
+    }
+
+    std::string Entry::get_text() const {
+        return mgl::utf32_to_utf8(text.get_string());
+    }
+
+    void Entry::set_masked(bool masked) {
+        if(masked == this->masked)
+            return;
+
+        this->masked = masked;
+
+        if(masked)
+            masked_text.set_string(std::u32string(text.get_string().size(), '*'));
+        else
+            masked_text.set_string(std::u32string());
+
+        mgl::Text32 &active_text = masked ? masked_text : text;
+        caret.offset_x = active_text.find_character_pos(caret.index).x - active_text.get_position().x;
+        selection_start_caret.offset_x = active_text.find_character_pos(selection_start_caret.index).x - active_text.get_position().x;
+    }
+
+    bool Entry::is_masked() const {
+        return masked;
+    }
+
+    void Entry::replace_text(size_t index, size_t size, const std::u32string &replacement) {
+        if(index + size > text.get_string().size())
+            return;
+
+        const auto prev_caret = caret;
+
+        if((int)index >= caret.index)
+            caret.index += replacement.size();
+        else
+            caret.index = caret.index - size + replacement.size();
+
+        std::u32string str = text.get_string();
+        str.replace(index, size, replacement);
+        const EntryValidateHandlerResult validate_result = set_text_internal(std::move(str));
+        if(validate_result == EntryValidateHandlerResult::DENY) {
+            caret = prev_caret;
+            return;
+        } else if(validate_result == EntryValidateHandlerResult::REPLACED) {
+            return;
+        }
+
+        mgl::Text32 &active_text = masked ? masked_text : text;
+        // TODO: Optimize
+        caret.offset_x = active_text.find_character_pos(caret.index).x - active_text.get_position().x;
+        selection_start_caret = caret;
+
+        selecting_text = false;
+        selecting_with_keyboard = false;
+        show_selection = false;
+    }
+
+    CaretIndexPos Entry::find_closest_caret_index_by_position(mgl::vec2f position) {
+        mgl::Text32 &active_text = masked ? masked_text : text;
+        const std::u32string &str = active_text.get_string();
+        mgl::Font *font = active_text.get_font();
+
+        CaretIndexPos result = {0, {active_text.get_position().x, active_text.get_position().y}};
+        for(result.index = 0; result.index < (int)str.size(); ++result.index) {
+            const uint32_t codepoint = str[result.index];
+
+            float glyph_width = 0.0f;
+            if(codepoint == '\t') {
+                const auto glyph = font->get_glyph(' ');
+                const int tab_width = 4;
+                glyph_width = glyph.advance * tab_width;
+            } else {
+                const auto glyph = font->get_glyph(codepoint);
+                glyph_width = glyph.advance;
+            }
+
+            if(result.pos.x + glyph_width * 0.5f >= position.x)
+                break;
+            
+            result.pos.x += glyph_width;
+        }
+
+        return result;
     }
 
     static bool is_number(uint8_t c) {
         return c >= '0' && c <= '9';
     }
 
-    static std::optional<int> to_integer(const std::string &str) {
+    static std::optional<int> to_integer(const std::u32string &str) {
         if(str.empty())
             return std::nullopt;
 
@@ -114,7 +432,7 @@ namespace gsr {
         int number = 0;
         for(; i < str.size(); ++i) {
             if(!is_number(str[i]))
-                return false;
+                return std::nullopt;
 
             const int new_number = number * 10 + (str[i] - '0');
             if(new_number < number)
@@ -129,19 +447,23 @@ namespace gsr {
     }
 
     EntryValidateHandler create_entry_validator_integer_in_range(int min, int max) {
-        return [min, max](std::string &str) {
+        return [min, max](Entry &entry, const std::u32string &str) {
             if(str.empty())
-                return true;
+                return EntryValidateHandlerResult::ALLOW;
 
-            std::optional<int> number = to_integer(str);
+            const std::optional<int> number = to_integer(str);
             if(!number)
-                return false;
+                return EntryValidateHandlerResult::DENY;
 
-            if(number.value() < min)
-                str = std::to_string(min);
-            else if(number.value() > max)
-                str = std::to_string(max);
-            return true;
+            if(number.value() < min) {
+                entry.set_text(std::to_string(min));
+                return EntryValidateHandlerResult::REPLACED;
+            } else if(number.value() > max) {
+                entry.set_text(std::to_string(max));
+                return EntryValidateHandlerResult::REPLACED;
+            }
+
+            return EntryValidateHandlerResult::ALLOW;
         };
     }
 }

src/gui/GlobalSettingsPage.cpp

@@ -1,7 +1,6 @@
 #include "../../include/gui/GlobalSettingsPage.hpp"
 
 #include "../../include/Overlay.hpp"
-#include "../../include/GlobalHotkeys.hpp"
 #include "../../include/Theme.hpp"
 #include "../../include/Process.hpp"
 #include "../../include/gui/GsrPage.hpp"
@@ -149,7 +148,7 @@ namespace gsr {
         tint_color_radio_button_ptr = tint_color_radio_button.get();
         tint_color_radio_button->add_item("Red", "amd");
         tint_color_radio_button->add_item("Green", "nvidia");
-        tint_color_radio_button->add_item("blue", "intel");
+        tint_color_radio_button->add_item("Blue", "intel");
         tint_color_radio_button->on_selection_changed = [](const std::string&, const std::string &id) {
             if(id == "amd")
                 get_color_theme().tint_color = mgl::Color(221, 0, 49);
@@ -191,11 +190,12 @@ namespace gsr {
     }
 
     std::unique_ptr<RadioButton> GlobalSettingsPage::create_enable_keyboard_hotkeys_button() {
-        auto enable_hotkeys_radio_button = std::make_unique<RadioButton>(&get_theme().body_font, RadioButton::Orientation::HORIZONTAL);
+        auto enable_hotkeys_radio_button = std::make_unique<RadioButton>(&get_theme().body_font, RadioButton::Orientation::VERTICAL);
         enable_keyboard_hotkeys_radio_button_ptr = enable_hotkeys_radio_button.get();
         enable_hotkeys_radio_button->add_item("Yes", "enable_hotkeys");
+        enable_hotkeys_radio_button->add_item("Yes, but only grab virtual devices (supports some input remapping software)", "enable_hotkeys_virtual_devices");
+        enable_hotkeys_radio_button->add_item("Yes, but don't grab devices (supports all input remapping software)", "enable_hotkeys_no_grab");
         enable_hotkeys_radio_button->add_item("No", "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_keyboard_hotkey_changed)
                 on_keyboard_hotkey_changed(id.c_str());
@@ -256,6 +256,30 @@ namespace gsr {
         return list;
     }
 
+    std::unique_ptr<List> GlobalSettingsPage::create_replay_partial_save_hotkey_options() {
+        auto list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER);
+
+        list->add_widget(std::make_unique<Label>(&get_theme().body_font, "Save 1 minute replay:", get_color_theme().text_color));
+        auto save_replay_1_min_button = std::make_unique<Button>(&get_theme().body_font, "", mgl::vec2f(0.0f, 0.0f), mgl::Color(0, 0, 0, 120));
+        save_replay_1_min_button_ptr = save_replay_1_min_button.get();
+        list->add_widget(std::move(save_replay_1_min_button));
+
+        list->add_widget(std::make_unique<Label>(&get_theme().body_font, "Save 10 minute replay:", get_color_theme().text_color));
+        auto save_replay_10_min_button = std::make_unique<Button>(&get_theme().body_font, "", mgl::vec2f(0.0f, 0.0f), mgl::Color(0, 0, 0, 120));
+        save_replay_10_min_button_ptr = save_replay_10_min_button.get();
+        list->add_widget(std::move(save_replay_10_min_button));
+
+        save_replay_1_min_button_ptr->on_click = [this] {
+            configure_hotkey_start(ConfigureHotkeyType::REPLAY_SAVE_1_MIN);
+        };
+
+        save_replay_10_min_button_ptr->on_click = [this] {
+            configure_hotkey_start(ConfigureHotkeyType::REPLAY_SAVE_10_MIN);
+        };
+
+        return list;
+    }
+
     std::unique_ptr<List> GlobalSettingsPage::create_record_hotkey_options() {
         auto list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER);
 
@@ -325,6 +349,27 @@ namespace gsr {
         return list;
     }
 
+    std::unique_ptr<List> GlobalSettingsPage::create_screenshot_window_hotkey_options() {
+        auto list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER);
+
+        char str[128];
+        if(gsr_info->system_info.display_server == DisplayServer::X11)
+            snprintf(str, sizeof(str), "Take a screenshot of a window:");
+        else
+            snprintf(str, sizeof(str), "Take a screenshot with desktop portal:");
+
+        list->add_widget(std::make_unique<Label>(&get_theme().body_font, str, get_color_theme().text_color));
+        auto take_screenshot_window_button = std::make_unique<Button>(&get_theme().body_font, "", mgl::vec2f(0.0f, 0.0f), mgl::Color(0, 0, 0, 120));
+        take_screenshot_window_button_ptr = take_screenshot_window_button.get();
+        list->add_widget(std::move(take_screenshot_window_button));
+
+        take_screenshot_window_button_ptr->on_click = [this] {
+            configure_hotkey_start(ConfigureHotkeyType::TAKE_SCREENSHOT_WINDOW);
+        };
+
+        return list;
+    }
+
     std::unique_ptr<List> GlobalSettingsPage::create_hotkey_control_buttons() {
         auto list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER);
 
@@ -335,8 +380,11 @@ namespace gsr {
             config.record_config.pause_unpause_hotkey = {mgl::Keyboard::Unknown, 0};
             config.replay_config.start_stop_hotkey = {mgl::Keyboard::Unknown, 0};
             config.replay_config.save_hotkey = {mgl::Keyboard::Unknown, 0};
+            config.replay_config.save_1_min_hotkey = {mgl::Keyboard::Unknown, 0};
+            config.replay_config.save_10_min_hotkey = {mgl::Keyboard::Unknown, 0};
             config.screenshot_config.take_screenshot_hotkey = {mgl::Keyboard::Unknown, 0};
             config.screenshot_config.take_screenshot_region_hotkey = {mgl::Keyboard::Unknown, 0};
+            config.screenshot_config.take_screenshot_window_hotkey = {mgl::Keyboard::Unknown, 0};
             config.main_config.show_hide_hotkey = {mgl::Keyboard::Unknown, 0};
             load_hotkeys();
             overlay->rebind_all_keyboard_hotkeys();
@@ -374,10 +422,12 @@ namespace gsr {
         list_ptr->add_widget(std::make_unique<LineSeparator>(LineSeparator::Orientation::HORIZONTAL, subsection->get_inner_size().x));
         list_ptr->add_widget(create_show_hide_hotkey_options());
         list_ptr->add_widget(create_replay_hotkey_options());
+        list_ptr->add_widget(create_replay_partial_save_hotkey_options());
         list_ptr->add_widget(create_record_hotkey_options());
         list_ptr->add_widget(create_stream_hotkey_options());
         list_ptr->add_widget(create_screenshot_hotkey_options());
         list_ptr->add_widget(create_screenshot_region_hotkey_options());
+        list_ptr->add_widget(create_screenshot_window_hotkey_options());
         list_ptr->add_widget(create_hotkey_control_buttons());
         return subsection;
     }
@@ -395,6 +445,8 @@ namespace gsr {
         list_ptr->add_widget(create_joystick_hotkey_text(&get_theme().ps4_home_texture, &get_theme().ps4_dpad_down_texture, get_theme().body_font.get_character_size(), "to save a replay"));
         list_ptr->add_widget(create_joystick_hotkey_text(&get_theme().ps4_home_texture, &get_theme().ps4_dpad_left_texture, get_theme().body_font.get_character_size(), "to start/stop recording"));
         list_ptr->add_widget(create_joystick_hotkey_text(&get_theme().ps4_home_texture, &get_theme().ps4_dpad_right_texture, get_theme().body_font.get_character_size(), "to turn replay on/off"));
+        list_ptr->add_widget(create_joystick_hotkey_text(&get_theme().ps4_home_texture, &get_theme().ps4_cross_texture, get_theme().body_font.get_character_size(), "to save a 1 minute replay"));
+        list_ptr->add_widget(create_joystick_hotkey_text(&get_theme().ps4_home_texture, &get_theme().ps4_triangle_texture, get_theme().body_font.get_character_size(), "to save a 10 minute replay"));
         return subsection;
     }
 
@@ -416,13 +468,42 @@ namespace gsr {
         return exit_program_button;
     }
 
+    std::unique_ptr<List> GlobalSettingsPage::create_notification_speed() {
+        auto list = std::make_unique<List>(List::Orientation::VERTICAL);
+        list->add_widget(std::make_unique<Label>(&get_theme().body_font, "Notification speed", get_color_theme().text_color));
+
+        auto radio_button = std::make_unique<RadioButton>(&get_theme().body_font, RadioButton::Orientation::HORIZONTAL);
+        notification_speed_button_ptr = radio_button.get();
+        radio_button->add_item("Normal", "normal");
+        radio_button->add_item("Fast", "fast");
+        radio_button->on_selection_changed = [this](const std::string&, const std::string &id) {
+            if(id == "normal")
+                overlay->set_notification_speed(NotificationSpeed::NORMAL);
+            else if(id == "fast")
+                overlay->set_notification_speed(NotificationSpeed::FAST);
+            return true;
+        };
+        list->add_widget(std::move(radio_button));
+
+        return list;
+    }
+
     std::unique_ptr<Subsection> GlobalSettingsPage::create_application_options_subsection(ScrollablePage *parent_page) {
+        auto list = std::make_unique<List>(List::Orientation::VERTICAL);
+        List *list_ptr = list.get();
+        auto subsection = std::make_unique<Subsection>("Application options", std::move(list), mgl::vec2f(parent_page->get_inner_size().x, 0.0f));
+
+        list_ptr->add_widget(create_notification_speed());
+        list_ptr->add_widget(std::make_unique<LineSeparator>(LineSeparator::Orientation::HORIZONTAL, subsection->get_inner_size().x));
+
         const bool inside_flatpak = getenv("FLATPAK_ID") != NULL;
-        auto list = std::make_unique<List>(List::Orientation::HORIZONTAL);
-        list->add_widget(create_exit_program_button());
+        auto navigate_list = std::make_unique<List>(List::Orientation::HORIZONTAL);
+        navigate_list->add_widget(create_exit_program_button());
         if(inside_flatpak)
-            list->add_widget(create_go_back_to_old_ui_button());
-        return std::make_unique<Subsection>("Application options", std::move(list), mgl::vec2f(parent_page->get_inner_size().x, 0.0f));
+            navigate_list->add_widget(create_go_back_to_old_ui_button());
+        list_ptr->add_widget(std::move(navigate_list));
+
+        return subsection;
     }
 
     std::unique_ptr<Subsection> GlobalSettingsPage::create_application_info_subsection(ScrollablePage *parent_page) {
@@ -448,6 +529,22 @@ namespace gsr {
         return std::make_unique<Subsection>("Application info", std::move(list), mgl::vec2f(parent_page->get_inner_size().x, 0.0f));
     }
 
+    std::unique_ptr<Subsection> GlobalSettingsPage::create_donate_subsection(ScrollablePage *parent_page) {
+        auto list = std::make_unique<List>(List::Orientation::VERTICAL);
+        list->add_widget(std::make_unique<Label>(&get_theme().body_font, "If you would like to donate you can do so by donating at https://buymeacoffee.com/dec05eba:", get_color_theme().text_color));
+
+        auto donate_button = std::make_unique<Button>(&get_theme().body_font, "Donate", mgl::vec2f(0.0f, 0.0f), mgl::Color(0, 0, 0, 120));
+        donate_button->on_click = [this] {
+            const char *args[] = { "xdg-open", "https://buymeacoffee.com/dec05eba", nullptr };
+            exec_program_daemonized(args);
+            overlay->hide_next_frame();
+        };
+        list->add_widget(std::move(donate_button));
+
+        list->add_widget(std::make_unique<Label>(&get_theme().body_font, "All donations go toward developing software (including GPU Screen Recorder)\nand buying hardware to test the software.", get_color_theme().text_color));
+        return std::make_unique<Subsection>("Donate", std::move(list), mgl::vec2f(parent_page->get_inner_size().x, 0.0f));
+    }
+
     void GlobalSettingsPage::add_widgets() {
         auto scrollable_page = std::make_unique<ScrollablePage>(content_page_ptr->get_inner_size());
 
@@ -459,6 +556,7 @@ namespace gsr {
         settings_list->add_widget(create_controller_hotkey_subsection(scrollable_page.get()));
         settings_list->add_widget(create_application_options_subsection(scrollable_page.get()));
         settings_list->add_widget(create_application_info_subsection(scrollable_page.get()));
+        settings_list->add_widget(create_donate_subsection(scrollable_page.get()));
         scrollable_page->add_widget(std::move(settings_list));
 
         content_page_ptr->add_widget(std::move(scrollable_page));
@@ -484,12 +582,16 @@ namespace gsr {
         enable_keyboard_hotkeys_radio_button_ptr->set_selected_item(config.main_config.hotkeys_enable_option, false, false);
         enable_joystick_hotkeys_radio_button_ptr->set_selected_item(config.main_config.joystick_hotkeys_enable_option, false, false);
 
+        notification_speed_button_ptr->set_selected_item(config.main_config.notification_speed);
+
         load_hotkeys();
     }
 
     void GlobalSettingsPage::load_hotkeys() {
         turn_replay_on_off_button_ptr->set_text(config.replay_config.start_stop_hotkey.to_string());
         save_replay_button_ptr->set_text(config.replay_config.save_hotkey.to_string());
+        save_replay_1_min_button_ptr->set_text(config.replay_config.save_1_min_hotkey.to_string());
+        save_replay_10_min_button_ptr->set_text(config.replay_config.save_10_min_hotkey.to_string());
 
         start_stop_recording_button_ptr->set_text(config.record_config.start_stop_hotkey.to_string());
         pause_unpause_recording_button_ptr->set_text(config.record_config.pause_unpause_hotkey.to_string());
@@ -498,6 +600,7 @@ namespace gsr {
 
         take_screenshot_button_ptr->set_text(config.screenshot_config.take_screenshot_hotkey.to_string());
         take_screenshot_region_button_ptr->set_text(config.screenshot_config.take_screenshot_region_hotkey.to_string());
+        take_screenshot_window_button_ptr->set_text(config.screenshot_config.take_screenshot_window_hotkey.to_string());
 
         show_hide_button_ptr->set_text(config.main_config.show_hide_hotkey.to_string());
     }
@@ -507,6 +610,7 @@ namespace gsr {
         config.main_config.tint_color = tint_color_radio_button_ptr->get_selected_id();
         config.main_config.hotkeys_enable_option = enable_keyboard_hotkeys_radio_button_ptr->get_selected_id();
         config.main_config.joystick_hotkeys_enable_option = enable_joystick_hotkeys_radio_button_ptr->get_selected_id();
+        config.main_config.notification_speed = notification_speed_button_ptr->get_selected_id();
         save_config(config);
     }
 
@@ -567,6 +671,10 @@ namespace gsr {
                 return turn_replay_on_off_button_ptr;
             case ConfigureHotkeyType::REPLAY_SAVE:
                 return save_replay_button_ptr;
+            case ConfigureHotkeyType::REPLAY_SAVE_1_MIN:
+                return save_replay_1_min_button_ptr;
+            case ConfigureHotkeyType::REPLAY_SAVE_10_MIN:
+                return save_replay_10_min_button_ptr;
             case ConfigureHotkeyType::RECORD_START_STOP:
                 return start_stop_recording_button_ptr;
             case ConfigureHotkeyType::RECORD_PAUSE_UNPAUSE:
@@ -577,6 +685,8 @@ namespace gsr {
                 return take_screenshot_button_ptr;
             case ConfigureHotkeyType::TAKE_SCREENSHOT_REGION:
                 return take_screenshot_region_button_ptr;
+            case ConfigureHotkeyType::TAKE_SCREENSHOT_WINDOW:
+                return take_screenshot_window_button_ptr;
             case ConfigureHotkeyType::SHOW_HIDE:
                 return show_hide_button_ptr;
         }
@@ -591,6 +701,10 @@ namespace gsr {
                 return &config.replay_config.start_stop_hotkey;
             case ConfigureHotkeyType::REPLAY_SAVE:
                 return &config.replay_config.save_hotkey;
+            case ConfigureHotkeyType::REPLAY_SAVE_1_MIN:
+                return &config.replay_config.save_1_min_hotkey;
+            case ConfigureHotkeyType::REPLAY_SAVE_10_MIN:
+                return &config.replay_config.save_10_min_hotkey;
             case ConfigureHotkeyType::RECORD_START_STOP:
                 return &config.record_config.start_stop_hotkey;
             case ConfigureHotkeyType::RECORD_PAUSE_UNPAUSE:
@@ -601,6 +715,8 @@ namespace gsr {
                 return &config.screenshot_config.take_screenshot_hotkey;
             case ConfigureHotkeyType::TAKE_SCREENSHOT_REGION:
                 return &config.screenshot_config.take_screenshot_region_hotkey;
+            case ConfigureHotkeyType::TAKE_SCREENSHOT_WINDOW:
+                return &config.screenshot_config.take_screenshot_window_hotkey;
             case ConfigureHotkeyType::SHOW_HIDE:
                 return &config.main_config.show_hide_hotkey;
         }
@@ -616,6 +732,7 @@ namespace gsr {
             &config.streaming_config.start_stop_hotkey,
             &config.screenshot_config.take_screenshot_hotkey,
             &config.screenshot_config.take_screenshot_region_hotkey,
+            &config.screenshot_config.take_screenshot_window_hotkey,
             &config.main_config.show_hide_hotkey
         };
         for(ConfigHotkey *config_hotkey : config_hotkeys) {
@@ -643,6 +760,12 @@ namespace gsr {
             case ConfigureHotkeyType::REPLAY_SAVE:
                 hotkey_configure_action_name = "Save replay";
                 break;
+            case ConfigureHotkeyType::REPLAY_SAVE_1_MIN:
+                hotkey_configure_action_name = "Save 1 minute replay";
+                break;
+            case ConfigureHotkeyType::REPLAY_SAVE_10_MIN:
+                hotkey_configure_action_name = "Save 10 minute replay";
+                break;
             case ConfigureHotkeyType::RECORD_START_STOP:
                 hotkey_configure_action_name = "Start/stop recording";
                 break;
@@ -658,6 +781,13 @@ namespace gsr {
             case ConfigureHotkeyType::TAKE_SCREENSHOT_REGION:
                 hotkey_configure_action_name = "Take a screenshot of a region";
                 break;
+            case ConfigureHotkeyType::TAKE_SCREENSHOT_WINDOW: {
+                if(gsr_info->system_info.display_server == DisplayServer::X11)
+                    hotkey_configure_action_name = "Take a screenshot of a window";
+                else
+                    hotkey_configure_action_name = "Take a screenshot with desktop portal";
+                break;
+            }
             case ConfigureHotkeyType::SHOW_HIDE:
                 hotkey_configure_action_name = "Show/hide UI";
                 break;

src/gui/GsrPage.cpp

@@ -39,8 +39,9 @@ namespace gsr {
 
         // Process widgets by visibility (backwards)
         return widgets.for_each_reverse([selected_widget, &window, &event, content_page_position](std::unique_ptr<Widget> &widget) {
-            if(widget.get() != selected_widget) {
-                if(!widget->on_event(event, window, content_page_position))
+            Widget *p = widget.get();
+            if(p != selected_widget) {
+                if(!p->on_event(event, window, content_page_position))
                     return false;
             }
             return true;

src/gui/List.cpp

@@ -24,14 +24,23 @@ namespace gsr {
         // Process widgets by visibility (backwards)
         return widgets.for_each_reverse([selected_widget, &event, &window](std::unique_ptr<Widget> &widget) {
             // Ignore offset because widgets are positioned with offset in ::draw, this solution is simpler
-            if(widget.get() != selected_widget) {
-                if(!widget->on_event(event, window, mgl::vec2f(0.0f, 0.0f)))
+            Widget *p = widget.get();
+            if(p != selected_widget) {
+                if(!p->on_event(event, window, mgl::vec2f(0.0f, 0.0f)))
                     return false;
             }
             return true;
         });
     }
 
+    List::~List() {
+        widgets.for_each([this](std::unique_ptr<Widget> &widget) {
+            if(widget->parent_widget == this)
+                widget->parent_widget = nullptr;
+            return true;
+        }, true);
+    }
+
     void List::draw(mgl::Window &window, mgl::vec2f offset) {
         if(!visible)
             return;
@@ -104,15 +113,6 @@ namespace gsr {
             selected_widget->draw(window, mgl::vec2f(0.0f, 0.0f));
     }
 
-    // void List::remove_child_widget(Widget *widget) {
-    //     for(auto it = widgets.begin(), end = widgets.end(); it != end; ++it) {
-    //         if(it->get() == widget) {
-    //             widgets.erase(it);
-    //             return;
-    //         }
-    //     }
-    // }
-
     void List::add_widget(std::unique_ptr<Widget> widget) {
         widget->parent_widget = this;
         widgets.push_back(std::move(widget));
@@ -122,6 +122,10 @@ namespace gsr {
         widgets.remove(widget);
     }
 
+    void List::replace_widget(Widget *widget, std::unique_ptr<Widget> new_widget) {
+        widgets.replace_item(widget, std::move(new_widget));
+    }
+
     void List::clear() {
         widgets.clear();
     }
@@ -137,6 +141,10 @@ namespace gsr {
             return nullptr;
     }
 
+    size_t List::get_num_children() const {
+        return widgets.size();
+    }
+
     void List::set_spacing(float spacing) {
         spacing_scale = spacing;
     }

src/gui/Page.cpp

@@ -1,14 +1,13 @@
 #include "../../include/gui/Page.hpp"
 
 namespace gsr {
-    // void Page::remove_child_widget(Widget *widget) {
-    //     for(auto it = widgets.begin(), end = widgets.end(); it != end; ++it) {
-    //         if(it->get() == widget) {
-    //             widgets.erase(it);
-    //             return;
-    //         }
-    //     }
-    // }
+    Page::~Page() {
+        widgets.for_each([this](std::unique_ptr<Widget> &widget) {
+            if(widget->parent_widget == this)
+                widget->parent_widget = nullptr;
+            return true;
+        }, true);
+    }
 
     void Page::add_widget(std::unique_ptr<Widget> widget) {
         widget->parent_widget = this;

src/gui/RadioButton.cpp

@@ -169,7 +169,7 @@ namespace gsr {
         }
     }
 
-    const std::string RadioButton::get_selected_id() const {
+    const std::string& RadioButton::get_selected_id() const {
         if(items.empty()) {
             static std::string dummy;
             return dummy;
@@ -177,4 +177,13 @@ namespace gsr {
             return items[selected_item].id;
         }
     }
+
+    const std::string& RadioButton::get_selected_text() const {
+        if(items.empty()) {
+            static std::string dummy;
+            return dummy;
+        } else {
+            return items[selected_item].text.get_string();
+        }
+    }
 }

src/gui/ScreenshotSettingsPage.cpp

@@ -35,13 +35,12 @@ namespace gsr {
     std::unique_ptr<ComboBox> ScreenshotSettingsPage::create_record_area_box() {
         auto record_area_box = std::make_unique<ComboBox>(&get_theme().body_font);
         // TODO: Show options not supported but disable them
-        // TODO: Enable this
-        //if(capture_options.window)
-        //    record_area_box->add_item("Window", "window");
+        if(capture_options.window)
+            record_area_box->add_item("Window", "window");
         if(capture_options.region)
             record_area_box->add_item("Region", "region");
         if(!capture_options.monitors.empty())
-            record_area_box->add_item(gsr_info->system_info.display_server == DisplayServer::WAYLAND ? "Focused monitor (Experimental on Wayland)" : "Focused monitor", "focused_monitor");
+            record_area_box->add_item("Focused monitor", "focused_monitor");
         for(const auto &monitor : capture_options.monitors) {
             char name[256];
             snprintf(name, sizeof(name), "Monitor %s (%dx%d)", monitor.name.c_str(), monitor.size.x, monitor.size.y);
@@ -60,14 +59,6 @@ namespace gsr {
         return record_area_list;
     }
 
-    std::unique_ptr<List> ScreenshotSettingsPage::create_select_window() {
-        auto select_window_list = std::make_unique<List>(List::Orientation::VERTICAL);
-        select_window_list->add_widget(std::make_unique<Label>(&get_theme().body_font, "Select window:", get_color_theme().text_color));
-        select_window_list->add_widget(std::make_unique<Button>(&get_theme().body_font, "Click here to select a window...", mgl::vec2f(0.0f, 0.0f), mgl::Color(0, 0, 0, 120)));
-        select_window_list_ptr = select_window_list.get();
-        return select_window_list;
-    }
-
     std::unique_ptr<Entry> ScreenshotSettingsPage::create_image_width_entry() {
         auto image_width_entry = std::make_unique<Entry>(&get_theme().body_font, "1920", get_theme().body_font.get_character_size() * 3);
         image_width_entry->validate_handler = create_entry_validator_integer_in_range(1, 1 << 15);
@@ -124,13 +115,12 @@ namespace gsr {
 
         auto capture_target_list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER);
         capture_target_list->add_widget(create_record_area());
-        capture_target_list->add_widget(create_select_window());
         capture_target_list->add_widget(create_image_resolution_section());
         capture_target_list->add_widget(create_restore_portal_session_section());
 
         ll->add_widget(std::move(capture_target_list));
         ll->add_widget(create_change_image_resolution_section());
-        return std::make_unique<Subsection>("Record area", std::move(ll), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f));
+        return std::make_unique<Subsection>("Capture", std::move(ll), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f));
     }
 
     std::unique_ptr<List> ScreenshotSettingsPage::create_image_quality_section() {
@@ -225,15 +215,38 @@ namespace gsr {
         return checkbox;
     }
 
-    std::unique_ptr<Widget> ScreenshotSettingsPage::create_general_section() {
-        return std::make_unique<Subsection>("General", create_save_screenshot_in_game_folder(), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f));
+    std::unique_ptr<CheckBox> ScreenshotSettingsPage::create_save_screenshot_to_clipboard() {
+        auto checkbox = std::make_unique<CheckBox>(&get_theme().body_font, gsr_info->system_info.display_server == DisplayServer::X11 ? "Save screenshot to clipboard" : "Save screenshot to clipboard (Not supported properly by Wayland)");
+        save_screenshot_to_clipboard_checkbox_ptr = checkbox.get();
+        return checkbox;
     }
 
-    std::unique_ptr<Widget> ScreenshotSettingsPage::create_notifications_section() {
-        auto show_screenshot_saved_notification_checkbox = std::make_unique<CheckBox>(&get_theme().body_font, "Show screenshot saved notification");
-        show_screenshot_saved_notification_checkbox->set_checked(true);
-        show_screenshot_saved_notification_checkbox_ptr = show_screenshot_saved_notification_checkbox.get();
-        return std::make_unique<Subsection>("Notifications", std::move(show_screenshot_saved_notification_checkbox), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f));
+    std::unique_ptr<Widget> ScreenshotSettingsPage::create_notifications() {
+        auto checkbox = std::make_unique<CheckBox>(&get_theme().body_font, "Show screenshot notifications");
+        checkbox->set_checked(true);
+        show_notification_checkbox_ptr = checkbox.get();
+        return checkbox;
+    }
+
+    std::unique_ptr<Widget> ScreenshotSettingsPage::create_led_indicator() {
+        auto checkbox = std::make_unique<CheckBox>(&get_theme().body_font, "Blink scroll lock led when taking a screenshot");
+        checkbox->set_checked(true);
+        led_indicator_checkbox_ptr = checkbox.get();
+        return checkbox;
+    }
+
+    std::unique_ptr<Widget> ScreenshotSettingsPage::create_general_section() {
+        auto list = std::make_unique<List>(List::Orientation::VERTICAL);
+        list->add_widget(create_save_screenshot_in_game_folder());
+        list->add_widget(create_save_screenshot_to_clipboard());
+        return std::make_unique<Subsection>("General", std::move(list), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f));
+    }
+
+    std::unique_ptr<Widget> ScreenshotSettingsPage::create_screenshot_indicator_section() {
+        auto list = std::make_unique<List>(List::Orientation::VERTICAL);
+        list->add_widget(create_notifications());
+        list->add_widget(create_led_indicator());
+        return std::make_unique<Subsection>("Screenshot indicator", std::move(list), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f));
     }
 
     std::unique_ptr<Widget> ScreenshotSettingsPage::create_settings() {
@@ -249,7 +262,7 @@ namespace gsr {
         settings_list->add_widget(create_image_section());
         settings_list->add_widget(create_file_info_section());
         settings_list->add_widget(create_general_section());
-        settings_list->add_widget(create_notifications_section());
+        settings_list->add_widget(create_screenshot_indicator_section());
         settings_scrollable_page_ptr->add_widget(std::move(settings_list));
         return page_list;
     }
@@ -257,11 +270,8 @@ namespace gsr {
     void ScreenshotSettingsPage::add_widgets() {
         content_page_ptr->add_widget(create_settings());
 
-        record_area_box_ptr->on_selection_changed = [this](const std::string &text, const std::string &id) {
-            (void)text;
-            const bool window_selected = id == "window";
+        record_area_box_ptr->on_selection_changed = [this](const std::string&, const std::string &id) {
             const bool portal_selected = id == "portal";
-            select_window_list_ptr->set_visible(window_selected);
             image_resolution_list_ptr->set_visible(change_image_resolution_checkbox_ptr->is_checked());
             restore_portal_session_list_ptr->set_visible(portal_selected);
             return true;
@@ -294,7 +304,9 @@ namespace gsr {
         restore_portal_session_checkbox_ptr->set_checked(config.screenshot_config.restore_portal_session);
         save_directory_button_ptr->set_text(config.screenshot_config.save_directory);
         save_screenshot_in_game_folder_checkbox_ptr->set_checked(config.screenshot_config.save_screenshot_in_game_folder);
-        show_screenshot_saved_notification_checkbox_ptr->set_checked(config.screenshot_config.show_screenshot_saved_notifications);
+        save_screenshot_to_clipboard_checkbox_ptr->set_checked(config.screenshot_config.save_screenshot_to_clipboard);
+        show_notification_checkbox_ptr->set_checked(config.screenshot_config.show_notifications);
+        led_indicator_checkbox_ptr->set_checked(config.screenshot_config.use_led_indicator);
 
         if(config.screenshot_config.image_width == 0)
             config.screenshot_config.image_width = 1920;
@@ -322,7 +334,9 @@ namespace gsr {
         config.screenshot_config.restore_portal_session = restore_portal_session_checkbox_ptr->is_checked();
         config.screenshot_config.save_directory = save_directory_button_ptr->get_text();
         config.screenshot_config.save_screenshot_in_game_folder = save_screenshot_in_game_folder_checkbox_ptr->is_checked();
-        config.screenshot_config.show_screenshot_saved_notifications = show_screenshot_saved_notification_checkbox_ptr->is_checked();
+        config.screenshot_config.save_screenshot_to_clipboard = save_screenshot_to_clipboard_checkbox_ptr->is_checked();
+        config.screenshot_config.show_notifications = show_notification_checkbox_ptr->is_checked();
+        config.screenshot_config.use_led_indicator = led_indicator_checkbox_ptr->is_checked();
 
         if(config.screenshot_config.image_width == 0)
             config.screenshot_config.image_width = 1920;

src/gui/ScrollablePage.cpp

@@ -15,6 +15,14 @@ namespace gsr {
 
     ScrollablePage::ScrollablePage(mgl::vec2f size) : size(size) {}
 
+    ScrollablePage::~ScrollablePage() {
+        widgets.for_each([this](std::unique_ptr<Widget> &widget) {
+            if(widget->parent_widget == this)
+                widget->parent_widget = nullptr;
+            return true;
+        }, true);
+    }
+
     bool ScrollablePage::on_event(mgl::Event &event, mgl::Window &window, mgl::vec2f offset) {
         if(!visible)
             return true;
@@ -57,8 +65,9 @@ namespace gsr {
 
         // Process widgets by visibility (backwards)
         const bool continue_events = widgets.for_each_reverse([selected_widget, &window, &event, offset](std::unique_ptr<Widget> &widget) {
-            if(widget.get() != selected_widget) {
-                if(!widget->on_event(event, window, offset))
+            Widget *p = widget.get();
+            if(p != selected_widget) {
+                if(!p->on_event(event, window, offset))
                     return false;
             }
             return true;

src/gui/StaticPage.cpp

@@ -20,8 +20,9 @@ namespace gsr {
 
         // Process widgets by visibility (backwards)
         return widgets.for_each_reverse([selected_widget, &window, &event, offset](std::unique_ptr<Widget> &widget) {
-            if(widget.get() != selected_widget) {
-                if(!widget->on_event(event, window, offset))
+            Widget *p = widget.get();
+            if(p != selected_widget) {
+                if(!p->on_event(event, window, offset))
                     return false;
             }
             return true;

src/gui/Subsection.cpp

@@ -12,12 +12,17 @@ namespace gsr {
     static const float title_spacing_scale = 0.010f;
 
     Subsection::Subsection(const char *title, std::unique_ptr<Widget> inner_widget, mgl::vec2f size) :
-        label(&get_theme().title_font, title, get_color_theme().text_color),
+        label(&get_theme().title_font, title ? title : "", get_color_theme().text_color),
         inner_widget(std::move(inner_widget)),
         size(size)
     {
         this->inner_widget->parent_widget = this;
     }
+
+    Subsection::~Subsection() {
+        if(inner_widget->parent_widget == this)
+            inner_widget->parent_widget = nullptr;
+    }
     
     bool Subsection::on_event(mgl::Event &event, mgl::Window &window, mgl::vec2f) {
         if(!visible)
@@ -32,7 +37,7 @@ namespace gsr {
 
         mgl::vec2f draw_pos = position + offset;
         mgl::Rectangle background(draw_pos.floor(), get_size().floor());
-        background.set_color(mgl::Color(25, 30, 34));
+        background.set_color(bg_color);
         window.draw(background);
 
         draw_pos += mgl::vec2f(margin_left_scale, margin_top_scale) * mgl::vec2f(get_theme().window_height, get_theme().window_height);
@@ -69,4 +74,12 @@ namespace gsr {
         const mgl::vec2f margin_size = mgl::vec2f(margin_left_scale + margin_right_scale, margin_top_scale + margin_bottom_scale) * mgl::vec2f(get_theme().window_height, get_theme().window_height);
         return get_size() - margin_size;
     }
+
+    Widget* Subsection::get_inner_widget() {
+        return inner_widget.get();
+    }
+
+    void Subsection::set_bg_color(mgl::Color color) {
+        bg_color = color;
+    }
 }

src/gui/Utils.cpp

@@ -5,6 +5,18 @@
 namespace gsr {
     static double frame_delta_seconds = 1.0;
 
+    static mgl::vec2i min_vec2i(mgl::vec2i a, mgl::vec2i b) {
+        return { std::min(a.x, b.x), std::min(a.y, b.y) };
+    }
+
+    static mgl::vec2i max_vec2i(mgl::vec2i a, mgl::vec2i b) {
+        return { std::max(a.x, b.x), std::max(a.y, b.y) };
+    }
+
+    static mgl::vec2i clamp_vec2i(mgl::vec2i value, mgl::vec2i min, mgl::vec2i max) {
+        return min_vec2i(max, max_vec2i(value, min));
+    }
+
     // TODO: Use vertices to make it one draw call
     void draw_rectangle_outline(mgl::Window &window, mgl::vec2f pos, mgl::vec2f size, mgl::Color color, float border_size) {
         pos = pos.floor();
@@ -74,4 +86,12 @@ namespace gsr {
         else
             return from;
     }
+
+    mgl::Scissor scissor_get_sub_area(mgl::Scissor parent, mgl::Scissor child) {
+        const mgl::vec2i pos = clamp_vec2i(child.position, parent.position, parent.position + parent.size);
+        return mgl::Scissor{
+            pos,
+            min_vec2i(child.size, parent.position + parent.size - pos)
+        };
+    }
 }

src/gui/Widget.cpp

@@ -1,14 +1,15 @@
 #include "../../include/gui/Widget.hpp"
+#include <vector>
 
 namespace gsr {
+    static std::vector<std::unique_ptr<Widget>> widgets_to_remove;
+
     Widget::Widget() {
         
     }
 
     Widget::~Widget() {
         remove_widget_as_selected_in_parent();
-        // if(parent_widget)
-        //     parent_widget->remove_child_widget(this);
     }
 
     void Widget::set_position(mgl::vec2f position) {
@@ -62,4 +63,19 @@ namespace gsr {
     void Widget::set_visible(bool visible) {
         this->visible = visible;
     }
+
+    Widget* Widget::get_parent_widget() {
+        return parent_widget;
+    }
+
+    void add_widget_to_remove(std::unique_ptr<Widget> widget) {
+        widgets_to_remove.push_back(std::move(widget));
+    }
+
+    void remove_widgets_to_be_removed() {
+        for(size_t i = 0; i < widgets_to_remove.size(); ++i) {
+            widgets_to_remove[i].reset();
+        }
+        widgets_to_remove.clear();
+    }
 }

src/main.cpp

@@ -4,7 +4,6 @@
 #include "../include/Process.hpp"
 #include "../include/Rpc.hpp"
 
-#include <unistd.h>
 #include <signal.h>
 #include <string.h>
 #include <limits.h>
@@ -14,7 +13,6 @@
 #include <mglpp/system/Clock.hpp>
 
 // TODO: Make keyboard/controller controllable for steam deck (and other controllers).
-// TODO: Keep track of gpu screen recorder run by other programs to not allow recording at the same time, or something.
 // TODO: Add systray by using org.kde.StatusNotifierWatcher/etc dbus directly.
 // TODO: Make sure the overlay always stays on top. Test with starting the overlay and then opening youtube in fullscreen.
 //       This is done in Overlay::force_window_on_top, but it's not called right now. It cant be used because the overlay will be on top of
@@ -30,6 +28,10 @@ static void sigint_handler(int signal) {
     running = 0;
 }
 
+static void signal_ignore(int) {
+
+}
+
 static void disable_prime_run() {
     unsetenv("__NV_PRIME_RENDER_OFFLOAD");
     unsetenv("__NV_PRIME_RENDER_OFFLOAD_PROVIDER");
@@ -74,6 +76,16 @@ static void rpc_add_commands(gsr::Rpc *rpc, gsr::Overlay *overlay) {
         overlay->save_replay();
     });
 
+    rpc->add_handler("replay-save-1-min", [overlay](const std::string &name) {
+        fprintf(stderr, "rpc command executed: %s\n", name.c_str());
+        overlay->save_replay_1_min();
+    });
+
+    rpc->add_handler("replay-save-10-min", [overlay](const std::string &name) {
+        fprintf(stderr, "rpc command executed: %s\n", name.c_str());
+        overlay->save_replay_10_min();
+    });
+
     rpc->add_handler("take-screenshot", [overlay](const std::string &name) {
         fprintf(stderr, "rpc command executed: %s\n", name.c_str());
         overlay->take_screenshot();
@@ -83,24 +95,11 @@ static void rpc_add_commands(gsr::Rpc *rpc, gsr::Overlay *overlay) {
         fprintf(stderr, "rpc command executed: %s\n", name.c_str());
         overlay->take_screenshot_region();
     });
-}
 
-static bool is_gsr_ui_virtual_keyboard_running() {
-    FILE *f = fopen("/proc/bus/input/devices", "rb");
-    if(!f)
-        return false;
-
-    bool virtual_keyboard_running = false;
-    char line[1024];
-    while(fgets(line, sizeof(line), f)) {
-        if(strstr(line, "gsr-ui virtual keyboard")) {
-            virtual_keyboard_running = true;
-            break;
-        }
-    }
-
-    fclose(f);
-    return virtual_keyboard_running;
+    rpc->add_handler("take-screenshot-window", [overlay](const std::string &name) {
+        fprintf(stderr, "rpc command executed: %s\n", name.c_str());
+        overlay->take_screenshot_window();
+    });
 }
 
 static void install_flatpak_systemd_service() {
@@ -145,23 +144,42 @@ static bool is_flatpak() {
     return getenv("FLATPAK_ID") != nullptr;
 }
 
+static void set_display_server_environment_variables() {
+    // Some users dont have properly setup environments (no display manager that does systemctl --user import-environment DISPLAY WAYLAND_DISPLAY)
+    const char *display = getenv("DISPLAY");
+    if(!display) {
+        display = ":0";
+        setenv("DISPLAY", display, true);
+    }
+
+    const char *wayland_display = getenv("WAYLAND_DISPLAY");
+    if(!wayland_display) {
+        wayland_display = "wayland-1";
+        setenv("WAYLAND_DISPLAY", wayland_display, true);
+    }
+}
+
 static void usage() {
     printf("usage: gsr-ui [action]\n");
     printf("OPTIONS:\n");
-    printf("  action  The launch action. Should be either \"launch-show\" or \"launch-hide\". Optional, defaults to \"launch-hide\".\n");
+    printf("  action  The launch action. Should be either \"launch-show\", \"launch-hide\" or \"launch-daemon\". Optional, defaults to \"launch-hide\".\n");
     printf("          If \"launch-show\" is used then the program starts and the UI is immediately opened and can be shown/hidden with Alt+Z.\n");
-    printf("          If \"launch-hide\" is used then the program starts but the UI is not opened until Alt+Z is pressed.\n");
+    printf("          If \"launch-hide\" is used then the program starts but the UI is not opened until Alt+Z is pressed. The UI will be opened if the program is already running in another process.\n");
+    printf("          If \"launch-daemon\" is used then the program starts but the UI is not opened until Alt+Z is pressed. The UI will not be opened if the program is already running in another process.\n");
     exit(1);
 }
 
 enum class LaunchAction {
     LAUNCH_SHOW,
-    LAUNCH_HIDE
+    LAUNCH_HIDE,
+    LAUNCH_DAEMON
 };
 
 int main(int argc, char **argv) {
     setlocale(LC_ALL, "C"); // Sigh... stupid C
+#ifdef __GLIBC__
     mallopt(M_MMAP_THRESHOLD, 65536);
+#endif
 
     if(geteuid() == 0) {
         fprintf(stderr, "Error: don't run gsr-ui as the root user\n");
@@ -177,27 +195,26 @@ int main(int argc, char **argv) {
             launch_action = LaunchAction::LAUNCH_SHOW;
         } else if(strcmp(launch_action_opt, "launch-hide") == 0) {
             launch_action = LaunchAction::LAUNCH_HIDE;
+        } else if(strcmp(launch_action_opt, "launch-daemon") == 0) {
+            launch_action = LaunchAction::LAUNCH_DAEMON;
         } else {
-            printf("error: invalid action \"%s\", expected \"launch-show\" or \"launch-hide\".\n", launch_action_opt);
+            printf("error: invalid action \"%s\", expected \"launch-show\", \"launch-hide\" or \"launch-daemon\".\n", launch_action_opt);
             usage();
         }
     } else {
         usage();
     }
 
-    if(is_flatpak())
-        install_flatpak_systemd_service();
-    else
-        remove_flatpak_systemd_service();
+    set_display_server_environment_variables();
 
-    // 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.
-    // 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.
-    // TODO: This doesn't work in flatpak when disabling hotkeys.
-    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)) {
+    auto rpc = std::make_unique<gsr::Rpc>();
+    const gsr::RpcOpenResult rpc_open_result = rpc->open("gsr-ui");
+
+    if(rpc_open_result == gsr::RpcOpenResult::OK) {
+        if(launch_action == LaunchAction::LAUNCH_DAEMON)
+            return 1;
+
+        if(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");
@@ -207,6 +224,24 @@ int main(int argc, char **argv) {
         return 1;
     }
 
+    if(!rpc->create("gsr-ui"))
+        fprintf(stderr, "Error: Failed to create rpc\n");
+
+    if(gsr::pidof("gpu-screen-recorder", -1) != -1) {
+        const char *args[] = { "gsr-notify", "--text", "GPU Screen Recorder is already running in another process.\nPlease close it before using GPU Screen Recorder UI.", "--timeout", "5.0", "--icon-color", "ff0000", "--bg-color", "ff0000", nullptr };
+        gsr::exec_program_daemonized(args);
+    }
+
+    if(mgl_init(MGL_WINDOW_SYSTEM_X11) != 0) {
+        fprintf(stderr, "Error: failed to initialize mgl. Failed to either connect to the X11 server or setup opengl\n");
+        return 1;
+    }
+
+    if(is_flatpak())
+        install_flatpak_systemd_service();
+    else
+        remove_flatpak_systemd_service();
+
     // Stop nvidia driver from buffering frames
     setenv("__GL_MaxFramesAllowed", "1", true);
     // If this is set to 1 then cuGraphicsGLRegisterImage will fail for egl context with error: invalid OpenGL or DirectX context,
@@ -218,6 +253,16 @@ int main(int argc, char **argv) {
     unsetenv("vblank_mode");
 
     signal(SIGINT, sigint_handler);
+    signal(SIGTERM, sigint_handler);
+    signal(SIGUSR1, signal_ignore);
+    signal(SIGUSR2, signal_ignore);
+    signal(SIGRTMIN, signal_ignore);
+    signal(SIGRTMIN+1, signal_ignore);
+    signal(SIGRTMIN+2, signal_ignore);
+    signal(SIGRTMIN+3, signal_ignore);
+    signal(SIGRTMIN+4, signal_ignore);
+    signal(SIGRTMIN+5, signal_ignore);
+    signal(SIGRTMIN+6, signal_ignore);
 
     gsr::GsrInfo gsr_info;
     // TODO: Show the error in ui
@@ -235,11 +280,6 @@ int main(int argc, char **argv) {
         disable_prime_run();
     }
 
-    if(mgl_init() != 0) {
-        fprintf(stderr, "Error: failed to initialize mgl. Failed to either connect to the X11 server or setup opengl\n");
-        exit(1);
-    }
-
     gsr::SupportedCaptureOptions capture_options = gsr::get_supported_capture_options(gsr_info);
 
     std::string resources_path;
@@ -272,10 +312,6 @@ int main(int argc, char **argv) {
     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());
 
     // 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.
@@ -303,10 +339,10 @@ int main(int argc, char **argv) {
     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;
+    } else if(exit_reason == "exit") {
+        return 0;
     }
 
-    return 0;
+    return mgl_is_connected_to_display_server() ? 0 : 1;
 }

tools/gsr-global-hotkeys/README.md

@@ -18,4 +18,15 @@ To unbind all keys send `unbind_all<newline>` to the programs stdin, for example
 ```
 unbind_all
 
-```
+```
+## Exit
+To close gsr-global-hotkeys send `exit<newline>` to the programs stdin, for example:
+```
+exit
+
+```
+# Conflict with other keyboard software
+Some keyboard remapping software such as keyd may conflict with gsr-global-hotkeys if configured incorrect (if it's configured to grab all devices, including gsr-ui virtual keyboard).
+If that happens it may grab gsr-ui-virtual keyboard while gsr-global-hotkeys will grab the keyboard remapping software virtual device, leading to a circular lock, making it not possible
+to use your keyboard. gsr-global-hotkeys detects this and outputs `gsr-ui-virtual-keyboard-grabbed` to stdout. You can listen to this and stop gsr-global-hotkeys or restart it with `--no-grab`
+option to only listen to devices, not grabbing them.

tools/gsr-global-hotkeys/keyboard_event.c

@@ -1,5 +1,6 @@
 #include "keyboard_event.h"
 #include "keys.h"
+#include "leds.h"
 
 /* C stdlib */
 #include <stdio.h>
@@ -7,6 +8,7 @@
 #include <errno.h>
 #include <stdbool.h>
 #include <stdlib.h>
+#include <time.h>
 
 /* POSIX */
 #include <fcntl.h>
@@ -17,6 +19,7 @@
 /* LINUX */
 #include <linux/input.h>
 #include <linux/uinput.h>
+#include <sys/timerfd.h>
 
 #define GSR_UI_VIRTUAL_KEYBOARD_NAME "gsr-ui virtual keyboard"
 
@@ -26,6 +29,14 @@
 
 #define KEY_STATES_SIZE (KEY_MAX/8 + 1)
 
+static double clock_get_monotonic_seconds(void) {
+    struct timespec ts;
+    ts.tv_sec = 0;
+    ts.tv_nsec = 0;
+    clock_gettime(CLOCK_MONOTONIC, &ts);
+    return (double)ts.tv_sec + (double)ts.tv_nsec * 0.000000001;
+}
+
 static inline int count_num_bits_set(unsigned char c) {
     int n = 0;
     n += (c & 1);
@@ -69,7 +80,7 @@ static void keyboard_event_fetch_update_key_states(keyboard_event *self, event_e
     if(ioctl(fd, EVIOCGKEY(KEY_STATES_SIZE), extra_data->key_states) == -1)
         fprintf(stderr, "Warning: failed to fetch key states for device: /dev/input/event%d\n", extra_data->dev_input_id);
 
-    if(!keyboard_event_has_exclusive_grab(self) || extra_data->grabbed)
+    if(!keyboard_event_has_exclusive_grab(self) || extra_data->grabbed || extra_data->is_non_keyboard_device)
         return;
 
     extra_data->num_keys_pressed = keyboard_event_get_num_keys_pressed(extra_data->key_states);
@@ -106,7 +117,7 @@ static void keyboard_event_process_key_state_change(keyboard_event *self, const
 
     extra_data->key_states[byte_index] = key_byte_state;
 
-    if(!keyboard_event_has_exclusive_grab(self) || extra_data->grabbed)
+    if(!keyboard_event_has_exclusive_grab(self) || extra_data->grabbed || extra_data->is_non_keyboard_device)
         return;
 
     if(extra_data->num_keys_pressed == 0) {
@@ -183,6 +194,12 @@ static void keyboard_event_process_input_event_data(keyboard_event *self, event_
         return;
     }
 
+    if(extra_data->gsr_ui_virtual_keyboard) {
+        if(event.type == EV_KEY || event.type == EV_MSC)
+            self->check_grab_lock = false;
+        return;
+    }
+
     if(event.type == EV_SYN && event.code == SYN_DROPPED) {
         /* TODO: Don't do this on every SYN_DROPPED to prevent spamming this, instead wait until the next event or wait for timeout */
         keyboard_event_fetch_update_key_states(self, extra_data, fd);
@@ -193,7 +210,8 @@ static void keyboard_event_process_input_event_data(keyboard_event *self, event_
         //fprintf(stderr, "fd: %d, type: %d, pressed %d, value: %d\n", fd, event.type, event.code, event.value);
     //}
 
-    if(event.type == EV_KEY && is_keyboard_key(event.code)) {
+    const bool keyboard_key = is_keyboard_key(event.code);
+    if(event.type == EV_KEY && keyboard_key) {
         keyboard_event_process_key_state_change(self, &event, extra_data, fd);
         const uint32_t modifier_bit = keycode_to_modifier_bit(event.code);
         if(modifier_bit == 0) {
@@ -210,23 +228,62 @@ static void keyboard_event_process_input_event_data(keyboard_event *self, event_
     }
 
     if(extra_data->grabbed) {
+        if(!self->check_grab_lock && (event.type == EV_KEY || event.type == EV_MSC)) {
+            self->uinput_written_time_seconds = clock_get_monotonic_seconds();
+            self->check_grab_lock = true;
+        }
+
         /* TODO: What to do on error? */
         if(write(self->uinput_fd, &event, sizeof(event)) != sizeof(event))
             fprintf(stderr, "Error: failed to write event data to virtual keyboard for exclusively grabbed device\n");
     }
+
+    if(event.type == EV_LED) {
+        write(fd, &event, sizeof(event));
+
+        const struct input_event syn_event = {
+            .type = EV_SYN,
+            .code = 0,
+            .value = 0
+        };
+        write(fd, &syn_event, sizeof(syn_event));
+    }
+
+    if(!extra_data->is_possibly_non_keyboard_device)
+        return;
+
+    /* TODO: What if some key is being pressed down while this is done? will it remain pressed down? */
+    if(!extra_data->is_non_keyboard_device && (event.type == EV_REL || event.type == EV_ABS || (event.type == EV_KEY && !keyboard_key))) {
+        fprintf(stderr, "Info: device /dev/input/event%d is likely a non-keyboard device as it received a non-keyboard event. This device will be ignored\n", extra_data->dev_input_id);
+        extra_data->is_non_keyboard_device = true;
+        if(extra_data->grabbed) {
+            extra_data->grabbed = false;
+            ioctl(fd, EVIOCGRAB, 0);
+            fprintf(stderr, "Info: ungrabbed device: /dev/input/event%d\n", extra_data->dev_input_id);
+        }
+    }
 }
 
 /* Retarded linux takes very long time to close /dev/input/eventN files, even though they are virtual and opened read-only */
 static void* keyboard_event_close_fds_callback(void *userdata) {
     keyboard_event *self = userdata;
+    int fds_to_close_now[MAX_CLOSE_FDS];
+    int num_fds_to_close_now = 0;
+
     while(self->running) {
         pthread_mutex_lock(&self->close_dev_input_mutex);
         for(int i = 0; i < self->num_close_fds; ++i) {
-            close(self->close_fds[i]);
+            fds_to_close_now[i] = self->close_fds[i];
         }
+        num_fds_to_close_now = self->num_close_fds;
         self->num_close_fds = 0;
         pthread_mutex_unlock(&self->close_dev_input_mutex);
 
+        for(int i = 0; i < num_fds_to_close_now; ++i) {
+            close(fds_to_close_now[i]);
+        }
+        num_fds_to_close_now = 0;
+
         usleep(100 * 1000); /* 100 milliseconds */
     }
     return NULL;
@@ -292,6 +349,46 @@ static bool dev_input_is_virtual(int dev_input_id) {
     return is_virtual;
 }
 
+static inline bool supports_key(unsigned char *key_bits, unsigned int key) {
+    return key_bits[key/8] & (1 << (key % 8));
+}
+
+static bool supports_keyboard_keys(unsigned char *key_bits) {
+    const int keys[2] = { KEY_A, KEY_ESC };
+    for(int i = 0; i < 2; ++i) {
+        if(supports_key(key_bits, keys[i]))
+            return true;
+    }
+    return false;
+}
+
+static bool supports_mouse_keys(unsigned char *key_bits) {
+    const int keys[2] = { BTN_MOUSE, BTN_LEFT };
+    for(int i = 0; i < 2; ++i) {
+        if(supports_key(key_bits, keys[i]))
+            return true;
+    }
+    return false;
+}
+
+static bool supports_joystick_keys(unsigned char *key_bits) {
+    const int keys[9] = { BTN_JOYSTICK, BTN_A, BTN_B, BTN_X, BTN_Y, BTN_SELECT, BTN_START, BTN_SELECT, BTN_TRIGGER_HAPPY1 };
+    for(int i = 0; i < 9; ++i) {
+        if(supports_key(key_bits, keys[i]))
+            return true;
+    }
+    return false;
+}
+
+static bool supports_wheel_keys(unsigned char *key_bits) {
+    const int keys[2] = { BTN_WHEEL, BTN_GEAR_DOWN };
+    for(int i = 0; i < 2; ++i) {
+        if(supports_key(key_bits, keys[i]))
+            return true;
+    }
+    return false;
+}
+
 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)
@@ -304,7 +401,7 @@ static bool keyboard_event_try_add_device_if_keyboard(keyboard_event *self, cons
     if(keyboard_event_has_event_with_dev_input_fd(self, dev_input_id))
         return false;
 
-    const int fd = open(dev_input_filepath, O_RDONLY);
+    const int fd = open(dev_input_filepath, O_RDWR);
     if(fd == -1)
         return false;
 
@@ -316,19 +413,37 @@ static bool keyboard_event_try_add_device_if_keyboard(keyboard_event *self, cons
     ioctl(fd, EVIOCGBIT(0, sizeof(evbit)), &evbit);
     const bool is_keyboard = (evbit & (1 << EV_SYN)) && (evbit & (1 << EV_KEY));
 
-    if(is_keyboard && strcmp(device_name, GSR_UI_VIRTUAL_KEYBOARD_NAME) != 0) {
+    if(strcmp(device_name, GSR_UI_VIRTUAL_KEYBOARD_NAME) == 0) {
+        if(self->num_event_polls < MAX_EVENT_POLLS) {
+            self->event_polls[self->num_event_polls] = (struct pollfd) {
+                .fd = fd,
+                .events = POLLIN,
+                .revents = 0
+            };
+
+            self->event_extra_data[self->num_event_polls] = (event_extra_data) {
+                .dev_input_id = dev_input_id,
+                .grabbed = false,
+                .key_states = NULL,
+                .key_presses_grabbed = NULL,
+                .num_keys_pressed = 0,
+                .gsr_ui_virtual_keyboard = true
+            };
+
+            ++self->num_event_polls;
+            return true;
+        } else {
+            fprintf(stderr, "Error: failed to listen to gsr-ui virtual keyboard\n");
+        }
+    } else if(is_keyboard) {
         unsigned char key_bits[KEY_MAX/8 + 1] = {0};
         ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(key_bits)), &key_bits);
 
-        const bool supports_key_a           = key_bits[KEY_A/8]        & (1 << (KEY_A % 8));
-        const bool supports_key_esc         = key_bits[KEY_ESC/8]      & (1 << (KEY_ESC % 8));
-        const bool supports_key_volume_up   = key_bits[KEY_VOLUMEUP/8] & (1 << (KEY_VOLUMEUP % 8));
-        const bool supports_key_events = supports_key_a || supports_key_esc || supports_key_volume_up;
+        const bool supports_key_events      = supports_keyboard_keys(key_bits);
+        const bool supports_mouse_events    = supports_mouse_keys(key_bits);
+        const bool supports_joystick_events = supports_joystick_keys(key_bits);
+        const bool supports_wheel_events    = supports_wheel_keys(key_bits);
 
-        const bool supports_mouse_events    = key_bits[BTN_MOUSE/8]    & (1 << (BTN_MOUSE % 8));
-        //const bool supports_touch_events    = key_bits[BTN_TOUCH/8]    & (1 << (BTN_TOUCH % 8));
-        const bool supports_joystick_events = key_bits[BTN_JOYSTICK/8] & (1 << (BTN_JOYSTICK % 8));
-        const bool supports_wheel_events    = key_bits[BTN_WHEEL/8]    & (1 << (BTN_WHEEL % 8));
         if(supports_key_events && (is_virtual_device || (!supports_joystick_events && !supports_wheel_events))) {
             unsigned char *key_states = calloc(1, KEY_STATES_SIZE);
             unsigned char *key_presses_grabbed = calloc(1, KEY_STATES_SIZE);
@@ -349,6 +464,7 @@ static bool keyboard_event_try_add_device_if_keyboard(keyboard_event *self, cons
                 };
 
                 if(supports_mouse_events || supports_joystick_events || supports_wheel_events) {
+                    self->event_extra_data[self->num_event_polls].is_possibly_non_keyboard_device = true;
                     fprintf(stderr, "Info: device not grabbed yet because it might be a mouse: /dev/input/event%d\n", dev_input_id);
                     fsync(fd);
                     if(ioctl(fd, EVIOCGKEY(KEY_STATES_SIZE), self->event_extra_data[self->num_event_polls].key_states) == -1)
@@ -404,8 +520,14 @@ static void keyboard_event_remove_event(keyboard_event *self, int index) {
     if(index < 0 || index >= self->num_event_polls)
         return;
 
-    ioctl(self->event_polls[index].fd, EVIOCGRAB, 0);
-    close(self->event_polls[index].fd);
+    const int poll_fd = self->event_polls[index].fd;
+    if(poll_fd > 0) {
+        ioctl(poll_fd, EVIOCGRAB, 0);
+        if(!keyboard_event_try_add_close_fd(self, poll_fd)) {
+            fprintf(stderr, "Error: failed to add immediately, closing now\n");
+            close(poll_fd);
+        }
+    }
     free(self->event_extra_data[index].key_states);
     free(self->event_extra_data[index].key_presses_grabbed);
 
@@ -435,19 +557,22 @@ static int setup_virtual_keyboard_input(const char *name) {
     success &= (ioctl(fd, UI_SET_EVBIT, EV_KEY) != -1);
     success &= (ioctl(fd, UI_SET_EVBIT, EV_REP) != -1);
     success &= (ioctl(fd, UI_SET_EVBIT, EV_REL) != -1);
-    success &= (ioctl(fd, UI_SET_EVBIT, EV_LED) != -1);
+    //success &= (ioctl(fd, UI_SET_EVBIT, EV_LED) != -1);
 
     success &= (ioctl(fd, UI_SET_MSCBIT, MSC_SCAN) != -1);
     for(int i = 1; i < KEY_MAX; ++i) {
+        // TODO: Check for joystick button? if we accidentally grab joystick
         if(is_keyboard_key(i) || is_mouse_button(i))
             success &= (ioctl(fd, UI_SET_KEYBIT, i) != -1);
     }
+
     for(int i = 0; i < REL_MAX; ++i) {
         success &= (ioctl(fd, UI_SET_RELBIT, i) != -1);
     }
-    for(int i = 0; i < LED_MAX; ++i) {
-        success &= (ioctl(fd, UI_SET_LEDBIT, i) != -1);
-    }
+
+    // for(int i = 0; i <= LED_CHARGING; ++i) {
+    //     success &= (ioctl(fd, UI_SET_LEDBIT, i) != -1);
+    // }
 
     // success &= (ioctl(fd, UI_SET_EVBIT, EV_ABS) != -1);
     // success &= (ioctl(fd, UI_SET_ABSBIT, ABS_X) != -1);
@@ -484,7 +609,6 @@ static int setup_virtual_keyboard_input(const char *name) {
 
 bool keyboard_event_init(keyboard_event *self, bool exclusive_grab, keyboard_grab_type grab_type) {
     memset(self, 0, sizeof(*self));
-    self->stdin_event_index = -1;
     self->hotplug_event_index = -1;
     self->grab_type = grab_type;
     self->running = true;
@@ -516,9 +640,51 @@ bool keyboard_event_init(keyboard_event *self, bool exclusive_grab, keyboard_gra
         .num_keys_pressed = 0
     };
 
-    self->stdin_event_index = self->num_event_polls;
     ++self->num_event_polls;
 
+    self->timer_fd = timerfd_create(CLOCK_MONOTONIC, 0);
+    if(self->timer_fd <= 0) {
+        fprintf(stderr, "Error: timerfd_create failed\n");
+        keyboard_event_deinit(self);
+        return false;
+    }
+
+    self->event_polls[self->num_event_polls] = (struct pollfd) {
+        .fd = self->timer_fd,
+        .events = POLLIN,
+        .revents = 0
+    };
+
+    self->event_extra_data[self->num_event_polls] = (event_extra_data) {
+        .dev_input_id = -1,
+        .grabbed = false,
+        .key_states = NULL,
+        .key_presses_grabbed = NULL,
+        .num_keys_pressed = 0
+    };
+
+    ++self->num_event_polls;
+
+    /* 0.5 seconds */
+    const struct itimerspec timer_value = {
+        .it_value = (struct timespec) {
+            .tv_sec = 0,
+            .tv_nsec = 500000000ULL,
+        },
+        .it_interval = (struct timespec) {
+            .tv_sec = 0,
+            .tv_nsec = 500000000ULL
+        }
+    };
+
+    if(timerfd_settime(self->timer_fd, 0, &timer_value, NULL) < 0) {
+        fprintf(stderr, "Error: timerfd_settime failed\n");
+        keyboard_event_deinit(self);
+        return false;
+    }
+
+    self->uinput_written_time_seconds = clock_get_monotonic_seconds();
+
     if(hotplug_event_init(&self->hotplug_ev)) {
         self->event_polls[self->num_event_polls] = (struct pollfd) {
             .fd = hotplug_event_steal_fd(&self->hotplug_ev),
@@ -551,6 +717,41 @@ bool keyboard_event_init(keyboard_event *self, bool exclusive_grab, keyboard_gra
     return true;
 }
 
+static void write_led_data_to_device(int fd, uint16_t led, int value) {
+    struct input_event led_data = {
+        .type = EV_LED,
+        .code = led,
+        .value = value
+    };
+    write(fd, &led_data, sizeof(led_data));
+
+    struct input_event syn_data = {
+        .type = EV_SYN,
+        .code = 0,
+        .value = 0
+    };
+    write(fd, &syn_data, sizeof(syn_data));
+}
+
+/* When the device is ungrabbed the leds are unset for some reason. Set them back to their previous brightness */
+static void keyboard_event_device_deinit(int fd, event_extra_data *extra_data) {
+    ggh_leds leds;
+    const bool got_leds = get_leds(extra_data->dev_input_id, &leds);
+
+    ioctl(fd, EVIOCGRAB, 0);
+    if(got_leds) {
+        if(leds.scroll_lock_brightness >= 0)
+            write_led_data_to_device(fd, LED_SCROLLL, leds.scroll_lock_brightness);
+
+        if(leds.num_lock_brightness >= 0)
+            write_led_data_to_device(fd, LED_NUML, leds.num_lock_brightness);
+
+        if(leds.caps_lock_brightness >= 0)
+            write_led_data_to_device(fd, LED_CAPSL, leds.caps_lock_brightness);
+    }
+    close(fd);
+}
+
 void keyboard_event_deinit(keyboard_event *self) {
     self->running = false;
 
@@ -566,8 +767,12 @@ void keyboard_event_deinit(keyboard_event *self) {
     }
 
     for(int i = 0; i < self->num_event_polls; ++i) {
-        ioctl(self->event_polls[i].fd, EVIOCGRAB, 0);
-        close(self->event_polls[i].fd);
+        if(self->event_polls[i].fd > 0) {
+            if(self->event_extra_data[i].dev_input_id > 0 && !self->event_extra_data[i].gsr_ui_virtual_keyboard)
+                keyboard_event_device_deinit(self->event_polls[i].fd, &self->event_extra_data[i]);
+            else
+                close(self->event_polls[i].fd);
+        }
         free(self->event_extra_data[i].key_states);
         free(self->event_extra_data[i].key_presses_grabbed);
     }
@@ -707,8 +912,11 @@ static void keyboard_event_parse_stdin_command(keyboard_event *self, const char
         }
         self->num_global_hotkeys = 0;
         fprintf(stderr, "Info: unbinded all hotkeys\n");
+    } else if(strncmp(command, "exit", 4) == 0) {
+        self->stdin_failed = true;
+        fprintf(stderr, "Info: received exit command\n");
     } else {
-        fprintf(stderr, "Warning: got invalid command: \"%s\", expected command to start with either \"bind\" or \"unbind_all\"\n", command);
+        fprintf(stderr, "Warning: got invalid command: \"%s\", expected command to start with either \"bind\", \"unbind_all\" or \"exit\"\n", command);
     }
 }
 
@@ -757,7 +965,7 @@ void keyboard_event_poll_events(keyboard_event *self, int timeout_milliseconds)
         return;
 
     for(int i = 0; i < self->num_event_polls; ++i) {
-        if(i == self->stdin_event_index && (self->event_polls[i].revents & (POLLHUP|POLLERR)))
+        if(self->event_polls[i].fd == STDIN_FILENO && (self->event_polls[i].revents & (POLLHUP|POLLERR)))
             self->stdin_failed = true;
 
         if(self->event_polls[i].revents & POLLHUP) { /* TODO: What if this is the hotplug fd? */
@@ -772,8 +980,17 @@ void keyboard_event_poll_events(keyboard_event *self, int timeout_milliseconds)
         if(i == self->hotplug_event_index) {
             /* Device is added to end of |event_polls| so it's ok to add while iterating it via index */
             hotplug_event_process_event_data(&self->hotplug_ev, self->event_polls[i].fd, on_device_added_callback, self);
-        } else if(i == self->stdin_event_index) {
+        } else if(self->event_polls[i].fd == STDIN_FILENO) {
             keyboard_event_process_stdin_command_data(self, self->event_polls[i].fd);
+        } else if(self->event_polls[i].fd == self->timer_fd) {
+            uint64_t timers_elapsed = 0;
+            read(self->timer_fd, &timers_elapsed, sizeof(timers_elapsed));
+
+            if(self->grab_type != KEYBOARD_GRAB_TYPE_NO_GRAB && self->check_grab_lock && clock_get_monotonic_seconds() - self->uinput_written_time_seconds >= 1.5) {
+                self->check_grab_lock = false;
+                puts("gsr-ui-virtual-keyboard-grabbed");
+                fflush(stdout);
+            }
         } else {
             keyboard_event_process_input_event_data(self, &self->event_extra_data[i], self->event_polls[i].fd);
         }

tools/gsr-global-hotkeys/keyboard_event.h

@@ -18,7 +18,7 @@
 
 #define MAX_EVENT_POLLS 32
 #define MAX_CLOSE_FDS 256
-#define MAX_GLOBAL_HOTKEYS 32
+#define MAX_GLOBAL_HOTKEYS 40
 
 typedef enum {
     KEYBOARD_MODKEY_LALT   = 1 << 0,
@@ -39,6 +39,9 @@ typedef enum {
 typedef struct {
     int dev_input_id;
     bool grabbed;
+    bool is_non_keyboard_device;
+    bool is_possibly_non_keyboard_device;
+    bool gsr_ui_virtual_keyboard;
     unsigned char *key_states;
     unsigned char *key_presses_grabbed;
     int num_keys_pressed;
@@ -46,7 +49,8 @@ typedef struct {
 
 typedef enum {
     KEYBOARD_GRAB_TYPE_ALL,
-    KEYBOARD_GRAB_TYPE_VIRTUAL
+    KEYBOARD_GRAB_TYPE_VIRTUAL,
+    KEYBOARD_GRAB_TYPE_NO_GRAB
 } keyboard_grab_type;
 
 typedef struct {
@@ -60,10 +64,12 @@ typedef struct {
     event_extra_data event_extra_data[MAX_EVENT_POLLS]; /* Current size is |num_event_polls| */
     int num_event_polls;
 
-    int stdin_event_index;
     int hotplug_event_index;
     int uinput_fd;
+    int timer_fd;
     bool stdin_failed;
+    bool check_grab_lock;
+    double uinput_written_time_seconds;
     keyboard_grab_type grab_type;
 
     pthread_t close_dev_input_fds_thread;

tools/gsr-global-hotkeys/leds.c

@@ -0,0 +1,181 @@
+#include "leds.h"
+
+/* C stdlib */
+#include <string.h>
+#include <stdio.h>
+#include <limits.h>
+#include <stddef.h>
+
+/* POSIX */
+#include <fcntl.h>
+#include <unistd.h>
+#include <dirent.h>
+#include <errno.h>
+
+/* LINUX */
+#include <linux/input.h>
+
+/* Returns -1 on error */
+static int read_int_from_file(const char *filepath) {
+    const int fd = open(filepath, O_RDONLY);
+    if(fd == -1) {
+        fprintf(stderr, "Warning: get_max_brightness open error: %s\n", strerror(errno));
+        return -1;
+    }
+
+    bool success = false;
+    int value = 0;
+    char buffer[32];
+    const ssize_t num_bytes_read = read(fd, buffer, sizeof(buffer));
+    if(num_bytes_read > 0) {
+        buffer[num_bytes_read] = '\0';
+        success = sscanf(buffer, "%d", &value) == 1;
+    }
+
+    close(fd);
+    return success ? value : -1;
+}
+
+static int get_max_brightness(const char *sys_class_path, const char *filename) {
+    char path[PATH_MAX];
+    snprintf(path, sizeof(path), "%s/%s/max_brightness", sys_class_path, filename);
+    return read_int_from_file(path);
+}
+
+static int get_brightness(const char *sys_class_path, const char *filename) {
+    char path[PATH_MAX];
+    snprintf(path, sizeof(path), "%s/%s/brightness", sys_class_path, filename);
+    return read_int_from_file(path);
+}
+
+static bool string_starts_with(const char *str, const char *sub) {
+    const int str_len = strlen(str);
+    const int sub_len = strlen(sub);
+    return str_len >= sub_len && memcmp(str, sub, sub_len) == 0;
+}
+
+static bool string_ends_with(const char *str, const char *sub) {
+    const int str_len = strlen(str);
+    const int sub_len = strlen(sub);
+    return str_len >= sub_len && memcmp(str + str_len - sub_len, sub, sub_len) == 0;
+}
+
+static int sys_class_led_path_get_event_number(const char *sys_class_path, const char *filename) {
+    char path[PATH_MAX];
+    snprintf(path, sizeof(path), "%s/%s/device", sys_class_path, filename);
+
+    DIR *dir = opendir(path);
+    if(!dir)
+        return -1;
+
+    int event_number = -1;
+    struct dirent *entry;
+    while((entry = readdir(dir)) != NULL) {
+        int v = -1;
+        if(sscanf(entry->d_name, "event%d", &v) == 1 && v >= 0) {
+            event_number = v;
+            break;
+        }
+    }
+
+    closedir(dir);
+    return event_number;
+}
+
+/*
+    We have to do this retardation instead of setting /sys/class/leds brightness since it doesn't work with /dev/uinput
+    and we cant loop all /dev/input devices and open and write to them either since closing a /dev/input is very slow on linux.
+    So we instead check which devices have the led before opening it.
+*/
+static bool set_device_leds(const char *led_name_path, bool enabled) {
+    DIR *dir = opendir("/sys/class/leds");
+    if(!dir)
+        return false;
+
+    char dev_input_filepath[1024];
+    struct dirent *entry;
+    while((entry = readdir(dir)) != NULL) {
+        if(entry->d_name[0] == '.')
+            continue;
+
+        if(!string_starts_with(entry->d_name, "input") || !string_ends_with(entry->d_name, led_name_path))
+            continue;
+
+        const int event_number = sys_class_led_path_get_event_number("/sys/class/leds", entry->d_name);
+        if(event_number == -1)
+            continue;
+
+        snprintf(dev_input_filepath, sizeof(dev_input_filepath), "/dev/input/event%d", event_number);
+        
+        const int device_fd = open(dev_input_filepath, O_WRONLY);
+        if(device_fd == -1)
+            continue;
+
+        int brightness = 0;
+        if(enabled) {
+            brightness = get_max_brightness("/sys/class/leds", entry->d_name);
+            if(brightness < 0)
+                brightness = 1;
+        }
+
+        struct input_event led_data = {
+            .type = EV_LED,
+            .code = LED_SCROLLL,
+            .value = brightness
+        };
+        write(device_fd, &led_data, sizeof(led_data));
+
+        struct input_event syn_data = {
+            .type = EV_SYN,
+            .code = 0,
+            .value = 0
+        };
+        write(device_fd, &syn_data, sizeof(syn_data));
+
+        close(device_fd);
+    }
+
+    closedir(dir);
+    return true;
+}
+
+bool set_leds(const char *led_name, bool enabled) {
+    if(strcmp(led_name, "Scroll Lock") == 0) {
+        return set_device_leds("::scrolllock", enabled);
+    } else {
+        fprintf(stderr, "Error: invalid led: \"%s\", expected \"Scroll Lock\"\n", led_name);
+        return false;
+    }
+}
+
+bool get_leds(int event_number, ggh_leds *leds) {
+    leds->scroll_lock_brightness = -1;
+    leds->num_lock_brightness = -1;
+    leds->caps_lock_brightness = -1;
+
+    char path[PATH_MAX];
+    snprintf(path, sizeof(path), "/sys/class/input/event%d/device", event_number);
+
+    DIR *dir = opendir(path);
+    if(!dir)
+        return false;
+
+    struct dirent *entry;
+    while((entry = readdir(dir)) != NULL) {
+        if(entry->d_name[0] == '.')
+            continue;
+
+        if(!string_starts_with(entry->d_name, "input"))
+            continue;
+
+        if(string_ends_with(entry->d_name, "::scrolllock"))
+            leds->scroll_lock_brightness = get_brightness(path, entry->d_name);
+        else if(string_ends_with(entry->d_name, "::numlock"))
+            leds->num_lock_brightness = get_brightness(path, entry->d_name);
+        else if(string_ends_with(entry->d_name, "::capslock"))
+            leds->caps_lock_brightness = get_brightness(path, entry->d_name);
+    }
+
+    closedir(dir);
+    return true;
+}

tools/gsr-global-hotkeys/leds.h

@@ -0,0 +1,17 @@
+#ifndef LEDS_H
+#define LEDS_H
+
+/* C stdlib */
+#include <stdbool.h>
+
+typedef struct {
+    /* These are set to -1 if not supported */
+    int scroll_lock_brightness;
+    int num_lock_brightness;
+    int caps_lock_brightness;
+} ggh_leds;
+
+bool set_leds(const char *led_name, bool enabled);
+bool get_leds(int event_number, ggh_leds *leds);
+
+#endif /* LEDS_H */

tools/gsr-global-hotkeys/main.c

@@ -1,18 +1,26 @@
 #include "keyboard_event.h"
+#include "leds.h"
 
 /* C stdlib */
 #include <stdio.h>
 #include <string.h>
 #include <locale.h>
+#include <stdbool.h>
 
 /* POSIX */
 #include <unistd.h>
 
 static void usage(void) {
-    fprintf(stderr, "usage: gsr-global-hotkeys [--all|--virtual]\n");
+    fprintf(stderr, "usage: gsr-global-hotkeys [--all|--virtual|--no-grab|--set-led] [Scroll Lock] [on|off]\n");
     fprintf(stderr, "OPTIONS:\n");
     fprintf(stderr, "  --all        Grab all devices.\n");
     fprintf(stderr, "  --virtual    Grab all virtual devices only.\n");
+    fprintf(stderr, "  --no-grab    Don't grab devices, only listen to them.\n");
+    fprintf(stderr, "  --set-led    Turn device led on/off.\n");
+    fprintf(stderr, "EXAMPLES:\n");
+    fprintf(stderr, "  gsr-global-hotkeys --all\n");
+    fprintf(stderr, "  gsr-global-hotkeys --set-led \"Scroll Lock\" on\n");
+    fprintf(stderr, "  gsr-global-hotkeys --set-led \"Scroll Lock\" off\n");
 }
 
 static bool is_gsr_global_hotkeys_already_running(void) {
@@ -37,49 +45,83 @@ int main(int argc, char **argv) {
     setlocale(LC_ALL, "C"); /* Sigh... stupid C */
 
     keyboard_grab_type grab_type = KEYBOARD_GRAB_TYPE_ALL;
+    const uid_t user_id = getuid();
+
     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 if(strcmp(grab_type_arg, "--no-grab") == 0) {
+            grab_type = KEYBOARD_GRAB_TYPE_NO_GRAB;
+        } else if(strcmp(grab_type_arg, "--set-led") == 0) {
+            fprintf(stderr, "Error: missing led name and on/off argument to --set-led\n");
+            usage();
+            return 1;
         } else {
-            fprintf(stderr, "Error: expected --all or --virtual, got %s\n", grab_type_arg);
+            fprintf(stderr, "gsr-global-hotkeys error: expected --all, --virtual, --no-grab or --set-led, got %s\n", grab_type_arg);
             usage();
             return 1;
         }
+    } else if(argc == 4) {
+        /* It's not ideal to use gsr-global-hotkeys for leds, but we do that for now because it's a mess to create another binary for flatpak and distros */
+        const char *led_name = argv[2];
+        const char *led_enabled_str = argv[3];
+        bool led_enabled = false;
+
+        if(strcmp(led_enabled_str, "on") == 0) {
+            led_enabled = true;
+        } else if(strcmp(led_enabled_str, "off") == 0) {
+            led_enabled = false;
+        } else {
+            fprintf(stderr, "Error: expected \"on\" or \"off\" for --set-led option, got: \"%s\"", led_enabled_str);
+            usage();
+            return 1;
+        }
+
+        if(geteuid() != 0) {
+            if(setuid(0) == -1) {
+                fprintf(stderr, "gsr-global-hotkeys error: failed to change user to root, global hotkeys will not work. Make sure to set the correct capability on gsr-global-hotkeys\n");
+                return 1;
+            }
+        }
+
+        const bool success = set_leds(led_name, led_enabled);
+        setuid(user_id);
+
+        return success ? 0 : 1;
     } else if(argc != 1) {
-        fprintf(stderr, "Error: expected 0 or 1 arguments, got %d argument(s)\n", argc);
+        fprintf(stderr, "gsr-global-hotkeys error: expected 0 or 1 arguments, got %d argument(s)\n", argc);
         usage();
         return 1;
     }
 
     if(is_gsr_global_hotkeys_already_running()) {
-        fprintf(stderr, "Error: gsr-global-hotkeys is already running\n");
+        fprintf(stderr, "gsr-global-hotkeys error: gsr-global-hotkeys is already running\n");
         return 1;
     }
 
-    const uid_t user_id = getuid();
     if(geteuid() != 0) {
         if(setuid(0) == -1) {
-            fprintf(stderr, "Error: failed to change user to root\n");
+            fprintf(stderr, "gsr-global-hotkeys error: failed to change user to root, global hotkeys will not work. Make sure to set the correct capability on gsr-global-hotkeys\n");
             return 1;
         }
     }
 
     keyboard_event keyboard_ev;
-    if(!keyboard_event_init(&keyboard_ev, true, grab_type)) {
-        fprintf(stderr, "Error: failed to setup hotplugging and no keyboard input devices were found\n");
+    if(!keyboard_event_init(&keyboard_ev, grab_type != KEYBOARD_GRAB_TYPE_NO_GRAB, grab_type)) {
+        fprintf(stderr, "gsr-global-hotkeys error: failed to setup hotplugging and no keyboard input devices were found\n");
         setuid(user_id);
         return 1;
     }
 
-    fprintf(stderr, "Info: global hotkeys setup, waiting for hotkeys to be pressed\n");
+    fprintf(stderr, "gsr-global-hotkeys info: global hotkeys setup, waiting for hotkeys to be pressed\n");
 
     for(;;) {
         keyboard_event_poll_events(&keyboard_ev, -1);
         if(keyboard_event_stdin_has_failed(&keyboard_ev)) {
-            fprintf(stderr, "Info: stdin closed (parent process likely closed this process), exiting...\n");
+            fprintf(stderr, "gsr-global-hotkeys info: stdin closed (parent process likely closed this process), exiting...\n");
             break;
         }
     }

tools/gsr-ui-cli/main.c

@@ -5,9 +5,11 @@
 #include <stdbool.h>
 #include <string.h>
 #include <unistd.h>
-#include <fcntl.h>
+#include <errno.h>
+#include <sys/socket.h>
+#include <sys/un.h>
 
-static void get_runtime_filepath(char *buffer, size_t buffer_size, const char *filename) {
+static void get_socket_filepath(char *buffer, size_t buffer_size, const char *filename) {
     char dir[PATH_MAX];
 
     const char *runtime_dir = getenv("XDG_RUNTIME_DIR");
@@ -23,7 +25,7 @@ static void get_runtime_filepath(char *buffer, size_t buffer_size, const char *f
 }
 
 /* Assumes |str| size is less than 256 */
-static void fifo_write_all(int file_fd, const char *str) {
+static void file_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)) {
@@ -33,7 +35,7 @@ static void fifo_write_all(int file_fd, const char *str) {
 
     ssize_t offset = 0;
     while(offset < (ssize_t)command_size) {
-        const ssize_t bytes_written = write(file_fd, str + offset, command_size - offset);
+        const ssize_t bytes_written = write(file_fd, command + offset, command_size - offset);
         if(bytes_written > 0)
             offset += bytes_written;
     }
@@ -56,10 +58,16 @@ static void usage(void) {
     printf("      Start/stop replay.\n");
     printf("  replay-save\n");
     printf("      Save replay.\n");
+    printf("  replay-save-1-min\n");
+    printf("      Save 1 minute replay.\n");
+    printf("  replay-save-10-min\n");
+    printf("      Save 10 minute replay.\n");
     printf("  take-screenshot\n");
     printf("      Take a screenshot.\n");
     printf("  take-screenshot-region\n");
     printf("      Take a screenshot of a region.\n");
+    printf("  take-screenshot-window\n");
+    printf("      Take a screenshot of a window (or desktop portal on Wayland).\n");
     printf("\n");
     printf("EXAMPLES:\n");
     printf("  gsr-ui-cli toggle-show\n");
@@ -75,8 +83,11 @@ static bool is_valid_command(const char *command) {
         "toggle-stream",
         "toggle-replay",
         "replay-save",
+        "replay-save-1-min",
+        "replay-save-10-min",
         "take-screenshot",
         "take-screenshot-region",
+        "take-screenshot-window",
         NULL
     };
 
@@ -103,15 +114,34 @@ int main(int argc, char **argv) {
         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);
+    char socket_filepath[PATH_MAX];
+    get_socket_filepath(socket_filepath, sizeof(socket_filepath), "gsr-ui");
+
+    const int socket_fd = socket(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK, 0);
+    if(socket_fd <= 0) {
+        fprintf(stderr, "Error: failed to create socket\n");
         exit(2);
     }
 
-    fifo_write_all(fifo_fd, command);
-    close(fifo_fd);
+    struct sockaddr_un addr = {0};
+    addr.sun_family = AF_UNIX;
+    snprintf(addr.sun_path, sizeof(addr.sun_path), "%s", socket_filepath);
+
+    for(;;) {
+        if(connect(socket_fd, (struct sockaddr*)&addr, sizeof(addr)) == -1) {
+            const int err = errno;
+            if(err == EWOULDBLOCK) {
+                usleep(10 * 1000);
+            } else {
+                fprintf(stderr, "Error: failed to connect, error: %s. Maybe gsr-ui is not running?\n", strerror(err));
+                exit(2);
+            }
+        } else {
+            break;
+        }
+    }
+
+    file_write_all(socket_fd, command);
+    close(socket_fd);
     return 0;
 }