#include "../../include/gui/SettingsPage.hpp" #include "../../include/gui/GsrPage.hpp" #include "../../include/gui/Label.hpp" #include "../../include/gui/PageStack.hpp" #include "../../include/gui/FileChooser.hpp" #include "../../include/gui/Subsection.hpp" #include "../../include/Theme.hpp" #include "../../include/GsrInfo.hpp" #include "../../include/Utils.hpp" #include <mglpp/graphics/Rectangle.hpp> #include <mglpp/graphics/Sprite.hpp> #include <mglpp/graphics/Text.hpp> #include <mglpp/window/Window.hpp> #include <string.h> namespace gsr { enum class AudioTrackType { DEVICE, APPLICATION, APPLICATION_CUSTOM }; SettingsPage::SettingsPage(Type type, const GsrInfo &gsr_info, Config &config, PageStack *page_stack) : StaticPage(mgl::vec2f(get_theme().window_width, get_theme().window_height).floor()), type(type), config(config), page_stack(page_stack), settings_title_text("Settings", get_theme().title_font) { audio_devices = get_audio_devices(); application_audio = get_application_audio(); auto content_page = std::make_unique<GsrPage>(); 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(gsr_info); add_page_specific_widgets(gsr_info); load(gsr_info); } std::unique_ptr<RadioButton> SettingsPage::create_view_radio_button() { auto view_radio_button = std::make_unique<RadioButton>(&get_theme().body_font, RadioButton::Orientation::HORIZONTAL); view_radio_button->add_item("Simple view", "simple"); view_radio_button->add_item("Advanced view", "advanced"); view_radio_button->set_horizontal_alignment(Widget::Alignment::CENTER); view_radio_button_ptr = view_radio_button.get(); return view_radio_button; } std::unique_ptr<ComboBox> SettingsPage::create_record_area_box(const GsrInfo &gsr_info) { auto record_area_box = std::make_unique<ComboBox>(&get_theme().body_font); // TODO: Show options not supported but disable them // TODO: Enable this //if(gsr_info.supported_capture_options.window) // record_area_box->add_item("Window", "window"); if(gsr_info.supported_capture_options.focused) record_area_box->add_item("Follow focused window", "focused"); if(gsr_info.supported_capture_options.screen) record_area_box->add_item("All monitors", "screen"); for(const auto &monitor : gsr_info.supported_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(gsr_info.supported_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> SettingsPage::create_record_area(const GsrInfo &gsr_info) { 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(gsr_info)); return record_area_list; } std::unique_ptr<List> SettingsPage::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> SettingsPage::create_area_width_entry() { auto area_width_entry = std::make_unique<Entry>(&get_theme().body_font, "1920", get_theme().body_font.get_character_size() * 3); area_width_entry->validate_handler = create_entry_validator_integer_in_range(1, 1 << 15); area_width_entry_ptr = area_width_entry.get(); return area_width_entry; } std::unique_ptr<Entry> SettingsPage::create_area_height_entry() { auto area_height_entry = std::make_unique<Entry>(&get_theme().body_font, "1080", get_theme().body_font.get_character_size() * 3); area_height_entry->validate_handler = create_entry_validator_integer_in_range(1, 1 << 15); area_height_entry_ptr = area_height_entry.get(); return area_height_entry; } std::unique_ptr<List> SettingsPage::create_area_size() { auto area_size_params_list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER); area_size_params_list->add_widget(create_area_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_area_height_entry()); return area_size_params_list; } std::unique_ptr<List> SettingsPage::create_area_size_section() { auto area_size_list = std::make_unique<List>(List::Orientation::VERTICAL); area_size_list->add_widget(std::make_unique<Label>(&get_theme().body_font, "Area size:", get_color_theme().text_color)); area_size_list->add_widget(create_area_size()); area_size_list_ptr = area_size_list.get(); return area_size_list; } std::unique_ptr<Entry> SettingsPage::create_video_width_entry() { auto video_width_entry = std::make_unique<Entry>(&get_theme().body_font, "1920", get_theme().body_font.get_character_size() * 3); video_width_entry->validate_handler = create_entry_validator_integer_in_range(1, 1 << 15); video_width_entry_ptr = video_width_entry.get(); return video_width_entry; } std::unique_ptr<Entry> SettingsPage::create_video_height_entry() { auto video_height_entry = std::make_unique<Entry>(&get_theme().body_font, "1080", get_theme().body_font.get_character_size() * 3); video_height_entry->validate_handler = create_entry_validator_integer_in_range(1, 1 << 15); video_height_entry_ptr = video_height_entry.get(); return video_height_entry; } std::unique_ptr<List> SettingsPage::create_video_resolution() { auto area_size_params_list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER); area_size_params_list->add_widget(create_video_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_video_height_entry()); return area_size_params_list; } std::unique_ptr<List> SettingsPage::create_video_resolution_section() { auto video_resolution_list = std::make_unique<List>(List::Orientation::VERTICAL); video_resolution_list->add_widget(std::make_unique<Label>(&get_theme().body_font, "Video resolution limit:", get_color_theme().text_color)); video_resolution_list->add_widget(create_video_resolution()); video_resolution_list_ptr = video_resolution_list.get(); return video_resolution_list; } std::unique_ptr<CheckBox> SettingsPage::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> SettingsPage::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> SettingsPage::create_change_video_resolution_section() { auto checkbox = std::make_unique<CheckBox>(&get_theme().body_font, "Change video resolution"); change_video_resolution_checkbox_ptr = checkbox.get(); return checkbox; } std::unique_ptr<Widget> SettingsPage::create_capture_target(const GsrInfo &gsr_info) { 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(gsr_info)); capture_target_list->add_widget(create_select_window()); capture_target_list->add_widget(create_area_size_section()); capture_target_list->add_widget(create_video_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_video_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<ComboBox> SettingsPage::create_audio_device_selection_combobox() { auto audio_device_box = std::make_unique<ComboBox>(&get_theme().body_font); for(const auto &audio_device : audio_devices) { audio_device_box->add_item(audio_device.description, audio_device.name); } return audio_device_box; } std::unique_ptr<Button> SettingsPage::create_remove_audio_device_button(List *audio_device_list_ptr) { auto remove_audio_track_button = std::make_unique<Button>(&get_theme().body_font, "Remove", mgl::vec2f(0.0f, 0.0f), mgl::Color(0, 0, 0, 120)); remove_audio_track_button->on_click = [this, audio_device_list_ptr]() { audio_track_list_ptr->remove_widget(audio_device_list_ptr); }; return remove_audio_track_button; } std::unique_ptr<List> SettingsPage::create_audio_device() { auto audio_device_list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER); audio_device_list->userdata = (void*)(uintptr_t)AudioTrackType::DEVICE; audio_device_list->add_widget(std::make_unique<Label>(&get_theme().body_font, "Device:", get_color_theme().text_color)); audio_device_list->add_widget(create_audio_device_selection_combobox()); audio_device_list->add_widget(create_remove_audio_device_button(audio_device_list.get())); return audio_device_list; } std::unique_ptr<Button> SettingsPage::create_add_audio_device_button() { auto add_audio_track_button = std::make_unique<Button>(&get_theme().body_font, "Add audio device", mgl::vec2f(0.0f, 0.0f), mgl::Color(0, 0, 0, 120)); add_audio_track_button->on_click = [this]() { audio_devices = get_audio_devices(); audio_track_list_ptr->add_widget(create_audio_device()); }; return add_audio_track_button; } std::unique_ptr<ComboBox> SettingsPage::create_application_audio_selection_combobox() { auto audio_device_box = std::make_unique<ComboBox>(&get_theme().body_font); for(const auto &app_audio : application_audio) { audio_device_box->add_item(app_audio, app_audio); } return audio_device_box; } std::unique_ptr<List> SettingsPage::create_application_audio() { auto application_audio_list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER); application_audio_list->userdata = (void*)(uintptr_t)AudioTrackType::APPLICATION; application_audio_list->add_widget(std::make_unique<Label>(&get_theme().body_font, "App: ", get_color_theme().text_color)); application_audio_list->add_widget(create_application_audio_selection_combobox()); application_audio_list->add_widget(create_remove_audio_device_button(application_audio_list.get())); return application_audio_list; } std::unique_ptr<List> SettingsPage::create_custom_application_audio() { auto application_audio_list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER); application_audio_list->userdata = (void*)(uintptr_t)AudioTrackType::APPLICATION_CUSTOM; application_audio_list->add_widget(std::make_unique<Label>(&get_theme().body_font, "App: ", get_color_theme().text_color)); application_audio_list->add_widget(std::make_unique<Entry>(&get_theme().body_font, "", (int)(get_theme().body_font.get_character_size() * 10.0f))); application_audio_list->add_widget(create_remove_audio_device_button(application_audio_list.get())); return application_audio_list; } std::unique_ptr<Button> SettingsPage::create_add_application_audio_button() { auto add_audio_track_button = std::make_unique<Button>(&get_theme().body_font, "Add application audio", mgl::vec2f(0.0f, 0.0f), mgl::Color(0, 0, 0, 120)); add_application_audio_button_ptr = add_audio_track_button.get(); add_audio_track_button->on_click = [this]() { application_audio = get_application_audio(); audio_track_list_ptr->add_widget(create_application_audio()); }; return add_audio_track_button; } std::unique_ptr<Button> SettingsPage::create_add_custom_application_audio_button() { auto add_audio_track_button = std::make_unique<Button>(&get_theme().body_font, "Add custom application audio", mgl::vec2f(0.0f, 0.0f), mgl::Color(0, 0, 0, 120)); add_custom_application_audio_button_ptr = add_audio_track_button.get(); add_audio_track_button->on_click = [this]() { audio_track_list_ptr->add_widget(create_custom_application_audio()); }; return add_audio_track_button; } std::unique_ptr<List> SettingsPage::create_add_audio_buttons() { auto list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER); list->add_widget(create_add_audio_device_button()); list->add_widget(create_add_application_audio_button()); list->add_widget(create_add_custom_application_audio_button()); return list; } std::unique_ptr<List> SettingsPage::create_audio_track_track_section() { auto list = std::make_unique<List>(List::Orientation::VERTICAL); audio_track_list_ptr = list.get(); audio_track_list_ptr->add_widget(create_audio_device()); // Add default_output by default return list; } std::unique_ptr<CheckBox> SettingsPage::create_merge_audio_tracks_checkbox() { auto merge_audio_tracks_checkbox = std::make_unique<CheckBox>(&get_theme().body_font, "Merge audio tracks"); merge_audio_tracks_checkbox->set_checked(true); merge_audio_tracks_checkbox_ptr = merge_audio_tracks_checkbox.get(); return merge_audio_tracks_checkbox; } std::unique_ptr<CheckBox> SettingsPage::create_application_audio_invert_checkbox() { auto application_audio_invert_checkbox = std::make_unique<CheckBox>(&get_theme().body_font, "Record audio from all applications except the selected ones"); application_audio_invert_checkbox->set_checked(false); application_audio_invert_checkbox_ptr = application_audio_invert_checkbox.get(); return application_audio_invert_checkbox; } std::unique_ptr<Widget> SettingsPage::create_audio_track_section() { auto list = std::make_unique<List>(List::Orientation::VERTICAL); list->add_widget(create_add_audio_buttons()); list->add_widget(create_audio_track_track_section()); return list; } std::unique_ptr<Widget> SettingsPage::create_audio_section() { auto audio_device_section_list = std::make_unique<List>(List::Orientation::VERTICAL); audio_device_section_list->add_widget(create_audio_track_section()); audio_device_section_list->add_widget(create_merge_audio_tracks_checkbox()); audio_device_section_list->add_widget(create_application_audio_invert_checkbox()); audio_device_section_list->add_widget(create_audio_codec()); return std::make_unique<Subsection>("Audio", std::move(audio_device_section_list), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f)); } std::unique_ptr<List> SettingsPage::create_video_quality_box() { auto list = std::make_unique<List>(List::Orientation::VERTICAL); list->add_widget(std::make_unique<Label>(&get_theme().body_font, "Video quality:", get_color_theme().text_color)); auto video_quality_box = std::make_unique<ComboBox>(&get_theme().body_font); if(type == Type::REPLAY || type == Type::STREAM) video_quality_box->add_item("Constant bitrate (Recommended)", "custom"); else video_quality_box->add_item("Constant bitrate", "custom"); video_quality_box->add_item("Medium", "medium"); video_quality_box->add_item("High", "high"); if(type == Type::REPLAY || type == Type::STREAM) video_quality_box->add_item("Very high", "very_high"); else video_quality_box->add_item("Very high (Recommended)", "very_high"); video_quality_box->add_item("Ultra", "ultra"); if(type == Type::REPLAY || type == Type::STREAM) video_quality_box->set_selected_item("custom"); else video_quality_box->set_selected_item("very_high"); video_quality_box_ptr = video_quality_box.get(); list->add_widget(std::move(video_quality_box)); return list; } std::unique_ptr<Entry> SettingsPage::create_video_bitrate_entry() { auto video_bitrate_entry = std::make_unique<Entry>(&get_theme().body_font, "15000", (int)(get_theme().body_font.get_character_size() * 4.0f)); video_bitrate_entry->validate_handler = create_entry_validator_integer_in_range(1, 500000); video_bitrate_entry_ptr = video_bitrate_entry.get(); return video_bitrate_entry; } std::unique_ptr<List> SettingsPage::create_video_bitrate() { auto video_bitrate_list = std::make_unique<List>(List::Orientation::VERTICAL); video_bitrate_list->add_widget(std::make_unique<Label>(&get_theme().body_font, "Video bitrate (kbps):", get_color_theme().text_color)); video_bitrate_list->add_widget(create_video_bitrate_entry()); video_bitrate_list_ptr = video_bitrate_list.get(); return video_bitrate_list; } std::unique_ptr<ComboBox> SettingsPage::create_color_range_box() { auto color_range_box = std::make_unique<ComboBox>(&get_theme().body_font); color_range_box->add_item("Limited", "limited"); color_range_box->add_item("Full", "full"); color_range_box_ptr = color_range_box.get(); return color_range_box; } std::unique_ptr<List> SettingsPage::create_color_range() { auto color_range_list = std::make_unique<List>(List::Orientation::VERTICAL); color_range_list->add_widget(std::make_unique<Label>(&get_theme().body_font, "Color range:", get_color_theme().text_color)); color_range_list->add_widget(create_color_range_box()); color_range_list_ptr = color_range_list.get(); return color_range_list; } std::unique_ptr<List> SettingsPage::create_video_quality_section() { auto quality_list = std::make_unique<List>(List::Orientation::HORIZONTAL); quality_list->add_widget(create_video_quality_box()); quality_list->add_widget(create_video_bitrate()); quality_list->add_widget(create_color_range()); return quality_list; } std::unique_ptr<ComboBox> SettingsPage::create_video_codec_box(const GsrInfo &gsr_info) { auto video_codec_box = std::make_unique<ComboBox>(&get_theme().body_font); // TODO: Show options not supported but disable them. // TODO: Show error if no encoders are supported. // TODO: Show warning (once) if only software encoder is available. video_codec_box->add_item("Auto (Recommended)", "auto"); if(gsr_info.supported_video_codecs.h264) video_codec_box->add_item("H264", "h264"); if(gsr_info.supported_video_codecs.hevc) video_codec_box->add_item("HEVC", "hevc"); if(gsr_info.supported_video_codecs.av1) video_codec_box->add_item("AV1", "av1"); if(gsr_info.supported_video_codecs.vp8) video_codec_box->add_item("VP8", "vp8"); if(gsr_info.supported_video_codecs.vp9) video_codec_box->add_item("VP9", "vp9"); if(gsr_info.supported_video_codecs.hevc_hdr) video_codec_box->add_item("HEVC (HDR)", "hevc_hdr"); if(gsr_info.supported_video_codecs.hevc_10bit) video_codec_box->add_item("HEVC (10 bit, reduces banding)", "hevc_10bit"); if(gsr_info.supported_video_codecs.av1_hdr) video_codec_box->add_item("AV1 (HDR)", "av1_hdr"); if(gsr_info.supported_video_codecs.av1_10bit) video_codec_box->add_item("AV1 (10 bit, reduces banding)", "av1_10bit"); if(gsr_info.supported_video_codecs.h264_software) video_codec_box->add_item("H264 Software Encoder (Slow, not recommended)", "h264_software"); video_codec_box_ptr = video_codec_box.get(); return video_codec_box; } std::unique_ptr<List> SettingsPage::create_video_codec(const GsrInfo &gsr_info) { auto video_codec_list = std::make_unique<List>(List::Orientation::VERTICAL); video_codec_list->add_widget(std::make_unique<Label>(&get_theme().body_font, "Video codec:", get_color_theme().text_color)); video_codec_list->add_widget(create_video_codec_box(gsr_info)); video_codec_ptr = video_codec_list.get(); return video_codec_list; } std::unique_ptr<ComboBox> SettingsPage::create_audio_codec_box() { auto audio_codec_box = std::make_unique<ComboBox>(&get_theme().body_font); audio_codec_box->add_item("Opus (Recommended)", "opus"); audio_codec_box->add_item("AAC", "aac"); audio_codec_box_ptr = audio_codec_box.get(); return audio_codec_box; } std::unique_ptr<List> SettingsPage::create_audio_codec() { auto audio_codec_list = std::make_unique<List>(List::Orientation::VERTICAL); audio_codec_list->add_widget(std::make_unique<Label>(&get_theme().body_font, "Audio codec:", get_color_theme().text_color)); audio_codec_list->add_widget(create_audio_codec_box()); audio_codec_ptr = audio_codec_list.get(); return audio_codec_list; } std::unique_ptr<Entry> SettingsPage::create_framerate_entry() { auto framerate_entry = std::make_unique<Entry>(&get_theme().body_font, "60", (int)(get_theme().body_font.get_character_size() * 2.5f)); framerate_entry->validate_handler = create_entry_validator_integer_in_range(1, 500); framerate_entry_ptr = framerate_entry.get(); return framerate_entry; } std::unique_ptr<List> SettingsPage::create_framerate() { auto framerate_list = std::make_unique<List>(List::Orientation::VERTICAL); framerate_list->add_widget(std::make_unique<Label>(&get_theme().body_font, "Frame rate:", get_color_theme().text_color)); framerate_list->add_widget(create_framerate_entry()); return framerate_list; } std::unique_ptr<ComboBox> SettingsPage::create_framerate_mode_box() { auto framerate_mode_box = std::make_unique<ComboBox>(&get_theme().body_font); framerate_mode_box->add_item("Auto (Recommended)", "auto"); framerate_mode_box->add_item("Constant", "cfr"); framerate_mode_box->add_item("Variable", "vfr"); framerate_mode_box_ptr = framerate_mode_box.get(); return framerate_mode_box; } std::unique_ptr<List> SettingsPage::create_framerate_mode() { auto framerate_mode_list = std::make_unique<List>(List::Orientation::VERTICAL); framerate_mode_list->add_widget(std::make_unique<Label>(&get_theme().body_font, "Frame rate mode:", get_color_theme().text_color)); framerate_mode_list->add_widget(create_framerate_mode_box()); framerate_mode_list_ptr = framerate_mode_list.get(); return framerate_mode_list; } std::unique_ptr<List> SettingsPage::create_framerate_section() { auto framerate_info_list = std::make_unique<List>(List::Orientation::HORIZONTAL); framerate_info_list->add_widget(create_framerate()); framerate_info_list->add_widget(create_framerate_mode()); return framerate_info_list; } std::unique_ptr<Widget> SettingsPage::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> SettingsPage::create_video_section(const GsrInfo &gsr_info) { auto video_section_list = std::make_unique<List>(List::Orientation::VERTICAL); video_section_list->add_widget(create_video_quality_section()); video_section_list->add_widget(create_video_codec(gsr_info)); video_section_list->add_widget(create_framerate_section()); video_section_list->add_widget(create_record_cursor_section()); return std::make_unique<Subsection>("Video", std::move(video_section_list), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f)); } std::unique_ptr<Widget> SettingsPage::create_settings(const GsrInfo &gsr_info) { auto page_list = std::make_unique<List>(List::Orientation::VERTICAL); page_list->set_spacing(0.018f); page_list->add_widget(create_view_radio_button()); 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(gsr_info)); settings_list->add_widget(create_audio_section()); settings_list->add_widget(create_video_section(gsr_info)); settings_list_ptr = settings_list.get(); settings_scrollable_page_ptr->add_widget(std::move(settings_list)); return page_list; } void SettingsPage::add_widgets(const GsrInfo &gsr_info) { content_page_ptr->add_widget(create_settings(gsr_info)); 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 focused_selected = id == "focused"; const bool portal_selected = id == "portal"; select_window_list_ptr->set_visible(window_selected); area_size_list_ptr->set_visible(focused_selected); video_resolution_list_ptr->set_visible(!focused_selected && change_video_resolution_checkbox_ptr->is_checked()); change_video_resolution_checkbox_ptr->set_visible(!focused_selected); restore_portal_session_list_ptr->set_visible(portal_selected); }; change_video_resolution_checkbox_ptr->on_changed = [this](bool checked) { const bool focused_selected = record_area_box_ptr->get_selected_id() == "focused"; video_resolution_list_ptr->set_visible(!focused_selected && checked); }; video_quality_box_ptr->on_selection_changed = [this](const std::string &text, const std::string &id) { (void)text; const bool custom_selected = id == "custom"; video_bitrate_list_ptr->set_visible(custom_selected); if(estimated_file_size_ptr) estimated_file_size_ptr->set_visible(custom_selected); }; video_quality_box_ptr->on_selection_changed("", video_quality_box_ptr->get_selected_id()); if(!gsr_info.supported_capture_options.monitors.empty()) record_area_box_ptr->set_selected_item(gsr_info.supported_capture_options.monitors.front().name); else if(gsr_info.supported_capture_options.portal) record_area_box_ptr->set_selected_item("portal"); else if(gsr_info.supported_capture_options.window) record_area_box_ptr->set_selected_item("window"); else record_area_box_ptr->on_selection_changed("", ""); if(!gsr_info.system_info.supports_app_audio) { add_application_audio_button_ptr->set_visible(false); add_custom_application_audio_button_ptr->set_visible(false); application_audio_invert_checkbox_ptr->set_visible(false); } } void SettingsPage::add_page_specific_widgets(const GsrInfo &gsr_info) { switch(type) { case Type::REPLAY: add_replay_widgets(gsr_info); break; case Type::RECORD: add_record_widgets(gsr_info); break; case Type::STREAM: add_stream_widgets(gsr_info); break; } } std::unique_ptr<List> SettingsPage::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_videos_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>(); 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()); 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> SettingsPage::create_container_box() { auto container_box = std::make_unique<ComboBox>(&get_theme().body_font); container_box->add_item("mp4", "mp4"); container_box->add_item("mkv", "matroska"); container_box->add_item("flv", "flv"); container_box->add_item("mov", "mov"); container_box_ptr = container_box.get(); return container_box; } std::unique_ptr<List> SettingsPage::create_container_section() { auto container_list = std::make_unique<List>(List::Orientation::VERTICAL); container_list->add_widget(std::make_unique<Label>(&get_theme().body_font, "Container:", get_color_theme().text_color)); container_list->add_widget(create_container_box()); return container_list; } std::unique_ptr<Entry> SettingsPage::create_replay_time_entry() { auto replay_time_entry = std::make_unique<Entry>(&get_theme().body_font, "60", get_theme().body_font.get_character_size() * 3); replay_time_entry->validate_handler = create_entry_validator_integer_in_range(1, 1200); replay_time_entry_ptr = replay_time_entry.get(); return replay_time_entry; } std::unique_ptr<List> SettingsPage::create_replay_time() { auto replay_time_list = std::make_unique<List>(List::Orientation::VERTICAL); replay_time_list->add_widget(std::make_unique<Label>(&get_theme().body_font, "Replay time in seconds:", get_color_theme().text_color)); replay_time_list->add_widget(create_replay_time_entry()); return replay_time_list; } std::unique_ptr<RadioButton> SettingsPage::create_start_replay_automatically(const GsrInfo &gsr_info) { char fullscreen_text[256]; snprintf(fullscreen_text, sizeof(fullscreen_text), "Turn on replay when starting a fullscreen application%s", gsr_info.system_info.display_server == DisplayServer::X11 ? "" : " (X11 only)"); auto radiobutton = std::make_unique<RadioButton>(&get_theme().body_font, RadioButton::Orientation::VERTICAL); radiobutton->add_item("Don't turn on replay automatically", "dont_turn_on_automatically"); radiobutton->add_item("Turn on replay at system startup", "turn_on_at_system_startup"); radiobutton->add_item(fullscreen_text, "turn_on_at_fullscreen"); radiobutton->add_item("Turn on replay when power supply is connected", "turn_on_at_power_supply_connected"); turn_on_replay_automatically_mode_ptr = radiobutton.get(); return radiobutton; } std::unique_ptr<CheckBox> SettingsPage::create_save_replay_in_game_folder(const GsrInfo &gsr_info) { char text[256]; snprintf(text, sizeof(text), "Save video in a folder with the name of the game%s", gsr_info.system_info.display_server == DisplayServer::X11 ? "" : " (X11 only)"); auto checkbox = std::make_unique<CheckBox>(&get_theme().body_font, text); save_replay_in_game_folder_ptr = checkbox.get(); return checkbox; } std::unique_ptr<Label> SettingsPage::create_estimated_file_size() { auto label = std::make_unique<Label>(&get_theme().body_font, "Estimated video max file size in RAM: 5.23MB", get_color_theme().text_color); estimated_file_size_ptr = label.get(); return label; } void SettingsPage::update_estimated_file_size() { const int64_t replay_time_seconds = atoi(replay_time_entry_ptr->get_text().c_str()); const int64_t video_bitrate_bps = atoi(video_bitrate_entry_ptr->get_text().c_str()) * 1000LL / 8LL; const double video_filesize_mb = ((double)replay_time_seconds * (double)video_bitrate_bps) / 1024.0 / 1024.0; char buffer[512]; snprintf(buffer, sizeof(buffer), "Estimated video max file size in RAM: %.2fMB", video_filesize_mb); estimated_file_size_ptr->set_text(buffer); } void SettingsPage::add_replay_widgets(const GsrInfo &gsr_info) { 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 replays:")); file_info_data_list->add_widget(create_container_section()); file_info_data_list->add_widget(create_replay_time()); file_info_list->add_widget(std::move(file_info_data_list)); file_info_list->add_widget(create_estimated_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))); auto general_list = std::make_unique<List>(List::Orientation::VERTICAL); general_list->add_widget(create_start_replay_automatically(gsr_info)); general_list->add_widget(create_save_replay_in_game_folder(gsr_info)); 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))); 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 &text, const std::string &id) { (void)text; const bool advanced_view = id == "advanced"; color_range_list_ptr->set_visible(advanced_view); audio_codec_ptr->set_visible(advanced_view); video_codec_ptr->set_visible(advanced_view); framerate_mode_list_ptr->set_visible(advanced_view); notifications_subsection_ptr->set_visible(advanced_view); settings_scrollable_page_ptr->reset_scroll(); }; view_radio_button_ptr->on_selection_changed("Simple", "simple"); replay_time_entry_ptr->on_changed = [this](const std::string&) { update_estimated_file_size(); }; video_bitrate_entry_ptr->on_changed = [this](const std::string&) { update_estimated_file_size(); }; } std::unique_ptr<CheckBox> SettingsPage::create_save_recording_in_game_folder(const GsrInfo &gsr_info) { char text[256]; snprintf(text, sizeof(text), "Save video in a folder with the name of the game%s", gsr_info.system_info.display_server == DisplayServer::X11 ? "" : " (X11 only)"); auto checkbox = std::make_unique<CheckBox>(&get_theme().body_font, text); save_recording_in_game_folder_ptr = checkbox.get(); return checkbox; } void SettingsPage::add_record_widgets(const GsrInfo &gsr_info) { auto file_list = std::make_unique<List>(List::Orientation::HORIZONTAL); file_list->add_widget(create_save_directory("Directory to save the video:")); file_list->add_widget(create_container_section()); settings_list_ptr->add_widget(std::make_unique<Subsection>("File info", std::move(file_list), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f))); auto general_list = std::make_unique<List>(List::Orientation::VERTICAL); general_list->add_widget(create_save_recording_in_game_folder(gsr_info)); 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))); auto checkboxes_list = std::make_unique<List>(List::Orientation::VERTICAL); 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 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 &text, const std::string &id) { (void)text; const bool advanced_view = id == "advanced"; color_range_list_ptr->set_visible(advanced_view); audio_codec_ptr->set_visible(advanced_view); video_codec_ptr->set_visible(advanced_view); framerate_mode_list_ptr->set_visible(advanced_view); notifications_subsection_ptr->set_visible(advanced_view); settings_scrollable_page_ptr->reset_scroll(); }; view_radio_button_ptr->on_selection_changed("Simple", "simple"); } std::unique_ptr<ComboBox> SettingsPage::create_streaming_service_box() { auto streaming_service_box = std::make_unique<ComboBox>(&get_theme().body_font); streaming_service_box->add_item("Twitch", "twitch"); streaming_service_box->add_item("YouTube", "youtube"); streaming_service_box->add_item("Custom", "custom"); streaming_service_box_ptr = streaming_service_box.get(); return streaming_service_box; } std::unique_ptr<List> SettingsPage::create_streaming_service_section() { auto streaming_service_list = std::make_unique<List>(List::Orientation::VERTICAL); streaming_service_list->add_widget(std::make_unique<Label>(&get_theme().body_font, "Stream service:", get_color_theme().text_color)); streaming_service_list->add_widget(create_streaming_service_box()); return streaming_service_list; } std::unique_ptr<List> SettingsPage::create_stream_key_section() { auto stream_key_list = std::make_unique<List>(List::Orientation::VERTICAL); stream_key_list->add_widget(std::make_unique<Label>(&get_theme().body_font, "Stream key:", get_color_theme().text_color)); auto twitch_stream_key_entry = std::make_unique<Entry>(&get_theme().body_font, "", get_theme().body_font.get_character_size() * 20); twitch_stream_key_entry_ptr = twitch_stream_key_entry.get(); stream_key_list->add_widget(std::move(twitch_stream_key_entry)); auto youtube_stream_key_entry = std::make_unique<Entry>(&get_theme().body_font, "", get_theme().body_font.get_character_size() * 20); youtube_stream_key_entry_ptr = youtube_stream_key_entry.get(); stream_key_list->add_widget(std::move(youtube_stream_key_entry)); stream_key_list_ptr = stream_key_list.get(); return stream_key_list; } std::unique_ptr<List> SettingsPage::create_stream_url_section() { auto stream_url_list = std::make_unique<List>(List::Orientation::VERTICAL); stream_url_list->add_widget(std::make_unique<Label>(&get_theme().body_font, "URL:", get_color_theme().text_color)); auto stream_url_entry = std::make_unique<Entry>(&get_theme().body_font, "", get_theme().body_font.get_character_size() * 20); stream_url_entry_ptr = stream_url_entry.get(); stream_url_list->add_widget(std::move(stream_url_entry)); stream_url_list_ptr = stream_url_list.get(); return stream_url_list; } std::unique_ptr<ComboBox> SettingsPage::create_stream_container_box() { auto container_box = std::make_unique<ComboBox>(&get_theme().body_font); container_box->add_item("mp4", "mp4"); container_box->add_item("flv", "flv"); container_box->add_item("ts", "mpegts"); container_box->add_item("m3u8", "hls"); container_box_ptr = container_box.get(); return container_box; } std::unique_ptr<List> SettingsPage::create_stream_container_section() { auto container_list = std::make_unique<List>(List::Orientation::VERTICAL); container_list->add_widget(std::make_unique<Label>(&get_theme().body_font, "Container:", get_color_theme().text_color)); container_list->add_widget(create_stream_container_box()); container_list_ptr = container_list.get(); return container_list; } void SettingsPage::add_stream_widgets(const GsrInfo&) { auto streaming_info_list = std::make_unique<List>(List::Orientation::HORIZONTAL); 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_url_section()); streaming_info_list->add_widget(create_stream_container_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 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)); streaming_service_box_ptr->on_selection_changed = [this](const std::string &text, const std::string &id) { (void)text; const bool twitch_option = id == "twitch"; const bool youtube_option = id == "youtube"; const bool custom_option = id == "custom"; stream_key_list_ptr->set_visible(!custom_option); stream_url_list_ptr->set_visible(custom_option); container_list_ptr->set_visible(custom_option); twitch_stream_key_entry_ptr->set_visible(twitch_option); youtube_stream_key_entry_ptr->set_visible(youtube_option); }; streaming_service_box_ptr->on_selection_changed("Twitch", "twitch"); view_radio_button_ptr->on_selection_changed = [this, notifications_subsection_ptr](const std::string &text, const std::string &id) { (void)text; const bool advanced_view = id == "advanced"; color_range_list_ptr->set_visible(advanced_view); audio_codec_ptr->set_visible(advanced_view); video_codec_ptr->set_visible(advanced_view); framerate_mode_list_ptr->set_visible(advanced_view); notifications_subsection_ptr->set_visible(advanced_view); settings_scrollable_page_ptr->reset_scroll(); }; view_radio_button_ptr->on_selection_changed("Simple", "simple"); } void SettingsPage::on_navigate_away_from_page() { save(); } void SettingsPage::load(const GsrInfo &gsr_info) { switch(type) { case Type::REPLAY: load_replay(gsr_info); break; case Type::RECORD: load_record(gsr_info); break; case Type::STREAM: load_stream(gsr_info); break; } } void SettingsPage::save() { switch(type) { case Type::REPLAY: save_replay(); break; case Type::RECORD: save_record(); break; case Type::STREAM: save_stream(); break; } save_config(config); } static const std::string* get_application_audio_by_name_case_insensitive(const std::vector<std::string> &application_audio, const std::string &name) { for(const auto &app_audio : application_audio) { if(strcasecmp(app_audio.c_str(), name.c_str()) == 0) return &app_audio; } return nullptr; } static bool starts_with(std::string_view str, const char *substr) { size_t len = strlen(substr); return str.size() >= len && memcmp(str.data(), substr, len) == 0; } void SettingsPage::load_audio_tracks(const RecordOptions &record_options, const GsrInfo &gsr_info) { audio_track_list_ptr->clear(); for(const std::string &audio_track : record_options.audio_tracks) { if(starts_with(audio_track, "app:")) { if(!gsr_info.system_info.supports_app_audio) continue; std::string audio_track_name = audio_track.substr(4); const std::string *app_audio = get_application_audio_by_name_case_insensitive(application_audio, audio_track_name); if(app_audio) { std::unique_ptr<List> application_audio_widget = create_application_audio(); ComboBox *application_audio_box = static_cast<ComboBox*>(application_audio_widget->get_child_widget_by_index(1)); application_audio_box->set_selected_item(*app_audio); audio_track_list_ptr->add_widget(std::move(application_audio_widget)); } else { std::unique_ptr<List> application_audio_widget = create_custom_application_audio(); Entry *application_audio_entry = static_cast<Entry*>(application_audio_widget->get_child_widget_by_index(1)); application_audio_entry->set_text(std::move(audio_track_name)); audio_track_list_ptr->add_widget(std::move(application_audio_widget)); } } else if(starts_with(audio_track, "device:")) { std::unique_ptr<List> audio_track_widget = create_audio_device(); ComboBox *audio_device_box = static_cast<ComboBox*>(audio_track_widget->get_child_widget_by_index(1)); audio_device_box->set_selected_item(audio_track.substr(7)); audio_track_list_ptr->add_widget(std::move(audio_track_widget)); } else { std::unique_ptr<List> audio_track_widget = create_audio_device(); ComboBox *audio_device_box = static_cast<ComboBox*>(audio_track_widget->get_child_widget_by_index(1)); audio_device_box->set_selected_item(audio_track); audio_track_list_ptr->add_widget(std::move(audio_track_widget)); } } } void SettingsPage::load_common(RecordOptions &record_options, const GsrInfo &gsr_info) { record_area_box_ptr->set_selected_item(record_options.record_area_option); merge_audio_tracks_checkbox_ptr->set_checked(record_options.merge_audio_tracks); application_audio_invert_checkbox_ptr->set_checked(record_options.application_audio_invert); change_video_resolution_checkbox_ptr->set_checked(record_options.change_video_resolution); load_audio_tracks(record_options, gsr_info); color_range_box_ptr->set_selected_item(record_options.color_range); video_quality_box_ptr->set_selected_item(record_options.video_quality); video_codec_box_ptr->set_selected_item(record_options.video_codec); audio_codec_box_ptr->set_selected_item(record_options.audio_codec); framerate_mode_box_ptr->set_selected_item(record_options.framerate_mode); view_radio_button_ptr->set_selected_item(record_options.advanced_view ? "advanced" : "simple"); // TODO: //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); if(record_options.record_area_width == 0) record_options.record_area_width = 1920; if(record_options.record_area_height == 0) record_options.record_area_height = 1080; if(record_options.video_width == 0) record_options.video_width = 1920; if(record_options.video_height == 0) record_options.video_height = 1080; if(record_options.record_area_width < 32) record_options.record_area_width = 32; area_width_entry_ptr->set_text(std::to_string(record_options.record_area_width)); if(record_options.record_area_height < 32) record_options.record_area_height = 32; area_height_entry_ptr->set_text(std::to_string(record_options.record_area_height)); if(record_options.video_width < 32) record_options.video_width = 32; video_width_entry_ptr->set_text(std::to_string(record_options.video_width)); if(record_options.video_height < 32) record_options.video_height = 32; video_height_entry_ptr->set_text(std::to_string(record_options.video_height)); if(record_options.fps < 1) record_options.fps = 1; framerate_entry_ptr->set_text(std::to_string(record_options.fps)); if(record_options.video_bitrate < 1) record_options.video_bitrate = 1; video_bitrate_entry_ptr->set_text(std::to_string(record_options.video_bitrate)); } void SettingsPage::load_replay(const GsrInfo &gsr_info) { load_common(config.replay_config.record_options, gsr_info); turn_on_replay_automatically_mode_ptr->set_selected_item(config.replay_config.turn_on_replay_automatically_mode); save_replay_in_game_folder_ptr->set_checked(config.replay_config.save_video_in_game_folder); 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); if(config.replay_config.replay_time < 5) config.replay_config.replay_time = 5; replay_time_entry_ptr->set_text(std::to_string(config.replay_config.replay_time)); } void SettingsPage::load_record(const GsrInfo &gsr_info) { load_common(config.record_config.record_options, gsr_info); 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); 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(const GsrInfo &gsr_info) { load_common(config.streaming_config.record_options, gsr_info); 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); stream_url_entry_ptr->set_text(config.streaming_config.custom.url); container_box_ptr->set_selected_item(config.streaming_config.custom.container); } static void save_audio_tracks(std::vector<std::string> &audio_devices, List *audio_devices_list_ptr) { audio_devices.clear(); audio_devices_list_ptr->for_each_child_widget([&audio_devices](std::unique_ptr<Widget> &child_widget) { List *audio_track_line = static_cast<List*>(child_widget.get()); const AudioTrackType audio_track_type = (AudioTrackType)(uintptr_t)audio_track_line->userdata; switch(audio_track_type) { case AudioTrackType::DEVICE: { ComboBox *audio_device_box = static_cast<ComboBox*>(audio_track_line->get_child_widget_by_index(1)); audio_devices.push_back("device:" + audio_device_box->get_selected_id()); break; } case AudioTrackType::APPLICATION: { ComboBox *application_audio_box = static_cast<ComboBox*>(audio_track_line->get_child_widget_by_index(1)); audio_devices.push_back("app:" + application_audio_box->get_selected_id()); break; } case AudioTrackType::APPLICATION_CUSTOM: { Entry *application_audio_entry = static_cast<Entry*>(audio_track_line->get_child_widget_by_index(1)); audio_devices.push_back("app:" + application_audio_entry->get_text()); break; } } return true; }); } void SettingsPage::save_common(RecordOptions &record_options) { record_options.record_area_option = record_area_box_ptr->get_selected_id(); record_options.record_area_width = atoi(area_width_entry_ptr->get_text().c_str()); record_options.record_area_height = atoi(area_height_entry_ptr->get_text().c_str()); record_options.video_width = atoi(video_width_entry_ptr->get_text().c_str()); record_options.video_height = atoi(video_height_entry_ptr->get_text().c_str()); record_options.fps = atoi(framerate_entry_ptr->get_text().c_str()); record_options.video_bitrate = atoi(video_bitrate_entry_ptr->get_text().c_str()); record_options.merge_audio_tracks = merge_audio_tracks_checkbox_ptr->is_checked(); record_options.application_audio_invert = application_audio_invert_checkbox_ptr->is_checked(); record_options.change_video_resolution = change_video_resolution_checkbox_ptr->is_checked(); save_audio_tracks(record_options.audio_tracks, audio_track_list_ptr); record_options.color_range = color_range_box_ptr->get_selected_id(); record_options.video_quality = video_quality_box_ptr->get_selected_id(); record_options.video_codec = video_codec_box_ptr->get_selected_id(); record_options.audio_codec = audio_codec_box_ptr->get_selected_id(); record_options.framerate_mode = framerate_mode_box_ptr->get_selected_id(); record_options.advanced_view = view_radio_button_ptr->get_selected_id() == "advanced"; // TODO: //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(); if(record_options.record_area_width == 0) record_options.record_area_width = 1920; if(record_options.record_area_height == 0) record_options.record_area_height = 1080; if(record_options.video_width == 0) record_options.video_width = 1920; if(record_options.video_height == 0) record_options.video_height = 1080; if(record_options.record_area_width < 32) { record_options.record_area_width = 32; area_width_entry_ptr->set_text("32"); } if(record_options.record_area_height < 32) { record_options.record_area_height = 32; area_height_entry_ptr->set_text("32"); } if(record_options.video_width < 32) { record_options.video_width = 32; video_width_entry_ptr->set_text("32"); } if(record_options.video_height < 32) { record_options.video_height = 32; video_height_entry_ptr->set_text("32"); } if(record_options.fps < 1) { record_options.fps = 1; framerate_entry_ptr->set_text("1"); } if(record_options.video_bitrate < 1) { record_options.video_bitrate = 1; video_bitrate_entry_ptr->set_text("1"); } } void SettingsPage::save_replay() { save_common(config.replay_config.record_options); config.replay_config.turn_on_replay_automatically_mode = turn_on_replay_automatically_mode_ptr->get_selected_id(); config.replay_config.save_video_in_game_folder = save_replay_in_game_folder_ptr->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()); if(config.replay_config.replay_time < 5) { config.replay_config.replay_time = 5; replay_time_entry_ptr->set_text("5"); } } 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.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(); config.streaming_config.custom.url = stream_url_entry_ptr->get_text(); config.streaming_config.custom.container = container_box_ptr->get_selected_id(); } }