1.9.3 - Only use led indicator if it's enabled

1.9.3
Fix high cpu usage when running global hotkeys without grab and then connecting a secondary keyboard
2026-04-05 11:16:28 +09:00 · 2026-01-08 20:40:11 +01:00 · 2026-01-08 20:23:39 +01:00 · 2026-01-08 20:23:21 +01:00 · 2026-01-08 01:25:08 +01:00 · 2026-01-06 22:17:54 +01:00
49 changed files with 1822 additions and 350 deletions
--- a/README.md
+++ b/README.md
@@ -37,14 +37,14 @@ There are also additional dependencies needed at runtime:
 * [GPU Screen Recorder Notification](https://git.dec05eba.com/gpu-screen-recorder-notification/)

 ## Program behavior notes
-This program has to grab all keyboards and create a virtual keyboard (`gsr-ui virtual keyboard`) to make global hotkeys work on all Wayland compositors.\
-This might cause issues for you if you use keyboard remapping software. To workaround this you can go into settings and select "Only grab virtual devices".\
+By default this program has to grab all keyboards and creates a virtual keyboard (`gsr-ui virtual keyboard`) to make global hotkeys work on all Wayland compositors.\
+This might cause issues for you if you use keyboard remapping software. To workaround this you can go into settings and select "Yes, but only grab virtual devices" or "Yes, but don't grab devices".\
 If you use keyboard remapping software such as keyd then make sure to make it ignore "gsr-ui virtual keyboard" (dec0:5eba device id), otherwise your keyboard can get locked
 as gpu screen recorder tries to grab keys and keyd grabs gpu screen recorder, leading to a lock.\
 If you are stuck in such a lock where you cant press and keyboard keys you can press (left) ctrl+shift+alt+esc to close gpu screen recorder and remove it from system startup.

 # License
-This software is licensed under GPL3.0-only. Files under `fonts/` directory belong to the Noto Sans Google fonts project and they are licensed under `SIL Open Font License`.\
+This software is licensed under GPL-3.0-only, see the LICENSE file for more information. Files under `fonts/` directory belong to the Noto Sans Google fonts project and they are licensed under `SIL Open Font License`.\
 `images/default.cur` it part of the [Adwaita icon theme](https://gitlab.gnome.org/GNOME/adwaita-icon-theme/-/tree/master) which is licensed under `CC BY-SA 3.0`.\
 The controller buttons under `images/` were created by [Julio Cacko](https://juliocacko.itch.io/free-input-prompts) and they are licensed under `CC0 1.0 Universal`.\
 The PlayStation logo under `images/` was created by [ArksDigital](https://arks.itch.io/ps4-buttons) and it's licensed under `CC BY 4.0`.
@@ -71,3 +71,8 @@ I'm looking for somebody that can create sound effects for the notifications.
 If you have previously used the flatpak version of GPU Screen Recorder with the new UI then the non-flatpak version of the systemd service will conflict with that. Run `gsr-ui` to fix that.
 ## I use a non-qwerty keyboard layout and I have an issue with incorrect keys registered in the software
 This is a KDE Plasma Wayland issue. Use `setxkbmap <language>` command, for example `setxkbmap se` to make sure X11 applications (such as this one) gets updated to use your languages keyboard layout.
+## "Save to clipboard" option doesn't work for screenshots
+Some Wayland compositors don't support copying images on the clipboard between X11 and Wayland applications. GPU Screen Recorder UI is an X11 application. It can't be done properly on Wayland
+since Wayland doesn't support a non-focused application from setting the clipboard, so it can't work with GPU Screen Recorder hotkey usage. Use X11 if you want a functioning desktop.
+## The controller hotkey and steam overlap (home button brings up steam overlay)
+You can either disable the steam overlay or in steam click Steam->Settings->Controller and then click "Begin Test" under "Test Device Inputs". Click on "Setup Device Inputs" and configure controller buttons there and when you get to the home button press X to unbind it from steam.
--- a/37
+++ b/37
@@ -84,9 +84,6 @@ Dont put widget position to int position when scrolling. This makes the UI jitte

 Show warning if another instance of gpu screen recorder is already running when starting recording?

-Keyboard leds get turned off when stopping gsr-global-hotkeys (for example numlock). The numlock key has to be pressed twice again to make it look correct to match its state.
-    Fix this by writing 0 or 1 to /sys/class/leds/input2::numlock/brightness.
-
 Make gsr-ui flatpak systemd work nicely with non-flatpak gsr-ui. Maybe change ExecStart to do flatpak run ... || gsr-ui, but make it run as a shell command first with /bin/sh -c "".

 When enabling X11 global hotkey again only grab lalt, not ralt.
@@ -130,8 +127,6 @@ Add option to do screen-direct recording. But make it clear that it should not b

 Add systray for recording status.

-Add a desktop icon when gsr-ui has a window mode option (which should be the default launch option).
-
 Verify if cursor tracker monitor name is always correct. It uses the wayland monitor name for recording, but gpu screen recorder uses a custom name created from the drm connector name.

 Notification with the focused monitor (with CursorTrackerWayland) assumes that the x11 monitor name is the same as the drm monitor name. Same for find_monitor_by_name.
@@ -216,8 +211,6 @@ The UI is unusable on a vertical monitor.

 Steam overlay interfers with controller input in gsr ui. Maybe move controller handling the gsr-global-hotkeys to do a grab on the controller, to only give the key input to gsr ui.

-Add option to show recording status with scroll lock led (use x11 xkb). Blink when starting/stopping recording and set led on when recording is running and set led off when not recording.
-
 For joysticks (gamepads) create a virtual device for each one (/dev/uinput) that has the same vendor, product and name. This is to make sure that it behaves the same way in applications since applications
    access joysticks directly through /dev/input/eventN or /dev/input/jsN. It needs the same number of buttons and pretend to be a controller of the same time, for example a ps4 controller
    so that games automatically display ps4 buttons if supported.
@@ -231,4 +224,32 @@ Add option to include game name in file name (video and screenshot). Replace / w

 Check if the focused window is on top on x11 when choosing to take screenshot or show the window as the background of the overlay.

-Convert clipboard image to requested type (from jpg to png for example).
+Convert clipboard image to requested type (from jpg to png for example).
+
+Save clipboard image with wayland on wayland. Some wayland compositors (such as hyprland, budgie and maybe more (wlroots based ones?)) don't support copying clipboard image data from x11 applications to wayland applications.
+    This can be done because retarded wayland only supports setting clipboard when the application has focus. This doesn't work with hotkey screenshot use.
+    This is specifically an issue when using wl_data_device_manager, which is a standard protocol. It can be done when using wlr specific protocol.
+
+When gsr supports pausing recording done in replay/streaming session then add support for that in gsr-ui as well.
+
+Add recording timer when recording to show for how long we have been recording for. Maybe the same for live streaming and replay.
+
+Add option to trim video in the ui. Show a list of all videos recorded so you dont have to navigate to them (maybe add option to manually navigate to a video as well). Maybe use mpv to view it (embedded) in the ui and trim regions (multiple) and ffmpeg command to trim it.
+
+Show the currently recorded capture in the ui, to preview if everything looks ok. This is also good for webcam overlay. Do this when gsr supports rpc, which would also include an option to get a fd to the capture texture.
+
+Show a question mark beside options. When hovering the question mark show a tooltip that explains the options.
+
+Remove all mgl::Clock usage in Overlay. We only need to get the time once per update in Overlay::handle_events. Also get time in other places outside handle_events.
+
+Handle stopping replay/stream when recording is running (show notification that the video is saved and move the video to folder with game name).
+
+Support translations.
+
+Sometimes when opening gpu screen recorder ui gsr-global-hotkeys incorrectly detects that keyboard input is locked.
+
+When running replay for a long time and then stopping it it takes a while. Improve this.
+
+When adding webcamera make replay auto start wait for camera to be available (when /dev/video device exists and can be initialized), just like audio device.
+
+Make it possible to resize webcam box from top left, top right and bottom left as well.
--- a/depends/mglpp
+++ b/depends/mglpp
--- a/gpu-screen-recorder.desktop
+++ b/gpu-screen-recorder.desktop
@@ -0,0 +1,10 @@
+[Desktop Entry]
+Type=Application
+Name=GPU Screen Recorder
+GenericName=Screen recorder
+Comment=A ShadowPlay-like screen recorder for Linux
+Icon=gpu-screen-recorder
+Exec=gsr-ui launch-hide-announce
+Terminal=false
+Keywords=gpu-screen-recorder;gsr-ui;screen recorder;streaming;twitch;replay;shadowplay;
+Categories=AudioVideo;Recorder;
--- a/icons/hicolor/128x128/apps/gpu-screen-recorder.png
+++ b/icons/hicolor/128x128/apps/gpu-screen-recorder.png
--- a/icons/hicolor/32x32/apps/gpu-screen-recorder.png
+++ b/icons/hicolor/32x32/apps/gpu-screen-recorder.png
--- a/icons/hicolor/64x64/apps/gpu-screen-recorder.png
+++ b/icons/hicolor/64x64/apps/gpu-screen-recorder.png
--- a/include/Config.hpp
+++ b/include/Config.hpp
@@ -60,11 +60,23 @@ namespace gsr {
        bool overclock = false;
        bool record_cursor = true;
        bool restore_portal_session = true;
+
+        std::string webcam_source = "";
+        bool webcam_flip_horizontally = false;
+        std::string webcam_video_format = "auto";
+        int32_t webcam_x = 0; // A value between 0 and 100 (percentage)
+        int32_t webcam_y = 0; // A value between 0 and 100 (percentage)
+        int32_t webcam_width = 30; // A value between 0 and 100 (percentage), 0 = Don't scale it
+        int32_t webcam_height = 30; // A value between 0 and 100 (percentage), 0 = Don't scale it
+
+        bool show_notifications = true;
+        bool use_led_indicator = false;
    };

    struct MainConfig {
        int32_t config_file_version = GSR_CONFIG_FILE_VERSION;
        bool software_encoding_warning_shown = false;
+        bool wayland_warning_shown = false;
        std::string hotkeys_enable_option = "enable_hotkeys";
        std::string joystick_hotkeys_enable_option = "disable_hotkeys";
        std::string tint_color;
@@ -92,8 +104,6 @@ namespace gsr {

    struct StreamingConfig {
        RecordOptions record_options;
-        bool show_streaming_started_notifications = true;
-        bool show_streaming_stopped_notifications = true;
        std::string streaming_service = "twitch";
        YoutubeStreamConfig youtube;
        TwitchStreamConfig twitch;
@@ -105,9 +115,6 @@ namespace gsr {
    struct RecordConfig {
        RecordOptions record_options;
        bool save_video_in_game_folder = false;
-        bool show_recording_started_notifications = true;
-        bool show_video_saved_notifications = true;
-        bool show_video_paused_notifications = true;
        std::string save_directory;
        std::string container = "mp4";
        ConfigHotkey start_stop_hotkey;
@@ -119,9 +126,6 @@ namespace gsr {
        std::string turn_on_replay_automatically_mode = "dont_turn_on_automatically";
        bool save_video_in_game_folder = false;
        bool restart_replay_on_save = false;
-        bool show_replay_started_notifications = true;
-        bool show_replay_stopped_notifications = true;
-        bool show_replay_saved_notifications = true;
        std::string save_directory;
        std::string container = "mp4";
        int32_t replay_time = 60;
@@ -144,11 +148,15 @@ namespace gsr {

        bool save_screenshot_in_game_folder = false;
        bool save_screenshot_to_clipboard = false;
-        bool show_screenshot_saved_notifications = true;
+        bool save_screenshot_to_disk = true;
+        bool show_notifications = true;
+        bool use_led_indicator = false;
        std::string save_directory;
        ConfigHotkey take_screenshot_hotkey;
        ConfigHotkey take_screenshot_region_hotkey;
        ConfigHotkey take_screenshot_window_hotkey; // Or desktop portal, on wayland
+
+        std::string custom_script;
    };

    struct Config {
@@ -167,4 +175,4 @@ namespace gsr {

    std::optional<Config> read_config(const SupportedCaptureOptions &capture_options);
    void save_config(Config &config);
-}
+}
--- a/include/CursorTracker/CursorTrackerWayland.hpp
+++ b/include/CursorTracker/CursorTrackerWayland.hpp
@@ -34,6 +34,7 @@ namespace gsr {
        std::vector<WaylandOutput> monitors;
        struct zxdg_output_manager_v1 *xdg_output_manager = nullptr;
    private:
+        void clear_monitors();
        void set_monitor_outputs_from_xdg_output(struct wl_display *dpy);
    private:
        int drm_fd = -1;
--- a/include/GlobalHotkeys/GlobalHotkeysLinux.hpp
+++ b/include/GlobalHotkeys/GlobalHotkeysLinux.hpp
@@ -9,7 +9,8 @@ namespace gsr {
    public:
        enum class GrabType {
            ALL,
-            VIRTUAL
+            VIRTUAL,
+            NO_GRAB
        };

        GlobalHotkeysLinux(GrabType grab_type);
@@ -21,6 +22,8 @@ namespace gsr {
        bool bind_key_press(Hotkey hotkey, const std::string &id, GlobalHotkeyCallback callback) override;
        void unbind_all_keys() override;
        void poll_events() override;
+
+        std::function<void()> on_gsr_ui_virtual_keyboard_grabbed;
    private:
        void close_fds();
    private:
--- a/include/GsrInfo.hpp
+++ b/include/GsrInfo.hpp
@@ -25,11 +25,22 @@ namespace gsr {
        bool png = false;
    };

+    struct SupportedCameraPixelFormats {
+        bool yuyv = false;
+        bool mjpeg = false;
+    };
+
    struct GsrMonitor {
        std::string name;
        mgl::vec2i size;
    };

+    struct GsrCamera {
+        std::string path;
+        mgl::vec2i size;
+        SupportedCameraPixelFormats supported_pixel_formats;
+    };
+
    struct GsrVersion {
        uint8_t major = 0;
        uint8_t minor = 0;
@@ -51,6 +62,7 @@ namespace gsr {
        bool focused = false;
        bool portal = false;
        std::vector<GsrMonitor> monitors;
+        std::vector<GsrCamera> cameras;
    };

    enum class DisplayServer {
@@ -103,4 +115,5 @@ namespace gsr {
    std::vector<AudioDevice> get_audio_devices();
    std::vector<std::string> get_application_audio();
    SupportedCaptureOptions get_supported_capture_options(const GsrInfo &gsr_info);
+    std::vector<GsrCamera> get_v4l2_devices();
 }
--- a/include/LedIndicator.hpp
+++ b/include/LedIndicator.hpp
@@ -0,0 +1,33 @@
+#pragma once
+
+#include <sys/types.h>
+#include <vector>
+#include <mglpp/system/Clock.hpp>
+
+namespace gsr {
+    class LedIndicator {
+    public:
+        LedIndicator();
+        LedIndicator(const LedIndicator&) = delete;
+        LedIndicator& operator=(const LedIndicator&) = delete;
+        ~LedIndicator();
+
+        void set_led(bool enabled);
+        void blink();
+        void update();
+    private:
+        bool run_gsr_global_hotkeys_set_leds(bool enabled);
+        void update_led(bool new_state);
+        void update_led_with_active_status();
+        void check_led_status_outdated();
+    private:
+        pid_t gsr_global_hotkeys_pid = -1;
+        bool led_indicator_on = false;
+        bool led_enabled = false;
+        bool perform_blink = false;
+        mgl::Clock blink_timer;
+
+        std::vector<int> led_brightness_files;
+        mgl::Clock read_led_brightness_timer;
+    };
+}
--- a/include/Overlay.hpp
+++ b/include/Overlay.hpp
@@ -11,6 +11,7 @@
 #include "RegionSelector.hpp"
 #include "WindowSelector.hpp"
 #include "ClipboardFile.hpp"
+#include "LedIndicator.hpp"
 #include "CursorTracker/CursorTracker.hpp"

 #include <mglpp/window/Window.hpp>
@@ -39,7 +40,13 @@ namespace gsr {
        RECORD,
        REPLAY,
        STREAM,
-        SCREENSHOT
+        SCREENSHOT,
+        NOTICE
+    };
+
+    enum class NotificationLevel {
+        INFO,
+        ERROR,
    };

    enum class ScreenshotForceType {
@@ -77,7 +84,7 @@ namespace gsr {
        void take_screenshot();
        void take_screenshot_region();
        void take_screenshot_window();
-        void show_notification(const char *str, double timeout_seconds, mgl::Color icon_color, mgl::Color bg_color, NotificationType notification_type, const char *capture_target = nullptr);
+        void show_notification(const char *str, double timeout_seconds, mgl::Color icon_color, mgl::Color bg_color, NotificationType notification_type, const char *capture_target = nullptr, NotificationLevel notification_level = NotificationLevel::INFO);
        bool is_open() const;
        bool should_exit(std::string &reason) const;
        void exit();
@@ -89,12 +96,19 @@ namespace gsr {
        void rebind_all_keyboard_hotkeys();

        void set_notification_speed(NotificationSpeed notification_speed);
+
+        bool global_hotkeys_ungrab_keyboard = false;
    private:
+        const char* notification_type_to_string(NotificationType notification_type);
+        void update_upause_status();
+
        void hide();

        void handle_keyboard_mapping_event();
        void on_event(mgl::Event &event);

+        void recreate_global_hotkeys(const char *hotkey_option);
+        void update_led_indicator_after_settings_change();
        void create_frontpage_ui_components();
        void xi_setup();
        void handle_xi_events();
@@ -106,7 +120,7 @@ namespace gsr {

        double get_time_passed_in_replay_buffer_seconds();
        void update_notification_process_status();
-        void save_video_in_current_game_directory(const char *video_filepath, NotificationType notification_type);
+        void save_video_in_current_game_directory(std::string &video_filepath, NotificationType notification_type);
        void on_replay_saved(const char *replay_saved_filepath);
        void process_gsr_output();
        void on_gsr_process_error(int exit_code, NotificationType notification_type);
@@ -118,7 +132,7 @@ namespace gsr {
        void update_power_supply_status();
        void update_system_startup_status();

-        void on_stop_recording(int exit_code, const std::string &video_filepath);
+        void on_stop_recording(int exit_code, std::string &video_filepath);

        void update_ui_recording_paused();
        void update_ui_recording_unpaused();
@@ -158,6 +172,9 @@ namespace gsr {
        GsrInfo gsr_info;
        egl_functions egl_funcs;
        Config config;
+        Config current_recording_config;
+
+        std::string gsr_icon_path;

        bool visible = false;

@@ -194,6 +211,8 @@ namespace gsr {

        RecordingStatus recording_status = RecordingStatus::NONE;
        bool paused = false;
+        mgl::Clock paused_clock;
+        double paused_total_time_seconds = 0.0;

        mgl::Clock replay_status_update_clock;
        std::string power_supply_online_filepath;
@@ -222,7 +241,7 @@ namespace gsr {

        std::unique_ptr<GlobalHotkeys> global_hotkeys = nullptr;
        std::unique_ptr<GlobalHotkeysJoystick> global_hotkeys_js = nullptr;
-        Display *x11_mapping_display = nullptr;
+        Display *x11_dpy = nullptr;
        XEvent x11_mapping_xev;

        mgl::Clock replay_save_clock;
@@ -231,7 +250,6 @@ namespace gsr {
        bool try_replay_startup = true;
        bool replay_recording = false;
        int replay_save_duration_min = 0;
-        double replay_buffer_save_duration_sec = 0.0;
        mgl::Clock replay_duration_clock;
        double replay_saved_duration_sec = 0.0;
        bool replay_restart_on_save = false;
@@ -257,5 +275,7 @@ namespace gsr {
        bool hide_ui = false;
        double notification_duration_multiplier = 1.0;
        ClipboardFile clipboard_file;
+
+        std::unique_ptr<LedIndicator> led_indicator = nullptr;
    };
 }
--- a/include/Process.hpp
+++ b/include/Process.hpp
@@ -13,13 +13,17 @@ namespace gsr {

    // Arguments ending with NULL
    bool exec_program_daemonized(const char **args, bool debug = true);
+    // Arguments ending with NULL.
+    // This works the same as |exec_program_get_stdout|, except on flatpak where this runs the program on the
+    // host machine with flatpak-spawn --host.
+    bool exec_program_on_host_daemonized(const char **args, bool debug = true);
    // Arguments ending with NULL. |read_fd| can be NULL
    pid_t exec_program(const char **args, int *read_fd, bool debug = true);
    // Arguments ending with NULL. Returns the exit status of the program or -1 on error
    int exec_program_get_stdout(const char **args, std::string &result, bool debug = true);
    // Arguments ending with NULL. Returns the exit status of the program or -1 on error.
    // This works the same as |exec_program_get_stdout|, except on flatpak where this runs the program on the
-    // host machine with flatpak-spawn --host
+    // host machine with flatpak-spawn --host.
    int exec_program_on_host_get_stdout(const char **args, std::string &result, bool debug = true);
    pid_t pidof(const char *process_name, pid_t ignore_pid);
 }
--- a/include/Theme.hpp
+++ b/include/Theme.hpp
@@ -24,6 +24,7 @@ namespace gsr {
        mgl::Font body_font;
        mgl::Font title_font;
        mgl::Font top_bar_font;
+        mgl::Font camera_setup_font;

        mgl::Texture combobox_arrow_texture;
        mgl::Texture settings_texture;
--- a/include/WindowUtils.hpp
+++ b/include/WindowUtils.hpp
@@ -19,8 +19,8 @@ namespace gsr {
    };

    std::optional<std::string> get_window_title(Display *dpy, Window window);
-    Window get_focused_window(Display *dpy, WindowCaptureType cap_type);
-    std::string get_focused_window_name(Display *dpy, WindowCaptureType window_capture_type);
+    Window get_focused_window(Display *dpy, WindowCaptureType cap_type, bool fallback_cursor_focused = true);
+    std::string get_focused_window_name(Display *dpy, WindowCaptureType window_capture_type, bool fallback_cursor_focused = true);
    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);
--- a/include/gui/ComboBox.hpp
+++ b/include/gui/ComboBox.hpp
@@ -19,6 +19,8 @@ namespace gsr {
        void draw(mgl::Window &window, mgl::vec2f offset) override;

        void add_item(const std::string &text, const std::string &id);
+        void clear_items();
+
        // The item can only be selected if it's enabled
        void set_selected_item(const std::string &id, bool trigger_event = true, bool trigger_event_even_if_selection_not_changed = true);
        void set_item_enabled(const std::string &id, bool enabled);
--- a/include/gui/ScreenshotSettingsPage.hpp
+++ b/include/gui/ScreenshotSettingsPage.hpp
@@ -23,6 +23,8 @@ namespace gsr {
        void load();
        void save();
        void on_navigate_away_from_page() override;
+
+        std::function<void()> on_config_changed;
    private:
        std::unique_ptr<ComboBox> create_record_area_box();
        std::unique_ptr<Widget> create_record_area();
@@ -43,8 +45,14 @@ namespace gsr {
        std::unique_ptr<Widget> create_file_info_section();
        std::unique_ptr<CheckBox> create_save_screenshot_in_game_folder();
        std::unique_ptr<CheckBox> create_save_screenshot_to_clipboard();
+        std::unique_ptr<CheckBox> create_save_screenshot_to_disk();
+        std::unique_ptr<Widget> create_notifications();
+        std::unique_ptr<Widget> create_led_indicator();
        std::unique_ptr<Widget> create_general_section();
-        std::unique_ptr<Widget> create_notifications_section();
+        std::unique_ptr<Widget> create_screenshot_indicator_section();
+        std::unique_ptr<Widget> create_custom_script_screenshot_section();
+        std::unique_ptr<List> create_custom_script_screenshot_entry();
+        std::unique_ptr<List> create_custom_script_screenshot();
        std::unique_ptr<Widget> create_settings();
        void add_widgets();

@@ -71,8 +79,11 @@ namespace gsr {
        Button *save_directory_button_ptr = nullptr;
        CheckBox *save_screenshot_in_game_folder_checkbox_ptr = nullptr;
        CheckBox *save_screenshot_to_clipboard_checkbox_ptr = nullptr;
-        CheckBox *show_screenshot_saved_notification_checkbox_ptr = nullptr;
+        CheckBox *save_screenshot_to_disk_checkbox_ptr = nullptr;
+        CheckBox *show_notification_checkbox_ptr = nullptr;
+        CheckBox *led_indicator_checkbox_ptr = nullptr;
+        Entry *create_custom_script_screenshot_entry_ptr = nullptr;

        PageStack *page_stack = nullptr;
    };
-}
+}
--- a/include/gui/SettingsPage.hpp
+++ b/include/gui/SettingsPage.hpp
@@ -25,6 +25,14 @@ namespace gsr {
        INPUT
    };

+    enum class WebcamBoxResizeCorner {
+        NONE,
+        //TOP_LEFT,
+        //TOP_RIGHT,
+        //BOTTOM_LEFT,
+        BOTTOM_RIGHT
+    };
+
    class SettingsPage : public StaticPage {
    public:
        enum class Type {
@@ -58,6 +66,12 @@ namespace gsr {
        std::unique_ptr<List> create_restore_portal_session_section();
        std::unique_ptr<Widget> create_change_video_resolution_section();
        std::unique_ptr<Widget> create_capture_target_section();
+        std::unique_ptr<List> create_webcam_sources();
+        std::unique_ptr<List> create_webcam_video_format();
+        std::unique_ptr<Widget> create_webcam_location_widget();
+        std::unique_ptr<CheckBox> create_flip_camera_checkbox();
+        std::unique_ptr<List> create_webcam_body();
+        std::unique_ptr<Widget> create_webcam_section();
        std::unique_ptr<ComboBox> create_audio_device_selection_combobox(AudioDeviceType device_type);
        std::unique_ptr<Button> create_remove_audio_device_button(List *audio_input_list_ptr, List *audio_device_list_ptr);
        std::unique_ptr<List> create_audio_device(AudioDeviceType device_type, List *audio_input_list_ptr);
@@ -112,6 +126,9 @@ namespace gsr {
        std::unique_ptr<CheckBox> create_save_recording_in_game_folder();
        std::unique_ptr<Label> create_estimated_record_file_size();
        void update_estimated_record_file_size();
+        std::unique_ptr<CheckBox> create_led_indicator(const char *type);
+        std::unique_ptr<CheckBox> create_notifications(const char *type);
+        std::unique_ptr<List> create_indicator(const char *type);
        void add_replay_widgets();
        void add_record_widgets();

@@ -136,7 +153,9 @@ namespace gsr {
        void save_record();
        void save_stream();

-        void view_changed(bool advanced_view, Subsection *notifications_subsection_ptr);
+        void view_changed(bool advanced_view);
+
+        RecordOptions& get_current_record_options();
    private:
        Type type;
        Config &config;
@@ -179,15 +198,7 @@ namespace gsr {
        CheckBox *save_replay_in_game_folder_ptr = nullptr;
        CheckBox *restart_replay_on_save = nullptr;
        Label *estimated_file_size_ptr = nullptr;
-        CheckBox *show_replay_started_notification_checkbox_ptr = nullptr;
-        CheckBox *show_replay_stopped_notification_checkbox_ptr = nullptr;
-        CheckBox *show_replay_saved_notification_checkbox_ptr = nullptr;
        CheckBox *save_recording_in_game_folder_ptr = nullptr;
-        CheckBox *show_recording_started_notification_checkbox_ptr = nullptr;
-        CheckBox *show_video_saved_notification_checkbox_ptr = nullptr;
-        CheckBox *show_video_paused_notification_checkbox_ptr = nullptr;
-        CheckBox *show_streaming_started_notification_checkbox_ptr = nullptr;
-        CheckBox *show_streaming_stopped_notification_checkbox_ptr = nullptr;
        Button *save_directory_button_ptr = nullptr;
        Entry *twitch_stream_key_entry_ptr = nullptr;
        Entry *youtube_stream_key_entry_ptr = nullptr;
@@ -200,7 +211,31 @@ namespace gsr {
        RadioButton *turn_on_replay_automatically_mode_ptr = nullptr;
        Subsection *audio_section_ptr = nullptr;
        List *audio_track_section_list_ptr = nullptr;
+        CheckBox *led_indicator_checkbox_ptr = nullptr;
+        CheckBox *show_notification_checkbox_ptr = nullptr;
+        ComboBox *webcam_sources_box_ptr = nullptr;
+        ComboBox *webcam_video_format_box_ptr = nullptr;
+        List *webcam_body_list_ptr = nullptr;
+        CheckBox *flip_camera_horizontally_checkbox_ptr = nullptr;

        PageStack *page_stack = nullptr;
+
+        mgl::vec2f webcam_box_pos;
+        mgl::vec2f webcam_box_size;
+
+        mgl::vec2f webcam_box_drawn_pos;
+        mgl::vec2f webcam_box_drawn_size;
+        mgl::vec2f webcam_box_grab_offset;
+
+        mgl::vec2f camera_screen_size;
+        mgl::vec2f screen_inner_size;
+        bool moving_webcam_box = false;
+
+        WebcamBoxResizeCorner webcam_resize_corner = WebcamBoxResizeCorner::NONE;
+        mgl::vec2f webcam_resize_start_pos;
+        mgl::vec2f webcam_box_pos_resize_start;
+        mgl::vec2f webcam_box_size_resize_start;
+
+        std::optional<GsrCamera> selected_camera;
    };
 }
--- a/include/gui/Utils.hpp
+++ b/include/gui/Utils.hpp
@@ -9,6 +9,10 @@ namespace mgl {
 }

 namespace gsr {
+    mgl::vec2i min_vec2i(mgl::vec2i a, mgl::vec2i b);
+    mgl::vec2i max_vec2i(mgl::vec2i a, mgl::vec2i b);
+    mgl::vec2i clamp_vec2i(mgl::vec2i value, mgl::vec2i min, mgl::vec2i max);
+
    // Inner border
    void draw_rectangle_outline(mgl::Window &window, mgl::vec2f pos, mgl::vec2f size, mgl::Color color, float border_size);
    double get_frame_delta_seconds();
--- a/meson.build
+++ b/meson.build
@@ -1,4 +1,4 @@
-project('gsr-ui', ['c', 'cpp'], version : '1.7.9', default_options : ['warning_level=2', 'cpp_std=c++17'], subproject_dir : 'depends')
+project('gsr-ui', ['c', 'cpp'], version : '1.9.3', default_options : ['warning_level=2', 'cpp_std=c++17'], subproject_dir : 'depends')

 add_project_arguments('-D_FILE_OFFSET_BITS=64', language : ['c', 'cpp'])

@@ -50,6 +50,7 @@ src = [
    'src/AudioPlayer.cpp',
    'src/Hotplug.cpp',
    'src/ClipboardFile.cpp',
+    'src/LedIndicator.cpp',
    'src/Rpc.cpp',
    'src/main.cpp',
 ]
@@ -63,9 +64,10 @@ mglpp_dep = mglpp_proj.get_variable('mglpp_dep')
 prefix = get_option('prefix')
 datadir = get_option('datadir')
 gsr_ui_resources_path = join_paths(prefix, datadir, 'gsr-ui')
+icons_path = join_paths(prefix, datadir, 'icons')

 add_project_arguments('-DGSR_UI_VERSION="' + meson.project_version() + '"', language: ['c', 'cpp'])
-add_project_arguments('-DGSR_FLATPAK_VERSION="5.8.3"', language: ['c', 'cpp'])
+add_project_arguments('-DGSR_FLATPAK_VERSION="5.11.5"', language: ['c', 'cpp'])

 executable(
    meson.project_name(),
@@ -93,6 +95,7 @@ executable(
        'tools/gsr-global-hotkeys/hotplug.c',
        'tools/gsr-global-hotkeys/keyboard_event.c',
        'tools/gsr-global-hotkeys/keys.c',
+        'tools/gsr-global-hotkeys/leds.c',
        'tools/gsr-global-hotkeys/main.c'
    ],
    c_args : '-fstack-protector-all',
@@ -110,6 +113,14 @@ executable(
 install_subdir('images', install_dir : gsr_ui_resources_path)
 install_subdir('fonts', install_dir : gsr_ui_resources_path)

+if get_option('desktop-files') == true
+    install_data(files('gpu-screen-recorder.desktop'), install_dir : join_paths(prefix, datadir, 'applications'))
+    install_subdir('icons/hicolor', install_dir : icons_path)
+
+    gnome = import('gnome')
+    gnome.post_install(update_desktop_database : true)
+endif
+
 if get_option('systemd') == true
    install_data(files('extra/gpu-screen-recorder-ui.service'), install_dir : 'lib/systemd/user')
 endif
--- a/meson_options.txt
+++ b/meson_options.txt
@@ -1,2 +1,3 @@
 option('systemd', type : 'boolean', value : true, description : 'Install systemd service file')
-option('capabilities', type : 'boolean', value : true, description : 'Set binary setuid capability on gsr-global-hotkeys binary to allow global hotkeys')
+option('capabilities', type : 'boolean', value : true, description : 'Set binary setuid capability on gsr-global-hotkeys binary to allow global hotkeys')
+option('desktop-files', type : 'boolean', value : true, description : 'Install desktop files')
--- a/project.conf
+++ b/project.conf
@@ -1,7 +1,7 @@
 [package]
 name = "gsr-ui"
 type = "executable"
-version = "1.7.9"
+version = "1.9.3"
 platforms = ["posix"]

 [lang.cpp]
--- a/src/ClipboardFile.cpp
+++ b/src/ClipboardFile.cpp
@@ -48,11 +48,18 @@ namespace gsr {
                    XNextEvent(dpy, &xev);
                    switch(xev.type) {
                        case SelectionClear: {
-                            should_clear_selection = true;
-                            if(clipboard_copies.empty()) {
-                                should_clear_selection = false;
-                                set_current_file("", file_type);
+                            bool clear_current_file = false;
+                            {
+                                std::lock_guard<std::mutex> lock(mutex);
+                                should_clear_selection = true;
+                                if(clipboard_copies.empty()) {
+                                    should_clear_selection = false;
+                                    clear_current_file = true;
+                                }
                            }
+
+                            if(clear_current_file)
+                                set_current_file("", file_type);
                            break;
                        }
                        case SelectionRequest:
@@ -205,6 +212,9 @@ namespace gsr {
        uint8_t file_buffer[1<<16];
        ssize_t file_bytes_read = 0;

+        if(file_fd <= 0)
+            return;
+
        if(lseek(file_fd, clipboard_copy->file_offset, SEEK_SET) == -1) {
            fprintf(stderr, "gsr ui: error: ClipboardFile::send_clipboard: failed to seek in clipboard file to offset " FORMAT_U64 " for requestor window " FORMAT_I64 ", error: %s\n", (uint64_t)clipboard_copy->file_offset, (int64_t)xselectionrequest->requestor, strerror(errno));
            clipboard_copy->file_offset = 0;
@@ -262,7 +272,13 @@ namespace gsr {
        }
        clipboard_copies.clear();

+        if(XGetSelectionOwner(dpy, clipboard_atom) == clipboard_window) {
+            XSetSelectionOwner(dpy, clipboard_atom, None, CurrentTime);
+            XFlush(dpy);
+        }
+
        if(filepath.empty()) {
+            // TODO: Cancel transfer
            if(file_fd > 0) {
                close(file_fd);
                file_fd = -1;
--- a/src/Config.cpp
+++ b/src/Config.cpp
@@ -171,6 +171,7 @@ namespace gsr {
        return {
            {"main.config_file_version", &config.main_config.config_file_version},
            {"main.software_encoding_warning_shown", &config.main_config.software_encoding_warning_shown},
+            {"main.wayland_warning_shown", &config.main_config.wayland_warning_shown},
            {"main.hotkeys_enable_option", &config.main_config.hotkeys_enable_option},
            {"main.joystick_hotkeys_enable_option", &config.main_config.joystick_hotkeys_enable_option},
            {"main.tint_color", &config.main_config.tint_color},
@@ -198,8 +199,15 @@ namespace gsr {
            {"streaming.record_options.overclock", &config.streaming_config.record_options.overclock},
            {"streaming.record_options.record_cursor", &config.streaming_config.record_options.record_cursor},
            {"streaming.record_options.restore_portal_session", &config.streaming_config.record_options.restore_portal_session},
-            {"streaming.show_streaming_started_notifications", &config.streaming_config.show_streaming_started_notifications},
-            {"streaming.show_streaming_stopped_notifications", &config.streaming_config.show_streaming_stopped_notifications},
+            {"streaming.record_options.webcam_source", &config.streaming_config.record_options.webcam_source},
+            {"streaming.record_options.webcam_flip_horizontally", &config.streaming_config.record_options.webcam_flip_horizontally},
+            {"streaming.record_options.webcam_video_format", &config.streaming_config.record_options.webcam_video_format},
+            {"streaming.record_options.webcam_x", &config.streaming_config.record_options.webcam_x},
+            {"streaming.record_options.webcam_y", &config.streaming_config.record_options.webcam_y},
+            {"streaming.record_options.webcam_width", &config.streaming_config.record_options.webcam_width},
+            {"streaming.record_options.webcam_height", &config.streaming_config.record_options.webcam_height},
+            {"streaming.record_options.show_notifications", &config.streaming_config.record_options.show_notifications},
+            {"streaming.record_options.use_led_indicator", &config.streaming_config.record_options.use_led_indicator},
            {"streaming.service", &config.streaming_config.streaming_service},
            {"streaming.youtube.key", &config.streaming_config.youtube.stream_key},
            {"streaming.twitch.key", &config.streaming_config.twitch.stream_key},
@@ -230,10 +238,16 @@ namespace gsr {
            {"record.record_options.overclock", &config.record_config.record_options.overclock},
            {"record.record_options.record_cursor", &config.record_config.record_options.record_cursor},
            {"record.record_options.restore_portal_session", &config.record_config.record_options.restore_portal_session},
+            {"record.record_options.webcam_source", &config.record_config.record_options.webcam_source},
+            {"record.record_options.webcam_flip_horizontally", &config.record_config.record_options.webcam_flip_horizontally},
+            {"record.record_options.webcam_video_format", &config.record_config.record_options.webcam_video_format},
+            {"record.record_options.webcam_x", &config.record_config.record_options.webcam_x},
+            {"record.record_options.webcam_y", &config.record_config.record_options.webcam_y},
+            {"record.record_options.webcam_width", &config.record_config.record_options.webcam_width},
+            {"record.record_options.webcam_height", &config.record_config.record_options.webcam_height},
+            {"record.record_options.show_notifications", &config.record_config.record_options.show_notifications},
+            {"record.record_options.use_led_indicator", &config.record_config.record_options.use_led_indicator},
            {"record.save_video_in_game_folder", &config.record_config.save_video_in_game_folder},
-            {"record.show_recording_started_notifications", &config.record_config.show_recording_started_notifications},
-            {"record.show_video_saved_notifications", &config.record_config.show_video_saved_notifications},
-            {"record.show_video_paused_notifications", &config.record_config.show_video_paused_notifications},
            {"record.save_directory", &config.record_config.save_directory},
            {"record.container", &config.record_config.container},
            {"record.start_stop_hotkey", &config.record_config.start_stop_hotkey},
@@ -260,12 +274,18 @@ namespace gsr {
            {"replay.record_options.overclock", &config.replay_config.record_options.overclock},
            {"replay.record_options.record_cursor", &config.replay_config.record_options.record_cursor},
            {"replay.record_options.restore_portal_session", &config.replay_config.record_options.restore_portal_session},
+            {"replay.record_options.webcam_source", &config.replay_config.record_options.webcam_source},
+            {"replay.record_options.webcam_flip_horizontally", &config.replay_config.record_options.webcam_flip_horizontally},
+            {"replay.record_options.webcam_video_format", &config.replay_config.record_options.webcam_video_format},
+            {"replay.record_options.webcam_x", &config.replay_config.record_options.webcam_x},
+            {"replay.record_options.webcam_y", &config.replay_config.record_options.webcam_y},
+            {"replay.record_options.webcam_width", &config.replay_config.record_options.webcam_width},
+            {"replay.record_options.webcam_height", &config.replay_config.record_options.webcam_height},
+            {"replay.record_options.show_notifications", &config.replay_config.record_options.show_notifications},
+            {"replay.record_options.use_led_indicator", &config.replay_config.record_options.use_led_indicator},
            {"replay.turn_on_replay_automatically_mode", &config.replay_config.turn_on_replay_automatically_mode},
            {"replay.save_video_in_game_folder", &config.replay_config.save_video_in_game_folder},
            {"replay.restart_replay_on_save", &config.replay_config.restart_replay_on_save},
-            {"replay.show_replay_started_notifications", &config.replay_config.show_replay_started_notifications},
-            {"replay.show_replay_stopped_notifications", &config.replay_config.show_replay_stopped_notifications},
-            {"replay.show_replay_saved_notifications", &config.replay_config.show_replay_saved_notifications},
            {"replay.save_directory", &config.replay_config.save_directory},
            {"replay.container", &config.replay_config.container},
            {"replay.time", &config.replay_config.replay_time},
@@ -285,11 +305,14 @@ namespace gsr {
            {"screenshot.restore_portal_session", &config.screenshot_config.restore_portal_session},
            {"screenshot.save_screenshot_in_game_folder", &config.screenshot_config.save_screenshot_in_game_folder},
            {"screenshot.save_screenshot_to_clipboard", &config.screenshot_config.save_screenshot_to_clipboard},
-            {"screenshot.show_screenshot_saved_notifications", &config.screenshot_config.show_screenshot_saved_notifications},
+            {"screenshot.save_screenshot_to_disk", &config.screenshot_config.save_screenshot_to_disk},
+            {"screenshot.show_notifications", &config.screenshot_config.show_notifications},
+            {"screenshot.use_led_indicator", &config.screenshot_config.use_led_indicator},
            {"screenshot.save_directory", &config.screenshot_config.save_directory},
            {"screenshot.take_screenshot_hotkey", &config.screenshot_config.take_screenshot_hotkey},
            {"screenshot.take_screenshot_region_hotkey", &config.screenshot_config.take_screenshot_region_hotkey},
-            {"screenshot.take_screenshot_window_hotkey", &config.screenshot_config.take_screenshot_window_hotkey}
+            {"screenshot.take_screenshot_window_hotkey", &config.screenshot_config.take_screenshot_window_hotkey},
+            {"screenshot.custom_script", &config.screenshot_config.custom_script},
        };
    }

@@ -487,4 +510,4 @@ namespace gsr {

        fclose(file);
    }
-}
+}
--- a/src/CursorTracker/CursorTrackerWayland.cpp
+++ b/src/CursorTracker/CursorTrackerWayland.cpp
@@ -403,6 +403,7 @@ namespace gsr {
    }

    CursorTrackerWayland::~CursorTrackerWayland() {
+        clear_monitors();
        if(drm_fd > 0)
            close(drm_fd);
    }
@@ -480,6 +481,21 @@ namespace gsr {
        wl_display_roundtrip(dpy);
    }

+    void CursorTrackerWayland::clear_monitors() {
+        for(WaylandOutput &monitor : monitors) {
+            if(monitor.output) {
+                wl_output_destroy(monitor.output);
+                monitor.output = nullptr;
+            }
+
+            if(monitor.xdg_output) {
+                zxdg_output_v1_destroy(monitor.xdg_output);
+                monitor.xdg_output = nullptr;
+            }
+        }
+        monitors.clear();
+    }
+
    std::optional<CursorInfo> CursorTrackerWayland::get_latest_cursor_info() {
        if(drm_fd <= 0 || latest_crtc_id == -1)
            return std::nullopt;
@@ -494,7 +510,7 @@ namespace gsr {
            return std::nullopt;
        }

-        monitors.clear();
+        clear_monitors();
        struct wl_registry *registry = wl_display_get_registry(dpy);
        wl_registry_add_listener(registry, &registry_listener, this);

@@ -508,22 +524,13 @@ namespace gsr {

        mgl::vec2i cursor_position = latest_cursor_position;
        const WaylandOutput *wayland_monitor = get_wayland_monitor_by_name(monitors, monitor_name);
-        if(!wayland_monitor)
+        if(!wayland_monitor) {
+            clear_monitors();
            return std::nullopt;
+        }

        cursor_position = wayland_monitor->pos + latest_cursor_position;
-        for(WaylandOutput &monitor : monitors) {
-            if(monitor.output) {
-                wl_output_destroy(monitor.output);
-                monitor.output = nullptr;
-            }
-
-            if(monitor.xdg_output) {
-                zxdg_output_v1_destroy(monitor.xdg_output);
-                monitor.xdg_output = nullptr;
-            }
-        }
-        monitors.clear();
+        clear_monitors();

        if(xdg_output_manager) {
            zxdg_output_manager_v1_destroy(xdg_output_manager);
--- a/src/GlobalHotkeys/GlobalHotkeysLinux.cpp
+++ b/src/GlobalHotkeys/GlobalHotkeysLinux.cpp
@@ -19,6 +19,7 @@ namespace gsr {
        switch(grab_type) {
            case GlobalHotkeysLinux::GrabType::ALL:     return "--all";
            case GlobalHotkeysLinux::GrabType::VIRTUAL: return "--virtual";
+            case GlobalHotkeysLinux::GrabType::NO_GRAB: return "--no-grab";
        }
        return "--all";
    }
@@ -192,7 +193,7 @@ namespace gsr {
            return false;
        }

-        if(hotkey.key == 0) {
+        if(hotkey.key == 0 || hotkey.key == XK_VoidSymbol) {
            //fprintf(stderr, "Error: GlobalHotkeysLinux::bind_key_press: hotkey requires a key\n");
            return false;
        }
@@ -270,6 +271,8 @@ namespace gsr {
            auto it = bound_actions_by_id.find(action);
            if(it != bound_actions_by_id.end())
                it->second(action);
+            else if(on_gsr_ui_virtual_keyboard_grabbed && action == "gsr-ui-virtual-keyboard-grabbed")
+                on_gsr_ui_virtual_keyboard_grabbed();
        }
    }
 }
--- a/src/GsrInfo.cpp
+++ b/src/GsrInfo.cpp
@@ -288,6 +288,56 @@ namespace gsr {
        return application_audio;
    }

+    struct KeyValue3 {
+        std::string_view value1;
+        std::string_view value2;
+        std::string_view value3;
+    };
+
+    static std::optional<KeyValue3> parse_3(std::string_view line) {
+        const size_t space_index1 = line.find('|');
+        if(space_index1 == std::string_view::npos)
+            return std::nullopt;
+
+        const size_t space_index2 = line.find('|', space_index1 + 1);
+        if(space_index2 == std::string_view::npos)
+            return std::nullopt;
+
+        return KeyValue3{
+            line.substr(0, space_index1),
+            line.substr(space_index1 + 1, space_index2 - (space_index1 + 1)),
+            line.substr(space_index2 + 1),
+        };
+    }
+
+    static SupportedCameraPixelFormats parse_supported_camera_pixel_formats(std::string_view line) {
+        SupportedCameraPixelFormats result;
+        string_split_char(line, ',', [&](std::string_view column) {
+            if(column == "yuyv")
+                result.yuyv = true;
+            else if(column == "mjpeg")
+                result.mjpeg = true;
+            return true;
+        });
+        return result;
+    }
+
+    static std::optional<GsrCamera> capture_option_line_to_camera(std::string_view line) {
+        std::optional<GsrCamera> camera;
+        const std::optional<KeyValue3> key_value3 = parse_3(line);
+        if(!key_value3)
+            return camera;
+
+        mgl::vec2i size;
+        char value_buffer[256];
+        snprintf(value_buffer, sizeof(value_buffer), "%.*s", (int)key_value3->value2.size(), key_value3->value2.data());
+        if(sscanf(value_buffer, "%dx%d", &size.x, &size.y) != 2)
+            return camera;
+
+        camera = GsrCamera{std::string(key_value3->value1), size, parse_supported_camera_pixel_formats(key_value3->value3)};
+        return camera;
+    }
+
    static std::optional<GsrMonitor> capture_option_line_to_monitor(std::string_view line) {
        std::optional<GsrMonitor> monitor;
        const std::optional<KeyValue> key_value = parse_key_value(line);
@@ -305,15 +355,19 @@ namespace gsr {
    }

    static void parse_capture_options_line(SupportedCaptureOptions &capture_options, std::string_view line) {
-        if(line == "window")
+        if(line == "window") {
            capture_options.window = true;
-        else if(line == "region")
+        } else if(line == "region") {
            capture_options.region = true;
-        else if(line == "focused")
+        } else if(line == "focused") {
            capture_options.focused = true;
-        else if(line == "portal")
+        } else if(line == "portal") {
            capture_options.portal = true;
-        else {
+        } else if(!line.empty() && line[0] == '/') {
+            std::optional<GsrCamera> camera = capture_option_line_to_camera(line);
+            if(camera)
+                capture_options.cameras.push_back(std::move(camera.value()));
+        } else {
            std::optional<GsrMonitor> monitor = capture_option_line_to_monitor(line);
            if(monitor)
                capture_options.monitors.push_back(std::move(monitor.value()));
@@ -348,4 +402,24 @@ namespace gsr {

        return capture_options;
    }
+
+    std::vector<GsrCamera> get_v4l2_devices() {
+        std::vector<GsrCamera> cameras;
+
+        std::string stdout_str;
+        const char *args[] = { "gpu-screen-recorder", "--list-v4l2-devices", nullptr };
+        if(exec_program_get_stdout(args, stdout_str) != 0) {
+            fprintf(stderr, "error: 'gpu-screen-recorder --list-v4l2-devices' failed\n");
+            return cameras;
+        }
+
+        string_split_char(stdout_str, '\n', [&](std::string_view line) {
+            std::optional<GsrCamera> camera = capture_option_line_to_camera(line);
+            if(camera)
+                cameras.push_back(std::move(camera.value()));
+            return true;
+        });
+
+        return cameras;
+    }
 }
--- a/src/LedIndicator.cpp
+++ b/src/LedIndicator.cpp
@@ -0,0 +1,175 @@
+#include "../include/LedIndicator.hpp"
+
+#include <unistd.h>
+#include <fcntl.h>
+#include <dirent.h>
+#include <sys/wait.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+// TODO: Support hotplug for led indicator check (led_brightness_files)
+
+namespace gsr {
+    static bool string_starts_with(const char *str, const char *sub) {
+        const int str_len = strlen(str);
+        const int sub_len = strlen(sub);
+        return str_len >= sub_len && memcmp(str, sub, sub_len) == 0;
+    }
+
+    static bool string_ends_with(const char *str, const char *sub) {
+        const int str_len = strlen(str);
+        const int sub_len = strlen(sub);
+        return str_len >= sub_len && memcmp(str + str_len - sub_len, sub, sub_len) == 0;
+    }
+
+    static std::vector<int> open_device_leds_brightness_files(const char *led_name_path) {
+        std::vector<int> files;
+
+        DIR *dir = opendir("/sys/class/leds");
+        if(!dir)
+            return files;
+
+        char brightness_filepath[1024];
+        struct dirent *entry;
+        while((entry = readdir(dir)) != NULL) {
+            if(entry->d_name[0] == '.')
+                continue;
+
+            if(!string_starts_with(entry->d_name, "input") || !string_ends_with(entry->d_name, led_name_path))
+                continue;
+
+            snprintf(brightness_filepath, sizeof(brightness_filepath), "/sys/class/leds/%s/brightness", entry->d_name);
+            const int led_brightness_file_fd = open(brightness_filepath, O_RDONLY | O_NONBLOCK);
+            if(led_brightness_file_fd > 0)
+                files.push_back(led_brightness_file_fd);
+        }
+
+        closedir(dir);
+        return files;
+    }
+
+    LedIndicator::LedIndicator() {
+        led_brightness_files = open_device_leds_brightness_files("scrolllock");
+        run_gsr_global_hotkeys_set_leds(false);
+    }
+
+    LedIndicator::~LedIndicator() {
+        for(int led_brightness_file_fd : led_brightness_files) {
+            close(led_brightness_file_fd);
+        }
+
+        run_gsr_global_hotkeys_set_leds(false);
+        if(gsr_global_hotkeys_pid > 0) {
+            int status;
+            waitpid(gsr_global_hotkeys_pid, &status, 0);
+        }
+    }
+
+    void LedIndicator::set_led(bool enabled) {
+        led_enabled = enabled;
+        perform_blink = false;
+    }
+
+    void LedIndicator::blink() {
+        perform_blink = true;
+        blink_timer.restart();
+    }
+
+    bool LedIndicator::run_gsr_global_hotkeys_set_leds(bool enabled) {
+        if(gsr_global_hotkeys_pid > 0) {
+            int status;
+            if(waitpid(gsr_global_hotkeys_pid, &status, WNOHANG) == 0) {
+                // Still running
+                return false;
+            }
+            gsr_global_hotkeys_pid = -1;
+        }
+
+        const bool inside_flatpak = getenv("FLATPAK_ID") != NULL;
+        const char *user_homepath = getenv("HOME");
+        if(!user_homepath)
+            user_homepath = "/tmp";
+
+        gsr_global_hotkeys_pid = vfork();
+        if(gsr_global_hotkeys_pid == -1) {
+            fprintf(stderr, "Error: LedIndicator::run_gsr_global_hotkeys_set_leds: failed to fork\n");
+            return false;
+        } else if(gsr_global_hotkeys_pid == 0) { // Child
+            if(inside_flatpak) {
+                const char *args[] = { "flatpak-spawn", "--host", "/var/lib/flatpak/app/com.dec05eba.gpu_screen_recorder/current/active/files/bin/kms-server-proxy", "launch-gsr-global-hotkeys", user_homepath, "--set-led", "Scroll Lock", enabled ? "on" : "off", nullptr };
+                execvp(args[0], (char* const*)args);
+            } else {
+                const char *args[] = { "gsr-global-hotkeys", "--set-led", "Scroll Lock", enabled ? "on" : "off", nullptr };
+                execvp(args[0], (char* const*)args);
+            }
+
+            perror("gsr-global-hotkeys");
+            _exit(127);
+            return false;
+        } else { // Parent
+            return true;
+        }
+    }
+
+    void LedIndicator::update_led(bool new_state) {
+        if(new_state == led_indicator_on)
+            return;
+
+        if(run_gsr_global_hotkeys_set_leds(new_state))
+            led_indicator_on = new_state;
+    }
+
+    void LedIndicator::update() {
+        update_led_with_active_status();
+        check_led_status_outdated();
+    }
+
+    void LedIndicator::update_led_with_active_status() {
+        if(perform_blink) {
+            const double blink_elapsed_sec = blink_timer.get_elapsed_time_seconds();
+            if(blink_elapsed_sec < 0.2) {
+                update_led(false);
+            } else if(blink_elapsed_sec < 0.4) {
+                update_led(true);
+            } else if(blink_elapsed_sec < 0.6) {
+                update_led(false);
+            } else if(blink_elapsed_sec < 0.8) {
+                update_led(true);
+            } else {
+                perform_blink = false;
+            }
+        } else {
+            update_led(led_enabled);
+        }
+    }
+
+    void LedIndicator::check_led_status_outdated() {
+        // The display server will unset our scroll lock led when pressing capslock/numlock as it updates
+        // all leds at the same time (not just the button pressed) (or at least xorg server does that).
+        // When that is done we want to set the scroll lock led on again if it should be on.
+        // TODO: Improve this. Dont do this with a timer.. but inotify doesn't work sysfs. netlink should work (man 7 netlink).
+        if(read_led_brightness_timer.get_elapsed_time_seconds() > 0.2) {
+            read_led_brightness_timer.restart();
+
+            bool any_keyboard_with_led_enabled = false;
+            bool any_keyboard_with_led_disabled = false;
+            char buffer[32];
+            for(int led_brightness_file_fd : led_brightness_files) {
+                const ssize_t bytes_read = read(led_brightness_file_fd, buffer, sizeof(buffer));
+                if(bytes_read > 0) {
+                    if(buffer[0] == '0')
+                        any_keyboard_with_led_disabled = true;
+                    else
+                        any_keyboard_with_led_enabled = true;
+                    lseek(led_brightness_file_fd, 0, SEEK_SET);
+                }
+            }
+
+            if(led_enabled && any_keyboard_with_led_disabled)
+                run_gsr_global_hotkeys_set_leds(true);
+            else if(!led_enabled && any_keyboard_with_led_enabled)
+                run_gsr_global_hotkeys_set_leds(false);
+        }
+    }
+}
--- a/src/Overlay.cpp
+++ b/src/Overlay.cpp
--- a/src/Process.cpp
+++ b/src/Process.cpp
@@ -73,6 +73,28 @@ namespace gsr {
        return true;
    }

+    bool exec_program_on_host_daemonized(const char **args, bool debug) {
+        if(count_num_args(args) > 64 - 3) {
+            fprintf(stderr, "Error: too many arguments when trying to launch \"%s\"\n", args[0]);
+            return -1;
+        }
+
+        const bool inside_flatpak = getenv("FLATPAK_ID") != NULL;
+        if(inside_flatpak) {
+            // Assumes programs wont need more than 64 - 3 args
+            const char *modified_args[64] = { "flatpak-spawn", "--host", "--" };
+            for(int i = 3; i < 64; ++i) {
+                const char *arg = args[i - 3];
+                modified_args[i] = arg;
+                if(!arg)
+                    break;
+            }
+            return exec_program_daemonized(modified_args, debug);
+        } else {
+            return exec_program_daemonized(args, debug);
+        }
+    }
+
    pid_t exec_program(const char **args, int *read_fd, bool debug) {
        if(read_fd)
            *read_fd = -1;
@@ -164,11 +186,9 @@ namespace gsr {
            const char *modified_args[64] = { "flatpak-spawn", "--host", "--" };
            for(int i = 3; i < 64; ++i) {
                const char *arg = args[i - 3];
-                if(!arg) {
-                    modified_args[i] = nullptr;
-                    break;
-                }
                modified_args[i] = arg;
+                if(!arg)
+                    break;
            }
            return exec_program_get_stdout(modified_args, result, debug);
        } else {
--- a/src/RegionSelector.cpp
+++ b/src/RegionSelector.cpp
@@ -3,6 +3,7 @@
 #include <stdio.h>
 #include <string.h>

+#include <X11/Xatom.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/extensions/Xrandr.h>
 #include <X11/extensions/shape.h>
@@ -221,6 +222,9 @@ namespace gsr {
        }
        set_window_size_not_resizable(dpy, region_window, XWidthOfScreen(screen), XHeightOfScreen(screen));

+        unsigned char data = 2; // Prefer being composed to allow transparency. Do this to prevent the compositor from getting turned on/off when taking a screenshot
+        XChangeProperty(dpy, region_window, XInternAtom(dpy, "_NET_WM_BYPASS_COMPOSITOR", False), XA_CARDINAL, 32, PropModeReplace, &data, 1);
+
        if(!is_wayland) {
            cursor_window = create_cursor_window(dpy, cursor_window_size, cursor_window_size, &vinfo, border_color_x11);
            if(!cursor_window)
@@ -309,6 +313,9 @@ namespace gsr {
            region_window = 0;
        }

+        XFlush(dpy);
+        XSync(dpy, False);
+
        XCloseDisplay(dpy);
        dpy = nullptr;
        selecting_region = false;
--- a/src/Theme.cpp
+++ b/src/Theme.cpp
@@ -48,6 +48,9 @@ namespace gsr {
        if(!theme->body_font.load_from_file(theme->body_font_file, std::max(13.0f, window_size.y * 0.015f)))
            return false;

+        if(!theme->camera_setup_font.load_from_file(theme->body_font_file, 24))
+            return false;
+
        return true;
    }

--- a/src/WindowSelector.cpp
+++ b/src/WindowSelector.cpp
@@ -4,6 +4,7 @@
 #include <stdio.h>
 #include <string.h>

+#include <X11/Xatom.h>
 #include <X11/extensions/shape.h>
 #include <X11/cursorfont.h>
 #include <X11/keysym.h>
@@ -122,6 +123,10 @@ namespace gsr {
            return false;
        }
        set_window_size_not_resizable(dpy, border_window, XWidthOfScreen(screen), XHeightOfScreen(screen));
+
+        unsigned char data = 2; // Prefer being composed to allow transparency. Do this to prevent the compositor from getting turned on/off when taking a screenshot
+        XChangeProperty(dpy, border_window, XInternAtom(dpy, "_NET_WM_BYPASS_COMPOSITOR", False), XA_CARDINAL, 32, PropModeReplace, &data, 1);
+
        if(cursor_window && cursor_window != DefaultRootWindow(dpy))
            set_region_rectangle(dpy, border_window, cursor_window_pos.x, cursor_window_pos.y, cursor_window_size.x, cursor_window_size.y, rectangle_border_size);
        else
@@ -163,6 +168,8 @@ namespace gsr {
        }

        XFlush(dpy);
+        XSync(dpy, False);
+
        XCloseDisplay(dpy);
        dpy = nullptr;
    }
--- a/src/WindowUtils.cpp
+++ b/src/WindowUtils.cpp
@@ -121,7 +121,7 @@ namespace gsr {
        return root_pos;
    }

-    Window get_focused_window(Display *dpy, WindowCaptureType cap_type) {
+    Window get_focused_window(Display *dpy, WindowCaptureType cap_type, bool fallback_cursor_focused) {
        //const Atom net_active_window_atom = XInternAtom(dpy, "_NET_ACTIVE_WINDOW", False);
        Window focused_window = None;

@@ -146,6 +146,9 @@ namespace gsr {
            XGetInputFocus(dpy, &focused_window, &revert_to);
            if(focused_window && focused_window != DefaultRootWindow(dpy) && window_is_user_program(dpy, focused_window))
                return focused_window;
+
+            if(!fallback_cursor_focused)
+                return None;
        }

        get_cursor_position(dpy, &focused_window);
@@ -213,9 +216,9 @@ namespace gsr {
        return result;
    }

-    std::string get_focused_window_name(Display *dpy, WindowCaptureType window_capture_type) {
+    std::string get_focused_window_name(Display *dpy, WindowCaptureType window_capture_type, bool fallback_cursor_focused) {
        std::string result;
-        const Window focused_window = get_focused_window(dpy, window_capture_type);
+        const Window focused_window = get_focused_window(dpy, window_capture_type, fallback_cursor_focused);
        if(focused_window == None)
            return result;

--- a/src/gui/ComboBox.cpp
+++ b/src/gui/ComboBox.cpp
@@ -90,6 +90,13 @@ namespace gsr {
        dirty = true;
    }

+    void ComboBox::clear_items() {
+        items.clear();
+        selected_item = 0;
+        show_dropdown = false;
+        dirty = true;
+    }
+
    void ComboBox::set_selected_item(const std::string &id, bool trigger_event, bool trigger_event_even_if_selection_not_changed) {
        for(size_t i = 0; i < items.size(); ++i) {
            auto &item = items[i];
--- a/src/gui/CustomRendererWidget.cpp
+++ b/src/gui/CustomRendererWidget.cpp
@@ -1,4 +1,5 @@
 #include "../../include/gui/CustomRendererWidget.hpp"
+#include "../../include/gui/Utils.hpp"

 #include <mglpp/window/Window.hpp>

@@ -17,11 +18,14 @@ namespace gsr {

        const mgl::vec2f draw_pos = position + offset;

-        const mgl::Scissor prev_scissor = window.get_scissor();
-        window.set_scissor({draw_pos.to_vec2i(), size.to_vec2i()});
+        const mgl::Scissor parent_scissor = window.get_scissor();
+        const mgl::Scissor scissor = scissor_get_sub_area(parent_scissor, {draw_pos.to_vec2i(), size.to_vec2i()});
+        window.set_scissor(scissor);
+
        if(draw_handler)
            draw_handler(window, draw_pos, size);
-        window.set_scissor(prev_scissor);
+
+        window.set_scissor(parent_scissor);
    }

    mgl::vec2f CustomRendererWidget::get_size() {
--- a/src/gui/GlobalSettingsPage.cpp
+++ b/src/gui/GlobalSettingsPage.cpp
@@ -190,11 +190,12 @@ namespace gsr {
    }

    std::unique_ptr<RadioButton> GlobalSettingsPage::create_enable_keyboard_hotkeys_button() {
-        auto enable_hotkeys_radio_button = std::make_unique<RadioButton>(&get_theme().body_font, RadioButton::Orientation::HORIZONTAL);
+        auto enable_hotkeys_radio_button = std::make_unique<RadioButton>(&get_theme().body_font, RadioButton::Orientation::VERTICAL);
        enable_keyboard_hotkeys_radio_button_ptr = enable_hotkeys_radio_button.get();
        enable_hotkeys_radio_button->add_item("Yes", "enable_hotkeys");
+        enable_hotkeys_radio_button->add_item("Yes, but only grab virtual devices (supports some input remapping software)", "enable_hotkeys_virtual_devices");
+        enable_hotkeys_radio_button->add_item("Yes, but don't grab devices (supports all input remapping software)", "enable_hotkeys_no_grab");
        enable_hotkeys_radio_button->add_item("No", "disable_hotkeys");
-        enable_hotkeys_radio_button->add_item("Only grab virtual devices (supports input remapping software)", "enable_hotkeys_virtual_devices");
        enable_hotkeys_radio_button->on_selection_changed = [&](const std::string&, const std::string &id) {
            if(on_keyboard_hotkey_changed)
                on_keyboard_hotkey_changed(id.c_str());
--- a/src/gui/ScreenshotSettingsPage.cpp
+++ b/src/gui/ScreenshotSettingsPage.cpp
@@ -54,7 +54,7 @@ namespace gsr {

    std::unique_ptr<Widget> ScreenshotSettingsPage::create_record_area() {
        auto record_area_list = std::make_unique<List>(List::Orientation::VERTICAL);
-        record_area_list->add_widget(std::make_unique<Label>(&get_theme().body_font, "Capture target:", get_color_theme().text_color));
+        record_area_list->add_widget(std::make_unique<Label>(&get_theme().body_font, "Capture source:", get_color_theme().text_color));
        record_area_list->add_widget(create_record_area_box());
        return record_area_list;
    }
@@ -139,7 +139,7 @@ namespace gsr {

        return list;
    }
-    
+
    std::unique_ptr<Widget> ScreenshotSettingsPage::create_record_cursor_section() {
        auto record_cursor_checkbox = std::make_unique<CheckBox>(&get_theme().body_font, "Record cursor");
        record_cursor_checkbox->set_checked(true);
@@ -163,7 +163,7 @@ namespace gsr {
            auto select_directory_page = std::make_unique<GsrPage>("File", "Settings");
            select_directory_page->add_button("Save", "save", get_color_theme().tint_color);
            select_directory_page->add_button("Cancel", "cancel", get_color_theme().page_bg_color);
-            
+
            auto file_chooser = std::make_unique<FileChooser>(save_directory_button_ptr->get_text().c_str(), select_directory_page->get_inner_size());
            FileChooser *file_chooser_ptr = file_chooser.get();
            select_directory_page->add_widget(std::move(file_chooser));
@@ -202,7 +202,7 @@ namespace gsr {

    std::unique_ptr<Widget> ScreenshotSettingsPage::create_file_info_section() {
        auto file_info_data_list = std::make_unique<List>(List::Orientation::HORIZONTAL);
-        file_info_data_list->add_widget(create_save_directory("Directory to save the screenshot:"));
+        file_info_data_list->add_widget(create_save_directory("Directory to save screenshots:"));
        file_info_data_list->add_widget(create_image_format_section());
        return std::make_unique<Subsection>("File info", std::move(file_info_data_list), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f));
    }
@@ -216,29 +216,72 @@ namespace gsr {
    }

    std::unique_ptr<CheckBox> ScreenshotSettingsPage::create_save_screenshot_to_clipboard() {
-        auto checkbox = std::make_unique<CheckBox>(&get_theme().body_font, "Save screenshot to clipboard");
+        auto checkbox = std::make_unique<CheckBox>(&get_theme().body_font, gsr_info->system_info.display_server == DisplayServer::X11 ? "Save screenshot to clipboard" : "Save screenshot to clipboard (Not supported properly by Wayland)");
        save_screenshot_to_clipboard_checkbox_ptr = checkbox.get();
        return checkbox;
    }

+    std::unique_ptr<CheckBox> ScreenshotSettingsPage::create_save_screenshot_to_disk() {
+        auto checkbox = std::make_unique<CheckBox>(&get_theme().body_font, "Save screenshot to disk");
+        save_screenshot_to_disk_checkbox_ptr = checkbox.get();
+        checkbox->set_checked(true);
+        return checkbox;
+    }
+
+    std::unique_ptr<Widget> ScreenshotSettingsPage::create_notifications() {
+        auto checkbox = std::make_unique<CheckBox>(&get_theme().body_font, "Show screenshot notifications");
+        checkbox->set_checked(true);
+        show_notification_checkbox_ptr = checkbox.get();
+        return checkbox;
+    }
+
+    std::unique_ptr<Widget> ScreenshotSettingsPage::create_led_indicator() {
+        auto checkbox = std::make_unique<CheckBox>(&get_theme().body_font, "Blink scroll lock led when taking a screenshot");
+        checkbox->set_checked(true);
+        led_indicator_checkbox_ptr = checkbox.get();
+        return checkbox;
+    }
+
    std::unique_ptr<Widget> ScreenshotSettingsPage::create_general_section() {
        auto list = std::make_unique<List>(List::Orientation::VERTICAL);
        list->add_widget(create_save_screenshot_in_game_folder());
        list->add_widget(create_save_screenshot_to_clipboard());
+        list->add_widget(create_save_screenshot_to_disk());
        return std::make_unique<Subsection>("General", std::move(list), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f));
    }

-    std::unique_ptr<Widget> ScreenshotSettingsPage::create_notifications_section() {
-        auto show_screenshot_saved_notification_checkbox = std::make_unique<CheckBox>(&get_theme().body_font, "Show screenshot saved notification");
-        show_screenshot_saved_notification_checkbox->set_checked(true);
-        show_screenshot_saved_notification_checkbox_ptr = show_screenshot_saved_notification_checkbox.get();
-        return std::make_unique<Subsection>("Notifications", std::move(show_screenshot_saved_notification_checkbox), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f));
+    std::unique_ptr<Widget> ScreenshotSettingsPage::create_screenshot_indicator_section() {
+        auto list = std::make_unique<List>(List::Orientation::VERTICAL);
+        list->add_widget(create_notifications());
+        list->add_widget(create_led_indicator());
+        return std::make_unique<Subsection>("Screenshot indicator", std::move(list), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f));
+    }
+
+    std::unique_ptr<List> ScreenshotSettingsPage::create_custom_script_screenshot_entry() {
+        auto list = std::make_unique<List>(List::Orientation::VERTICAL, List::Alignment::CENTER);
+
+        auto create_custom_script_screenshot_entry = std::make_unique<Entry>(&get_theme().body_font, "", get_theme().body_font.get_character_size() * 20);
+        create_custom_script_screenshot_entry_ptr = create_custom_script_screenshot_entry.get();
+        list->add_widget(std::move(create_custom_script_screenshot_entry));
+
+        return list;
+    }
+
+    std::unique_ptr<List> ScreenshotSettingsPage::create_custom_script_screenshot() {
+        auto custom_script_screenshot_list = std::make_unique<List>(List::Orientation::VERTICAL);
+        custom_script_screenshot_list->add_widget(std::make_unique<Label>(&get_theme().body_font, "Command to open the screenshot with:", get_color_theme().text_color));
+        custom_script_screenshot_list->add_widget(create_custom_script_screenshot_entry());
+        return custom_script_screenshot_list;
+    }
+
+    std::unique_ptr<Widget> ScreenshotSettingsPage::create_custom_script_screenshot_section() {
+        return std::make_unique<Subsection>("Script", create_custom_script_screenshot(), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f));
    }

    std::unique_ptr<Widget> ScreenshotSettingsPage::create_settings() {
        auto page_list = std::make_unique<List>(List::Orientation::VERTICAL);
        page_list->set_spacing(0.018f);
-        auto scrollable_page = std::make_unique<ScrollablePage>(content_page_ptr->get_inner_size() - mgl::vec2f(0.0f, page_list->get_size().y + 0.018f * get_theme().window_height));
+        auto scrollable_page = std::make_unique<ScrollablePage>(content_page_ptr->get_inner_size() - mgl::vec2f(0.0f, page_list->get_size().y));
        settings_scrollable_page_ptr = scrollable_page.get();
        page_list->add_widget(std::move(scrollable_page));

@@ -248,7 +291,8 @@ namespace gsr {
        settings_list->add_widget(create_image_section());
        settings_list->add_widget(create_file_info_section());
        settings_list->add_widget(create_general_section());
-        settings_list->add_widget(create_notifications_section());
+        settings_list->add_widget(create_screenshot_indicator_section());
+        settings_list->add_widget(create_custom_script_screenshot_section());
        settings_scrollable_page_ptr->add_widget(std::move(settings_list));
        return page_list;
    }
@@ -291,7 +335,9 @@ namespace gsr {
        save_directory_button_ptr->set_text(config.screenshot_config.save_directory);
        save_screenshot_in_game_folder_checkbox_ptr->set_checked(config.screenshot_config.save_screenshot_in_game_folder);
        save_screenshot_to_clipboard_checkbox_ptr->set_checked(config.screenshot_config.save_screenshot_to_clipboard);
-        show_screenshot_saved_notification_checkbox_ptr->set_checked(config.screenshot_config.show_screenshot_saved_notifications);
+        save_screenshot_to_disk_checkbox_ptr->set_checked(config.screenshot_config.save_screenshot_to_disk);
+        show_notification_checkbox_ptr->set_checked(config.screenshot_config.show_notifications);
+        led_indicator_checkbox_ptr->set_checked(config.screenshot_config.use_led_indicator);

        if(config.screenshot_config.image_width == 0)
            config.screenshot_config.image_width = 1920;
@@ -306,9 +352,13 @@ namespace gsr {
        if(config.screenshot_config.image_height < 32)
            config.screenshot_config.image_height = 32;
        image_height_entry_ptr->set_text(std::to_string(config.screenshot_config.image_height));
+
+        create_custom_script_screenshot_entry_ptr->set_text(config.screenshot_config.custom_script);
    }

    void ScreenshotSettingsPage::save() {
+        Config prev_config = config;
+
        config.screenshot_config.record_area_option = record_area_box_ptr->get_selected_id();
        config.screenshot_config.image_width = atoi(image_width_entry_ptr->get_text().c_str());
        config.screenshot_config.image_height = atoi(image_height_entry_ptr->get_text().c_str());
@@ -320,7 +370,10 @@ namespace gsr {
        config.screenshot_config.save_directory = save_directory_button_ptr->get_text();
        config.screenshot_config.save_screenshot_in_game_folder = save_screenshot_in_game_folder_checkbox_ptr->is_checked();
        config.screenshot_config.save_screenshot_to_clipboard = save_screenshot_to_clipboard_checkbox_ptr->is_checked();
-        config.screenshot_config.show_screenshot_saved_notifications = show_screenshot_saved_notification_checkbox_ptr->is_checked();
+        config.screenshot_config.save_screenshot_to_disk = save_screenshot_to_disk_checkbox_ptr->is_checked();
+        config.screenshot_config.show_notifications = show_notification_checkbox_ptr->is_checked();
+        config.screenshot_config.use_led_indicator = led_indicator_checkbox_ptr->is_checked();
+        config.screenshot_config.custom_script = create_custom_script_screenshot_entry_ptr->get_text();

        if(config.screenshot_config.image_width == 0)
            config.screenshot_config.image_width = 1920;
@@ -339,5 +392,8 @@ namespace gsr {
        }

        save_config(config);
+
+        if(on_config_changed && config != prev_config)
+            on_config_changed();
    }
-}
+}
--- a/src/gui/ScrollablePage.cpp
+++ b/src/gui/ScrollablePage.cpp
@@ -50,7 +50,9 @@ namespace gsr {
            return false;
        }

-        if(event.type == mgl::Event::MouseButtonPressed || event.type == mgl::Event::MouseButtonReleased) {
+        // Pass release to children even if outside area, because we want to be able to release mouse when moved outside,
+        // for example in Entry when selecting text
+        if(event.type == mgl::Event::MouseButtonPressed/* || event.type == mgl::Event::MouseButtonReleased*/) {
            if(!mgl::IntRect(scissor_pos, scissor_size).contains({event.mouse_button.x, event.mouse_button.y}))
                return true;
        } else if(event.type == mgl::Event::MouseMoved) {
--- a/src/gui/SettingsPage.cpp
+++ b/src/gui/SettingsPage.cpp
@@ -4,11 +4,16 @@
 #include "../../include/gui/PageStack.hpp"
 #include "../../include/gui/FileChooser.hpp"
 #include "../../include/gui/Subsection.hpp"
-#include "../../include/gui/Image.hpp"
+#include "../../include/gui/CustomRendererWidget.hpp"
+#include "../../include/gui/Utils.hpp"
 #include "../../include/Theme.hpp"
 #include "../../include/GsrInfo.hpp"
 #include "../../include/Utils.hpp"
+#include "mglpp/window/Window.hpp"
+#include "mglpp/window/Event.hpp"

+#include <algorithm>
+#include <cmath>
 #include <string.h>

 namespace gsr {
@@ -87,7 +92,7 @@ namespace gsr {

    std::unique_ptr<Widget> SettingsPage::create_record_area() {
        auto record_area_list = std::make_unique<List>(List::Orientation::VERTICAL);
-        record_area_list->add_widget(std::make_unique<Label>(&get_theme().body_font, "Capture target:", get_color_theme().text_color));
+        record_area_list->add_widget(std::make_unique<Label>(&get_theme().body_font, "Capture source:", get_color_theme().text_color));
        record_area_list->add_widget(create_record_area_box());
        return record_area_list;
    }
@@ -187,6 +192,216 @@ namespace gsr {
        return std::make_unique<Subsection>("Capture", std::move(ll), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f));
    }

+    std::unique_ptr<List> SettingsPage::create_webcam_sources() {
+        auto ll = std::make_unique<List>(List::Orientation::VERTICAL);
+        ll->add_widget(std::make_unique<Label>(&get_theme().body_font, "Webcam source:", get_color_theme().text_color));
+
+        auto combobox = std::make_unique<ComboBox>(&get_theme().body_font);
+        combobox->add_item("None", "");
+        for(const GsrCamera &camera : capture_options.cameras) {
+            combobox->add_item(camera.path, camera.path);
+        }
+        webcam_sources_box_ptr = combobox.get();
+
+        webcam_sources_box_ptr->on_selection_changed = [this](const std::string&, const std::string &id) {
+            selected_camera = std::nullopt;
+            webcam_video_format_box_ptr->clear_items();
+            if(id == "") {
+                webcam_body_list_ptr->set_visible(false);
+                return;
+            }
+
+            auto it = std::find_if(capture_options.cameras.begin(), capture_options.cameras.end(), [&](const GsrCamera &camera) {
+                return camera.path == id;
+            });
+            if(it == capture_options.cameras.end())
+                return;
+
+            webcam_body_list_ptr->set_visible(true);
+            webcam_video_format_box_ptr->add_item("Auto (recommended)", "auto");
+
+            if(it->supported_pixel_formats.yuyv)
+                webcam_video_format_box_ptr->add_item("YUYV", "yuyv");
+
+            if(it->supported_pixel_formats.mjpeg)
+                webcam_video_format_box_ptr->add_item("Motion-JPEG", "mjpeg");
+
+            webcam_video_format_box_ptr->set_selected_item(get_current_record_options().webcam_video_format);
+            selected_camera = *it;
+        };
+
+        ll->add_widget(std::move(combobox));
+        return ll;
+    }
+
+    std::unique_ptr<List> SettingsPage::create_webcam_video_format() {
+        auto ll = std::make_unique<List>(List::Orientation::VERTICAL);
+        ll->add_widget(std::make_unique<Label>(&get_theme().body_font, "Video format:", get_color_theme().text_color));
+
+        auto combobox = std::make_unique<ComboBox>(&get_theme().body_font);
+        webcam_video_format_box_ptr = combobox.get();
+
+        webcam_video_format_box_ptr->on_selection_changed = [this](const std::string&, const std::string &id) {
+            get_current_record_options().webcam_video_format = id;
+        };
+
+        ll->add_widget(std::move(combobox));
+        return ll;
+    }
+
+    std::unique_ptr<Widget> SettingsPage::create_webcam_location_widget() {
+        const float camera_screen_width = std::min(400.0f, (float)settings_scrollable_page_ptr->get_inner_size().x * 0.90f);
+        camera_screen_size = mgl::vec2f(camera_screen_width, camera_screen_width * 0.5625);
+
+        const float screen_border = 2.0f;
+        const mgl::vec2f screen_border_size(screen_border, screen_border);
+        screen_inner_size = mgl::vec2f(camera_screen_size - screen_border_size*2.0f);
+
+        const mgl::vec2f bounding_box_size(30.0f, 30.0f);
+
+        auto camera_location_widget = std::make_unique<CustomRendererWidget>(camera_screen_size);
+        camera_location_widget->draw_handler = [this, screen_border_size, screen_border](mgl::Window &window, mgl::vec2f pos, mgl::vec2f size) {
+            if(!selected_camera.has_value())
+                return;
+
+            pos = pos.floor();
+            size = size.floor();
+            const mgl::vec2i mouse_pos = window.get_mouse_position();
+            const mgl::vec2f webcam_box_min_size = clamp_keep_aspect_ratio(selected_camera->size.to_vec2f(), screen_inner_size * 0.2f);
+
+            if(moving_webcam_box) {
+                webcam_box_pos = mouse_pos.to_vec2f() - screen_border_size - webcam_box_grab_offset - pos;
+            } else if(webcam_resize_corner == WebcamBoxResizeCorner::BOTTOM_RIGHT) {
+                const mgl::vec2f mouse_diff = mouse_pos.to_vec2f() - webcam_resize_start_pos;
+                webcam_box_size = webcam_box_size_resize_start + mouse_diff;
+            }
+
+            webcam_box_size = clamp_keep_aspect_ratio(selected_camera->size.to_vec2f(), webcam_box_size);
+
+            if(webcam_box_pos.x < 0.0f)
+                webcam_box_pos.x = 0.0f;
+            else if(webcam_box_pos.x + webcam_box_size.x > screen_inner_size.x)
+                webcam_box_pos.x = screen_inner_size.x - webcam_box_size.x;
+
+            if(webcam_box_pos.y < 0.0f)
+                webcam_box_pos.y = 0.0f;
+            else if(webcam_box_pos.y + webcam_box_size.y > screen_inner_size.y)
+                webcam_box_pos.y = screen_inner_size.y - webcam_box_size.y;
+
+            if(webcam_box_size.x < webcam_box_min_size.x)
+                webcam_box_size.x = webcam_box_min_size.x;
+            else if(webcam_box_pos.x + webcam_box_size.x > screen_inner_size.x)
+                webcam_box_size.x = screen_inner_size.x - webcam_box_pos.x;
+
+            //webcam_box_size = clamp_keep_aspect_ratio(selected_camera->size.to_vec2f(), webcam_box_size);
+
+            if(webcam_box_size.y < webcam_box_min_size.y)
+                webcam_box_size.y = webcam_box_min_size.y;
+            else if(webcam_box_pos.y + webcam_box_size.y > screen_inner_size.y)
+                webcam_box_size.y = screen_inner_size.y - webcam_box_pos.y;
+
+            webcam_box_size = clamp_keep_aspect_ratio(selected_camera->size.to_vec2f(), webcam_box_size);
+
+            {
+                draw_rectangle_outline(window, pos, size, mgl::Color(255, 0, 0, 255), screen_border);
+                mgl::Text screen_text("Screen", get_theme().camera_setup_font);
+                screen_text.set_position((pos + size * 0.5f - screen_text.get_bounds().size * 0.5f).floor());
+                window.draw(screen_text);
+            }
+
+            {
+                webcam_box_drawn_size = clamp_keep_aspect_ratio(selected_camera->size.to_vec2f(), webcam_box_size);
+                webcam_box_drawn_pos = (pos + screen_border_size + webcam_box_pos).floor();
+
+                draw_rectangle_outline(window, webcam_box_drawn_pos, webcam_box_drawn_size, mgl::Color(0, 255, 0, 255), screen_border);
+
+                // mgl::Rectangle resize_area(webcam_box_drawn_pos + webcam_box_drawn_size - bounding_box_size*0.5f - screen_border_size*0.5f, bounding_box_size);
+                // resize_area.set_color(mgl::Color(0, 0, 255, 255));
+                // window.draw(resize_area);
+
+                mgl::Text webcam_text("Webcam", get_theme().camera_setup_font);
+                webcam_text.set_position((webcam_box_drawn_pos + webcam_box_drawn_size * 0.5f - webcam_text.get_bounds().size * 0.5f).floor());
+                window.draw(webcam_text);
+            }
+        };
+
+        camera_location_widget->event_handler = [this, screen_border_size, bounding_box_size](mgl::Event &event, mgl::Window&, mgl::vec2f, mgl::vec2f) {
+            switch(event.type) {
+                case mgl::Event::MouseButtonPressed: {
+                    if(event.mouse_button.button == mgl::Mouse::Left && webcam_resize_corner == WebcamBoxResizeCorner::NONE) {
+                        const mgl::vec2f mouse_button_pos(event.mouse_button.x, event.mouse_button.y);
+                        if(mgl::FloatRect(webcam_box_drawn_pos, webcam_box_drawn_size).contains(mouse_button_pos)) {
+                            moving_webcam_box = true;
+                            webcam_box_grab_offset = mouse_button_pos - webcam_box_drawn_pos;
+                        } else {
+                            moving_webcam_box = false;
+                        }
+                    } else if(event.mouse_button.button == mgl::Mouse::Right && !moving_webcam_box) {
+                        const mgl::vec2f mouse_button_pos(event.mouse_button.x, event.mouse_button.y);
+                        webcam_resize_start_pos = mouse_button_pos;
+                        webcam_box_pos_resize_start = webcam_box_pos;
+                        webcam_box_size_resize_start = webcam_box_size;
+                        webcam_box_grab_offset = mouse_button_pos - webcam_box_drawn_pos;
+
+                        /*if(mgl::FloatRect(webcam_box_drawn_pos - bounding_box_size*0.5f, bounding_box_size).contains(mouse_button_pos)) {
+                            webcam_resize_corner = WebcamBoxResizeCorner::TOP_LEFT;
+                            fprintf(stderr, "top left\n");
+                        } else if(mgl::FloatRect(webcam_box_drawn_pos + mgl::vec2f(webcam_box_drawn_size.x, 0.0f) - bounding_box_size*0.5f, bounding_box_size).contains(mouse_button_pos)) {
+                            webcam_resize_corner = WebcamBoxResizeCorner::TOP_RIGHT;
+                            fprintf(stderr, "top right\n");
+                        } else if(mgl::FloatRect(webcam_box_drawn_pos + mgl::vec2f(0.0f, webcam_box_drawn_size.y) - bounding_box_size*0.5f, bounding_box_size).contains(mouse_button_pos)) {
+                            webcam_resize_corner = WebcamBoxResizeCorner::BOTTOM_LEFT;
+                            fprintf(stderr, "bottom left\n");
+                        } else */if(mgl::FloatRect(webcam_box_drawn_pos + webcam_box_drawn_size - bounding_box_size*0.5f - screen_border_size*0.5f, bounding_box_size).contains(mouse_button_pos)) {
+                            webcam_resize_corner = WebcamBoxResizeCorner::BOTTOM_RIGHT;
+                        } else {
+                            webcam_resize_corner = WebcamBoxResizeCorner::NONE;
+                        }
+                    }
+                    break;
+                }
+                case mgl::Event::MouseButtonReleased: {
+                    if(event.mouse_button.button == mgl::Mouse::Left && webcam_resize_corner == WebcamBoxResizeCorner::NONE) {
+                        moving_webcam_box = false;
+                    } else if(event.mouse_button.button == mgl::Mouse::Right && !moving_webcam_box) {
+                        webcam_resize_corner = WebcamBoxResizeCorner::NONE;
+                    }
+                    break;
+                }
+                default: {
+                    break;
+                }
+            }
+            return true;
+        };
+
+        return camera_location_widget;
+    }
+
+    std::unique_ptr<CheckBox> SettingsPage::create_flip_camera_checkbox() {
+        auto flip_camera_horizontally_checkbox = std::make_unique<CheckBox>(&get_theme().body_font, "Flip camera horizontally");
+        flip_camera_horizontally_checkbox_ptr = flip_camera_horizontally_checkbox.get();
+        return flip_camera_horizontally_checkbox;
+    }
+
+    std::unique_ptr<List> SettingsPage::create_webcam_body() {
+        auto body_list = std::make_unique<List>(List::Orientation::VERTICAL);
+        webcam_body_list_ptr = body_list.get();
+        body_list->set_visible(false);
+        body_list->add_widget(create_webcam_location_widget());
+        body_list->add_widget(std::make_unique<Label>(&get_theme().body_font, "* Right click in the bottom right corner to resize the webcam", get_color_theme().text_color));
+        body_list->add_widget(create_flip_camera_checkbox());
+        body_list->add_widget(create_webcam_video_format());
+        return body_list;
+    }
+
+    std::unique_ptr<Widget> SettingsPage::create_webcam_section() {
+        auto ll = std::make_unique<List>(List::Orientation::VERTICAL);
+        ll->add_widget(create_webcam_sources());
+        ll->add_widget(create_webcam_body());
+        return std::make_unique<Subsection>("Webcam", std::move(ll), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f));
+    }
+
    static bool audio_device_is_output(const std::string &audio_device_id) {
        return audio_device_id == "default_output" || ends_with(audio_device_id, ".monitor");
    }
@@ -618,6 +833,7 @@ namespace gsr {
        auto settings_list = std::make_unique<List>(List::Orientation::VERTICAL);
        settings_list->set_spacing(0.018f);
        settings_list->add_widget(create_capture_target_section());
+        settings_list->add_widget(create_webcam_section());
        settings_list->add_widget(create_audio_section());
        settings_list->add_widget(create_video_section());
        settings_list_ptr = settings_list.get();
@@ -821,16 +1037,51 @@ namespace gsr {
        replay_time_label_ptr->set_text(buffer);
    }

-    void SettingsPage::view_changed(bool advanced_view, Subsection *notifications_subsection_ptr) {
+    void SettingsPage::view_changed(bool advanced_view) {
        color_range_list_ptr->set_visible(advanced_view);
        audio_codec_ptr->set_visible(advanced_view);
        video_codec_ptr->set_visible(advanced_view);
        framerate_mode_list_ptr->set_visible(advanced_view);
-        notifications_subsection_ptr->set_visible(advanced_view);
        set_application_audio_options_visible(audio_track_section_list_ptr, advanced_view, *gsr_info);
        settings_scrollable_page_ptr->reset_scroll();
    }

+    RecordOptions& SettingsPage::get_current_record_options() {
+        switch(type) {
+            default:
+                assert(false);
+            case Type::REPLAY: return config.replay_config.record_options;
+            case Type::RECORD: return config.record_config.record_options;
+            case Type::STREAM: return config.streaming_config.record_options;
+        }
+    }
+
+    std::unique_ptr<CheckBox> SettingsPage::create_led_indicator(const char *type) {
+        char label_str[256];
+        snprintf(label_str, sizeof(label_str), "Show %s status with scroll lock led", type);
+
+        auto checkbox = std::make_unique<CheckBox>(&get_theme().body_font, label_str);
+        checkbox->set_checked(false);
+        led_indicator_checkbox_ptr = checkbox.get();
+        return checkbox;
+    }
+
+    std::unique_ptr<CheckBox> SettingsPage::create_notifications(const char *type) {
+        char label_str[256];
+        snprintf(label_str, sizeof(label_str), "Show %s notifications", type);
+        auto checkbox = std::make_unique<CheckBox>(&get_theme().body_font, label_str);
+        checkbox->set_checked(true);
+        show_notification_checkbox_ptr = checkbox.get();
+        return checkbox;
+    }
+
+    std::unique_ptr<List> SettingsPage::create_indicator(const char *type) {
+        auto list = std::make_unique<List>(List::Orientation::VERTICAL);
+        list->add_widget(create_notifications(type));
+        list->add_widget(create_led_indicator(type));
+        return list;
+    }
+
    void SettingsPage::add_replay_widgets() {
        auto file_info_list = std::make_unique<List>(List::Orientation::VERTICAL);
        auto file_info_data_list = std::make_unique<List>(List::Orientation::HORIZONTAL);
@@ -846,33 +1097,13 @@ namespace gsr {
        general_list->add_widget(create_save_replay_in_game_folder());
        if(gsr_info->system_info.gsr_version >= GsrVersion{5, 0, 3})
            general_list->add_widget(create_restart_replay_on_save());
-        settings_list_ptr->add_widget(std::make_unique<Subsection>("General", std::move(general_list), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f)));

+        settings_list_ptr->add_widget(std::make_unique<Subsection>("General", std::move(general_list), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f)));
+        settings_list_ptr->add_widget(std::make_unique<Subsection>("Replay indicator", create_indicator("replay"), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f)));
        settings_list_ptr->add_widget(std::make_unique<Subsection>("Autostart", create_start_replay_automatically(), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f)));

-        auto checkboxes_list = std::make_unique<List>(List::Orientation::VERTICAL);
-
-        auto show_replay_started_notification_checkbox = std::make_unique<CheckBox>(&get_theme().body_font, "Show replay started notification");
-        show_replay_started_notification_checkbox->set_checked(true);
-        show_replay_started_notification_checkbox_ptr = show_replay_started_notification_checkbox.get();
-        checkboxes_list->add_widget(std::move(show_replay_started_notification_checkbox));
-
-        auto show_replay_stopped_notification_checkbox = std::make_unique<CheckBox>(&get_theme().body_font, "Show replay stopped notification");
-        show_replay_stopped_notification_checkbox->set_checked(true);
-        show_replay_stopped_notification_checkbox_ptr = show_replay_stopped_notification_checkbox.get();
-        checkboxes_list->add_widget(std::move(show_replay_stopped_notification_checkbox));
-
-        auto show_replay_saved_notification_checkbox = std::make_unique<CheckBox>(&get_theme().body_font, "Show replay saved notification");
-        show_replay_saved_notification_checkbox->set_checked(true);
-        show_replay_saved_notification_checkbox_ptr = show_replay_saved_notification_checkbox.get();
-        checkboxes_list->add_widget(std::move(show_replay_saved_notification_checkbox));
-
-        auto notifications_subsection = std::make_unique<Subsection>("Notifications", std::move(checkboxes_list), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f));        
-        Subsection *notifications_subsection_ptr = notifications_subsection.get();
-        settings_list_ptr->add_widget(std::move(notifications_subsection));
-
-        view_radio_button_ptr->on_selection_changed = [this, notifications_subsection_ptr](const std::string&, const std::string &id) {
-            view_changed(id == "advanced", notifications_subsection_ptr);
+        view_radio_button_ptr->on_selection_changed = [this](const std::string&, const std::string &id) {
+            view_changed(id == "advanced");
            return true;
        };
        view_radio_button_ptr->on_selection_changed("Simple", "simple");
@@ -913,37 +1144,21 @@ namespace gsr {
    void SettingsPage::add_record_widgets() {
        auto file_info_list = std::make_unique<List>(List::Orientation::VERTICAL);
        auto file_info_data_list = std::make_unique<List>(List::Orientation::HORIZONTAL);
-        file_info_data_list->add_widget(create_save_directory("Directory to save the video:"));
+        file_info_data_list->add_widget(create_save_directory("Directory to save videos:"));
        file_info_data_list->add_widget(create_container_section());
        file_info_list->add_widget(std::move(file_info_data_list));
        file_info_list->add_widget(create_estimated_record_file_size());
+
        settings_list_ptr->add_widget(std::make_unique<Subsection>("File info", std::move(file_info_list), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f)));

-        settings_list_ptr->add_widget(std::make_unique<Subsection>("General", create_save_recording_in_game_folder(), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f)));
+        auto general_list = std::make_unique<List>(List::Orientation::VERTICAL);
+        general_list->add_widget(create_save_recording_in_game_folder());

-        auto checkboxes_list = std::make_unique<List>(List::Orientation::VERTICAL);
+        settings_list_ptr->add_widget(std::make_unique<Subsection>("General", std::move(general_list), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f)));
+        settings_list_ptr->add_widget(std::make_unique<Subsection>("Recording indicator", create_indicator("recording"), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f)));

-        auto show_recording_started_notification_checkbox = std::make_unique<CheckBox>(&get_theme().body_font, "Show recording started notification");
-        show_recording_started_notification_checkbox->set_checked(true);
-        show_recording_started_notification_checkbox_ptr = show_recording_started_notification_checkbox.get();
-        checkboxes_list->add_widget(std::move(show_recording_started_notification_checkbox));
-
-        auto show_video_saved_notification_checkbox = std::make_unique<CheckBox>(&get_theme().body_font, "Show video saved notification");
-        show_video_saved_notification_checkbox->set_checked(true);
-        show_video_saved_notification_checkbox_ptr = show_video_saved_notification_checkbox.get();
-        checkboxes_list->add_widget(std::move(show_video_saved_notification_checkbox));
-
-        auto show_video_paused_notification_checkbox = std::make_unique<CheckBox>(&get_theme().body_font, "Show video paused/unpaused notification");
-        show_video_paused_notification_checkbox->set_checked(true);
-        show_video_paused_notification_checkbox_ptr = show_video_paused_notification_checkbox.get();
-        checkboxes_list->add_widget(std::move(show_video_paused_notification_checkbox));
-
-        auto notifications_subsection = std::make_unique<Subsection>("Notifications", std::move(checkboxes_list), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f));        
-        Subsection *notifications_subsection_ptr = notifications_subsection.get();
-        settings_list_ptr->add_widget(std::move(notifications_subsection));
-
-        view_radio_button_ptr->on_selection_changed = [this, notifications_subsection_ptr](const std::string&, const std::string &id) {
-            view_changed(id == "advanced", notifications_subsection_ptr);
+        view_radio_button_ptr->on_selection_changed = [this](const std::string&, const std::string &id) {
+            view_changed(id == "advanced");
            return true;
        };
        view_radio_button_ptr->on_selection_changed("Simple", "simple");
@@ -1063,23 +1278,14 @@ namespace gsr {
        streaming_info_list->add_widget(create_streaming_service_section());
        streaming_info_list->add_widget(create_stream_key_section());
        streaming_info_list->add_widget(create_stream_custom_section());
+
        settings_list_ptr->add_widget(std::make_unique<Subsection>("Streaming info", std::move(streaming_info_list), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f)));

-        auto checkboxes_list = std::make_unique<List>(List::Orientation::VERTICAL);
+        auto general_list = std::make_unique<List>(List::Orientation::VERTICAL);
+        general_list->add_widget(create_save_recording_in_game_folder());

-        auto show_streaming_started_notification_checkbox = std::make_unique<CheckBox>(&get_theme().body_font, "Show streaming started notification");
-        show_streaming_started_notification_checkbox->set_checked(true);
-        show_streaming_started_notification_checkbox_ptr = show_streaming_started_notification_checkbox.get();
-        checkboxes_list->add_widget(std::move(show_streaming_started_notification_checkbox));
-
-        auto show_streaming_stopped_notification_checkbox = std::make_unique<CheckBox>(&get_theme().body_font, "Show streaming stopped notification");
-        show_streaming_stopped_notification_checkbox->set_checked(true);
-        show_streaming_stopped_notification_checkbox_ptr = show_streaming_stopped_notification_checkbox.get();
-        checkboxes_list->add_widget(std::move(show_streaming_stopped_notification_checkbox));
-
-        auto notifications_subsection = std::make_unique<Subsection>("Notifications", std::move(checkboxes_list), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f));        
-        Subsection *notifications_subsection_ptr = notifications_subsection.get();
-        settings_list_ptr->add_widget(std::move(notifications_subsection));
+        settings_list_ptr->add_widget(std::make_unique<Subsection>("General", std::move(general_list), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f)));
+        settings_list_ptr->add_widget(std::make_unique<Subsection>("Streaming indicator", create_indicator("streaming"), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f)));

        streaming_service_box_ptr->on_selection_changed = [this](const std::string&, const std::string &id) {
            const bool twitch_option = id == "twitch";
@@ -1095,8 +1301,8 @@ namespace gsr {
        };
        streaming_service_box_ptr->on_selection_changed("Twitch", "twitch");

-        view_radio_button_ptr->on_selection_changed = [this, notifications_subsection_ptr](const std::string&, const std::string &id) {
-            view_changed(id == "advanced", notifications_subsection_ptr);
+        view_radio_button_ptr->on_selection_changed = [this](const std::string&, const std::string &id) {
+            view_changed(id == "advanced");
            return true;
        };
        view_radio_button_ptr->on_selection_changed("Simple", "simple");
@@ -1217,6 +1423,19 @@ namespace gsr {
        //record_options.overclock = false;
        record_cursor_checkbox_ptr->set_checked(record_options.record_cursor);
        restore_portal_session_checkbox_ptr->set_checked(record_options.restore_portal_session);
+        show_notification_checkbox_ptr->set_checked(record_options.show_notifications);
+        led_indicator_checkbox_ptr->set_checked(record_options.use_led_indicator);
+
+        webcam_sources_box_ptr->set_selected_item(record_options.webcam_source);
+        flip_camera_horizontally_checkbox_ptr->set_checked(record_options.webcam_flip_horizontally);
+        webcam_video_format_box_ptr->set_selected_item(record_options.webcam_video_format);
+        webcam_box_pos.x = ((float)record_options.webcam_x / 100.0f) * screen_inner_size.x;
+        webcam_box_pos.y = ((float)record_options.webcam_y / 100.0f) * screen_inner_size.y;
+        webcam_box_size.x = ((float)record_options.webcam_width / 100.0f * screen_inner_size.x);
+        webcam_box_size.y = ((float)record_options.webcam_height / 100.0f * screen_inner_size.y);
+
+        if(selected_camera.has_value())
+            webcam_box_size = clamp_keep_aspect_ratio(selected_camera->size.to_vec2f(), webcam_box_size);

        if(record_options.record_area_width == 0)
            record_options.record_area_width = 1920;
@@ -1262,9 +1481,7 @@ namespace gsr {
        save_replay_in_game_folder_ptr->set_checked(config.replay_config.save_video_in_game_folder);
        if(restart_replay_on_save)
            restart_replay_on_save->set_checked(config.replay_config.restart_replay_on_save);
-        show_replay_started_notification_checkbox_ptr->set_checked(config.replay_config.show_replay_started_notifications);
-        show_replay_stopped_notification_checkbox_ptr->set_checked(config.replay_config.show_replay_stopped_notifications);
-        show_replay_saved_notification_checkbox_ptr->set_checked(config.replay_config.show_replay_saved_notifications);
+        
        save_directory_button_ptr->set_text(config.replay_config.save_directory);
        container_box_ptr->set_selected_item(config.replay_config.container);

@@ -1278,17 +1495,12 @@ namespace gsr {
    void SettingsPage::load_record() {
        load_common(config.record_config.record_options);
        save_recording_in_game_folder_ptr->set_checked(config.record_config.save_video_in_game_folder);
-        show_recording_started_notification_checkbox_ptr->set_checked(config.record_config.show_recording_started_notifications);
-        show_video_saved_notification_checkbox_ptr->set_checked(config.record_config.show_video_saved_notifications);
-        show_video_paused_notification_checkbox_ptr->set_checked(config.record_config.show_video_paused_notifications);
        save_directory_button_ptr->set_text(config.record_config.save_directory);
        container_box_ptr->set_selected_item(config.record_config.container);
    }

    void SettingsPage::load_stream() {
        load_common(config.streaming_config.record_options);
-        show_streaming_started_notification_checkbox_ptr->set_checked(config.streaming_config.show_streaming_started_notifications);
-        show_streaming_stopped_notification_checkbox_ptr->set_checked(config.streaming_config.show_streaming_stopped_notifications);
        streaming_service_box_ptr->set_selected_item(config.streaming_config.streaming_service);
        youtube_stream_key_entry_ptr->set_text(config.streaming_config.youtube.stream_key);
        twitch_stream_key_entry_ptr->set_text(config.streaming_config.twitch.stream_key);
@@ -1354,6 +1566,19 @@ namespace gsr {
        //record_options.overclock = false;
        record_options.record_cursor = record_cursor_checkbox_ptr->is_checked();
        record_options.restore_portal_session = restore_portal_session_checkbox_ptr->is_checked();
+        record_options.show_notifications = show_notification_checkbox_ptr->is_checked();
+        record_options.use_led_indicator = led_indicator_checkbox_ptr->is_checked();
+
+        if(selected_camera.has_value())
+            webcam_box_size = clamp_keep_aspect_ratio(selected_camera->size.to_vec2f(), webcam_box_size);
+
+        record_options.webcam_source = webcam_sources_box_ptr->get_selected_id();
+        record_options.webcam_flip_horizontally = flip_camera_horizontally_checkbox_ptr->is_checked();
+        record_options.webcam_video_format = webcam_video_format_box_ptr->get_selected_id();
+        record_options.webcam_x = std::round((webcam_box_pos.x / screen_inner_size.x) * 100.0f);
+        record_options.webcam_y = std::round((webcam_box_pos.y / screen_inner_size.y) * 100.0f);
+        record_options.webcam_width = std::round((webcam_box_size.x / screen_inner_size.x) * 100.0f);
+        record_options.webcam_height = std::round((webcam_box_size.y / screen_inner_size.y) * 100.0f);

        if(record_options.record_area_width == 0)
            record_options.record_area_width = 1920;
@@ -1404,9 +1629,6 @@ namespace gsr {
        config.replay_config.save_video_in_game_folder = save_replay_in_game_folder_ptr->is_checked();
        if(restart_replay_on_save)
            config.replay_config.restart_replay_on_save = restart_replay_on_save->is_checked();
-        config.replay_config.show_replay_started_notifications = show_replay_started_notification_checkbox_ptr->is_checked();
-        config.replay_config.show_replay_stopped_notifications = show_replay_stopped_notification_checkbox_ptr->is_checked();
-        config.replay_config.show_replay_saved_notifications = show_replay_saved_notification_checkbox_ptr->is_checked();
        config.replay_config.save_directory = save_directory_button_ptr->get_text();
        config.replay_config.container = container_box_ptr->get_selected_id();
        config.replay_config.replay_time = atoi(replay_time_entry_ptr->get_text().c_str());
@@ -1421,17 +1643,12 @@ namespace gsr {
    void SettingsPage::save_record() {
        save_common(config.record_config.record_options);
        config.record_config.save_video_in_game_folder = save_recording_in_game_folder_ptr->is_checked();
-        config.record_config.show_recording_started_notifications = show_recording_started_notification_checkbox_ptr->is_checked();
-        config.record_config.show_video_saved_notifications = show_video_saved_notification_checkbox_ptr->is_checked();
-        config.record_config.show_video_paused_notifications = show_video_paused_notification_checkbox_ptr->is_checked();
        config.record_config.save_directory = save_directory_button_ptr->get_text();
        config.record_config.container = container_box_ptr->get_selected_id();
    }

    void SettingsPage::save_stream() {
        save_common(config.streaming_config.record_options);
-        config.streaming_config.show_streaming_started_notifications = show_streaming_started_notification_checkbox_ptr->is_checked();
-        config.streaming_config.show_streaming_stopped_notifications = show_streaming_stopped_notification_checkbox_ptr->is_checked();
        config.streaming_config.streaming_service = streaming_service_box_ptr->get_selected_id();
        config.streaming_config.youtube.stream_key = youtube_stream_key_entry_ptr->get_text();
        config.streaming_config.twitch.stream_key = twitch_stream_key_entry_ptr->get_text();
--- a/src/gui/Utils.cpp
+++ b/src/gui/Utils.cpp
@@ -5,15 +5,15 @@
 namespace gsr {
    static double frame_delta_seconds = 1.0;

-    static mgl::vec2i min_vec2i(mgl::vec2i a, mgl::vec2i b) {
+    mgl::vec2i min_vec2i(mgl::vec2i a, mgl::vec2i b) {
        return { std::min(a.x, b.x), std::min(a.y, b.y) };
    }

-    static mgl::vec2i max_vec2i(mgl::vec2i a, mgl::vec2i b) {
+    mgl::vec2i max_vec2i(mgl::vec2i a, mgl::vec2i b) {
        return { std::max(a.x, b.x), std::max(a.y, b.y) };
    }

-    static mgl::vec2i clamp_vec2i(mgl::vec2i value, mgl::vec2i min, mgl::vec2i max) {
+    mgl::vec2i clamp_vec2i(mgl::vec2i value, mgl::vec2i min, mgl::vec2i max) {
        return min_vec2i(max, max_vec2i(value, min));
    }

@@ -91,7 +91,7 @@ namespace gsr {
        const mgl::vec2i pos = clamp_vec2i(child.position, parent.position, parent.position + parent.size);
        return mgl::Scissor{
            pos,
-            min_vec2i(child.size, parent.position + parent.size - pos)
+            max_vec2i(mgl::vec2i(0, 0), min_vec2i(child.position + child.size - pos, parent.position + parent.size - pos))
        };
    }
 }
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -3,6 +3,7 @@
 #include "../include/gui/Utils.hpp"
 #include "../include/Process.hpp"
 #include "../include/Rpc.hpp"
+#include "../include/Theme.hpp"

 #include <signal.h>
 #include <string.h>
@@ -23,8 +24,10 @@ extern "C" {
 }

 static sig_atomic_t running = 1;
+static sig_atomic_t killed = 0;
 static void sigint_handler(int signal) {
    (void)signal;
+    killed = 1;
    running = 0;
 }

@@ -162,9 +165,10 @@ static void set_display_server_environment_variables() {
 static void usage() {
    printf("usage: gsr-ui [action]\n");
    printf("OPTIONS:\n");
-    printf("  action  The launch action. Should be either \"launch-show\", \"launch-hide\" or \"launch-daemon\". Optional, defaults to \"launch-hide\".\n");
+    printf("  action  The launch action. Should be either \"launch-show\", \"launch-hide\", \"launch-hide-announce\" or \"launch-daemon\". Optional, defaults to \"launch-hide\".\n");
    printf("          If \"launch-show\" is used then the program starts and the UI is immediately opened and can be shown/hidden with Alt+Z.\n");
    printf("          If \"launch-hide\" is used then the program starts but the UI is not opened until Alt+Z is pressed. The UI will be opened if the program is already running in another process.\n");
+    printf("          If \"launch-hide-announce\" is used then the program starts but the UI is not opened until Alt+Z is pressed and a notification tells the user to press Alt+Z. The UI will be opened if the program is already running in another process.\n");
    printf("          If \"launch-daemon\" is used then the program starts but the UI is not opened until Alt+Z is pressed. The UI will not be opened if the program is already running in another process.\n");
    exit(1);
 }
@@ -172,6 +176,7 @@ static void usage() {
 enum class LaunchAction {
    LAUNCH_SHOW,
    LAUNCH_HIDE,
+    LAUNCH_HIDE_ANNOUNCE,
    LAUNCH_DAEMON
 };

@@ -195,10 +200,12 @@ int main(int argc, char **argv) {
            launch_action = LaunchAction::LAUNCH_SHOW;
        } else if(strcmp(launch_action_opt, "launch-hide") == 0) {
            launch_action = LaunchAction::LAUNCH_HIDE;
+        } else if(strcmp(launch_action_opt, "launch-hide-announce") == 0) {
+            launch_action = LaunchAction::LAUNCH_HIDE_ANNOUNCE;
        } else if(strcmp(launch_action_opt, "launch-daemon") == 0) {
            launch_action = LaunchAction::LAUNCH_DAEMON;
        } else {
-            printf("error: invalid action \"%s\", expected \"launch-show\", \"launch-hide\" or \"launch-daemon\".\n", launch_action_opt);
+            printf("error: invalid action \"%s\", expected \"launch-show\", \"launch-hide\", \"launch-hide-announce\" or \"launch-daemon\".\n", launch_action_opt);
            usage();
        }
    } else {
@@ -207,6 +214,19 @@ int main(int argc, char **argv) {

    set_display_server_environment_variables();

+    std::string resources_path;
+    if(access("sibs-build/linux_x86_64/debug/gsr-ui", F_OK) == 0) {
+        resources_path = "./";
+    } else {
+#ifdef GSR_UI_RESOURCES_PATH
+        resources_path = GSR_UI_RESOURCES_PATH "/";
+#else
+        resources_path = "/usr/share/gsr-ui/";
+#endif
+    }
+
+    const std::string gsr_icon_path = resources_path + "images/gpu_screen_recorder_logo.png";
+
    auto rpc = std::make_unique<gsr::Rpc>();
    const gsr::RpcOpenResult rpc_open_result = rpc->open("gsr-ui");

@@ -218,7 +238,10 @@ int main(int argc, char **argv) {
            fprintf(stderr, "Error: another instance of gsr-ui is already running, opening that one instead\n");
        } else {
            fprintf(stderr, "Error: failed to send command to running gsr-ui instance, user will have to open the UI manually with Alt+Z\n");
-            const char *args[] = { "gsr-notify", "--text", "Another instance of GPU Screen Recorder UI is already running.\nPress Alt+Z to open the UI.", "--timeout", "5.0", "--icon-color", "ff0000", "--bg-color", "ff0000", nullptr };
+            const char *args[] = {
+                "gsr-notify", "--text", "Another instance of GPU Screen Recorder UI is already running.\nPress Alt+Z to open the UI.", "--timeout", "5.0",
+                "--icon-color", "ffffff", "--icon", gsr_icon_path.c_str(), "--bg-color", "ff0000", nullptr
+            };
            gsr::exec_program_daemonized(args);
        }
        return 1;
@@ -228,7 +251,10 @@ int main(int argc, char **argv) {
        fprintf(stderr, "Error: Failed to create rpc\n");

    if(gsr::pidof("gpu-screen-recorder", -1) != -1) {
-        const char *args[] = { "gsr-notify", "--text", "GPU Screen Recorder is already running in another process.\nPlease close it before using GPU Screen Recorder UI.", "--timeout", "5.0", "--icon-color", "ff0000", "--bg-color", "ff0000", nullptr };
+        const char *args[] = {
+            "gsr-notify", "--text", "GPU Screen Recorder is already running in another process.\nPlease close it before using GPU Screen Recorder UI.",
+            "--timeout", "5.0", "--icon-color", "ffffff", "--icon", gsr_icon_path.c_str(), "--bg-color", "ff0000", nullptr
+        };
        gsr::exec_program_daemonized(args);
    }

@@ -282,17 +308,6 @@ int main(int argc, char **argv) {

    gsr::SupportedCaptureOptions capture_options = gsr::get_supported_capture_options(gsr_info);

-    std::string resources_path;
-    if(access("sibs-build/linux_x86_64/debug/gsr-ui", F_OK) == 0) {
-        resources_path = "./";
-    } else {
-#ifdef GSR_UI_RESOURCES_PATH
-        resources_path = GSR_UI_RESOURCES_PATH "/";
-#else
-        resources_path = "/usr/share/gsr-ui/";
-#endif
-    }
-
    mgl_context *context = mgl_get_context();

    egl_functions egl_funcs;
@@ -311,6 +326,8 @@ int main(int argc, char **argv) {
    auto overlay = std::make_unique<gsr::Overlay>(resources_path, std::move(gsr_info), std::move(capture_options), egl_funcs);
    if(launch_action == LaunchAction::LAUNCH_SHOW)
        overlay->show();
+    else if(launch_action == LaunchAction::LAUNCH_HIDE_ANNOUNCE)
+        overlay->show_notification("Press Alt+Z to open the GPU Screen Recorder UI", 5.0, mgl::Color(255, 255, 255), gsr::get_color_theme().tint_color, gsr::NotificationType::NOTICE, nullptr, gsr::NotificationLevel::ERROR);

    rpc_add_commands(rpc.get(), overlay.get());

@@ -331,6 +348,8 @@ int main(int argc, char **argv) {
        }
    }

+    const bool connected_to_display_server = mgl_is_connected_to_display_server();
+
    fprintf(stderr, "Info: shutting down!\n");
    rpc.reset();
    overlay.reset();
@@ -344,5 +363,11 @@ int main(int argc, char **argv) {
        return 0;
    }

-    return mgl_is_connected_to_display_server() ? 0 : 1;
+    if(killed)
+        return 0;
+
+    if(connected_to_display_server)
+        return 1;
+
+    return 0;
 }
--- a/tools/gsr-global-hotkeys/README.md
+++ b/tools/gsr-global-hotkeys/README.md
@@ -24,4 +24,9 @@ To close gsr-global-hotkeys send `exit<newline>` to the programs stdin, for exam
 ```
 exit

-```
+```
+# Conflict with other keyboard software
+Some keyboard remapping software such as keyd may conflict with gsr-global-hotkeys if configured incorrect (if it's configured to grab all devices, including gsr-ui virtual keyboard).
+If that happens it may grab gsr-ui-virtual keyboard while gsr-global-hotkeys will grab the keyboard remapping software virtual device, leading to a circular lock, making it not possible
+to use your keyboard. gsr-global-hotkeys detects this and outputs `gsr-ui-virtual-keyboard-grabbed` to stdout. You can listen to this and stop gsr-global-hotkeys or restart it with `--no-grab`
+option to only listen to devices, not grabbing them.
--- a/tools/gsr-global-hotkeys/keyboard_event.c
+++ b/tools/gsr-global-hotkeys/keyboard_event.c
@@ -1,5 +1,6 @@
 #include "keyboard_event.h"
 #include "keys.h"
+#include "leds.h"

 /* C stdlib */
 #include <stdio.h>
@@ -7,6 +8,7 @@
 #include <errno.h>
 #include <stdbool.h>
 #include <stdlib.h>
+#include <time.h>

 /* POSIX */
 #include <fcntl.h>
@@ -17,6 +19,7 @@
 /* LINUX */
 #include <linux/input.h>
 #include <linux/uinput.h>
+#include <sys/timerfd.h>

 #define GSR_UI_VIRTUAL_KEYBOARD_NAME "gsr-ui virtual keyboard"

@@ -26,6 +29,14 @@

 #define KEY_STATES_SIZE (KEY_MAX/8 + 1)

+static double clock_get_monotonic_seconds(void) {
+    struct timespec ts;
+    ts.tv_sec = 0;
+    ts.tv_nsec = 0;
+    clock_gettime(CLOCK_MONOTONIC, &ts);
+    return (double)ts.tv_sec + (double)ts.tv_nsec * 0.000000001;
+}
+
 static inline int count_num_bits_set(unsigned char c) {
    int n = 0;
    n += (c & 1);
@@ -183,6 +194,15 @@ static void keyboard_event_process_input_event_data(keyboard_event *self, event_
        return;
    }

+    if(extra_data->gsr_ui_virtual_keyboard) {
+        if(event.type == EV_KEY || event.type == EV_MSC)
+            self->check_grab_lock = false;
+        return;
+    }
+
+    if(extra_data->is_non_keyboard_device)
+        return;
+
    if(event.type == EV_SYN && event.code == SYN_DROPPED) {
        /* TODO: Don't do this on every SYN_DROPPED to prevent spamming this, instead wait until the next event or wait for timeout */
        keyboard_event_fetch_update_key_states(self, extra_data, fd);
@@ -193,6 +213,8 @@ static void keyboard_event_process_input_event_data(keyboard_event *self, event_
        //fprintf(stderr, "fd: %d, type: %d, pressed %d, value: %d\n", fd, event.type, event.code, event.value);
    //}

+    const bool prev_grabbed = extra_data->grabbed;
+
    const bool keyboard_key = is_keyboard_key(event.code);
    if(event.type == EV_KEY && keyboard_key) {
        keyboard_event_process_key_state_change(self, &event, extra_data, fd);
@@ -211,6 +233,11 @@ static void keyboard_event_process_input_event_data(keyboard_event *self, event_
    }

    if(extra_data->grabbed) {
+        if(prev_grabbed && !self->check_grab_lock && (event.type == EV_KEY || event.type == EV_MSC)) {
+            self->uinput_written_time_seconds = clock_get_monotonic_seconds();
+            self->check_grab_lock = true;
+        }
+
        /* TODO: What to do on error? */
        if(write(self->uinput_fd, &event, sizeof(event)) != sizeof(event))
            fprintf(stderr, "Error: failed to write event data to virtual keyboard for exclusively grabbed device\n");
@@ -368,7 +395,7 @@ static bool keyboard_event_try_add_device_if_keyboard(keyboard_event *self, cons
    if(keyboard_event_has_event_with_dev_input_fd(self, dev_input_id))
        return false;

-    const int fd = open(dev_input_filepath, O_RDONLY);
+    const int fd = open(dev_input_filepath, O_RDWR);
    if(fd == -1)
        return false;

@@ -380,7 +407,29 @@ static bool keyboard_event_try_add_device_if_keyboard(keyboard_event *self, cons
    ioctl(fd, EVIOCGBIT(0, sizeof(evbit)), &evbit);
    const bool is_keyboard = (evbit & (1 << EV_SYN)) && (evbit & (1 << EV_KEY));

-    if(is_keyboard && strcmp(device_name, GSR_UI_VIRTUAL_KEYBOARD_NAME) != 0) {
+    if(strcmp(device_name, GSR_UI_VIRTUAL_KEYBOARD_NAME) == 0) {
+        if(self->num_event_polls < MAX_EVENT_POLLS) {
+            self->event_polls[self->num_event_polls] = (struct pollfd) {
+                .fd = fd,
+                .events = POLLIN,
+                .revents = 0
+            };
+
+            self->event_extra_data[self->num_event_polls] = (event_extra_data) {
+                .dev_input_id = dev_input_id,
+                .grabbed = false,
+                .key_states = NULL,
+                .key_presses_grabbed = NULL,
+                .num_keys_pressed = 0,
+                .gsr_ui_virtual_keyboard = true
+            };
+
+            ++self->num_event_polls;
+            return true;
+        } else {
+            fprintf(stderr, "Error: failed to listen to gsr-ui virtual keyboard\n");
+        }
+    } else if(is_keyboard) {
        unsigned char key_bits[KEY_MAX/8 + 1] = {0};
        ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(key_bits)), &key_bits);

@@ -510,10 +559,12 @@ static int setup_virtual_keyboard_input(const char *name) {
        if(is_keyboard_key(i) || is_mouse_button(i))
            success &= (ioctl(fd, UI_SET_KEYBIT, i) != -1);
    }
+
    for(int i = 0; i < REL_MAX; ++i) {
        success &= (ioctl(fd, UI_SET_RELBIT, i) != -1);
    }
-    // for(int i = 0; i < LED_MAX; ++i) {
+
+    // for(int i = 0; i <= LED_CHARGING; ++i) {
    //     success &= (ioctl(fd, UI_SET_LEDBIT, i) != -1);
    // }

@@ -552,7 +603,6 @@ static int setup_virtual_keyboard_input(const char *name) {

 bool keyboard_event_init(keyboard_event *self, bool exclusive_grab, keyboard_grab_type grab_type) {
    memset(self, 0, sizeof(*self));
-    self->stdin_event_index = -1;
    self->hotplug_event_index = -1;
    self->grab_type = grab_type;
    self->running = true;
@@ -584,9 +634,51 @@ bool keyboard_event_init(keyboard_event *self, bool exclusive_grab, keyboard_gra
        .num_keys_pressed = 0
    };

-    self->stdin_event_index = self->num_event_polls;
    ++self->num_event_polls;

+    self->timer_fd = timerfd_create(CLOCK_MONOTONIC, 0);
+    if(self->timer_fd <= 0) {
+        fprintf(stderr, "Error: timerfd_create failed\n");
+        keyboard_event_deinit(self);
+        return false;
+    }
+
+    self->event_polls[self->num_event_polls] = (struct pollfd) {
+        .fd = self->timer_fd,
+        .events = POLLIN,
+        .revents = 0
+    };
+
+    self->event_extra_data[self->num_event_polls] = (event_extra_data) {
+        .dev_input_id = -1,
+        .grabbed = false,
+        .key_states = NULL,
+        .key_presses_grabbed = NULL,
+        .num_keys_pressed = 0
+    };
+
+    ++self->num_event_polls;
+
+    /* 0.5 seconds */
+    const struct itimerspec timer_value = {
+        .it_value = (struct timespec) {
+            .tv_sec = 0,
+            .tv_nsec = 500000000ULL,
+        },
+        .it_interval = (struct timespec) {
+            .tv_sec = 0,
+            .tv_nsec = 500000000ULL
+        }
+    };
+
+    if(timerfd_settime(self->timer_fd, 0, &timer_value, NULL) < 0) {
+        fprintf(stderr, "Error: timerfd_settime failed\n");
+        keyboard_event_deinit(self);
+        return false;
+    }
+
+    self->uinput_written_time_seconds = clock_get_monotonic_seconds();
+
    if(hotplug_event_init(&self->hotplug_ev)) {
        self->event_polls[self->num_event_polls] = (struct pollfd) {
            .fd = hotplug_event_steal_fd(&self->hotplug_ev),
@@ -619,6 +711,41 @@ bool keyboard_event_init(keyboard_event *self, bool exclusive_grab, keyboard_gra
    return true;
 }

+static void write_led_data_to_device(int fd, uint16_t led, int value) {
+    struct input_event led_data = {
+        .type = EV_LED,
+        .code = led,
+        .value = value
+    };
+    write(fd, &led_data, sizeof(led_data));
+
+    struct input_event syn_data = {
+        .type = EV_SYN,
+        .code = 0,
+        .value = 0
+    };
+    write(fd, &syn_data, sizeof(syn_data));
+}
+
+/* When the device is ungrabbed the leds are unset for some reason. Set them back to their previous brightness */
+static void keyboard_event_device_deinit(int fd, event_extra_data *extra_data) {
+    ggh_leds leds;
+    const bool got_leds = get_leds(extra_data->dev_input_id, &leds);
+
+    ioctl(fd, EVIOCGRAB, 0);
+    if(got_leds) {
+        if(leds.scroll_lock_brightness >= 0)
+            write_led_data_to_device(fd, LED_SCROLLL, leds.scroll_lock_brightness);
+
+        if(leds.num_lock_brightness >= 0)
+            write_led_data_to_device(fd, LED_NUML, leds.num_lock_brightness);
+
+        if(leds.caps_lock_brightness >= 0)
+            write_led_data_to_device(fd, LED_CAPSL, leds.caps_lock_brightness);
+    }
+    close(fd);
+}
+
 void keyboard_event_deinit(keyboard_event *self) {
    self->running = false;

@@ -635,8 +762,10 @@ void keyboard_event_deinit(keyboard_event *self) {

    for(int i = 0; i < self->num_event_polls; ++i) {
        if(self->event_polls[i].fd > 0) {
-            ioctl(self->event_polls[i].fd, EVIOCGRAB, 0);
-            close(self->event_polls[i].fd);
+            if(self->event_extra_data[i].dev_input_id > 0 && !self->event_extra_data[i].gsr_ui_virtual_keyboard)
+                keyboard_event_device_deinit(self->event_polls[i].fd, &self->event_extra_data[i]);
+            else
+                close(self->event_polls[i].fd);
        }
        free(self->event_extra_data[i].key_states);
        free(self->event_extra_data[i].key_presses_grabbed);
@@ -830,7 +959,7 @@ void keyboard_event_poll_events(keyboard_event *self, int timeout_milliseconds)
        return;

    for(int i = 0; i < self->num_event_polls; ++i) {
-        if(i == self->stdin_event_index && (self->event_polls[i].revents & (POLLHUP|POLLERR)))
+        if(self->event_polls[i].fd == STDIN_FILENO && (self->event_polls[i].revents & (POLLHUP|POLLERR)))
            self->stdin_failed = true;

        if(self->event_polls[i].revents & POLLHUP) { /* TODO: What if this is the hotplug fd? */
@@ -845,8 +974,17 @@ void keyboard_event_poll_events(keyboard_event *self, int timeout_milliseconds)
        if(i == self->hotplug_event_index) {
            /* Device is added to end of |event_polls| so it's ok to add while iterating it via index */
            hotplug_event_process_event_data(&self->hotplug_ev, self->event_polls[i].fd, on_device_added_callback, self);
-        } else if(i == self->stdin_event_index) {
+        } else if(self->event_polls[i].fd == STDIN_FILENO) {
            keyboard_event_process_stdin_command_data(self, self->event_polls[i].fd);
+        } else if(self->event_polls[i].fd == self->timer_fd) {
+            uint64_t timers_elapsed = 0;
+            read(self->timer_fd, &timers_elapsed, sizeof(timers_elapsed));
+
+            if(self->grab_type != KEYBOARD_GRAB_TYPE_NO_GRAB && self->check_grab_lock && clock_get_monotonic_seconds() - self->uinput_written_time_seconds >= 1.5) {
+                self->check_grab_lock = false;
+                puts("gsr-ui-virtual-keyboard-grabbed");
+                fflush(stdout);
+            }
        } else {
            keyboard_event_process_input_event_data(self, &self->event_extra_data[i], self->event_polls[i].fd);
        }
--- a/tools/gsr-global-hotkeys/keyboard_event.h
+++ b/tools/gsr-global-hotkeys/keyboard_event.h
@@ -18,7 +18,7 @@

 #define MAX_EVENT_POLLS 32
 #define MAX_CLOSE_FDS 256
-#define MAX_GLOBAL_HOTKEYS 32
+#define MAX_GLOBAL_HOTKEYS 40

 typedef enum {
    KEYBOARD_MODKEY_LALT   = 1 << 0,
@@ -41,6 +41,7 @@ typedef struct {
    bool grabbed;
    bool is_non_keyboard_device;
    bool is_possibly_non_keyboard_device;
+    bool gsr_ui_virtual_keyboard;
    unsigned char *key_states;
    unsigned char *key_presses_grabbed;
    int num_keys_pressed;
@@ -48,7 +49,8 @@ typedef struct {

 typedef enum {
    KEYBOARD_GRAB_TYPE_ALL,
-    KEYBOARD_GRAB_TYPE_VIRTUAL
+    KEYBOARD_GRAB_TYPE_VIRTUAL,
+    KEYBOARD_GRAB_TYPE_NO_GRAB
 } keyboard_grab_type;

 typedef struct {
@@ -62,10 +64,12 @@ typedef struct {
    event_extra_data event_extra_data[MAX_EVENT_POLLS]; /* Current size is |num_event_polls| */
    int num_event_polls;

-    int stdin_event_index;
    int hotplug_event_index;
    int uinput_fd;
+    int timer_fd;
    bool stdin_failed;
+    bool check_grab_lock;
+    double uinput_written_time_seconds;
    keyboard_grab_type grab_type;

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

 /* C stdlib */
 #include <stdio.h>
 #include <string.h>
 #include <locale.h>
+#include <stdbool.h>

 /* POSIX */
 #include <unistd.h>

 static void usage(void) {
-    fprintf(stderr, "usage: gsr-global-hotkeys [--all|--virtual]\n");
+    fprintf(stderr, "usage: gsr-global-hotkeys [--all|--virtual|--no-grab|--set-led] [Scroll Lock] [on|off]\n");
    fprintf(stderr, "OPTIONS:\n");
    fprintf(stderr, "  --all        Grab all devices.\n");
    fprintf(stderr, "  --virtual    Grab all virtual devices only.\n");
+    fprintf(stderr, "  --no-grab    Don't grab devices, only listen to them.\n");
+    fprintf(stderr, "  --set-led    Turn device led on/off.\n");
+    fprintf(stderr, "EXAMPLES:\n");
+    fprintf(stderr, "  gsr-global-hotkeys --all\n");
+    fprintf(stderr, "  gsr-global-hotkeys --set-led \"Scroll Lock\" on\n");
+    fprintf(stderr, "  gsr-global-hotkeys --set-led \"Scroll Lock\" off\n");
 }

 static bool is_gsr_global_hotkeys_already_running(void) {
@@ -37,17 +45,52 @@ int main(int argc, char **argv) {
    setlocale(LC_ALL, "C"); /* Sigh... stupid C */

    keyboard_grab_type grab_type = KEYBOARD_GRAB_TYPE_ALL;
+    const uid_t user_id = getuid();
+
    if(argc == 2) {
        const char *grab_type_arg = argv[1];
        if(strcmp(grab_type_arg, "--all") == 0) {
            grab_type = KEYBOARD_GRAB_TYPE_ALL;
        } else if(strcmp(grab_type_arg, "--virtual") == 0) {
            grab_type = KEYBOARD_GRAB_TYPE_VIRTUAL;
+        } else if(strcmp(grab_type_arg, "--no-grab") == 0) {
+            grab_type = KEYBOARD_GRAB_TYPE_NO_GRAB;
+        } else if(strcmp(grab_type_arg, "--set-led") == 0) {
+            fprintf(stderr, "Error: missing led name and on/off argument to --set-led\n");
+            usage();
+            return 1;
        } else {
-            fprintf(stderr, "gsr-global-hotkeys error: expected --all or --virtual, got %s\n", grab_type_arg);
+            fprintf(stderr, "gsr-global-hotkeys error: expected --all, --virtual, --no-grab or --set-led, got %s\n", grab_type_arg);
            usage();
            return 1;
        }
+    } else if(argc == 4) {
+        /* It's not ideal to use gsr-global-hotkeys for leds, but we do that for now because it's a mess to create another binary for flatpak and distros */
+        const char *led_name = argv[2];
+        const char *led_enabled_str = argv[3];
+        bool led_enabled = false;
+
+        if(strcmp(led_enabled_str, "on") == 0) {
+            led_enabled = true;
+        } else if(strcmp(led_enabled_str, "off") == 0) {
+            led_enabled = false;
+        } else {
+            fprintf(stderr, "Error: expected \"on\" or \"off\" for --set-led option, got: \"%s\"", led_enabled_str);
+            usage();
+            return 1;
+        }
+
+        if(geteuid() != 0) {
+            if(setuid(0) == -1) {
+                fprintf(stderr, "gsr-global-hotkeys error: failed to change user to root, global hotkeys will not work. Make sure to set the correct capability on gsr-global-hotkeys\n");
+                return 1;
+            }
+        }
+
+        const bool success = set_leds(led_name, led_enabled);
+        setuid(user_id);
+
+        return success ? 0 : 1;
    } else if(argc != 1) {
        fprintf(stderr, "gsr-global-hotkeys error: expected 0 or 1 arguments, got %d argument(s)\n", argc);
        usage();
@@ -59,7 +102,6 @@ int main(int argc, char **argv) {
        return 1;
    }

-    const uid_t user_id = getuid();
    if(geteuid() != 0) {
        if(setuid(0) == -1) {
            fprintf(stderr, "gsr-global-hotkeys error: failed to change user to root, global hotkeys will not work. Make sure to set the correct capability on gsr-global-hotkeys\n");
@@ -68,7 +110,7 @@ int main(int argc, char **argv) {
    }

    keyboard_event keyboard_ev;
-    if(!keyboard_event_init(&keyboard_ev, true, grab_type)) {
+    if(!keyboard_event_init(&keyboard_ev, grab_type != KEYBOARD_GRAB_TYPE_NO_GRAB, grab_type)) {
        fprintf(stderr, "gsr-global-hotkeys error: failed to setup hotplugging and no keyboard input devices were found\n");
        setuid(user_id);
        return 1;
Author	SHA1	Message	Date
dec05eba	fed47000ce	1.9.3 - Only use led indicator if it's enabled	2026-01-08 20:40:11 +01:00
dec05eba	7f43adfbd5	1.9.3	2026-01-08 20:23:39 +01:00
dec05eba	1f6251baf3	Fix high cpu usage when running global hotkeys without grab and then connecting a secondary keyboard	2026-01-08 20:23:21 +01:00
dec05eba	d1220b013e	Update flatpak version reference	2026-01-08 01:25:08 +01:00
dec05eba	93a55b6bdf	1.9.2	2026-01-06 22:17:54 +01:00
dec05eba	974e760136	Fix clipboard save to disk option not working correctly	2026-01-06 22:17:38 +01:00
dec05eba	387141d36f	Update flatpak version reference	2026-01-06 19:36:57 +01:00
dec05eba	3713d3d59e	Add -Ddesktop-files option	2026-01-01 04:53:26 +01:00
dec05eba	2bb6754523	Update usage text	2025-12-31 16:32:31 +01:00
dec05eba	df1610431d	Add application icon, show gsr icon in notification	2025-12-31 16:29:11 +01:00
dec05eba	1ea9615584	Add option to not save screenshot to disk (only clipboard), refactor webcam ui code	2025-12-27 22:57:09 +01:00
dec05eba	45ae7c95cf	1.9.1	2025-12-27 13:04:19 +01:00
dec05eba	f1b6df4d56	Dont turn on led when using replay/streaming and then recording if not enabled	2025-12-27 13:03:30 +01:00
dec05eba	202c0b2415	Correct license identifier	2025-12-26 16:17:05 +01:00
dec05eba	fd5026489c	Revert minor	2025-12-25 08:28:17 +01:00
dec05eba	8032cb2cf0	1.9.0	2025-12-25 08:19:42 +01:00
dec05eba	13562d2aa1	Add webcam support	2025-12-25 08:19:07 +01:00
dec05eba	1971d4a288	Die properly when killed with SIGINT	2025-12-23 22:54:27 +01:00
dec05eba	c039b79174	Wayland: only prevent game minimizing if the input focused window is x11. Change screenshot program to a command instead, allows spectacle -E to work	2025-12-22 15:55:13 +01:00
dec05eba	245dcf5730	1.8.3	2025-12-07 18:15:47 +01:00
dec05eba	e68a342b81	Default empty text not kolourpaint	2025-12-04 23:23:57 +01:00
Giovane Perlin	11aa237821	feat: adds an option to run a script after a screenshot	2025-12-04 23:18:01 +01:00
dec05eba	d7be9b38b1	Screenshot: fix image not saved to clipboard if notifications are disabled	2025-12-04 22:43:54 +01:00
dec05eba	4717c64b03	Update flatpak version reference	2025-12-04 20:16:53 +01:00
dec05eba	2c2633ec58	Add exec_program_on_host_daemonized	2025-12-01 19:57:56 +01:00
dec05eba	71d28f8ba3	1.8.2	2025-11-29 01:40:09 +01:00
dec05eba	bb1e9c6616	Live stream: fix codec not applied, focused window area not applied and video resolution change not applied	2025-11-27 20:57:06 +01:00
dec05eba	e14bb0cbcf	Text update	2025-11-26 01:26:48 +01:00
dec05eba	5a13bd2491	Fix led indicator getting turned off when turning caps lock/numlock on/off	2025-11-20 21:50:20 +01:00
dec05eba	b875f96885	Fix hotkeys not getting unbound correctly when unbinding them in the ui	2025-11-20 12:10:03 +01:00
dec05eba	0d3d4229bf	Fix hotkeys not getting unbound correctly when unbinding them in the ui	2025-11-20 12:09:51 +01:00
dec05eba	ed23f56a29	Update flatpak version reference	2025-11-18 11:42:25 +01:00
dec05eba	a9a1f9d01c	Only show 'saving replay, this might take some time' if notifications are enabled	2025-11-12 23:22:33 +01:00
dec05eba	2506750243	Fix leds getting unset when closing the program	2025-11-08 13:24:40 +01:00
dec05eba	f017f04bdc	Unset led when running replay and recording and stopping replay without replay led enabled	2025-11-08 03:31:26 +01:00
dec05eba	d1f8db3760	Support keyboard led indicator on wayland as well	2025-11-08 03:28:18 +01:00
dec05eba	0995e86e89	Move notifications/led indicator to new section in the ui	2025-11-07 23:21:17 +01:00
dec05eba	4992185323	Make it clear that led indicator is only supported by x11	2025-11-07 22:11:43 +01:00
dec05eba	70df557c2b	Add led indicator setting, use one setting for notifications, move it under general	2025-11-07 22:05:14 +01:00
dec05eba	be07070789	Ungrab devices if there is a keyboard lock (if an input remapping software runs and grabs gsr-ui virtual keyboard)	2025-11-07 19:23:38 +01:00
dec05eba	2bc2252d30	Dont show replay save 1/10 min if replay buffer is set to a lower time	2025-11-03 23:11:12 +01:00
dec05eba	9af3c85161	Set window class to gsr-ui	2025-11-02 23:05:02 +01:00
dec05eba	d7f6d2cc0c	README update	2025-11-01 14:50:09 +01:00
dec05eba	0f5b225107	Fix incorrect recorded video duration in notification if the recording was paused	2025-11-01 12:43:00 +01:00
dec05eba	85e8b04ee2	malloc_trim is glibc only	2025-10-31 09:44:16 +01:00
dec05eba	a6b1111230	Properly cleanup wl outputs for cursor tracker	2025-10-30 20:12:47 +01:00
dec05eba	d70b36000f	Spelling	2025-10-30 18:36:11 +01:00
dec05eba	12c090c7d3	Show an error once for wayland users. Wayland doesn't support this software	2025-10-30 18:35:14 +01:00
dec05eba	d9496e0a0a	Add warning that clipboard screenshot is not supported properly by wayland	2025-10-30 18:21:39 +01:00
dec05eba	c4ff7fd6b8	Update flatpak version reference	2025-10-29 18:18:04 +01:00