Better Button:click + don't react to mouse up if downed on another frame

Author: cschreib

include/lxgui/gui_button.hpp

@@ -310,6 +310,21 @@ class button : public frame {
      */
     virtual void release();
 
+    /**
+     * \brief Handle a mouse click over this button.
+     * \param mouse_event The mouse event with which to generate a click
+     * \note This calls the OnClick() handler only if the event is registered for clicks.
+     */
+    void click(const std::string& mouse_event);
+
+    /**
+     * \brief Handle a mouse click over this button.
+     * \param button_id The mouse button with which to generate a click
+     * \param button_event The mouse button event with which to generate a click
+     * \note This calls the OnClick() handler only if the event is registered for clicks.
+     */
+    void click(input::mouse_button button_id, input::mouse_button_event button_event);
+
     /**
      * \brief Highlights this button.
      * \note The button will be highlighted even if the
@@ -456,6 +471,11 @@ class button : public frame {
     void parse_attributes_(const layout_node& node) override;
     void parse_all_nodes_before_children_(const layout_node& node) override;
 
+    bool is_button_clicks_enabled_(input::mouse_button button_id) const;
+
+    virtual void click_(
+        input::mouse_button button_id, input::mouse_button_event button_event, float mx, float my);
+
     const std::vector<std::string>& get_type_list_() const override;
 
     state state_               = state::up;

include/lxgui/input_keys.hpp

@@ -4,6 +4,7 @@
 #include "lxgui/lxgui.hpp"
 
 #include <cstdint>
+#include <optional>
 #include <string_view>
 
 namespace lxgui::input {
@@ -164,6 +165,7 @@ enum class key : std::uint8_t {
 /**
  * \brief Returns a standard English name for the provided mouse button.
  * \param button_id The ID code of the mouse button
+ * \return The corresponding code name in English
  * \note This will return a standard English button name, e.g., "LeftButton" for the left mouse
  * button. This can be used for string-based key identification in scripts, where key
  * integer codes would be less usable, or for displaying debug or error messages.
@@ -182,6 +184,7 @@ std::string_view get_localizable_mouse_button_name(mouse_button button_id);
 /**
  * \brief Returns a standard English name for the provided mouse button event.
  * \param button_event The ID code of the mouse button event
+ * \return The corresponding code name in English
  * \note This will return a standard English button name, e.g., "Up" for the mouse up event.
  * This can be used for string-based key identification in scripts, where key
  * integer codes would be less usable, or for displaying debug or error messages.
@@ -197,6 +200,26 @@ std::string_view get_mouse_button_event_codename(mouse_button_event button_event
  */
 std::string_view get_localizable_mouse_button_event_name(mouse_button_event button_event);
 
+/**
+ * \brief Returns a standard Engilsh name for the provided mouse button and event.
+ * \param button_id The ID code of the mouse button
+ * \param button_event The ID code of the mouse button event
+ * \return The corresponding code name in English
+ * \note This will return a string with the format "<button>:<event>".
+ * \see get_mouse_button_codename()
+ * \see get_mouse_button_event_codename()
+ */
+std::string_view
+get_mouse_button_and_event_codename(mouse_button button_id, mouse_button_event button_event);
+
+/**
+ * \brief Returns a mouse button and a button event ID from a string formatted as "<button>:<event>".
+ * \param event_name The name of the mouse button event, as "<button>:<event>"
+ * \return The pair of decoded button and event ID, or std::nullopt if parsing failed.
+ */
+std::optional<std::pair<mouse_button, mouse_button_event>>
+get_mouse_button_and_event_from_codename(std::string_view button_and_event_name);
+
 /**
  * \brief Returns a standard English name for the provided key.
  * \param key_id The key

src/gui_button.cpp

@@ -34,46 +34,52 @@ void button::fire_script(const std::string& script_name, const event_data& data)
     if (!checker.is_alive())
         return;
 
-    if (is_enabled()) {
-        if (script_name == "OnEnter")
-            highlight();
+    if (!is_enabled())
+        return;
 
-        if (script_name == "OnLeave") {
-            unlight();
+    if (script_name == "OnEnter")
+        highlight();
 
-            if (state_ == state::down)
-                release();
+    if (script_name == "OnLeave") {
+        unlight();
+
+        if (state_ == state::down)
+            release();
+    }
+
+    bool try_handle_click = false;
+    if (script_name == "OnMouseDown" || script_name == "OnMouseUp" ||
+        script_name == "OnDoubleClick") {
+
+        try_handle_click = true;
+
+        // If reacting to a "mouse up" event, only handle as a click if
+        // the mouse was pressed down on this button.
+        if (script_name == "OnMouseUp" && !data.get<bool>(5)) {
+            try_handle_click = false;
         }
+    }
 
-        if (script_name == "OnMouseDown" || script_name == "OnMouseUp" ||
-            script_name == "OnDoubleClick") {
-
-            const input::mouse_button_event event_id =
-                script_name == "OnMouseDown" ? input::mouse_button_event::down
-                : script_name == "OnMouseUp" ? input::mouse_button_event::up
-                                             : input::mouse_button_event::double_click;
-
-            const auto event_name = data.get<std::string>(1) +
-                                    std::string{input::get_mouse_button_event_codename(event_id)};
-
-            if (is_button_clicks_enabled(event_name)) {
-                if (event_id == input::mouse_button_event::down)
-                    push();
-                else if (event_id == input::mouse_button_event::up)
-                    release();
-
-                event_data new_data;
-                new_data.add(data.get(0)); // Mouse button ID
-                new_data.add(static_cast<std::underlying_type_t<input::mouse_button_event>>(
-                    event_id)); // Mouse button event
-                new_data.add(event_name); // Mouse button event name
-                new_data.add(data.get(2)); // Mouse pos X
-                new_data.add(data.get(3)); // Mouse pos Y
-                fire_script("OnClick", new_data);
-                if (!checker.is_alive())
-                    return;
-            }
+    if (try_handle_click) {
+        const input::mouse_button       button_id = data.get<input::mouse_button>(0);
+        const input::mouse_button_event event_id =
+            script_name == "OnMouseDown" ? input::mouse_button_event::down
+            : script_name == "OnMouseUp" ? input::mouse_button_event::up
+                                         : input::mouse_button_event::double_click;
+
+        if (is_button_clicks_enabled_(button_id)) {
+            if (event_id == input::mouse_button_event::down)
+                push();
+            else if (event_id == input::mouse_button_event::up)
+                release();
         }
+
+        float mx = data.get<float>(2);
+        float my = data.get<float>(3);
+
+        click_(button_id, event_id, mx, my);
+        if (!checker.is_alive())
+            return;
     }
 }
 
@@ -389,6 +395,39 @@ void button::release() {
     state_ = state::up;
 }
 
+void button::click(const std::string& mouse_event) {
+    auto mouse_event_id = input::get_mouse_button_and_event_from_codename(mouse_event);
+    if (!mouse_event_id.has_value()) {
+        return;
+    }
+
+    click(mouse_event_id.value().first, mouse_event_id.value().second);
+}
+
+void button::click(input::mouse_button button_id, input::mouse_button_event button_event) {
+    vector2f center = get_center();
+    click_(button_id, button_event, center.x, center.y);
+}
+
+void button::click_(
+    input::mouse_button button_id, input::mouse_button_event button_event, float mx, float my) {
+
+    if (!is_button_clicks_enabled(button_id, button_event)) {
+        return;
+    }
+
+    std::string event_name =
+        std::string{input::get_mouse_button_and_event_codename(button_id, button_event)};
+
+    event_data new_data;
+    new_data.add(static_cast<std::underlying_type_t<input::mouse_button>>(button_id));
+    new_data.add(static_cast<std::underlying_type_t<input::mouse_button_event>>(button_event));
+    new_data.add(event_name);
+    new_data.add(mx);
+    new_data.add(my);
+    fire_script("OnClick", new_data);
+}
+
 void button::highlight() {
     if (is_highlighted_)
         return;
@@ -464,8 +503,7 @@ void button::enable_button_clicks(const std::string& mouse_state) {
 void button::enable_button_clicks(
     input::mouse_button button_id, input::mouse_button_event button_event) {
     reg_click_list_.insert(
-        std::string{input::get_mouse_button_codename(button_id)} +
-        std::string{input::get_mouse_button_event_codename(button_event)});
+        std::string{input::get_mouse_button_and_event_codename(button_id, button_event)});
 }
 
 void button::disable_button_clicks(const std::string& mouse_state) {
@@ -475,8 +513,7 @@ void button::disable_button_clicks(const std::string& mouse_state) {
 void button::disable_button_clicks(
     input::mouse_button button_id, input::mouse_button_event button_event) {
     reg_click_list_.erase(
-        std::string{input::get_mouse_button_codename(button_id)} +
-        std::string{input::get_mouse_button_event_codename(button_event)});
+        std::string{input::get_mouse_button_and_event_codename(button_id, button_event)});
 }
 
 void button::disable_button_clicks() {
@@ -489,10 +526,19 @@ bool button::is_button_clicks_enabled(const std::string& mouse_event) const {
 
 bool button::is_button_clicks_enabled(
     input::mouse_button button_id, input::mouse_button_event button_event) const {
-    return reg_click_list_.find(
-               std::string{input::get_mouse_button_codename(button_id)} +
-               std::string{input::get_mouse_button_event_codename(button_event)}) !=
-           reg_click_list_.end();
+    return reg_click_list_.find(std::string{input::get_mouse_button_and_event_codename(
+               button_id, button_event)}) != reg_click_list_.end();
+}
+
+bool button::is_button_clicks_enabled_(input::mouse_button button_id) const {
+    auto button_name = input::get_mouse_button_codename(button_id);
+    for (const auto& click : reg_click_list_) {
+        if (click.find(button_name) == 0) {
+            return true;
+        }
+    }
+
+    return false;
 }
 
 const std::vector<std::string>& button::get_type_list_() const {

src/gui_button_glues.cpp

@@ -58,7 +58,9 @@ void button::register_on_lua(sol::state& lua) {
 
     /** @function click
      */
-    type.set_function("click", [](button& self) { self.fire_script("OnClick"); });
+    type.set_function(
+        "click", member_function< // select the right overload for Lua
+                     static_cast<void (button::*)(const std::string&)>(&button::click)>());
 
     /** @function disable
      */

src/input_keys.cpp

@@ -1,5 +1,7 @@
 #include "lxgui/input_keys.hpp"
 
+#include "lxgui/utils_string.hpp"
+
 namespace lxgui::input {
 
 std::string_view get_mouse_button_codename(mouse_button button_id) {
@@ -38,6 +40,53 @@ std::string_view get_localizable_mouse_button_event_name(mouse_button_event butt
     }
 }
 
+std::string_view
+get_mouse_button_and_event_codename(mouse_button button_id, mouse_button_event button_event) {
+    switch (button_id) {
+    case mouse_button::left:
+        switch (button_event) {
+        case mouse_button_event::up: return "LeftButton:Up";
+        case mouse_button_event::down: return "LeftButton:Down";
+        case mouse_button_event::double_click: return "LeftButton:DoubleClick";
+        default: return "";
+        }
+    case mouse_button::right:
+        switch (button_event) {
+        case mouse_button_event::up: return "RightButton:Up";
+        case mouse_button_event::down: return "RightButton:Down";
+        case mouse_button_event::double_click: return "RightButton:DoubleClick";
+        default: return "";
+        };
+    case mouse_button::middle:
+        switch (button_event) {
+        case mouse_button_event::up: return "MiddleButton:Up";
+        case mouse_button_event::down: return "MiddleButton:Down";
+        case mouse_button_event::double_click: return "MiddleButton:DoubleClick";
+        default: return "";
+        };
+    default: return "";
+    }
+}
+
+std::optional<std::pair<mouse_button, mouse_button_event>>
+get_mouse_button_and_event_from_codename(std::string_view button_and_event_name) {
+    const auto pos = button_and_event_name.find_first_of(':');
+    if (pos == std::string_view::npos)
+        return {};
+
+    auto button_name = button_and_event_name.substr(0, pos);
+    auto event_name  = button_and_event_name.substr(pos + 1);
+
+    auto button_id = utils::from_string<mouse_button>(button_name);
+    auto event_id  = utils::from_string<mouse_button_event>(event_name);
+
+    if (!button_id.has_value() || !event_id.has_value()) {
+        return {};
+    }
+
+    return std::make_pair(button_id.value(), event_id.value());
+}
+
 std::string_view get_key_codename(key key_id) {
     switch (key_id) {
     case key::k_escape: return "Escape";