Replace sfml with mgl

1 files changed, 199 insertions, 214 deletions

diff --git a/src/Body.cpp b/src/Body.cpp
index eb7a1be..d8e4acd 100644
--- a/src/Body.cpp
+++ b/src/Body.cpp
@@ -6,12 +6,12 @@
 #include "../include/Utils.hpp"
 #include "../include/Theme.hpp"
 #include "../include/StringUtils.hpp"
+#include <mglpp/system/FloatRect.hpp>
 #include "../plugins/Plugin.hpp"
 #include <json/value.h>
-#include <SFML/Graphics/CircleShape.hpp>
-#include <SFML/Window/Event.hpp>
-#include <SFML/Graphics/RenderWindow.hpp>
-#include <SFML/Graphics/Shader.hpp>
+#include <mglpp/window/Event.hpp>
+#include <mglpp/window/Window.hpp>
+#include <mglpp/graphics/Shader.hpp>
 #include <assert.h>
 #include <cmath>
 #include <malloc.h>
@@ -41,7 +41,7 @@ namespace QuickMedia {
     static const int card_padding_x = 20 * get_config().scale;
     static const int card_padding_y = 20 * get_config().scale;
     static const int card_image_text_padding = 10 * get_config().scale;
-    static const sf::Vector2i card_max_image_size(card_width - card_padding_x * 2, (card_height - card_padding_y * 2) / 2);
+    static const mgl::vec2i card_max_image_size(card_width - card_padding_x * 2, (card_height - card_padding_y * 2) / 2);
     static const int num_columns_switch_to_list = 1;
     static const int embedded_item_border_width = 4;
 
@@ -82,7 +82,7 @@ namespace QuickMedia {
         body_spacing[BODY_THEME_MODERN_SPACIOUS].embedded_item_font_size = std::floor(get_config().body.embedded_load_font_size * get_config().scale * get_config().font_scale);
     }
 
-    static void init_body_themes() {
+    void init_body_themes() {
         if(themes_initialized)
             return;
 
@@ -91,38 +91,31 @@ namespace QuickMedia {
         themes_initialized = true;
     }
 
-    static sf::Vector2f to_vec2f(const sf::Vector2i &vec) {
-        return sf::Vector2f(vec.x, vec.y);
-    }
-
-    Body::Body(BodyTheme body_theme, sf::Texture &loading_icon_texture, sf::Shader *rounded_rectangle_shader, sf::Shader *rounded_rectangle_mask_shader) :
+    Body::Body(BodyTheme body_theme, mgl::Texture &loading_icon_texture, mgl::Shader *rounded_rectangle_shader, mgl::Shader *rounded_rectangle_mask_shader) :
         draw_thumbnails(true),
         body_item_render_callback(nullptr),
         thumbnail_mask_shader(nullptr),
         body_theme(body_theme),
         selected_item(0),
         prev_selected_item(0),
-        loading_icon(loading_icon_texture),
-        progress_text("", *FontLoader::get_font(FontLoader::FontType::LATIN), std::floor(get_config().body.progress_font_size * get_config().scale * get_config().font_scale)),
-        replies_text("", *FontLoader::get_font(FontLoader::FontType::LATIN), std::floor(get_config().body.replies_font_size * get_config().scale * get_config().font_scale)),
+        loading_icon(&loading_icon_texture),
+        progress_text("", *FontLoader::get_font(FontLoader::FontType::LATIN, get_config().body.progress_font_size * get_config().scale * get_config().font_scale)),
+        replies_text("", *FontLoader::get_font(FontLoader::FontType::LATIN, get_config().body.replies_font_size * get_config().scale * get_config().font_scale)),
+        embedded_item_load_text("", *FontLoader::get_font(FontLoader::FontType::LATIN, body_spacing[body_theme].embedded_item_font_size)),
         num_visible_items(0),
         top_cut_off(false),
         bottom_cut_off(false),
-        item_background(sf::Vector2f(1.0f, 1.0f), 10.0f * get_config().scale, get_theme().selected_color, rounded_rectangle_shader),
-        reaction_background(sf::Vector2f(1.0f, 1.0f), 10.0f * get_config().scale, get_theme().shade_color, rounded_rectangle_shader),
+        item_background(mgl::vec2f(1.0f, 1.0f), 10.0f * get_config().scale, get_theme().selected_color, rounded_rectangle_shader),
+        reaction_background(mgl::vec2f(1.0f, 1.0f), 10.0f * get_config().scale, get_theme().shade_color, rounded_rectangle_shader),
         rounded_rectangle_shader(rounded_rectangle_shader),
         rounded_rectangle_mask_shader(rounded_rectangle_mask_shader)
     {
-        assert(rounded_rectangle_shader);
-        assert(rounded_rectangle_mask_shader);
-        init_body_themes();
-        embedded_item_load_text = sf::Text("", *FontLoader::get_font(FontLoader::FontType::LATIN), body_spacing[body_theme].embedded_item_font_size);
-        progress_text.setFillColor(get_theme().text_color);
-        replies_text.setFillColor(get_theme().replies_text_color);
+        progress_text.set_color(get_theme().text_color);
+        replies_text.set_color(get_theme().replies_text_color);
         thumbnail_max_size.x = 600;
         thumbnail_max_size.y = 337;
-        sf::Vector2f loading_icon_size(loading_icon.getTexture()->getSize().x, loading_icon.getTexture()->getSize().y);
-        loading_icon.setOrigin(loading_icon_size.x * 0.5f, loading_icon_size.y * 0.5f);
+        mgl::vec2f loading_icon_size(loading_icon.get_texture()->get_size().x, loading_icon.get_texture()->get_size().y);
+        loading_icon.set_origin(mgl::vec2f(loading_icon_size.x * 0.5f, loading_icon_size.y * 0.5f));
         render_selected_item_bg = !is_touch_enabled();
     }
 
@@ -480,23 +473,23 @@ namespace QuickMedia {
         }
     }
 
-    bool Body::on_event(const sf::RenderWindow &window, const sf::Event &event, bool keyboard_navigation) {
-        if(keyboard_navigation && event.type == sf::Event::KeyPressed && !event.key.alt) {
+    bool Body::on_event(const mgl::Window &window, const mgl::Event &event, bool keyboard_navigation) {
+        if(keyboard_navigation && event.type == mgl::Event::KeyPressed && !event.key.alt) {
             const bool rendering_card_view = card_view && card_view_enabled;
 
-            if(event.key.code == sf::Keyboard::Up || (event.key.control && event.key.code == sf::Keyboard::K)) {
+            if(event.key.code == mgl::Keyboard::Up || (event.key.control && event.key.code == mgl::Keyboard::K)) {
                 render_selected_item_bg = true;
                 bool top_reached = select_previous_item(true);
                 if(!top_reached && on_top_reached)
                     on_top_reached();
                 return true;
-            } else if(event.key.code == sf::Keyboard::Down || (event.key.control && event.key.code == sf::Keyboard::J)) {
+            } else if(event.key.code == mgl::Keyboard::Down || (event.key.control && event.key.code == mgl::Keyboard::J)) {
                 render_selected_item_bg = true;
                 bool bottom_reached = select_next_item(true);
                 if(!bottom_reached && on_bottom_reached)
                     on_bottom_reached();
                 return true;
-            } else if(rendering_card_view && selected_column > 0 && ((!event.key.control && event.key.code == sf::Keyboard::Left) || (event.key.control && event.key.code == sf::Keyboard::H))) {
+            } else if(rendering_card_view && selected_column > 0 && ((!event.key.control && event.key.code == mgl::Keyboard::Left) || (event.key.control && event.key.code == mgl::Keyboard::H))) {
                 render_selected_item_bg = true;
                 const int new_selected_item = get_previous_visible_item(selected_item);
                 if(new_selected_item != -1) {
@@ -505,7 +498,7 @@ namespace QuickMedia {
                     on_top_reached();
                 }
                 return true;
-            } else if(rendering_card_view && selected_column + 1 < num_columns && ((!event.key.control && event.key.code == sf::Keyboard::Right) || (event.key.control && event.key.code == sf::Keyboard::L))) {
+            } else if(rendering_card_view && selected_column + 1 < num_columns && ((!event.key.control && event.key.code == mgl::Keyboard::Right) || (event.key.control && event.key.code == mgl::Keyboard::L))) {
                 render_selected_item_bg = true;
                 const int new_selected_item = get_next_visible_item(selected_item);
                 if(new_selected_item != -1) {
@@ -514,25 +507,25 @@ namespace QuickMedia {
                     on_bottom_reached();
                 }
                 return true;
-            } else if(event.key.code == sf::Keyboard::Home) {
+            } else if(event.key.code == mgl::Keyboard::Home) {
                 render_selected_item_bg = true;
                 select_first_item(false);
                 if(on_top_reached)
                     on_top_reached();
                 return true;
-            } else if(event.key.code == sf::Keyboard::End) {
+            } else if(event.key.code == mgl::Keyboard::End) {
                 render_selected_item_bg = true;
                 select_last_item();
                 if(on_bottom_reached)
                     on_bottom_reached();
                 return true;
-            } else if(event.key.code == sf::Keyboard::PageUp) {
+            } else if(event.key.code == mgl::Keyboard::PageUp) {
                 render_selected_item_bg = true;
                 bool top_reached = select_previous_page();
                 if(!top_reached && on_top_reached)
                     on_top_reached();
                 return true;
-            } else if(event.key.code == sf::Keyboard::PageDown) {
+            } else if(event.key.code == mgl::Keyboard::PageDown) {
                 render_selected_item_bg = true;
                 bool bottom_reached = select_next_page();
                 if(!bottom_reached && on_bottom_reached)
@@ -544,11 +537,11 @@ namespace QuickMedia {
         if(!is_touch_enabled())
             return false;
 
-        if(event.type == sf::Event::MouseButtonPressed && event.mouseButton.button == sf::Mouse::Left && !mouse_left_pressed && sf::FloatRect(body_pos, body_size).contains(sf::Vector2f(event.mouseButton.x, event.mouseButton.y))) {
+        if(event.type == mgl::Event::MouseButtonPressed && event.mouse_button.button == mgl::Mouse::Left && !mouse_left_pressed && mgl::FloatRect(body_pos, body_size).contains(mgl::vec2f(event.mouse_button.x, event.mouse_button.y))) {
             mouse_left_pressed = true;
-            mouse_pos_raw.x = event.mouseButton.x;
-            mouse_pos_raw.y = event.mouseButton.y;
-            mouse_pos = sf::Vector2f(mouse_pos_raw.x, mouse_pos_raw.y);
+            mouse_pos_raw.x = event.mouse_button.x;
+            mouse_pos_raw.y = event.mouse_button.y;
+            mouse_pos = mgl::vec2f(mouse_pos_raw.x, mouse_pos_raw.y);
             prev_mouse_pos_raw = mouse_pos_raw;
             mouse_click_pos = mouse_pos;
             mouse_press_pixels_moved_abs = 0.0;
@@ -557,20 +550,20 @@ namespace QuickMedia {
             click_counts = std::abs(mouse_scroll_accel.y) < 5.0f; // Touching the body while it scrolls should stop it, not select the touched item
             body_swipe_x = 0.0;
             body_swipe_move_right = false;
-            grabbed_left_side = (event.mouseButton.x < body_pos.x + body_size.x * 0.15f);
+            grabbed_left_side = (event.mouse_button.x < body_pos.x + body_size.x * 0.15f);
             return true;
-        } else if(event.type == sf::Event::MouseButtonReleased && event.mouseButton.button == sf::Mouse::Left && mouse_left_pressed) {
+        } else if(event.type == mgl::Event::MouseButtonReleased && event.mouse_button.button == mgl::Mouse::Left && mouse_left_pressed) {
             mouse_left_pressed = false;
             mouse_left_clicked = true;
-            mouse_release_pos = sf::Vector2f(event.mouseButton.x, event.mouseButton.y);
-            if(event.mouseButton.x > body_pos.x + body_size.x * 0.5f || mouse_scroll_accel.x > 20.0f)
+            mouse_release_pos = mgl::vec2f(event.mouse_button.x, event.mouse_button.y);
+            if(event.mouse_button.x > body_pos.x + body_size.x * 0.5f || mouse_scroll_accel.x > 20.0f)
                 body_swipe_move_right = true;
             return true;
-        } else if(event.type == sf::Event::MouseMoved && mouse_left_pressed) {
-            sf::Vector2i mouse_pos_diff(event.mouseMove.x - mouse_pos_raw.x, event.mouseMove.y - mouse_pos_raw.y);
+        } else if(event.type == mgl::Event::MouseMoved && mouse_left_pressed) {
+            mgl::vec2i mouse_pos_diff(event.mouse_move.x - mouse_pos_raw.x, event.mouse_move.y - mouse_pos_raw.y);
             mouse_press_pixels_moved_abs += std::sqrt(mouse_pos_diff.x*mouse_pos_diff.x + mouse_pos_diff.y*mouse_pos_diff.y);
-            mouse_pos_raw.x = event.mouseMove.x;
-            mouse_pos_raw.y = event.mouseMove.y;
+            mouse_pos_raw.x = event.mouse_move.x;
+            mouse_pos_raw.y = event.mouse_move.y;
             render_selected_item_bg = false;
             return true;
         }
@@ -578,28 +571,27 @@ namespace QuickMedia {
         return false;
     }
 
-    void Body::draw_drop_shadow(sf::RenderWindow &window) {
+    void Body::draw_drop_shadow(mgl::Window &window) {
         if(!show_drop_shadow)
             return;
 
-        const sf::Color color(0, 0, 0, 50);
+        const mgl::Color color(0, 0, 0, 50);
         const float height = 5.0f;
 
-        sf::Vertex gradient_points[4];
-        gradient_points[0] = sf::Vertex(body_pos + sf::Vector2f(0.0f, 0.0f), color);
-        gradient_points[1] = sf::Vertex(body_pos + sf::Vector2f(body_size.x, 0.0f), color);
-        gradient_points[2] = sf::Vertex(body_pos + sf::Vector2f(body_size.x, height), sf::Color(color.r, color.g, color.b, 0));
-        gradient_points[3] = sf::Vertex(body_pos + sf::Vector2f(0.0f, height), sf::Color(color.r, color.g, color.b, 0));
-        window.draw(gradient_points, 4, sf::Quads);
+        mgl::Vertex gradient_points[4];
+        gradient_points[0] = mgl::Vertex(body_pos + mgl::vec2f(0.0f, 0.0f), color);
+        gradient_points[1] = mgl::Vertex(body_pos + mgl::vec2f(body_size.x, 0.0f), color);
+        gradient_points[2] = mgl::Vertex(body_pos + mgl::vec2f(body_size.x, height), mgl::Color(color.r, color.g, color.b, 0));
+        gradient_points[3] = mgl::Vertex(body_pos + mgl::vec2f(0.0f, height), mgl::Color(color.r, color.g, color.b, 0));
+        window.draw(gradient_points, 4, mgl::PrimitiveType::Quads);
     }
 
-    double Body::draw(sf::RenderWindow &window, sf::Vector2f pos, sf::Vector2f size) {
+    double Body::draw(mgl::Window &window, mgl::vec2f pos, mgl::vec2f size) {
         return draw(window, pos, size, Json::Value::nullSingleton());
     }
 
     // TODO: Use a render target for the whole body so all images can be put into one.
-    // TODO: Load thumbnails with more than one thread.
-    double Body::draw(sf::RenderWindow &window, sf::Vector2f pos, sf::Vector2f size, const Json::Value &content_progress) {
+    double Body::draw(mgl::Window &window, mgl::vec2f pos, mgl::vec2f size, const Json::Value &content_progress) {
         const bool rendering_card_view = card_view && card_view_enabled;
 
         body_size_changed = std::abs(size.x - body_size.x) > 0.1f || std::abs(size.y - body_size.y) > 0.1f;
@@ -619,7 +611,7 @@ namespace QuickMedia {
         if(attach_side == AttachSide::TOP)
             pos.y += body_spacing[body_theme].body_padding_vertical;
 
-        float frame_time = frame_timer.restart().asSeconds();
+        float frame_time = frame_timer.restart();
         if(frame_time > 1.0f)
             frame_time = 1.0f;
 
@@ -633,7 +625,7 @@ namespace QuickMedia {
             prev_selected_item = selected_item;
         }
 
-        elapsed_time_sec = draw_timer.getElapsedTime().asSeconds();
+        elapsed_time_sec = draw_timer.get_elapsed_time_seconds();
 
         const bool prev_items_cut_off = top_cut_off || bottom_cut_off;
         const int prev_first_visible_item = first_visible_item;
@@ -671,14 +663,14 @@ namespace QuickMedia {
         }
 
         if(is_touch_enabled()) {
-            const sf::Vector2f mouse_pos_diff(mouse_pos_raw.x - mouse_pos.x, mouse_pos_raw.y - mouse_pos.y);
+            const mgl::vec2f mouse_pos_diff(mouse_pos_raw.x - mouse_pos.x, mouse_pos_raw.y - mouse_pos.y);
             const float move_speed = 35.0f;
-            sf::Vector2f prev_mouse_pos = mouse_pos;
+            mgl::vec2f prev_mouse_pos = mouse_pos;
             mouse_pos.x += (mouse_pos_diff.x * std::min(1.0f, frame_time * move_speed));
             mouse_pos.y += (mouse_pos_diff.y * std::min(1.0f, frame_time * move_speed));
-            const sf::Vector2f mouse_pos_diff_smooth = mouse_pos - prev_mouse_pos;
+            const mgl::vec2f mouse_pos_diff_smooth = mouse_pos - prev_mouse_pos;
 
-            sf::Vector2f mouse_pos_raw_diff(mouse_pos_raw.x - prev_mouse_pos_raw.x, mouse_pos_raw.y - prev_mouse_pos_raw.y);
+            mgl::vec2f mouse_pos_raw_diff(mouse_pos_raw.x - prev_mouse_pos_raw.x, mouse_pos_raw.y - prev_mouse_pos_raw.y);
             prev_mouse_pos_raw = mouse_pos_raw;
 
             if(prev_items_cut_off) {
@@ -687,7 +679,7 @@ namespace QuickMedia {
                     if(body_swipe_x < 0.0)
                         body_swipe_x = 0.0;
                     page_scroll += mouse_pos_diff_smooth.y;
-                    mouse_scroll_accel = sf::Vector2f(mouse_pos_raw_diff.x, mouse_pos_raw_diff.y) / (frame_time * 120.0f);
+                    mouse_scroll_accel = mgl::vec2f(mouse_pos_raw_diff.x, mouse_pos_raw_diff.y) / (frame_time * 120.0f);
                 } else {
                     page_scroll += mouse_scroll_accel.y;
                 }
@@ -745,13 +737,12 @@ namespace QuickMedia {
                 selected_scrolled = 0.0f;
         }
 
-        const sf::Vector2u window_size = window.getSize();
-        const sf::View prev_view = window.getView();
+        const mgl::vec2i window_size = window.get_size();
+        const mgl::View prev_view = window.get_view();
 
         if(!rendering_card_view) {
-            sf::View new_view(sf::FloatRect(0.0f, 0.0f, window_size.x, size.y));
-            new_view.setViewport(sf::FloatRect(0.0f, scissor_y / (float)window_size.y, 1.0f, size.y / (float)window_size.y));
-            window.setView(new_view);
+            mgl::View new_view = { mgl::vec2i(0, scissor_y), mgl::vec2i(window_size.x, size.y) };
+            window.set_view(new_view);
         }
 
         bool instant_move = body_size_changed;
@@ -762,32 +753,34 @@ namespace QuickMedia {
 
         const float speed = 30.0f;
 
-        const sf::Vector2f item_background_size_diff = sf::Vector2f(item_background_target_size.x, item_background_target_height) - item_background_prev_size;
+        const mgl::vec2f item_background_size_diff = mgl::vec2f(item_background_target_size.x, item_background_target_height) - item_background_prev_size;
         const float item_background_size_speed = instant_move ? 1000.0f : speed;
-        const sf::Vector2f item_background_new_size = item_background_prev_size + (item_background_size_diff * std::min(1.0f, frame_time * item_background_size_speed));
+        const mgl::vec2f item_background_new_size = item_background_prev_size + (item_background_size_diff * std::min(1.0f, frame_time * item_background_size_speed));
         item_background_prev_size = item_background_new_size;
 
-        const sf::Vector2f item_background_pos_diff = item_background_target_pos - item_background_prev_pos;
+        const mgl::vec2f item_background_pos_diff = item_background_target_pos - item_background_prev_pos;
         const float item_background_move_speed = instant_move ? 1000.0f : speed;
-        sf::Vector2f item_background_new_pos = item_background_prev_pos + (item_background_pos_diff * std::min(1.0f, frame_time * item_background_move_speed));
+        mgl::vec2f item_background_new_pos = item_background_prev_pos + (item_background_pos_diff * std::min(1.0f, frame_time * item_background_move_speed));
         if(selected_item_fits_in_body) {
             item_background_new_pos.y = std::min(item_background_new_pos.y, size.y - item_background_new_size.y);
             item_background_new_pos.y = std::max(item_background_new_pos.y, 0.0f);
         }
         item_background_prev_pos = item_background_new_pos;
 
+        bool switched_to_list_view = false;
         double body_total_height = 0.0;
         if(rendering_card_view) {
-            body_total_height = draw_card_view(window, pos, size, window_size, scissor_y);
+            body_total_height = draw_card_view(window, pos, size, window_size, scissor_y, switched_to_list_view);
         } else {
             body_total_height = draw_list_view(window, pos, size, content_progress);
         }
 
-        window.setView(prev_view);
-        draw_drop_shadow(window);
+        window.set_view(prev_view);
+        if(!switched_to_list_view)
+            draw_drop_shadow(window);
 
         const double scrolling_bar_height_ratio = body_total_height == 0.0 ? 0.0 : (size.y / body_total_height);
-        if(scrolling_bar_height_ratio <= 1.0) {
+        if(!switched_to_list_view && scrolling_bar_height_ratio <= 1.0) {
             const double scrollbar_max_height = size.y - body_spacing[body_theme].body_padding_vertical * 2.0f;
             double scrollbar_offset_y = body_total_height == 0.0 ? 0.0 : (std::abs(page_scroll) / body_total_height);
 
@@ -808,7 +801,7 @@ namespace QuickMedia {
                 scrollbar_y = std::floor(scissor_y + body_spacing[body_theme].body_padding_vertical + scrollbar_max_height - scrollbar.get_size().y - scrollbar_offset_y * scrollbar_max_height);
 
             scrollbar.set_position(
-                sf::Vector2f(pos.x + scrollbar_offset_x, scrollbar_y));
+                mgl::vec2f(pos.x + scrollbar_offset_x, scrollbar_y));
             scrollbar.draw(window);
         }
 
@@ -873,41 +866,37 @@ namespace QuickMedia {
     void Body::update_dirty_state(BodyItem *body_item, float width) {
         if((body_item->dirty && !body_item->get_title().empty()) || (body_size_changed && body_item->title_text)) {
             body_item->dirty = false;
-            // TODO: Find a way to optimize fromUtf8
-            sf::String str = sf::String::fromUtf8(body_item->get_title().begin(), body_item->get_title().end());
             if(body_item->title_text) {
-                body_item->title_text->setString(std::move(str));
+                body_item->title_text->setString(body_item->get_title());
                 body_item->title_text->setMaxWidth(width);
             } else {
-                body_item->title_text = std::make_unique<Text>(std::move(str), false, std::floor(get_config().body.title_font_size * get_config().scale * get_config().font_scale), width, title_mark_urls);
+                body_item->title_text = std::make_unique<Text>(body_item->get_title(), false, std::floor(get_config().body.title_font_size * get_config().scale * get_config().font_scale), width, title_mark_urls);
             }
-            body_item->title_text->setFillColor(body_item->get_title_color());
+            body_item->title_text->set_color(body_item->get_title_color());
             body_item->title_text->updateGeometry();
         }
 
         if((body_item->dirty_description && !body_item->get_description().empty()) || (body_size_changed && body_item->description_text)) {
             body_item->dirty_description = false;
-            sf::String str = sf::String::fromUtf8(body_item->get_description().begin(), body_item->get_description().end());
             if(body_item->description_text) {
-                body_item->description_text->setString(std::move(str));
+                body_item->description_text->setString(body_item->get_description());
                 body_item->description_text->setMaxWidth(width);
             } else {
-                body_item->description_text = std::make_unique<Text>(std::move(str), false, std::floor(get_config().body.description_font_size * get_config().scale * get_config().font_scale), width, true);
+                body_item->description_text = std::make_unique<Text>(body_item->get_description(), false, std::floor(get_config().body.description_font_size * get_config().scale * get_config().font_scale), width, true);
             }
-            body_item->description_text->setFillColor(body_item->get_description_color());
+            body_item->description_text->set_color(body_item->get_description_color());
             body_item->description_text->updateGeometry();
         }
 
         if((body_item->dirty_author && !body_item->get_author().empty()) || (body_size_changed && body_item->author_text)) {
             body_item->dirty_author = false;
-            sf::String str = sf::String::fromUtf8(body_item->get_author().begin(), body_item->get_author().end());
             if(body_item->author_text) {
-                body_item->author_text->setString(std::move(str));
+                body_item->author_text->setString(body_item->get_author());
                 body_item->author_text->setMaxWidth(width);
             } else {
-                body_item->author_text = std::make_unique<Text>(std::move(str), true, std::floor(get_config().body.author_font_size * get_config().scale * get_config().font_scale), width);
+                body_item->author_text = std::make_unique<Text>(body_item->get_author(), true, std::floor(get_config().body.author_font_size * get_config().scale * get_config().font_scale), width);
             }
-            body_item->author_text->setFillColor(body_item->get_author_color());
+            body_item->author_text->set_color(body_item->get_author_color());
             body_item->author_text->updateGeometry();
         }
 
@@ -928,12 +917,12 @@ namespace QuickMedia {
                 strftime(time_str, sizeof(time_str) - 1, "%Y %b %d, %a %H:%M", &message_tm);
 
                 if(body_item->timestamp_text) {
-                    body_item->timestamp_text->setString(time_str);
+                    body_item->timestamp_text->set_string(time_str);
                 } else {
-                    body_item->timestamp_text = std::make_unique<sf::Text>(time_str, *FontLoader::get_font(FontLoader::FontType::LATIN), std::floor(get_config().body.timestamp_font_size * get_config().scale * get_config().font_scale));
+                    body_item->timestamp_text = std::make_unique<mgl::Text>(time_str, *FontLoader::get_font(FontLoader::FontType::LATIN, get_config().body.timestamp_font_size * get_config().scale * get_config().font_scale));
                 }
 
-                body_item->timestamp_text->setFillColor(get_theme().timestamp_text_color);
+                body_item->timestamp_text->set_color(get_theme().timestamp_text_color);
             }
         }
     }
@@ -959,13 +948,13 @@ namespace QuickMedia {
         body_item->keep_alive_frames = 0;
     }
 
-    sf::Vector2i Body::get_item_thumbnail_size(BodyItem *item) const {
-        sf::Vector2i content_size;
-        sf::Vector2i thumbnail_max_size_scaled = (card_view && card_view_enabled) ? card_max_image_size : sf::Vector2i(thumbnail_max_size.x * get_config().scale, thumbnail_max_size.y * get_config().scale);
+    mgl::vec2i Body::get_item_thumbnail_size(BodyItem *item) const {
+        mgl::vec2i content_size;
+        mgl::vec2i thumbnail_max_size_scaled = (card_view && card_view_enabled) ? card_max_image_size : mgl::vec2i(thumbnail_max_size.x * get_config().scale, thumbnail_max_size.y * get_config().scale);
         if(item->thumbnail_size.x > 0 && item->thumbnail_size.y > 0)
-            content_size = clamp_to_size(sf::Vector2i(std::floor(item->thumbnail_size.x * get_config().scale), std::floor(item->thumbnail_size.y * get_config().scale)), thumbnail_max_size_scaled);
+            content_size = clamp_to_size(mgl::vec2i(std::floor(item->thumbnail_size.x * get_config().scale), std::floor(item->thumbnail_size.y * get_config().scale)), thumbnail_max_size_scaled);
         else
-            content_size = sf::Vector2i(250 * get_config().scale, 141 * get_config().scale);
+            content_size = mgl::vec2i(250 * get_config().scale, 141 * get_config().scale);
         return content_size;
     }
 
@@ -987,7 +976,7 @@ namespace QuickMedia {
         return -1;
     }
 
-    void Body::draw_item(sf::RenderWindow &window, std::shared_ptr<BodyItem> &item, sf::Vector2f pos, sf::Vector2f size, bool include_embedded_item, bool is_embedded) {
+    void Body::draw_item(mgl::Window &window, std::shared_ptr<BodyItem> &item, mgl::vec2f pos, mgl::vec2f size, bool include_embedded_item, bool is_embedded) {
         // TODO: What about when |card_view| is used?
         item->keep_alive_frames = 3;
         get_item_height(item.get(), size.x, true, false, false, -1);
@@ -1010,9 +999,9 @@ namespace QuickMedia {
         return "";
     }
 
-    void Body::handle_item_render(const sf::Vector2f pos, const float item_width, const float item_height, int item_index) {
+    void Body::handle_item_render(const mgl::vec2f pos, const float item_width, const float item_height, int item_index) {
         if(body_item_select_callback && mouse_left_clicked && !clicked_body_item && click_counts && std::abs(mouse_scroll_accel.y) < 5.0f) {
-            sf::FloatRect item_box(pos + body_pos, sf::Vector2f(item_width, item_height));
+            mgl::FloatRect item_box(pos + body_pos, mgl::vec2f(item_width, item_height));
             if(item_box.contains(mouse_click_pos) && item_box.contains(mouse_release_pos) && mouse_press_pixels_moved_abs <= 25.0) {
                 clicked_body_item = items[item_index];
                 set_selected_item(item_index, false);
@@ -1021,7 +1010,7 @@ namespace QuickMedia {
 
         if(item_index == selected_item) {
             item_background_target_pos = pos;
-            item_background_target_size = sf::Vector2f(item_width, item_height);
+            item_background_target_size = mgl::vec2f(item_width, item_height);
             item_background_target_height = item_height;
             if(target_set == TargetSetState::NOT_SET)
                 target_set = TargetSetState::SET;
@@ -1032,11 +1021,11 @@ namespace QuickMedia {
         return std::min(max, std::max(min, value));
     }
 
-    static sf::Vector2f round(sf::Vector2f vec) {
+    static mgl::vec2f round(mgl::vec2f vec) {
         return { std::floor(vec.x), std::floor(vec.y) };
     }
 
-    double Body::draw_list_view(sf::RenderWindow &window, sf::Vector2f pos, sf::Vector2f size, const Json::Value &content_progress) {
+    double Body::draw_list_view(mgl::Window &window, mgl::vec2f pos, mgl::vec2f size, const Json::Value &content_progress) {
         const int num_items = items.size();
         const float pos_y_before_scroll = pos.y;
         
@@ -1180,7 +1169,7 @@ namespace QuickMedia {
 
                 if(selected_item_fits_in_body) {
                     item_background.set_position(round(
-                        sf::Vector2f(
+                        mgl::vec2f(
                             item_background_prev_pos.x,
                             clamp(item_background_prev_pos.y, pos_y_before_scroll, pos_y_before_scroll + size.y - item_background_prev_size.y - body_spacing[body_theme].body_padding_vertical + offset_y_spacing))));
                 } else {
@@ -1202,7 +1191,8 @@ namespace QuickMedia {
         return std::abs(pos.y - pos_y_start);
     }
 
-    double Body::draw_card_view(sf::RenderWindow &window, sf::Vector2f pos, sf::Vector2f size, sf::Vector2u window_size, float scissor_y) {
+    double Body::draw_card_view(mgl::Window &window, mgl::vec2f pos, mgl::vec2f size, mgl::vec2i window_size, float scissor_y, bool &switched_to_list_view) {
+        switched_to_list_view = false;
         num_columns = size.x / card_width;
 
         int space_left_column = size.x - (num_columns * card_width);
@@ -1223,6 +1213,7 @@ namespace QuickMedia {
             card_view_enabled = false;
             const float body_total_height = draw(window, body_pos, body_size);
             card_view_enabled = true;
+            switched_to_list_view = true;
             return body_total_height;
         }
 
@@ -1238,7 +1229,7 @@ namespace QuickMedia {
         int row_max_height = 0;
         const int num_items = items.size();
         const float pos_y_start = page_scroll;
-        sf::Vector2f pos_offset(space_left_column_each, page_scroll);
+        mgl::vec2f pos_offset(space_left_column_each, page_scroll);
 
         while(item_index < num_items) {
             std::shared_ptr<BodyItem> &item = items[item_index];
@@ -1269,7 +1260,7 @@ namespace QuickMedia {
                 if(body_item_render_callback)
                     body_item_render_callback(item);
 
-                sf::Vector2i thumbnail_size = get_item_thumbnail_size(item.get());
+                mgl::vec2i thumbnail_size = get_item_thumbnail_size(item.get());
                 std::shared_ptr<ThumbnailData> item_thumbnail;
                 if(draw_thumbnails && !item->thumbnail_url.empty())
                     item_thumbnail = AsyncImageLoader::get_instance().get_thumbnail(item->thumbnail_url, item->thumbnail_is_local, thumbnail_size);
@@ -1288,10 +1279,6 @@ namespace QuickMedia {
                 render_item.item_thumbnail = item_thumbnail;
                 render_items.push_back(std::move(render_item));
 
-                sf::View new_view(sf::FloatRect(0.0f, 0.0f, window_size.x, size.y));
-                new_view.setViewport(sf::FloatRect(0.0f, scissor_y / (float)window_size.y, 1.0f, size.y / (float)window_size.y));
-                window.setView(new_view);
-
                 handle_item_render(pos + pos_offset, card_width, item_height, item_index);
 
                 ++num_visible_items;
@@ -1319,7 +1306,7 @@ namespace QuickMedia {
 
                 if(drawn_column_index == num_columns) {
                     if(row_has_selected_item)
-                        item_background_target_size = sf::Vector2f(card_width, row_max_height);
+                        item_background_target_size = mgl::vec2f(card_width, row_max_height);
 
                     drawn_column_index = 0;
                     ++num_visible_rows;
@@ -1333,14 +1320,13 @@ namespace QuickMedia {
             ++item_index;
         }
 
-        sf::View new_view(sf::FloatRect(0.0f, 0.0f, window_size.x, size.y));
-        new_view.setViewport(sf::FloatRect(0.0f, scissor_y / (float)window_size.y, 1.0f, size.y / (float)window_size.y));
-        window.setView(new_view);
+        mgl::View new_view = { mgl::vec2i(0, scissor_y), mgl::vec2i(window_size.x, size.y) };
+        window.set_view(new_view);
 
         for(RenderItem &render_item : render_items) {
             if(render_item.item_index == selected_item) {
                 item_background.set_position(round(
-                    sf::Vector2f(
+                    mgl::vec2f(
                         item_background_prev_pos.x,
                         clamp(item_background_prev_pos.y, pos.y, pos.y + size.y - item_background_prev_size.y - body_spacing[body_theme].body_padding_vertical - body_spacing[body_theme].spacing_y))));
                 item_background.set_size(round(item_background_prev_size));
@@ -1351,29 +1337,29 @@ namespace QuickMedia {
         }
 
         for(RenderItem &render_item : render_items) {
-            draw_card_item(window, render_item.body_item, render_item.pos, render_item.pos_offset, size, sf::Vector2f(window_size.x, window_size.y), render_item.item_height, scissor_y, render_item.item_index, render_item.item_thumbnail.get());
+            draw_card_item(window, render_item.body_item, render_item.pos, render_item.pos_offset, size, mgl::vec2f(window_size.x, window_size.y), render_item.item_height, scissor_y, render_item.item_index, render_item.item_thumbnail.get());
         }
 
         render_items.clear();
 
         if(row_has_selected_item)
-            item_background_target_size = sf::Vector2f(card_width, row_max_height);
+            item_background_target_size = mgl::vec2f(card_width, row_max_height);
 
         return std::abs(pos_offset.y - pos_y_start);
     }
 
-    void Body::draw_item(sf::RenderWindow &window, std::shared_ptr<BodyItem> &item, const sf::Vector2f &pos, const sf::Vector2f &size, const float item_height, const int item_index, const Json::Value &content_progress, bool include_embedded_item, bool merge_with_previous) {
-        sf::Vector2i thumbnail_size = get_item_thumbnail_size(item.get());
+    void Body::draw_item(mgl::Window &window, std::shared_ptr<BodyItem> &item, const mgl::vec2f &pos, const mgl::vec2f &size, const float item_height, const int item_index, const Json::Value &content_progress, bool include_embedded_item, bool merge_with_previous) {
+        mgl::vec2i thumbnail_size = get_item_thumbnail_size(item.get());
         std::shared_ptr<ThumbnailData> item_thumbnail;
         if(draw_thumbnails && !merge_with_previous && !item->thumbnail_url.empty())
             item_thumbnail = AsyncImageLoader::get_instance().get_thumbnail(item->thumbnail_url, item->thumbnail_is_local, thumbnail_size);
 
-        thumbnail_size = clamp_to_size_x(thumbnail_size, sf::Vector2i(size.x - body_spacing[body_theme].image_padding_x * 2.0f, thumbnail_size.y));
+        thumbnail_size = clamp_to_size_x(thumbnail_size, size.x - body_spacing[body_theme].image_padding_x * 2.0f);
 
         if(body_item_render_callback && include_embedded_item)
             body_item_render_callback(item);
 
-        sf::Vector2f item_pos;
+        mgl::vec2f item_pos;
         item_pos.x = std::floor(pos.x);
         item_pos.y = std::floor(pos.y);
 
@@ -1382,51 +1368,52 @@ namespace QuickMedia {
         float text_offset_x = body_spacing[body_theme].padding_x;
         if(item_thumbnail && !merge_with_previous) {
             // TODO: Verify if this is safe. The thumbnail is being modified in another thread
-            if(item_thumbnail->loading_state == LoadingState::APPLIED_TO_TEXTURE && item_thumbnail->texture.getNativeHandle() != 0) {
-                image.setTexture(item_thumbnail->texture, true);
-                auto image_size = image.getTexture()->getSize();
-                sf::Vector2f image_size_f(image_size.x, image_size.y);
-                sf::Vector2f content_size = to_vec2f(thumbnail_size);
+            if(item_thumbnail->loading_state == LoadingState::APPLIED_TO_TEXTURE && item_thumbnail->texture.is_valid()) {
+                image.set_texture(&item_thumbnail->texture);
+                auto image_size = image.get_texture()->get_size();
+                mgl::vec2f image_size_f(image_size.x, image_size.y);
+                mgl::vec2f content_size = thumbnail_size.to_vec2f();
                 auto new_image_size = clamp_to_size(image_size_f, content_size);
                 auto image_scale = get_ratio(image_size_f, new_image_size);
-                image.setScale(image_scale);
-                image.setPosition(item_pos + sf::Vector2f(body_spacing[body_theme].image_padding_x, padding_y));
+                image.set_scale(image_scale);
+                image.set_position(item_pos + mgl::vec2f(body_spacing[body_theme].image_padding_x, padding_y));
                 if(thumbnail_mask_shader && item->thumbnail_mask_type == ThumbnailMaskType::CIRCLE) {
-                    thumbnail_mask_shader->setUniform("resolution", new_image_size);
+                    thumbnail_mask_shader->set_uniform("resolution", new_image_size);
                     window.draw(image, thumbnail_mask_shader);
                 } else if(rounded_rectangle_mask_shader) {
-                    rounded_rectangle_mask_shader->setUniform("radius", 10.0f);
-                    rounded_rectangle_mask_shader->setUniform("resolution", new_image_size);
+                    rounded_rectangle_mask_shader->set_uniform("radius", 10.0f);
+                    rounded_rectangle_mask_shader->set_uniform("resolution", new_image_size);
                     window.draw(image, rounded_rectangle_mask_shader);
                 } else {
                     window.draw(image);
                 }
                 text_offset_x += body_spacing[body_theme].image_padding_x + new_image_size.x;
                 // We want the next image fallback to have the same size as the successful image rendering, because its likely the image fallback will have the same size (for example thumbnails on youtube)
-                //image_fallback.setSize(sf::Vector2f(width_ratio * image_size.x, height_ratio * image_size.y));
+                //image_fallback.set_size(mgl::vec2f(width_ratio * image_size.x, height_ratio * image_size.y));
             } else if(!item->thumbnail_url.empty()) {
-                sf::Vector2f content_size = to_vec2f(thumbnail_size);
+                mgl::vec2f content_size = thumbnail_size.to_vec2f();
 
                 if(thumbnail_mask_shader && item->thumbnail_mask_type == ThumbnailMaskType::CIRCLE) {
                     // TODO: Use the mask shader instead, but a vertex shader is also needed for that to pass the vertex coordinates since
                     // shapes dont have texture coordinates.
                     // TODO: Cache circle shape
-                    sf::CircleShape circle_shape(content_size.x * 0.5f);
-                    circle_shape.setFillColor(get_theme().image_loading_background_color);
-                    circle_shape.setPosition(item_pos + sf::Vector2f(body_spacing[body_theme].image_padding_x, padding_y));
-                    window.draw(circle_shape);
+                    // TODO: Fix
+                    //sf::CircleShape circle_shape(content_size.x * 0.5f);
+                    //circle_shape.set_color(get_theme().image_loading_background_color);
+                    //circle_shape.set_position(item_pos + mgl::vec2f(body_spacing[body_theme].image_padding_x, padding_y));
+                    //window.draw(circle_shape);
                 } else {
-                    image_fallback.setSize(content_size);
-                    image_fallback.setFillColor(get_theme().image_loading_background_color);
-                    image_fallback.setPosition(item_pos + sf::Vector2f(body_spacing[body_theme].image_padding_x, padding_y));
+                    image_fallback.set_size(content_size);
+                    image_fallback.set_color(get_theme().image_loading_background_color);
+                    image_fallback.set_position(item_pos + mgl::vec2f(body_spacing[body_theme].image_padding_x, padding_y));
                     window.draw(image_fallback);
                 }
 
-                sf::Vector2f loading_icon_size(loading_icon.getTexture()->getSize().x, loading_icon.getTexture()->getSize().y);
+                mgl::vec2f loading_icon_size(loading_icon.get_texture()->get_size().x, loading_icon.get_texture()->get_size().y);
                 auto new_loading_icon_size = clamp_to_size(loading_icon_size, content_size);
-                loading_icon.setPosition(item_pos + sf::Vector2f(body_spacing[body_theme].image_padding_x, padding_y) + (content_size * 0.5f));
-                loading_icon.setScale(get_ratio(loading_icon_size, new_loading_icon_size));
-                loading_icon.setRotation(elapsed_time_sec * 400.0);
+                loading_icon.set_position(item_pos + mgl::vec2f(body_spacing[body_theme].image_padding_x, padding_y) + (content_size * 0.5f));
+                loading_icon.set_scale(get_ratio(loading_icon_size, new_loading_icon_size));
+                loading_icon.set_rotation(elapsed_time_sec * 400.0);
                 window.draw(loading_icon);
                 text_offset_x += body_spacing[body_theme].image_padding_x + item->loaded_image_size.x;
             }
@@ -1436,22 +1423,22 @@ namespace QuickMedia {
 
         const float text_offset_y = std::floor(6.0f * get_config().scale * get_config().font_scale);
 
-        const float timestamp_text_y = std::floor(item_pos.y + padding_y - text_offset_y);
+        const float timestamp_text_y = std::floor(item_pos.y + padding_y - text_offset_y - std::floor(4.0f * get_config().scale * get_config().font_scale));
         if(item->author_text && !merge_with_previous) {
-            item->author_text->setPosition(vec2f_floor(item_pos.x + text_offset_x, item_pos.y + padding_y - text_offset_y));
+            item->author_text->set_position(vec2f_floor(item_pos.x + text_offset_x, item_pos.y + padding_y - text_offset_y));
             item->author_text->draw(window);
 
-            sf::Vector2f replies_text_pos = item->author_text->getPosition() + sf::Vector2f(0.0f, 5.0f);
+            mgl::vec2f replies_text_pos = item->author_text->get_position();
             replies_text_pos.x += item->author_text->getWidth() + 5.0f;
-            replies_text.setPosition(replies_text_pos);
+            replies_text.set_position(replies_text_pos);
 
-            sf::String replies_text_str;
+            std::string replies_text_str;
             for(size_t reply_index : item->replies) {
                 BodyItem *reply_item = items[reply_index].get();
                 replies_text_str += " >>";
                 replies_text_str += reply_item->post_number;
             }
-            replies_text.setString(std::move(replies_text_str));
+            replies_text.set_string(std::move(replies_text_str));
             window.draw(replies_text);
 
             item_pos.y += item->author_text->getHeight() - 2.0f + std::floor(3.0f * get_config().scale);
@@ -1460,32 +1447,32 @@ namespace QuickMedia {
         if(include_embedded_item && item->embedded_item_status != FetchStatus::NONE) {
             const float embedded_item_width = std::floor(size.x - text_offset_x - embedded_item_border_width - body_spacing[body_theme].padding_x);
             float embedded_item_height = item->embedded_item ? get_item_height(item->embedded_item.get(), embedded_item_width, true, false) : ((body_spacing[body_theme].embedded_item_font_size + 5.0f) + body_spacing[body_theme].embedded_item_padding_y * 2.0f);
-            sf::RectangleShape border_left(sf::Vector2f(embedded_item_border_width, std::floor(embedded_item_height)));
-            border_left.setFillColor(get_theme().embedded_item_border_color);
-            border_left.setPosition(vec2f_floor(item_pos.x + text_offset_x, item_pos.y + body_spacing[body_theme].embedded_item_padding_y + 2.0f));
+            mgl::Rectangle border_left(mgl::vec2f(embedded_item_border_width, std::floor(embedded_item_height)));
+            border_left.set_color(get_theme().embedded_item_border_color);
+            border_left.set_position(vec2f_floor(item_pos.x + text_offset_x, item_pos.y + body_spacing[body_theme].embedded_item_padding_y + 2.0f));
             window.draw(border_left);
 
             if(item->embedded_item) {
-                sf::Vector2f embedded_item_pos(std::floor(item_pos.x + text_offset_x + embedded_item_border_width + body_spacing[body_theme].padding_x), std::floor(item_pos.y + body_spacing[body_theme].embedded_item_padding_y + 6.0f));
-                sf::Vector2f embedded_item_size(embedded_item_width, embedded_item_height);
+                mgl::vec2f embedded_item_pos(std::floor(item_pos.x + text_offset_x + embedded_item_border_width + body_spacing[body_theme].padding_x), std::floor(item_pos.y + body_spacing[body_theme].embedded_item_padding_y + 6.0f));
+                mgl::vec2f embedded_item_size(embedded_item_width, embedded_item_height);
                 draw_item(window, item->embedded_item, embedded_item_pos, embedded_item_size, false, true);
             } else {
-                embedded_item_load_text.setString(embedded_item_status_to_string(item->embedded_item_status));
-                embedded_item_load_text.setPosition(vec2f_floor(item_pos.x + text_offset_x + embedded_item_border_width + body_spacing[body_theme].padding_x, item_pos.y + embedded_item_height * 0.5f - (body_spacing[body_theme].embedded_item_font_size + 5.0f) * 0.5f + 6.0f));
+                embedded_item_load_text.set_string(embedded_item_status_to_string(item->embedded_item_status));
+                embedded_item_load_text.set_position(vec2f_floor(item_pos.x + text_offset_x + embedded_item_border_width + body_spacing[body_theme].padding_x, item_pos.y + embedded_item_height * 0.5f - (body_spacing[body_theme].embedded_item_font_size + 5.0f) * 0.5f + 6.0f));
                 window.draw(embedded_item_load_text);
             }
             item_pos.y += embedded_item_height + 4.0f;
         }
 
         if(item->title_text) {
-            item->title_text->setPosition(vec2f_floor(item_pos.x + text_offset_x, item_pos.y + padding_y - text_offset_y));
+            item->title_text->set_position(vec2f_floor(item_pos.x + text_offset_x, item_pos.y + padding_y - text_offset_y));
             item->title_text->draw(window);
             item_pos.y += item->title_text->getHeight() - 2.0f + std::floor(3.0f * get_config().scale);
         }
 
         if(item->description_text) {
             float height_offset = 0.0f;
-            item->description_text->setPosition(vec2f_floor(item_pos.x + text_offset_x, item_pos.y + padding_y - text_offset_y + height_offset));
+            item->description_text->set_position(vec2f_floor(item_pos.x + text_offset_x, item_pos.y + padding_y - text_offset_y + height_offset));
             item->description_text->draw(window);
             item_pos.y += item->description_text->getHeight() - 2.0f;
         }
@@ -1499,9 +1486,9 @@ namespace QuickMedia {
                 auto &reaction = item->reactions[i];
                 reaction.text->updateGeometry();
                 reaction_max_height = std::max(reaction_max_height, reaction.text->getHeight());
-                reaction.text->setPosition(vec2f_floor(item_pos.x + text_offset_x + reaction_offset_x + body_spacing[body_theme].reaction_background_padding_x, item_pos.y + padding_y - 4.0f + body_spacing[body_theme].reaction_background_padding_y));
+                reaction.text->set_position(vec2f_floor(item_pos.x + text_offset_x + reaction_offset_x + body_spacing[body_theme].reaction_background_padding_x, item_pos.y + padding_y - 4.0f + body_spacing[body_theme].reaction_background_padding_y));
                 reaction_background.set_position(vec2f_floor(item_pos.x + text_offset_x + reaction_offset_x, item_pos.y + padding_y));
-                reaction_background.set_size(sf::Vector2f(reaction.text->getWidth() + body_spacing[body_theme].reaction_background_padding_x * 2.0f, reaction.text->getHeight() + body_spacing[body_theme].reaction_background_padding_y * 2.0f));
+                reaction_background.set_size(mgl::vec2f(reaction.text->getWidth() + body_spacing[body_theme].reaction_background_padding_x * 2.0f, reaction.text->getHeight() + body_spacing[body_theme].reaction_background_padding_y * 2.0f));
                 reaction_background.draw(window);
                 reaction_offset_x += reaction.text->getWidth() + body_spacing[body_theme].reaction_background_padding_x * 2.0f + body_spacing[body_theme].reaction_spacing_x;
                 reaction.text->draw(window);
@@ -1515,7 +1502,7 @@ namespace QuickMedia {
         }
 
         if(item_index == selected_item && item->timestamp_text) {
-            item->timestamp_text->setPosition(vec2f_floor(item_pos.x + size.x - item->timestamp_text->getLocalBounds().width - body_spacing[body_theme].padding_x, timestamp_text_y + 8.0f));
+            item->timestamp_text->set_position(vec2f_floor(item_pos.x + size.x - item->timestamp_text->get_bounds().size.x - body_spacing[body_theme].padding_x, timestamp_text_y + 8.0f));
             window.draw(*item->timestamp_text);
         }
 
@@ -1529,126 +1516,124 @@ namespace QuickMedia {
             const Json::Value &current_json = item_progress["current"];
             const Json::Value &total_json = item_progress["total"];
             if(current_json.isNumeric() && total_json.isNumeric()) {
-                progress_text.setString(std::string("Page: ") + std::to_string(current_json.asInt()) + "/" + std::to_string(total_json.asInt()));
-                auto bounds = progress_text.getLocalBounds();
-                progress_text.setPosition(vec2f_floor(item_pos.x + size.x - bounds.width - body_spacing[body_theme].padding_x, timestamp_text_y + text_offset_y));
+                progress_text.set_string(std::string("Page: ") + std::to_string(current_json.asInt()) + "/" + std::to_string(total_json.asInt()));
+                auto bounds = progress_text.get_bounds();
+                progress_text.set_position(vec2f_floor(item_pos.x + size.x - bounds.size.x - body_spacing[body_theme].padding_x, timestamp_text_y + text_offset_y));
                 window.draw(progress_text);
             }
         }
     }
 
-    void Body::draw_card_item(sf::RenderWindow &window, std::shared_ptr<BodyItem> &item, const sf::Vector2f &pos, const sf::Vector2f &pos_offset, const sf::Vector2f &body_size, const sf::Vector2f &window_size, float item_height, float scissor_y, int item_index, ThumbnailData *item_thumbnail) {
-        const sf::Vector2i thumbnail_size = get_item_thumbnail_size(item.get());
+    void Body::draw_card_item(mgl::Window &window, std::shared_ptr<BodyItem> &item, const mgl::vec2f &pos, const mgl::vec2f &pos_offset, const mgl::vec2f &body_size, const mgl::vec2f &window_size, float item_height, float scissor_y, int item_index, ThumbnailData *item_thumbnail) {
+        const mgl::vec2i thumbnail_size = get_item_thumbnail_size(item.get());
 
-        sf::View new_view(sf::FloatRect(0.0f, 0.0f, window_size.x, body_size.y));
-        new_view.setViewport(sf::FloatRect(0.0f, scissor_y / (float)window_size.y, 1.0f, body_size.y / (float)window_size.y));
-        window.setView(new_view);
+        mgl::View new_view = { mgl::vec2i(0, scissor_y), mgl::vec2i(window_size.x, body_size.y) };
+        window.set_view(new_view);
 
         {
             float image_height = 0.0f;
-            if(item_thumbnail && item_thumbnail->loading_state == LoadingState::APPLIED_TO_TEXTURE && item_thumbnail->texture.getNativeHandle() != 0) {
-                image.setTexture(item_thumbnail->texture, true);
-                auto image_size = image.getTexture()->getSize();
-                sf::Vector2f image_size_f(image_size.x, image_size.y);
-                sf::Vector2f content_size = to_vec2f(thumbnail_size);
+            if(item_thumbnail && item_thumbnail->loading_state == LoadingState::APPLIED_TO_TEXTURE && item_thumbnail->texture.is_valid()) {
+                image.set_texture(&item_thumbnail->texture);
+                auto image_size = image.get_texture()->get_size();
+                mgl::vec2f image_size_f(image_size.x, image_size.y);
+                mgl::vec2f content_size = thumbnail_size.to_vec2f();
                 auto new_image_size = clamp_to_size(image_size_f, content_size);
                 auto image_scale = get_ratio(image_size_f, new_image_size);
-                image.setScale(image_scale);
-                image.setPosition(pos + pos_offset + sf::Vector2f(card_padding_x, card_padding_y) + sf::Vector2f(card_max_image_size.x * 0.5f, 0.0f) - sf::Vector2f(new_image_size.x * 0.5f, 0.0f));
+                image.set_scale(image_scale);
+                image.set_position(pos + pos_offset + mgl::vec2f(card_padding_x, card_padding_y) + mgl::vec2f(card_max_image_size.x * 0.5f, 0.0f) - mgl::vec2f(new_image_size.x * 0.5f, 0.0f));
                 image_height = new_image_size.y;
                 if(thumbnail_mask_shader && item->thumbnail_mask_type == ThumbnailMaskType::CIRCLE) {
-                    thumbnail_mask_shader->setUniform("resolution", new_image_size);
+                    thumbnail_mask_shader->set_uniform("resolution", new_image_size);
                     window.draw(image, thumbnail_mask_shader);
                 } else if(rounded_rectangle_mask_shader) {
-                    rounded_rectangle_mask_shader->setUniform("radius", 10.0f);
-                    rounded_rectangle_mask_shader->setUniform("resolution", new_image_size);
+                    rounded_rectangle_mask_shader->set_uniform("radius", 10.0f);
+                    rounded_rectangle_mask_shader->set_uniform("resolution", new_image_size);
                     window.draw(image, rounded_rectangle_mask_shader);
                 } else {
                     window.draw(image);
                 }
             } else if(!item->thumbnail_url.empty()) {
-                sf::Vector2f content_size = to_vec2f(thumbnail_size);
-                sf::Vector2f loading_icon_size(loading_icon.getTexture()->getSize().x, loading_icon.getTexture()->getSize().y);
+                mgl::vec2f content_size = thumbnail_size.to_vec2f();
+                mgl::vec2f loading_icon_size(loading_icon.get_texture()->get_size().x, loading_icon.get_texture()->get_size().y);
                 auto new_loading_icon_size = clamp_to_size(loading_icon_size, content_size);
-                loading_icon.setPosition(pos + pos_offset + sf::Vector2f(card_padding_x, card_padding_y) + sf::Vector2f(card_max_image_size.x, content_size.y) * 0.5f);
-                loading_icon.setScale(get_ratio(loading_icon_size, new_loading_icon_size));
-                loading_icon.setRotation(elapsed_time_sec * 400.0);
+                loading_icon.set_position(pos + pos_offset + mgl::vec2f(card_padding_x, card_padding_y) + mgl::vec2f(card_max_image_size.x, content_size.y) * 0.5f);
+                loading_icon.set_scale(get_ratio(loading_icon_size, new_loading_icon_size));
+                loading_icon.set_rotation(elapsed_time_sec * 400.0);
                 window.draw(loading_icon);
                 image_height = content_size.y;
             }
 
             const float text_padding = item_thumbnail ? card_image_text_padding : 0.0f;
 
-            sf::Vector2f text_pos = sf::Vector2f(pos.x, scissor_y + body_spacing[body_theme].body_padding_vertical) + pos_offset + sf::Vector2f(card_padding_x, card_padding_y) + sf::Vector2f(0.0f, image_height + text_padding);
+            mgl::vec2f text_pos = mgl::vec2f(pos.x, scissor_y + body_spacing[body_theme].body_padding_vertical) + pos_offset + mgl::vec2f(card_padding_x, card_padding_y) + mgl::vec2f(0.0f, image_height + text_padding);
             const float text_height = (item_height - card_padding_y * 2.0f) - image_height - text_padding;
 
             const float underflow_text = text_pos.y - scissor_y;
             const float underflow_height = underflow_text < 0.0f ? std::max(0.0f, text_height + underflow_text) : text_height;
-            sf::View new_view(sf::FloatRect(0.0f, 0.0f, window_size.x, underflow_height));
-            new_view.setViewport(sf::FloatRect(0.0f, std::max(text_pos.y, scissor_y) / (float)window_size.y, 1.0f, underflow_height / (float)window_size.y));
-            window.setView(new_view);
+
+            mgl::View new_view = { mgl::vec2i(0, std::max(text_pos.y, scissor_y)), mgl::vec2i(window_size.x, underflow_height) };
+            window.set_view(new_view);
 
             text_pos.y = std::min(0.0f, underflow_text);
             float text_offset_y = 0.0f;
             if(item->author_text) {
-                item->author_text->setPosition(text_pos);
+                item->author_text->set_position(text_pos);
                 item->author_text->draw(window);
                 text_offset_y += item->author_text->getHeight();
             }
 
             if(item->title_text) {
-                item->title_text->setPosition(text_pos + sf::Vector2f(0.0f, text_offset_y));
+                item->title_text->set_position(text_pos + mgl::vec2f(0.0f, text_offset_y));
                 item->title_text->draw(window);
                 text_offset_y += item->title_text->getHeight();
             }
 
             if(item->description_text) {
-                item->description_text->setPosition(text_pos + sf::Vector2f(0.0f, text_offset_y));
+                item->description_text->set_position(text_pos + mgl::vec2f(0.0f, text_offset_y));
                 item->description_text->draw(window);
                 text_offset_y += item->description_text->getHeight();
             }
 
             const float gradient_height = 5.0f;
             if(text_offset_y >= text_height - gradient_height && std::abs(item_height - card_height) < 1) {
-                const sf::Vector2f card_bottom(text_pos.x, text_height);
-                const sf::Color color = item_index == selected_item ? get_theme().selected_color : get_theme().background_color;
-
-                sf::Vertex gradient_points[4];
-                gradient_points[0] = sf::Vertex(card_bottom + sf::Vector2f(0.0f, -gradient_height), sf::Color(color.r, color.g, color.b, 0));
-                gradient_points[1] = sf::Vertex(card_bottom + sf::Vector2f(card_max_image_size.x, -gradient_height), sf::Color(color.r, color.g, color.b, 0));
-                gradient_points[2] = sf::Vertex(card_bottom + sf::Vector2f(card_max_image_size.x, 0.0f), color);
-                gradient_points[3] = sf::Vertex(card_bottom + sf::Vector2f(0.0f, 0.0f), color);
-                window.draw(gradient_points, 4, sf::Quads);
+                const mgl::vec2f card_bottom(text_pos.x, text_height);
+                const mgl::Color color = item_index == selected_item ? get_theme().selected_color : get_theme().background_color;
+
+                mgl::Vertex gradient_points[4];
+                gradient_points[0] = mgl::Vertex(card_bottom + mgl::vec2f(0.0f, -gradient_height), mgl::Color(color.r, color.g, color.b, 0));
+                gradient_points[1] = mgl::Vertex(card_bottom + mgl::vec2f(card_max_image_size.x, -gradient_height), mgl::Color(color.r, color.g, color.b, 0));
+                gradient_points[2] = mgl::Vertex(card_bottom + mgl::vec2f(card_max_image_size.x, 0.0f), color);
+                gradient_points[3] = mgl::Vertex(card_bottom + mgl::vec2f(0.0f, 0.0f), color);
+                window.draw(gradient_points, 4, mgl::PrimitiveType::Quads);
             }
         }
     }
 
     float Body::get_item_height(BodyItem *item, float width, bool load_texture, bool include_embedded_item, bool merge_with_previous, int item_index) {
         const bool rendering_card_view = card_view && card_view_enabled;
-        sf::Vector2i content_size = get_item_thumbnail_size(item);
+        mgl::vec2i content_size = get_item_thumbnail_size(item);
 
         const bool show_thumbnail = draw_thumbnails && !item->thumbnail_url.empty() && !merge_with_previous;
         if(load_texture && show_thumbnail) {
             std::shared_ptr<ThumbnailData> item_thumbnail = AsyncImageLoader::get_instance().get_thumbnail(item->thumbnail_url, item->thumbnail_is_local, content_size);
-            content_size = clamp_to_size_x(content_size, sf::Vector2i(width - (rendering_card_view ? 0.0f : body_spacing[body_theme].image_padding_x * 2.0f), content_size.y));
+            content_size = clamp_to_size_x(content_size, width - (rendering_card_view ? 0.0f : body_spacing[body_theme].image_padding_x * 2.0f));
 
-            if(item_thumbnail && item_thumbnail->loading_state == LoadingState::FINISHED_LOADING && item_thumbnail->image->getSize().x > 0 && item_thumbnail->image->getSize().y > 0) {
-                if(!item_thumbnail->texture.loadFromImage(*item_thumbnail->image))
+            if(item_thumbnail && item_thumbnail->loading_state == LoadingState::FINISHED_LOADING && item_thumbnail->image->get_size().x > 0 && item_thumbnail->image->get_size().y > 0) {
+                if(!item_thumbnail->texture.load_from_image(*item_thumbnail->image))
                     fprintf(stderr, "Warning: failed to load texture from image: %s\n", item->thumbnail_url.c_str());
-                item_thumbnail->texture.setSmooth(true);
                 //item_thumbnail->texture.generateMipmap();
                 item_thumbnail->image.reset();
                 item_thumbnail->loading_state = LoadingState::APPLIED_TO_TEXTURE;
             }
 
-            if(item_thumbnail && item_thumbnail->loading_state == LoadingState::APPLIED_TO_TEXTURE && item_thumbnail->texture.getNativeHandle() != 0) {
-                auto image_size = item_thumbnail->texture.getSize();
-                sf::Vector2f image_size_f(image_size.x, image_size.y);
-                auto new_image_size = clamp_to_size(image_size_f, to_vec2f(content_size));
+            if(item_thumbnail && item_thumbnail->loading_state == LoadingState::APPLIED_TO_TEXTURE && item_thumbnail->texture.is_valid()) {
+                auto image_size = item_thumbnail->texture.get_size();
+                mgl::vec2f image_size_f(image_size.x, image_size.y);
+                auto new_image_size = clamp_to_size(image_size_f, content_size.to_vec2f());
                 item->loaded_image_size = new_image_size;
             } else {
                 if(item->loaded_image_size.y < 0.1f)
-                    item->loaded_image_size = to_vec2f(content_size);
+                    item->loaded_image_size = content_size.to_vec2f();
             }
         } else if(item->thumbnail_size.x > 0) {
             if(!show_thumbnail)