Add option to take a screenshot (default hotkey: alt+f1)

1 files changed, 339 insertions, 0 deletions

diff --git a/src/gui/ScreenshotSettingsPage.cpp b/src/gui/ScreenshotSettingsPage.cpp
new file mode 100644
index 0000000..457ff89
--- /dev/null
+++ b/src/gui/ScreenshotSettingsPage.cpp
@@ -0,0 +1,339 @@
+#include "../../include/gui/ScreenshotSettingsPage.hpp"
+#include "../../include/gui/GsrPage.hpp"
+#include "../../include/gui/PageStack.hpp"
+#include "../../include/Theme.hpp"
+#include "../../include/GsrInfo.hpp"
+#include "../../include/Utils.hpp"
+#include "../../include/gui/List.hpp"
+#include "../../include/gui/ScrollablePage.hpp"
+#include "../../include/gui/Label.hpp"
+#include "../../include/gui/Subsection.hpp"
+#include "../../include/gui/FileChooser.hpp"
+
+namespace gsr {
+    ScreenshotSettingsPage::ScreenshotSettingsPage(const GsrInfo *gsr_info, Config &config, PageStack *page_stack) :
+        StaticPage(mgl::vec2f(get_theme().window_width, get_theme().window_height).floor()),
+        config(config),
+        gsr_info(gsr_info),
+        page_stack(page_stack)
+    {
+        capture_options = get_supported_capture_options(*gsr_info);
+
+        auto content_page = std::make_unique<GsrPage>("Screenshot", "Settings");
+        content_page->add_button("Back", "back", get_color_theme().page_bg_color);
+        content_page->on_click = [page_stack](const std::string &id) {
+            if(id == "back")
+                page_stack->pop();
+        };
+        content_page_ptr = content_page.get();
+        add_widget(std::move(content_page));
+
+        add_widgets();
+        load();
+    }
+
+    std::unique_ptr<ComboBox> ScreenshotSettingsPage::create_record_area_box() {
+        auto record_area_box = std::make_unique<ComboBox>(&get_theme().body_font);
+        // TODO: Show options not supported but disable them
+        // TODO: Enable this
+        //if(capture_options.window)
+        //    record_area_box->add_item("Window", "window");
+        for(const auto &monitor : capture_options.monitors) {
+            char name[256];
+            snprintf(name, sizeof(name), "Monitor %s (%dx%d)", monitor.name.c_str(), monitor.size.x, monitor.size.y);
+            record_area_box->add_item(name, monitor.name);
+        }
+        if(capture_options.portal)
+            record_area_box->add_item("Desktop portal", "portal");
+        record_area_box_ptr = record_area_box.get();
+        return record_area_box;
+    }
+
+    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(create_record_area_box());
+        return record_area_list;
+    }
+
+    std::unique_ptr<List> ScreenshotSettingsPage::create_select_window() {
+        auto select_window_list = std::make_unique<List>(List::Orientation::VERTICAL);
+        select_window_list->add_widget(std::make_unique<Label>(&get_theme().body_font, "Select window:", get_color_theme().text_color));
+        select_window_list->add_widget(std::make_unique<Button>(&get_theme().body_font, "Click here to select a window...", mgl::vec2f(0.0f, 0.0f), mgl::Color(0, 0, 0, 120)));
+        select_window_list_ptr = select_window_list.get();
+        return select_window_list;
+    }
+
+    std::unique_ptr<Entry> ScreenshotSettingsPage::create_image_width_entry() {
+        auto image_width_entry = std::make_unique<Entry>(&get_theme().body_font, "1920", get_theme().body_font.get_character_size() * 3);
+        image_width_entry->validate_handler = create_entry_validator_integer_in_range(1, 1 << 15);
+        image_width_entry_ptr = image_width_entry.get();
+        return image_width_entry;
+    }
+
+    std::unique_ptr<Entry> ScreenshotSettingsPage::create_image_height_entry() {
+        auto image_height_entry = std::make_unique<Entry>(&get_theme().body_font, "1080", get_theme().body_font.get_character_size() * 3);
+        image_height_entry->validate_handler = create_entry_validator_integer_in_range(1, 1 << 15);
+        image_height_entry_ptr = image_height_entry.get();
+        return image_height_entry;
+    }
+
+    std::unique_ptr<List> ScreenshotSettingsPage::create_image_resolution() {
+        auto area_size_params_list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER);
+        area_size_params_list->add_widget(create_image_width_entry());
+        area_size_params_list->add_widget(std::make_unique<Label>(&get_theme().body_font, "x", get_color_theme().text_color));
+        area_size_params_list->add_widget(create_image_height_entry());
+        return area_size_params_list;
+    }
+
+    std::unique_ptr<List> ScreenshotSettingsPage::create_image_resolution_section() {
+        auto image_resolution_list = std::make_unique<List>(List::Orientation::VERTICAL);
+        image_resolution_list->add_widget(std::make_unique<Label>(&get_theme().body_font, "Image resolution limit:", get_color_theme().text_color));
+        image_resolution_list->add_widget(create_image_resolution());
+        image_resolution_list_ptr = image_resolution_list.get();
+        return image_resolution_list;
+    }
+
+    std::unique_ptr<CheckBox> ScreenshotSettingsPage::create_restore_portal_session_checkbox() {
+        auto restore_portal_session_checkbox = std::make_unique<CheckBox>(&get_theme().body_font, "Restore portal session");
+        restore_portal_session_checkbox->set_checked(true);
+        restore_portal_session_checkbox_ptr = restore_portal_session_checkbox.get();
+        return restore_portal_session_checkbox;
+    }
+
+    std::unique_ptr<List> ScreenshotSettingsPage::create_restore_portal_session_section() {
+        auto restore_portal_session_list = std::make_unique<List>(List::Orientation::VERTICAL);
+        restore_portal_session_list->add_widget(std::make_unique<Label>(&get_theme().body_font, " ", get_color_theme().text_color));
+        restore_portal_session_list->add_widget(create_restore_portal_session_checkbox());
+        restore_portal_session_list_ptr = restore_portal_session_list.get();
+        return restore_portal_session_list;
+    }
+
+    std::unique_ptr<Widget> ScreenshotSettingsPage::create_change_image_resolution_section() {
+        auto checkbox = std::make_unique<CheckBox>(&get_theme().body_font, "Change image resolution");
+        change_image_resolution_checkbox_ptr = checkbox.get();
+        return checkbox;
+    }
+
+    std::unique_ptr<Widget> ScreenshotSettingsPage::create_capture_target_section() {
+        auto ll = std::make_unique<List>(List::Orientation::VERTICAL);
+
+        auto capture_target_list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER);
+        capture_target_list->add_widget(create_record_area());
+        capture_target_list->add_widget(create_select_window());
+        capture_target_list->add_widget(create_image_resolution_section());
+        capture_target_list->add_widget(create_restore_portal_session_section());
+
+        ll->add_widget(std::move(capture_target_list));
+        ll->add_widget(create_change_image_resolution_section());
+        return std::make_unique<Subsection>("Record area", std::move(ll), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f));
+    }
+
+    std::unique_ptr<List> ScreenshotSettingsPage::create_image_quality_section() {
+        auto list = std::make_unique<List>(List::Orientation::VERTICAL);
+        list->add_widget(std::make_unique<Label>(&get_theme().body_font, "Image quality:", get_color_theme().text_color));
+
+        auto image_quality_box = std::make_unique<ComboBox>(&get_theme().body_font);
+        image_quality_box->add_item("Medium", "medium");
+        image_quality_box->add_item("High", "high");
+        image_quality_box->add_item("Very high (Recommended)", "very_high");
+        image_quality_box->add_item("Ultra", "ultra");
+        image_quality_box->set_selected_item("very_high");
+
+        image_quality_box_ptr = image_quality_box.get();
+        list->add_widget(std::move(image_quality_box));
+
+        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);
+        record_cursor_checkbox_ptr = record_cursor_checkbox.get();
+        return record_cursor_checkbox;
+    }
+
+    std::unique_ptr<Widget> ScreenshotSettingsPage::create_image_section() {
+        auto image_section_list = std::make_unique<List>(List::Orientation::VERTICAL);
+        image_section_list->add_widget(create_image_quality_section());
+        image_section_list->add_widget(create_record_cursor_section());
+        return std::make_unique<Subsection>("Image", std::move(image_section_list), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f));
+    }
+
+    std::unique_ptr<List> ScreenshotSettingsPage::create_save_directory(const char *label) {
+        auto save_directory_list = std::make_unique<List>(List::Orientation::VERTICAL);
+        save_directory_list->add_widget(std::make_unique<Label>(&get_theme().body_font, label, get_color_theme().text_color));
+        auto save_directory_button = std::make_unique<Button>(&get_theme().body_font, get_pictures_dir().c_str(), mgl::vec2f(0.0f, 0.0f), mgl::Color(0, 0, 0, 120));
+        save_directory_button_ptr = save_directory_button.get();
+        save_directory_button->on_click = [this]() {
+            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));
+
+            select_directory_page->on_click = [this, file_chooser_ptr](const std::string &id) {
+                if(id == "save") {
+                    save_directory_button_ptr->set_text(file_chooser_ptr->get_current_directory());
+                    page_stack->pop();
+                } else if(id == "cancel") {
+                    page_stack->pop();
+                }
+            };
+
+            page_stack->push(std::move(select_directory_page));
+        };
+        save_directory_list->add_widget(std::move(save_directory_button));
+        return save_directory_list;
+    }
+
+    std::unique_ptr<ComboBox> ScreenshotSettingsPage::create_image_format_box() {
+        auto box = std::make_unique<ComboBox>(&get_theme().body_font);
+        box->add_item("jpg", "jpg");
+        box->add_item("png", "png");
+        image_format_box_ptr = box.get();
+        return box;
+    }
+
+    std::unique_ptr<List> ScreenshotSettingsPage::create_image_format_section() {
+        auto list = std::make_unique<List>(List::Orientation::VERTICAL);
+        list->add_widget(std::make_unique<Label>(&get_theme().body_font, "Image format:", get_color_theme().text_color));
+        list->add_widget(create_image_format_box());
+        return list;
+    }
+
+    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_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));
+    }
+
+    std::unique_ptr<CheckBox> ScreenshotSettingsPage::create_save_screenshot_in_game_folder() {
+        char text[256];
+        snprintf(text, sizeof(text), "Save screenshot in a folder with the name of the game%s", gsr_info->system_info.display_server == DisplayServer::X11 ? "" : " (X11 applications only)");
+        auto checkbox = std::make_unique<CheckBox>(&get_theme().body_font, text);
+        save_screenshot_in_game_folder_checkbox_ptr = checkbox.get();
+        return checkbox;
+    }
+
+    std::unique_ptr<Widget> ScreenshotSettingsPage::create_general_section() {
+        return std::make_unique<Subsection>("General", create_save_screenshot_in_game_folder(), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f));
+    }
+
+    std::unique_ptr<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_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));
+        settings_scrollable_page_ptr = scrollable_page.get();
+        page_list->add_widget(std::move(scrollable_page));
+
+        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_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_scrollable_page_ptr->add_widget(std::move(settings_list));
+        return page_list;
+    }
+
+    void ScreenshotSettingsPage::add_widgets() {
+        content_page_ptr->add_widget(create_settings());
+
+        record_area_box_ptr->on_selection_changed = [this](const std::string &text, const std::string &id) {
+            (void)text;
+            const bool window_selected = id == "window";
+            const bool portal_selected = id == "portal";
+            select_window_list_ptr->set_visible(window_selected);
+            image_resolution_list_ptr->set_visible(change_image_resolution_checkbox_ptr->is_checked());
+            restore_portal_session_list_ptr->set_visible(portal_selected);
+            return true;
+        };
+
+        change_image_resolution_checkbox_ptr->on_changed = [this](bool checked) {
+            image_resolution_list_ptr->set_visible(checked);
+        };
+
+        if(!capture_options.monitors.empty())
+            record_area_box_ptr->set_selected_item(capture_options.monitors.front().name);
+        else if(capture_options.portal)
+            record_area_box_ptr->set_selected_item("portal");
+        else if(capture_options.window)
+            record_area_box_ptr->set_selected_item("window");
+        else
+            record_area_box_ptr->on_selection_changed("", "");
+    }
+
+    void ScreenshotSettingsPage::on_navigate_away_from_page() {
+        save();
+    }
+
+    void ScreenshotSettingsPage::load() {
+        record_area_box_ptr->set_selected_item(config.screenshot_config.record_area_option);
+        change_image_resolution_checkbox_ptr->set_checked(config.screenshot_config.change_image_resolution);
+        image_quality_box_ptr->set_selected_item(config.screenshot_config.image_quality);
+        image_format_box_ptr->set_selected_item(config.screenshot_config.image_format);
+        record_cursor_checkbox_ptr->set_checked(config.screenshot_config.record_cursor);
+        restore_portal_session_checkbox_ptr->set_checked(config.screenshot_config.restore_portal_session);
+        save_directory_button_ptr->set_text(config.screenshot_config.save_directory);
+        save_screenshot_in_game_folder_checkbox_ptr->set_checked(config.screenshot_config.save_screenshot_in_game_folder);
+        show_screenshot_saved_notification_checkbox_ptr->set_checked(config.screenshot_config.show_screenshot_saved_notifications);
+
+        if(config.screenshot_config.image_width == 0)
+            config.screenshot_config.image_width = 1920;
+
+        if(config.screenshot_config.image_height == 0)
+            config.screenshot_config.image_height = 1080;
+
+        if(config.screenshot_config.image_width < 32)
+            config.screenshot_config.image_width = 32;
+        image_width_entry_ptr->set_text(std::to_string(config.screenshot_config.image_width));
+
+        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));
+    }
+
+    void ScreenshotSettingsPage::save() {
+        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());
+        config.screenshot_config.change_image_resolution = change_image_resolution_checkbox_ptr->is_checked();
+        config.screenshot_config.image_quality = image_quality_box_ptr->get_selected_id();
+        config.screenshot_config.image_format = image_format_box_ptr->get_selected_id();
+        config.screenshot_config.record_cursor = record_cursor_checkbox_ptr->is_checked();
+        config.screenshot_config.restore_portal_session = restore_portal_session_checkbox_ptr->is_checked();
+        config.screenshot_config.save_directory = save_directory_button_ptr->get_text();
+        config.screenshot_config.save_screenshot_in_game_folder = save_screenshot_in_game_folder_checkbox_ptr->is_checked();
+        config.screenshot_config.show_screenshot_saved_notifications = show_screenshot_saved_notification_checkbox_ptr->is_checked();
+
+        if(config.screenshot_config.image_width == 0)
+            config.screenshot_config.image_width = 1920;
+
+        if(config.screenshot_config.image_height == 0)
+            config.screenshot_config.image_height = 1080;
+
+        if(config.screenshot_config.image_width < 32) {
+            config.screenshot_config.image_width = 32;
+            image_width_entry_ptr->set_text("32");
+        }
+
+        if(config.screenshot_config.image_height < 32) {
+            config.screenshot_config.image_height = 32;
+            image_height_entry_ptr->set_text("32");
+        }
+
+        save_config(config);
+    }
+}
\ No newline at end of file