1.8.3

TODO

@@ -245,3 +245,5 @@ Show a question mark beside options. When hovering the question mark show a tool
 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.

include/Config.hpp

@@ -146,6 +146,8 @@ namespace gsr {
         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 {
@@ -164,4 +166,4 @@ namespace gsr {
 
     std::optional<Config> read_config(const SupportedCaptureOptions &capture_options);
     void save_config(Config &config);
-}
+}

include/LedIndicator.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <sys/types.h>
+#include <vector>
 #include <mglpp/system/Clock.hpp>
 
 namespace gsr {
@@ -17,11 +18,16 @@ namespace gsr {
     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;
     };
 }

include/Overlay.hpp

@@ -117,7 +117,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);
@@ -129,7 +129,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();

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

include/gui/ScreenshotSettingsPage.hpp

@@ -47,6 +47,9 @@ namespace gsr {
         std::unique_ptr<Widget> create_led_indicator();
         std::unique_ptr<Widget> create_general_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();
 
@@ -75,7 +78,8 @@ namespace gsr {
         CheckBox *save_screenshot_to_clipboard_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;
     };
-}
+}

meson.build

@@ -1,4 +1,4 @@
-project('gsr-ui', ['c', 'cpp'], version : '1.8.0', default_options : ['warning_level=2', 'cpp_std=c++17'], subproject_dir : 'depends')
+project('gsr-ui', ['c', 'cpp'], version : '1.8.3', default_options : ['warning_level=2', 'cpp_std=c++17'], subproject_dir : 'depends')
 
 add_project_arguments('-D_FILE_OFFSET_BITS=64', language : ['c', 'cpp'])
 
@@ -66,7 +66,7 @@ datadir = get_option('datadir')
 gsr_ui_resources_path = join_paths(prefix, datadir, 'gsr-ui')
 
 add_project_arguments('-DGSR_UI_VERSION="' + meson.project_version() + '"', language: ['c', 'cpp'])
-add_project_arguments('-DGSR_FLATPAK_VERSION="5.8.5"', language: ['c', 'cpp'])
+add_project_arguments('-DGSR_FLATPAK_VERSION="5.10.0"', language: ['c', 'cpp'])
 
 executable(
     meson.project_name(),

project.conf

@@ -1,7 +1,7 @@
 [package]
 name = "gsr-ui"
 type = "executable"
-version = "1.8.0"
+version = "1.8.3"
 platforms = ["posix"]
 
 [lang.cpp]

src/Config.cpp

@@ -289,7 +289,8 @@ namespace gsr {
             {"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 +488,4 @@ namespace gsr {
 
         fclose(file);
     }
-}
+}

src/GlobalHotkeys/GlobalHotkeysLinux.cpp

@@ -193,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;
         }

src/LedIndicator.cpp

@@ -1,16 +1,64 @@
 #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;
@@ -58,7 +106,7 @@ namespace gsr {
 
             perror("gsr-global-hotkeys");
             _exit(127);
-            return true;
+            return false;
         } else { // Parent
             return true;
         }
@@ -73,6 +121,11 @@ namespace gsr {
     }
 
     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) {
@@ -90,4 +143,28 @@ namespace gsr {
             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 led_status_outdated = 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')
+                        led_status_outdated = true;
+                    lseek(led_brightness_file_fd, 0, SEEK_SET);
+                }
+            }
+
+            if(led_status_outdated && led_enabled)
+                run_gsr_global_hotkeys_set_leds(true);
+        }
+    }
 }

src/Overlay.cpp

@@ -518,7 +518,7 @@ namespace gsr {
             if(!config.main_config.wayland_warning_shown) {
                 config.main_config.wayland_warning_shown = true;
                 save_config(config);
-                show_notification("Wayland doesn't support GPU Screen Recorder properly,\nthings may not work as expected. Use X11 if you experience issues.", notification_error_timeout_seconds, mgl::Color(255, 0, 0), mgl::Color(255, 0, 0), NotificationType::NONE, nullptr, NotificationLevel::ERROR);
+                show_notification("Wayland doesn't support GPU Screen Recorder UI properly,\nthings may not work as expected. Use X11 if you experience issues.", notification_error_timeout_seconds, mgl::Color(255, 0, 0), mgl::Color(255, 0, 0), NotificationType::NONE, nullptr, NotificationLevel::ERROR);
             }
         }
 
@@ -1909,10 +1909,10 @@ namespace gsr {
         return ClipboardFile::FileType::PNG;
     }
 
-    void Overlay::save_video_in_current_game_directory(const char *video_filepath, NotificationType notification_type) {
+    void Overlay::save_video_in_current_game_directory(std::string &video_filepath, NotificationType notification_type) {
         mgl_context *context = mgl_get_context();
         Display *display = (Display*)context->connection;
-        const std::string video_filename = filepath_get_filename(video_filepath);
+        const std::string video_filename = filepath_get_filename(video_filepath.c_str());
 
         const Window gsr_ui_window = window ? (Window)window->get_system_handle() : None;
         std::string focused_window_name = get_window_name_at_cursor_position(display, gsr_ui_window);
@@ -1923,11 +1923,12 @@ namespace gsr {
 
         string_replace_characters(focused_window_name.data(), "/\\", ' ');
 
-        std::string video_directory = filepath_get_directory(video_filepath) + "/" + focused_window_name;
+        std::string video_directory = filepath_get_directory(video_filepath.c_str()) + "/" + focused_window_name;
         create_directory_recursive(video_directory.data());
 
         const std::string new_video_filepath = video_directory + "/" + video_filename;
-        rename(video_filepath, new_video_filepath.c_str());
+        rename(video_filepath.c_str(), new_video_filepath.c_str());
+        video_filepath = new_video_filepath;
 
         truncate_string(focused_window_name, 40);
         const char *capture_target = nullptr;
@@ -1935,15 +1936,6 @@ namespace gsr {
 
         switch(notification_type) {
             case NotificationType::RECORD: {
-                if(led_indicator) {
-                    if(recording_status == RecordingStatus::REPLAY && !current_recording_config.replay_config.record_options.use_led_indicator)
-                        led_indicator->set_led(false);
-                    else if(recording_status == RecordingStatus::STREAM && !current_recording_config.streaming_config.record_options.use_led_indicator)
-                        led_indicator->set_led(false);
-                    else if(config.record_config.record_options.use_led_indicator)
-                        led_indicator->blink();
-                }
-
                 if(!config.record_config.record_options.show_notifications)
                     return;
 
@@ -1955,9 +1947,6 @@ namespace gsr {
                 break;
             }
             case NotificationType::REPLAY: {
-                if(led_indicator && config.replay_config.record_options.use_led_indicator)
-                    led_indicator->blink();
-
                 if(!config.replay_config.record_options.show_notifications)
                     return;
 
@@ -1969,18 +1958,12 @@ namespace gsr {
                 break;
             }
             case NotificationType::SCREENSHOT: {
-                if(led_indicator && config.screenshot_config.use_led_indicator)
-                    led_indicator->blink();
-
                 if(!config.screenshot_config.show_notifications)
                     return;
 
                 snprintf(msg, sizeof(msg), "Saved a screenshot of %s\nto \"%s\"",
                     capture_target_get_notification_name(screenshot_capture_target.c_str(), true).c_str(), focused_window_name.c_str());
                 capture_target = screenshot_capture_target.c_str();
-
-                if(config.screenshot_config.save_screenshot_to_clipboard)
-                    clipboard_file.set_current_file(new_video_filepath, filename_to_clipboard_file_type(new_video_filepath));
                 break;
             }
             case NotificationType::NONE:
@@ -2003,28 +1986,27 @@ namespace gsr {
     void Overlay::on_replay_saved(const char *replay_saved_filepath) {
         replay_save_show_notification = false;
         if(config.replay_config.save_video_in_game_folder) {
-            save_video_in_current_game_directory(replay_saved_filepath, NotificationType::REPLAY);
-            return;
-        } else {
-            if(config.replay_config.record_options.show_notifications) {
-                const std::string duration_str = to_duration_string(get_time_passed_in_replay_buffer_seconds());
+            std::string filepath = replay_saved_filepath;
+            save_video_in_current_game_directory(filepath, NotificationType::REPLAY);
+        } else if(config.replay_config.record_options.show_notifications) {
+            const std::string duration_str = to_duration_string(get_time_passed_in_replay_buffer_seconds());
 
-                char msg[512];
-                snprintf(msg, sizeof(msg), "Saved a %s replay of %s",
-                    duration_str.c_str(),
-                    capture_target_get_notification_name(recording_capture_target.c_str(), true).c_str());
-                show_notification(msg, notification_timeout_seconds, mgl::Color(255, 255, 255), get_color_theme().tint_color, NotificationType::REPLAY, recording_capture_target.c_str());
-            }
-
-            if(led_indicator && config.replay_config.record_options.use_led_indicator)
-                led_indicator->blink();
+            char msg[512];
+            snprintf(msg, sizeof(msg), "Saved a %s replay of %s",
+                duration_str.c_str(),
+                capture_target_get_notification_name(recording_capture_target.c_str(), true).c_str());
+            show_notification(msg, notification_timeout_seconds, mgl::Color(255, 255, 255), get_color_theme().tint_color, NotificationType::REPLAY, recording_capture_target.c_str());
         }
+
+        if(led_indicator && config.replay_config.record_options.use_led_indicator)
+            led_indicator->blink();
     }
 
     void Overlay::process_gsr_output() {
         if(replay_save_show_notification && replay_save_clock.get_elapsed_time_seconds() >= replay_saving_notification_timeout_seconds) {
             replay_save_show_notification = false;
-            show_notification("Saving replay, this might take some time", notification_timeout_seconds, mgl::Color(255, 255, 255), get_color_theme().tint_color, NotificationType::REPLAY);
+            if(config.replay_config.record_options.show_notifications)
+                show_notification("Saving replay, this might take some time", notification_timeout_seconds, mgl::Color(255, 255, 255), get_color_theme().tint_color, NotificationType::REPLAY);
         }
 
         if(gpu_screen_recorder_process_output_file) {
@@ -2044,7 +2026,8 @@ namespace gsr {
 
             const std::string video_filepath = filepath_get_filename(line);
             if(starts_with(video_filepath, "Video_")) {
-                on_stop_recording(0, line);
+                record_filepath = line;
+                on_stop_recording(0, record_filepath);
                 return;
             }
 
@@ -2181,20 +2164,22 @@ namespace gsr {
 
         if(exit_code == 0) {
             if(config.screenshot_config.save_screenshot_in_game_folder) {
-                save_video_in_current_game_directory(screenshot_filepath.c_str(), NotificationType::SCREENSHOT);
-            } else {
-                if(config.screenshot_config.show_notifications) {
-                    char msg[512];
-                    snprintf(msg, sizeof(msg), "Saved a screenshot of %s",
-                        capture_target_get_notification_name(screenshot_capture_target.c_str(), true).c_str());
-                    show_notification(msg, notification_timeout_seconds, mgl::Color(255, 255, 255), get_color_theme().tint_color, NotificationType::SCREENSHOT, screenshot_capture_target.c_str());
+                save_video_in_current_game_directory(screenshot_filepath, NotificationType::SCREENSHOT);
+            } else if(config.screenshot_config.show_notifications) {
+                char msg[512];
+                snprintf(msg, sizeof(msg), "Saved a screenshot of %s", capture_target_get_notification_name(screenshot_capture_target.c_str(), true).c_str());
+                show_notification(msg, notification_timeout_seconds, mgl::Color(255, 255, 255), get_color_theme().tint_color, NotificationType::SCREENSHOT, screenshot_capture_target.c_str());
+            }
 
-                    if(config.screenshot_config.save_screenshot_to_clipboard)
-                        clipboard_file.set_current_file(screenshot_filepath, filename_to_clipboard_file_type(screenshot_filepath));
-                }
+            if(config.screenshot_config.save_screenshot_to_clipboard)
+                clipboard_file.set_current_file(screenshot_filepath, filename_to_clipboard_file_type(screenshot_filepath));
 
-                if(led_indicator && config.screenshot_config.use_led_indicator)
-                    led_indicator->blink();
+            if(led_indicator && config.screenshot_config.use_led_indicator)
+                led_indicator->blink();
+
+            if(!strip(config.screenshot_config.custom_script).empty()) {
+                const char *args[] = { config.screenshot_config.custom_script.c_str(), screenshot_filepath.c_str(), nullptr };
+                exec_program_on_host_daemonized(args);
             }
         } else {
             fprintf(stderr, "Warning: gpu-screen-recorder (%d) exited with exit status %d\n", (int)gpu_screen_recorder_screenshot_process, exit_code);
@@ -2286,29 +2271,27 @@ namespace gsr {
             on_press_start_replay(true, false);
     }
 
-    void Overlay::on_stop_recording(int exit_code, const std::string &video_filepath) {
+    void Overlay::on_stop_recording(int exit_code, std::string &video_filepath) {
         if(exit_code == 0) {
             if(config.record_config.save_video_in_game_folder) {
-                save_video_in_current_game_directory(video_filepath.c_str(), NotificationType::RECORD);
-            } else {
-                if(config.record_config.record_options.show_notifications) {
-                    const std::string duration_str = to_duration_string(recording_duration_clock.get_elapsed_time_seconds() - paused_total_time_seconds - (paused ? paused_clock.get_elapsed_time_seconds() : 0.0));
+                save_video_in_current_game_directory(video_filepath, NotificationType::RECORD);
+            } else if(config.record_config.record_options.show_notifications) {
+                const std::string duration_str = to_duration_string(recording_duration_clock.get_elapsed_time_seconds() - paused_total_time_seconds - (paused ? paused_clock.get_elapsed_time_seconds() : 0.0));
 
-                    char msg[512];
-                    snprintf(msg, sizeof(msg), "Saved a %s recording of %s",
-                        duration_str.c_str(),
-                        capture_target_get_notification_name(recording_capture_target.c_str(), true).c_str());
-                    show_notification(msg, notification_timeout_seconds, mgl::Color(255, 255, 255), get_color_theme().tint_color, NotificationType::RECORD, recording_capture_target.c_str());
-                }
+                char msg[512];
+                snprintf(msg, sizeof(msg), "Saved a %s recording of %s",
+                    duration_str.c_str(),
+                    capture_target_get_notification_name(recording_capture_target.c_str(), true).c_str());
+                show_notification(msg, notification_timeout_seconds, mgl::Color(255, 255, 255), get_color_theme().tint_color, NotificationType::RECORD, recording_capture_target.c_str());
+            }
 
-                if(led_indicator) {
-                    if(recording_status == RecordingStatus::REPLAY && !current_recording_config.replay_config.record_options.use_led_indicator)
-                        led_indicator->set_led(false);
-                    else if(recording_status == RecordingStatus::STREAM && !current_recording_config.streaming_config.record_options.use_led_indicator)
-                        led_indicator->set_led(false);
-                    else if(config.record_config.record_options.use_led_indicator)
-                        led_indicator->blink();
-                }
+            if(led_indicator) {
+                if(recording_status == RecordingStatus::REPLAY && !current_recording_config.replay_config.record_options.use_led_indicator)
+                    led_indicator->set_led(false);
+                else if(recording_status == RecordingStatus::STREAM && !current_recording_config.streaming_config.record_options.use_led_indicator)
+                    led_indicator->set_led(false);
+                else if(config.record_config.record_options.use_led_indicator)
+                    led_indicator->blink();
             }
         } else {
             on_gsr_process_error(exit_code, NotificationType::RECORD);
@@ -3174,10 +3157,10 @@ namespace gsr {
 
         char size[64];
         size[0] = '\0';
-        if(config.record_config.record_options.record_area_option == "focused")
+        if(config.streaming_config.record_options.record_area_option == "focused")
             snprintf(size, sizeof(size), "%dx%d", (int)config.streaming_config.record_options.record_area_width, (int)config.streaming_config.record_options.record_area_height);
 
-        if(config.record_config.record_options.record_area_option != "focused" && config.streaming_config.record_options.change_video_resolution)
+        if(config.streaming_config.record_options.record_area_option != "focused" && config.streaming_config.record_options.change_video_resolution)
             snprintf(size, sizeof(size), "%dx%d", (int)config.streaming_config.record_options.video_width, (int)config.streaming_config.record_options.video_height);
 
         std::vector<const char*> args = {
@@ -3187,6 +3170,7 @@ namespace gsr {
             "-cursor", config.streaming_config.record_options.record_cursor ? "yes" : "no",
             "-cr", config.streaming_config.record_options.color_range.c_str(),
             "-fm", framerate_mode.c_str(),
+            "-k", video_codec,
             "-encoder", encoder,
             "-f", fps.c_str(),
             "-v", "no",

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 {

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;

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

src/gui/ScreenshotSettingsPage.cpp

@@ -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));
     }
@@ -249,6 +249,27 @@ namespace gsr {
         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, "Program 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);
@@ -263,6 +284,7 @@ namespace gsr {
         settings_list->add_widget(create_file_info_section());
         settings_list->add_widget(create_general_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;
     }
@@ -321,6 +343,8 @@ 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() {
@@ -337,6 +361,7 @@ namespace gsr {
         config.screenshot_config.save_screenshot_to_clipboard = save_screenshot_to_clipboard_checkbox_ptr->is_checked();
         config.screenshot_config.show_notifications = show_notification_checkbox_ptr->is_checked();
         config.screenshot_config.use_led_indicator = led_indicator_checkbox_ptr->is_checked();
+        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;
@@ -356,4 +381,4 @@ namespace gsr {
 
         save_config(config);
     }
-}
+}

src/gui/SettingsPage.cpp

@@ -918,7 +918,7 @@ 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());