More

12 files changed, 941 insertions, 674 deletions

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 <X11/keysymdef.h>
+
+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 <string.h>
+#include <assert.h>
+// TODO: Remove
+#include <signal.h>
+#include <sys/wait.h>
+
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/cursorfont.h>
+#include <mglpp/system/Rect.hpp>
+#include <mglpp/window/Event.hpp>
+
+extern "C" {
+#include <mgl/mgl.h>
+}
+
+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<StaticPage>(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>(List::Orientation::HORIZONTAL);
+        main_buttons_list->set_spacing(0.0f);
+        {
+            auto button = std::make_unique<DropdownButton>(&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>(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<DropdownButton>(&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>(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<DropdownButton>(&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>(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 <assert.h>
 
 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) {
+        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 <mglpp/graphics/Rectangle.hpp>
 #include <mglpp/graphics/Sprite.hpp>
@@ -61,9 +63,9 @@ namespace gsr {
         return record_area_box;
     }
 
-    std::unique_ptr<List> SettingsPage::create_record_area(const GsrInfo &gsr_info) {
+    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, "Record area:", get_theme().text_color));
+        record_area_list->add_widget(std::make_unique<Label>(&get_theme().body_font, "Capture target:", get_theme().text_color));
         record_area_list->add_widget(create_record_area_box(gsr_info));
         return record_area_list;
     }
@@ -121,14 +123,14 @@ namespace gsr {
         return restore_portal_session_list;
     }
 
-    std::unique_ptr<List> SettingsPage::create_capture_target(const GsrInfo &gsr_info) {
+    std::unique_ptr<Widget> SettingsPage::create_capture_target(const GsrInfo &gsr_info) {
         // TODO: List::Alignment::Center causes 1 frame glitch when switching record area but only the first time
         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_restore_portal_session_section());
-        return capture_target_list;
+        return std::make_unique<Subsection>("Record area", std::move(capture_target_list), mgl::vec2f(content_page_ptr->get_inner_size().x, 0.0f));
     }
 
     std::unique_ptr<ComboBox> SettingsPage::create_audio_track_selection_checkbox(const std::vector<AudioDevice> &audio_devices) {
@@ -177,13 +179,12 @@ namespace gsr {
         return merge_audio_tracks_checkbox;
     }
 
-    std::unique_ptr<List> SettingsPage::create_audio_device_section(const std::vector<AudioDevice> &audio_devices) {
+    std::unique_ptr<Widget> SettingsPage::create_audio_device_section(const std::vector<AudioDevice> &audio_devices) {
         auto audio_device_section_list = std::make_unique<List>(List::Orientation::VERTICAL);
-        audio_device_section_list->add_widget(std::make_unique<Label>(&get_theme().body_font, "Audio:", get_theme().text_color));
         audio_device_section_list->add_widget(create_add_audio_track_button(audio_devices));
         audio_device_section_list->add_widget(create_audio_track_section(audio_devices));
         audio_device_section_list->add_widget(create_merge_audio_tracks_checkbox());
-        return audio_device_section_list;
+        return std::make_unique<Subsection>("Audio", std::move(audio_device_section_list), mgl::vec2f(content_page_ptr->get_inner_size().x, 0.0f));
     }
 
     std::unique_ptr<ComboBox> SettingsPage::create_video_quality_box() {
@@ -241,7 +242,14 @@ namespace gsr {
             video_codec_box->add_item("VP8", "vp8");
         if(gsr_info.supported_video_codecs.vp9)
             video_codec_box->add_item("VP9", "vp9");
-        // TODO: Add hdr options
+        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();
@@ -315,18 +323,39 @@ namespace gsr {
         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<List> SettingsPage::create_settings(const GsrInfo &gsr_info, const std::vector<AudioDevice> &audio_devices) {
+    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_codec_section(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(content_page_ptr->get_inner_size().x, 0.0f));
+    }
+
+    std::unique_ptr<Widget> SettingsPage::create_settings(const GsrInfo &gsr_info, const std::vector<AudioDevice> &audio_devices) {
         auto settings_list = std::make_unique<List>(List::Orientation::VERTICAL);
         settings_list->set_spacing(0.018f);
-        settings_list->add_widget(create_view_radio_button());
         settings_list->add_widget(create_capture_target(gsr_info));
         settings_list->add_widget(create_audio_device_section(audio_devices));
-        settings_list->add_widget(create_video_quality_section());
-        settings_list->add_widget(create_codec_section(gsr_info));
-        settings_list->add_widget(create_framerate_section());
+        settings_list->add_widget(create_video_section(gsr_info));
         settings_list_ptr = settings_list.get();
-        return settings_list;
+
+        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();
+        scrollable_page->add_widget(std::move(settings_list));
+        page_list->add_widget(std::move(scrollable_page));
+        return page_list;
     }
 
     void SettingsPage::add_widgets(const GsrInfo &gsr_info, const std::vector<AudioDevice> &audio_devices) {
@@ -346,6 +375,10 @@ namespace gsr {
             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("", "");
     }
 
     void SettingsPage::add_page_specific_widgets() {
@@ -365,7 +398,7 @@ namespace gsr {
     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_theme().text_color));
-        auto save_directory_button = std::make_unique<Button>(&get_theme().body_font, "/home/dec05eba", mgl::vec2f(0.0f, 0.0f), mgl::Color(0, 0, 0, 120));
+        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>();
@@ -424,15 +457,10 @@ namespace gsr {
         replay_data_list->add_widget(create_save_directory("Directory to save replays:"));
         replay_data_list->add_widget(create_container_section());
         replay_data_list->add_widget(create_replay_time());
-        settings_list_ptr->add_widget(std::move(replay_data_list));
+        settings_list_ptr->add_widget(std::make_unique<Subsection>("File info", std::move(replay_data_list), mgl::vec2f(content_page_ptr->get_inner_size().x, 0.0f)));
 
         auto checkboxes_list = std::make_unique<List>(List::Orientation::VERTICAL);
 
-        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();
-        checkboxes_list->add_widget(std::move(record_cursor_checkbox));
-
         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();
@@ -448,17 +476,18 @@ namespace gsr {
         show_replay_saved_notification_checkbox_ptr = show_replay_saved_notification_checkbox.get();
         checkboxes_list->add_widget(std::move(show_replay_saved_notification_checkbox));
 
-        settings_list_ptr->add_widget(std::move(checkboxes_list));
+        auto notifications_subsection = std::make_unique<Subsection>("Notifications", std::move(checkboxes_list), mgl::vec2f(content_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](const std::string &text, const std::string &id) {
+        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);
             codec_list_ptr->set_visible(advanced_view);
             framerate_mode_list_ptr->set_visible(advanced_view);
-            show_replay_started_notification_checkbox_ptr->set_visible(advanced_view);
-            show_replay_stopped_notification_checkbox_ptr->set_visible(advanced_view);
-            show_replay_saved_notification_checkbox_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");
     }
@@ -467,15 +496,10 @@ namespace gsr {
         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::move(file_list));
+        settings_list_ptr->add_widget(std::make_unique<Subsection>("File info", std::move(file_list), mgl::vec2f(content_page_ptr->get_inner_size().x, 0.0f)));
 
         auto checkboxes_list = std::make_unique<List>(List::Orientation::VERTICAL);
 
-        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();
-        checkboxes_list->add_widget(std::move(record_cursor_checkbox));
-
         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();
@@ -486,16 +510,18 @@ namespace gsr {
         show_video_saved_notification_checkbox_ptr = show_video_saved_notification_checkbox.get();
         checkboxes_list->add_widget(std::move(show_video_saved_notification_checkbox));
 
-        settings_list_ptr->add_widget(std::move(checkboxes_list));
+        auto notifications_subsection = std::make_unique<Subsection>("Notifications", std::move(checkboxes_list), mgl::vec2f(content_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](const std::string &text, const std::string &id) {
+        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);
             codec_list_ptr->set_visible(advanced_view);
             framerate_mode_list_ptr->set_visible(advanced_view);
-            show_recording_started_notification_checkbox_ptr->set_visible(advanced_view);
-            show_video_saved_notification_checkbox_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");
     }
@@ -570,15 +596,10 @@ namespace gsr {
         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::move(streaming_info_list));
+        settings_list_ptr->add_widget(std::make_unique<Subsection>("Streaming info", std::move(streaming_info_list), mgl::vec2f(content_page_ptr->get_inner_size().x, 0.0f)));
 
         auto checkboxes_list = std::make_unique<List>(List::Orientation::VERTICAL);
 
-        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();
-        checkboxes_list->add_widget(std::move(record_cursor_checkbox));
-
         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();
@@ -589,7 +610,9 @@ namespace gsr {
         show_streaming_stopped_notification_checkbox_ptr = show_streaming_stopped_notification_checkbox.get();
         checkboxes_list->add_widget(std::move(show_streaming_stopped_notification_checkbox));
 
-        settings_list_ptr->add_widget(std::move(checkboxes_list));
+        auto notifications_subsection = std::make_unique<Subsection>("Notifications", std::move(checkboxes_list), mgl::vec2f(content_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;
@@ -604,14 +627,14 @@ namespace gsr {
         };
         streaming_service_box_ptr->on_selection_changed("Twitch", "twitch");
 
-        view_radio_button_ptr->on_selection_changed = [this](const std::string &text, const std::string &id) {
+        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);
             codec_list_ptr->set_visible(advanced_view);
             framerate_mode_list_ptr->set_visible(advanced_view);
-            show_streaming_started_notification_checkbox_ptr->set_visible(advanced_view);
-            show_streaming_stopped_notification_checkbox_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");
     }
diff --git a/src/gui/Subsection.cpp b/src/gui/Subsection.cpp
new file mode 100644
index 0000000..74b65e0
--- /dev/null
+++ b/src/gui/Subsection.cpp
@@ -0,0 +1,60 @@
+#include "../../include/gui/Subsection.hpp"
+#include "../../include/Theme.hpp"
+
+#include <mglpp/window/Window.hpp>
+#include <mglpp/graphics/Rectangle.hpp>
+
+namespace gsr {
+    static const float margin_top_scale = 0.015f;
+    static const float margin_bottom_scale = 0.015f;
+    static const float margin_left_scale = 0.015f;
+    static const float margin_right_scale = 0.015f;
+    static const float title_spacing_scale = 0.015f;
+
+    Subsection::Subsection(const char *title, std::unique_ptr<Widget> inner_widget, mgl::vec2f size) :
+        label(&get_theme().title_font, title, get_theme().text_color),
+        inner_widget(std::move(inner_widget)),
+        size(size)
+    {
+        this->inner_widget->parent_widget = this;
+    }
+    
+    bool Subsection::on_event(mgl::Event &event, mgl::Window &window, mgl::vec2f) {
+        if(!visible)
+            return true;
+
+        return inner_widget->on_event(event, window, mgl::vec2f(0.0f, 0.0f));
+    }
+
+    void Subsection::draw(mgl::Window &window, mgl::vec2f offset) {
+        if(!visible)
+            return;
+
+        mgl::vec2f draw_pos = position + offset;
+        mgl::Rectangle background(draw_pos.floor(), get_size().floor());
+        background.set_color(mgl::Color(25, 30, 34));
+        window.draw(background);
+
+        draw_pos += mgl::vec2f(margin_left_scale, margin_top_scale) * mgl::vec2f(get_theme().window_height, get_theme().window_height);
+        label.draw(window, draw_pos);
+        draw_pos.y += label.get_size().y + title_spacing_scale * get_theme().window_height;
+
+        inner_widget->set_position(draw_pos);
+        inner_widget->draw(window, mgl::vec2f(0.0f, 0.0f));
+    }
+
+    mgl::vec2f Subsection::get_size() {
+        if(!visible)
+            return {0.0f, 0.0f};
+
+        const mgl::vec2f margin_size = mgl::vec2f(margin_left_scale + margin_right_scale, margin_top_scale + margin_bottom_scale) * mgl::vec2f(get_theme().window_height, get_theme().window_height);
+        mgl::vec2f widgets_size = mgl::vec2f(0.0f, label.get_size().y + title_spacing_scale * get_theme().window_height) + inner_widget->get_size() + margin_size;
+
+        if(std::abs(size.x) > 0.001f)
+            widgets_size.x = size.x;
+        if(std::abs(size.y) > 0.001f)
+            widgets_size.y = size.y;
+
+        return widgets_size;
+    }
+}
\ No newline at end of file
diff --git a/src/main.cpp b/src/main.cpp
index 042a9af..fca2f87 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -1,31 +1,18 @@
-
-#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/Process.hpp"
-#include "../include/Theme.hpp"
 #include "../include/GsrInfo.hpp"
+#include "../include/Theme.hpp"
 #include "../include/window_texture.h"
-#include "../include/Config.hpp"
+#include "../include/Overlay.hpp"
+#include "../include/GlobalHotkeysX11.hpp"
+#include "../include/gui/Utils.hpp"
 
-#include <string.h>
+#include <unistd.h>
 #include <signal.h>
-#include <sys/wait.h>
-#include <assert.h>
 
 #include <X11/Xlib.h>
-#include <X11/cursorfont.h>
 #include <X11/Xatom.h>
-#include <X11/Xutil.h>
-
+#define XK_LATIN1
+#include <X11/keysymdef.h>
 #include <mglpp/mglpp.hpp>
-#include <mglpp/graphics/Text.hpp>
-#include <mglpp/graphics/Texture.hpp>
-#include <mglpp/graphics/Sprite.hpp>
-#include <mglpp/graphics/Rectangle.hpp>
 #include <mglpp/window/Window.hpp>
 #include <mglpp/window/Event.hpp>
 #include <mglpp/system/Clock.hpp>
@@ -39,8 +26,6 @@
 // to make it more efficient by doing record/replay/stream with the same encoded packets.
 // TODO: Make sure the overlay always stays on top. Test with starting the overlay and then opening youtube in fullscreen.
 
-#include <vector>
-
 extern "C" {
 #include <mgl/mgl.h>
 }
@@ -57,169 +42,12 @@ static void startup_error(const char *msg) {
     exit(1);
 }
 
-#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);
-}
-
-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;
-}
-
-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 sig_atomic_t running = 1;
-static void sigint_handler(int dummy) {
-    (void)dummy;
+static void sigint_handler(int signal) {
+    (void)signal;
     running = 0;
 }
 
-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);
-}
-
-// 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];
-}
-
 int main(int argc, char **argv) {
     (void)argv;
     if(argc != 1)
@@ -235,8 +63,6 @@ int main(int argc, char **argv) {
         exit(1);
     }
 
-    const std::vector<gsr::AudioDevice> audio_devices = gsr::get_audio_devices();
-
     std::string resources_path;
     if(access("images/gpu_screen_recorder_logo.png", F_OK) == 0) {
         resources_path = "./";
@@ -263,8 +89,6 @@ int main(int argc, char **argv) {
         exit(1);
     }
 
-    const bool compositor_running = is_compositor_running(display, DefaultScreen(display));
-
     mgl::vec2i window_size = { 1280, 720 };
     mgl::vec2i window_pos = { 0, 0 };
 
@@ -284,440 +108,48 @@ int main(int argc, char **argv) {
     if(!window.create("gsr overlay", window_create_params))
         startup_error("failed to create window");
 
-    mgl_window *win = window.internal_window();
-    if(win->num_monitors == 0)
-        startup_error("no monitors found");
-
-    const mgl_monitor *focused_monitor = find_monitor_by_cursor_position(window);
-    window_pos.x = focused_monitor->pos.x;
-    window_pos.y = focused_monitor->pos.y;
-    window_size.x = focused_monitor->size.x;
-    window_size.y = focused_monitor->size.y;
-
-    window.set_size_limits(window_size, window_size);
-    window.set_size(window_size);
-    window.set_position(window_pos);
-
-    if(!gsr::init_theme(gsr_info, window_size, resources_path)) {
-        fprintf(stderr, "Error: failed to load theme\n");
-        exit(1);
-    }
-
     unsigned char data = 2; // Prefer being composed to allow transparency
     XChangeProperty(display, window.get_system_handle(), XInternAtom(display, "_NET_WM_BYPASS_COMPOSITOR", False), XA_CARDINAL, 32, PropModeReplace, &data, 1);
 
     data = 1;
     XChangeProperty(display, window.get_system_handle(), XInternAtom(display, "GAMESCOPE_EXTERNAL_OVERLAY", False), XA_CARDINAL, 32, PropModeReplace, &data, 1);
 
-    mgl::Texture replay_button_texture;
-    if(!replay_button_texture.load_from_file((resources_path + "images/replay.png").c_str()))
-        startup_error("failed to load texture: images/replay.png");
-
-    mgl::Texture record_button_texture;
-    if(!record_button_texture.load_from_file((resources_path + "images/record.png").c_str()))
-        startup_error("failed to load texture: images/record.png");
-
-    mgl::Texture stream_button_texture;
-    if(!stream_button_texture.load_from_file((resources_path + "images/stream.png").c_str()))
-        startup_error("failed to load texture: images/stream.png");
-
-    WindowTexture window_texture;
-    bool window_texture_loaded = false;
-
-    mgl::Texture window_texture_texture;
-    mgl::Sprite window_texture_sprite;
-
-    mgl::Texture screenshot_texture;
-    if(!compositor_running) {
-        const Window window_at_cursor_position = get_window_at_cursor_position(display);
-        if(is_window_fullscreen_on_monitor(display, window_at_cursor_position, focused_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), window_pos.x, window_pos.y, window_size.x, window_size.y, AllPlanes, ZPixmap);
-            if(!img)
-                fprintf(stderr, "Error: failed to take a screenshot\n");
-
-            if(img) {
-                screenshot_texture = texture_from_ximage(img);
-                XDestroyImage(img);
-                img = NULL;
-            }
-        }
-    }
-
-    mgl::Sprite screenshot_sprite;
-    if(screenshot_texture.is_valid())
-        screenshot_sprite.set_texture(&screenshot_texture);
-
-    mgl::Rectangle bg_screenshot_overlay(window_size.to_vec2f());
-    bg_screenshot_overlay.set_color(bg_color);
-
-    auto front_page = std::make_unique<gsr::StaticPage>(window_size.to_vec2f());
-    gsr::StaticPage *front_page_ptr = front_page.get();
-
-    gsr::PageStack page_stack;
-    page_stack.push(std::move(front_page));
-
-    std::optional<gsr::Config> config = gsr::read_config();
-
-    struct MainButton {
-        gsr::DropdownButton* button;
-        gsr::GsrMode mode;
-    };
-
-    const int num_frontpage_buttons = 3;
-
-    const char *titles[num_frontpage_buttons] = {
-        "Instant Replay",
-        "Record",
-        "Livestream"
-    };
-
-    const char *descriptions_off[num_frontpage_buttons] = {
-        "Off",
-        "Not recording",
-        "Not streaming"
-    };
-
-    const char *descriptions_on[num_frontpage_buttons] = {
-        "On",
-        "Recording",
-        "Streaming"
-    };
-
-    mgl::Texture *textures[num_frontpage_buttons] = {
-        &replay_button_texture,
-        &record_button_texture,
-        &stream_button_texture
-    };
-
-    const int button_height = window_size.y / 5.0f;
-    const int button_width = button_height;
-
-    std::vector<MainButton> main_buttons;
-
-    for(int i = 0; i < num_frontpage_buttons; ++i) {
-        auto button = std::make_unique<gsr::DropdownButton>(&gsr::get_theme().title_font, &gsr::get_theme().body_font, titles[i], descriptions_on[i], descriptions_off[i], textures[i], mgl::vec2f(button_width, button_height));
-        button->add_item("Start", "start");
-        button->add_item("Settings", "settings");
-        gsr::DropdownButton *button_ptr = button.get();
-        front_page_ptr->add_widget(std::move(button));
-
-        MainButton main_button = {
-            button_ptr,
-            gsr::GsrMode::Unknown
-        };
-
-        main_buttons.push_back(std::move(main_button));
+    if(!gsr::init_theme(gsr_info, resources_path)) {
+        fprintf(stderr, "Error: failed to load theme\n");
+        exit(1);
     }
 
-    gsr::GsrMode gsr_mode = gsr::GsrMode::Unknown;
-
-    auto update_overlay_shape = [&]() {
-        fprintf(stderr, "update overlay shape!\n");
-        const int spacing = 0;// * get_config().scale;
-        const int combined_spacing = spacing * std::max(0, (int)main_buttons.size() - 1);
-
-        const int per_button_width = main_buttons[0].button->get_size().x;// * get_config().scale;
-        const mgl::vec2i overlay_desired_size(per_button_width * (int)main_buttons.size() + combined_spacing, main_buttons[0].button->get_size().y);
-
-        const mgl::vec2i main_buttons_start_pos = mgl::vec2i(window_size.x*0.5f, window_size.y*0.25f) - overlay_desired_size/2;
-        mgl::vec2i main_button_pos = main_buttons_start_pos;
-
-        // if(!gsr_mode.has_value()) {
-        //     gsr_mode = gsr::GsrMode::Unknown;
-        //     pid_t gpu_screen_recorder_process = -1;
-        //     gsr::is_gpu_screen_recorder_running(gpu_screen_recorder_process, gsr_mode.value());
-        // }
-
-        for(size_t i = 0; i < main_buttons.size(); ++i) {
-            if(main_buttons[i].mode != gsr::GsrMode::Unknown && main_buttons[i].mode == gsr_mode) {
-                main_buttons[i].button->set_activated(true);
-            } else {
-                main_buttons[i].button->set_activated(false);
-            }
-
-            main_buttons[i].button->set_position(main_button_pos.to_vec2f());
-            main_button_pos.x += per_button_width + combined_spacing;
-        }
-    };
-
-    // Replay
-    main_buttons[0].button->on_click = [&](const std::string &id) {
-        if(id == "settings") {
-            auto replay_settings_page = std::make_unique<gsr::SettingsPage>(gsr::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
-        };
-        gsr::exec_program_daemonized(args);
-        */
-    };
-    main_buttons[0].mode = gsr::GsrMode::Replay;
-
-    // TODO: Monitor /tmp/gpu-screen-recorder and update ui to match state
-
-    pid_t gpu_screen_recorder_process = -1;
-    // Record
-    main_buttons[1].button->on_click = [&](const std::string &id) {
-        if(id == "settings") {
-            auto record_settings_page = std::make_unique<gsr::SettingsPage>(gsr::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(gsr::get_theme().tint_color);
-
-        if(gpu_screen_recorder_process != -1) {
-            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;
-            gsr_mode = gsr::GsrMode::Unknown;
-            update_overlay_shape();
-            main_buttons[1].button->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
-            };
-            gsr::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 = gsr::exec_program(args);
-        if(gpu_screen_recorder_process == -1) {
-            // TODO: Show notification failed to start
-        } else {
-            gsr_mode = gsr::GsrMode::Record;
-            update_overlay_shape();
-            main_buttons[1].button->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
-        };
-        gsr::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[1].mode = gsr::GsrMode::Record;
-
-    // Stream
-    main_buttons[2].button->on_click = [&](const std::string &id) {
-        if(id == "settings") {
-            auto stream_settings_page = std::make_unique<gsr::SettingsPage>(gsr::SettingsPage::Type::STREAM, gsr_info, audio_devices, config, &page_stack);
-            page_stack.push(std::move(stream_settings_page));
-            return;
-        }
-    };
-    main_buttons[2].mode = gsr::GsrMode::Stream;
-
-    update_overlay_shape();
-
-    window.set_visible(true);
-    make_window_sticky(display, window.get_system_handle());
-
-    Cursor 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);
-    XGrabKeyboard(display, window.get_system_handle(), True, GrabModeAsync, GrabModeAsync, CurrentTime);
+    gsr::Overlay overlay(window, resources_path, gsr_info, egl_funcs, bg_color);
+    overlay.show();
 
-    XSetInputFocus(display, window.get_system_handle(), RevertToParent, CurrentTime);
-    XFlush(display);
-
-    window.set_fullscreen(true);
-
-    //XGrabServer(display);
-
-    mgl::Rectangle top_bar_background(mgl::vec2f(window_size.x, window_size.y*0.06f).floor());
-    top_bar_background.set_color(mgl::Color(0, 0, 0, 180));
-
-    mgl::Text top_bar_text("GPU Screen Recorder", gsr::get_theme().top_bar_font);
-    //top_bar_text.set_color(gsr::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());
-
-    mgl::Texture close_texture;
-    if(!close_texture.load_from_file((resources_path + "images/cross.png").c_str()))
-        startup_error("failed to load texture: images/cross.png");
-
-    gsr::CustomRendererWidget close_button_widget(mgl::vec2f(top_bar_background.get_size().y * 0.3f, top_bar_background.get_size().y * 0.3f).floor());
-    close_button_widget.set_position(mgl::vec2f(window_size.x - 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());
-    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 * gsr::get_theme().window_height);
-            gsr::draw_rectangle_outline(window, pos, size, gsr::get_theme().tint_color, border_size);
-        }
-
-        mgl::Sprite close_sprite(&close_texture);
-        close_sprite.set_position(pos);
-        close_sprite.set_size(size);
-        window.draw(close_sprite);
-    };
-    bool close_button_pressed_inside = false;
-    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))) {
-                running = false;
-                return false;
-            }
-        }
-        return true;
-    };
+    // gsr::GlobalHotkeysX11 global_hotkeys;
+    // global_hotkeys.bind_key_press({ XK_z, Mod1Mask }, "open/hide", [&](const std::string &id) {
+    //     fprintf(stderr, "pressed %s\n", id.c_str());
+    //     overlay.toggle_show();
+    // });
 
-    mgl::Texture logo_texture;
-    if(!logo_texture.load_from_file((resources_path + "images/gpu_screen_recorder_logo.png").c_str()))
-        startup_error("failed to load texture: images/gpu_screen_recorder_logo.png");
-
-    mgl::Sprite logo_sprite(&logo_texture);
-    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());
+    //fprintf(stderr, "info: gsr overlay is now ready, waiting for inputs. Press alt+z to show/hide the overlay\n");
 
     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;
-    page_stack.top()->on_event(event, window, mgl::vec2f(0.0f, 0.0f));
-
-    const auto render = [&] {
-        window.clear(bg_color);
-        if(window_texture_loaded && 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.top()->draw(window, mgl::vec2f(0.0f, 0.0f));
-        window.display();
-    };
-
     mgl::Clock frame_delta_clock;
-    while(window.is_open()) {
+    while(window.is_open() && overlay.is_open() && running) {
         const double frame_delta_seconds = frame_delta_clock.get_elapsed_time_seconds();
         frame_delta_clock.restart();
         gsr::set_frame_delta_seconds(frame_delta_seconds);
 
-        if(page_stack.empty() || !running) {
-            running = false;
-            goto quit;
-        }
-
+        //global_hotkeys.poll_events();        
         while(window.poll_event(event)) {
-            page_stack.top()->on_event(event, window, mgl::vec2f(0.0f, 0.0f));
-            close_button_widget.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.empty()) {
-                    page_stack.top()->on_navigate_away_from_page();
-                    page_stack.pop();
-                }
-            }
-
-            if(page_stack.empty())
-                break;
+            overlay.on_event(event, window);
         }
 
-        // if(state_update_timer.get_elapsed_time_seconds() >= state_update_timeout_sec) {
-        //     state_update_timer.restart();
-        //     update_overlay_shape();
-        // }
-
-        if(!page_stack.empty())
-            render();
+        window.clear(bg_color);
+        overlay.draw(window);
+        window.display();
     }
 
-    quit:
     fprintf(stderr, "shutting down!\n");
-    XUngrabKeyboard(display, CurrentTime);
-    XUngrabPointer(display, CurrentTime);
-    if(window_texture_loaded)
-        window_texture_deinit(&window_texture);
     gsr::deinit_theme();
     window.close();
 
-    if(gpu_screen_recorder_process != -1) {
-        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;
-    }
-
     return 0;
 }