1.3.1

This reverts commit 3060e3ee00.

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,7 +22,7 @@ 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)
+* x11 (libx11, libxrandr, libxrender, libxcomposite, libxfixes, libxext, libxi)
 * libxcursor
 * libglvnd (which provides libgl, libglx and libegl)
 * linux-api-headers
@@ -38,10 +39,14 @@ This program has to grab all keyboards and create a virtual keyboard (`gsr-ui vi
 This might cause issues for you if you use input remapping software. To workaround this you can go into settings and select "Only grab virtual devices"
 
 # License
-This software is licensed under GPL3.0-only. Files under `fonts/` directory belong to the Noto Sans Google fonts project and they are licensed under `SIL Open Font License`. `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 are 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 +61,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

@@ -105,13 +105,9 @@ 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.
@@ -137,4 +133,21 @@ 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).
+
+Implement focused monitor capture. On nvidia x11 just use the x11 monitor name. On wayland get monitor name from drm cursor. We can get x11 monitor by combining all drm monitors together (with either x11 or wayland monitor position info) and then calculating the x11 monitor at that position.
+    To get the drm monitor from x11 cursor we can get the x11 monitor then get the CONNECTOR_ID property and get the monitor that matches that. Then copy the drm monitor name code from gsr and use that in gsr-ui to get the same name to use as monitor.
+
+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.
+
+Add systray for recording status.
+
+Add a desktop icon when gsr-ui has a window mode option (which should be the default launch option).

include/Config.hpp

@@ -126,6 +126,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/GlobalHotkeysJoystick.hpp

@@ -3,10 +3,8 @@
 #include "GlobalHotkeys.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,12 @@ namespace gsr {
         ~GlobalHotkeysJoystick() override;
 
         bool start();
+        // Currently valid ids:
+        // save_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 +49,17 @@ 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 take_screenshot = false;
+        bool toggle_record = false;
+        bool toggle_replay = false;
+        bool toggle_show = false;
         int hotplug_poll_index = -1;
         Hotplug hotplug;
     };

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,9 @@
 #include "Config.hpp"
 #include "window_texture.h"
 #include "WindowUtils.hpp"
-#include "GlobalHotkeysLinux.hpp"
 #include "GlobalHotkeysJoystick.hpp"
 #include "AudioPlayer.hpp"
+#include "RegionSelector.hpp"
 
 #include <mglpp/window/Window.hpp>
 #include <mglpp/window/Event.hpp>
@@ -59,6 +59,7 @@ namespace gsr {
         void toggle_replay();
         void save_replay();
         void take_screenshot();
+        void take_screenshot_region();
         void show_notification(const char *str, double timeout_seconds, mgl::Color icon_color, mgl::Color bg_color, NotificationType notification_type);
         bool is_open() const;
         bool should_exit(std::string &reason) const;
@@ -78,7 +79,6 @@ 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();
 
@@ -109,10 +109,10 @@ namespace gsr {
         void update_ui_replay_stopped();
 
         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();
+        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);
 
         void force_window_on_top();
@@ -202,5 +202,8 @@ namespace gsr {
         bool try_replay_startup = true;
 
         AudioPlayer audio_player;
+        RegionSelector region_selector;
+        bool start_region_capture = false;
+        std::function<void()> on_region_selected;
     };
 }

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

@@ -43,6 +43,13 @@ namespace gsr {
         mgl::Texture save_texture;
         mgl::Texture screenshot_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;
+
         double double_click_timeout_seconds = 0.4;
 
         // Reloads fonts

include/Utils.hpp

@@ -4,7 +4,6 @@
 #include <string_view>
 #include <map>
 #include <string>
-#include <optional>
 
 namespace gsr {
     struct KeyValue {

include/WindowUtils.hpp

@@ -22,9 +22,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/GlobalSettingsPage.hpp

@@ -26,6 +26,7 @@ namespace gsr {
         RECORD_PAUSE_UNPAUSE,
         STREAM_START_STOP,
         TAKE_SCREENSHOT,
+        TAKE_SCREENSHOT_REGION,
         SHOW_HIDE
     };
 
@@ -58,8 +59,10 @@ namespace gsr {
         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);
@@ -90,6 +93,7 @@ namespace gsr {
         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/SettingsPage.hpp

@@ -64,7 +64,7 @@ namespace gsr {
         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<CheckBox> create_split_audio_checkbox();
         std::unique_ptr<CheckBox> create_application_audio_invert_checkbox();
         std::unique_ptr<Widget> create_audio_track_section();
         std::unique_ptr<Widget> create_audio_section();
@@ -155,7 +155,7 @@ namespace gsr {
         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 *split_audio_checkbox_ptr = nullptr;
         CheckBox *application_audio_invert_checkbox_ptr = nullptr;
         CheckBox *change_video_resolution_checkbox_ptr = nullptr;
         ComboBox *color_range_box_ptr = nullptr;

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);
 }

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.3.1', 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',
@@ -33,6 +34,7 @@ src = [
     'src/gui/Subsection.cpp',
     'src/Utils.cpp',
     'src/WindowUtils.cpp',
+    'src/RegionSelector.cpp',
     'src/Config.cpp',
     'src/GsrInfo.cpp',
     'src/Process.cpp',
@@ -54,7 +56,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.2.0"', language: ['c', 'cpp'])
 
 executable(
     meson.project_name(),
@@ -65,6 +67,7 @@ executable(
         dependency('threads'),
         dependency('xcomposite'),
         dependency('xfixes'),
+        dependency('xext'),
         dependency('xi'),
         dependency('xcursor'),
         dependency('libpulse-simple'),

project.conf

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

src/Config.cpp

@@ -139,7 +139,8 @@ 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};
 
-        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};
     }
@@ -262,7 +263,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}
         };
     }
 

src/GlobalHotkeysJoystick.cpp

@@ -6,7 +6,11 @@
 #include <sys/eventfd.h>
 
 namespace gsr {
-    static constexpr double double_click_timeout_seconds = 0.33;
+    static constexpr int button_pressed = 1;
+    static constexpr int options_button = 9;
+    static constexpr int playstation_button = 10;
+    static constexpr int axis_up_down = 7;
+    static constexpr int axis_left_right = 6;
 
     // Returns -1 on error
     static int get_js_dev_input_id_from_filepath(const char *dev_input_filepath) {
@@ -99,6 +103,34 @@ namespace gsr {
             if(it != bound_actions_by_id.end())
                 it->second("save_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 +185,34 @@ namespace gsr {
         if(read(fd, &event, sizeof(event)) != sizeof(event))
             return;
 
-        if((event.type & JS_EVENT_BUTTON) == 0)
-            return;
+        if((event.type & JS_EVENT_BUTTON) == JS_EVENT_BUTTON) {
+            if(event.number == playstation_button)
+                playstation_button_pressed = event.value == button_pressed;
+            else if(playstation_button_pressed && event.number == options_button && event.value == button_pressed)
+                toggle_show = true;
+        } else if((event.type & JS_EVENT_AXIS) == JS_EVENT_AXIS && playstation_button_pressed) {
+            const int trigger_threshold = 16383;
+            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 == 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(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(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(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/GlobalHotkeysLinux.cpp

@@ -9,6 +9,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 +59,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;
@@ -173,7 +178,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 +190,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/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;
         }
@@ -310,6 +312,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 +327,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/Overlay.cpp

@@ -13,6 +13,7 @@
 #include "../include/gui/PageStack.hpp"
 #include "../include/WindowUtils.hpp"
 #include "../include/GlobalHotkeys.hpp"
+#include "../include/GlobalHotkeysLinux.hpp"
 
 #include <string.h>
 #include <assert.h>
@@ -30,7 +31,7 @@
 #include <X11/cursorfont.h>
 #include <X11/extensions/Xfixes.h>
 #include <X11/extensions/XInput2.h>
-#include <X11/extensions/shape.h>
+#include <X11/extensions/shapeconst.h>
 #include <X11/Xcursor/Xcursor.h>
 #include <mglpp/system/Rect.hpp>
 #include <mglpp/window/Event.hpp>
@@ -203,77 +204,6 @@ namespace gsr {
         return false;
     }*/
 
-    static 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
-
-    static 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;
-    }
-
-    static 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);
-    }
-
-    static Bool make_window_sticky(Display *dpy, Window window) {
-        return set_window_wm_state(dpy, window, XInternAtom(dpy, "_NET_WM_STATE_STICKY", False));
-    }
-
-    static Bool hide_window_from_taskbar(Display *dpy, Window window) {
-        return set_window_wm_state(dpy, window, XInternAtom(dpy, "_NET_WM_STATE_SKIP_TASKBAR", False));
-    }
-
     // Returns the first monitor if not found. Assumes there is at least one monitor connected.
     static const Monitor* find_monitor_at_position(const std::vector<Monitor> &monitors, mgl::vec2i pos) {
         assert(!monitors.empty());
@@ -342,7 +272,7 @@ namespace gsr {
     static void bind_linux_hotkeys(GlobalHotkeysLinux *global_hotkeys, Overlay *overlay) {
         global_hotkeys->bind_key_press(
             config_hotkey_to_hotkey(overlay->get_config().main_config.show_hide_hotkey),
-            "show_hide", [overlay](const std::string &id) {
+            "toggle_show", [overlay](const std::string &id) {
                 fprintf(stderr, "pressed %s\n", id.c_str());
                 overlay->toggle_show();
             });
@@ -388,6 +318,13 @@ namespace gsr {
                 fprintf(stderr, "pressed %s\n", id.c_str());
                 overlay->take_screenshot();
             });
+
+        global_hotkeys->bind_key_press(
+            config_hotkey_to_hotkey(overlay->get_config().screenshot_config.take_screenshot_region_hotkey),
+            "take_screenshot_region", [overlay](const std::string &id) {
+                fprintf(stderr, "pressed %s\n", id.c_str());
+                overlay->take_screenshot_region();
+            });
     }
 
     static std::unique_ptr<GlobalHotkeysLinux> register_linux_hotkeys(Overlay *overlay, GlobalHotkeysLinux::GrabType grab_type) {
@@ -404,11 +341,31 @@ namespace gsr {
         if(!global_hotkeys_js->start())
             fprintf(stderr, "Warning: failed to start joystick hotkeys\n");
 
+        global_hotkeys_js->bind_action("toggle_show", [overlay](const std::string &id) {
+            fprintf(stderr, "pressed %s\n", id.c_str());
+            overlay->toggle_show();
+        });
+
         global_hotkeys_js->bind_action("save_replay", [overlay](const std::string &id) {
             fprintf(stderr, "pressed %s\n", id.c_str());
             overlay->save_replay();
         });
 
+        global_hotkeys_js->bind_action("take_screenshot", [overlay](const std::string &id) {
+            fprintf(stderr, "pressed %s\n", id.c_str());
+            overlay->take_screenshot();
+        });
+
+        global_hotkeys_js->bind_action("toggle_record", [overlay](const std::string &id) {
+            fprintf(stderr, "pressed %s\n", id.c_str());
+            overlay->toggle_record();
+        });
+
+        global_hotkeys_js->bind_action("toggle_replay", [overlay](const std::string &id) {
+            fprintf(stderr, "pressed %s\n", id.c_str());
+            overlay->toggle_replay();
+        });
+
         return global_hotkeys_js;
     }
 
@@ -661,6 +618,13 @@ namespace gsr {
             global_hotkeys_js->poll_events();
 
         handle_keyboard_mapping_event();
+        region_selector.poll_events();
+        if(region_selector.take_canceled()) {
+            on_region_selected = nullptr;
+        } else if(region_selector.take_selection() && on_region_selected) {
+            on_region_selected();
+            on_region_selected = nullptr;
+        }
 
         if(!visible || !window)
             return;
@@ -696,6 +660,20 @@ namespace gsr {
         update_gsr_screenshot_process_status();
         replay_status_update_status();
 
+        if(start_region_capture) {
+            start_region_capture = false;
+            hide();
+            if(!region_selector.start(get_color_theme().tint_color)) {
+                show_notification("Failed to start region capture", notification_error_timeout_seconds, mgl::Color(255, 0, 0, 0), mgl::Color(255, 0, 0, 0), NotificationType::NONE);
+                on_region_selected = nullptr;
+            }
+        }
+
+        if(region_selector.is_started()) {
+            usleep(5 * 1000); // 5 ms
+            return true;
+        }
+
         if(!visible)
             return false;
 
@@ -821,52 +799,13 @@ namespace gsr {
         XcursorImageDestroy(cursor_image);
     }
 
-    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;
-    }
-
-    void Overlay::xi_grab_all_mouse_devices() {
-        if(!xi_display)
-            return;
-
-        int num_devices = 0;
-        XIDeviceInfo *info = XIQueryDevice(xi_display, XIAllDevices, &num_devices);
-        if(!info)
-            return;
-
-        unsigned char mask[XIMaskLen(XI_LASTEVENT)];
-        memset(mask, 0, sizeof(mask));
-        XISetMask(mask, XI_Motion);
-        //XISetMask(mask, XI_RawMotion);
-        XISetMask(mask, XI_ButtonPress);
-        XISetMask(mask, XI_ButtonRelease);
-        XISetMask(mask, XI_KeyPress);
-        XISetMask(mask, XI_KeyRelease);
-
-        for (int i = 0; i < num_devices; ++i) {
-            const XIDeviceInfo *dev = &info[i];
-            if(!device_is_mouse(dev))
-                continue;
-
-            XIEventMask xi_masks;
-            xi_masks.deviceid = dev->deviceid;
-            xi_masks.mask_len = sizeof(mask);
-            xi_masks.mask = mask;
-            XIGrabDevice(xi_display, dev->deviceid, window->get_system_handle(), CurrentTime, None, XIGrabModeAsync, XIGrabModeAsync, XIOwnerEvents, &xi_masks);
-        }
-
-        XFlush(xi_display);
-        XIFreeDeviceInfo(info);
-    }
-
     void Overlay::show() {
         if(visible)
             return;
 
+        if(region_selector.is_started())
+            return;
+
         drawn_first_frame = false;
         window.reset();
         window = std::make_unique<mgl::Window>();
@@ -990,7 +929,7 @@ namespace gsr {
 
         // We want to grab all devices to prevent any other application below the UI from receiving events.
         // Owlboy seems to use xi events and XGrabPointer doesn't prevent owlboy from receiving events.
-        xi_grab_all_mouse_devices();
+        xi_grab_all_mouse_devices(xi_display);
 
         if(!is_wlroots)
             window->set_fullscreen(true);
@@ -1079,7 +1018,7 @@ namespace gsr {
                 } else if(id == "save") {
                     on_press_save_replay();
                 } else if(id == "start") {
-                    on_press_start_replay(false);
+                    on_press_start_replay(false, false);
                 }
             };
             main_buttons_list->add_widget(std::move(button));
@@ -1105,7 +1044,7 @@ namespace gsr {
                 } else if(id == "pause") {
                     toggle_pause();
                 } else if(id == "start") {
-                    on_press_start_record();
+                    on_press_start_record(false);
                 }
             };
             main_buttons_list->add_widget(std::move(button));
@@ -1127,7 +1066,7 @@ namespace gsr {
                     };
                     page_stack.push(std::move(stream_settings_page));
                 } else if(id == "start") {
-                    on_press_start_stream();
+                    on_press_start_stream(false);
                 }
             };
             main_buttons_list->add_widget(std::move(button));
@@ -1217,6 +1156,7 @@ namespace gsr {
             button->set_position((main_buttons_list_ptr->get_position() + main_buttons_size - mgl::vec2f(0.0f, settings_button_size*2) + mgl::vec2f(settings_button_size * 0.333f, 0.0f)).floor());
             button->set_bg_hover_color(mgl::Color(0, 0, 0, 255));
             button->set_icon(&get_theme().screenshot_texture);
+            button->set_icon_padding_scale(1.2f);
             button->on_click = [&]() {
                 auto screenshot_settings_page = std::make_unique<ScreenshotSettingsPage>(&gsr_info, config, &page_stack);
                 page_stack.push(std::move(screenshot_settings_page));
@@ -1284,6 +1224,7 @@ namespace gsr {
 
         visible = false;
         drawn_first_frame = false;
+        start_region_capture = false;
 
         if(xi_input_xev) {
             free(xi_input_xev);
@@ -1296,20 +1237,21 @@ namespace gsr {
         }
 
         if(xi_display) {
-            XCloseDisplay(xi_display);
-            xi_display = nullptr;
-
             if(window) {
                 mgl_context *context = mgl_get_context();
                 Display *display = (Display*)context->connection;
 
                 const mgl::vec2i new_cursor_position = mgl::vec2i(window->internal_window()->pos.x, window->internal_window()->pos.y) + window->get_mouse_position();
                 XWarpPointer(display, DefaultRootWindow(display), DefaultRootWindow(display), 0, 0, 0, 0, new_cursor_position.x, new_cursor_position.y);
+                xi_warp_all_mouse_devices(xi_display, new_cursor_position);
                 XFlush(display);
 
                 XFixesShowCursor(display, DefaultRootWindow(display));
                 XFlush(display);
             }
+
+            XCloseDisplay(xi_display);
+            xi_display = nullptr;
         }
 
         if(window) {
@@ -1345,7 +1287,7 @@ namespace gsr {
     }
 
     void Overlay::toggle_record() {
-        on_press_start_record();
+        on_press_start_record(false);
     }
 
     void Overlay::toggle_pause() {
@@ -1365,11 +1307,11 @@ namespace gsr {
     }
 
     void Overlay::toggle_stream() {
-        on_press_start_stream();
+        on_press_start_stream(false);
     }
 
     void Overlay::toggle_replay() {
-        on_press_start_replay(false);
+        on_press_start_replay(false, false);
     }
 
     void Overlay::save_replay() {
@@ -1377,7 +1319,11 @@ namespace gsr {
     }
 
     void Overlay::take_screenshot() {
-        on_press_take_screenshot();
+        on_press_take_screenshot(false, false);
+    }
+
+    void Overlay::take_screenshot_region() {
+        on_press_take_screenshot(false, true);
     }
 
     static const char* notification_type_to_string(NotificationType notification_type) {
@@ -1711,9 +1657,9 @@ namespace gsr {
         if(focused_window_is_fullscreen != prev_focused_window_is_fullscreen) {
             if(recording_status == RecordingStatus::NONE && focused_window_is_fullscreen) {
                 if(are_all_audio_tracks_available_to_capture(config.replay_config.record_options.audio_tracks))
-                    on_press_start_replay(false);
+                    on_press_start_replay(false, false);
             } else if(recording_status == RecordingStatus::REPLAY && !focused_window_is_fullscreen) {
-                on_press_start_replay(true);
+                on_press_start_replay(true, false);
             }
         }
     }
@@ -1728,9 +1674,9 @@ namespace gsr {
         if(power_supply_connected != prev_power_supply_status) {
             if(recording_status == RecordingStatus::NONE && power_supply_connected) {
                 if(are_all_audio_tracks_available_to_capture(config.replay_config.record_options.audio_tracks))
-                    on_press_start_replay(false);
+                    on_press_start_replay(false, false);
             } else if(recording_status == RecordingStatus::REPLAY && !power_supply_connected) {
-                on_press_start_replay(false);
+                on_press_start_replay(false, false);
             }
         }
     }
@@ -1740,7 +1686,7 @@ namespace gsr {
             return;
 
         if(are_all_audio_tracks_available_to_capture(config.replay_config.record_options.audio_tracks))
-            on_press_start_replay(true);
+            on_press_start_replay(true, false);
     }
 
     void Overlay::on_stop_recording(int exit_code) {
@@ -1884,7 +1830,18 @@ namespace gsr {
         return result;
     }
 
-    static void add_common_gpu_screen_recorder_args(std::vector<const char*> &args, const RecordOptions &record_options, const std::vector<std::string> &audio_tracks, const std::string &video_bitrate, const char *region, const std::string &audio_devices_merged) {
+    static void add_region_command(std::vector<const char*> &args, char *region_str, int region_str_size, const RegionSelector &region_selector) {
+        Region region = region_selector.get_selection();
+        if(region.size.x <= 32 && region.size.y <= 32) {
+            region.size.x = 0;
+            region.size.y = 0;
+        }
+        snprintf(region_str, region_str_size, "%dx%d+%d+%d", region.size.x, region.size.y, region.pos.x, region.pos.y);
+        args.push_back("-region");
+        args.push_back(region_str);
+    }
+
+    static void add_common_gpu_screen_recorder_args(std::vector<const char*> &args, const RecordOptions &record_options, const std::vector<std::string> &audio_tracks, const std::string &video_bitrate, const char *region, const std::string &audio_devices_merged, char *region_str, int region_str_size, const RegionSelector &region_selector) {
         if(record_options.video_quality == "custom") {
             args.push_back("-bm");
             args.push_back("cbr");
@@ -1916,12 +1873,17 @@ namespace gsr {
             args.push_back("-restore-portal-session");
             args.push_back("yes");
         }
+
+        if(record_options.record_area_option == "region")
+            add_region_command(args, region_str, region_str_size, region_selector);
     }
 
     static bool validate_capture_target(const GsrInfo &gsr_info, const std::string &capture_target) {
         const SupportedCaptureOptions capture_options = get_supported_capture_options(gsr_info);
         // TODO: Also check x11 window when enabled (check if capture_target is a decminal/hex number)
-        if(capture_target == "focused") {
+        if(capture_target == "region") {
+            return capture_options.region;
+        } else if(capture_target == "focused") {
             return capture_options.focused;
         } else if(capture_target == "portal") {
             return capture_options.portal;
@@ -1943,7 +1905,10 @@ namespace gsr {
         kill(gpu_screen_recorder_process, SIGUSR1);
     }
 
-    bool Overlay::on_press_start_replay(bool disable_notification) {
+    bool Overlay::on_press_start_replay(bool disable_notification, bool finished_region_selection) {
+        if(region_selector.is_started())
+            return false;
+
         switch(recording_status) {
             case RecordingStatus::NONE:
             case RecordingStatus::REPLAY:
@@ -1991,6 +1956,14 @@ namespace gsr {
             return false;
         }
 
+        if(config.replay_config.record_options.record_area_option == "region" && !finished_region_selection) {
+            start_region_capture = true;
+            on_region_selected = [disable_notification, this]() {
+                on_press_start_replay(disable_notification, true);
+            };
+            return false;
+        }
+
         // TODO: Validate input, fallback to valid values
         const std::string fps = std::to_string(config.replay_config.record_options.fps);
         const std::string video_bitrate = std::to_string(config.replay_config.record_options.video_bitrate);
@@ -2006,13 +1979,13 @@ namespace gsr {
             encoder = "cpu";
         }
 
-        char region[64];
-        region[0] = '\0';
+        char size[64];
+        size[0] = '\0';
         if(config.replay_config.record_options.record_area_option == "focused")
-            snprintf(region, sizeof(region), "%dx%d", (int)config.replay_config.record_options.record_area_width, (int)config.replay_config.record_options.record_area_height);
+            snprintf(size, sizeof(size), "%dx%d", (int)config.replay_config.record_options.record_area_width, (int)config.replay_config.record_options.record_area_height);
 
         if(config.replay_config.record_options.record_area_option != "focused" && config.replay_config.record_options.change_video_resolution)
-            snprintf(region, sizeof(region), "%dx%d", (int)config.replay_config.record_options.video_width, (int)config.replay_config.record_options.video_height);
+            snprintf(size, sizeof(size), "%dx%d", (int)config.replay_config.record_options.video_width, (int)config.replay_config.record_options.video_height);
 
         std::vector<const char*> args = {
             "gpu-screen-recorder", "-w", config.replay_config.record_options.record_area_option.c_str(),
@@ -2034,7 +2007,8 @@ namespace gsr {
             args.push_back("yes");
         }
 
-        add_common_gpu_screen_recorder_args(args, config.replay_config.record_options, audio_tracks, video_bitrate, region, audio_tracks_merged);
+        char region_str[128];
+        add_common_gpu_screen_recorder_args(args, config.replay_config.record_options, audio_tracks, video_bitrate, size, audio_tracks_merged, region_str, sizeof(region_str), region_selector);
 
         args.push_back(nullptr);
 
@@ -2067,7 +2041,10 @@ namespace gsr {
         return true;
     }
 
-    void Overlay::on_press_start_record() {
+    void Overlay::on_press_start_record(bool finished_region_selection) {
+        if(region_selector.is_started())
+            return;
+
         switch(recording_status) {
             case RecordingStatus::NONE:
             case RecordingStatus::RECORD:
@@ -2112,6 +2089,14 @@ namespace gsr {
             return;
         }
 
+        if(config.record_config.record_options.record_area_option == "region" && !finished_region_selection) {
+            start_region_capture = true;
+            on_region_selected = [this]() {
+                on_press_start_record(true);
+            };
+            return;
+        }
+
         record_filepath.clear();
 
         // TODO: Validate input, fallback to valid values
@@ -2128,13 +2113,13 @@ namespace gsr {
             encoder = "cpu";
         }
 
-        char region[64];
-        region[0] = '\0';
+        char size[64];
+        size[0] = '\0';
         if(config.record_config.record_options.record_area_option == "focused")
-            snprintf(region, sizeof(region), "%dx%d", (int)config.record_config.record_options.record_area_width, (int)config.record_config.record_options.record_area_height);
+            snprintf(size, sizeof(size), "%dx%d", (int)config.record_config.record_options.record_area_width, (int)config.record_config.record_options.record_area_height);
 
         if(config.record_config.record_options.record_area_option != "focused" && config.record_config.record_options.change_video_resolution)
-            snprintf(region, sizeof(region), "%dx%d", (int)config.record_config.record_options.video_width, (int)config.record_config.record_options.video_height);
+            snprintf(size, sizeof(size), "%dx%d", (int)config.record_config.record_options.video_width, (int)config.record_config.record_options.video_height);
 
         std::vector<const char*> args = {
             "gpu-screen-recorder", "-w", config.record_config.record_options.record_area_option.c_str(),
@@ -2150,7 +2135,8 @@ namespace gsr {
             "-o", output_file.c_str()
         };
 
-        add_common_gpu_screen_recorder_args(args, config.record_config.record_options, audio_tracks, video_bitrate, region, audio_tracks_merged);
+        char region_str[128];
+        add_common_gpu_screen_recorder_args(args, config.record_config.record_options, audio_tracks, video_bitrate, size, audio_tracks_merged, region_str, sizeof(region_str), region_selector);
 
         args.push_back(nullptr);
 
@@ -2205,7 +2191,10 @@ namespace gsr {
         return url;
     }
 
-    void Overlay::on_press_start_stream() {
+    void Overlay::on_press_start_stream(bool finished_region_selection) {
+        if(region_selector.is_started())
+            return;
+
         switch(recording_status) {
             case RecordingStatus::NONE:
             case RecordingStatus::STREAM:
@@ -2248,6 +2237,14 @@ namespace gsr {
             return;
         }
 
+        if(config.streaming_config.record_options.record_area_option == "region" && !finished_region_selection) {
+            start_region_capture = true;
+            on_region_selected = [this]() {
+                on_press_start_stream(true);
+            };
+            return;
+        }
+
         // TODO: Validate input, fallback to valid values
         const std::string fps = std::to_string(config.streaming_config.record_options.fps);
         const std::string video_bitrate = std::to_string(config.streaming_config.record_options.video_bitrate);
@@ -2267,13 +2264,13 @@ namespace gsr {
 
         const std::string url = streaming_get_url(config);
 
-        char region[64];
-        region[0] = '\0';
+        char size[64];
+        size[0] = '\0';
         if(config.record_config.record_options.record_area_option == "focused")
-            snprintf(region, sizeof(region), "%dx%d", (int)config.streaming_config.record_options.record_area_width, (int)config.streaming_config.record_options.record_area_height);
+            snprintf(size, sizeof(size), "%dx%d", (int)config.streaming_config.record_options.record_area_width, (int)config.streaming_config.record_options.record_area_height);
 
         if(config.record_config.record_options.record_area_option != "focused" && config.streaming_config.record_options.change_video_resolution)
-            snprintf(region, sizeof(region), "%dx%d", (int)config.streaming_config.record_options.video_width, (int)config.streaming_config.record_options.video_height);
+            snprintf(size, sizeof(size), "%dx%d", (int)config.streaming_config.record_options.video_width, (int)config.streaming_config.record_options.video_height);
 
         std::vector<const char*> args = {
             "gpu-screen-recorder", "-w", config.streaming_config.record_options.record_area_option.c_str(),
@@ -2289,7 +2286,8 @@ namespace gsr {
         };
 
         config.streaming_config.record_options.merge_audio_tracks = true;
-        add_common_gpu_screen_recorder_args(args, config.streaming_config.record_options, audio_tracks, video_bitrate, region, audio_tracks_merged);
+        char region_str[128];
+        add_common_gpu_screen_recorder_args(args, config.streaming_config.record_options, audio_tracks, video_bitrate, size, audio_tracks_merged, region_str, sizeof(region_str), region_selector);
 
         args.push_back(nullptr);
 
@@ -2314,36 +2312,50 @@ namespace gsr {
             show_notification("Streaming has started", notification_timeout_seconds, get_color_theme().tint_color, get_color_theme().tint_color, NotificationType::STREAM);
     }
 
-    void Overlay::on_press_take_screenshot() {
+    void Overlay::on_press_take_screenshot(bool finished_region_selection, bool force_region_capture) {
+        if(region_selector.is_started())
+            return;
+
         if(gpu_screen_recorder_screenshot_process > 0) {
             fprintf(stderr, "Error: failed to take screenshot, another screenshot is currently being saved\n");
             return;
         }
 
-        if(!validate_capture_target(gsr_info, config.screenshot_config.record_area_option)) {
+        const bool region_capture = config.screenshot_config.record_area_option == "region" || force_region_capture;
+        const char *record_area_option = region_capture ? "region" : config.screenshot_config.record_area_option.c_str();
+        if(!validate_capture_target(gsr_info, record_area_option)) {
             char err_msg[256];
-            snprintf(err_msg, sizeof(err_msg), "Failed to take a screenshot, capture target \"%s\" is invalid. Please change capture target in settings", config.screenshot_config.record_area_option.c_str());
+            snprintf(err_msg, sizeof(err_msg), "Failed to take a screenshot, capture target \"%s\" is invalid. Please change capture target in settings", record_area_option);
             show_notification(err_msg, notification_error_timeout_seconds, mgl::Color(255, 0, 0, 0), mgl::Color(255, 0, 0, 0), NotificationType::SCREENSHOT);
             return;
         }
 
+        if(region_capture && !finished_region_selection) {
+            start_region_capture = true;
+            on_region_selected = [this, force_region_capture]() {
+                usleep(200 * 1000); // Hack: wait 0.2 seconds before taking a screenshot to allow user to move cursor away. TODO: Remove this
+                on_press_take_screenshot(true, force_region_capture);
+            };
+            return;
+        }
+
         // TODO: Validate input, fallback to valid values
         const std::string output_file = config.screenshot_config.save_directory + "/Screenshot_" + get_date_str() + "." + config.screenshot_config.image_format; // TODO: Validate image format
 
         std::vector<const char*> args = {
-            "gpu-screen-recorder", "-w", config.screenshot_config.record_area_option.c_str(),
+            "gpu-screen-recorder", "-w", record_area_option,
             "-cursor", config.screenshot_config.record_cursor ? "yes" : "no",
             "-v", "no",
             "-q", config.screenshot_config.image_quality.c_str(),
             "-o", output_file.c_str()
         };
 
-        char region[64];
-        region[0] = '\0';
+        char size[64];
+        size[0] = '\0';
         if(config.screenshot_config.change_image_resolution) {
-            snprintf(region, sizeof(region), "%dx%d", (int)config.screenshot_config.image_width, (int)config.screenshot_config.image_height);
+            snprintf(size, sizeof(size), "%dx%d", (int)config.screenshot_config.image_width, (int)config.screenshot_config.image_height);
             args.push_back("-s");
-            args.push_back(region);
+            args.push_back(size);
         }
 
         if(config.screenshot_config.restore_portal_session) {
@@ -2351,6 +2363,10 @@ namespace gsr {
             args.push_back("yes");
         }
 
+        char region_str[128];
+        if(region_capture)
+            add_region_command(args, region_str, sizeof(region_str), region_selector);
+
         args.push_back(nullptr);
 
         screenshot_filepath = output_file;

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);
     }
 
@@ -111,6 +114,24 @@ namespace gsr {
         if(!theme->screenshot_texture.load_from_file((resources_path + "images/screenshot.png").c_str()))
             goto error;
 
+        if(!theme->ps4_home_texture.load_from_file((resources_path + "images/ps4_home.png").c_str(), mgl::Texture::LoadOptions{false, false, true}))
+            goto error;
+
+        if(!theme->ps4_options_texture.load_from_file((resources_path + "images/ps4_options.png").c_str(), mgl::Texture::LoadOptions{false, false, true}))
+            goto error;
+
+        if(!theme->ps4_dpad_up_texture.load_from_file((resources_path + "images/ps4_dpad_up.png").c_str(), mgl::Texture::LoadOptions{false, false, true}))
+            goto error;
+
+        if(!theme->ps4_dpad_down_texture.load_from_file((resources_path + "images/ps4_dpad_down.png").c_str(), mgl::Texture::LoadOptions{false, false, true}))
+            goto error;
+        
+        if(!theme->ps4_dpad_left_texture.load_from_file((resources_path + "images/ps4_dpad_left.png").c_str(), mgl::Texture::LoadOptions{false, false, true}))
+            goto error;
+
+        if(!theme->ps4_dpad_right_texture.load_from_file((resources_path + "images/ps4_dpad_right.png").c_str(), mgl::Texture::LoadOptions{false, false, true}))
+            goto error;
+
         return true;
 
         error:

src/WindowUtils.cpp

@@ -1,8 +1,10 @@
 #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 <mglpp/system/Utf8.hpp>
 
@@ -301,6 +303,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 +365,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 +419,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);
@@ -531,4 +528,172 @@ namespace gsr {
         mgl_for_each_active_monitor_output(dpy, get_monitors_callback, &monitors);
         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

@@ -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

@@ -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/GlobalSettingsPage.cpp

@@ -10,6 +10,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 +35,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 +70,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 +101,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 +118,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 +135,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);
@@ -297,6 +310,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);
 
@@ -308,6 +336,7 @@ namespace gsr {
             config.replay_config.start_stop_hotkey = {mgl::Keyboard::Unknown, 0};
             config.replay_config.save_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 +354,50 @@ 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_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"));
+        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 +455,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));
@@ -443,6 +497,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 +535,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();
@@ -520,6 +575,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;
         }
@@ -542,6 +599,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 +615,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) {
@@ -595,6 +655,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/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/ScreenshotSettingsPage.cpp

@@ -38,6 +38,8 @@ 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");
         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);

src/gui/SettingsPage.cpp

@@ -66,6 +66,8 @@ 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");
         for(const auto &monitor : capture_options.monitors) {
@@ -284,11 +286,11 @@ namespace gsr {
         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_split_audio_checkbox() {
+        auto split_audio_checkbox = std::make_unique<CheckBox>(&get_theme().body_font, "Split each device/app audio into separate audio tracks");
+        split_audio_checkbox->set_checked(false);
+        split_audio_checkbox_ptr = split_audio_checkbox.get();
+        return split_audio_checkbox;
     }
 
     std::unique_ptr<CheckBox> SettingsPage::create_application_audio_invert_checkbox() {
@@ -309,7 +311,7 @@ namespace gsr {
         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_split_audio_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));
@@ -351,14 +353,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 +370,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;
@@ -758,6 +760,7 @@ namespace gsr {
             video_codec_ptr->set_visible(advanced_view);
             framerate_mode_list_ptr->set_visible(advanced_view);
             notifications_subsection_ptr->set_visible(advanced_view);
+            split_audio_checkbox_ptr->set_visible(advanced_view);
             settings_scrollable_page_ptr->reset_scroll();
             return true;
         };
@@ -831,6 +834,7 @@ namespace gsr {
             video_codec_ptr->set_visible(advanced_view);
             framerate_mode_list_ptr->set_visible(advanced_view);
             notifications_subsection_ptr->set_visible(advanced_view);
+            split_audio_checkbox_ptr->set_visible(advanced_view);
             settings_scrollable_page_ptr->reset_scroll();
             return true;
         };
@@ -1041,8 +1045,8 @@ namespace gsr {
 
     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);
+        if(split_audio_checkbox_ptr)
+            split_audio_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);
@@ -1167,8 +1171,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();
+        if(split_audio_checkbox_ptr)
+            record_options.merge_audio_tracks = !split_audio_checkbox_ptr->is_checked();
         record_options.application_audio_invert = application_audio_invert_checkbox_ptr->is_checked();
         record_options.change_video_resolution = change_video_resolution_checkbox_ptr->is_checked();
         save_audio_tracks(record_options.audio_tracks, audio_track_list_ptr);

src/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/main.cpp

@@ -78,6 +78,11 @@ static void rpc_add_commands(gsr::Rpc *rpc, gsr::Overlay *overlay) {
         fprintf(stderr, "rpc command executed: %s\n", name.c_str());
         overlay->take_screenshot();
     });
+
+    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() {

tools/gsr-global-hotkeys/keyboard_event.c

@@ -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)) {
@@ -176,8 +197,13 @@ static void keyboard_event_process_input_event_data(keyboard_event *self, event_
         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);
         }
@@ -294,14 +320,19 @@ 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_key_a           = key_bits[KEY_A/8]        & (1 << (KEY_A % 8));
+        const bool supports_key_esc         = key_bits[KEY_ESC/8]      & (1 << (KEY_ESC % 8));
+        const bool supports_key_volume_up   = key_bits[KEY_VOLUMEUP/8] & (1 << (KEY_VOLUMEUP % 8));
+        const bool supports_key_events = supports_key_a || supports_key_esc || supports_key_volume_up;
+
         const bool supports_mouse_events    = key_bits[BTN_MOUSE/8]    & (1 << (BTN_MOUSE % 8));
         //const bool supports_touch_events    = key_bits[BTN_TOUCH/8]    & (1 << (BTN_TOUCH % 8));
         const bool supports_joystick_events = key_bits[BTN_JOYSTICK/8] & (1 << (BTN_JOYSTICK % 8));
         const bool supports_wheel_events    = key_bits[BTN_WHEEL/8]    & (1 << (BTN_WHEEL % 8));
         if(supports_key_events && (is_virtual_device || (!supports_joystick_events && !supports_wheel_events))) {
             unsigned char *key_states = calloc(1, KEY_STATES_SIZE);
-            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,6 +344,7 @@ 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
                 };
 
@@ -331,6 +363,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);
             }
         }
     }
@@ -373,6 +407,7 @@ static void keyboard_event_remove_event(keyboard_event *self, int index) {
     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];
@@ -477,6 +512,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 +530,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
         };
 
@@ -532,6 +569,7 @@ void keyboard_event_deinit(keyboard_event *self) {
         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 +609,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 +650,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;
     }
 

tools/gsr-global-hotkeys/keyboard_event.h

@@ -40,6 +40,7 @@ typedef struct {
     int dev_input_id;
     bool grabbed;
     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,22 @@ 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("  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");
@@ -67,6 +76,7 @@ static bool is_valid_command(const char *command) {
         "toggle-replay",
         "replay-save",
         "take-screenshot",
+        "take-screenshot-region",
         NULL
     };