From 194415500d24a77fdb58af0158512a6c7d7ba59b Mon Sep 17 00:00:00 2001
From: zv0n <tom.zvon@gmail.com>
Date: Thu, 23 Jun 2022 10:31:58 +0200
Subject: [PATCH] Move map/tool controls to new button API

---
 mario/editor.cpp  | 323 +++++++++++++++++++++++++++++++++++-----------
 mario/gui/gui.hpp |  77 ++++++-----
 2 files changed, 284 insertions(+), 116 deletions(-)

diff --git a/mario/editor.cpp b/mario/editor.cpp
index 2d8031f..8cb56cd 100644
--- a/mario/editor.cpp
+++ b/mario/editor.cpp
@@ -1,6 +1,7 @@
 #include "../sdlpp/sdlpp.hpp"
 #include "gui/gui.hpp"
 #include "sprites.hpp"
+#include <memory>
 #ifdef _WIN32
 #include "../sdlpp/SDL2/SDL2_framerate.h"
 #include <ctime>
@@ -520,55 +521,115 @@ void getMousePositionFlags(SDLPP::Scene &scene) {
     }
 }
 
-void mouseUpAction(uint64_t flags, SDLPP::Scene &scene) {
-    if (MouseVisitor::moveMapLeft(flags) && global_vars.map.cur_page != 0) {
-        global_vars.map.cur_page--;
-        scene.moveEverything(BLOCK_SIZE, 0);
+struct moveStruct {
+    std::shared_ptr<SDLPP::Scene> scene;
+    std::shared_ptr<Button> other_button;
+};
+
+void toolMoveLeftUpdateButtons(Button *left, Button *right, int &cur_page, int &max_page, bool canAdd) {
+    if(cur_page == 0) {
+        left->disable(render_mutex);
     }
-    if (MouseVisitor::moveMapRight(flags)) {
-        if (global_vars.map.cur_page == global_vars.map.max_page) {
-            // add column
-            global_vars.objects.resize(global_vars.objects.size() + 1);
-            global_vars.map.max_page++;
+    if(cur_page != max_page) {
+        if(canAdd) {
+            // TOOD global button config
+            right->changeText(">");
+            right->setFontColor("#000000", render_mutex);
+            right->setFontOutlineColor("#FFFFFF88", render_mutex);
+            right->setFontColorHighlight("#000000", render_mutex);
+            right->setFontOutlineColorHighlight("#FFFFFFAA", render_mutex);
+        } else {
+            right->enable(render_mutex);
         }
-        global_vars.map.cur_page += 1;
-        scene.moveEverything(-BLOCK_SIZE, 0);
     }
-    if (MouseVisitor::moveToolsLeft(flags) &&
-        global_vars.tool.cur_page_tools != 0) {
-        global_vars.tool.cur_page_tools--;
-        updateToolSelection(global_vars.tool.cur_page_tools + 1,
-                            ToolType::BLOCK);
+}
+
+void toolMoveLeft(Button *left, Button *right, int &cur_page, int &max_page, bool canAdd) {
+    cur_page--;
+    toolMoveLeftUpdateButtons(left, right, cur_page, max_page, canAdd);
+}
+
+void toolMoveRightUpdateButtons(Button *left, Button *right, int &cur_page, int &max_page, bool canAdd) {
+    if(cur_page == max_page) {
+        if(canAdd) {
+            right->changeText("+");
+            right->setFontColor("#00FF00", render_mutex);
+            right->setFontOutlineColor("#000000", render_mutex);
+            right->setFontColorHighlight("#88FF88", render_mutex);
+            right->setFontOutlineColorHighlight("#444444", render_mutex);
+        } else {
+            right->disable(render_mutex);
+        }
     }
-    if (MouseVisitor::moveToolsRight(flags) &&
-        global_vars.tool.cur_page_tools != global_vars.tool.max_page_tools) {
-        global_vars.tool.cur_page_tools++;
-        updateToolSelection(global_vars.tool.cur_page_tools - 1,
-                            ToolType::BLOCK);
+    if(cur_page != 0) {
+        left->enable(render_mutex);
     }
-    if (MouseVisitor::moveModsLeft(flags) &&
-        global_vars.tool.cur_page_mods != 0) {
-        global_vars.tool.cur_page_mods--;
-        updateToolSelection(global_vars.tool.cur_page_mods + 1, ToolType::MOD);
-    }
-    if (MouseVisitor::moveModsRight(flags) &&
-        global_vars.tool.cur_page_mods != global_vars.tool.max_page_mods) {
-        global_vars.tool.cur_page_mods++;
-        updateToolSelection(global_vars.tool.cur_page_mods - 1, ToolType::MOD);
-    }
-    if (MouseVisitor::moveCharactersLeft(flags) &&
-        global_vars.tool.cur_page_characters != 0) {
-        global_vars.tool.cur_page_characters--;
-        updateToolSelection(global_vars.tool.cur_page_characters + 1,
-                            ToolType::CHARACTER);
-    }
-    if (MouseVisitor::moveCharactersRight(flags) &&
-        global_vars.tool.cur_page_characters !=
-            global_vars.tool.max_page_characters) {
-        global_vars.tool.cur_page_characters++;
-        updateToolSelection(global_vars.tool.cur_page_characters - 1,
-                            ToolType::CHARACTER);
+}
+
+void toolMoveRight(Button *left, Button *right, int &cur_page, int &max_page, bool canAdd) {
+    cur_page += 1;
+    toolMoveRightUpdateButtons(left, right, cur_page, max_page, canAdd);
+}
+
+void moveMapLeft(void *input, Button *caller) {
+    auto actual_input = static_cast<moveStruct*>(input);
+    actual_input->scene->moveEverything(BLOCK_SIZE, 0);
+    toolMoveLeft(caller, actual_input->other_button.get(), global_vars.map.cur_page, global_vars.map.max_page, true);
+}
+
+void moveMapRight(void *input, Button *caller) {
+    auto actual_input = static_cast<moveStruct*>(input);
+    if (global_vars.map.cur_page == global_vars.map.max_page) { // add column
+        global_vars.objects.resize(global_vars.objects.size() + 1);
+        global_vars.map.max_page++;
     }
+    toolMoveRight(actual_input->other_button.get(), caller, global_vars.map.cur_page, global_vars.map.max_page, true);
+    actual_input->scene->moveEverything(-BLOCK_SIZE, 0);
+}
+
+void moveToolsLeftButton(void *input, Button *caller) {
+    auto actual_input = static_cast<moveStruct*>(input);
+    toolMoveLeft(caller, actual_input->other_button.get(), global_vars.tool.cur_page_tools, global_vars.tool.max_page_tools, false);
+    updateToolSelection(global_vars.tool.cur_page_tools + 1,
+                        ToolType::BLOCK);
+}
+
+void moveToolsRightButton(void *input, Button *caller) {
+    auto actual_input = static_cast<moveStruct*>(input);
+    toolMoveRight(actual_input->other_button.get(), caller, global_vars.tool.cur_page_tools, global_vars.tool.max_page_tools, false);
+    updateToolSelection(global_vars.tool.cur_page_tools - 1,
+                        ToolType::BLOCK);
+}
+
+void moveModsLeft(void *input, Button *caller) {
+    auto actual_input = static_cast<moveStruct*>(input);
+    toolMoveLeft(caller, actual_input->other_button.get(), global_vars.tool.cur_page_mods, global_vars.tool.max_page_mods, false);
+    updateToolSelection(global_vars.tool.cur_page_tools + 1,
+                        ToolType::MOD);
+}
+
+void moveModsRight(void *input, Button *caller) {
+    auto actual_input = static_cast<moveStruct*>(input);
+    toolMoveRight(actual_input->other_button.get(), caller, global_vars.tool.cur_page_mods, global_vars.tool.max_page_mods, false);
+    updateToolSelection(global_vars.tool.cur_page_tools - 1,
+                        ToolType::MOD);
+}
+
+void moveCharsLeft(void *input, Button *caller) {
+    auto actual_input = static_cast<moveStruct*>(input);
+    toolMoveLeft(caller, actual_input->other_button.get(), global_vars.tool.cur_page_characters, global_vars.tool.max_page_characters, false);
+    updateToolSelection(global_vars.tool.cur_page_tools + 1,
+                        ToolType::CHARACTER);
+}
+
+void moveCharsRight(void *input, Button *caller) {
+    auto actual_input = static_cast<moveStruct*>(input);
+    toolMoveRight(actual_input->other_button.get(), caller, global_vars.tool.cur_page_characters, global_vars.tool.max_page_characters, false);
+    updateToolSelection(global_vars.tool.cur_page_tools - 1,
+                        ToolType::CHARACTER);
+}
+
+void mouseUpAction(uint64_t flags) {
     if(MouseVisitor::button(flags)) {
         global_vars.buttons[global_vars.mouse.cur_button_index]->performFunction();
     }
@@ -701,7 +762,7 @@ void pollEvents(SDLPP::Scene &scene) {
             break;
         case SDL_MOUSEBUTTONUP:
             if (global_vars.mouse.cur_flags == global_vars.mouse.prev_flags) {
-                mouseUpAction(global_vars.mouse.cur_flags, scene);
+                mouseUpAction(global_vars.mouse.cur_flags);
             }
             if (global_vars.mouse.edit_box.getX() != 0) {
                 placeTool(scene);
@@ -931,7 +992,7 @@ void populateWorldType(
     scene->addObject(tool_text);
 }
 
-void checkArrowsEnabled(uint64_t cur_page, uint64_t max_page,
+/*void checkArrowsEnabled(uint64_t cur_page, uint64_t max_page,
                         uint64_t left_flag, uint64_t right_flag,
                         std::shared_ptr<SDLPP::TextRenderer> &left_arrow,
                         std::shared_ptr<SDLPP::TextRenderer> &right_arrow,
@@ -962,12 +1023,12 @@ void checkArrowsEnabled(uint64_t cur_page, uint64_t max_page,
             right_arrow->changeText(">");
         }
     }
-}
+}*/
 
-void testButtonFunc(void *input) {
+void testButtonFunc(void *input, Button *caller) {
     auto actual = static_cast<int*>(input);
     std::cout << "NUM: " << *actual << std::endl;
-    global_vars.buttons[0]->disable(render_mutex);
+    caller->disable(render_mutex);
 }
 
 #ifdef _WIN32
@@ -1025,12 +1086,49 @@ int main() {
 
     // create grids and arrow controls
     // map
-    auto arrows = createArrowControls(
+/*    auto arrows = createArrowControls(
         0, (MAP_WIDTH + 1) * BLOCK_SIZE, 1 - MAP_HEIGHT * BLOCK_SIZE,
         MAP_HEIGHT * BLOCK_SIZE, EDITOR_LEFT_MAP_ID, EDITOR_RIGHT_MAP_ID, scene,
         font_config);
     auto left_map_arrow = arrows.first;
-    auto right_map_arrow = arrows.second;
+    auto right_map_arrow = arrows.second;*/
+    ButtonConfig default_button_theme{};
+    default_button_theme.bg_color = "#FFFFFF88";
+    default_button_theme.bg_color_highlight = "#FFFFFFBB";
+    default_button_theme.bg_color_disabled = "#AAAAAA88";
+    default_button_theme.font_color = "#000000";
+    default_button_theme.font_color_highlight = "#000000";
+    default_button_theme.font_color_disabled = "#555555";
+    default_button_theme.font_outline_color = "#FFFFFF88";
+    default_button_theme.font_outline_color_highlight = "#FFFFFFAA";
+    default_button_theme.font_outline_color_disabled = "#787878";
+    default_button_theme.outline = 0.1;
+    // left map arrow
+    moveStruct left_map_input{
+        .scene = scene,
+        .other_button = nullptr,
+    };
+    global_vars.buttons.emplace_back(std::make_shared<Button>(
+        0, 1 - MAP_HEIGHT * BLOCK_SIZE, BLOCK_SIZE, MAP_HEIGHT * BLOCK_SIZE,
+        renderer, "<", default_button_theme, moveMapLeft, &left_map_input));
+    global_vars.buttons.back()->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
+    global_vars.buttons.back()->setPermanent();
+    global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1);
+    // right map arrow
+    moveStruct right_map_input{
+        .scene = scene,
+        .other_button = global_vars.buttons.back(),
+    };
+    global_vars.buttons.emplace_back(std::make_shared<Button>(
+        (MAP_WIDTH + 1) * BLOCK_SIZE, 1 - MAP_HEIGHT * BLOCK_SIZE, BLOCK_SIZE, MAP_HEIGHT * BLOCK_SIZE,
+        renderer, ">", default_button_theme, moveMapRight, &right_map_input));
+    global_vars.buttons.back()->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
+    global_vars.buttons.back()->setPermanent();
+    global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1);
+    left_map_input.other_button = global_vars.buttons.back();
+    // ensure disabled/enabled properly
+    toolMoveRightUpdateButtons(right_map_input.other_button.get(), global_vars.buttons.back().get(), global_vars.map.cur_page, global_vars.map.max_page, true);
+    toolMoveLeftUpdateButtons(right_map_input.other_button.get(), global_vars.buttons.back().get(), global_vars.map.cur_page, global_vars.map.max_page, true);
     createGrid(BLOCK_SIZE, 1 - MAP_HEIGHT * BLOCK_SIZE, MAP_WIDTH, MAP_HEIGHT,
                scene);
     // edit blocks on map
@@ -1042,17 +1140,50 @@ int main() {
         }
     }
 
+    global_vars.tool.max_page_tools =
+        (possibleBlocks.size() - 1) / (2 * TOOLS_WIDTH);
+    global_vars.tool.max_page_mods =
+        (possibleMods.size() - 1) / (2 * MOD_WIDTH);
+    global_vars.tool.max_page_characters =
+        (possibleCharacters.size() - 1) / (2 * CHARACTER_WIDTH);
+
     // tools
     populateToolGrid(TOOLS_WIDTH, 2, (MAP_WIDTH - TOOLS_WIDTH) * BLOCK_SIZE,
                      1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, ToolType::BLOCK,
                      possibleBlocks, global_vars.tools, global_vars.tool_boxes,
                      scene, "TERRAIN", font_config);
-    arrows = createArrowControls(
+/*    arrows = createArrowControls(
         (MAP_WIDTH - TOOLS_WIDTH - 1) * BLOCK_SIZE, MAP_WIDTH * BLOCK_SIZE,
         1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, 2 * BLOCK_SIZE, EDITOR_LEFT_TOOL_ID,
         EDITOR_RIGHT_TOOL_ID, scene, font_config);
     auto left_tool_arrow = arrows.first;
-    auto right_tool_arrow = arrows.second;
+    auto right_tool_arrow = arrows.second;*/
+    // left tool arrow
+    moveStruct left_tool_input{
+        .scene = scene,
+        .other_button = nullptr,
+    };
+    global_vars.buttons.emplace_back(std::make_shared<Button>(
+        (MAP_WIDTH - TOOLS_WIDTH - 1) * BLOCK_SIZE, 1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, BLOCK_SIZE, 2 * BLOCK_SIZE,
+        renderer, "<", default_button_theme, moveToolsLeftButton, &left_tool_input));
+    global_vars.buttons.back()->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
+    global_vars.buttons.back()->setPermanent();
+    global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1);
+    // right tool arrow
+    moveStruct right_tool_input{
+        .scene = scene,
+        .other_button = global_vars.buttons.back(),
+    };
+    global_vars.buttons.emplace_back(std::make_shared<Button>(
+        MAP_WIDTH * BLOCK_SIZE, 1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, BLOCK_SIZE, 2 * BLOCK_SIZE,
+        renderer, ">", default_button_theme, moveToolsRightButton, &right_tool_input));
+    global_vars.buttons.back()->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
+    global_vars.buttons.back()->setPermanent();
+    global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1);
+    left_tool_input.other_button = global_vars.buttons.back();
+    // ensure disabled/enabled properly
+    toolMoveRightUpdateButtons(right_tool_input.other_button.get(), global_vars.buttons.back().get(), global_vars.tool.cur_page_tools, global_vars.tool.max_page_tools, false);
+    toolMoveLeftUpdateButtons(right_tool_input.other_button.get(), global_vars.buttons.back().get(), global_vars.tool.cur_page_tools, global_vars.tool.max_page_tools, false);
     createGrid((MAP_WIDTH - TOOLS_WIDTH) * BLOCK_SIZE,
                1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, TOOLS_WIDTH, 2, scene);
     // mods
@@ -1060,12 +1191,38 @@ int main() {
                      1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, ToolType::MOD,
                      possibleMods, global_vars.mods, global_vars.mod_boxes,
                      scene, "MODS", font_config);
-    arrows = createArrowControls(4 * BLOCK_SIZE, (MOD_WIDTH + 5) * BLOCK_SIZE,
+/*    arrows = createArrowControls(4 * BLOCK_SIZE, (MOD_WIDTH + 5) * BLOCK_SIZE,
                                  1 - (MAP_HEIGHT + 3) * BLOCK_SIZE,
                                  2 * BLOCK_SIZE, EDITOR_LEFT_MOD_ID,
                                  EDITOR_RIGHT_MOD_ID, scene, font_config);
     auto left_mod_arrow = arrows.first;
-    auto right_mod_arrow = arrows.second;
+    auto right_mod_arrow = arrows.second;*/
+    // left mod arrow
+    moveStruct left_mod_input{
+        .scene = scene,
+        .other_button = nullptr,
+    };
+    global_vars.buttons.emplace_back(std::make_shared<Button>(
+        4 * BLOCK_SIZE, 1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, BLOCK_SIZE, 2 * BLOCK_SIZE,
+        renderer, "<", default_button_theme, moveModsLeft, &left_mod_input));
+    global_vars.buttons.back()->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
+    global_vars.buttons.back()->setPermanent();
+    global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1);
+    // right mod arrow
+    moveStruct right_mod_input{
+        .scene = scene,
+        .other_button = global_vars.buttons.back(),
+    };
+    global_vars.buttons.emplace_back(std::make_shared<Button>(
+        (MOD_WIDTH + 5) * BLOCK_SIZE, 1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, BLOCK_SIZE, 2 * BLOCK_SIZE,
+        renderer, ">", default_button_theme, moveModsRight, &right_mod_input));
+    global_vars.buttons.back()->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
+    global_vars.buttons.back()->setPermanent();
+    global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1);
+    left_mod_input.other_button = global_vars.buttons.back();
+    // ensure disabled/enabled properly
+    toolMoveRightUpdateButtons(right_mod_input.other_button.get(), global_vars.buttons.back().get(), global_vars.tool.cur_page_mods, global_vars.tool.max_page_mods, false);
+    toolMoveLeftUpdateButtons(right_mod_input.other_button.get(), global_vars.buttons.back().get(), global_vars.tool.cur_page_mods, global_vars.tool.max_page_mods, false);
     createGrid(5 * BLOCK_SIZE, 1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, MOD_WIDTH, 2,
                scene);
     // characters
@@ -1074,13 +1231,39 @@ int main() {
                      possibleCharacters, global_vars.characters,
                      global_vars.character_boxes, scene, "CHARACTERS",
                      font_config);
-    arrows = createArrowControls((MOD_WIDTH + 7) * BLOCK_SIZE,
+/*    arrows = createArrowControls((MOD_WIDTH + 7) * BLOCK_SIZE,
                                  (MOD_WIDTH + 8 + CHARACTER_WIDTH) * BLOCK_SIZE,
                                  1 - (MAP_HEIGHT + 3) * BLOCK_SIZE,
                                  2 * BLOCK_SIZE, EDITOR_LEFT_CHARACTER_ID,
                                  EDITOR_RIGHT_CHARACTER_ID, scene, font_config);
     auto left_char_arrow = arrows.first;
-    auto right_char_arrow = arrows.second;
+    auto right_char_arrow = arrows.second;*/
+    // left character arrow
+    moveStruct left_character_input{
+        .scene = scene,
+        .other_button = nullptr,
+    };
+    global_vars.buttons.emplace_back(std::make_shared<Button>(
+        (MOD_WIDTH + 7) * BLOCK_SIZE, 1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, BLOCK_SIZE, 2 * BLOCK_SIZE,
+        renderer, "<", default_button_theme, moveCharsLeft, &left_character_input));
+    global_vars.buttons.back()->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
+    global_vars.buttons.back()->setPermanent();
+    global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1);
+    // right character arrow
+    moveStruct right_character_input{
+        .scene = scene,
+        .other_button = global_vars.buttons.back(),
+    };
+    global_vars.buttons.emplace_back(std::make_shared<Button>(
+        (MOD_WIDTH + 8 + CHARACTER_WIDTH) * BLOCK_SIZE, 1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, BLOCK_SIZE, 2 * BLOCK_SIZE,
+        renderer, ">", default_button_theme, moveCharsRight, &right_character_input));
+    global_vars.buttons.back()->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
+    global_vars.buttons.back()->setPermanent();
+    global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1);
+    // ensure disabled/enabled properly
+    toolMoveRightUpdateButtons(right_character_input.other_button.get(), global_vars.buttons.back().get(), global_vars.tool.cur_page_characters, global_vars.tool.max_page_characters, false);
+    toolMoveLeftUpdateButtons(right_character_input.other_button.get(), global_vars.buttons.back().get(), global_vars.tool.cur_page_characters, global_vars.tool.max_page_characters, false);
+    left_character_input.other_button = global_vars.buttons.back();
     createGrid((MOD_WIDTH + 8) * BLOCK_SIZE, 1 - (MAP_HEIGHT + 3) * BLOCK_SIZE,
                CHARACTER_WIDTH, 2, scene);
 
@@ -1093,13 +1276,6 @@ int main() {
 
     global_vars.map.max_page = global_vars.objects.size() - MAP_WIDTH;
 
-    global_vars.tool.max_page_tools =
-        (possibleBlocks.size() - 1) / (2 * TOOLS_WIDTH);
-    global_vars.tool.max_page_mods =
-        (possibleMods.size() - 1) / (2 * MOD_WIDTH);
-    global_vars.tool.max_page_characters =
-        (possibleCharacters.size() - 1) / (2 * CHARACTER_WIDTH);
-
     auto mouse =
         std::make_shared<SDLPP::RectangleRender>(0.01, 0.01, 0, 0, renderer);
     mouse->setMinWidth(1);
@@ -1148,20 +1324,12 @@ int main() {
     updateToolSelection(0, ToolType::CHARACTER);
     setToolColor();
 
-    ButtonColors default_button_theme{};
-    default_button_theme.bg_color = "#FF0088";
-    default_button_theme.bg_color_highlight = "#FF00FF";
-    default_button_theme.bg_color_disabled = "#FFAAFF";
-    default_button_theme.font_color = "#FFFFFF";
-    default_button_theme.font_color_highlight = "#FFFFFF";
-    default_button_theme.font_color_disabled = "#BBBBBB";
-    default_button_theme.font_outline_color = "#000000";
-    default_button_theme.font_outline_color_highlight = "#444444";
-    default_button_theme.font_outline_color_disabled = "#888888";
     global_vars.buttons.emplace_back(std::make_shared<Button>(0, 0, 0.2, 0.2, renderer, "CLICK ME", default_button_theme, testButtonFunc, &num));
-    global_vars.buttons.back()->setStatic();
+    global_vars.buttons.back()->setPermanent();
     global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1);
-    scene->addObject(global_vars.buttons.back());
+    for(auto &button : global_vars.buttons) {
+        scene->addObject(button);
+    }
 
     auto base = SDL_GetTicks();
     int frames = 0;
@@ -1199,7 +1367,8 @@ int main() {
             frames = 0;
             base = SDL_GetTicks();
         }
-        checkArrowsEnabled(global_vars.map.cur_page, global_vars.map.max_page,
+        // TODO maybe button update func instead of using mutex?
+/*        checkArrowsEnabled(global_vars.map.cur_page, global_vars.map.max_page,
                            MAP_LEFT_ENABLED_FLAG, MAP_RIGHT_ENABLED_FLAG,
                            left_map_arrow, right_map_arrow, font, true);
         checkArrowsEnabled(global_vars.tool.cur_page_tools,
@@ -1214,7 +1383,7 @@ int main() {
                            global_vars.tool.max_page_characters,
                            CHARACTER_LEFT_ENABLED_FLAG,
                            CHARACTER_RIGHT_ENABLED_FLAG, left_char_arrow,
-                           right_char_arrow, font);
+                           right_char_arrow, font);*/
         if (getFlag(UPDATE_FLAG)) {
             scene->updateSizeAndPosition();
             unsetFlag(UPDATE_FLAG);
diff --git a/mario/gui/gui.hpp b/mario/gui/gui.hpp
index de5d2f9..8132667 100644
--- a/mario/gui/gui.hpp
+++ b/mario/gui/gui.hpp
@@ -8,9 +8,7 @@
 #include <mutex>
 #include <utility>
 
-#define TEXT_OUTLINE 0.2
-
-struct ButtonColors {
+struct ButtonConfig {
     std::string font_color;
     std::string font_outline_color;
     std::string bg_color;
@@ -20,6 +18,7 @@ struct ButtonColors {
     std::string font_color_disabled;
     std::string font_outline_color_disabled;
     std::string bg_color_disabled;
+    double outline;
 };
 
 class Button : public SDLPP::TextRenderer {
@@ -27,73 +26,73 @@ public:
     Button() = delete;
     Button(double x, double y, double w, double h,
            std::shared_ptr<SDLPP::Renderer> &r, const std::string &text,
-           const ButtonColors &colors,
-           std::function<void(void *)> click_fun, void *input)
-            : TextRenderer(x, y, w, h, r, g_text_config->getFont(), text, colors.font_color,
-                           colors.font_outline_color, TEXT_OUTLINE),
+           const ButtonConfig &config,
+           std::function<void(void *, Button *)> click_fun, void *input)
+            : TextRenderer(x, y, w, h, r, g_text_config->getFont(), text, config.font_color,
+                           config.font_outline_color, config.outline),
               click_fun(std::move(click_fun)), func_input(input),
-              colors(colors) {
-        setColor(colors.bg_color);
+              config(config) {
+        setColor(config.bg_color);
         setId(BUTTON_ID);
         addCollision(SDLPP::RectColider(0, 0, 1, 1));
     }
     void setFontColor(const std::string &color, std::mutex &mutex) {
-        colors.font_color = color;
+        config.font_color = color;
         if(!highlighted && !disabled) {
-            updateTextColor(colors.font_color, colors.font_outline_color, mutex);
+            updateTextColor(config.font_color, config.font_outline_color, mutex);
         }
     }
     void setFontColorHighlight(const std::string &color, std::mutex &mutex) {
-        colors.font_color_highlight = color;
+        config.font_color_highlight = color;
         if(highlighted && !disabled) {
-            updateTextColor(colors.font_color_highlight, colors.font_outline_color_highlight, mutex);
+            updateTextColor(config.font_color_highlight, config.font_outline_color_highlight, mutex);
         }
     }
     void setFontColorDisabled(const std::string &color, std::mutex &mutex) {
-        colors.font_color_disabled = color;
+        config.font_color_disabled = color;
         if(disabled) {
-            updateTextColor(colors.font_color_disabled, colors.font_outline_color_disabled, mutex);
+            updateTextColor(config.font_color_disabled, config.font_outline_color_disabled, mutex);
         }
     }
     void setFontOutlineColor(const std::string &color, std::mutex &mutex) {
-        colors.font_outline_color = color;
+        config.font_outline_color = color;
         if(!highlighted && !disabled) {
-            updateTextColor(colors.font_color, colors.font_outline_color, mutex);
+            updateTextColor(config.font_color, config.font_outline_color, mutex);
         }
     }
     void setFontOutlineColorHighlight(const std::string &color, std::mutex &mutex) {
-        colors.font_outline_color_highlight = color;
+        config.font_outline_color_highlight = color;
         if(highlighted && !disabled) {
-            updateTextColor(colors.font_color_highlight, colors.font_outline_color_highlight, mutex);
+            updateTextColor(config.font_color_highlight, config.font_outline_color_highlight, mutex);
         }
     }
     void setFontOutlineColorDisabled(const std::string &color, std::mutex &mutex) {
-        colors.font_outline_color_disabled = color;
+        config.font_outline_color_disabled = color;
         if(disabled) {
-            updateTextColor(colors.font_color_disabled, colors.font_outline_color_disabled, mutex);
+            updateTextColor(config.font_color_disabled, config.font_outline_color_disabled, mutex);
         }
     }
     void setBackgroundColor(const std::string &color) {
-        colors.bg_color = color;
+        config.bg_color = color;
         if(!highlighted && !disabled) {
             setColor(color);
         }
     }
     void setBackgroundColorHighlight(const std::string &color) {
-        colors.bg_color_highlight = color;
+        config.bg_color_highlight = color;
         if(highlighted && !disabled) {
             setColor(color);
         }
     }
     void setBackgroundColorDisabled(const std::string &color) {
-        colors.bg_color_disabled = color;
+        config.bg_color_disabled = color;
         if(disabled) {
             setColor(color);
         }
     }
-    void performFunction() const {
+    void performFunction() {
         if(!disabled) {
-            click_fun(func_input);
+            click_fun(func_input, this);
         }
     }
     uint64_t getButtonIndex() const {
@@ -104,43 +103,43 @@ public:
     }
     void setHighlight(std::mutex &mutex) {
         if(!disabled) {
-            setColor(colors.bg_color_highlight);
-            updateTextColor(colors.font_color_highlight, colors.font_outline_color_highlight, mutex);
+            setColor(config.bg_color_highlight);
+            updateTextColor(config.font_color_highlight, config.font_outline_color_highlight, mutex);
         }
         highlighted = true;
     }
     void unsetHighlight(std::mutex &mutex) {
         if(!disabled) {
-            setColor(colors.bg_color);
-            updateTextColor(colors.font_color, colors.font_outline_color, mutex);
+            setColor(config.bg_color);
+            updateTextColor(config.font_color, config.font_outline_color, mutex);
         }
         highlighted = false;
     }
     void disable(std::mutex &mutex) {
-        setColor(colors.bg_color_disabled);
-        updateTextColor(colors.font_color_disabled, colors.font_outline_color_disabled, mutex);
+        setColor(config.bg_color_disabled);
+        updateTextColor(config.font_color_disabled, config.font_outline_color_disabled, mutex);
         disabled = true;
     }
     void enable(std::mutex &mutex) {
         if(!highlighted) {
-            setColor(colors.bg_color);
-            updateTextColor(colors.font_color, colors.font_outline_color, mutex);
+            setColor(config.bg_color);
+            updateTextColor(config.font_color, config.font_outline_color, mutex);
         } else {
-            setColor(colors.bg_color_highlight);
-            updateTextColor(colors.font_color_highlight, colors.font_outline_color_highlight, mutex);
+            setColor(config.bg_color_highlight);
+            updateTextColor(config.font_color_highlight, config.font_outline_color_highlight, mutex);
         }
         disabled = false;
     }
 private:
     void updateTextColor(const std::string &font, const std::string &outline, std::mutex &mutex) {
         std::lock_guard<std::mutex> textUpdate(mutex);
-        setTextColor(g_text_config->getFont(), font, outline, TEXT_OUTLINE);
+        setTextColor(g_text_config->getFont(), font, outline, config.outline);
     }
 
-    std::function<void(void *)> click_fun;
+    std::function<void(void *, Button *)> click_fun;
     void *func_input;
     uint64_t _id{};
-    ButtonColors colors{};
+    ButtonConfig config{};
     bool highlighted = false;
     bool disabled = false;
 };