ui: redesing button handle system, that avoid draw/handle in different functions

Author: s.kushnirenko

src/graphics/elements/generic_button.cpp

@@ -1,6 +1,8 @@
 #include "generic_button.h"
 
-static int get_button(const mouse* m, int x, int y, generic_button* buttons, int num_buttons) {
+#include "input/mouse.h"
+
+static int get_button(const mouse* m, int x, int y, const generic_button* buttons, int num_buttons) {
     for (int i = 0; i < num_buttons; i++) {
         if (x + buttons[i].x <= m->x && x + buttons[i].x + buttons[i].width > m->x && y + buttons[i].y <= m->y
             && y + buttons[i].y + buttons[i].height > m->y) {
@@ -10,7 +12,7 @@ static int get_button(const mouse* m, int x, int y, generic_button* buttons, int
     return 0;
 }
 
-static int get_button_min(const mouse* m, int x, int y, generic_button* buttons, int num_buttons, int minimum_button) {
+static int get_button_min(const mouse* m, int x, int y, const generic_button* buttons, int num_buttons, int minimum_button) {
     for (int i = minimum_button; i < num_buttons; i++) {
         if (x + buttons[i].x <= m->x && x + buttons[i].x + buttons[i].width > m->x && y + buttons[i].y <= m->y
             && y + buttons[i].y + buttons[i].height > m->y) {
@@ -20,7 +22,7 @@ static int get_button_min(const mouse* m, int x, int y, generic_button* buttons,
     return 0;
 }
 
-int generic_buttons_handle_mouse(const mouse* m, int x, int y, generic_button* buttons, int num_buttons, int* focus_button_id) {
+int generic_buttons_handle_mouse(const mouse* m, int x, int y, const generic_button* buttons, int num_buttons, int* focus_button_id) {
     int button_id = get_button(m, x, y, buttons, num_buttons);
     if (focus_button_id) {
         *focus_button_id = button_id;
@@ -30,9 +32,12 @@ int generic_buttons_handle_mouse(const mouse* m, int x, int y, generic_button* b
         return 0;
     }
 
-    generic_button* button = &buttons[button_id - 1];
+    const generic_button* button = &buttons[button_id - 1];
     if (m->left.went_up) {
         button->left_click_handler(button->parameter1, button->parameter2);
+        if (button->onclick) {
+            button->onclick(button->parameter1, button->parameter2);
+        }
     } else if (m->right.went_up) {
         button->right_click_handler(button->parameter1, button->parameter2);
     } else {
@@ -42,15 +47,15 @@ int generic_buttons_handle_mouse(const mouse* m, int x, int y, generic_button* b
     return button_id;
 }
 
-int generic_buttons_min_handle_mouse(const mouse* m, int x, int y, generic_button* buttons, int num_buttons, int* focus_button_id, int minimum_button) {
+int generic_buttons_min_handle_mouse(const mouse* m, int x, int y, const generic_button* buttons, int num_buttons, int* focus_button_id, int minimum_button) {
     int button_id = get_button_min(m, x, y, buttons, num_buttons, minimum_button);
     if (focus_button_id)
         *focus_button_id = button_id;
 
     if (!button_id)
         return 0;
 
-    generic_button* button = &buttons[button_id - 1];
+    const generic_button* button = &buttons[button_id - 1];
     if (m->left.went_up)
         button->left_click_handler(button->parameter1, button->parameter2);
 
@@ -61,3 +66,10 @@ int generic_buttons_min_handle_mouse(const mouse* m, int x, int y, generic_butto
 
     return button_id;
 }
+
+bool is_button_hover(generic_button &button, vec2i context) {
+    const mouse *m = mouse_get();
+    vec2i bpos = context + vec2i{button.x, button.y};
+    return (   bpos.x <= m->x && bpos.x + button.width > m->x
+            && bpos.y <= m->y && bpos.y + button.height > m->y);
+}

src/graphics/elements/generic_button.h

@@ -4,22 +4,32 @@
 #include "input/mouse.h"
 
 #include <vector>
+#include <functional>
 
 struct generic_button {
-    short x;
-    short y;
-    short width;
-    short height;
+    int x;
+    int y;
+    int width;
+    int height;
     void (*left_click_handler)(int param1, int param2);
     void (*right_click_handler)(int param1, int param2);
     int parameter1;
     int parameter2;
+
+    std::function<void(int,int)> onclick;
 };
 
-int generic_buttons_handle_mouse(const mouse* m, int x, int y, generic_button* buttons, int num_buttons, int* focus_button_id);
-int generic_buttons_min_handle_mouse(const mouse* m, int x, int y, generic_button* buttons, int num_buttons, int* focus_button_id, int minimum_button);
+int generic_buttons_handle_mouse(const mouse* m, int x, int y, const generic_button* buttons, int num_buttons, int* focus_button_id);
+int generic_buttons_min_handle_mouse(const mouse* m, int x, int y, const generic_button* buttons, int num_buttons, int* focus_button_id, int minimum_button);
+
+bool is_button_hover(generic_button &button, vec2i context);
+
+template<class T, uint32_t N>
+inline int generic_buttons_handle_mouse(const mouse *m, vec2i pos, const T (&buttons)[N], int &focus_button_id) {
+    return generic_buttons_handle_mouse(m, pos.x, pos.y, buttons, N, &focus_button_id);
+}
 
 template<class T>
-inline int generic_buttons_handle_mouse(const mouse *m, vec2i pos, T &buttons, int &focus_button_id) {
-    return generic_buttons_handle_mouse(m, pos.x, pos.y, std::begin(buttons), (int)std::size(buttons), &focus_button_id);
+inline int generic_buttons_handle_mouse(const mouse *m, vec2i pos, const T &buttons, int &focus_button_id) {
+    return generic_buttons_handle_mouse(m, pos.x, pos.y, &buttons.front(), buttons.size(), &focus_button_id);
 }

src/input/mouse.cpp

@@ -7,13 +7,11 @@ enum { SYSTEM_NONE = 0, SYSTEM_UP = 1, SYSTEM_DOWN = 2, SYSTEM_DOUBLE_CLICK = 4
 
 #define DOUBLE_CLICK_TIME 500
 
-static mouse data;
+mouse g_mouse;
 static mouse dialog;
 static time_millis last_click;
 
-const mouse* mouse_get(void) {
-    return &data;
-}
+const mouse* mouse_get() { return &g_mouse; }
 
 static void clear_mouse_button(mouse_button* button) {
     button->is_down = 0;
@@ -24,6 +22,8 @@ static void clear_mouse_button(mouse_button* button) {
 }
 
 void mouse_set_from_touch(const touch* first, const touch* last) {
+    auto &data = g_mouse;
+
     data.x = first->current_point.x;
     data.y = first->current_point.y;
     data.scrolled = touch_get_scroll();
@@ -51,6 +51,8 @@ void mouse_set_from_touch(const touch* first, const touch* last) {
 }
 
 void mouse_set_position(int x, int y) {
+    auto &data = g_mouse;
+
     if (x != data.x || y != data.y)
         last_click = 0;
 
@@ -61,6 +63,8 @@ void mouse_set_position(int x, int y) {
 }
 
 void mouse_set_left_down(int down) {
+    auto &data = g_mouse;
+
     data.left.system_change |= down ? SYSTEM_DOWN : SYSTEM_UP;
     data.is_touch = 0;
     data.is_inside_window = 1;
@@ -72,20 +76,26 @@ void mouse_set_left_down(int down) {
 }
 
 void mouse_set_middle_down(int down) {
+    auto &data = g_mouse;
+
     data.middle.system_change |= down ? SYSTEM_DOWN : SYSTEM_UP;
     data.is_touch = 0;
     data.is_inside_window = 1;
     last_click = 0;
 }
 
 void mouse_set_right_down(int down) {
+    auto &data = g_mouse;
+
     data.right.system_change |= down ? SYSTEM_DOWN : SYSTEM_UP;
     data.is_touch = 0;
     data.is_inside_window = 1;
     last_click = 0;
 }
 
 void mouse_set_inside_window(int inside) {
+    auto &data = g_mouse;
+
     data.is_inside_window = inside;
     data.is_touch = 0;
 }
@@ -99,28 +109,38 @@ static void update_button_state(mouse_button* button) {
 }
 
 void mouse_determine_button_state() {
+    auto &data = g_mouse;
+
     update_button_state(&data.left);
     update_button_state(&data.middle);
     update_button_state(&data.right);
 }
 
 void mouse_set_scroll(int state) {
+    auto &data = g_mouse;
+
     data.scrolled = state;
     data.is_touch = 0;
     data.is_inside_window = 1;
 }
 
-void mouse_reset_scroll(void) {
+void mouse_reset_scroll() {
+    auto &data = g_mouse;
+
     data.scrolled = SCROLL_NONE;
 }
 
-void mouse_reset_up_state(void) {
+void mouse_reset_up_state() {
+    auto &data = g_mouse;
+
     data.left.went_up = 0;
     data.middle.went_up = 0;
     data.right.went_up = 0;
 }
 
 void mouse_reset_button_state(void) {
+    auto &data = g_mouse;
+
     last_click = 0;
     clear_mouse_button(&data.left);
     clear_mouse_button(&data.middle);

src/platform/mouse.cpp

@@ -20,6 +20,7 @@ void system_mouse_set_relative_mode(int enabled) {
     auto &data = g_mouse_data;
     if (enabled == data.enabled)
         return;
+
     if (enabled) {
         SDL_GetMouseState(&data.x, &data.y);
         SDL_SetRelativeMouseMode(SDL_TRUE);

src/window/window_building_info.cpp

@@ -81,11 +81,8 @@ struct building_info_data {
     int image_button_id = 0;
     int generic_button_id = 0;
     int debug_path_button_id = 0;
-    int overlay_button_id = 0;
 
-    generic_button generic_button_layer[1] = {
-        {375, 3, 24, 24, button_overlay, button_none, 0, 0}
-    };
+    std::vector<generic_button> btns;
 
     generic_button generic_button_figures[1] = {
         {400, 3, 24, 24, button_debugpath, button_none, 0, 0}
@@ -579,12 +576,18 @@ static void draw_mothball_button(int x, int y, int focused) {
     }
 }
 
-static void draw_overlay_button(int x, int y, int focused) {
+template<class Func>
+static void make_button(pcstr label, vec2i pos, vec2i size, Func func) {
     auto &context = g_building_info_context;
-    button_border_draw(x, y, 20, 20, focused ? 1 : 0);
+    auto &data = g_building_info;
+
+    data.btns.push_back({pos.x, pos.y, size.x + 4, size.y + 4, button_none, button_none, 0, 0, func});
+    int focused = is_button_hover(data.btns.back(), context.offset);
+
+    button_border_draw(context.offset.x + pos.x, context.offset.y + pos.y, size.x, size.y, focused ? 1 : 0);
 
     if (context.show_overlay != OVERLAY_NONE) {
-        text_draw_centered((uint8_t *)(game_state_overlay() != context.show_overlay ? "V" : "v"), x + 1, y + 4, 20, FONT_NORMAL_BLACK_ON_LIGHT, 0);
+        text_draw_centered((uint8_t *)label, context.offset.x + pos.x + 1, context.offset.y + pos.y + 4, 20, FONT_NORMAL_BLACK_ON_LIGHT, 0);
     }
 }
 
@@ -770,6 +773,10 @@ static void draw_background() {
 
 static void draw_foreground() {
     auto &context = g_building_info_context;
+    auto &data = g_building_info;
+
+    data.btns.clear();
+
     // building-specific buttons
     if (context.type == BUILDING_INFO_BUILDING) {
         building *b = building_get(context.building_id);
@@ -852,8 +859,17 @@ static void draw_foreground() {
     }
 
     if (context.show_overlay != OVERLAY_NONE) {
-        draw_overlay_button(context.offset.x + 375, context.offset.y + 3 + 16 * context.height_blocks - 40, g_building_info.overlay_button_id);
+        pcstr label = (game_state_overlay() != context.show_overlay ? "v" : "V");
+        make_button(label, {375, 3 + 16 * context.height_blocks - 40}, {20, 20}, [&context] (int, int) {
+            if (game_state_overlay() != context.show_overlay) {
+                game_state_set_overlay((e_overlay)context.show_overlay);
+            } else {
+                game_state_reset_overlay();
+            }
+            window_invalidate();
+        });
     }
+
 }
 
 static int handle_specific_building_info_mouse(const mouse *m) {
@@ -917,6 +933,8 @@ static int handle_specific_building_info_mouse(const mouse *m) {
 
 static void handle_input(const mouse* m, const hotkeys* h) {
     auto &context = g_building_info_context;
+    auto &data = g_building_info;
+
     bool button_id = 0;
     int tmp_btn_id;
     // general buttons
@@ -951,9 +969,8 @@ static void handle_input(const mouse* m, const hotkeys* h) {
                                                   g_building_info.generic_button_figures, g_building_info.debug_path_button_id);
     }
 
-    if (context.show_overlay != OVERLAY_NONE) {
-        button_id |= generic_buttons_handle_mouse(m, context.offset + vec2i(0, 16 * context.height_blocks - 40), g_building_info.generic_button_layer, g_building_info.overlay_button_id);
-    }
+    int tmp_btn;
+    button_id |= generic_buttons_handle_mouse(m, context.offset, data.btns, tmp_btn);
 
     if (!button_id && input_go_back_requested(m, h)) {
         if (context.storage_show_special_orders) {
@@ -1006,16 +1023,6 @@ static void button_debugpath(int debug, int param2) {
     window_invalidate();
 }
 
-static void button_overlay(int debug, int param2) {
-    auto &context = g_building_info_context;
-    if (game_state_overlay() != context.show_overlay) {
-        game_state_set_overlay((e_overlay)context.show_overlay);
-    } else {
-        game_state_reset_overlay();
-    }
-    window_invalidate();
-}
-
 void window_building_info_show(const map_point& point) {
     window_type window = {
         WINDOW_BUILDING_INFO,