1.6.3

This reverts commit 3060e3ee00.

.gitignore

@@ -2,5 +2,5 @@
 sibs-build/
 compile_commands.json
 
-gpu-screen-recorder-overlay-daemon/sibs-build/
-gpu-screen-recorder-overlay-daemon/compile_commands.json
+**/xdg-output-unstable-v1-client-protocol.h
+**/xdg-output-unstable-v1-protocol.c

README.md

@@ -5,15 +5,16 @@ A fullscreen overlay UI for [GPU Screen Recorder](https://git.dec05eba.com/gpu-s
 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
-Run `gsr-ui` and press `Left Alt+Z` to show/hide the UI. You can start the overlay UI at system startup by running `systemctl enable --now --user gpu-screen-recorder-ui`.
-There is also an option in the settings to enable/disable starting the program on system startup. This option only works on systems that use systemd.
-You have to manually add `gsr-ui` to system startup on systems that uses another init system.\
+You 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 (the gtk gui version) from [flathub](https://flathub.org/apps/details/com.dec05eba.gpu_screen_recorder). This flatpak includes both this UI and gpu-screen-recorder so no need to install that first.
+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.
 
 # Dependencies
 GPU Screen Recorder UI uses meson build system so you need to install `meson` to build GPU Screen Recorder UI.
@@ -21,11 +22,12 @@ 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, 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 (wayland-client, wayland-egl, wayland-scanner)
 
 ## Runtime dependencies
 There are also additional dependencies needed at runtime:
@@ -34,14 +36,21 @@ 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"
+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 keyboard remapping software. To workaround this you can go into settings and select "Only grab virtual 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 `Creative Commons Attribution-Share Alike 3.0`.
+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 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).
+See [https://git.dec05eba.com/?p=about](https://git.dec05eba.com/?p=about).\
+I'm looking for somebody that can create sound effects for the notifications.
 
 # Demo
 [![Click here to watch a demo video on youtube](https://img.youtube.com/vi/SOqXusCTXXA/0.jpg)](https://www.youtube.com/watch?v=SOqXusCTXXA)
@@ -56,4 +65,4 @@ See [https://git.dec05eba.com/?p=about](https://git.dec05eba.com/?p=about).
 
 # 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 non-flatpak version of the systemd service will conflict with that. Run `gsr-ui` to fix that.
+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.

TODO

@@ -14,8 +14,6 @@ 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.
@@ -105,18 +103,16 @@ When adding window capture only add it to recording and streaming and do the win
 
 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.
 
-Is it possible to configure hotkey and the new hotkey to get triggered immediately?
-
 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
     See if there is any way around this.
 
-Instead of installing gsr-global-hotkeys in flatpak use kms-server-proxy to launch gsr-global-hotkeys inside the flatpak with root, just like gsr-kms-server. This removes the need to update gsr-global-hotkeys everytime there is an update.
-
 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.
 
@@ -125,8 +121,6 @@ Maybe change gsr-ui startup retry time in the systemd service, from 5 seconds to
 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.
@@ -137,4 +131,57 @@ Make input work with cjk input systems (such as fcitx).
 
 System startup option should also support runit and some other init systems, not only soystemd.
 
-Allow using a hotkey such as printscreen or any other non-alphanumeric key without a modifier. Allow that in gsr-ui and gsr-global-hotkeys. Update the ui to match that.
+Use x11 shm instead of XGetImage (https://stackoverflow.com/questions/43442675/how-to-use-xshmgetimage-and-xshmputimage).
+
+Add a hotkey to record/stream/replay region.
+
+Do xi grab for keys as well. Otherwise the ui cant be used for keyboard input if a program has grabbed the keyboard, and there could possibly be a game that grabs the keyboard as well.
+
+Make inactive buttons gray (in dropdown boxes and in the front page with save, etc when replay is not running).
+
+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.
+
+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.

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

flatpak/gpu-screen-recorder-ui.service

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

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;
@@ -38,10 +46,11 @@ namespace gsr {
         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;
+        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";
@@ -108,8 +117,11 @@ namespace gsr {
         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 {
@@ -126,6 +138,7 @@ namespace gsr {
         bool show_screenshot_saved_notifications = true;
         std::string save_directory;
         ConfigHotkey take_screenshot_hotkey;
+        ConfigHotkey take_screenshot_region_hotkey;
     };
 
     struct Config {

include/CursorTracker/CursorTracker.hpp

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <optional>
+#include <string>
+#include <mglpp/system/vec.hpp>
+
+namespace gsr {
+    struct CursorInfo {
+        mgl::vec2i position;
+        std::string monitor_name;
+    };
+
+    class CursorTracker {
+    public:
+        CursorTracker() = default;
+        CursorTracker(const CursorTracker&) = delete;
+        CursorTracker& operator=(const CursorTracker&) = delete;
+        virtual ~CursorTracker() = default;
+
+        virtual void update() = 0;
+        virtual std::optional<CursorInfo> get_latest_cursor_info() = 0;
+    };
+}

include/CursorTracker/CursorTrackerWayland.hpp

@@ -0,0 +1,43 @@
+#pragma once
+
+#include "CursorTracker.hpp"
+#include <stdint.h>
+#include <vector>
+
+struct wl_display;
+struct wl_registry;
+struct wl_output;
+struct zxdg_output_manager_v1;
+struct zxdg_output_v1;
+
+namespace gsr {
+    struct WaylandOutput {
+        uint32_t wl_name;
+        struct wl_output *output;
+        struct zxdg_output_v1 *xdg_output;
+        mgl::vec2i pos;
+        mgl::vec2i size;
+        int32_t transform;
+        std::string name;
+    };
+
+    class CursorTrackerWayland : public CursorTracker {
+    public:
+        CursorTrackerWayland(const char *card_path);
+        CursorTrackerWayland(const CursorTrackerWayland&) = delete;
+        CursorTrackerWayland& operator=(const CursorTrackerWayland&) = delete;
+        ~CursorTrackerWayland();
+
+        void update() override;
+        std::optional<CursorInfo> get_latest_cursor_info() override;
+
+        std::vector<WaylandOutput> monitors;
+        struct zxdg_output_manager_v1 *xdg_output_manager = nullptr;
+    private:
+        void set_monitor_outputs_from_xdg_output(struct wl_display *dpy);
+    private:
+        int drm_fd = -1;
+        mgl::vec2i latest_cursor_position; // Position of the cursor within the monitor
+        int latest_crtc_id = -1;
+    };
+}

include/CursorTracker/CursorTrackerX11.hpp

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "CursorTracker.hpp"
+
+typedef struct _XDisplay Display;
+
+namespace gsr {
+    class CursorTrackerX11 : public CursorTracker {
+    public:
+        CursorTrackerX11(Display *dpy);
+        CursorTrackerX11(const CursorTrackerX11&) = delete;
+        CursorTrackerX11& operator=(const CursorTrackerX11&) = delete;
+        ~CursorTrackerX11() = default;
+
+        void update() override {}
+        std::optional<CursorInfo> get_latest_cursor_info() override;
+    private:
+        Display *dpy = nullptr;
+    };
+}

include/GlobalHotkeys/GlobalHotkeysJoystick.hpp

@@ -1,12 +1,10 @@
 #pragma once
 
 #include "GlobalHotkeys.hpp"
-#include "Hotplug.hpp"
+#include "../Hotplug.hpp"
 #include <unordered_map>
-#include <optional>
 #include <thread>
 #include <poll.h>
-#include <mglpp/system/Clock.hpp>
 #include <linux/joystick.h>
 
 namespace gsr {
@@ -21,6 +19,14 @@ namespace gsr {
         ~GlobalHotkeysJoystick() override;
 
         bool start();
+        // Currently valid ids:
+        // save_replay
+        // save_1_min_replay
+        // save_10_min_replay
+        // take_screenshot
+        // toggle_record
+        // toggle_replay
+        // toggle_show
         bool bind_action(const std::string &id, GlobalHotkeyCallback callback) override;
         void poll_events() override;
     private:
@@ -45,9 +51,19 @@ namespace gsr {
         int event_fd = -1;
         int event_index = -1;
 
-        mgl::Clock double_click_clock;
-        std::optional<double> prev_time_clicked;
+        bool playstation_button_pressed = false;
+        bool up_pressed = false;
+        bool down_pressed = false;
+        bool left_pressed = false;
+        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;
+        bool toggle_show = false;
         int hotplug_poll_index = -1;
         Hotplug hotplug;
     };

include/GlobalHotkeys/GlobalHotkeysLinux.hpp

@@ -21,6 +21,8 @@ namespace gsr {
         bool bind_key_press(Hotkey hotkey, const std::string &id, GlobalHotkeyCallback callback) override;
         void unbind_all_keys() override;
         void poll_events() override;
+    private:
+        void close_fds();
     private:
         pid_t process_id = 0;
         int read_pipes[2];

include/GsrInfo.hpp

@@ -47,6 +47,7 @@ namespace gsr {
 
     struct SupportedCaptureOptions {
         bool window = false;
+        bool region = false;
         bool focused = false;
         bool portal = false;
         std::vector<GsrMonitor> monitors;
@@ -68,7 +69,8 @@ namespace gsr {
         UNKNOWN,
         AMD,
         INTEL,
-        NVIDIA
+        NVIDIA,
+        BROADCOM
     };
 
     struct GpuInfo {

include/Overlay.hpp

@@ -6,9 +6,10 @@
 #include "Config.hpp"
 #include "window_texture.h"
 #include "WindowUtils.hpp"
-#include "GlobalHotkeysLinux.hpp"
-#include "GlobalHotkeysJoystick.hpp"
+#include "GlobalHotkeys/GlobalHotkeysJoystick.hpp"
 #include "AudioPlayer.hpp"
+#include "RegionSelector.hpp"
+#include "CursorTracker/CursorTracker.hpp"
 
 #include <mglpp/window/Window.hpp>
 #include <mglpp/window/Event.hpp>
@@ -58,11 +59,15 @@ namespace gsr {
         void toggle_stream();
         void toggle_replay();
         void save_replay();
+        void save_replay_1_min();
+        void save_replay_10_min();
         void take_screenshot();
-        void show_notification(const char *str, double timeout_seconds, mgl::Color icon_color, mgl::Color bg_color, NotificationType notification_type);
+        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);
         bool is_open() const;
         bool should_exit(std::string &reason) const;
         void exit();
+        void go_back_to_old_ui();
 
         const Config& get_config() const;
 
@@ -78,14 +83,13 @@ namespace gsr {
         void process_key_bindings(mgl::Event &event);
         void grab_mouse_and_keyboard();
         void xi_setup_fake_cursor();
-        void xi_grab_all_mouse_devices();
 
         void close_gpu_screen_recorder_output();
 
         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 update_gsr_process_status();
         void update_gsr_screenshot_process_status();
 
@@ -94,7 +98,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();
@@ -108,13 +112,18 @@ 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);
-        void on_press_start_record();
-        void on_press_start_stream();
-        void on_press_take_screenshot();
+        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_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);
         bool update_compositor_texture(const Monitor &monitor);
 
+        std::string get_capture_target(const std::string &capture_target, const SupportedCaptureOptions &capture_options);
+
         void force_window_on_top();
     private:
         using KeyBindingCallback = std::function<void()>;
@@ -200,7 +209,18 @@ namespace gsr {
         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;
 
         AudioPlayer audio_player;
+        RegionSelector region_selector;
+        bool start_region_capture = false;
+        std::function<void()> on_region_selected;
+
+        std::string recording_capture_target;
+        std::string screenshot_capture_target;
+
+        std::unique_ptr<CursorTracker> cursor_tracker;
+        mgl::Clock cursor_tracker_update_clock;
     };
 }

include/RegionSelector.hpp

@@ -0,0 +1,54 @@
+#pragma once
+
+#include "WindowUtils.hpp"
+#include <mglpp/system/vec.hpp>
+#include <mglpp/graphics/Color.hpp>
+#include <vector>
+
+#include <X11/Xlib.h>
+
+namespace gsr {
+    struct Region {
+        mgl::vec2i pos;
+        mgl::vec2i size;
+    };
+
+    class RegionSelector {
+    public:
+        RegionSelector();
+        RegionSelector(const RegionSelector&) = delete;
+        RegionSelector& operator=(const RegionSelector&) = delete;
+        ~RegionSelector();
+
+        bool start(mgl::Color border_color);
+        void stop();
+        bool is_started() const;
+
+        bool failed() const;
+        bool poll_events();
+        bool is_selected() const;
+        bool take_selection();
+        bool take_canceled();
+        Region get_selection() const;
+    private:
+        void on_button_press(const void *de);
+        void on_button_release(const void *de);
+        void on_mouse_motion(const void *de);
+    private:
+        Display *dpy = nullptr;
+        unsigned long region_window = 0;
+        unsigned long cursor_window = 0;
+        unsigned long region_window_colormap = 0;
+        int xi_opcode = 0;
+        GC region_gc = nullptr;
+        GC cursor_gc = nullptr;
+
+        Region region;
+        bool selecting_region = false;
+        bool selected = false;
+        bool canceled = false;
+        bool is_wayland = false;
+        std::vector<Monitor> monitors;
+        mgl::vec2i cursor_pos;
+    };
+}

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

@@ -42,6 +42,16 @@ namespace gsr {
         mgl::Texture pause_texture;
         mgl::Texture save_texture;
         mgl::Texture screenshot_texture;
+        mgl::Texture trash_texture;
+
+        mgl::Texture ps4_home_texture;
+        mgl::Texture ps4_options_texture;
+        mgl::Texture ps4_dpad_up_texture;
+        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

@@ -4,7 +4,6 @@
 #include <string_view>
 #include <map>
 #include <string>
-#include <optional>
 
 namespace gsr {
     struct KeyValue {
@@ -15,6 +14,8 @@ 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 get_home_dir();
     std::string get_config_dir();

include/WindowUtils.hpp

@@ -15,6 +15,7 @@ namespace gsr {
     struct Monitor {
         mgl::vec2i position;
         mgl::vec2i size;
+        std::string name;
     };
 
     std::optional<std::string> get_window_title(Display *dpy, Window window);
@@ -22,9 +23,19 @@ namespace gsr {
     std::string get_focused_window_name(Display *dpy, WindowCaptureType window_capture_type);
     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);
     mgl::vec2i get_cursor_position(Display *dpy, Window *window);
     mgl::vec2i create_window_get_center_position(Display *display);
     std::string get_window_manager_name(Display *display);
     bool is_compositor_running(Display *dpy, int screen);
     std::vector<Monitor> get_monitors(Display *dpy);
+    void xi_grab_all_mouse_devices(Display *dpy);
+    void xi_ungrab_all_mouse_devices(Display *dpy);
+    void xi_warp_all_mouse_devices(Display *dpy, mgl::vec2i position);
+    void window_set_fullscreen(Display *dpy, Window window, bool fullscreen);
+    bool window_is_fullscreen(Display *display, Window window);
+    bool set_window_wm_state(Display *dpy, Window window, Atom atom);
+    void make_window_click_through(Display *display, Window window);
+    bool make_window_sticky(Display *dpy, Window window);
+    bool hide_window_from_taskbar(Display *dpy, Window window);
 }

include/gui/Button.hpp

@@ -21,6 +21,7 @@ namespace gsr {
 
         mgl::vec2f get_size() override;
         void set_border_scale(float scale);
+        void set_icon_padding_scale(float scale);
         void set_bg_hover_color(mgl::Color color);
         void set_icon(mgl::Texture *texture);
 
@@ -38,5 +39,6 @@ namespace gsr {
         mgl::Text text;
         mgl::Sprite sprite;
         float border_scale = 0.0015f;
+        float icon_padding_scale = 1.0f;
     };
 }

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/GlobalSettingsPage.hpp

@@ -22,10 +22,13 @@ 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,
         SHOW_HIDE
     };
 
@@ -55,11 +58,14 @@ 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_hotkey_control_buttons();
-        std::unique_ptr<Subsection> create_hotkey_subsection(ScrollablePage *parent_page);
+        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<Subsection> create_application_options_subsection(ScrollablePage *parent_page);
@@ -86,10 +92,13 @@ 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 *show_hide_button_ptr = nullptr;
 
         ConfigHotkey configure_config_hotkey;

include/gui/Image.hpp

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "Widget.hpp"
+
+#include <mglpp/graphics/Sprite.hpp>
+
+namespace gsr {
+    class Image : public Widget {
+    public:
+        enum class ScaleBehavior {
+            SCALE,
+            CLAMP
+        };
+
+        // Set size to {0.0f, 0.0f} for no limit. The image is scaled to the size while keeping its aspect ratio
+        Image(mgl::Texture *texture, mgl::vec2f size, ScaleBehavior scale_behavior);
+        Image(const Image&) = delete;
+        Image& operator=(const Image&) = delete;
+
+        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;
+    private:
+        mgl::Sprite sprite;
+        mgl::vec2f size;
+        ScaleBehavior scale_behavior;
+    };
+}

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/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:
@@ -53,20 +59,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_merge_audio_tracks_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,11 +103,12 @@ 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();
@@ -125,6 +134,8 @@ namespace gsr {
         void save_replay();
         void save_record();
         void save_stream();
+
+        void view_changed(bool advanced_view, Subsection *notifications_subsection_ptr);
     private:
         Type type;
         Config &config;
@@ -152,11 +163,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 *merge_audio_tracks_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;
@@ -187,8 +193,11 @@ namespace gsr {
         Entry *youtube_stream_key_entry_ptr = nullptr;
         Entry *stream_url_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;
 
         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

@@ -3,9 +3,6 @@
 #include <mglpp/system/vec.hpp>
 #include <mglpp/graphics/Color.hpp>
 
-#include <functional>
-#include <string_view>
-
 namespace mgl {
     class Window;
 }
@@ -16,4 +13,5 @@ namespace gsr {
     double get_frame_delta_seconds();
     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);
 }

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
@@ -61,4 +60,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,4 @@
-project('gsr-ui', ['c', 'cpp'], version : '1.2.2', default_options : ['warning_level=2', 'cpp_std=c++17'], subproject_dir : 'depends')
+project('gsr-ui', ['c', 'cpp'], version : '1.6.3', default_options : ['warning_level=2', 'cpp_std=c++17'], subproject_dir : 'depends')
 
 if get_option('buildtype') == 'debug'
     add_project_arguments('-g3', language : ['c', 'cpp'])
@@ -23,6 +23,7 @@ src = [
     'src/gui/Utils.cpp',
     'src/gui/DropdownButton.cpp',
     'src/gui/Label.cpp',
+    'src/gui/Image.cpp',
     'src/gui/LineSeparator.cpp',
     'src/gui/CustomRendererWidget.cpp',
     'src/gui/FileChooser.cpp',
@@ -31,21 +32,27 @@ 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/Config.cpp',
     'src/GsrInfo.cpp',
     'src/Process.cpp',
     'src/Overlay.cpp',
-    'src/GlobalHotkeysX11.cpp',
-    'src/GlobalHotkeysLinux.cpp',
-    'src/GlobalHotkeysJoystick.cpp',
     'src/AudioPlayer.cpp',
     'src/Hotplug.cpp',
     'src/Rpc.cpp',
     'src/main.cpp',
 ]
 
+subdir('protocol')
+src += protocol_src
+
 mglpp_proj = subproject('mglpp')
 mglpp_dep = mglpp_proj.get_variable('mglpp_dep')
 
@@ -54,7 +61,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.1.7"', language: ['c', 'cpp'])
+add_project_arguments('-DGSR_FLATPAK_VERSION="5.6.0"', language: ['c', 'cpp'])
 
 executable(
     meson.project_name(),
@@ -65,9 +72,13 @@ executable(
         dependency('threads'),
         dependency('xcomposite'),
         dependency('xfixes'),
+        dependency('xext'),
         dependency('xi'),
         dependency('xcursor'),
+        dependency('xrandr'),
         dependency('libpulse-simple'),
+        dependency('libdrm'),
+        dependency('wayland-client'),
     ],
     cpp_args : '-DGSR_UI_RESOURCES_PATH="' + gsr_ui_resources_path + '"',
 )

project.conf

@@ -1,7 +1,7 @@
 [package]
 name = "gsr-ui"
 type = "executable"
-version = "1.2.2"
+version = "1.6.3"
 platforms = ["posix"]
 
 [lang.cpp]
@@ -13,6 +13,10 @@ ignore_dirs = ["build", "tools"]
 [dependencies]
 xcomposite = ">=0"
 xfixes = ">=0"
+xext = ">=0"
 xi = ">=0"
 xcursor = ">=1"
+xrandr = ">=0.5"
 libpulse-simple = ">=0"
+libdrm = ">=2"
+wayland-client = ">=1"

protocol/meson.build

@@ -0,0 +1,25 @@
+wayland_scanner = dependency('wayland-scanner', native: true)
+wayland_scanner_path = wayland_scanner.get_variable(pkgconfig: 'wayland_scanner')
+wayland_scanner_prog = find_program(wayland_scanner_path, native: true)
+
+wayland_scanner_code = generator(
+	wayland_scanner_prog,
+	output: '@BASENAME@-protocol.c',
+	arguments: ['private-code', '@INPUT@', '@OUTPUT@'],
+)
+
+wayland_scanner_client = generator(
+	wayland_scanner_prog,
+	output: '@BASENAME@-client-protocol.h',
+	arguments: ['client-header', '@INPUT@', '@OUTPUT@'],
+)
+
+protocols = [
+	'xdg-output-unstable-v1.xml',
+]
+
+protocol_src = []
+foreach xml : protocols
+	protocol_src += wayland_scanner_code.process(xml)
+	protocol_src += wayland_scanner_client.process(xml)
+endforeach

protocol/xdg-output-unstable-v1.xml

@@ -0,0 +1,222 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<protocol name="xdg_output_unstable_v1">
+
+  <copyright>
+    Copyright © 2017 Red Hat Inc.
+
+    Permission is hereby granted, free of charge, to any person obtaining a
+    copy of this software and associated documentation files (the "Software"),
+    to deal in the Software without restriction, including without limitation
+    the rights to use, copy, modify, merge, publish, distribute, sublicense,
+    and/or sell copies of the Software, and to permit persons to whom the
+    Software is furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice (including the next
+    paragraph) shall be included in all copies or substantial portions of the
+    Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+    THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+    DEALINGS IN THE SOFTWARE.
+  </copyright>
+
+  <description summary="Protocol to describe output regions">
+    This protocol aims at describing outputs in a way which is more in line
+    with the concept of an output on desktop oriented systems.
+
+    Some information are more specific to the concept of an output for
+    a desktop oriented system and may not make sense in other applications,
+    such as IVI systems for example.
+
+    Typically, the global compositor space on a desktop system is made of
+    a contiguous or overlapping set of rectangular regions.
+
+    The logical_position and logical_size events defined in this protocol
+    might provide information identical to their counterparts already
+    available from wl_output, in which case the information provided by this
+    protocol should be preferred to their equivalent in wl_output. The goal is
+    to move the desktop specific concepts (such as output location within the
+    global compositor space, etc.) out of the core wl_output protocol.
+
+    Warning! The protocol described in this file is experimental and
+    backward incompatible changes may be made. Backward compatible
+    changes may be added together with the corresponding interface
+    version bump.
+    Backward incompatible changes are done by bumping the version
+    number in the protocol and interface names and resetting the
+    interface version. Once the protocol is to be declared stable,
+    the 'z' prefix and the version number in the protocol and
+    interface names are removed and the interface version number is
+    reset.
+  </description>
+
+  <interface name="zxdg_output_manager_v1" version="3">
+    <description summary="manage xdg_output objects">
+      A global factory interface for xdg_output objects.
+    </description>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy the xdg_output_manager object">
+	Using this request a client can tell the server that it is not
+	going to use the xdg_output_manager object anymore.
+
+	Any objects already created through this instance are not affected.
+      </description>
+    </request>
+
+    <request name="get_xdg_output">
+      <description summary="create an xdg output from a wl_output">
+	This creates a new xdg_output object for the given wl_output.
+      </description>
+      <arg name="id" type="new_id" interface="zxdg_output_v1"/>
+      <arg name="output" type="object" interface="wl_output"/>
+    </request>
+  </interface>
+
+  <interface name="zxdg_output_v1" version="3">
+    <description summary="compositor logical output region">
+      An xdg_output describes part of the compositor geometry.
+
+      This typically corresponds to a monitor that displays part of the
+      compositor space.
+
+      For objects version 3 onwards, after all xdg_output properties have been
+      sent (when the object is created and when properties are updated), a
+      wl_output.done event is sent. This allows changes to the output
+      properties to be seen as atomic, even if they happen via multiple events.
+    </description>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy the xdg_output object">
+	Using this request a client can tell the server that it is not
+	going to use the xdg_output object anymore.
+      </description>
+    </request>
+
+    <event name="logical_position">
+      <description summary="position of the output within the global compositor space">
+	The position event describes the location of the wl_output within
+	the global compositor space.
+
+	The logical_position event is sent after creating an xdg_output
+	(see xdg_output_manager.get_xdg_output) and whenever the location
+	of the output changes within the global compositor space.
+      </description>
+      <arg name="x" type="int"
+	   summary="x position within the global compositor space"/>
+      <arg name="y" type="int"
+	   summary="y position within the global compositor space"/>
+    </event>
+
+    <event name="logical_size">
+      <description summary="size of the output in the global compositor space">
+	The logical_size event describes the size of the output in the
+	global compositor space.
+
+	Most regular Wayland clients should not pay attention to the
+	logical size and would rather rely on xdg_shell interfaces.
+
+	Some clients such as Xwayland, however, need this to configure
+	their surfaces in the global compositor space as the compositor
+	may apply a different scale from what is advertised by the output
+	scaling property (to achieve fractional scaling, for example).
+
+	For example, for a wl_output mode 3840×2160 and a scale factor 2:
+
+	- A compositor not scaling the monitor viewport in its compositing space
+	  will advertise a logical size of 3840×2160,
+
+	- A compositor scaling the monitor viewport with scale factor 2 will
+	  advertise a logical size of 1920×1080,
+
+	- A compositor scaling the monitor viewport using a fractional scale of
+	  1.5 will advertise a logical size of 2560×1440.
+
+	For example, for a wl_output mode 1920×1080 and a 90 degree rotation,
+	the compositor will advertise a logical size of 1080x1920.
+
+	The logical_size event is sent after creating an xdg_output
+	(see xdg_output_manager.get_xdg_output) and whenever the logical
+	size of the output changes, either as a result of a change in the
+	applied scale or because of a change in the corresponding output
+	mode(see wl_output.mode) or transform (see wl_output.transform).
+      </description>
+      <arg name="width" type="int"
+	   summary="width in global compositor space"/>
+      <arg name="height" type="int"
+	   summary="height in global compositor space"/>
+    </event>
+
+    <event name="done" deprecated-since="3">
+      <description summary="all information about the output have been sent">
+	This event is sent after all other properties of an xdg_output
+	have been sent.
+
+	This allows changes to the xdg_output properties to be seen as
+	atomic, even if they happen via multiple events.
+
+	For objects version 3 onwards, this event is deprecated. Compositors
+	are not required to send it anymore and must send wl_output.done
+	instead.
+      </description>
+    </event>
+
+    <!-- Version 2 additions -->
+
+    <event name="name" since="2">
+      <description summary="name of this output">
+	Many compositors will assign names to their outputs, show them to the
+	user, allow them to be configured by name, etc. The client may wish to
+	know this name as well to offer the user similar behaviors.
+
+	The naming convention is compositor defined, but limited to
+	alphanumeric characters and dashes (-). Each name is unique among all
+	wl_output globals, but if a wl_output global is destroyed the same name
+	may be reused later. The names will also remain consistent across
+	sessions with the same hardware and software configuration.
+
+	Examples of names include 'HDMI-A-1', 'WL-1', 'X11-1', etc. However, do
+	not assume that the name is a reflection of an underlying DRM
+	connector, X11 connection, etc.
+
+	The name event is sent after creating an xdg_output (see
+	xdg_output_manager.get_xdg_output). This event is only sent once per
+	xdg_output, and the name does not change over the lifetime of the
+	wl_output global.
+
+        This event is deprecated, instead clients should use wl_output.name.
+        Compositors must still support this event.
+      </description>
+      <arg name="name" type="string" summary="output name"/>
+    </event>
+
+    <event name="description" since="2">
+      <description summary="human-readable description of this output">
+	Many compositors can produce human-readable descriptions of their
+	outputs.  The client may wish to know this description as well, to
+	communicate the user for various purposes.
+
+	The description is a UTF-8 string with no convention defined for its
+	contents. Examples might include 'Foocorp 11" Display' or 'Virtual X11
+	output via :1'.
+
+	The description event is sent after creating an xdg_output (see
+	xdg_output_manager.get_xdg_output) and whenever the description
+	changes. The description is optional, and may not be sent at all.
+
+	For objects of version 2 and lower, this event is only sent once per
+	xdg_output, and the description does not change over the lifetime of
+	the wl_output global.
+
+	This event is deprecated, instead clients should use
+	wl_output.description. Compositors must still support this event.
+      </description>
+      <arg name="description" type="string" summary="output description"/>
+    </event>
+
+  </interface>
+</protocol>

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,25 +118,25 @@ 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.audio_tracks_list.push_back({std::vector<std::string>{"default_output"}, false});
         streaming_config.record_options.video_bitrate = 15000;
 
         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;
 
         if(!capture_options.monitors.empty()) {
-            streaming_config.record_options.record_area_option = capture_options.monitors.front().name;
-            record_config.record_options.record_area_option = capture_options.monitors.front().name;
-            replay_config.record_options.record_area_option = capture_options.monitors.front().name;
-            screenshot_config.record_area_option = capture_options.monitors.front().name;
+            streaming_config.record_options.record_area_option = "focused_monitor";
+            record_config.record_options.record_area_option = "focused_monitor";
+            replay_config.record_options.record_area_option = "focused_monitor";
+            screenshot_config.record_area_option = "focused_monitor";
         }
     }
 
@@ -138,8 +148,11 @@ 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::F1, HOTKEY_MOD_LALT};
+        screenshot_config.take_screenshot_hotkey = {mgl::Keyboard::Printscreen, 0};
+        screenshot_config.take_screenshot_region_hotkey = {mgl::Keyboard::Printscreen, HOTKEY_MOD_LCTRL};
 
         main_config.show_hide_hotkey = {mgl::Keyboard::Z, HOTKEY_MOD_LALT};
     }
@@ -151,7 +164,7 @@ 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 {
@@ -173,6 +186,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},
@@ -202,6 +216,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},
@@ -230,6 +245,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},
@@ -248,8 +264,11 @@ namespace gsr {
             {"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},
@@ -262,7 +281,8 @@ namespace gsr {
             {"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_directory", &config.screenshot_config.save_directory},
-            {"screenshot.take_screenshot_hotkey", &config.screenshot_config.take_screenshot_hotkey}
+            {"screenshot.take_screenshot_hotkey", &config.screenshot_config.take_screenshot_hotkey},
+            {"screenshot.take_screenshot_region_hotkey", &config.screenshot_config.take_screenshot_region_hotkey}
         };
     }
 
@@ -289,6 +309,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);
             }
@@ -300,6 +323,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;
 
@@ -311,10 +345,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) {
@@ -353,6 +392,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);
             }
@@ -360,11 +416,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;
     }
 
@@ -400,9 +461,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

@@ -0,0 +1,564 @@
+#include "../../include/CursorTracker/CursorTrackerWayland.hpp"
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <xf86drm.h>
+#include <xf86drmMode.h>
+#include <wayland-client.h>
+#include "xdg-output-unstable-v1-client-protocol.h"
+
+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,
+        PLANE_PROPERTY_CRTC_ID     = 1 << 2,
+        PLANE_PROPERTY_TYPE_CURSOR = 1 << 3,
+    } plane_property_mask;
+
+    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) {
+        *crtc_x = 0;
+        *crtc_y = 0;
+        *crtc_id = 0;
+
+        uint32_t property_mask = 0;
+
+        drmModeObjectPropertiesPtr props = drmModeObjectGetProperties(drm_fd, plane_id, DRM_MODE_OBJECT_PLANE);
+        if(!props)
+            return property_mask;
+
+        for(uint32_t i = 0; i < props->count_props; ++i) {
+            drmModePropertyPtr prop = drmModeGetProperty(drm_fd, props->props[i]);
+            if(!prop)
+                continue;
+
+            // SRC_* values are fixed 16.16 points
+            const uint32_t type = prop->flags & (DRM_MODE_PROP_LEGACY_TYPE | DRM_MODE_PROP_EXTENDED_TYPE);
+            if((type & DRM_MODE_PROP_SIGNED_RANGE) && strcmp(prop->name, "CRTC_X") == 0) {
+                *crtc_x = (int)props->prop_values[i];
+                property_mask |= PLANE_PROPERTY_CRTC_X;
+            } else if((type & DRM_MODE_PROP_SIGNED_RANGE) && strcmp(prop->name, "CRTC_Y") == 0) {
+                *crtc_y = (int)props->prop_values[i];
+                property_mask |= PLANE_PROPERTY_CRTC_Y;
+            } else if((type & DRM_MODE_PROP_OBJECT) && strcmp(prop->name, "CRTC_ID") == 0) {
+                *crtc_id = (int)props->prop_values[i];
+                property_mask |= PLANE_PROPERTY_CRTC_ID;
+            } else if((type & DRM_MODE_PROP_ENUM) && strcmp(prop->name, "type") == 0) {
+                const uint64_t current_enum_value = props->prop_values[i];
+                for(int j = 0; j < prop->count_enums; ++j) {
+                    if(prop->enums[j].value == current_enum_value && strcmp(prop->enums[j].name, "Cursor") == 0) {
+                        property_mask |= PLANE_PROPERTY_TYPE_CURSOR;
+                        break;
+                    }
+                }
+            }
+
+            drmModeFreeProperty(prop);
+        }
+
+        drmModeFreeObjectProperties(props);
+        return property_mask;
+    }
+
+    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;
+
+            if(strcmp(name, prop->name) == 0) {
+                *result = props->prop_values[i];
+                drmModeFreeProperty(prop);
+                return true;
+            }
+            drmModeFreeProperty(prop);
+        }
+        return false;
+    }
+
+    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);
+    }
+
+    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];
+    }
+
+    // Note: this monitor name logic is kept in sync with gpu screen recorder
+    static std::string get_monitor_name_from_crtc_id(int drm_fd, uint32_t crtc_id) {
+        std::string result;
+        drmModeResPtr resources = drmModeGetResources(drm_fd);
+        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(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) {
+                result = connection_name;
+                result += "-";
+                result += std::to_string(connector_type->count);
+                drmModeFreeConnector(connector);
+                break;
+            }
+
+            next:
+            drmModeFreeConnector(connector);
+        }
+
+        drmModeFreeResources(resources);
+        return result;
+    }
+
+    // Name is the crtc name. TODO: verify if this works on all wayland compositors
+    static const WaylandOutput* get_wayland_monitor_by_name(const std::vector<WaylandOutput> &monitors, const std::string &name) {
+        for(const WaylandOutput &monitor : monitors) {
+            if(monitor.name == name)
+                return &monitor;
+        }
+        return nullptr;
+    }
+
+    static WaylandOutput* get_wayland_monitor_by_output(CursorTrackerWayland &cursor_tracker_wayland, struct wl_output *output) {
+        for(WaylandOutput &monitor : cursor_tracker_wayland.monitors) {
+            if(monitor.output == output)
+                return &monitor;
+        }
+        return nullptr;
+    }
+
+    static void output_handle_geometry(void *data, struct wl_output *wl_output,
+        int32_t x, int32_t y, int32_t phys_width, int32_t phys_height,
+        int32_t subpixel, const char *make, const char *model,
+        int32_t transform) {
+        (void)wl_output;
+        (void)phys_width;
+        (void)phys_height;
+        (void)subpixel;
+        (void)make;
+        (void)model;
+        CursorTrackerWayland *cursor_tracker_wayland = (CursorTrackerWayland*)data;
+        WaylandOutput *monitor = get_wayland_monitor_by_output(*cursor_tracker_wayland, wl_output);
+        if(!monitor)
+            return;
+
+        monitor->pos.x = x;
+        monitor->pos.y = y;
+        monitor->transform = transform;
+    }
+
+    static void output_handle_mode(void *data, struct wl_output *wl_output, uint32_t flags, int32_t width, int32_t height, int32_t refresh) {
+        (void)wl_output;
+        (void)flags;
+        (void)refresh;
+        CursorTrackerWayland *cursor_tracker_wayland = (CursorTrackerWayland*)data;
+        WaylandOutput *monitor = get_wayland_monitor_by_output(*cursor_tracker_wayland, wl_output);
+        if(!monitor)
+            return;
+
+        monitor->size.x = width;
+        monitor->size.y = height;
+    }
+
+    static void output_handle_done(void *data, struct wl_output *wl_output) {
+        (void)data;
+        (void)wl_output;
+    }
+
+    static void output_handle_scale(void* data, struct wl_output *wl_output, int32_t factor) {
+        (void)data;
+        (void)wl_output;
+        (void)factor;
+    }
+
+    static void output_handle_name(void *data, struct wl_output *wl_output, const char *name) {
+        (void)wl_output;
+        CursorTrackerWayland *cursor_tracker_wayland = (CursorTrackerWayland*)data;
+        WaylandOutput *monitor = get_wayland_monitor_by_output(*cursor_tracker_wayland, wl_output);
+        if(!monitor)
+            return;
+
+        monitor->name = name;
+    }
+
+    static void output_handle_description(void *data, struct wl_output *wl_output, const char *description) {
+        (void)data;
+        (void)wl_output;
+        (void)description;
+    }
+
+    static const struct wl_output_listener output_listener = {
+        output_handle_geometry,
+        output_handle_mode,
+        output_handle_done,
+        output_handle_scale,
+        output_handle_name,
+        output_handle_description,
+    };
+
+    static void registry_add_object(void *data, struct wl_registry *registry, uint32_t name, const char *interface, uint32_t version) {
+        (void)version;
+        CursorTrackerWayland *cursor_tracker_wayland = (CursorTrackerWayland*)data;
+        if(strcmp(interface, wl_output_interface.name) == 0) {
+            if(version < 4) {
+                fprintf(stderr, "Warning: wl output interface version is < 4, expected >= 4\n");
+                return;
+            }
+
+            struct wl_output *output = (struct wl_output*)wl_registry_bind(registry, name, &wl_output_interface, 4);
+            cursor_tracker_wayland->monitors.push_back(
+                WaylandOutput{
+                    name,
+                    output,
+                    nullptr,
+                    mgl::vec2i{0, 0},
+                    mgl::vec2i{0, 0},
+                    0,
+                    ""
+                });
+            wl_output_add_listener(output, &output_listener, cursor_tracker_wayland);
+        } else if(strcmp(interface, zxdg_output_manager_v1_interface.name) == 0) {
+            if(version < 1) {
+                fprintf(stderr, "Warning: xdg output interface version is < 1, expected >= 1\n");
+                return;
+            }
+
+            if(cursor_tracker_wayland->xdg_output_manager) {
+                zxdg_output_manager_v1_destroy(cursor_tracker_wayland->xdg_output_manager);
+                cursor_tracker_wayland->xdg_output_manager = NULL;
+            }
+            cursor_tracker_wayland->xdg_output_manager = (struct zxdg_output_manager_v1*)wl_registry_bind(registry, name, &zxdg_output_manager_v1_interface, 1);
+        }
+    }
+
+    static void registry_remove_object(void *data, struct wl_registry *registry, uint32_t name) {
+        (void)data;
+        (void)registry;
+        (void)name;
+        // TODO: Remove output
+    }
+
+    static struct wl_registry_listener registry_listener = {
+        registry_add_object,
+        registry_remove_object,
+    };
+
+    static void xdg_output_logical_position(void *data, struct zxdg_output_v1 *zxdg_output_v1, int32_t x, int32_t y) {
+        (void)zxdg_output_v1;
+        WaylandOutput *monitor = (WaylandOutput*)data;
+        monitor->pos.x = x;
+        monitor->pos.y = y;
+    }
+
+    static void xdg_output_handle_logical_size(void *data, struct zxdg_output_v1 *xdg_output, int32_t width, int32_t height) {
+        (void)data;
+        (void)xdg_output;
+        (void)width;
+        (void)height;
+    }
+
+    static void xdg_output_handle_done(void *data, struct zxdg_output_v1 *xdg_output) {
+        (void)data;
+        (void)xdg_output;
+    }
+
+    static void xdg_output_handle_name(void *data, struct zxdg_output_v1 *xdg_output, const char *name) {
+        (void)data;
+        (void)xdg_output;
+        (void)name;
+    }
+
+    static void xdg_output_handle_description(void *data, struct zxdg_output_v1 *xdg_output, const char *description) {
+        (void)data;
+        (void)xdg_output;
+        (void)description;
+    }
+
+    static const struct zxdg_output_v1_listener xdg_output_listener = {
+        xdg_output_logical_position,
+        xdg_output_handle_logical_size,
+        xdg_output_handle_done,
+        xdg_output_handle_name,
+        xdg_output_handle_description,
+    };
+
+    /* Returns nullptr if not found */
+    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];
+        }
+        return nullptr;
+    }
+
+    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;
+
+        for(int i = 0; i < resources->count_connectors && drm_connectors->num_connectors < MAX_CONNECTORS; ++i) {
+            drmModeConnectorPtr connector = nullptr;
+            drmModeCrtcPtr crtc = nullptr;
+
+            connector = drmModeGetConnectorCurrent(drm_fd, resources->connectors[i]);
+            if(!connector)
+                continue;
+
+            uint64_t crtc_id = 0;
+            connector_get_property_by_name(drm_fd, connector, "CRTC_ID", &crtc_id);
+            if(crtc_id == 0)
+                goto next_connector;
+
+            crtc = drmModeGetCrtc(drm_fd, crtc_id);
+            if(!crtc)
+                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_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);
+    }
+
+    CursorTrackerWayland::CursorTrackerWayland(const char *card_path) {
+        drm_fd = open(card_path, O_RDONLY);
+        if(drm_fd <= 0) {
+            fprintf(stderr, "Error: CursorTrackerWayland: failed to open %s\n", card_path);
+            return;
+        }
+
+        drmSetClientCap(drm_fd, DRM_CLIENT_CAP_UNIVERSAL_PLANES, 1);
+        drmSetClientCap(drm_fd, DRM_CLIENT_CAP_ATOMIC, 1);
+    }
+
+    CursorTrackerWayland::~CursorTrackerWayland() {
+        if(drm_fd > 0)
+            close(drm_fd);
+    }
+
+    void CursorTrackerWayland::update() {
+        if(drm_fd <= 0)
+            return;
+
+        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;
+            uint32_t property_mask = 0;
+
+            plane = drmModeGetPlane(drm_fd, planes->planes[i]);
+            if(!plane)
+                goto next;
+
+            if(!plane->fb_id)
+                goto next;
+
+            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;
+
+            connector = get_drm_connector_by_crtc_id(&connectors, crtc_id);
+            if(!connector)
+                goto next;
+
+            if(crtc_x >= 0 && crtc_x <= connector->size.x && crtc_y >= 0 && crtc_y <= connector->size.y) {
+                latest_cursor_position.x = crtc_x;
+                latest_cursor_position.y = crtc_y;
+                latest_crtc_id = crtc_id;
+                found_cursor = true;
+                drmModeFreePlane(plane);
+                break;
+            }
+
+            next:
+            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);
+    }
+
+    void CursorTrackerWayland::set_monitor_outputs_from_xdg_output(struct wl_display *dpy) {
+        if(!xdg_output_manager) {
+            fprintf(stderr, "Warning: CursorTrackerWayland::set_monitor_outputs_from_xdg_output: zxdg_output_manager not found. Registered monitor positions might be incorrect\n");
+            return;
+        }
+
+        for(WaylandOutput &monitor : monitors) {
+            monitor.xdg_output = zxdg_output_manager_v1_get_xdg_output(xdg_output_manager, monitor.output);
+            zxdg_output_v1_add_listener(monitor.xdg_output, &xdg_output_listener, &monitor);
+        }
+
+        // Fetch xdg_output
+        wl_display_roundtrip(dpy);
+    }
+
+    std::optional<CursorInfo> CursorTrackerWayland::get_latest_cursor_info() {
+        if(drm_fd <= 0 || latest_crtc_id == -1)
+            return std::nullopt;
+
+        std::string monitor_name = get_monitor_name_from_crtc_id(drm_fd, latest_crtc_id);
+        if(monitor_name.empty())
+            return std::nullopt;
+
+        struct wl_display *dpy = wl_display_connect(nullptr);
+        if(!dpy) {
+            fprintf(stderr, "Error: CursorTrackerWayland::get_latest_cursor_info: failed to connect to the wayland server\n");
+            return std::nullopt;
+        }
+
+        monitors.clear();
+        struct wl_registry *registry = wl_display_get_registry(dpy);
+        wl_registry_add_listener(registry, &registry_listener, this);
+
+        // Fetch globals
+        wl_display_roundtrip(dpy);
+
+        // Fetch wl_output
+        wl_display_roundtrip(dpy);
+
+        set_monitor_outputs_from_xdg_output(dpy);
+
+        mgl::vec2i cursor_position = latest_cursor_position;
+        const WaylandOutput *wayland_monitor = get_wayland_monitor_by_name(monitors, monitor_name);
+        if(!wayland_monitor)
+            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();
+
+        if(xdg_output_manager) {
+            zxdg_output_manager_v1_destroy(xdg_output_manager);
+            xdg_output_manager = nullptr;
+        }
+
+        wl_registry_destroy(registry);
+        wl_display_disconnect(dpy);
+
+        return CursorInfo{ cursor_position, std::move(monitor_name) };
+    }
+}

src/CursorTracker/CursorTrackerX11.cpp

@@ -0,0 +1,29 @@
+#include "../../include/CursorTracker/CursorTrackerX11.hpp"
+#include "../../include/WindowUtils.hpp"
+
+namespace gsr {
+    CursorTrackerX11::CursorTrackerX11(Display *dpy) : dpy(dpy) {
+        
+    }
+
+    std::optional<CursorInfo> CursorTrackerX11::get_latest_cursor_info() {
+        Window window = None;
+        const auto cursor_pos = get_cursor_position(dpy, &window);
+        const auto monitors = get_monitors(dpy);
+        std::string monitor_name;
+
+        for(const auto &monitor : monitors) {
+            if(cursor_pos.x >= monitor.position.x && cursor_pos.x <= monitor.position.x + monitor.size.x
+                && cursor_pos.y >= monitor.position.y && cursor_pos.y <= monitor.position.y + monitor.size.y)
+            {
+                monitor_name = monitor.name;
+                break;
+            }
+        }
+
+        if(monitor_name.empty())
+            return std::nullopt;
+
+        return CursorInfo{ cursor_pos, std::move(monitor_name) };
+    }
+}

src/GlobalHotkeys/GlobalHotkeysJoystick.cpp

@@ -1,4 +1,4 @@
-#include "../include/GlobalHotkeysJoystick.hpp"
+#include "../../include/GlobalHotkeys/GlobalHotkeysJoystick.hpp"
 #include <string.h>
 #include <errno.h>
 #include <fcntl.h>
@@ -6,7 +6,13 @@
 #include <sys/eventfd.h>
 
 namespace gsr {
-    static constexpr double double_click_timeout_seconds = 0.33;
+    static constexpr int button_pressed = 1;
+    static constexpr int cross_button = 0;
+    static constexpr int triangle_button = 2;
+    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) {
@@ -99,6 +105,48 @@ namespace gsr {
             if(it != bound_actions_by_id.end())
                 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");
+            if(it != bound_actions_by_id.end())
+                it->second("take_screenshot");
+        }
+
+        if(toggle_record) {
+            toggle_record = false;
+            auto it = bound_actions_by_id.find("toggle_record");
+            if(it != bound_actions_by_id.end())
+                it->second("toggle_record");
+        }
+
+        if(toggle_replay) {
+            toggle_replay = false;
+            auto it = bound_actions_by_id.find("toggle_replay");
+            if(it != bound_actions_by_id.end())
+                it->second("toggle_replay");
+        }
+
+        if(toggle_show) {
+            toggle_show = false;
+            auto it = bound_actions_by_id.find("toggle_show");
+            if(it != bound_actions_by_id.end())
+                it->second("toggle_show");
+        }
     }
 
     void GlobalHotkeysJoystick::read_events() {
@@ -153,25 +201,51 @@ namespace gsr {
         if(read(fd, &event, sizeof(event)) != sizeof(event))
             return;
 
-        if((event.type & JS_EVENT_BUTTON) == 0)
-            return;
-
-        if(event.number == 8 && event.value == 1) {
-            const double now = double_click_clock.get_elapsed_time_seconds();
-            if(!prev_time_clicked.has_value()) {
-                prev_time_clicked = now;
-                return;
-            }
-
-            if(prev_time_clicked.has_value()) {
-                const bool double_clicked = (now - prev_time_clicked.value()) < double_click_timeout_seconds;
-                if(double_clicked) {
-                    save_replay = true;
-                    prev_time_clicked.reset();
-                } else {
-                    prev_time_clicked = now;
+        if((event.type & JS_EVENT_BUTTON) == JS_EVENT_BUTTON) {
+            switch(event.number) {
+                case playstation_button: {
+                    playstation_button_pressed = event.value == button_pressed;
+                    break;
+                }
+                case options_button: {
+                    if(playstation_button_pressed && event.value == button_pressed)
+                        toggle_show = true;
+                    break;
+                }
+                case cross_button: {
+                    if(playstation_button_pressed && event.value == button_pressed)
+                        save_1_min_replay = true;
+                    break;
+                }
+                case triangle_button: {
+                    if(playstation_button_pressed && event.value == button_pressed)
+                        save_10_min_replay = true;
+                    break;
                 }
             }
+        } else if((event.type & JS_EVENT_AXIS) == JS_EVENT_AXIS && playstation_button_pressed) {
+            const int trigger_threshold = 16383;
+            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(up_pressed && !prev_up_pressed)
+                take_screenshot = true;
+            else if(down_pressed && !prev_down_pressed)
+                save_replay = true;
+            else if(left_pressed && !prev_left_pressed)
+                toggle_record = true;
+            else if(right_pressed && !prev_right_pressed)
+                toggle_replay = true;
         }
     }
 

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>
@@ -9,6 +8,7 @@ extern "C" {
 #include <mgl/mgl.h>
 }
 #include <X11/Xlib.h>
+#include <X11/keysym.h>
 #include <linux/input-event-codes.h>
 
 #define PIPE_READ 0
@@ -58,6 +58,10 @@ namespace gsr {
         return result;
     }
 
+    static bool x11_key_is_alpha_numerical(KeySym keysym) {
+        return (keysym >= XK_A && keysym <= XK_Z) || (keysym >= XK_a && keysym <= XK_z) || (keysym >= XK_0 && keysym <= XK_9);
+    }
+
     GlobalHotkeysLinux::GlobalHotkeysLinux(GrabType grab_type) : grab_type(grab_type) {
         for(int i = 0; i < 2; ++i) {
             read_pipes[i] = -1;
@@ -66,22 +70,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() {
@@ -173,7 +197,7 @@ namespace gsr {
             return false;
         }
 
-        if(hotkey.modifiers == 0) {
+        if(hotkey.modifiers == 0 && x11_key_is_alpha_numerical(hotkey.key)) {
             //fprintf(stderr, "Error: GlobalHotkeysLinux::bind_key_press: hotkey requires a modifier\n");
             return false;
         }
@@ -185,7 +209,12 @@ namespace gsr {
         const std::string modifiers_command = linux_keys_to_command_string(modifiers.data(), modifiers.size());
 
         char command[256];
-        const int command_size = snprintf(command, sizeof(command), "bind %s %d+%s\n", id.c_str(), (int)keycode, modifiers_command.c_str());
+        int command_size = 0;
+        if(modifiers_command.empty())
+            command_size = snprintf(command, sizeof(command), "bind %s %d\n", id.c_str(), (int)keycode);
+        else
+            command_size = snprintf(command, sizeof(command), "bind %s %d+%s\n", id.c_str(), (int)keycode, modifiers_command.c_str());
+
         if(write(write_pipes[PIPE_WRITE], command, command_size) != command_size) {
             fprintf(stderr, "Error: GlobalHotkeysLinux::bind_key_press: failed to write command to gsr-global-hotkeys, error: %s\n", strerror(errno));
             return false;

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

@@ -11,7 +11,7 @@ namespace gsr {
     }
 
     bool GsrVersion::operator>=(const GsrVersion &other) const {
-        return major >= other.major || (major == other.major && minor >= other.minor) || (major == other.major && minor == other.minor && patch >= other.patch);
+        return major > other.major || (major == other.major && minor > other.minor) || (major == other.major && minor == other.minor && patch >= other.patch);
     }
 
     bool GsrVersion::operator<(const GsrVersion &other) const {
@@ -129,6 +129,8 @@ namespace gsr {
                 gsr_info->gpu_info.vendor = GpuVendor::INTEL;
             else if(key_value->value == "nvidia")
                 gsr_info->gpu_info.vendor = GpuVendor::NVIDIA;
+            else if(key_value->value == "broadcom")
+                gsr_info->gpu_info.vendor = GpuVendor::BROADCOM;
         } else if(key_value->key == "card_path") {
             gsr_info->gpu_info.card_path = key_value->value;
         }
@@ -173,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{};
 
@@ -310,6 +307,8 @@ namespace gsr {
     static void parse_capture_options_line(SupportedCaptureOptions &capture_options, std::string_view line) {
         if(line == "window")
             capture_options.window = true;
+        else if(line == "region")
+            capture_options.region = true;
         else if(line == "focused")
             capture_options.focused = true;
         else if(line == "portal")
@@ -323,10 +322,11 @@ namespace gsr {
 
     static const char* gpu_vendor_to_string(GpuVendor vendor) {
         switch(vendor) {
-            case GpuVendor::UNKNOWN: return "unknown";
-            case GpuVendor::AMD:     return "amd";
-            case GpuVendor::INTEL:   return "intel";
-            case GpuVendor::NVIDIA:  return "nvidia";
+            case GpuVendor::UNKNOWN:  return "unknown";
+            case GpuVendor::AMD:      return "amd";
+            case GpuVendor::INTEL:    return "intel";
+            case GpuVendor::NVIDIA:   return "nvidia";
+            case GpuVendor::BROADCOM: return "broadcom";
         }
         return "unknown";
     }

src/Process.cpp

@@ -130,8 +130,6 @@ namespace gsr {
                 exit_status = -1;
                 break;
             }
-
-            buffer[bytes_read] = '\0';
             result.append(buffer, bytes_read);
         }
 

src/RegionSelector.cpp

@@ -0,0 +1,454 @@
+#include "../include/RegionSelector.hpp"
+
+#include <stdio.h>
+#include <string.h>
+
+#include <X11/extensions/XInput2.h>
+#include <X11/extensions/Xrandr.h>
+#include <X11/extensions/shape.h>
+
+namespace gsr {
+    static const int cursor_window_size = 32;
+    static const int cursor_thickness = 5;
+    static const int region_border_size = 2;
+
+    static bool xinput_is_supported(Display *dpy, int *xi_opcode) {
+        *xi_opcode = 0;
+        int query_event = 0;
+        int query_error = 0;
+        if(!XQueryExtension(dpy, "XInputExtension", xi_opcode, &query_event, &query_error)) {
+            fprintf(stderr, "error: RegionSelector: X Input extension not available\n");
+            return false;
+        }
+
+        int major = 2;
+        int minor = 1;
+        int retval = XIQueryVersion(dpy, &major, &minor);
+        if(retval != Success) {
+            fprintf(stderr, "error: RegionSelector: XInput 2.1 is not supported\n");
+            return false;
+        }
+
+        return true;
+    }
+
+    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 void set_window_shape_cross(Display *dpy, Window window, int window_width, int window_height, int thickness) {
+        XRectangle rectangles[] = {
+            {
+                (short)(window_width / 2 - thickness / 2), (short)0,
+                (unsigned short)thickness,                 (unsigned short)window_height
+            }, // Vertical
+            {
+                (short)(0),                                (short)(window_height / 2 - thickness / 2),
+                (unsigned short)window_width,              (unsigned short)thickness
+            },     // Horizontal
+        };
+        XShapeCombineRectangles(dpy, window, ShapeBounding, 0, 0, rectangles, 2, ShapeSet, Unsorted);
+        XFlush(dpy);
+    }
+
+    static void draw_rectangle(Display *dpy, Window window, GC gc, int x, int y, int width, int height) {
+        if(width < 0) {
+            x += width;
+            width = abs(width);
+        }
+
+        if(height < 0) {
+            y += height;
+            height = abs(height);
+        }
+
+        XDrawRectangle(dpy, window, gc, x, y, width, height);
+    }
+
+    static Window create_cursor_window(Display *dpy, int width, int height, XVisualInfo *vinfo, unsigned long background_pixel) {
+        XSetWindowAttributes window_attr;
+        window_attr.background_pixel = background_pixel;
+        window_attr.border_pixel = 0;
+        window_attr.override_redirect = true;
+        window_attr.event_mask = StructureNotifyMask | PointerMotionMask;
+        window_attr.colormap = XCreateColormap(dpy, DefaultRootWindow(dpy), vinfo->visual, AllocNone);
+        const Window window = XCreateWindow(dpy, DefaultRootWindow(dpy), 0, 0, width, height, 0, vinfo->depth, InputOutput, vinfo->visual, CWBackPixel | CWBorderPixel | CWOverrideRedirect | CWEventMask | CWColormap, &window_attr);
+        if(window) {
+            set_window_size_not_resizable(dpy, window, width, height);
+            set_window_shape_cross(dpy, window, width, height, cursor_thickness);
+            make_window_click_through(dpy, window);
+        }
+        return window;
+    }
+
+    static void draw_rectangle_around_selected_monitor(Display *dpy, Window window, GC region_gc, int region_border_size, bool is_wayland, const std::vector<Monitor> &monitors, mgl::vec2i cursor_pos) {
+        const Monitor *focused_monitor = nullptr;
+        for(const Monitor &monitor : monitors) {
+            if(cursor_pos.x >= monitor.position.x && cursor_pos.x <= monitor.position.x + monitor.size.x
+                && cursor_pos.y >= monitor.position.y && cursor_pos.y <= monitor.position.y + monitor.size.y)
+            {
+                focused_monitor = &monitor;
+                break;
+            }
+        }
+
+        int x = 0;
+        int y = 0;
+        int width = 0;
+        int height = 0;
+        if(focused_monitor) {
+            x = focused_monitor->position.x;
+            y = focused_monitor->position.y;
+            width = focused_monitor->size.x;
+            height = focused_monitor->size.y;
+        }
+
+        if(is_wayland)
+            draw_rectangle(dpy, window, region_gc, x, y, width, height);
+        else
+            set_region_rectangle(dpy, window, x, y, width, height, region_border_size);
+    }
+
+    static void update_cursor_window(Display *dpy, Window window, Window cursor_window, bool is_wayland, int cursor_x, int cursor_y, int cursor_window_size, int thickness, GC cursor_gc) {
+        if(is_wayland) {
+            const int x = cursor_x - cursor_window_size / 2;
+            const int y = cursor_y - cursor_window_size / 2;
+            XFillRectangle(dpy, window, cursor_gc, x + cursor_window_size / 2 - thickness / 2 , y,                                          thickness,          cursor_window_size);
+            XFillRectangle(dpy, window, cursor_gc, x,                                           y + cursor_window_size / 2 - thickness / 2, cursor_window_size, thickness);
+        } else if(cursor_window) {
+            XMoveWindow(dpy, cursor_window, cursor_x - cursor_window_size / 2, cursor_y - cursor_window_size / 2);
+        }
+        XFlush(dpy);
+    }
+
+    static bool is_xwayland(Display *dpy) {
+        int opcode, event, error;
+        return XQueryExtension(dpy, "XWAYLAND", &opcode, &event, &error);
+    }
+
+    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);
+    }
+
+    RegionSelector::RegionSelector() {
+        
+    }
+
+    RegionSelector::~RegionSelector() {
+        stop();
+    }
+
+    bool RegionSelector::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: RegionSelector::start: failed to connect to the X11 server\n");
+            return false;
+        }
+
+        xi_opcode = 0;
+        if(!xinput_is_supported(dpy, &xi_opcode)) {
+            fprintf(stderr, "Error: RegionSelector::start: xinput not supported on your system\n");
+            stop();
+            return false;
+        }
+
+        is_wayland = is_xwayland(dpy);
+        monitors = get_monitors(dpy);
+
+        Window x11_cursor_window = None;
+        cursor_pos = get_cursor_position(dpy, &x11_cursor_window);
+        region.pos = {0, 0};
+        region.size = {0, 0};
+
+        XVisualInfo vinfo;
+        memset(&vinfo, 0, sizeof(vinfo));
+        XMatchVisualInfo(dpy, DefaultScreen(dpy), 32, TrueColor, &vinfo);
+        region_window_colormap = XCreateColormap(dpy, DefaultRootWindow(dpy), vinfo.visual, AllocNone);
+
+        XSetWindowAttributes window_attr;
+        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.colormap = region_window_colormap;
+
+        Screen *screen = XDefaultScreenOfDisplay(dpy);
+        region_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(!region_window) {
+            fprintf(stderr, "Error: RegionSelector::start: failed to create region window\n");
+            stop();
+            return false;
+        }
+        set_window_size_not_resizable(dpy, region_window, XWidthOfScreen(screen), XHeightOfScreen(screen));
+
+        if(!is_wayland) {
+            cursor_window = create_cursor_window(dpy, cursor_window_size, cursor_window_size, &vinfo, border_color_x11);
+            if(!cursor_window)
+                fprintf(stderr, "Warning: RegionSelector::start: failed to create cursor window\n");
+            set_region_rectangle(dpy, region_window, 0, 0, 0, 0, 0);
+        }
+
+        XGCValues region_gc_values;
+        memset(&region_gc_values, 0, sizeof(region_gc_values));
+        region_gc_values.foreground = border_color_x11;
+        region_gc_values.line_width = region_border_size;
+        region_gc_values.line_style = LineSolid;
+        region_gc = XCreateGC(dpy, region_window, GCForeground | GCLineWidth | GCLineStyle, &region_gc_values);
+
+        XGCValues cursor_gc_values;
+        memset(&cursor_gc_values, 0, sizeof(cursor_gc_values));
+        cursor_gc_values.foreground = border_color_x11;
+        cursor_gc_values.line_width = cursor_thickness;
+        cursor_gc_values.line_style = LineSolid;
+        cursor_gc = XCreateGC(dpy, region_window, GCForeground | GCLineWidth | GCLineStyle, &cursor_gc_values);
+
+        if(!region_gc || !cursor_gc) {
+            fprintf(stderr, "Error: RegionSelector::start: failed to create gc\n");
+            stop();
+            return false;
+        }
+
+        XMapWindow(dpy, region_window);
+        make_window_sticky(dpy, region_window);
+        hide_window_from_taskbar(dpy, region_window);
+        XFixesHideCursor(dpy, region_window);
+        XGrabPointer(dpy, DefaultRootWindow(dpy), True, ButtonPressMask | ButtonReleaseMask | ButtonMotionMask, GrabModeAsync, GrabModeAsync, None, None, CurrentTime);
+        XGrabKeyboard(dpy, DefaultRootWindow(dpy), True, GrabModeAsync, GrabModeAsync, CurrentTime);
+        xi_grab_all_mouse_devices(dpy);
+        XFlush(dpy);
+
+        window_set_fullscreen(dpy, region_window, true);
+
+        if(!is_wayland || x11_cursor_window)
+            update_cursor_window(dpy, region_window, cursor_window, is_wayland, cursor_pos.x, cursor_pos.y, cursor_window_size, cursor_thickness, cursor_gc);
+
+        if(cursor_window) {
+            XMapWindow(dpy, cursor_window);
+            make_window_sticky(dpy, cursor_window);
+            hide_window_from_taskbar(dpy, cursor_window);
+        }
+
+        draw_rectangle_around_selected_monitor(dpy, region_window, region_gc, region_border_size, is_wayland, monitors, cursor_pos);
+
+        XFlush(dpy);
+        selected = false;
+        canceled = false;
+        return true;
+    }
+
+    void RegionSelector::stop() {
+        if(!dpy)
+            return;
+
+        XWarpPointer(dpy, DefaultRootWindow(dpy), DefaultRootWindow(dpy), 0, 0, 0, 0, cursor_pos.x, cursor_pos.y);
+        xi_warp_all_mouse_devices(dpy, cursor_pos);
+        XFixesShowCursor(dpy, region_window);
+
+        XUngrabPointer(dpy, CurrentTime);
+        XUngrabKeyboard(dpy, CurrentTime);
+        xi_ungrab_all_mouse_devices(dpy);
+        XFlush(dpy);
+
+        if(region_gc) {
+            XFreeGC(dpy, region_gc);
+            region_gc = nullptr;
+        }
+
+        if(cursor_gc) {
+            XFreeGC(dpy, cursor_gc);
+            cursor_gc = nullptr;
+        }
+
+        if(region_window_colormap) {
+            XFreeColormap(dpy, region_window_colormap);
+            region_window_colormap = 0;
+        }
+
+        if(region_window) {
+            XDestroyWindow(dpy, region_window);
+            region_window = 0;
+        }
+
+        XCloseDisplay(dpy);
+        dpy = nullptr;
+        selecting_region = false;
+    }
+
+    bool RegionSelector::is_started() const {
+        return dpy != nullptr;
+    }
+
+    bool RegionSelector::failed() const {
+        return !dpy;
+    }
+
+    bool RegionSelector::poll_events() {
+        if(!dpy || selected)
+            return false;
+
+        XEvent xev;
+        while(XPending(dpy)) {
+            XNextEvent(dpy, &xev);
+
+            if(xev.type == KeyRelease && XKeycodeToKeysym(dpy, xev.xkey.keycode, 0) == XK_Escape) {
+                canceled = true;
+                selected = false;
+                stop();
+                break;
+            }
+
+            XGenericEventCookie *cookie = &xev.xcookie;
+            if(cookie->type != GenericEvent || cookie->extension != xi_opcode || !XGetEventData(dpy, cookie))
+                continue;
+
+            const XIDeviceEvent *de = (XIDeviceEvent*)cookie->data;
+            switch(cookie->evtype) {
+                case XI_ButtonPress: {
+                    on_button_press(de);
+                    break;
+                }
+                case XI_ButtonRelease: {
+                    on_button_release(de);
+                    break;
+                }
+                case XI_Motion: {
+                    on_mouse_motion(de);
+                    break;
+                }
+            }
+            XFreeEventData(dpy, cookie);
+
+            if(selected) {
+                stop();
+                break;
+            }
+        }
+        return true;
+    }
+
+    bool RegionSelector::is_selected() const {
+        return selected;
+    }
+
+    bool RegionSelector::take_selection() {
+        const bool result = selected;
+        selected = false;
+        return result;
+    }
+
+    bool RegionSelector::take_canceled() {
+        const bool result = canceled;
+        canceled = false;
+        return result;
+    }
+
+    Region RegionSelector::get_selection() const {
+        return region;
+    }
+
+    void RegionSelector::on_button_press(const void *de) {
+        const XIDeviceEvent *device_event = (XIDeviceEvent*)de;
+        if(device_event->detail != Button1)
+            return;
+
+        region.pos = { (int)device_event->root_x, (int)device_event->root_y };
+        selecting_region = true;
+    }
+
+    void RegionSelector::on_button_release(const void *de) {
+        const XIDeviceEvent *device_event = (XIDeviceEvent*)de;
+        if(device_event->detail != Button1)
+            return;
+
+        if(!selecting_region)
+            return;
+
+        if(is_wayland) {
+            XClearWindow(dpy, region_window);
+            XFlush(dpy);
+        } else {
+            set_region_rectangle(dpy, region_window, 0, 0, 0, 0, 0);
+        }
+        selecting_region = false;
+
+        cursor_pos = region.pos + region.size;
+
+        if(region.size.x < 0) {
+            region.pos.x += region.size.x;
+            region.size.x = abs(region.size.x);
+        }
+
+        if(region.size.y < 0) {
+            region.pos.y += region.size.y;
+            region.size.y = abs(region.size.y);
+        }
+
+        if(region.size.x > 0)
+            region.size.x += 1;
+
+        if(region.size.y > 0)
+            region.size.y += 1;
+
+        selected = true;
+    }
+
+    void RegionSelector::on_mouse_motion(const void *de) {
+        const XIDeviceEvent *device_event = (XIDeviceEvent*)de;
+        XClearWindow(dpy, region_window);
+        if(selecting_region) {
+            region.size.x = device_event->root_x - region.pos.x;
+            region.size.y = device_event->root_y - region.pos.y;
+            cursor_pos = region.pos + region.size;
+
+            if(is_wayland)
+                draw_rectangle(dpy, region_window, region_gc, region.pos.x, region.pos.y, region.size.x, region.size.y);
+            else
+                set_region_rectangle(dpy, region_window, region.pos.x, region.pos.y, region.size.x, region.size.y, region_border_size);
+        } else {
+            cursor_pos = { (int)device_event->root_x, (int)device_event->root_y };
+            draw_rectangle_around_selected_monitor(dpy, region_window, region_gc, region_border_size, is_wayland, monitors, cursor_pos);
+        }
+        update_cursor_window(dpy, region_window, cursor_window, is_wayland, cursor_pos.x, cursor_pos.y, cursor_window_size, cursor_thickness, cursor_gc);
+        XFlush(dpy);
+    }
+}

src/Theme.cpp

@@ -10,10 +10,11 @@ namespace gsr {
 
     static mgl::Color gpu_vendor_to_color(GpuVendor vendor) {
         switch(vendor) {
-            case GpuVendor::UNKNOWN: return mgl::Color(221, 0, 49);
-            case GpuVendor::AMD:     return mgl::Color(221, 0, 49);
-            case GpuVendor::INTEL:   return mgl::Color(8, 109, 183);
-            case GpuVendor::NVIDIA:  return mgl::Color(118, 185, 0);
+            case GpuVendor::UNKNOWN:  return mgl::Color(221, 0, 49);
+            case GpuVendor::AMD:      return mgl::Color(221, 0, 49);
+            case GpuVendor::INTEL:    return mgl::Color(8, 109, 183);
+            case GpuVendor::NVIDIA:   return mgl::Color(118, 185, 0);
+            case GpuVendor::BROADCOM: return mgl::Color(221, 0, 49);
         }
         return mgl::Color(221, 0, 49);
     }
@@ -26,6 +27,8 @@ namespace gsr {
             vendor = GpuVendor::INTEL;
         else if(color_name == "nvidia")
             vendor = GpuVendor::NVIDIA;
+        else if(color_name == "broadcom")
+            vendor = GpuVendor::BROADCOM;
         return gpu_vendor_to_color(vendor);
     }
 
@@ -72,7 +75,7 @@ namespace gsr {
         if(!theme->folder_texture.load_from_file((resources_path + "images/folder.png").c_str()))
             goto error;
 
-        if(!theme->up_arrow_texture.load_from_file((resources_path + "images/up_arrow.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->replay_button_texture.load_from_file((resources_path + "images/replay.png").c_str()))
@@ -90,10 +93,10 @@ namespace gsr {
         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()))
@@ -111,6 +114,33 @@ namespace gsr {
         if(!theme->screenshot_texture.load_from_file((resources_path + "images/screenshot.png").c_str()))
             goto error;
 
+        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_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, 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, 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;
 
         error:

src/Utils.cpp

@@ -22,6 +22,16 @@ 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 get_home_dir() {
         const char *home_dir = getenv("HOME");
         if(!home_dir) {

src/WindowUtils.cpp

@@ -1,8 +1,11 @@
 #include "../include/WindowUtils.hpp"
 
-#include <X11/Xlib.h>
 #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>
 
@@ -301,6 +304,21 @@ namespace gsr {
         return get_window_name_at_position(dpy, cursor_position, ignore_window);
     }
 
+    void set_window_size_not_resizable(Display *dpy, Window window, int width, int height) {
+        XSizeHints *size_hints = XAllocSizeHints();
+        if(size_hints) {
+            size_hints->width = width;
+            size_hints->height = height;
+            size_hints->min_width = width;
+            size_hints->min_height = height;
+            size_hints->max_width = width;
+            size_hints->max_height = height;
+            size_hints->flags = PSize | PMinSize | PMaxSize;
+            XSetWMNormalHints(dpy, window, size_hints);
+            XFree(size_hints);
+        }
+    }
+
     typedef struct {
         unsigned long flags;
         unsigned long functions;
@@ -348,17 +366,7 @@ namespace gsr {
         XChangeProperty(display, window, net_wm_window_opacity, XA_CARDINAL, 32, PropModeReplace, (unsigned char *)&opacity, 1L);
 
         window_set_decorations_visible(display, window, false);
-
-        XSizeHints *size_hints = XAllocSizeHints();
-        size_hints->width = size;
-        size_hints->height = size;
-        size_hints->min_width = size;
-        size_hints->min_height = size;
-        size_hints->max_width = size;
-        size_hints->max_height = size;
-        size_hints->flags = PSize | PMinSize | PMaxSize;
-        XSetWMNormalHints(display, window, size_hints);
-        XFree(size_hints);
+        set_window_size_not_resizable(display, window, size, size);
 
         XMapWindow(display, window);
         XFlush(display);
@@ -412,17 +420,7 @@ namespace gsr {
         XChangeProperty(display, window, net_wm_window_opacity, XA_CARDINAL, 32, PropModeReplace, (unsigned char *)&opacity, 1L);
 
         window_set_decorations_visible(display, window, false);
-
-        XSizeHints *size_hints = XAllocSizeHints();
-        size_hints->width = size;
-        size_hints->height = size;
-        size_hints->min_width = size;
-        size_hints->min_height = size;
-        size_hints->max_width = size;
-        size_hints->max_height = size;
-        size_hints->flags = PSize | PMinSize | PMaxSize;
-        XSetWMNormalHints(display, window, size_hints);
-        XFree(size_hints);
+        set_window_size_not_resizable(display, window, size, size);
 
         XMapWindow(display, window);
         XFlush(display);
@@ -521,14 +519,189 @@ 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::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;
     }
+
+    static bool device_is_mouse(const XIDeviceInfo *dev) {
+        for(int i = 0; i < dev->num_classes; ++i) {
+            if(dev->classes[i]->type == XIMasterPointer || dev->classes[i]->type == XISlavePointer)
+                return true;
+        }
+        return false;
+    }
+
+    static void xi_grab_all_mouse_devices(Display *dpy, bool grab) {
+        if(!dpy)
+            return;
+
+        int num_devices = 0;
+        XIDeviceInfo *info = XIQueryDevice(dpy, XIAllDevices, &num_devices);
+        if(!info)
+            return;
+
+        unsigned char mask[XIMaskLen(XI_LASTEVENT)];
+        memset(mask, 0, sizeof(mask));
+        XISetMask(mask, XI_Motion);
+        //XISetMask(mask, XI_RawMotion);
+        XISetMask(mask, XI_ButtonPress);
+        XISetMask(mask, XI_ButtonRelease);
+        XISetMask(mask, XI_KeyPress);
+        XISetMask(mask, XI_KeyRelease);
+
+        for (int i = 0; i < num_devices; ++i) {
+            const XIDeviceInfo *dev = &info[i];
+            if(!device_is_mouse(dev))
+                continue;
+
+            XIEventMask xi_masks;
+            xi_masks.deviceid = dev->deviceid;
+            xi_masks.mask_len = sizeof(mask);
+            xi_masks.mask = mask;
+            if(grab)
+                XIGrabDevice(dpy, dev->deviceid, DefaultRootWindow(dpy), CurrentTime, None, XIGrabModeAsync, XIGrabModeAsync, XIOwnerEvents, &xi_masks);
+            else
+                XIUngrabDevice(dpy, dev->deviceid, CurrentTime);
+        }
+
+        XFlush(dpy);
+        XIFreeDeviceInfo(info);
+    }
+
+    void xi_grab_all_mouse_devices(Display *dpy) {
+        xi_grab_all_mouse_devices(dpy, true);
+    }
+
+    void xi_ungrab_all_mouse_devices(Display *dpy) {
+        xi_grab_all_mouse_devices(dpy, false);
+    }
+
+    void xi_warp_all_mouse_devices(Display *dpy, mgl::vec2i position) {
+        if(!dpy)
+            return;
+
+        int num_devices = 0;
+        XIDeviceInfo *info = XIQueryDevice(dpy, XIAllDevices, &num_devices);
+        if(!info)
+            return;
+
+        for (int i = 0; i < num_devices; ++i) {
+            const XIDeviceInfo *dev = &info[i];
+            if(!device_is_mouse(dev))
+                continue;
+
+            XIWarpPointer(dpy, dev->deviceid, DefaultRootWindow(dpy), DefaultRootWindow(dpy), 0, 0, 0, 0, position.x, position.y);
+        }
+
+        XFlush(dpy);
+        XIFreeDeviceInfo(info);
+    }
+
+    void window_set_fullscreen(Display *dpy, Window window, bool fullscreen) {
+        const Atom net_wm_state_atom = XInternAtom(dpy, "_NET_WM_STATE", False);
+        const Atom net_wm_state_fullscreen_atom = XInternAtom(dpy, "_NET_WM_STATE_FULLSCREEN", False);
+
+        XEvent xev;
+        xev.type = ClientMessage;
+        xev.xclient.window = window;
+        xev.xclient.message_type = net_wm_state_atom;
+        xev.xclient.format = 32;
+        xev.xclient.data.l[0] = fullscreen ? 1 : 0;
+        xev.xclient.data.l[1] = net_wm_state_fullscreen_atom;
+        xev.xclient.data.l[2] = 0;
+        xev.xclient.data.l[3] = 1;
+        xev.xclient.data.l[4] = 0;
+
+        if(!XSendEvent(dpy, DefaultRootWindow(dpy), 0, SubstructureRedirectMask | SubstructureNotifyMask, &xev)) {
+            fprintf(stderr, "mgl warning: failed to change window fullscreen state\n");
+            return;
+        }
+
+        XFlush(dpy);
+    }
+
+    bool window_is_fullscreen(Display *display, Window window) {
+        const Atom wm_state_atom = XInternAtom(display, "_NET_WM_STATE", False);
+        const Atom wm_state_fullscreen_atom = XInternAtom(display, "_NET_WM_STATE_FULLSCREEN", False);
+
+        Atom type = None;
+        int format = 0;
+        unsigned long num_items = 0;
+        unsigned long bytes_after = 0;
+        unsigned char *properties = nullptr;
+        if(XGetWindowProperty(display, window, wm_state_atom, 0, 1024, False, XA_ATOM, &type, &format, &num_items, &bytes_after, &properties) < Success) {
+            fprintf(stderr, "Failed to get window wm state property\n");
+            return false;
+        }
+
+        if(!properties)
+            return false;
+
+        bool is_fullscreen = false;
+        Atom *atoms = (Atom*)properties;
+        for(unsigned long i = 0; i < num_items; ++i) {
+            if(atoms[i] == wm_state_fullscreen_atom) {
+                is_fullscreen = true;
+                break;
+            }
+        }
+
+        XFree(properties);
+        return is_fullscreen;
+    }
+
+    #define _NET_WM_STATE_REMOVE  0
+    #define _NET_WM_STATE_ADD     1
+    #define _NET_WM_STATE_TOGGLE  2
+
+    bool set_window_wm_state(Display *dpy, Window window, Atom atom) {
+        const Atom net_wm_state_atom = XInternAtom(dpy, "_NET_WM_STATE", False);
+
+        XClientMessageEvent xclient;
+        memset(&xclient, 0, sizeof(xclient));
+
+        xclient.type = ClientMessage;
+        xclient.window = window;
+        xclient.message_type = net_wm_state_atom;
+        xclient.format = 32;
+        xclient.data.l[0] = _NET_WM_STATE_ADD;
+        xclient.data.l[1] = atom;
+        xclient.data.l[2] = 0;
+        xclient.data.l[3] = 0;
+        xclient.data.l[4] = 0;
+
+        XSendEvent(dpy, DefaultRootWindow(dpy), False, SubstructureRedirectMask | SubstructureNotifyMask, (XEvent*)&xclient);
+        XFlush(dpy);
+        return true;
+    }
+
+    void make_window_click_through(Display *display, Window window) {
+        XRectangle rect;
+        memset(&rect, 0, sizeof(rect));
+        XserverRegion region = XFixesCreateRegion(display, &rect, 1);
+        XFixesSetWindowShapeRegion(display, window, ShapeInput, 0, 0, region);
+        XFixesDestroyRegion(display, region);
+    }
+
+    bool make_window_sticky(Display *dpy, Window window) {
+        return set_window_wm_state(dpy, window, XInternAtom(dpy, "_NET_WM_STATE_STICKY", False));
+    }
+
+    bool hide_window_from_taskbar(Display *dpy, Window window) {
+        return set_window_wm_state(dpy, window, XInternAtom(dpy, "_NET_WM_STATE_SKIP_TASKBAR", False));
+    }
 }

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());
@@ -105,6 +105,10 @@ namespace gsr {
         border_scale = scale;
     }
 
+    void Button::set_icon_padding_scale(float scale) {
+        icon_padding_scale = scale;
+    }
+
     void Button::set_bg_hover_color(mgl::Color color) {
         bg_hover_color = color;
     }
@@ -127,8 +131,8 @@ namespace gsr {
 
         const float widget_height = get_button_height();
 
-        const int padding_icon_top = padding_top_icon_scale * widget_height;
-        const int padding_icon_bottom = padding_bottom_icon_scale * widget_height;
+        const int padding_icon_top = padding_top_icon_scale * icon_padding_scale * widget_height;
+        const int padding_icon_bottom = padding_bottom_icon_scale * icon_padding_scale * widget_height;
 
         const float desired_height = widget_height - (padding_icon_top + padding_icon_bottom);
         sprite.set_height((int)desired_height);

src/gui/ComboBox.cpp

@@ -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;
     }
@@ -210,7 +210,7 @@ namespace gsr {
         const int padding_right = padding_right_scale * get_theme().window_height;
 
         Item *selected_item_ptr = (selected_item < items.size()) ? &items[selected_item] : nullptr;
-        max_size = { 0.0f, padding_top + padding_bottom + (selected_item_ptr ? selected_item_ptr->text.get_bounds().size.y : 0.0f) };
+        max_size = { 0.0f, padding_top + padding_bottom + (selected_item_ptr ? selected_item_ptr->text.get_bounds().size.y : font->get_character_size()) };
         for(Item &item : items) {
             const mgl::vec2f bounds = item.text.get_bounds().size;
             max_size.x = std::max(max_size.x, bounds.x + padding_left + padding_right);
@@ -233,7 +233,7 @@ namespace gsr {
         const int padding_top = padding_top_scale * get_theme().window_height;
         const int padding_bottom = padding_bottom_scale * get_theme().window_height;
         Item *selected_item_ptr = (selected_item < items.size()) ? &items[selected_item] : nullptr;
-        return { max_size.x, padding_top + padding_bottom + (selected_item_ptr ? selected_item_ptr->text.get_bounds().size.y : 0.0f) };
+        return { max_size.x, padding_top + padding_bottom + (selected_item_ptr ? selected_item_ptr->text.get_bounds().size.y : font->get_character_size()) };
     }
 
     float ComboBox::get_dropdown_arrow_height() const {

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/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"
@@ -10,6 +9,7 @@
 #include "../../include/gui/Subsection.hpp"
 #include "../../include/gui/List.hpp"
 #include "../../include/gui/Label.hpp"
+#include "../../include/gui/Image.hpp"
 #include "../../include/gui/RadioButton.hpp"
 #include "../../include/gui/LineSeparator.hpp"
 #include "../../include/gui/CustomRendererWidget.hpp"
@@ -34,20 +34,22 @@ extern "C" {
 namespace gsr {
     static const char* gpu_vendor_to_color_name(GpuVendor vendor) {
         switch(vendor) {
-            case GpuVendor::UNKNOWN: return "amd";
-            case GpuVendor::AMD:     return "amd";
-            case GpuVendor::INTEL:   return "intel";
-            case GpuVendor::NVIDIA:  return "nvidia";
+            case GpuVendor::UNKNOWN:  return "amd";
+            case GpuVendor::AMD:      return "amd";
+            case GpuVendor::INTEL:    return "intel";
+            case GpuVendor::NVIDIA:   return "nvidia";
+            case GpuVendor::BROADCOM: return "broadcom";
         }
         return "amd";
     }
 
     static const char* gpu_vendor_to_string(GpuVendor vendor) {
         switch(vendor) {
-            case GpuVendor::UNKNOWN: return "Unknown";
-            case GpuVendor::AMD:     return "AMD";
-            case GpuVendor::INTEL:   return "Intel";
-            case GpuVendor::NVIDIA:  return "NVIDIA";
+            case GpuVendor::UNKNOWN:  return "Unknown";
+            case GpuVendor::AMD:      return "AMD";
+            case GpuVendor::INTEL:    return "Intel";
+            case GpuVendor::NVIDIA:   return "NVIDIA";
+            case GpuVendor::BROADCOM: return "Broadcom";
         }
         return "unknown";
     }
@@ -67,6 +69,10 @@ namespace gsr {
         return 0;
     }
 
+    static bool key_is_alpha_numerical(mgl::Keyboard::Key key) {
+        return key >= mgl::Keyboard::A && key <= mgl::Keyboard::Num9;
+    }
+
     GlobalSettingsPage::GlobalSettingsPage(Overlay *overlay, const GsrInfo *gsr_info, Config &config, PageStack *page_stack) :
         StaticPage(mgl::vec2f(get_theme().window_width, get_theme().window_height).floor()),
         overlay(overlay),
@@ -94,13 +100,13 @@ namespace gsr {
 
             mgl::Text title_text("Press a key combination to use for the hotkey \"" + hotkey_configure_action_name + "\":", get_theme().title_font);
             mgl::Text hotkey_text(configure_hotkey_button->get_text(), get_theme().top_bar_font);
-            mgl::Text description_text("The hotkey has to contain one or more of these keys: Alt, Ctrl, Shift and Super. Press Esc to cancel or Backspace to remove the hotkey.", get_theme().body_font);
+            mgl::Text description_text("Alpha-numerical keys can't be used alone in hotkeys, they have to be used one or more of these keys: Alt, Ctrl, Shift and Super.\nPress Esc to cancel or Backspace to remove the hotkey.", get_theme().body_font);
             const float text_max_width = std::max(title_text.get_bounds().size.x, std::max(hotkey_text.get_bounds().size.x, description_text.get_bounds().size.x));
 
             const float padding_horizontal = int(get_theme().window_height * 0.01f);
             const float padding_vertical = int(get_theme().window_height * 0.01f);
 
-            const mgl::vec2f bg_size = mgl::vec2f(text_max_width + padding_horizontal*2.0f, get_theme().window_height * 0.1f).floor();
+            const mgl::vec2f bg_size = mgl::vec2f(text_max_width + padding_horizontal*2.0f, get_theme().window_height * 0.13f).floor();
             mgl::Rectangle bg_rect(mgl::vec2f(get_theme().window_width*0.5f - bg_size.x*0.5f, get_theme().window_height*0.5f - bg_size.y*0.5f).floor(), bg_size);
             bg_rect.set_color(get_color_theme().page_bg_color);
             window.draw(bg_rect);
@@ -111,9 +117,16 @@ namespace gsr {
             window.draw(tint_rect);
 
             title_text.set_position(mgl::vec2f(bg_rect.get_position() + mgl::vec2f(bg_rect.get_size().x*0.5f - title_text.get_bounds().size.x*0.5f, padding_vertical)).floor());
+            description_text.set_position(mgl::vec2f(bg_rect.get_position() + mgl::vec2f(bg_rect.get_size().x*0.5f - description_text.get_bounds().size.x*0.5f, bg_rect.get_size().y - description_text.get_bounds().size.y - padding_vertical)).floor());
+
             window.draw(title_text);
 
-            hotkey_text.set_position(mgl::vec2f(bg_rect.get_position() + bg_rect.get_size()*0.5f - hotkey_text.get_bounds().size*0.5f).floor());
+            const float title_text_bottom = title_text.get_position().y + title_text.get_bounds().size.y;
+            hotkey_text.set_position(
+                mgl::vec2f(
+                    bg_rect.get_position().x + bg_rect.get_size().x*0.5f - hotkey_text.get_bounds().size.x*0.5f,
+                    title_text_bottom + (description_text.get_position().y - title_text_bottom) * 0.5f - hotkey_text.get_bounds().size.y*0.5f
+                ).floor());
             window.draw(hotkey_text);
 
             const float caret_padding_x = int(0.001f * get_theme().window_height);
@@ -121,7 +134,6 @@ namespace gsr {
             mgl::Rectangle caret_rect(hotkey_text.get_position() + mgl::vec2f(hotkey_text.get_bounds().size.x + caret_padding_x, hotkey_text.get_bounds().size.y*0.5f - caret_size.y*0.5f).floor(), caret_size);
             window.draw(caret_rect);
 
-            description_text.set_position(mgl::vec2f(bg_rect.get_position() + mgl::vec2f(bg_rect.get_size().x*0.5f - description_text.get_bounds().size.x*0.5f, bg_rect.get_size().y - description_text.get_bounds().size.y - padding_vertical)).floor());
             window.draw(description_text);
         };
         hotkey_overlay->set_visible(false);
@@ -136,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);
@@ -243,6 +255,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);
 
@@ -297,6 +333,21 @@ namespace gsr {
         return list;
     }
 
+    std::unique_ptr<List> GlobalSettingsPage::create_screenshot_region_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, "Take a screenshot of a region:", get_color_theme().text_color));
+        auto take_screenshot_region_button = std::make_unique<Button>(&get_theme().body_font, "", mgl::vec2f(0.0f, 0.0f), mgl::Color(0, 0, 0, 120));
+        take_screenshot_region_button_ptr = take_screenshot_region_button.get();
+        list->add_widget(std::move(take_screenshot_region_button));
+
+        take_screenshot_region_button_ptr->on_click = [this] {
+            configure_hotkey_start(ConfigureHotkeyType::TAKE_SCREENSHOT_REGION);
+        };
+
+        return list;
+    }
+
     std::unique_ptr<List> GlobalSettingsPage::create_hotkey_control_buttons() {
         auto list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER);
 
@@ -307,7 +358,10 @@ 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.main_config.show_hide_hotkey = {mgl::Keyboard::Unknown, 0};
             load_hotkeys();
             overlay->rebind_all_keyboard_hotkeys();
@@ -325,26 +379,53 @@ namespace gsr {
         return list;
     }
 
-    std::unique_ptr<Subsection> GlobalSettingsPage::create_hotkey_subsection(ScrollablePage *parent_page) {
+    static std::unique_ptr<List> create_joystick_hotkey_text(mgl::Texture *image1, mgl::Texture *image2, float max_height, const char *suffix) {
+        auto list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER);
+        list->add_widget(std::make_unique<Label>(&get_theme().body_font, "Press", get_color_theme().text_color));
+        list->add_widget(std::make_unique<Image>(image1, mgl::vec2f{max_height, 1000.0f}, Image::ScaleBehavior::SCALE));
+        list->add_widget(std::make_unique<Label>(&get_theme().body_font, "and", get_color_theme().text_color));
+        list->add_widget(std::make_unique<Image>(image2, mgl::vec2f{max_height, 1000.0f}, Image::ScaleBehavior::SCALE));
+        list->add_widget(std::make_unique<Label>(&get_theme().body_font, suffix, get_color_theme().text_color));
+        return list;
+    }
+
+    std::unique_ptr<Subsection> GlobalSettingsPage::create_keyboard_hotkey_subsection(ScrollablePage *parent_page) {
         auto list = std::make_unique<List>(List::Orientation::VERTICAL);
         List *list_ptr = list.get();
-        auto subsection = std::make_unique<Subsection>("Hotkeys", std::move(list), mgl::vec2f(parent_page->get_inner_size().x, 0.0f));
+        auto subsection = std::make_unique<Subsection>("Keyboard hotkeys", std::move(list), mgl::vec2f(parent_page->get_inner_size().x, 0.0f));
 
         list_ptr->add_widget(std::make_unique<Label>(&get_theme().body_font, "Enable keyboard hotkeys?", get_color_theme().text_color));
         list_ptr->add_widget(create_enable_keyboard_hotkeys_button());
-        list_ptr->add_widget(std::make_unique<Label>(&get_theme().body_font, "Enable controller hotkeys?", get_color_theme().text_color));
-        list_ptr->add_widget(create_enable_joystick_hotkeys_button());
         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(std::make_unique<Label>(&get_theme().body_font, "Double-click the controller share button to save a replay", get_color_theme().text_color));
+        list_ptr->add_widget(create_screenshot_region_hotkey_options());
         list_ptr->add_widget(create_hotkey_control_buttons());
         return subsection;
     }
 
+    std::unique_ptr<Subsection> GlobalSettingsPage::create_controller_hotkey_subsection(ScrollablePage *parent_page) {
+        auto list = std::make_unique<List>(List::Orientation::VERTICAL);
+        List *list_ptr = list.get();
+        auto subsection = std::make_unique<Subsection>("Controller hotkeys", std::move(list), mgl::vec2f(parent_page->get_inner_size().x, 0.0f));
+
+        list_ptr->add_widget(std::make_unique<Label>(&get_theme().body_font, "Enable controller hotkeys?", get_color_theme().text_color));
+        list_ptr->add_widget(create_enable_joystick_hotkeys_button());
+        list_ptr->add_widget(std::make_unique<LineSeparator>(LineSeparator::Orientation::HORIZONTAL, subsection->get_inner_size().x));
+        list_ptr->add_widget(create_joystick_hotkey_text(&get_theme().ps4_home_texture, &get_theme().ps4_options_texture, get_theme().body_font.get_character_size(), "to show/hide the UI"));
+        list_ptr->add_widget(create_joystick_hotkey_text(&get_theme().ps4_home_texture, &get_theme().ps4_dpad_up_texture, get_theme().body_font.get_character_size(), "to take a screenshot"));
+        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;
+    }
+
     std::unique_ptr<Button> GlobalSettingsPage::create_exit_program_button() {
         auto exit_program_button = std::make_unique<Button>(&get_theme().body_font, "Exit program", mgl::vec2f(0.0f, 0.0f), mgl::Color(0, 0, 0, 120));
         exit_program_button->on_click = [&]() {
@@ -402,7 +483,8 @@ namespace gsr {
         settings_list->set_spacing(0.018f);
         settings_list->add_widget(create_appearance_subsection(scrollable_page.get()));
         settings_list->add_widget(create_startup_subsection(scrollable_page.get()));
-        settings_list->add_widget(create_hotkey_subsection(scrollable_page.get()));
+        settings_list->add_widget(create_keyboard_hotkey_subsection(scrollable_page.get()));
+        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()));
         scrollable_page->add_widget(std::move(settings_list));
@@ -436,6 +518,8 @@ namespace gsr {
     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());
@@ -443,6 +527,7 @@ namespace gsr {
         start_stop_streaming_button_ptr->set_text(config.streaming_config.start_stop_hotkey.to_string());
 
         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());
 
         show_hide_button_ptr->set_text(config.main_config.show_hide_hotkey.to_string());
     }
@@ -480,7 +565,7 @@ namespace gsr {
             if(mgl::Keyboard::key_is_modifier(event.key.code)) {
                 configure_config_hotkey.modifiers |= mgl_modifier_to_hotkey_modifier(event.key.code);
                 configure_hotkey_button->set_text(configure_config_hotkey.to_string());
-            } else if(configure_config_hotkey.modifiers != 0) {
+            } else if(event.key.code != mgl::Keyboard::Unknown && (configure_config_hotkey.modifiers != 0 || !key_is_alpha_numerical(event.key.code))) {
                 configure_config_hotkey.key = event.key.code;
                 configure_hotkey_button->set_text(configure_config_hotkey.to_string());
                 configure_hotkey_stop_and_save();
@@ -512,6 +597,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:
@@ -520,6 +609,8 @@ namespace gsr {
                 return start_stop_streaming_button_ptr;
             case ConfigureHotkeyType::TAKE_SCREENSHOT:
                 return take_screenshot_button_ptr;
+            case ConfigureHotkeyType::TAKE_SCREENSHOT_REGION:
+                return take_screenshot_region_button_ptr;
             case ConfigureHotkeyType::SHOW_HIDE:
                 return show_hide_button_ptr;
         }
@@ -534,6 +625,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:
@@ -542,6 +637,8 @@ namespace gsr {
                 return &config.streaming_config.start_stop_hotkey;
             case ConfigureHotkeyType::TAKE_SCREENSHOT:
                 return &config.screenshot_config.take_screenshot_hotkey;
+            case ConfigureHotkeyType::TAKE_SCREENSHOT_REGION:
+                return &config.screenshot_config.take_screenshot_region_hotkey;
             case ConfigureHotkeyType::SHOW_HIDE:
                 return &config.main_config.show_hide_hotkey;
         }
@@ -556,6 +653,7 @@ namespace gsr {
             &config.record_config.pause_unpause_hotkey,
             &config.streaming_config.start_stop_hotkey,
             &config.screenshot_config.take_screenshot_hotkey,
+            &config.screenshot_config.take_screenshot_region_hotkey,
             &config.main_config.show_hide_hotkey
         };
         for(ConfigHotkey *config_hotkey : config_hotkeys) {
@@ -583,6 +681,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;
@@ -595,6 +699,9 @@ namespace gsr {
             case ConfigureHotkeyType::TAKE_SCREENSHOT:
                 hotkey_configure_action_name = "Take a screenshot";
                 break;
+            case ConfigureHotkeyType::TAKE_SCREENSHOT_REGION:
+                hotkey_configure_action_name = "Take a screenshot of a region";
+                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/Image.cpp

@@ -0,0 +1,39 @@
+#include "../../include/gui/Image.hpp"
+#include "../../include/gui/Utils.hpp"
+
+#include <mglpp/window/Window.hpp>
+#include <mglpp/graphics/Texture.hpp>
+
+namespace gsr {
+    Image::Image(mgl::Texture *texture, mgl::vec2f size, ScaleBehavior scale_behavior) :
+        sprite(texture), size(size), scale_behavior(scale_behavior)
+    {
+
+    }
+
+    bool Image::on_event(mgl::Event&, mgl::Window&, mgl::vec2f) {
+        return true;
+    }
+
+    void Image::draw(mgl::Window &window, mgl::vec2f offset) {
+        if(!visible)
+            return;
+
+        sprite.set_size(get_size());
+        sprite.set_position((position + offset).floor());
+        window.draw(sprite);
+    }
+
+    mgl::vec2f Image::get_size() {
+        if(!visible || !sprite.get_texture())
+            return {0.0f, 0.0f};
+
+        const mgl::vec2f sprite_size = sprite.get_texture()->get_size().to_vec2f();
+        if(size.x < 0.001f && size.y < 0.001f)
+            return sprite_size;
+        else if(scale_behavior == ScaleBehavior::SCALE)
+            return scale_keep_aspect_ratio(sprite_size, size);
+        else
+            return clamp_keep_aspect_ratio(sprite_size, size);
+    }
+}

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

@@ -38,6 +38,10 @@ namespace gsr {
         // TODO: Enable this
         //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");
         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);
@@ -253,8 +257,7 @@ 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;
+        record_area_box_ptr->on_selection_changed = [this](const std::string&, const std::string &id) {
             const bool window_selected = id == "window";
             const bool portal_selected = id == "portal";
             select_window_list_ptr->set_visible(window_selected);
@@ -268,7 +271,7 @@ namespace gsr {
         };
 
         if(!capture_options.monitors.empty())
-            record_area_box_ptr->set_selected_item(capture_options.monitors.front().name);
+            record_area_box_ptr->set_selected_item("focused_monitor");
         else if(capture_options.portal)
             record_area_box_ptr->set_selected_item("portal");
         else if(capture_options.window)

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/SettingsPage.cpp

@@ -11,6 +11,8 @@
 #include <string.h>
 
 namespace gsr {
+    static const char *custom_app_audio_tag = "[custom]";
+
     enum class AudioTrackType {
         DEVICE,
         APPLICATION,
@@ -66,8 +68,12 @@ namespace gsr {
         // TODO: Enable this
         //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.focused)
             record_area_box->add_item("Follow focused window", "focused");
+        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");
         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);
@@ -190,129 +196,229 @@ namespace gsr {
         return std::make_unique<Subsection>("Record area", std::move(ll), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f));
     }
 
-    std::unique_ptr<ComboBox> SettingsPage::create_audio_device_selection_combobox() {
+    static bool audio_device_is_output(const std::string &audio_device_id) {
+        return audio_device_id == "default_output" || ends_with(audio_device_id, ".monitor");
+    }
+
+    std::unique_ptr<ComboBox> SettingsPage::create_audio_device_selection_combobox(AudioDeviceType device_type) {
         auto audio_device_box = std::make_unique<ComboBox>(&get_theme().body_font);
         for(const auto &audio_device : audio_devices) {
-            audio_device_box->add_item(audio_device.description, audio_device.name);
+            const bool device_is_output = audio_device_is_output(audio_device.name);
+            if((device_type == AudioDeviceType::OUTPUT && device_is_output) || (device_type == AudioDeviceType::INPUT && !device_is_output)) {
+                std::string description = audio_device.description;
+                if(starts_with(description, "Monitor of "))
+                    description.erase(0, 11);
+                audio_device_box->add_item(description, audio_device.name);
+            }
         }
         return audio_device_box;
     }
 
-    std::unique_ptr<Button> SettingsPage::create_remove_audio_device_button(List *audio_device_list_ptr) {
-        auto remove_audio_track_button = std::make_unique<Button>(&get_theme().body_font, "Remove", mgl::vec2f(0.0f, 0.0f), mgl::Color(0, 0, 0, 120));
-        remove_audio_track_button->on_click = [this, audio_device_list_ptr]() {
-            audio_track_list_ptr->remove_widget(audio_device_list_ptr);
+    static void set_application_audio_options_visible(Subsection *audio_track_subsection, bool visible, const GsrInfo &gsr_info) {
+        if(!gsr_info.system_info.supports_app_audio)
+            visible = false;
+
+        List *audio_track_items_list = dynamic_cast<List*>(audio_track_subsection->get_inner_widget());
+
+        List *buttons_list = dynamic_cast<List*>(audio_track_items_list->get_child_widget_by_index(1));
+        Button *add_application_audio_button = dynamic_cast<Button*>(buttons_list->get_child_widget_by_index(2));
+        add_application_audio_button->set_visible(visible);
+
+        CheckBox *invert_app_audio_checkbox = dynamic_cast<CheckBox*>(audio_track_items_list->get_child_widget_by_index(3));
+        invert_app_audio_checkbox->set_visible(visible);
+    }
+
+    static void set_application_audio_options_visible(List *audio_track_section_list_ptr, bool visible, const GsrInfo &gsr_info) {
+        audio_track_section_list_ptr->for_each_child_widget([visible, &gsr_info](std::unique_ptr<Widget> &widget) {
+            Subsection *audio_track_subsection = dynamic_cast<Subsection*>(widget.get());
+            set_application_audio_options_visible(audio_track_subsection, visible, gsr_info);
+            return true;
+        });
+    }
+
+    std::unique_ptr<Button> SettingsPage::create_remove_audio_device_button(List *audio_input_list_ptr, List *audio_device_list_ptr) {
+        auto remove_audio_track_button = std::make_unique<Button>(&get_theme().body_font, "", mgl::vec2f(0.0f, 0.0f), mgl::Color(0, 0, 0, 0));
+        remove_audio_track_button->set_icon(&get_theme().trash_texture);
+        remove_audio_track_button->set_icon_padding_scale(0.75f);
+        remove_audio_track_button->on_click = [audio_input_list_ptr, audio_device_list_ptr]() {
+            audio_input_list_ptr->remove_widget(audio_device_list_ptr);
         };
         return remove_audio_track_button;
     }
 
-    std::unique_ptr<List> SettingsPage::create_audio_device() {
+    std::unique_ptr<List> SettingsPage::create_audio_device(AudioDeviceType device_type, List *audio_input_list_ptr) {
         auto audio_device_list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER);
         audio_device_list->userdata = (void*)(uintptr_t)AudioTrackType::DEVICE;
-        audio_device_list->add_widget(std::make_unique<Label>(&get_theme().body_font, "Device:", get_color_theme().text_color));
-        audio_device_list->add_widget(create_audio_device_selection_combobox());
-        audio_device_list->add_widget(create_remove_audio_device_button(audio_device_list.get()));
+        audio_device_list->add_widget(std::make_unique<Label>(&get_theme().body_font, device_type == AudioDeviceType::OUTPUT ? "Output device:" : "Input device:   ", get_color_theme().text_color));
+        audio_device_list->add_widget(create_audio_device_selection_combobox(device_type));
+        audio_device_list->add_widget(create_remove_audio_device_button(audio_input_list_ptr, audio_device_list.get()));
         return audio_device_list;
     }
 
-    std::unique_ptr<Button> SettingsPage::create_add_audio_device_button() {
-        auto add_audio_track_button = std::make_unique<Button>(&get_theme().body_font, "Add audio device", mgl::vec2f(0.0f, 0.0f), mgl::Color(0, 0, 0, 120));
-        add_audio_track_button->on_click = [this]() {
-            audio_devices = get_audio_devices();
-            audio_track_list_ptr->add_widget(create_audio_device());
+    std::unique_ptr<Button> SettingsPage::create_add_audio_track_button() {
+        auto button = std::make_unique<Button>(&get_theme().body_font, "Add audio track", mgl::vec2f(0.0f, 0.0f), mgl::Color(0, 0, 0, 120));
+        button->on_click = [this]() {
+            audio_track_section_list_ptr->add_widget(create_audio_track_section(audio_section_ptr));
         };
-        return add_audio_track_button;
+        button->set_visible(type != Type::STREAM);
+        return button;
     }
 
-    std::unique_ptr<ComboBox> SettingsPage::create_application_audio_selection_combobox() {
+    std::unique_ptr<Button> SettingsPage::create_add_audio_output_device_button(List *audio_input_list_ptr) {
+        auto button = std::make_unique<Button>(&get_theme().body_font, "Add output device", mgl::vec2f(0.0f, 0.0f), mgl::Color(0, 0, 0, 120));
+        button->on_click = [this, audio_input_list_ptr]() {
+            audio_devices = get_audio_devices();
+            audio_input_list_ptr->add_widget(create_audio_device(AudioDeviceType::OUTPUT, audio_input_list_ptr));
+        };
+        return button;
+    }
+
+    std::unique_ptr<Button> SettingsPage::create_add_audio_input_device_button(List *audio_input_list_ptr) {
+        auto button = std::make_unique<Button>(&get_theme().body_font, "Add input device", mgl::vec2f(0.0f, 0.0f), mgl::Color(0, 0, 0, 120));
+        button->on_click = [this, audio_input_list_ptr]() {
+            audio_devices = get_audio_devices();
+            audio_input_list_ptr->add_widget(create_audio_device(AudioDeviceType::INPUT, audio_input_list_ptr));
+        };
+        return button;
+    }
+
+    std::unique_ptr<ComboBox> SettingsPage::create_application_audio_selection_combobox(List *application_audio_row) {
         auto audio_device_box = std::make_unique<ComboBox>(&get_theme().body_font);
+        ComboBox *audio_device_box_ptr = audio_device_box.get();
         for(const auto &app_audio : application_audio) {
             audio_device_box->add_item(app_audio, app_audio);
         }
+        audio_device_box->add_item("Custom...", custom_app_audio_tag);
+
+        audio_device_box->on_selection_changed = [application_audio_row, audio_device_box_ptr](const std::string&, const std::string &id) {
+            if(id == custom_app_audio_tag) {
+                application_audio_row->userdata = (void*)(uintptr_t)AudioTrackType::APPLICATION_CUSTOM;
+                auto custom_app_audio_entry = std::make_unique<Entry>(&get_theme().body_font, "", (int)(get_theme().body_font.get_character_size() * 10.0f));
+                application_audio_row->replace_widget(audio_device_box_ptr, std::move(custom_app_audio_entry));
+            }
+        };
+
         return audio_device_box;
     }
 
-    std::unique_ptr<List> SettingsPage::create_application_audio() {
+    std::unique_ptr<List> SettingsPage::create_application_audio(List *audio_input_list_ptr) {
         auto application_audio_list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER);
         application_audio_list->userdata = (void*)(uintptr_t)AudioTrackType::APPLICATION;
-        application_audio_list->add_widget(std::make_unique<Label>(&get_theme().body_font, "App:     ", get_color_theme().text_color));
-        application_audio_list->add_widget(create_application_audio_selection_combobox());
-        application_audio_list->add_widget(create_remove_audio_device_button(application_audio_list.get()));
+        application_audio_list->add_widget(std::make_unique<Label>(&get_theme().body_font, "Application:     ", get_color_theme().text_color));
+        application_audio_list->add_widget(create_application_audio_selection_combobox(application_audio_list.get()));
+        application_audio_list->add_widget(create_remove_audio_device_button(audio_input_list_ptr, application_audio_list.get()));
         return application_audio_list;
     }
 
-    std::unique_ptr<List> SettingsPage::create_custom_application_audio() {
+    std::unique_ptr<List> SettingsPage::create_custom_application_audio(List *audio_input_list_ptr) {
         auto application_audio_list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER);
         application_audio_list->userdata = (void*)(uintptr_t)AudioTrackType::APPLICATION_CUSTOM;
-        application_audio_list->add_widget(std::make_unique<Label>(&get_theme().body_font, "App:     ", get_color_theme().text_color));
+        application_audio_list->add_widget(std::make_unique<Label>(&get_theme().body_font, "Application:     ", get_color_theme().text_color));
         application_audio_list->add_widget(std::make_unique<Entry>(&get_theme().body_font, "", (int)(get_theme().body_font.get_character_size() * 10.0f)));
-        application_audio_list->add_widget(create_remove_audio_device_button(application_audio_list.get()));
+        application_audio_list->add_widget(create_remove_audio_device_button(audio_input_list_ptr, application_audio_list.get()));
         return application_audio_list;
     }
 
-    std::unique_ptr<Button> SettingsPage::create_add_application_audio_button() {
+    std::unique_ptr<Button> SettingsPage::create_add_application_audio_button(List *audio_input_list_ptr) {
         auto add_audio_track_button = std::make_unique<Button>(&get_theme().body_font, "Add application audio", mgl::vec2f(0.0f, 0.0f), mgl::Color(0, 0, 0, 120));
-        add_application_audio_button_ptr = add_audio_track_button.get();
-        add_audio_track_button->on_click = [this]() {
+        add_audio_track_button->on_click = [this, audio_input_list_ptr]() {
             application_audio = get_application_audio();
-            audio_track_list_ptr->add_widget(create_application_audio());
+            if(application_audio.empty())
+                audio_input_list_ptr->add_widget(create_custom_application_audio(audio_input_list_ptr));
+            else
+                audio_input_list_ptr->add_widget(create_application_audio(audio_input_list_ptr));
         };
         return add_audio_track_button;
     }
 
-    std::unique_ptr<Button> SettingsPage::create_add_custom_application_audio_button() {
-        auto add_audio_track_button = std::make_unique<Button>(&get_theme().body_font, "Add custom application audio", mgl::vec2f(0.0f, 0.0f), mgl::Color(0, 0, 0, 120));
-        add_custom_application_audio_button_ptr = add_audio_track_button.get();
-        add_audio_track_button->on_click = [this]() {
-            audio_track_list_ptr->add_widget(create_custom_application_audio());
-        };
-        return add_audio_track_button;
-    }
-
-    std::unique_ptr<List> SettingsPage::create_add_audio_buttons() {
+    std::unique_ptr<List> SettingsPage::create_add_audio_buttons(List *audio_input_list_ptr) {
         auto list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER);
-        list->add_widget(create_add_audio_device_button());
-        list->add_widget(create_add_application_audio_button());
-        list->add_widget(create_add_custom_application_audio_button());
+        list->add_widget(create_add_audio_output_device_button(audio_input_list_ptr));
+        list->add_widget(create_add_audio_input_device_button(audio_input_list_ptr));
+        list->add_widget(create_add_application_audio_button(audio_input_list_ptr));
         return list;
     }
 
-    std::unique_ptr<List> SettingsPage::create_audio_track_track_section() {
+    std::unique_ptr<List> SettingsPage::create_audio_input_section() {
         auto list = std::make_unique<List>(List::Orientation::VERTICAL);
-        audio_track_list_ptr = list.get();
-        audio_track_list_ptr->add_widget(create_audio_device()); // Add default_output by default
+        //list->add_widget(create_audio_device(list.get())); // Add default_output by default
         return list;
     }
 
-    std::unique_ptr<CheckBox> SettingsPage::create_merge_audio_tracks_checkbox() {
-        auto merge_audio_tracks_checkbox = std::make_unique<CheckBox>(&get_theme().body_font, "Merge audio tracks");
-        merge_audio_tracks_checkbox->set_checked(true);
-        merge_audio_tracks_checkbox_ptr = merge_audio_tracks_checkbox.get();
-        return merge_audio_tracks_checkbox;
-    }
-
     std::unique_ptr<CheckBox> SettingsPage::create_application_audio_invert_checkbox() {
         auto application_audio_invert_checkbox = std::make_unique<CheckBox>(&get_theme().body_font, "Record audio from all applications except the selected ones");
         application_audio_invert_checkbox->set_checked(false);
-        application_audio_invert_checkbox_ptr = application_audio_invert_checkbox.get();
         return application_audio_invert_checkbox;
     }
 
-    std::unique_ptr<Widget> SettingsPage::create_audio_track_section() {
+    static void update_audio_track_titles(List *audio_track_section_list_ptr) {
+        int index = 0;
+        audio_track_section_list_ptr->for_each_child_widget([&index](std::unique_ptr<Widget> &widget) {
+            char audio_track_name[32];
+            snprintf(audio_track_name, sizeof(audio_track_name), "Audio track #%d", 1 + index);
+            ++index;
+
+            Subsection *subsection = dynamic_cast<Subsection*>(widget.get());
+            List *subesection_items = dynamic_cast<List*>(subsection->get_inner_widget());
+            Label *audio_track_title = dynamic_cast<Label*>(dynamic_cast<List*>(subesection_items->get_child_widget_by_index(0))->get_child_widget_by_index(0));
+            audio_track_title->set_text(audio_track_name);
+            return true;
+        });
+    }
+
+    std::unique_ptr<List> SettingsPage::create_audio_track_title_and_remove(Subsection *audio_track_subsection, const char *title) {
+        auto list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER);
+        list->add_widget(std::make_unique<Label>(&get_theme().title_font, title, get_color_theme().text_color));
+
+        auto remove_track_button = std::make_unique<Button>(&get_theme().body_font, "", mgl::vec2f(0.0f, 0.0f), mgl::Color(0, 0, 0, 0));
+        remove_track_button->set_icon(&get_theme().trash_texture);
+        remove_track_button->set_icon_padding_scale(0.75f);
+        remove_track_button->on_click = [this, audio_track_subsection]() {
+            audio_track_section_list_ptr->remove_widget(audio_track_subsection);
+            update_audio_track_titles(audio_track_section_list_ptr);
+        };
+        list->add_widget(std::move(remove_track_button));
+        list->set_visible(type != Type::STREAM);
+        return list;
+    }
+
+    std::unique_ptr<Subsection> SettingsPage::create_audio_track_section(Widget *parent_widget) {
+        char audio_track_name[32];
+        snprintf(audio_track_name, sizeof(audio_track_name), "Audio track #%d", 1 + (int)audio_track_section_list_ptr->get_num_children());
+
+        auto audio_input_section = create_audio_input_section();
+        List *audio_input_section_ptr = audio_input_section.get();
+
         auto list = std::make_unique<List>(List::Orientation::VERTICAL);
-        list->add_widget(create_add_audio_buttons());
-        list->add_widget(create_audio_track_track_section());
+        List *list_ptr = list.get();
+        auto subsection = std::make_unique<Subsection>("", std::move(std::move(list)), mgl::vec2f(parent_widget->get_inner_size().x, 0.0f));
+        subsection->set_bg_color(mgl::Color(35, 40, 44));
+
+        list_ptr->add_widget(create_audio_track_title_and_remove(subsection.get(), audio_track_name));
+        list_ptr->add_widget(create_add_audio_buttons(audio_input_section_ptr));
+        list_ptr->add_widget(std::move(audio_input_section));
+        list_ptr->add_widget(create_application_audio_invert_checkbox());
+
+        set_application_audio_options_visible(subsection.get(), view_radio_button_ptr->get_selected_id() == "advanced", *gsr_info);
+        return subsection;
+    }
+
+    std::unique_ptr<List> SettingsPage::create_audio_track_section_list() {
+        auto list = std::make_unique<List>(List::Orientation::VERTICAL);
+        audio_track_section_list_ptr = list.get();
         return list;
     }
 
     std::unique_ptr<Widget> SettingsPage::create_audio_section() {
         auto audio_device_section_list = std::make_unique<List>(List::Orientation::VERTICAL);
-        audio_device_section_list->add_widget(create_audio_track_section());
-        if(type != Type::STREAM)
-            audio_device_section_list->add_widget(create_merge_audio_tracks_checkbox());
-        audio_device_section_list->add_widget(create_application_audio_invert_checkbox());
-        audio_device_section_list->add_widget(create_audio_codec());
-        return std::make_unique<Subsection>("Audio", std::move(audio_device_section_list), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f));
+        List *audio_device_section_list_ptr = audio_device_section_list.get();
+
+        auto subsection = std::make_unique<Subsection>("Audio", std::move(audio_device_section_list), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f));
+        audio_section_ptr = subsection.get();
+        audio_device_section_list_ptr->add_widget(create_add_audio_track_button());
+        audio_device_section_list_ptr->add_widget(create_audio_track_section_list());
+        audio_device_section_list_ptr->add_widget(create_audio_codec());
+        return subsection;
     }
 
     std::unique_ptr<List> SettingsPage::create_video_quality_box() {
@@ -351,14 +457,14 @@ namespace gsr {
         list->add_widget(std::move(video_bitrate_entry));
 
         if(type == Type::STREAM) {
-            auto size_mb_label = std::make_unique<Label>(&get_theme().body_font, "1.92MB", get_color_theme().text_color);
+            auto size_mb_label = std::make_unique<Label>(&get_theme().body_font, "1.64MB", get_color_theme().text_color);
             Label *size_mb_label_ptr = size_mb_label.get();
             list->add_widget(std::move(size_mb_label));
 
             video_bitrate_entry_ptr->on_changed = [size_mb_label_ptr](const std::string &text) {
-                const double video_bitrate_mb_per_seconds = (double)atoi(text.c_str()) / 1000LL / 8LL * 1.024;
+                const double video_bitrate_mbits_per_seconds = (double)atoi(text.c_str()) / 1024.0;
                 char buffer[32];
-                snprintf(buffer, sizeof(buffer), "%.2fMB", video_bitrate_mb_per_seconds);
+                snprintf(buffer, sizeof(buffer), "%.2fMbps", video_bitrate_mbits_per_seconds);
                 size_mb_label_ptr->set_text(buffer);
             };
         }
@@ -368,7 +474,7 @@ namespace gsr {
 
     std::unique_ptr<List> SettingsPage::create_video_bitrate() {
         auto video_bitrate_list = std::make_unique<List>(List::Orientation::VERTICAL);
-        video_bitrate_list->add_widget(std::make_unique<Label>(&get_theme().body_font, "Video bitrate (kbps):", get_color_theme().text_color));
+        video_bitrate_list->add_widget(std::make_unique<Label>(&get_theme().body_font, "Video bitrate (Kbps):", get_color_theme().text_color));
         video_bitrate_list->add_widget(create_video_bitrate_entry());
         video_bitrate_list_ptr = video_bitrate_list.get();
         return video_bitrate_list;
@@ -527,8 +633,7 @@ namespace gsr {
     void SettingsPage::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;
+        record_area_box_ptr->on_selection_changed = [this](const std::string&, const std::string &id) {
             const bool window_selected = id == "window";
             const bool focused_selected = id == "focused";
             const bool portal_selected = id == "portal";
@@ -545,8 +650,7 @@ namespace gsr {
             video_resolution_list_ptr->set_visible(!focused_selected && checked);
         };
 
-        video_quality_box_ptr->on_selection_changed = [this](const std::string &text, const std::string &id) {
-            (void)text;
+        video_quality_box_ptr->on_selection_changed = [this](const std::string&, const std::string &id) {
             const bool custom_selected = id == "custom";
             video_bitrate_list_ptr->set_visible(custom_selected);
 
@@ -558,19 +662,13 @@ namespace gsr {
         video_quality_box_ptr->on_selection_changed("", video_quality_box_ptr->get_selected_id());
 
         if(!capture_options.monitors.empty())
-            record_area_box_ptr->set_selected_item(capture_options.monitors.front().name);
+            record_area_box_ptr->set_selected_item("focused_monitor");
         else if(capture_options.portal)
             record_area_box_ptr->set_selected_item("portal");
         else if(capture_options.window)
             record_area_box_ptr->set_selected_item("window");
         else
             record_area_box_ptr->on_selection_changed("", "");
-
-        if(!gsr_info->system_info.supports_app_audio) {
-            add_application_audio_button_ptr->set_visible(false);
-            add_custom_application_audio_button_ptr->set_visible(false);
-            application_audio_invert_checkbox_ptr->set_visible(false);
-        }
     }
 
     void SettingsPage::add_page_specific_widgets() {
@@ -637,7 +735,7 @@ namespace gsr {
         auto list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER);
 
         auto replay_time_entry = std::make_unique<Entry>(&get_theme().body_font, "60", get_theme().body_font.get_character_size() * 3);
-        replay_time_entry->validate_handler = create_entry_validator_integer_in_range(1, 10800);
+        replay_time_entry->validate_handler = create_entry_validator_integer_in_range(1, 86400);
         replay_time_entry_ptr = replay_time_entry.get();
         list->add_widget(std::move(replay_time_entry));
 
@@ -655,6 +753,24 @@ namespace gsr {
         return replay_time_list;
     }
 
+    std::unique_ptr<List> SettingsPage::create_replay_storage() {
+        auto list = std::make_unique<List>(List::Orientation::VERTICAL);
+        list->add_widget(std::make_unique<Label>(&get_theme().body_font, "Where should temporary replay data be stored?", get_color_theme().text_color));
+        auto replay_storage_button = std::make_unique<RadioButton>(&get_theme().body_font, RadioButton::Orientation::HORIZONTAL);
+        replay_storage_button_ptr = replay_storage_button.get();
+        replay_storage_button->add_item("RAM", "ram");
+        replay_storage_button->add_item("Disk (Not recommended on SSDs)", "disk");
+
+        replay_storage_button->on_selection_changed = [this](const std::string&, const std::string &id) {
+            update_estimated_replay_file_size(id);
+            return true;
+        };
+
+        list->add_widget(std::move(replay_storage_button));
+        list->set_visible(gsr_info->system_info.gsr_version >= GsrVersion{5, 5, 0});
+        return list;
+    }
+
     std::unique_ptr<RadioButton> SettingsPage::create_start_replay_automatically() {
         char fullscreen_text[256];
         snprintf(fullscreen_text, sizeof(fullscreen_text), "Turn on replay when starting a fullscreen application%s", gsr_info->system_info.display_server == DisplayServer::X11 ? "" : " (X11 applications only)");
@@ -688,13 +804,13 @@ namespace gsr {
         return label;
     }
 
-    void SettingsPage::update_estimated_replay_file_size() {
+    void SettingsPage::update_estimated_replay_file_size(const std::string &replay_storage_type) {
         const int64_t replay_time_seconds = atoi(replay_time_entry_ptr->get_text().c_str());
         const int64_t video_bitrate_bps = atoi(video_bitrate_entry_ptr->get_text().c_str()) * 1000LL / 8LL;
         const double video_filesize_mb = ((double)replay_time_seconds * (double)video_bitrate_bps) / 1000.0 / 1000.0 * 1.024;
 
         char buffer[256];
-        snprintf(buffer, sizeof(buffer), "Estimated video max file size in RAM: %.2fMB.\nChange video bitrate or replay duration to change file size.", video_filesize_mb);
+        snprintf(buffer, sizeof(buffer), "Estimated video max file size %s: %.2fMB.\nChange video bitrate or replay duration to change file size.", replay_storage_type == "ram" ? "in RAM" : "on disk", video_filesize_mb);
         estimated_file_size_ptr->set_text(buffer);
     }
 
@@ -712,6 +828,16 @@ namespace gsr {
         replay_time_label_ptr->set_text(buffer);
     }
 
+    void SettingsPage::view_changed(bool advanced_view, Subsection *notifications_subsection_ptr) {
+        color_range_list_ptr->set_visible(advanced_view);
+        audio_codec_ptr->set_visible(advanced_view);
+        video_codec_ptr->set_visible(advanced_view);
+        framerate_mode_list_ptr->set_visible(advanced_view);
+        notifications_subsection_ptr->set_visible(advanced_view);
+        set_application_audio_options_visible(audio_track_section_list_ptr, advanced_view, *gsr_info);
+        settings_scrollable_page_ptr->reset_scroll();
+    }
+
     void SettingsPage::add_replay_widgets() {
         auto file_info_list = std::make_unique<List>(List::Orientation::VERTICAL);
         auto file_info_data_list = std::make_unique<List>(List::Orientation::HORIZONTAL);
@@ -723,12 +849,14 @@ namespace gsr {
         settings_list_ptr->add_widget(std::make_unique<Subsection>("File info", std::move(file_info_list), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f)));
 
         auto general_list = std::make_unique<List>(List::Orientation::VERTICAL);
-        general_list->add_widget(create_start_replay_automatically());
+        general_list->add_widget(create_replay_storage());
         general_list->add_widget(create_save_replay_in_game_folder());
         if(gsr_info->system_info.gsr_version >= GsrVersion{5, 0, 3})
             general_list->add_widget(create_restart_replay_on_save());
         settings_list_ptr->add_widget(std::make_unique<Subsection>("General", std::move(general_list), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f)));
 
+        settings_list_ptr->add_widget(std::make_unique<Subsection>("Autostart", create_start_replay_automatically(), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f)));
+
         auto checkboxes_list = std::make_unique<List>(List::Orientation::VERTICAL);
 
         auto show_replay_started_notification_checkbox = std::make_unique<CheckBox>(&get_theme().body_font, "Show replay started notification");
@@ -750,26 +878,19 @@ namespace gsr {
         Subsection *notifications_subsection_ptr = notifications_subsection.get();
         settings_list_ptr->add_widget(std::move(notifications_subsection));
 
-        view_radio_button_ptr->on_selection_changed = [this, notifications_subsection_ptr](const std::string &text, const std::string &id) {
-            (void)text;
-            const bool advanced_view = id == "advanced";
-            color_range_list_ptr->set_visible(advanced_view);
-            audio_codec_ptr->set_visible(advanced_view);
-            video_codec_ptr->set_visible(advanced_view);
-            framerate_mode_list_ptr->set_visible(advanced_view);
-            notifications_subsection_ptr->set_visible(advanced_view);
-            settings_scrollable_page_ptr->reset_scroll();
+        view_radio_button_ptr->on_selection_changed = [this, notifications_subsection_ptr](const std::string&, const std::string &id) {
+            view_changed(id == "advanced", notifications_subsection_ptr);
             return true;
         };
         view_radio_button_ptr->on_selection_changed("Simple", "simple");
 
         replay_time_entry_ptr->on_changed = [this](const std::string&) {
-            update_estimated_replay_file_size();
+            update_estimated_replay_file_size(replay_storage_button_ptr->get_selected_id());
             update_replay_time_text();
         };
 
         video_bitrate_entry_ptr->on_changed = [this](const std::string&) {
-            update_estimated_replay_file_size();
+            update_estimated_replay_file_size(replay_storage_button_ptr->get_selected_id());
         };
     }
 
@@ -823,15 +944,8 @@ namespace gsr {
         Subsection *notifications_subsection_ptr = notifications_subsection.get();
         settings_list_ptr->add_widget(std::move(notifications_subsection));
 
-        view_radio_button_ptr->on_selection_changed = [this, notifications_subsection_ptr](const std::string &text, const std::string &id) {
-            (void)text;
-            const bool advanced_view = id == "advanced";
-            color_range_list_ptr->set_visible(advanced_view);
-            audio_codec_ptr->set_visible(advanced_view);
-            video_codec_ptr->set_visible(advanced_view);
-            framerate_mode_list_ptr->set_visible(advanced_view);
-            notifications_subsection_ptr->set_visible(advanced_view);
-            settings_scrollable_page_ptr->reset_scroll();
+        view_radio_button_ptr->on_selection_changed = [this, notifications_subsection_ptr](const std::string&, const std::string &id) {
+            view_changed(id == "advanced", notifications_subsection_ptr);
             return true;
         };
         view_radio_button_ptr->on_selection_changed("Simple", "simple");
@@ -927,8 +1041,7 @@ namespace gsr {
         Subsection *notifications_subsection_ptr = notifications_subsection.get();
         settings_list_ptr->add_widget(std::move(notifications_subsection));
 
-        streaming_service_box_ptr->on_selection_changed = [this](const std::string &text, const std::string &id) {
-            (void)text;
+        streaming_service_box_ptr->on_selection_changed = [this](const std::string&, const std::string &id) {
             const bool twitch_option = id == "twitch";
             const bool youtube_option = id == "youtube";
             const bool custom_option = id == "custom";
@@ -941,15 +1054,8 @@ namespace gsr {
         };
         streaming_service_box_ptr->on_selection_changed("Twitch", "twitch");
 
-        view_radio_button_ptr->on_selection_changed = [this, notifications_subsection_ptr](const std::string &text, const std::string &id) {
-            (void)text;
-            const bool advanced_view = id == "advanced";
-            color_range_list_ptr->set_visible(advanced_view);
-            audio_codec_ptr->set_visible(advanced_view);
-            video_codec_ptr->set_visible(advanced_view);
-            framerate_mode_list_ptr->set_visible(advanced_view);
-            notifications_subsection_ptr->set_visible(advanced_view);
-            settings_scrollable_page_ptr->reset_scroll();
+        view_radio_button_ptr->on_selection_changed = [this, notifications_subsection_ptr](const std::string&, const std::string &id) {
+            view_changed(id == "advanced", notifications_subsection_ptr);
             return true;
         };
         view_radio_button_ptr->on_selection_changed("Simple", "simple");
@@ -1000,50 +1106,64 @@ namespace gsr {
         return nullptr;
     }
 
-    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;
-    }
-
     void SettingsPage::load_audio_tracks(const RecordOptions &record_options) {
-        audio_track_list_ptr->clear();
-        for(const std::string &audio_track : record_options.audio_tracks) {
-            if(starts_with(audio_track, "app:")) {
-                if(!gsr_info->system_info.supports_app_audio)
-                    continue;
+        audio_track_section_list_ptr->clear();
+        for(const AudioTrack &audio_track : record_options.audio_tracks_list) {
+            auto audio_track_section = create_audio_track_section(audio_section_ptr);
+            List *audio_track_section_items_list_ptr = dynamic_cast<List*>(audio_track_section->get_inner_widget());
+            List *audio_input_list_ptr = dynamic_cast<List*>(audio_track_section_items_list_ptr->get_child_widget_by_index(2));
+            CheckBox *application_audio_invert_checkbox_ptr = dynamic_cast<CheckBox*>(audio_track_section_items_list_ptr->get_child_widget_by_index(3));
+            application_audio_invert_checkbox_ptr->set_checked(audio_track.application_audio_invert);
 
-                std::string audio_track_name = audio_track.substr(4);
-                const std::string *app_audio = get_application_audio_by_name_case_insensitive(application_audio, audio_track_name);
-                if(app_audio) {
-                    std::unique_ptr<List> application_audio_widget = create_application_audio();
-                    ComboBox *application_audio_box = static_cast<ComboBox*>(application_audio_widget->get_child_widget_by_index(1));
-                    application_audio_box->set_selected_item(*app_audio);
-                    audio_track_list_ptr->add_widget(std::move(application_audio_widget));
+            audio_input_list_ptr->clear();
+            for(const std::string &audio_input : audio_track.audio_inputs) {
+                if(starts_with(audio_input, "app:")) {
+                    if(!gsr_info->system_info.supports_app_audio)
+                        continue;
+
+                    std::string audio_track_name = audio_input.substr(4);
+                    const std::string *app_audio = get_application_audio_by_name_case_insensitive(application_audio, audio_track_name);
+                    if(app_audio) {
+                        std::unique_ptr<List> application_audio_widget = create_application_audio(audio_input_list_ptr);
+                        ComboBox *application_audio_box = dynamic_cast<ComboBox*>(application_audio_widget->get_child_widget_by_index(1));
+                        application_audio_box->set_selected_item(*app_audio);
+                        audio_input_list_ptr->add_widget(std::move(application_audio_widget));
+                    } else {
+                        std::unique_ptr<List> application_audio_widget = create_custom_application_audio(audio_input_list_ptr);
+                        Entry *application_audio_entry = dynamic_cast<Entry*>(application_audio_widget->get_child_widget_by_index(1));
+                        application_audio_entry->set_text(std::move(audio_track_name));
+                        audio_input_list_ptr->add_widget(std::move(application_audio_widget));
+                    }
+                } else if(starts_with(audio_input, "device:")) {
+                    const std::string device_name = audio_input.substr(7);
+                    const AudioDeviceType audio_device_type = audio_device_is_output(device_name) ? AudioDeviceType::OUTPUT : AudioDeviceType::INPUT;
+                    std::unique_ptr<List> audio_track_widget = create_audio_device(audio_device_type, audio_input_list_ptr);
+                    ComboBox *audio_device_box = dynamic_cast<ComboBox*>(audio_track_widget->get_child_widget_by_index(1));
+                    audio_device_box->set_selected_item(device_name);
+                    audio_input_list_ptr->add_widget(std::move(audio_track_widget));
                 } else {
-                    std::unique_ptr<List> application_audio_widget = create_custom_application_audio();
-                    Entry *application_audio_entry = static_cast<Entry*>(application_audio_widget->get_child_widget_by_index(1));
-                    application_audio_entry->set_text(std::move(audio_track_name));
-                    audio_track_list_ptr->add_widget(std::move(application_audio_widget));
+                    const AudioDeviceType audio_device_type = audio_device_is_output(audio_input) ? AudioDeviceType::OUTPUT : AudioDeviceType::INPUT;
+                    std::unique_ptr<List> audio_track_widget = create_audio_device(audio_device_type, audio_input_list_ptr);
+                    ComboBox *audio_device_box = dynamic_cast<ComboBox*>(audio_track_widget->get_child_widget_by_index(1));
+                    audio_device_box->set_selected_item(audio_input);
+                    audio_input_list_ptr->add_widget(std::move(audio_track_widget));
                 }
-            } else if(starts_with(audio_track, "device:")) {
-                std::unique_ptr<List> audio_track_widget = create_audio_device();
-                ComboBox *audio_device_box = static_cast<ComboBox*>(audio_track_widget->get_child_widget_by_index(1));
-                audio_device_box->set_selected_item(audio_track.substr(7));
-                audio_track_list_ptr->add_widget(std::move(audio_track_widget));
-            } else {
-                std::unique_ptr<List> audio_track_widget = create_audio_device();
-                ComboBox *audio_device_box = static_cast<ComboBox*>(audio_track_widget->get_child_widget_by_index(1));
-                audio_device_box->set_selected_item(audio_track);
-                audio_track_list_ptr->add_widget(std::move(audio_track_widget));
             }
+
+            audio_track_section_list_ptr->add_widget(std::move(audio_track_section));
+
+            if(type == Type::STREAM)
+                break;
+        }
+
+        if(type == Type::STREAM && audio_track_section_list_ptr->get_num_children() == 0) {
+            auto audio_track_section = create_audio_track_section(audio_section_ptr);
+            audio_track_section_list_ptr->add_widget(std::move(audio_track_section));
         }
     }
 
     void SettingsPage::load_common(RecordOptions &record_options) {
         record_area_box_ptr->set_selected_item(record_options.record_area_option);
-        if(merge_audio_tracks_checkbox_ptr)
-            merge_audio_tracks_checkbox_ptr->set_checked(record_options.merge_audio_tracks);
-        application_audio_invert_checkbox_ptr->set_checked(record_options.application_audio_invert);
         change_video_resolution_checkbox_ptr->set_checked(record_options.change_video_resolution);
         load_audio_tracks(record_options);
         color_range_box_ptr->set_selected_item(record_options.color_range);
@@ -1096,6 +1216,7 @@ namespace gsr {
 
     void SettingsPage::load_replay() {
         load_common(config.replay_config.record_options);
+        replay_storage_button_ptr->set_selected_item(config.replay_config.replay_storage);
         turn_on_replay_automatically_mode_ptr->set_selected_item(config.replay_config.turn_on_replay_automatically_mode);
         save_replay_in_game_folder_ptr->set_checked(config.replay_config.save_video_in_game_folder);
         if(restart_replay_on_save)
@@ -1108,8 +1229,8 @@ namespace gsr {
 
         if(config.replay_config.replay_time < 2)
             config.replay_config.replay_time = 2;
-        if(config.replay_config.replay_time > 10800)
-            config.replay_config.replay_time = 10800;
+        if(config.replay_config.replay_time > 86400)
+            config.replay_config.replay_time = 86400;
         replay_time_entry_ptr->set_text(std::to_string(config.replay_config.replay_time));
     }
 
@@ -1133,28 +1254,38 @@ namespace gsr {
         container_box_ptr->set_selected_item(config.streaming_config.custom.container);
     }
 
-    static void save_audio_tracks(std::vector<std::string> &audio_devices, List *audio_devices_list_ptr) {
-        audio_devices.clear();
-        audio_devices_list_ptr->for_each_child_widget([&audio_devices](std::unique_ptr<Widget> &child_widget) {
-            List *audio_track_line = static_cast<List*>(child_widget.get());
-            const AudioTrackType audio_track_type = (AudioTrackType)(uintptr_t)audio_track_line->userdata;
-            switch(audio_track_type) {
-                case AudioTrackType::DEVICE: {
-                    ComboBox *audio_device_box = static_cast<ComboBox*>(audio_track_line->get_child_widget_by_index(1));
-                    audio_devices.push_back("device:" + audio_device_box->get_selected_id());
-                    break;
+    static void save_audio_tracks(std::vector<AudioTrack> &audio_tracks, List *audio_track_section_list_ptr) {
+        audio_tracks.clear();
+        audio_track_section_list_ptr->for_each_child_widget([&audio_tracks](std::unique_ptr<Widget> &child_widget) {
+            Subsection *audio_subsection = dynamic_cast<Subsection*>(child_widget.get());
+            List *audio_track_section_items_list_ptr = dynamic_cast<List*>(audio_subsection->get_inner_widget());
+            List *audio_input_list_ptr = dynamic_cast<List*>(audio_track_section_items_list_ptr->get_child_widget_by_index(2));
+            CheckBox *application_audio_invert_checkbox_ptr = dynamic_cast<CheckBox*>(audio_track_section_items_list_ptr->get_child_widget_by_index(3));
+
+            audio_tracks.push_back({std::vector<std::string>{}, application_audio_invert_checkbox_ptr->is_checked()});
+            audio_input_list_ptr->for_each_child_widget([&audio_tracks](std::unique_ptr<Widget> &child_widget){
+                List *audio_track_line = dynamic_cast<List*>(child_widget.get());
+                const AudioTrackType audio_track_type = (AudioTrackType)(uintptr_t)audio_track_line->userdata;
+                switch(audio_track_type) {
+                    case AudioTrackType::DEVICE: {
+                        ComboBox *audio_device_box = dynamic_cast<ComboBox*>(audio_track_line->get_child_widget_by_index(1));
+                        audio_tracks.back().audio_inputs.push_back("device:" + audio_device_box->get_selected_id());
+                        break;
+                    }
+                    case AudioTrackType::APPLICATION: {
+                        ComboBox *application_audio_box = dynamic_cast<ComboBox*>(audio_track_line->get_child_widget_by_index(1));
+                        audio_tracks.back().audio_inputs.push_back("app:" + application_audio_box->get_selected_id());
+                        break;
+                    }
+                    case AudioTrackType::APPLICATION_CUSTOM: {
+                        Entry *application_audio_entry = dynamic_cast<Entry*>(audio_track_line->get_child_widget_by_index(1));
+                        audio_tracks.back().audio_inputs.push_back("app:" + application_audio_entry->get_text());
+                        break;
+                    }
                 }
-                case AudioTrackType::APPLICATION: {
-                    ComboBox *application_audio_box = static_cast<ComboBox*>(audio_track_line->get_child_widget_by_index(1));
-                    audio_devices.push_back("app:" + application_audio_box->get_selected_id());
-                    break;
-                }
-                case AudioTrackType::APPLICATION_CUSTOM: {
-                    Entry *application_audio_entry = static_cast<Entry*>(audio_track_line->get_child_widget_by_index(1));
-                    audio_devices.push_back("app:" + application_audio_entry->get_text());
-                    break;
-                }
-            }
+                return true;
+            });
+
             return true;
         });
     }
@@ -1167,11 +1298,8 @@ namespace gsr {
         record_options.video_height = atoi(video_height_entry_ptr->get_text().c_str());
         record_options.fps = atoi(framerate_entry_ptr->get_text().c_str());
         record_options.video_bitrate = atoi(video_bitrate_entry_ptr->get_text().c_str());
-        if(merge_audio_tracks_checkbox_ptr)
-            record_options.merge_audio_tracks = merge_audio_tracks_checkbox_ptr->is_checked();
-        record_options.application_audio_invert = application_audio_invert_checkbox_ptr->is_checked();
         record_options.change_video_resolution = change_video_resolution_checkbox_ptr->is_checked();
-        save_audio_tracks(record_options.audio_tracks, audio_track_list_ptr);
+        save_audio_tracks(record_options.audio_tracks_list, audio_track_section_list_ptr);
         record_options.color_range = color_range_box_ptr->get_selected_id();
         record_options.video_quality = video_quality_box_ptr->get_selected_id();
         record_options.video_codec = video_codec_box_ptr->get_selected_id();
@@ -1238,6 +1366,7 @@ namespace gsr {
         config.replay_config.save_directory = save_directory_button_ptr->get_text();
         config.replay_config.container = container_box_ptr->get_selected_id();
         config.replay_config.replay_time = atoi(replay_time_entry_ptr->get_text().c_str());
+        config.replay_config.replay_storage = replay_storage_button_ptr->get_selected_id();
 
         if(config.replay_config.replay_time < 5) {
             config.replay_config.replay_time = 5;

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

@@ -67,4 +67,11 @@ namespace gsr {
 
         return from;
     }
+
+    mgl::vec2f clamp_keep_aspect_ratio(mgl::vec2f from, mgl::vec2f to) {
+        if(from.x > to.x || from.y > to.y)
+            return scale_keep_aspect_ratio(from, to);
+        else
+            return from;
+    }
 }

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,15 @@ namespace gsr {
     void Widget::set_visible(bool visible) {
         this->visible = visible;
     }
+
+    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

@@ -30,6 +30,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,10 +78,25 @@ 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();
     });
+
+    rpc->add_handler("take-screenshot-region", [overlay](const std::string &name) {
+        fprintf(stderr, "rpc command executed: %s\n", name.c_str());
+        overlay->take_screenshot_region();
+    });
 }
 
 static bool is_gsr_ui_virtual_keyboard_running() {
@@ -140,18 +159,35 @@ 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) {
@@ -172,18 +208,17 @@ 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.
@@ -191,6 +226,9 @@ int main(int argc, char **argv) {
     // 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) {
+        if(launch_action == LaunchAction::LAUNCH_DAEMON)
+            return 1;
+
         gsr::Rpc rpc;
         if(rpc.open("gsr-ui") && rpc.write("show_ui\n", 8)) {
             fprintf(stderr, "Error: another instance of gsr-ui is already running, opening that one instead\n");
@@ -202,6 +240,11 @@ int main(int argc, char **argv) {
         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,
@@ -213,6 +256,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
@@ -230,7 +283,7 @@ int main(int argc, char **argv) {
         disable_prime_run();
     }
 
-    if(mgl_init() != 0) {
+    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");
         exit(1);
     }
@@ -298,10 +351,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,10 @@ 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
+
 ```

tools/gsr-global-hotkeys/keyboard_event.c

@@ -69,7 +69,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 +106,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) {
@@ -120,14 +120,13 @@ static void keyboard_event_process_key_state_change(keyboard_event *self, const
 
 /* Return true if a global hotkey is assigned to the key combination */
 static bool keyboard_event_on_key_pressed(keyboard_event *self, const struct input_event *event, uint32_t modifiers) {
-    if(event->value != KEYBOARD_BUTTON_PRESSED)
-        return false;
-
     bool global_hotkey_match = false;
     for(int i = 0; i < self->num_global_hotkeys; ++i) {
         if(event->code == self->global_hotkeys[i].key && modifiers == self->global_hotkeys[i].modifiers) {
-            puts(self->global_hotkeys[i].action);
-            fflush(stdout);
+            if(event->value == KEYBOARD_BUTTON_PRESSED) {
+                puts(self->global_hotkeys[i].action);
+                fflush(stdout);
+            }
             global_hotkey_match = true;
         }
     }
@@ -155,6 +154,28 @@ static uint32_t keycode_to_modifier_bit(uint32_t keycode) {
     return 0;
 }
 
+/* Returns true if the state changed */
+static bool keyboard_event_set_key_presses_grabbed(const struct input_event *event, event_extra_data *extra_data) {
+    if(event->type != EV_KEY)
+        return false;
+
+    if(!extra_data->key_presses_grabbed || event->code >= KEY_STATES_SIZE * 8)
+        return false;
+
+    const unsigned int byte_index = event->code / 8;
+    const unsigned char bit_index = event->code % 8;
+    unsigned char key_byte_state = extra_data->key_presses_grabbed[byte_index];
+    const bool prev_key_pressed = (key_byte_state & (1 << bit_index)) != KEY_RELEASE;
+    extra_data->key_presses_grabbed[byte_index] = set_bit(key_byte_state, bit_index, event->value >= 1);
+
+    if(event->value == KEY_PRESS)
+        return !prev_key_pressed;
+    else if(event->value == KEY_RELEASE || event->value == KEY_REPEAT)
+        return prev_key_pressed;
+
+    return false;
+}
+
 static void keyboard_event_process_input_event_data(keyboard_event *self, event_extra_data *extra_data, int fd) {
     struct input_event event;
     if(read(fd, &event, sizeof(event)) != sizeof(event)) {
@@ -172,12 +193,18 @@ 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) {
-            if(keyboard_event_on_key_pressed(self, &event, self->modifier_button_states))
-                return;
+            if(keyboard_event_on_key_pressed(self, &event, self->modifier_button_states)) {
+                if(keyboard_event_set_key_presses_grabbed(&event, extra_data))
+                    return;
+            } else if(event.value == KEY_RELEASE) {
+                if(keyboard_event_set_key_presses_grabbed(&event, extra_data))
+                    return;
+            }
         } else {
             self->modifier_button_states = set_bit(self->modifier_button_states, modifier_bit, event.value >= 1);
         }
@@ -188,6 +215,20 @@ static void keyboard_event_process_input_event_data(keyboard_event *self, event_
         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(!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 */
@@ -266,6 +307,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)
@@ -294,14 +375,15 @@ static bool keyboard_event_try_add_device_if_keyboard(keyboard_event *self, cons
         unsigned char key_bits[KEY_MAX/8 + 1] = {0};
         ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(key_bits)), &key_bits);
 
-        const bool supports_key_events      = key_bits[KEY_A/8]        & (1 << (KEY_A % 8));
-        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));
+        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);
+
         if(supports_key_events && (is_virtual_device || (!supports_joystick_events && !supports_wheel_events))) {
             unsigned char *key_states = calloc(1, KEY_STATES_SIZE);
-            if(key_states && self->num_event_polls < MAX_EVENT_POLLS) {
+            unsigned char *key_presses_grabbed = calloc(1, KEY_STATES_SIZE);
+            if(key_states && key_presses_grabbed && self->num_event_polls < MAX_EVENT_POLLS) {
                 //fprintf(stderr, "%s (%s) supports key inputs\n", dev_input_filepath, device_name);
                 self->event_polls[self->num_event_polls] = (struct pollfd) {
                     .fd = fd,
@@ -313,10 +395,12 @@ static bool keyboard_event_try_add_device_if_keyboard(keyboard_event *self, cons
                     .dev_input_id = dev_input_id,
                     .grabbed = false,
                     .key_states = key_states,
+                    .key_presses_grabbed = key_presses_grabbed,
                     .num_keys_pressed = 0
                 };
 
                 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)
@@ -331,6 +415,8 @@ static bool keyboard_event_try_add_device_if_keyboard(keyboard_event *self, cons
                 return true;
             } else {
                 fprintf(stderr, "Warning: the maximum number of keyboard devices have been registered. The newly added keyboard will be ignored\n");
+                free(key_states);
+                free(key_presses_grabbed);
             }
         }
     }
@@ -370,9 +456,12 @@ 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);
+    if(self->event_polls[index].fd > 0) {
+        ioctl(self->event_polls[index].fd, EVIOCGRAB, 0);
+        close(self->event_polls[index].fd);
+    }
     free(self->event_extra_data[index].key_states);
+    free(self->event_extra_data[index].key_presses_grabbed);
 
     for(int i = index + 1; i < self->num_event_polls; ++i) {
         self->event_polls[i - 1] = self->event_polls[i];
@@ -400,19 +489,20 @@ 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_MAX; ++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);
@@ -477,6 +567,7 @@ bool keyboard_event_init(keyboard_event *self, bool exclusive_grab, keyboard_gra
         .dev_input_id = -1,
         .grabbed = false,
         .key_states = NULL,
+        .key_presses_grabbed = NULL,
         .num_keys_pressed = 0
     };
 
@@ -494,6 +585,7 @@ bool keyboard_event_init(keyboard_event *self, bool exclusive_grab, keyboard_gra
             .dev_input_id = -1,
             .grabbed = false,
             .key_states = NULL,
+            .key_presses_grabbed = NULL,
             .num_keys_pressed = 0
         };
 
@@ -529,9 +621,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) {
+            ioctl(self->event_polls[i].fd, EVIOCGRAB, 0);
+            close(self->event_polls[i].fd);
+        }
         free(self->event_extra_data[i].key_states);
+        free(self->event_extra_data[i].key_presses_grabbed);
     }
     self->num_event_polls = 0;
 
@@ -571,6 +666,13 @@ static int parse_u8(const char *str, int size) {
     return result;
 }
 
+static bool is_key_alpha_numerical(uint8_t key) {
+    return (key >= KEY_1 && key <= KEY_0)
+        || (key >= KEY_Q && key <= KEY_P)
+        || (key >= KEY_A && key <= KEY_L)
+        || (key >= KEY_Z && key <= KEY_M);
+}
+
 static bool keyboard_event_parse_bind_keys(const char *str, int size, uint8_t *key, uint32_t *modifiers) {
     *key = 0;
     *modifiers = 0;
@@ -605,13 +707,13 @@ static bool keyboard_event_parse_bind_keys(const char *str, int size, uint8_t *k
             break;
     }
 
-    if(key == 0) {
+    if(*key == 0) {
         fprintf(stderr, "Error: can't bind hotkey without a non-modifier key\n");
         return false;
     }
 
-    if(modifiers == 0) {
-        fprintf(stderr, "Error: can't bind hotkey without a modifier\n");
+    if(*modifiers == 0 && is_key_alpha_numerical(*key)) {
+        fprintf(stderr, "Error: can't bind hotkey without a modifier unless the key is a non alpha-numerical key\n");
         return false;
     }
 
@@ -662,8 +764,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);
     }
 }
 

tools/gsr-global-hotkeys/keyboard_event.h

@@ -39,7 +39,10 @@ typedef enum {
 typedef struct {
     int dev_input_id;
     bool grabbed;
+    bool is_non_keyboard_device;
+    bool is_possibly_non_keyboard_device;
     unsigned char *key_states;
+    unsigned char *key_presses_grabbed;
     int num_keys_pressed;
 } event_extra_data;
 

tools/gsr-ui-cli/main.c

@@ -44,13 +44,26 @@ static void usage(void) {
     printf("Run commands on the running gsr-ui instance.\n");
     printf("\n");
     printf("COMMANDS:\n");
-    printf("  toggle-show      Show/hide the UI.\n");
-    printf("  toggle-record    Start/stop recording.\n");
-    printf("  toggle-pause     Pause/unpause recording. Only applies to regular recording.\n");
-    printf("  toggle-stream    Start/stop streaming.\n");
-    printf("  toggle-replay    Start/stop replay.\n");
-    printf("  replay-save      Save replay.\n");
-    printf("  take-screenshot  Take a screenshot.\n");
+    printf("  toggle-show\n");
+    printf("      Show/hide the UI.\n");
+    printf("  toggle-record\n");
+    printf("      Start/stop recording.\n");
+    printf("  toggle-pause\n");
+    printf("      Pause/unpause recording. Only applies to regular recording.\n");
+    printf("  toggle-stream\n");
+    printf("      Start/stop streaming.\n");
+    printf("  toggle-replay\n");
+    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("\n");
     printf("EXAMPLES:\n");
     printf("  gsr-ui-cli toggle-show\n");
@@ -66,7 +79,10 @@ 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",
         NULL
     };