From b145d957e3809fd6c2d814c34c58234ade983bb0 Mon Sep 17 00:00:00 2001 From: dec05eba Date: Sun, 8 Sep 2024 17:07:22 +0200 Subject: More --- src/GlobalHotkeysX11.cpp | 137 +++++++++ src/GsrInfo.cpp | 8 + src/Overlay.cpp | 567 +++++++++++++++++++++++++++++++++++ src/Theme.cpp | 49 +++- src/gui/Button.cpp | 6 +- src/gui/ComboBox.cpp | 28 +- src/gui/CustomRendererWidget.cpp | 4 + src/gui/List.cpp | 20 +- src/gui/ScrollablePage.cpp | 1 + src/gui/SettingsPage.cpp | 115 +++++--- src/gui/Subsection.cpp | 60 ++++ src/main.cpp | 620 ++------------------------------------- 12 files changed, 941 insertions(+), 674 deletions(-) create mode 100644 src/GlobalHotkeysX11.cpp create mode 100644 src/Overlay.cpp create mode 100644 src/gui/Subsection.cpp (limited to 'src') diff --git a/src/GlobalHotkeysX11.cpp b/src/GlobalHotkeysX11.cpp new file mode 100644 index 0000000..6b01bfd --- /dev/null +++ b/src/GlobalHotkeysX11.cpp @@ -0,0 +1,137 @@ +#include "../include/GlobalHotkeysX11.hpp" +#define XK_MISCELLANY +#include + +namespace gsr { + static bool x_failed = false; + static int xerror_grab_error(Display*, XErrorEvent*) { + x_failed = true; + return 0; + } + + static unsigned int x11_get_numlock_mask(Display *dpy) { + unsigned int numlockmask = 0; + KeyCode numlock_keycode = XKeysymToKeycode(dpy, XK_Num_Lock); + XModifierKeymap *modmap = XGetModifierMapping(dpy); + if(modmap) { + for(int i = 0; i < 8; ++i) { + for(int j = 0; j < modmap->max_keypermod; ++j) { + if(modmap->modifiermap[i * modmap->max_keypermod + j] == numlock_keycode) + numlockmask = (1 << i); + } + } + XFreeModifiermap(modmap); + } + return numlockmask; + } + + GlobalHotkeysX11::GlobalHotkeysX11() { + dpy = XOpenDisplay(NULL); + if(!dpy) + fprintf(stderr, "GlobalHotkeysX11 error: failed to connect to X11 server, global hotkeys wont be available\n"); + } + + GlobalHotkeysX11::~GlobalHotkeysX11() { + if(dpy) { + XCloseDisplay(dpy); + dpy = nullptr; + } + } + + bool GlobalHotkeysX11::bind_key_press(Hotkey hotkey, const std::string &id, GlobalHotkeyCallback callback) { + if(!dpy) + return false; + + auto it = bound_keys_by_id.find(id); + if(it != bound_keys_by_id.end()) + return false; + + x_failed = false; + XErrorHandler prev_xerror = XSetErrorHandler(xerror_grab_error); + + unsigned int numlock_mask = x11_get_numlock_mask(dpy); + unsigned int modifiers[] = { 0, LockMask, numlock_mask, numlock_mask|LockMask }; + for(int i = 0; i < 4; ++i) { + XGrabKey(dpy, XKeysymToKeycode(dpy, hotkey.key), hotkey.modifiers | modifiers[i], DefaultRootWindow(dpy), False, GrabModeAsync, GrabModeAsync); + } + XSync(dpy, False); + + if(x_failed) { + for(int i = 0; i < 4; ++i) { + XUngrabKey(dpy, XKeysymToKeycode(dpy, hotkey.key), hotkey.modifiers | modifiers[i], DefaultRootWindow(dpy)); + } + XSync(dpy, False); + XSetErrorHandler(prev_xerror); + return false; + } else { + XSetErrorHandler(prev_xerror); + bound_keys_by_id[id] = { hotkey, std::move(callback) }; + return true; + } + } + + void GlobalHotkeysX11::unbind_key_press(const std::string &id) { + if(!dpy) + return; + + auto it = bound_keys_by_id.find(id); + if(it == bound_keys_by_id.end()) + return; + + x_failed = false; + XErrorHandler prev_xerror = XSetErrorHandler(xerror_grab_error); + + unsigned int numlock_mask = x11_get_numlock_mask(dpy); + unsigned int modifiers[] = { 0, LockMask, numlock_mask, numlock_mask|LockMask }; + for(int i = 0; i < 4; ++i) { + XUngrabKey(dpy, XKeysymToKeycode(dpy, it->second.hotkey.key), it->second.hotkey.modifiers | modifiers[i], DefaultRootWindow(dpy)); + } + XSync(dpy, False); + + XSetErrorHandler(prev_xerror); + bound_keys_by_id.erase(id); + } + + void GlobalHotkeysX11::unbind_all_keys() { + if(!dpy) + return; + + x_failed = false; + XErrorHandler prev_xerror = XSetErrorHandler(xerror_grab_error); + + unsigned int numlock_mask = x11_get_numlock_mask(dpy); + unsigned int modifiers[] = { 0, LockMask, numlock_mask, numlock_mask|LockMask }; + for(auto it = bound_keys_by_id.begin(); it != bound_keys_by_id.end();) { + for(int i = 0; i < 4; ++i) { + XUngrabKey(dpy, XKeysymToKeycode(dpy, it->second.hotkey.key), it->second.hotkey.modifiers | modifiers[i], DefaultRootWindow(dpy)); + } + } + bound_keys_by_id.clear(); + XSync(dpy, False); + + XSetErrorHandler(prev_xerror); + } + + void GlobalHotkeysX11::poll_events() { + while(XPending(dpy)) { + XNextEvent(dpy, &xev); + if(xev.type == KeyPress) { + const KeySym key_sym = XLookupKeysym(&xev.xkey, 0); + call_hotkey_callback({ key_sym, xev.xkey.state }); + } + } + } + + static unsigned int key_state_without_locks(unsigned int key_state) { + return key_state & ~(Mod2Mask|LockMask); + } + + void GlobalHotkeysX11::call_hotkey_callback(Hotkey hotkey) const { + for(const auto &[key, val] : bound_keys_by_id) { + if(val.hotkey.key == hotkey.key && key_state_without_locks(val.hotkey.modifiers) == key_state_without_locks(hotkey.modifiers)) { + val.callback(key); + return; + } + } + } +} \ No newline at end of file diff --git a/src/GsrInfo.cpp b/src/GsrInfo.cpp index 5d9773d..916430c 100644 --- a/src/GsrInfo.cpp +++ b/src/GsrInfo.cpp @@ -46,8 +46,16 @@ namespace gsr { gsr_info->supported_video_codecs.h264_software = true; else if(line == "hevc") gsr_info->supported_video_codecs.hevc = true; + else if(line == "hevc_hdr") + gsr_info->supported_video_codecs.hevc_hdr = true; + else if(line == "hevc_10bit") + gsr_info->supported_video_codecs.hevc_10bit = true; else if(line == "av1") gsr_info->supported_video_codecs.av1 = true; + else if(line == "av1_hdr") + gsr_info->supported_video_codecs.av1_hdr = true; + else if(line == "av1_10bit") + gsr_info->supported_video_codecs.av1_10bit = true; else if(line == "vp8") gsr_info->supported_video_codecs.vp8 = true; else if(line == "vp9") diff --git a/src/Overlay.cpp b/src/Overlay.cpp new file mode 100644 index 0000000..a7b813f --- /dev/null +++ b/src/Overlay.cpp @@ -0,0 +1,567 @@ +#include "../include/Overlay.hpp" +#include "../include/Theme.hpp" +#include "../include/Config.hpp" +#include "../include/Process.hpp" +#include "../include/gui/StaticPage.hpp" +#include "../include/gui/DropdownButton.hpp" +#include "../include/gui/CustomRendererWidget.hpp" +#include "../include/gui/SettingsPage.hpp" +#include "../include/gui/Utils.hpp" +#include "../include/gui/PageStack.hpp" + +#include +#include +// TODO: Remove +#include +#include + +#include +#include +#include +#include +#include + +extern "C" { +#include +} + +namespace gsr { + static mgl::Texture texture_from_ximage(XImage *img) { + uint8_t *texture_data = (uint8_t*)malloc(img->width * img->height * 3); + // TODO: + + for(int y = 0; y < img->height; ++y) { + for(int x = 0; x < img->width; ++x) { + unsigned long pixel = XGetPixel(img, x, y); + unsigned char red = (pixel & img->red_mask) >> 16; + unsigned char green = (pixel & img->green_mask) >> 8; + unsigned char blue = pixel & img->blue_mask; + + const size_t texture_data_index = (x + y * img->width) * 3; + texture_data[texture_data_index + 0] = red; + texture_data[texture_data_index + 1] = green; + texture_data[texture_data_index + 2] = blue; + } + } + + mgl::Texture texture; + // TODO: + texture.load_from_memory(texture_data, img->width, img->height, MGL_IMAGE_FORMAT_RGB); + free(texture_data); + return texture; + } + + static char hex_value_to_str(uint8_t v) { + if(v <= 9) + return '0' + v; + else if(v >= 10 && v <= 15) + return 'A' + (v - 10); + else + return '0'; + } + + // Excludes alpha + static std::string color_to_hex_str(mgl::Color color) { + std::string result; + result.resize(6); + + result[0] = hex_value_to_str((color.r & 0xF0) >> 4); + result[1] = hex_value_to_str(color.r & 0x0F); + + result[2] = hex_value_to_str((color.g & 0xF0) >> 4); + result[3] = hex_value_to_str(color.g & 0x0F); + + result[4] = hex_value_to_str((color.b & 0xF0) >> 4); + result[5] = hex_value_to_str(color.b & 0x0F); + + return result; + } + + static Window get_window_at_cursor_position(Display *display) { + Window root_window = None; + Window window = None; + int dummy_i; + unsigned int dummy_u; + int cursor_pos_x = 0; + int cursor_pos_y = 0; + XQueryPointer(display, DefaultRootWindow(display), &root_window, &window, &dummy_i, &dummy_i, &cursor_pos_x, &cursor_pos_y, &dummy_u); + return window; + } + + struct DrawableGeometry { + int x, y, width, height; + }; + + static bool get_drawable_geometry(Display *display, Drawable drawable, DrawableGeometry *geometry) { + geometry->x = 0; + geometry->y = 0; + geometry->width = 0; + geometry->height = 0; + + Window root_window; + unsigned int w, h; + unsigned int dummy_border, dummy_depth; + Status s = XGetGeometry(display, drawable, &root_window, &geometry->x, &geometry->y, &w, &h, &dummy_border, &dummy_depth); + + geometry->width = w; + geometry->height = h; + return s != Success; + } + + static bool diff_int(int a, int b, int difference) { + return std::abs(a - b) <= difference; + } + + static bool is_window_fullscreen_on_monitor(Display *display, Window window, const mgl_monitor *monitor) { + if(!window) + return false; + + DrawableGeometry geometry; + if(!get_drawable_geometry(display, window, &geometry)) + return false; + + const int margin = 2; + return diff_int(geometry.x, monitor->pos.x, margin) && diff_int(geometry.y, monitor->pos.y, margin) + && diff_int(geometry.width, monitor->size.x, margin) && diff_int(geometry.height, monitor->size.y, margin); + } + + #define _NET_WM_STATE_REMOVE 0 + #define _NET_WM_STATE_ADD 1 + #define _NET_WM_STATE_TOGGLE 2 + + static Bool set_window_wm_state(Display *display, Window window, Atom atom) { + Atom net_wm_state_atom = XInternAtom(display, "_NET_WM_STATE", False); + if(!net_wm_state_atom) { + fprintf(stderr, "Error: failed to find atom _NET_WM_STATE\n"); + return False; + } + + XClientMessageEvent xclient; + memset(&xclient, 0, sizeof(xclient)); + + xclient.type = ClientMessage; + xclient.window = window; + xclient.message_type = net_wm_state_atom; + xclient.format = 32; + xclient.data.l[0] = _NET_WM_STATE_ADD; + xclient.data.l[1] = atom; + xclient.data.l[2] = 0; + xclient.data.l[3] = 0; + xclient.data.l[4] = 0; + + XSendEvent(display, DefaultRootWindow(display), False, SubstructureRedirectMask | SubstructureNotifyMask, (XEvent*)&xclient); + XFlush(display); + return True; + } + + static Bool make_window_sticky(Display* display, Window window) { + Atom net_wm_state_sticky_atom = XInternAtom(display, "_NET_WM_STATE_STICKY", False); + if(!net_wm_state_sticky_atom) { + fprintf(stderr, "Error: failed to find atom _NET_WM_STATE_STICKY\n"); + return False; + } + + return set_window_wm_state(display, window, net_wm_state_sticky_atom); + } + + // Returns the first monitor if not found. Assumes there is at least one monitor connected. + static const mgl_monitor* find_monitor_by_cursor_position(mgl::Window &window) { + const mgl_window *win = window.internal_window(); + assert(win->num_monitors > 0); + for(int i = 0; i < win->num_monitors; ++i) { + const mgl_monitor *mon = &win->monitors[i]; + if(mgl::IntRect({ mon->pos.x, mon->pos.y }, { mon->size.x, mon->size.y }).contains({ win->cursor_position.x, win->cursor_position.y })) + return mon; + } + return &win->monitors[0]; + } + + static bool is_compositor_running(Display *dpy, int screen) { + char prop_name[20]; + snprintf(prop_name, sizeof(prop_name), "_NET_WM_CM_S%d", screen); + Atom prop_atom = XInternAtom(dpy, prop_name, False); + return XGetSelectionOwner(dpy, prop_atom) != None; + } + + Overlay::Overlay(mgl::Window &window, std::string resources_path, GsrInfo gsr_info, egl_functions egl_funcs, mgl::Color bg_color) : + window(window), + resources_path(std::move(resources_path)), + gsr_info(std::move(gsr_info)), + egl_funcs(egl_funcs), + bg_color(bg_color), + bg_screenshot_overlay({0.0f, 0.0f}), + top_bar_background({0.0f, 0.0f}), + top_bar_text("GPU Screen Recorder", get_theme().top_bar_font), + logo_sprite(&get_theme().logo_texture), + close_button_widget({0.0f, 0.0f}) + { + memset(&window_texture, 0, sizeof(window_texture)); + } + + Overlay::~Overlay() { + hide(); + if(gpu_screen_recorder_process > 0) { + kill(gpu_screen_recorder_process, SIGINT); + int status; + if(waitpid(gpu_screen_recorder_process, &status, 0) == -1) { + perror("waitpid failed"); + /* Ignore... */ + } + gpu_screen_recorder_process = -1; + } + } + + void Overlay::on_event(mgl::Event &event, mgl::Window &window) { + if(!visible) + return; + + close_button_widget.on_event(event, window, mgl::vec2f(0.0f, 0.0f)); + page_stack.on_event(event, window, mgl::vec2f(0.0f, 0.0f)); + if(event.type == mgl::Event::KeyReleased) { + if(event.key.code == mgl::Keyboard::Escape) + page_stack.pop(); + } + } + + void Overlay::draw(mgl::Window &window) { + if(!visible) + return; + + if(page_stack.empty()) { + hide(); + return; + } + + if(window_texture_sprite.get_texture() && window_texture.texture_id) { + window.draw(window_texture_sprite); + window.draw(bg_screenshot_overlay); + } else if(screenshot_texture.is_valid()) { + window.draw(screenshot_sprite); + window.draw(bg_screenshot_overlay); + } + + window.draw(top_bar_background); + window.draw(top_bar_text); + window.draw(logo_sprite); + + close_button_widget.draw(window, mgl::vec2f(0.0f, 0.0f)); + page_stack.draw(window, mgl::vec2f(0.0f, 0.0f)); + } + + void Overlay::show() { + mgl_window *win = window.internal_window(); + if(win->num_monitors == 0) { + fprintf(stderr, "gsr warning: no monitors found, not showing overlay\n"); + return; + } + + const mgl_monitor *focused_monitor = find_monitor_by_cursor_position(window); + const mgl::vec2i window_pos(focused_monitor->pos.x, focused_monitor->pos.y); + const mgl::vec2i window_size(focused_monitor->size.x, focused_monitor->size.y); + get_theme().set_window_size(window_size); + + window.set_size(window_size); + window.set_size_limits(window_size, window_size); + window.set_position(window_pos); + + update_compositor_texture(focused_monitor); + + audio_devices = get_audio_devices(); + config = read_config(); + + bg_screenshot_overlay = mgl::Rectangle(mgl::vec2f(get_theme().window_width, get_theme().window_height)); + top_bar_background = mgl::Rectangle(mgl::vec2f(get_theme().window_width, get_theme().window_height*0.06f).floor()); + top_bar_text = mgl::Text("GPU Screen Recorder", get_theme().top_bar_font); + logo_sprite = mgl::Sprite(&get_theme().logo_texture); + close_button_widget.set_size(mgl::vec2f(top_bar_background.get_size().y * 0.3f, top_bar_background.get_size().y * 0.3f).floor()); + + bg_screenshot_overlay.set_color(bg_color); + top_bar_background.set_color(mgl::Color(0, 0, 0, 180)); + //top_bar_text.set_color(get_theme().tint_color); + top_bar_text.set_position((top_bar_background.get_position() + top_bar_background.get_size()*0.5f - top_bar_text.get_bounds().size*0.5f).floor()); + close_button_widget.set_position(mgl::vec2f(get_theme().window_width - close_button_widget.get_size().x - 50.0f, top_bar_background.get_size().y * 0.5f - close_button_widget.get_size().y * 0.5f).floor()); + + logo_sprite.set_height((int)(top_bar_background.get_size().y * 0.65f)); + logo_sprite.set_position(mgl::vec2f( + (top_bar_background.get_size().y - logo_sprite.get_size().y) * 0.5f, + top_bar_background.get_size().y * 0.5f - logo_sprite.get_size().y * 0.5f + ).floor()); + + while(!page_stack.empty()) { + page_stack.pop(); + } + + auto front_page = std::make_unique(window_size.to_vec2f()); + StaticPage *front_page_ptr = front_page.get(); + page_stack.push(std::move(front_page)); + + const int button_height = window_size.y / 5.0f; + const int button_width = button_height; + + auto main_buttons_list = std::make_unique(List::Orientation::HORIZONTAL); + main_buttons_list->set_spacing(0.0f); + { + auto button = std::make_unique(&get_theme().title_font, &get_theme().body_font, "Instant Replay", "On", "Off", &get_theme().replay_button_texture, + mgl::vec2f(button_width, button_height)); + button->add_item("Start", "start"); + button->add_item("Settings", "settings"); + button->on_click = [&](const std::string &id) { + if(id == "settings") { + auto replay_settings_page = std::make_unique(SettingsPage::Type::REPLAY, gsr_info, audio_devices, config, &page_stack); + page_stack.push(std::move(replay_settings_page)); + return; + } + /* + char window_to_record_str[32]; + snprintf(window_to_record_str, sizeof(window_to_record_str), "%ld", target_window); + + const char *args[] = { + "gpu-screen-recorder", "-w", window_to_record_str, + "-c", "mp4", + "-f", "60", + "-o", "/home/dec05eba/Videos/gpu-screen-recorder.mp4", + nullptr + }; + exec_program_daemonized(args); + */ + }; + main_buttons_list->add_widget(std::move(button)); + } + { + auto button = std::make_unique(&get_theme().title_font, &get_theme().body_font, "Record", "Recording", "Not recording", &get_theme().record_button_texture, + mgl::vec2f(button_width, button_height)); + DropdownButton *button_ptr = button.get(); + button->add_item("Start", "start"); + button->add_item("Settings", "settings"); + button->on_click = [&, button_ptr](const std::string &id) { + if(id == "settings") { + auto record_settings_page = std::make_unique(SettingsPage::Type::RECORD, gsr_info, audio_devices, config, &page_stack); + page_stack.push(std::move(record_settings_page)); + return; + } + + if(id != "start") + return; + + // window.close(); + // usleep(1000 * 50); // 50 milliseconds + + const std::string tint_color_as_hex = color_to_hex_str(get_theme().tint_color); + + if(gpu_screen_recorder_process > 0) { + kill(gpu_screen_recorder_process, SIGINT); + int status; + if(waitpid(gpu_screen_recorder_process, &status, 0) == -1) { + perror("waitpid failed"); + /* Ignore... */ + } + // window.set_visible(false); + // window.close(); + // return; + //exit(0); + gpu_screen_recorder_process = -1; + button_ptr->set_item_label(id, "Start"); + + // TODO: Show this with a slight delay to make sure it doesn't show up in the video + const std::string record_image_filepath = resources_path + "images/record.png"; + const char *notification_args[] = { + "gsr-notify", "--text", "Recording has been saved", "--timeout", "3.0", + "--icon", record_image_filepath.c_str(), + "--icon-color", "ffffff", "--bg-color", tint_color_as_hex.c_str(), + nullptr + }; + exec_program_daemonized(notification_args); + return; + } + + const char *args[] = { + "gpu-screen-recorder", "-w", "screen", + "-c", "mp4", + "-f", "60", + "-o", "/home/dec05eba/Videos/gpu-screen-recorder.mp4", + nullptr + }; + gpu_screen_recorder_process = exec_program(args); + if(gpu_screen_recorder_process == -1) { + // TODO: Show notification failed to start + } else { + button_ptr->set_item_label(id, "Stop"); + } + + // TODO: Start recording after this notification has disappeared to make sure it doesn't show up in the video. + // Make clear to the user that the recording starts after the notification is gone. + // Maybe have the option in notification to show timer until its getting hidden, then the notification can say: + // Starting recording in 3... + // 2... + // 1... + // TODO: Do not run this is a daemon. Instead get the pid and when launching another notification close the current notification + // program and start another one. This can also be used to check when the notification has finished by checking with waitpid NOWAIT + // to see when the program has exit. + const std::string record_image_filepath = resources_path + "images/record.png"; + const char *notification_args[] = { + "gsr-notify", "--text", "Recording has started", "--timeout", "3.0", + "--icon", record_image_filepath.c_str(), + "--icon-color", tint_color_as_hex.c_str(), "--bg-color", tint_color_as_hex.c_str(), + nullptr + }; + exec_program_daemonized(notification_args); + //exit(0); + // window.set_visible(false); + // window.close(); + + // TODO: Show notification with args: + // "Recording has started" 3.0 ./images/record.png 76b900 + }; + main_buttons_list->add_widget(std::move(button)); + } + { + auto button = std::make_unique(&get_theme().title_font, &get_theme().body_font, "Livestream", "Streaming", "Not streaming", &get_theme().stream_button_texture, + mgl::vec2f(button_width, button_height)); + button->add_item("Start", "start"); + button->add_item("Settings", "settings"); + button->on_click = [&](const std::string &id) { + if(id == "settings") { + auto stream_settings_page = std::make_unique(SettingsPage::Type::STREAM, gsr_info, audio_devices, config, &page_stack); + page_stack.push(std::move(stream_settings_page)); + return; + } + }; + main_buttons_list->add_widget(std::move(button)); + } + + const mgl::vec2f main_buttons_list_size = main_buttons_list->get_size(); + main_buttons_list->set_position((mgl::vec2f(window_size.x * 0.5f, window_size.y * 0.25f) - main_buttons_list_size * 0.5f).floor()); + front_page_ptr->add_widget(std::move(main_buttons_list)); + + close_button_widget.draw_handler = [&](mgl::Window &window, mgl::vec2f pos, mgl::vec2f size) { + if(mgl::FloatRect(pos, size).contains(window.get_mouse_position().to_vec2f())) { + const float border_scale = 0.0015f; + const int border_size = std::max(1.0f, border_scale * get_theme().window_height); + draw_rectangle_outline(window, pos, size, get_theme().tint_color, border_size); + } + + mgl::Sprite close_sprite(&get_theme().close_texture); + close_sprite.set_position(pos); + close_sprite.set_size(size); + window.draw(close_sprite); + }; + + close_button_widget.event_handler = [&](mgl::Event &event, mgl::Window&, mgl::vec2f pos, mgl::vec2f size) { + if(event.type == mgl::Event::MouseButtonPressed && event.mouse_button.button == mgl::Mouse::Left) { + close_button_pressed_inside = mgl::FloatRect(pos, size).contains(mgl::vec2f(event.mouse_button.x, event.mouse_button.y)); + } else if(event.type == mgl::Event::MouseButtonReleased && event.mouse_button.button == mgl::Mouse::Left && close_button_pressed_inside) { + if(mgl::FloatRect(pos, size).contains(mgl::vec2f(event.mouse_button.x, event.mouse_button.y))) { + while(!page_stack.empty()) { + page_stack.pop(); + } + return false; + } + } + return true; + }; + + mgl_context *context = mgl_get_context(); + Display *display = (Display*)context->connection; + + window.set_fullscreen(true); + window.set_visible(true); + make_window_sticky(display, window.get_system_handle()); + + if(default_cursor) { + XFreeCursor(display, default_cursor); + default_cursor = 0; + } + default_cursor = XCreateFontCursor(display, XC_arrow); + + // TODO: Retry if these fail. + // TODO: Hmm, these dont work in owlboy. Maybe owlboy uses xi2 and that breaks this (does it?). + // Remove these grabs when debugging with a debugger, or your X11 session will appear frozen + + XGrabPointer(display, window.get_system_handle(), True, + ButtonPressMask | ButtonReleaseMask | PointerMotionMask | + Button1MotionMask | Button2MotionMask | Button3MotionMask | Button4MotionMask | Button5MotionMask | + ButtonMotionMask, + GrabModeAsync, GrabModeAsync, None, default_cursor, CurrentTime); + // TODO: This breaks global hotkeys + //XGrabKeyboard(display, window.get_system_handle(), True, GrabModeAsync, GrabModeAsync, CurrentTime); + + XSetInputFocus(display, window.get_system_handle(), RevertToParent, CurrentTime); + XFlush(display); + + //window.set_fullscreen(true); + + visible = true; + + mgl::Event event; + event.type = mgl::Event::MouseMoved; + event.mouse_move.x = window.get_mouse_position().x; + event.mouse_move.y = window.get_mouse_position().y; + on_event(event, window); + } + + void Overlay::hide() { + mgl_context *context = mgl_get_context(); + Display *display = (Display*)context->connection; + + if(default_cursor) { + XFreeCursor(display, default_cursor); + default_cursor = 0; + } + + //XUngrabKeyboard(display, CurrentTime); + XUngrabPointer(display, CurrentTime); + XFlush(display); + + window_texture_deinit(&window_texture); + visible = false; + window.set_visible(false); + } + + void Overlay::toggle_show() { + if(visible) + hide(); + else + show(); + } + + bool Overlay::is_open() const { + return visible; + } + + bool Overlay::update_compositor_texture(const mgl_monitor *monitor) { + window_texture_deinit(&window_texture); + window_texture_sprite.set_texture(nullptr); + screenshot_texture.clear(); + screenshot_sprite.set_texture(nullptr); + + mgl_context *context = mgl_get_context(); + Display *display = (Display*)context->connection; + + if(is_compositor_running(display, 0)) + return false; + + bool window_texture_loaded = false; + const Window window_at_cursor_position = get_window_at_cursor_position(display); + if(is_window_fullscreen_on_monitor(display, window_at_cursor_position, monitor) && window_at_cursor_position) + window_texture_loaded = window_texture_init(&window_texture, display, mgl_window_get_egl_display(window.internal_window()), window_at_cursor_position, egl_funcs) == 0; + + if(window_texture_loaded && window_texture.texture_id) { + window_texture_texture = mgl::Texture(window_texture.texture_id, MGL_TEXTURE_FORMAT_RGB); + window_texture_sprite.set_texture(&window_texture_texture); + } else { + XImage *img = XGetImage(display, DefaultRootWindow(display), monitor->pos.x, monitor->pos.y, monitor->size.x, monitor->size.y, AllPlanes, ZPixmap); + if(!img) + fprintf(stderr, "Error: failed to take a screenshot\n"); + + if(img) { + screenshot_texture = texture_from_ximage(img); + if(screenshot_texture.is_valid()) + screenshot_sprite.set_texture(&screenshot_texture); + XDestroyImage(img); + img = NULL; + } + } + + return true; + } +} \ No newline at end of file diff --git a/src/Theme.cpp b/src/Theme.cpp index d498ef3..523a324 100644 --- a/src/Theme.cpp +++ b/src/Theme.cpp @@ -1,19 +1,36 @@ #include "../include/Theme.hpp" #include "../include/GsrInfo.hpp" + #include namespace gsr { static Theme *theme = nullptr; - bool init_theme(const GsrInfo &gsr_info, mgl::vec2i window_size, const std::string &resources_path) { + bool Theme::set_window_size(mgl::vec2i window_size) { + if(std::abs(window_size.x - window_width) < 0.1f && std::abs(window_size.y - window_height) < 0.1f) + return true; + + window_width = window_size.x; + window_height = window_size.y; + + if(!theme->title_font.load_from_file(theme->title_font_file, std::max(16.0f, window_size.y * 0.019f))) + return false; + + if(!theme->top_bar_font.load_from_file(theme->title_font_file, std::max(23.0f, window_size.y * 0.03f))) + return false; + + if(!theme->body_font.load_from_file(theme->body_font_file, std::max(13.0f, window_size.y * 0.015f))) + return false; + + return true; + } + + bool init_theme(const GsrInfo &gsr_info, const std::string &resources_path) { if(theme) return true; theme = new Theme(); - theme->window_width = window_size.x; - theme->window_height = window_size.y; - switch(gsr_info.gpu_info.vendor) { case GpuVendor::UNKNOWN: { break; @@ -32,31 +49,37 @@ namespace gsr { } } - if(!theme->body_font_file.load("/usr/share/fonts/noto/NotoSans-Regular.ttf", mgl::MemoryMappedFile::LoadOptions{true, false})) + if(!theme->body_font_file.load((resources_path + "fonts/NotoSans-Regular.ttf").c_str(), mgl::MemoryMappedFile::LoadOptions{true, false})) goto error; - if(!theme->title_font_file.load("/usr/share/fonts/noto/NotoSans-Bold.ttf", mgl::MemoryMappedFile::LoadOptions{true, false})) + if(!theme->title_font_file.load((resources_path + "fonts/NotoSans-Bold.ttf").c_str(), mgl::MemoryMappedFile::LoadOptions{true, false})) goto error; - if(!theme->title_font.load_from_file(theme->title_font_file, std::max(16.0f, window_size.y * 0.019f))) + if(!theme->combobox_arrow_texture.load_from_file((resources_path + "images/combobox_arrow.png").c_str())) goto error; - if(!theme->top_bar_font.load_from_file(theme->title_font_file, std::max(23.0f, window_size.y * 0.03f))) + if(!theme->settings_texture.load_from_file((resources_path + "images/settings.png").c_str())) goto error; - if(!theme->body_font.load_from_file(theme->body_font_file, std::max(13.0f, window_size.y * 0.015f))) + if(!theme->folder_texture.load_from_file((resources_path + "images/folder.png").c_str())) + goto error; + + if(!theme->up_arrow_texture.load_from_file((resources_path + "images/up_arrow.png").c_str())) + goto error; + + if(!theme->replay_button_texture.load_from_file((resources_path + "images/replay.png").c_str())) goto error; - if(!theme->combobox_arrow_texture.load_from_file((resources_path + "images/combobox_arrow.png").c_str(), {false, false, false})) + if(!theme->record_button_texture.load_from_file((resources_path + "images/record.png").c_str())) goto error; - if(!theme->settings_texture.load_from_file((resources_path + "images/settings.png").c_str(), {false, false, false})) + if(!theme->stream_button_texture.load_from_file((resources_path + "images/stream.png").c_str())) goto error; - if(!theme->folder_texture.load_from_file((resources_path + "images/folder.png").c_str(), {false, false, false})) + if(!theme->close_texture.load_from_file((resources_path + "images/cross.png").c_str())) goto error; - if(!theme->up_arrow_texture.load_from_file((resources_path + "images/up_arrow.png").c_str(), {false, false, false})) + if(!theme->logo_texture.load_from_file((resources_path + "images/gpu_screen_recorder_logo.png").c_str())) goto error; return true; diff --git a/src/gui/Button.cpp b/src/gui/Button.cpp index 0cf5bee..bccf7b0 100644 --- a/src/gui/Button.cpp +++ b/src/gui/Button.cpp @@ -48,8 +48,10 @@ namespace gsr { window.draw(text); const bool mouse_inside = mgl::FloatRect(draw_pos, item_size).contains(window.get_mouse_position().to_vec2f()) && !has_parent_with_selected_child_widget(); - if(mouse_inside) - draw_rectangle_outline(window, draw_pos, item_size, get_theme().tint_color, std::max(1.0f, border_scale * get_theme().window_height)); + if(mouse_inside) { + const mgl::Color outline_color = (bg_color == get_theme().tint_color) ? mgl::Color(255, 255, 255) : get_theme().tint_color; + draw_rectangle_outline(window, draw_pos, item_size, outline_color, std::max(1.0f, border_scale * get_theme().window_height)); + } } mgl::vec2f Button::get_size() { diff --git a/src/gui/ComboBox.cpp b/src/gui/ComboBox.cpp index b344c4e..760ddae 100644 --- a/src/gui/ComboBox.cpp +++ b/src/gui/ComboBox.cpp @@ -22,6 +22,9 @@ namespace gsr { if(!visible) return true; + if(items.empty()) + return true; + const int padding_top = padding_top_scale * get_theme().window_height; const int padding_bottom = padding_bottom_scale * get_theme().window_height; const int padding_left = padding_left_scale * get_theme().window_height; @@ -73,9 +76,6 @@ namespace gsr { update_if_dirty(); - if(items.empty()) - return; - const int padding_top = padding_top_scale * get_theme().window_height; const int padding_bottom = padding_bottom_scale * get_theme().window_height; const int padding_left = padding_left_scale * get_theme().window_height; @@ -106,15 +106,17 @@ namespace gsr { const bool mouse_inside = mgl::FloatRect(draw_pos, item_size).contains(window.get_mouse_position().to_vec2f()) && !has_parent_with_selected_child_widget(); mgl::vec2f pos = draw_pos + mgl::vec2f(padding_left, padding_top); - Item &item = items[selected_item]; - item.text.set_position(pos.floor()); - if(show_dropdown || mouse_inside) { - const int border_size = std::max(1.0f, border_scale * get_theme().window_height); - const mgl::Color border_color = get_theme().tint_color; - draw_rectangle_outline(window, pos - mgl::vec2f(padding_left, padding_top), item_size.floor(), border_color, border_size); + if(selected_item < items.size()) { + Item &selected_item_widget = items[selected_item]; + selected_item_widget.text.set_position(pos.floor()); + if(show_dropdown || mouse_inside) { + const int border_size = std::max(1.0f, border_scale * get_theme().window_height); + const mgl::Color border_color = get_theme().tint_color; + draw_rectangle_outline(window, pos - mgl::vec2f(padding_left, padding_top), item_size.floor(), border_color, border_size); + } + window.draw(selected_item_widget.text); + pos.y += selected_item_widget.text.get_bounds().size.y + padding_top + padding_bottom; } - window.draw(item.text); - pos.y += item.text.get_bounds().size.y + padding_top + padding_bottom; for(size_t i = 0; i < items.size(); ++i) { Item &item = items[i]; @@ -185,6 +187,10 @@ namespace gsr { max_size.x = std::max(max_size.x, bounds.x + padding_left + padding_right); max_size.y += bounds.y + padding_top + padding_bottom; } + + if(max_size.x <= 0.001f) + max_size.x = 50.0f; + max_size.x += padding_left + get_dropdown_arrow_height(); dirty = false; } diff --git a/src/gui/CustomRendererWidget.cpp b/src/gui/CustomRendererWidget.cpp index 98b7caf..cfb113b 100644 --- a/src/gui/CustomRendererWidget.cpp +++ b/src/gui/CustomRendererWidget.cpp @@ -38,4 +38,8 @@ namespace gsr { return size; } + + void CustomRendererWidget::set_size(mgl::vec2f size) { + this->size = size; + } } \ No newline at end of file diff --git a/src/gui/List.cpp b/src/gui/List.cpp index 849329f..81f0e80 100644 --- a/src/gui/List.cpp +++ b/src/gui/List.cpp @@ -52,6 +52,9 @@ namespace gsr { if(!widget->visible) continue; + if(i > 0) + draw_pos.y += spacing; + const auto widget_size = widget->get_size(); // TODO: Do this parent widget alignment for horizontal alignment and for other types of widget alignment // and other widgets. @@ -67,8 +70,6 @@ namespace gsr { if(widget.get() != selected_widget) widget->draw(window, mgl::vec2f(0.0f, 0.0f)); draw_pos.y += widget_size.y; - if(widget_size.y > 0.001f && i + 1 < widgets.size()) - draw_pos.y += spacing; } break; } @@ -78,6 +79,9 @@ namespace gsr { if(!widget->visible) continue; + if(i > 0) + draw_pos.x += spacing; + const auto widget_size = widget->get_size(); if(content_alignment == Alignment::CENTER) offset.y = floor(size.y * 0.5f - widget_size.y * 0.5f); @@ -88,8 +92,6 @@ namespace gsr { if(widget.get() != selected_widget) widget->draw(window, mgl::vec2f(0.0f, 0.0f)); draw_pos.x += widget_size.x; - if(widget_size.x > 0.001f && i + 1 < widgets.size()) - draw_pos.x += spacing; } break; } @@ -146,11 +148,12 @@ namespace gsr { if(!widget->visible) continue; + if(i > 0) + size.y += spacing; + const auto widget_size = widget->get_size(); size.x = std::max(size.x, widget_size.x); size.y += widget_size.y; - if(widget_size.y > 0.001f && i + 1 < widgets.size()) - size.y += spacing; } break; } @@ -160,10 +163,11 @@ namespace gsr { if(!widget->visible) continue; + if(i > 0) + size.x += spacing; + const auto widget_size = widget->get_size(); size.x += widget_size.x; - if(widget_size.x > 0.001f && i + 1 < widgets.size()) - size.x += spacing; size.y = std::max(size.y, widget_size.y); } break; diff --git a/src/gui/ScrollablePage.cpp b/src/gui/ScrollablePage.cpp index a791d75..7e15edf 100644 --- a/src/gui/ScrollablePage.cpp +++ b/src/gui/ScrollablePage.cpp @@ -140,6 +140,7 @@ namespace gsr { } void ScrollablePage::add_widget(std::unique_ptr widget) { + widget->parent_widget = this; widgets.push_back(std::move(widget)); } diff --git a/src/gui/SettingsPage.cpp b/src/gui/SettingsPage.cpp index 259df6c..12d1d99 100644 --- a/src/gui/SettingsPage.cpp +++ b/src/gui/SettingsPage.cpp @@ -3,8 +3,10 @@ #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 #include @@ -61,9 +63,9 @@ namespace gsr { return record_area_box; } - std::unique_ptr SettingsPage::create_record_area(const GsrInfo &gsr_info) { + std::unique_ptr SettingsPage::create_record_area(const GsrInfo &gsr_info) { auto record_area_list = std::make_unique(List::Orientation::VERTICAL); - record_area_list->add_widget(std::make_unique