Replace sfml with mgl

1 files changed, 105 insertions, 96 deletions

diff --git a/src/SearchBar.cpp b/src/SearchBar.cpp
index 33cea08..e6c51e9 100644
--- a/src/SearchBar.cpp
+++ b/src/SearchBar.cpp
@@ -4,28 +4,30 @@
 #include "../include/ResourceLoader.hpp"
 #include "../include/Config.hpp"
 #include "../include/Utils.hpp"
-#include <SFML/Window/Event.hpp>
-#include <SFML/Window/Clipboard.hpp>
-#include <SFML/Graphics/RenderWindow.hpp>
+#include <mglpp/system/FloatRect.hpp>
+#include <mglpp/system/Utf8.hpp>
+#include <mglpp/graphics/Texture.hpp>
+#include <mglpp/window/Window.hpp>
 #include <cmath>
 #include <assert.h>
 
-// TODO: Use a seperate placeholder sf::Text instead of switching the text to placeholder text....
+// TODO: Use a seperate placeholder mgl::Text instead of switching the text to placeholder text....
 
 namespace QuickMedia {
     static const float background_margin_horizontal = 10.0f + std::floor(5.0f * get_config().scale);
     static const float padding_top_default = std::floor(10.0f * get_config().scale);
     static const float padding_bottom_default = std::floor(15.0f * get_config().scale);
     static const float background_margin_vertical = std::floor(4.0f * get_config().scale);
+    static const int character_size = get_config().search.font_size * get_config().scale * get_config().font_scale;
 
-    SearchBar::SearchBar(sf::Texture *plugin_logo, sf::Shader *rounded_rectangle_shader, const std::string &placeholder, bool input_masked) :
+    SearchBar::SearchBar(mgl::Texture *plugin_logo, mgl::Shader *rounded_rectangle_shader, const std::string &placeholder, bool input_masked) :
         onTextUpdateCallback(nullptr),
         onTextSubmitCallback(nullptr),
         onTextBeginTypingCallback(nullptr),
-        text_autosearch_delay(50),
+        text_autosearch_delay_ms(50),
         caret_visible(true),
-        text(placeholder, *FontLoader::get_font(FontLoader::FontType::LATIN), std::floor(get_config().search.font_size * get_config().scale * get_config().font_scale)),
-        background(sf::Vector2f(1.0f, 1.0f), 10.0f * get_config().scale, get_theme().selected_color, rounded_rectangle_shader),
+        text(placeholder, *FontLoader::get_font(FontLoader::FontType::LATIN, character_size)),
+        background(mgl::vec2f(1.0f, 1.0f), 10.0f * get_config().scale, get_theme().selected_color, rounded_rectangle_shader),
         placeholder_str(placeholder),
         show_placeholder(true),
         updated_search(false),
@@ -40,13 +42,13 @@ namespace QuickMedia {
     {
         padding_top = padding_top_default;
         padding_bottom = padding_bottom_default;
-        text.setFillColor(get_theme().placeholder_text_color);
-        shade.setFillColor(get_theme().shade_color);
-        if(plugin_logo && plugin_logo->getNativeHandle() != 0)
-            plugin_logo_sprite.setTexture(*plugin_logo, true);
+        text.set_color(get_theme().placeholder_text_color);
+        shade.set_color(get_theme().shade_color);
+        if(plugin_logo && plugin_logo->is_valid())
+            plugin_logo_sprite.set_texture(plugin_logo);
     }
 
-    void SearchBar::draw(sf::RenderWindow &window, sf::Vector2f size, bool draw_background) {
+    void SearchBar::draw(mgl::Window &window, mgl::vec2f size, bool draw_background) {
         if(std::abs(size.x - prev_size.x) > 1.0f || std::abs(size.y - prev_size.y) > 1.0f) {
             needs_update = true;
             prev_size = size;
@@ -63,17 +65,17 @@ namespace QuickMedia {
         background.draw(window);
 
         if(input_masked && !show_placeholder) {
-            std::string masked_str(text.getString().getSize(), '*');
-            sf::Text masked_text(std::move(masked_str), *text.getFont(), text.getCharacterSize());
-            masked_text.setPosition(text.getPosition());
+            std::string masked_str(text.get_string().size(), '*');
+            mgl::Text masked_text(std::move(masked_str), *text.get_font());
+            masked_text.set_position(text.get_position());
             window.draw(masked_text);
-            caret.setPosition(masked_text.findCharacterPos(masked_text.getString().getSize()) + sf::Vector2f(0.0f, 2.0f));
+            caret.set_position(masked_text.find_character_pos(masked_text.get_string().size()) + mgl::vec2f(0.0f, character_size * 0.4f));
         } else {
             window.draw(text);
-            if(show_placeholder || text.getString().isEmpty())
-                caret.setPosition(text.getPosition() - sf::Vector2f(2.0f, 0.0f) + sf::Vector2f(0.0f, 2.0f));
+            if(show_placeholder || text.get_string().empty())
+                caret.set_position(text.get_position() - mgl::vec2f(2.0f, 0.0f) + mgl::vec2f(0.0f, character_size * 0.4f));
             else
-                caret.setPosition(text.findCharacterPos(text.getString().getSize()) + sf::Vector2f(0.0f, 2.0f));
+                caret.set_position(text.find_character_pos(text.get_string().size()) + mgl::vec2f(0.0f, character_size * 0.4f));
         }
         
         if(caret_visible && is_editable())
@@ -83,16 +85,16 @@ namespace QuickMedia {
             window.draw(plugin_logo_sprite);
     }
 
-    void SearchBar::on_event(sf::Event &event) {
-        if(is_touch_enabled() && event.type == sf::Event::MouseButtonPressed && event.mouseButton.button == sf::Mouse::Left) {
-            sf::FloatRect box(background.get_position(), background.get_size());
-            if(box.contains(event.mouseButton.x, event.mouseButton.y))
+    void SearchBar::on_event(mgl::Window &window, mgl::Event &event) {
+        if(is_touch_enabled() && event.type == mgl::Event::MouseButtonPressed && event.mouse_button.button == mgl::Mouse::Left) {
+            mgl::FloatRect box(background.get_position(), background.get_size());
+            if(box.contains(mgl::vec2f(event.mouse_button.x, event.mouse_button.y)))
                 mouse_left_inside = true;
             else
                 mouse_left_inside = false;
-        } else if(is_touch_enabled() && event.type == sf::Event::MouseButtonReleased && event.mouseButton.button == sf::Mouse::Left) {
-            sf::FloatRect box(background.get_position(), background.get_size());
-            if(mouse_left_inside && box.contains(event.mouseButton.x, event.mouseButton.y))
+        } else if(is_touch_enabled() && event.type == mgl::Event::MouseButtonReleased && event.mouse_button.button == mgl::Mouse::Left) {
+            mgl::FloatRect box(background.get_position(), background.get_size());
+            if(mouse_left_inside && box.contains(mgl::vec2f(event.mouse_button.x, event.mouse_button.y)))
                 show_virtual_keyboard();
             mouse_left_inside = false;
         }
@@ -100,63 +102,70 @@ namespace QuickMedia {
         if(!editable)
             return;
 
-        if(event.type == sf::Event::KeyPressed && event.key.code == sf::Keyboard::Backspace)
+        if(event.type == mgl::Event::KeyPressed && event.key.code == mgl::Keyboard::Backspace)
             backspace_pressed = true;
-        else if(event.type == sf::Event::KeyReleased && event.key.code == sf::Keyboard::Backspace)
+        else if(event.type == mgl::Event::KeyReleased && event.key.code == mgl::Keyboard::Backspace)
             backspace_pressed = false;
-        if(event.type == sf::Event::KeyPressed && event.key.code == sf::Keyboard::V && event.key.control) {
-            auto clipboard = sf::Clipboard::getString().toUtf8();
-            append_text(*(std::string*)&clipboard);
+        if(event.type == mgl::Event::KeyPressed && event.key.code == mgl::Keyboard::V && event.key.control) {
+            append_text(window.get_clipboard());
         }
 
-        if(event.type == sf::Event::KeyPressed && event.key.code == sf::Keyboard::D && event.key.control) {
-            clear();
-            updated_search = true;
-            time_since_search_update.restart();
-        }
-
-        if((sf::Keyboard::isKeyPressed(sf::Keyboard::LControl) || sf::Keyboard::isKeyPressed(sf::Keyboard::RControl)) && (event.type != sf::Event::TextEntered || event.text.unicode != 13)) // Enter
+        if(event.type == mgl::Event::KeyPressed && event.key.code == mgl::Keyboard::D && event.key.control) {
+            if(!text.get_string().empty()) {
+                clear();
+                updated_search = true;
+                time_since_search_update.restart();
+            }
             return;
+        }
 
-        if(event.type == sf::Event::TextEntered && event.text.unicode != 8 && event.text.unicode != 127) // 8 = backspace, 127 = del
-            onTextEntered(event.text.unicode);
-        else if(event.type == sf::Event::KeyPressed && event.key.code == sf::Keyboard::Backspace)
-            onTextEntered(8);
+        if((window.is_key_pressed(mgl::Keyboard::LControl) || window.is_key_pressed(mgl::Keyboard::RControl)) && (event.type != mgl::Event::TextEntered || event.text.codepoint != 13)) // Enter
+           return;
+
+        if(event.type == mgl::Event::TextEntered && event.text.codepoint != 8 && event.text.codepoint != 127) { // 8 = backspace, 127 = del
+            onTextEntered(event.text);
+        } else if(event.type == mgl::Event::KeyPressed && event.key.code == mgl::Keyboard::Backspace) {
+            mgl::Event::TextEvent text_event;
+            text_event.codepoint = 8;
+            text_event.size = 1;
+            text_event.str[0] = 8;
+            text_event.str[1] = '\0';
+            onTextEntered(text_event);
+        }
     }
 
     void SearchBar::update() {
-        sf::Int32 elapsed_time = time_since_search_update.getElapsedTime().asMilliseconds();
-        int timeout = text_autosearch_delay;
+        double elapsed_time_sec = time_since_search_update.get_elapsed_time_seconds();
+        double timeout_sec = (double)text_autosearch_delay_ms * 0.001;
         if(backspace_pressed)
-            timeout = 750;
-        if(updated_search && elapsed_time >= timeout) {
+            timeout_sec = 0.75;
+        if(updated_search && elapsed_time_sec >= timeout_sec) {
             updated_search = false;
-            auto u8 = text.getString().toUtf8();
-            std::string *u8_str = (std::string*)&u8;
+            std::string str = text.get_string();
             if(show_placeholder)
-                u8_str->clear();
+                str.clear();
             if(onTextUpdateCallback)
-                onTextUpdateCallback(*u8_str);
+                onTextUpdateCallback(str);
             typing = false;
         }
     }
 
-    void SearchBar::onWindowResize(const sf::Vector2f &size) {
-        draw_logo = plugin_logo_sprite.getTexture() != nullptr;
+    void SearchBar::onWindowResize(const mgl::vec2f &size) {
+        draw_logo = plugin_logo_sprite.get_texture() != nullptr;
         if(size.x < 400.0f)
             draw_logo = false;
 
-        float font_height = text.getCharacterSize() + 7.0f;
+        float font_height = character_size + 7.0f;
         float rect_height = std::floor(font_height + background_margin_vertical * 2.0f);
 
         float offset_x;
         if(draw_logo) {
-            float one_line_height = std::floor(text.getCharacterSize() + 8.0f + background_margin_vertical * 2.0f);
-            auto texture_size = plugin_logo_sprite.getTexture()->getSize();
-            sf::Vector2f texture_size_f(texture_size.x, texture_size.y);
-            sf::Vector2f new_size = wrap_to_size(texture_size_f, sf::Vector2f(200.0f, one_line_height));
-            plugin_logo_sprite.setScale(get_ratio(texture_size_f, new_size));
-            plugin_logo_sprite.setPosition(pos.x + padding_x, pos.y + padding_top + rect_height * 0.5f - plugin_logo_sprite.getTexture()->getSize().y * plugin_logo_sprite.getScale().y * 0.5f);
+            float one_line_height = std::floor(character_size + 8.0f + background_margin_vertical * 2.0f);
+            auto texture_size = plugin_logo_sprite.get_texture()->get_size();
+            mgl::vec2f texture_size_f(texture_size.x, texture_size.y);
+            mgl::vec2f new_size = wrap_to_size(texture_size_f, mgl::vec2f(200.0f, one_line_height));
+            plugin_logo_sprite.set_scale(get_ratio(texture_size_f, new_size));
+            plugin_logo_sprite.set_position(mgl::vec2f(pos.x + padding_x, pos.y + padding_top + rect_height * 0.5f - plugin_logo_sprite.get_texture()->get_size().y * plugin_logo_sprite.get_scale().y * 0.5f));
             offset_x = padding_x + new_size.x + 10.0f;
         } else {
             offset_x = padding_x;
@@ -164,29 +173,32 @@ namespace QuickMedia {
 
         const float width = std::floor(size.x - offset_x - padding_x);
 
-        background.set_size(sf::Vector2f(width, rect_height));
-        shade.setSize(sf::Vector2f(size.x, padding_top + rect_height + padding_bottom));
-        caret.setSize(vec2f_floor(2.0f * get_config().scale, text.getCharacterSize() + std::floor(2.0f * get_config().scale)));
+        background.set_size(mgl::vec2f(width, rect_height));
+        shade.set_size(mgl::vec2f(size.x, padding_top + rect_height + padding_bottom));
+        caret.set_size(vec2f_floor(2.0f * get_config().scale, character_size + std::floor(2.0f * get_config().scale)));
 
-        background.set_position(sf::Vector2f(pos.x + offset_x, pos.y + padding_top));
-        shade.setPosition(pos);
-        sf::Vector2f font_position(std::floor(pos.x + offset_x + background_margin_horizontal), std::floor(pos.y + padding_top + background_margin_vertical));
-        text.setPosition(font_position);
+        background.set_position(mgl::vec2f(pos.x + offset_x, pos.y + padding_top));
+        shade.set_position(pos);
+        mgl::vec2f font_position(std::floor(pos.x + offset_x + background_margin_horizontal), std::floor(pos.y + padding_top + background_margin_vertical - character_size * 0.3f));
+        text.set_position(font_position);
     }
 
-    void SearchBar::onTextEntered(sf::Uint32 codepoint) {
-        if(codepoint == 8 && !show_placeholder) { // Backspace
-            sf::String str = text.getString();
-            if(str.getSize() > 0) {
+    void SearchBar::onTextEntered(const mgl::Event::TextEvent &text_event) {
+        if(text_event.codepoint == 8 && !show_placeholder) { // Backspace
+            std::string str = text.get_string();
+            if(str.size() > 0) {
                 // TODO: When it's possible to move the cursor, then check at cursor position instead of end of the string
-                if(str[str.getSize() - 1] == '\n')
+                if(str[str.size() - 1] == '\n')
                     needs_update = true;
-                str.erase(str.getSize() - 1, 1);
-                text.setString(str);
-                if(str.getSize() == 0) {
+                
+                const size_t codepoint_start_index = mgl::utf8_get_start_of_codepoint((const unsigned char*)str.c_str(), str.size(), str.size() - 1);
+                str.erase(codepoint_start_index);
+                const bool empty = str.empty();
+                text.set_string(std::move(str));
+                if(empty) {
                     show_placeholder = true;
-                    text.setString(placeholder_str);
-                    text.setFillColor(get_theme().placeholder_text_color);
+                    text.set_string(placeholder_str);
+                    text.set_color(get_theme().placeholder_text_color);
                 }
                 if(!updated_search) {
                     typing = true;
@@ -196,18 +208,17 @@ namespace QuickMedia {
                 updated_search = true;
                 time_since_search_update.restart();
             }
-        } else if(codepoint == 13) { // Return
+        } else if(text_event.codepoint == 13) { // Return
             backspace_pressed = false;
             if(onTextSubmitCallback) {
-                auto u8 = text.getString().toUtf8();
-                std::string *u8_str = (std::string*)&u8;
+                std::string str = text.get_string();
                 if(show_placeholder)
-                    u8_str->clear();
-                onTextSubmitCallback(*u8_str);
+                    str.clear();
+                onTextSubmitCallback(str);
             }
-        } else if(codepoint > 31) { // Non-control character
-            append_text(sf::String(codepoint));
-        } else if(codepoint == '\n')
+        } else if(text_event.codepoint > 31) { // Non-control character
+            append_text(std::string(text_event.str, text_event.size));
+        } else if(text_event.codepoint == '\n')
             needs_update = true;
     }
 
@@ -215,8 +226,8 @@ namespace QuickMedia {
         if(show_placeholder)
             return;
         show_placeholder = true;
-        text.setString(placeholder_str);
-        text.setFillColor(get_theme().placeholder_text_color);
+        text.set_string(placeholder_str);
+        text.set_color(get_theme().placeholder_text_color);
         needs_update = true;
         updated_search = false;
         backspace_pressed = false;
@@ -238,13 +249,11 @@ namespace QuickMedia {
 
         if(show_placeholder) {
             show_placeholder = false;
-            text.setString("");
-            text.setFillColor(sf::Color::White);
+            text.set_string("");
+            text.set_color(mgl::Color(255, 255, 255, 255));
         }
 
-        sf::String str = text.getString();
-        str += sf::String::fromUtf8(text_to_add.begin(), text_to_add.end());;
-        text.setString(str);
+        text.append_string(text_to_add);
 
         if(!updated_search) {
             typing = true;
@@ -258,7 +267,7 @@ namespace QuickMedia {
             needs_update = true;
     }
 
-    void SearchBar::set_position(sf::Vector2f pos) {
+    void SearchBar::set_position(mgl::vec2f pos) {
         if(std::abs(this->pos.x - pos.x) > 1.0f || std::abs(this->pos.y - pos.y) > 1.0f) {
             this->pos = pos;
             needs_update = true;
@@ -274,18 +283,18 @@ namespace QuickMedia {
     }
 
     float SearchBar::getBottom() const {
-        return getBottomWithoutShadow() + 5.0f;//background_shadow.getSize().y;
+        return getBottomWithoutShadow() + 5.0f;//background_shadow.get_size().y;
     }
 
     float SearchBar::getBottomWithoutShadow() const {
-        float font_height = text.getCharacterSize() + 7.0f;
+        float font_height = character_size + 7.0f;
         return std::floor(font_height + background_margin_vertical * 2.0f + padding_top + padding_bottom);
     }
 
     std::string SearchBar::get_text() const {
         if(show_placeholder)
             return "";
-        return text.getString();
+        return text.get_string();
     }
 
     bool SearchBar::is_empty() const {