public/gpu-screen-recorder-ui
1
0
Fork 0
mirror of https://repo.dec05eba.com/gpu-screen-recorder-ui synced 2026-03-31 09:17:04 +09:00
Code Issues Actions Packages Projects Releases Wiki Activity

Add option to not save screenshot to disk (only clipboard), refactor webcam ui code

Browse Source
This commit is contained in:
dec05eba
2025-12-27 22:57:09 +01:00
parent 45ae7c95cf
commit 1ea9615584
7 changed files with 148 additions and 124 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
include/Config.hpp
View File

@@ -148,6 +148,7 @@ namespace gsr {
bool save_screenshot_in_game_folder = false; bool save_screenshot_in_game_folder = false;
bool save_screenshot_to_clipboard = false; bool save_screenshot_to_clipboard = false;
bool save_screenshot_to_disk = true;
bool show_notifications = true; bool show_notifications = true;
bool use_led_indicator = false; bool use_led_indicator = false;
std::string save_directory; std::string save_directory;

2
include/gui/ScreenshotSettingsPage.hpp
View File

@@ -43,6 +43,7 @@ namespace gsr {
std::unique_ptr<Widget> create_file_info_section(); std::unique_ptr<Widget> create_file_info_section();
std::unique_ptr<CheckBox> create_save_screenshot_in_game_folder(); std::unique_ptr<CheckBox> create_save_screenshot_in_game_folder();
std::unique_ptr<CheckBox> create_save_screenshot_to_clipboard(); std::unique_ptr<CheckBox> create_save_screenshot_to_clipboard();
std::unique_ptr<CheckBox> create_save_screenshot_to_disk();
std::unique_ptr<Widget> create_notifications(); std::unique_ptr<Widget> create_notifications();
std::unique_ptr<Widget> create_led_indicator(); std::unique_ptr<Widget> create_led_indicator();
std::unique_ptr<Widget> create_general_section(); std::unique_ptr<Widget> create_general_section();
@@ -76,6 +77,7 @@ namespace gsr {
Button *save_directory_button_ptr = nullptr; Button *save_directory_button_ptr = nullptr;
CheckBox *save_screenshot_in_game_folder_checkbox_ptr = nullptr; CheckBox *save_screenshot_in_game_folder_checkbox_ptr = nullptr;
CheckBox *save_screenshot_to_clipboard_checkbox_ptr = nullptr; CheckBox *save_screenshot_to_clipboard_checkbox_ptr = nullptr;
CheckBox *save_screenshot_to_disk_checkbox_ptr = nullptr;
CheckBox *show_notification_checkbox_ptr = nullptr; CheckBox *show_notification_checkbox_ptr = nullptr;
CheckBox *led_indicator_checkbox_ptr = nullptr; CheckBox *led_indicator_checkbox_ptr = nullptr;
Entry *create_custom_script_screenshot_entry_ptr = nullptr; Entry *create_custom_script_screenshot_entry_ptr = nullptr;

3
include/gui/SettingsPage.hpp
View File

@@ -68,6 +68,9 @@ namespace gsr {
std::unique_ptr<Widget> create_capture_target_section(); std::unique_ptr<Widget> create_capture_target_section();
std::unique_ptr<List> create_webcam_sources(); std::unique_ptr<List> create_webcam_sources();
std::unique_ptr<List> create_webcam_video_format(); std::unique_ptr<List> create_webcam_video_format();
std::unique_ptr<Widget> create_webcam_location_widget();
std::unique_ptr<CheckBox> create_flip_camera_checkbox();
std::unique_ptr<List> create_webcam_body();
std::unique_ptr<Widget> create_webcam_section(); std::unique_ptr<Widget> create_webcam_section();
std::unique_ptr<ComboBox> create_audio_device_selection_combobox(AudioDeviceType device_type); std::unique_ptr<ComboBox> create_audio_device_selection_combobox(AudioDeviceType device_type);
std::unique_ptr<Button> create_remove_audio_device_button(List *audio_input_list_ptr, List *audio_device_list_ptr); std::unique_ptr<Button> create_remove_audio_device_button(List *audio_input_list_ptr, List *audio_device_list_ptr);

1
src/Config.cpp
View File

@@ -305,6 +305,7 @@ namespace gsr {
{"screenshot.restore_portal_session", &config.screenshot_config.restore_portal_session}, {"screenshot.restore_portal_session", &config.screenshot_config.restore_portal_session},
{"screenshot.save_screenshot_in_game_folder", &config.screenshot_config.save_screenshot_in_game_folder}, {"screenshot.save_screenshot_in_game_folder", &config.screenshot_config.save_screenshot_in_game_folder},
{"screenshot.save_screenshot_to_clipboard", &config.screenshot_config.save_screenshot_to_clipboard}, {"screenshot.save_screenshot_to_clipboard", &config.screenshot_config.save_screenshot_to_clipboard},
{"screenshot.save_screenshot_to_disk", &config.screenshot_config.save_screenshot_to_disk},
{"screenshot.show_notifications", &config.screenshot_config.show_notifications}, {"screenshot.show_notifications", &config.screenshot_config.show_notifications},
{"screenshot.use_led_indicator", &config.screenshot_config.use_led_indicator}, {"screenshot.use_led_indicator", &config.screenshot_config.use_led_indicator},
{"screenshot.save_directory", &config.screenshot_config.save_directory}, {"screenshot.save_directory", &config.screenshot_config.save_directory},

9
src/Overlay.cpp
View File

@@ -2167,7 +2167,7 @@ namespace gsr {
exit_code = WEXITSTATUS(status); exit_code = WEXITSTATUS(status);
if(exit_code == 0) { if(exit_code == 0) {
if(config.screenshot_config.save_screenshot_in_game_folder) { if(config.screenshot_config.save_screenshot_in_game_folder && config.screenshot_config.save_screenshot_to_disk) {
save_video_in_current_game_directory(screenshot_filepath, NotificationType::SCREENSHOT); save_video_in_current_game_directory(screenshot_filepath, NotificationType::SCREENSHOT);
} else if(config.screenshot_config.show_notifications) { } else if(config.screenshot_config.show_notifications) {
char msg[512]; char msg[512];
@@ -3359,7 +3359,12 @@ namespace gsr {
} }
// TODO: Validate input, fallback to valid values // TODO: Validate input, fallback to valid values
const std::string output_file = config.screenshot_config.save_directory + "/Screenshot_" + get_date_str() + "." + config.screenshot_config.image_format; // TODO: Validate image format std::string output_file;
if(config.screenshot_config.save_screenshot_to_disk)
output_file = config.screenshot_config.save_directory + "/Screenshot_" + get_date_str() + "." + config.screenshot_config.image_format; // TODO: Validate image format
else
output_file = "/tmp/gsr_ui_clipboard_screenshot." + config.screenshot_config.image_format;
const bool capture_cursor = force_type == ScreenshotForceType::NONE && config.screenshot_config.record_cursor; const bool capture_cursor = force_type == ScreenshotForceType::NONE && config.screenshot_config.record_cursor;
std::vector<const char*> args = { std::vector<const char*> args = {

14
src/gui/ScreenshotSettingsPage.cpp
View File

@@ -221,6 +221,13 @@ namespace gsr {
return checkbox; return checkbox;
} }
std::unique_ptr<CheckBox> ScreenshotSettingsPage::create_save_screenshot_to_disk() {
auto checkbox = std::make_unique<CheckBox>(&get_theme().body_font, "Save screenshot to disk");
save_screenshot_to_disk_checkbox_ptr = checkbox.get();
checkbox->set_checked(true);
return checkbox;
}
std::unique_ptr<Widget> ScreenshotSettingsPage::create_notifications() { std::unique_ptr<Widget> ScreenshotSettingsPage::create_notifications() {
auto checkbox = std::make_unique<CheckBox>(&get_theme().body_font, "Show screenshot notifications"); auto checkbox = std::make_unique<CheckBox>(&get_theme().body_font, "Show screenshot notifications");
checkbox->set_checked(true); checkbox->set_checked(true);
@@ -239,6 +246,7 @@ namespace gsr {
auto list = std::make_unique<List>(List::Orientation::VERTICAL); auto list = std::make_unique<List>(List::Orientation::VERTICAL);
list->add_widget(create_save_screenshot_in_game_folder()); list->add_widget(create_save_screenshot_in_game_folder());
list->add_widget(create_save_screenshot_to_clipboard()); list->add_widget(create_save_screenshot_to_clipboard());
list->add_widget(create_save_screenshot_to_disk());
return std::make_unique<Subsection>("General", std::move(list), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f)); return std::make_unique<Subsection>("General", std::move(list), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f));
} }
@@ -273,7 +281,7 @@ namespace gsr {
std::unique_ptr<Widget> ScreenshotSettingsPage::create_settings() { std::unique_ptr<Widget> ScreenshotSettingsPage::create_settings() {
auto page_list = std::make_unique<List>(List::Orientation::VERTICAL); auto page_list = std::make_unique<List>(List::Orientation::VERTICAL);
page_list->set_spacing(0.018f); page_list->set_spacing(0.018f);
auto scrollable_page = std::make_unique<ScrollablePage>(content_page_ptr->get_inner_size() - mgl::vec2f(0.0f, page_list->get_size().y + 0.018f * get_theme().window_height)); auto scrollable_page = std::make_unique<ScrollablePage>(content_page_ptr->get_inner_size() - mgl::vec2f(0.0f, page_list->get_size().y));
settings_scrollable_page_ptr = scrollable_page.get(); settings_scrollable_page_ptr = scrollable_page.get();
page_list->add_widget(std::move(scrollable_page)); page_list->add_widget(std::move(scrollable_page));
@@ -327,6 +335,7 @@ namespace gsr {
save_directory_button_ptr->set_text(config.screenshot_config.save_directory); save_directory_button_ptr->set_text(config.screenshot_config.save_directory);
save_screenshot_in_game_folder_checkbox_ptr->set_checked(config.screenshot_config.save_screenshot_in_game_folder); save_screenshot_in_game_folder_checkbox_ptr->set_checked(config.screenshot_config.save_screenshot_in_game_folder);
save_screenshot_to_clipboard_checkbox_ptr->set_checked(config.screenshot_config.save_screenshot_to_clipboard); save_screenshot_to_clipboard_checkbox_ptr->set_checked(config.screenshot_config.save_screenshot_to_clipboard);
save_screenshot_to_disk_checkbox_ptr->set_checked(config.screenshot_config.save_screenshot_to_disk);
show_notification_checkbox_ptr->set_checked(config.screenshot_config.show_notifications); show_notification_checkbox_ptr->set_checked(config.screenshot_config.show_notifications);
led_indicator_checkbox_ptr->set_checked(config.screenshot_config.use_led_indicator); led_indicator_checkbox_ptr->set_checked(config.screenshot_config.use_led_indicator);
@@ -358,7 +367,8 @@ namespace gsr {
config.screenshot_config.restore_portal_session = restore_portal_session_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_directory = save_directory_button_ptr->get_text();
config.screenshot_config.save_screenshot_in_game_folder = save_screenshot_in_game_folder_checkbox_ptr->is_checked(); config.screenshot_config.save_screenshot_in_game_folder = save_screenshot_in_game_folder_checkbox_ptr->is_checked();
config.screenshot_config.save_screenshot_to_clipboard = save_screenshot_to_clipboard_checkbox_ptr->is_checked(); config.screenshot_config.save_screenshot_to_clipboard = save_screenshot_to_disk_checkbox_ptr->is_checked();
config.screenshot_config.save_screenshot_to_disk = save_screenshot_to_clipboard_checkbox_ptr->is_checked();
config.screenshot_config.show_notifications = show_notification_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.use_led_indicator = led_indicator_checkbox_ptr->is_checked();
config.screenshot_config.custom_script = create_custom_script_screenshot_entry_ptr->get_text(); config.screenshot_config.custom_script = create_custom_script_screenshot_entry_ptr->get_text();

242
src/gui/SettingsPage.cpp
View File

@@ -249,154 +249,156 @@ namespace gsr {
return ll; return ll;
} }
std::unique_ptr<Widget> SettingsPage::create_webcam_section() { std::unique_ptr<Widget> SettingsPage::create_webcam_location_widget() {
auto ll = std::make_unique<List>(List::Orientation::VERTICAL); const float camera_screen_width = std::min(400.0f, (float)settings_scrollable_page_ptr->get_inner_size().x * 0.90f);
camera_screen_size = mgl::vec2f(camera_screen_width, camera_screen_width * 0.5625);
ll->add_widget(create_webcam_sources()); const float screen_border = 2.0f;
const mgl::vec2f screen_border_size(screen_border, screen_border);
screen_inner_size = mgl::vec2f(camera_screen_size - screen_border_size*2.0f);
auto body_list = std::make_unique<List>(List::Orientation::VERTICAL); const mgl::vec2f bounding_box_size(30.0f, 30.0f);
body_list->set_visible(false);
webcam_body_list_ptr = body_list.get();
{
const float camera_screen_width = std::min(400.0f, (float)settings_scrollable_page_ptr->get_inner_size().x * 0.90f);
camera_screen_size = mgl::vec2f(camera_screen_width, camera_screen_width * 0.5625);
const float screen_border = 2.0f; auto camera_location_widget = std::make_unique<CustomRendererWidget>(camera_screen_size);
const mgl::vec2f screen_border_size(screen_border, screen_border); camera_location_widget->draw_handler = [this, screen_border_size, screen_border](mgl::Window &window, mgl::vec2f pos, mgl::vec2f size) {
screen_inner_size = mgl::vec2f(camera_screen_size - screen_border_size*2.0f); if(!selected_camera.has_value())
return;
const mgl::vec2f bounding_box_size(30.0f, 30.0f); pos = pos.floor();
size = size.floor();
const mgl::vec2i mouse_pos = window.get_mouse_position();
const mgl::vec2f webcam_box_min_size = clamp_keep_aspect_ratio(selected_camera->size.to_vec2f(), screen_inner_size * 0.2f);
auto camera_location_widget = std::make_unique<CustomRendererWidget>(camera_screen_size); if(moving_webcam_box) {
camera_location_widget->draw_handler = [this, screen_border_size, screen_border](mgl::Window &window, mgl::vec2f pos, mgl::vec2f size) { webcam_box_pos = mouse_pos.to_vec2f() - screen_border_size - webcam_box_grab_offset - pos;
if(!selected_camera.has_value()) } else if(webcam_resize_corner == WebcamBoxResizeCorner::BOTTOM_RIGHT) {
return; const mgl::vec2f mouse_diff = mouse_pos.to_vec2f() - webcam_resize_start_pos;
webcam_box_size = webcam_box_size_resize_start + mouse_diff;
}
pos = pos.floor(); webcam_box_size = clamp_keep_aspect_ratio(selected_camera->size.to_vec2f(), webcam_box_size);
size = size.floor();
const mgl::vec2i mouse_pos = window.get_mouse_position();
const mgl::vec2f webcam_box_min_size = clamp_keep_aspect_ratio(selected_camera->size.to_vec2f(), screen_inner_size * 0.2f);
if(moving_webcam_box) { if(webcam_box_pos.x < 0.0f)
webcam_box_pos = mouse_pos.to_vec2f() - screen_border_size - webcam_box_grab_offset - pos; webcam_box_pos.x = 0.0f;
} else if(webcam_resize_corner == WebcamBoxResizeCorner::BOTTOM_RIGHT) { else if(webcam_box_pos.x + webcam_box_size.x > screen_inner_size.x)
const mgl::vec2f mouse_diff = mouse_pos.to_vec2f() - webcam_resize_start_pos; webcam_box_pos.x = screen_inner_size.x - webcam_box_size.x;
webcam_box_size = webcam_box_size_resize_start + mouse_diff;
}
webcam_box_size = clamp_keep_aspect_ratio(selected_camera->size.to_vec2f(), webcam_box_size); if(webcam_box_pos.y < 0.0f)
webcam_box_pos.y = 0.0f;
else if(webcam_box_pos.y + webcam_box_size.y > screen_inner_size.y)
webcam_box_pos.y = screen_inner_size.y - webcam_box_size.y;
if(webcam_box_pos.x < 0.0f) if(webcam_box_size.x < webcam_box_min_size.x)
webcam_box_pos.x = 0.0f; webcam_box_size.x = webcam_box_min_size.x;
else if(webcam_box_pos.x + webcam_box_size.x > screen_inner_size.x) else if(webcam_box_pos.x + webcam_box_size.x > screen_inner_size.x)
webcam_box_pos.x = screen_inner_size.x - webcam_box_size.x; webcam_box_size.x = screen_inner_size.x - webcam_box_pos.x;
if(webcam_box_pos.y < 0.0f) //webcam_box_size = clamp_keep_aspect_ratio(selected_camera->size.to_vec2f(), webcam_box_size);
webcam_box_pos.y = 0.0f;
else if(webcam_box_pos.y + webcam_box_size.y > screen_inner_size.y)
webcam_box_pos.y = screen_inner_size.y - webcam_box_size.y;
if(webcam_box_size.x < webcam_box_min_size.x) if(webcam_box_size.y < webcam_box_min_size.y)
webcam_box_size.x = webcam_box_min_size.x; webcam_box_size.y = webcam_box_min_size.y;
else if(webcam_box_pos.x + webcam_box_size.x > screen_inner_size.x) else if(webcam_box_pos.y + webcam_box_size.y > screen_inner_size.y)
webcam_box_size.x = screen_inner_size.x - webcam_box_pos.x; webcam_box_size.y = screen_inner_size.y - webcam_box_pos.y;
//webcam_box_size = clamp_keep_aspect_ratio(selected_camera->size.to_vec2f(), webcam_box_size); webcam_box_size = clamp_keep_aspect_ratio(selected_camera->size.to_vec2f(), webcam_box_size);
if(webcam_box_size.y < webcam_box_min_size.y) {
webcam_box_size.y = webcam_box_min_size.y; draw_rectangle_outline(window, pos, size, mgl::Color(255, 0, 0, 255), screen_border);
else if(webcam_box_pos.y + webcam_box_size.y > screen_inner_size.y) mgl::Text screen_text("Screen", get_theme().camera_setup_font);
webcam_box_size.y = screen_inner_size.y - webcam_box_pos.y; screen_text.set_position((pos + size * 0.5f - screen_text.get_bounds().size * 0.5f).floor());
window.draw(screen_text);
}
webcam_box_size = clamp_keep_aspect_ratio(selected_camera->size.to_vec2f(), webcam_box_size); {
webcam_box_drawn_size = clamp_keep_aspect_ratio(selected_camera->size.to_vec2f(), webcam_box_size);
webcam_box_drawn_pos = (pos + screen_border_size + webcam_box_pos).floor();
{ draw_rectangle_outline(window, webcam_box_drawn_pos, webcam_box_drawn_size, mgl::Color(0, 255, 0, 255), screen_border);
draw_rectangle_outline(window, pos, size, mgl::Color(255, 0, 0, 255), screen_border);
mgl::Text screen_text("Screen", get_theme().camera_setup_font);
screen_text.set_position((pos + size * 0.5f - screen_text.get_bounds().size * 0.5f).floor());
window.draw(screen_text);
}
{ // mgl::Rectangle resize_area(webcam_box_drawn_pos + webcam_box_drawn_size - bounding_box_size*0.5f - screen_border_size*0.5f, bounding_box_size);
webcam_box_drawn_size = clamp_keep_aspect_ratio(selected_camera->size.to_vec2f(), webcam_box_size); // resize_area.set_color(mgl::Color(0, 0, 255, 255));
webcam_box_drawn_pos = (pos + screen_border_size + webcam_box_pos).floor(); // window.draw(resize_area);
draw_rectangle_outline(window, webcam_box_drawn_pos, webcam_box_drawn_size, mgl::Color(0, 255, 0, 255), screen_border); mgl::Text webcam_text("Webcam", get_theme().camera_setup_font);
webcam_text.set_position((webcam_box_drawn_pos + webcam_box_drawn_size * 0.5f - webcam_text.get_bounds().size * 0.5f).floor());
window.draw(webcam_text);
}
};
// mgl::Rectangle resize_area(webcam_box_drawn_pos + webcam_box_drawn_size - bounding_box_size*0.5f - screen_border_size*0.5f, bounding_box_size); camera_location_widget->event_handler = [this, screen_border_size, bounding_box_size](mgl::Event &event, mgl::Window&, mgl::vec2f, mgl::vec2f) {
// resize_area.set_color(mgl::Color(0, 0, 255, 255)); switch(event.type) {
// window.draw(resize_area); case mgl::Event::MouseButtonPressed: {
if(event.mouse_button.button == mgl::Mouse::Left && webcam_resize_corner == WebcamBoxResizeCorner::NONE) {
mgl::Text webcam_text("Webcam", get_theme().camera_setup_font); const mgl::vec2f mouse_button_pos(event.mouse_button.x, event.mouse_button.y);
webcam_text.set_position((webcam_box_drawn_pos + webcam_box_drawn_size * 0.5f - webcam_text.get_bounds().size * 0.5f).floor()); if(mgl::FloatRect(webcam_box_drawn_pos, webcam_box_drawn_size).contains(mouse_button_pos)) {
window.draw(webcam_text); moving_webcam_box = true;
}
};
camera_location_widget->event_handler = [this, screen_border_size, bounding_box_size](mgl::Event &event, mgl::Window&, mgl::vec2f, mgl::vec2f) {
switch(event.type) {
case mgl::Event::MouseButtonPressed: {
if(event.mouse_button.button == mgl::Mouse::Left && webcam_resize_corner == WebcamBoxResizeCorner::NONE) {
const mgl::vec2f mouse_button_pos(event.mouse_button.x, event.mouse_button.y);
if(mgl::FloatRect(webcam_box_drawn_pos, webcam_box_drawn_size).contains(mouse_button_pos)) {
moving_webcam_box = true;
webcam_box_grab_offset = mouse_button_pos - webcam_box_drawn_pos;
} else {
moving_webcam_box = false;
}
} else if(event.mouse_button.button == mgl::Mouse::Right && !moving_webcam_box) {
const mgl::vec2f mouse_button_pos(event.mouse_button.x, event.mouse_button.y);
webcam_resize_start_pos = mouse_button_pos;
webcam_box_pos_resize_start = webcam_box_pos;
webcam_box_size_resize_start = webcam_box_size;
webcam_box_grab_offset = mouse_button_pos - webcam_box_drawn_pos; webcam_box_grab_offset = mouse_button_pos - webcam_box_drawn_pos;
} else {
/*if(mgl::FloatRect(webcam_box_drawn_pos - bounding_box_size*0.5f, bounding_box_size).contains(mouse_button_pos)) {
webcam_resize_corner = WebcamBoxResizeCorner::TOP_LEFT;
fprintf(stderr, "top left\n");
} else if(mgl::FloatRect(webcam_box_drawn_pos + mgl::vec2f(webcam_box_drawn_size.x, 0.0f) - bounding_box_size*0.5f, bounding_box_size).contains(mouse_button_pos)) {
webcam_resize_corner = WebcamBoxResizeCorner::TOP_RIGHT;
fprintf(stderr, "top right\n");
} else if(mgl::FloatRect(webcam_box_drawn_pos + mgl::vec2f(0.0f, webcam_box_drawn_size.y) - bounding_box_size*0.5f, bounding_box_size).contains(mouse_button_pos)) {
webcam_resize_corner = WebcamBoxResizeCorner::BOTTOM_LEFT;
fprintf(stderr, "bottom left\n");
} else */if(mgl::FloatRect(webcam_box_drawn_pos + webcam_box_drawn_size - bounding_box_size*0.5f - screen_border_size*0.5f, bounding_box_size).contains(mouse_button_pos)) {
webcam_resize_corner = WebcamBoxResizeCorner::BOTTOM_RIGHT;
} else {
webcam_resize_corner = WebcamBoxResizeCorner::NONE;
}
}
break;
}
case mgl::Event::MouseButtonReleased: {
if(event.mouse_button.button == mgl::Mouse::Left && webcam_resize_corner == WebcamBoxResizeCorner::NONE) {
moving_webcam_box = false; moving_webcam_box = false;
} else if(event.mouse_button.button == mgl::Mouse::Right && !moving_webcam_box) { }
} else if(event.mouse_button.button == mgl::Mouse::Right && !moving_webcam_box) {
const mgl::vec2f mouse_button_pos(event.mouse_button.x, event.mouse_button.y);
webcam_resize_start_pos = mouse_button_pos;
webcam_box_pos_resize_start = webcam_box_pos;
webcam_box_size_resize_start = webcam_box_size;
webcam_box_grab_offset = mouse_button_pos - webcam_box_drawn_pos;
/*if(mgl::FloatRect(webcam_box_drawn_pos - bounding_box_size*0.5f, bounding_box_size).contains(mouse_button_pos)) {
webcam_resize_corner = WebcamBoxResizeCorner::TOP_LEFT;
fprintf(stderr, "top left\n");
} else if(mgl::FloatRect(webcam_box_drawn_pos + mgl::vec2f(webcam_box_drawn_size.x, 0.0f) - bounding_box_size*0.5f, bounding_box_size).contains(mouse_button_pos)) {
webcam_resize_corner = WebcamBoxResizeCorner::TOP_RIGHT;
fprintf(stderr, "top right\n");
} else if(mgl::FloatRect(webcam_box_drawn_pos + mgl::vec2f(0.0f, webcam_box_drawn_size.y) - bounding_box_size*0.5f, bounding_box_size).contains(mouse_button_pos)) {
webcam_resize_corner = WebcamBoxResizeCorner::BOTTOM_LEFT;
fprintf(stderr, "bottom left\n");
} else */if(mgl::FloatRect(webcam_box_drawn_pos + webcam_box_drawn_size - bounding_box_size*0.5f - screen_border_size*0.5f, bounding_box_size).contains(mouse_button_pos)) {
webcam_resize_corner = WebcamBoxResizeCorner::BOTTOM_RIGHT;
} else {
webcam_resize_corner = WebcamBoxResizeCorner::NONE; webcam_resize_corner = WebcamBoxResizeCorner::NONE;
} }
break;
}
default: {
break;
} }
break;
} }
return true; case mgl::Event::MouseButtonReleased: {
}; if(event.mouse_button.button == mgl::Mouse::Left && webcam_resize_corner == WebcamBoxResizeCorner::NONE) {
moving_webcam_box = false;
body_list->add_widget(std::move(camera_location_widget)); } else if(event.mouse_button.button == mgl::Mouse::Right && !moving_webcam_box) {
} webcam_resize_corner = WebcamBoxResizeCorner::NONE;
}
break;
}
default: {
break;
}
}
return true;
};
return camera_location_widget;
}
std::unique_ptr<CheckBox> SettingsPage::create_flip_camera_checkbox() {
auto flip_camera_horizontally_checkbox = std::make_unique<CheckBox>(&get_theme().body_font, "Flip camera horizontally");
flip_camera_horizontally_checkbox_ptr = flip_camera_horizontally_checkbox.get();
return flip_camera_horizontally_checkbox;
}
std::unique_ptr<List> SettingsPage::create_webcam_body() {
auto body_list = std::make_unique<List>(List::Orientation::VERTICAL);
webcam_body_list_ptr = body_list.get();
body_list->set_visible(false);
body_list->add_widget(create_webcam_location_widget());
body_list->add_widget(std::make_unique<Label>(&get_theme().body_font, "* Right click in the bottom right corner to resize the webcam", get_color_theme().text_color)); body_list->add_widget(std::make_unique<Label>(&get_theme().body_font, "* Right click in the bottom right corner to resize the webcam", get_color_theme().text_color));
body_list->add_widget(create_flip_camera_checkbox());
{
auto flip_camera_horizontally_checkbox = std::make_unique<CheckBox>(&get_theme().body_font, "Flip camera horizontally");
flip_camera_horizontally_checkbox_ptr = flip_camera_horizontally_checkbox.get();
body_list->add_widget(std::move(flip_camera_horizontally_checkbox));
}
body_list->add_widget(create_webcam_video_format()); body_list->add_widget(create_webcam_video_format());
ll->add_widget(std::move(body_list)); return body_list;
}
std::unique_ptr<Widget> SettingsPage::create_webcam_section() {
auto ll = std::make_unique<List>(List::Orientation::VERTICAL);
ll->add_widget(create_webcam_sources());
ll->add_widget(create_webcam_body());
return std::make_unique<Subsection>("Webcam", std::move(ll), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f)); return std::make_unique<Subsection>("Webcam", std::move(ll), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f));
} }