Signal.hpp

 
//
// TGUI - Texus' Graphical User Interface
// Copyright (C) 2012-2020 Bruno Van de Velde (vdv_b@tgui.eu)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it freely,
// subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented;
// you must not claim that you wrote the original software.
// If you use this software in a product, an acknowledgment
// in the product documentation would be appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such,
// and must not be misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source distribution.
//
 
 
#ifndef TGUI_SIGNAL_HPP
#define TGUI_SIGNAL_HPP
 
 
#include <TGUI/Global.hpp>
#include <TGUI/Vector2f.hpp>
#include <TGUI/Animation.hpp>
#include <TGUI/Color.hpp>
#include <SFML/System/String.hpp>
#include <type_traits>
#include <functional>
#include <typeindex>
#include <memory>
#include <vector>
#include <deque>
#include <map>
 
#undef MessageBox // windows.h defines MessageBox when NOMB isn't defined before including windows.h
 
 
namespace tgui
{
 class Widget;
 class ChildWindow;
 class SignalWidgetBase;
 
 namespace internal_signal
 {
 extern TGUI_API std::deque<const void*> parameters;
 }
 
 namespace Signals
 {
 struct Widget
 {
 static constexpr const char* const PositionChanged = "PositionChanged"; 
 static constexpr const char* const SizeChanged = "SizeChanged"; 
 static constexpr const char* const Focused = "Focused"; 
 static constexpr const char* const Unfocused = "Unfocused"; 
 static constexpr const char* const MouseEntered = "MouseEntered"; 
 static constexpr const char* const MouseLeft = "MouseLeft"; 
 static constexpr const char* const AnimationFinished = "AnimationFinished"; 
 };
 
 struct ClickableWidget : public Widget
 {
 static constexpr const char* const MousePressed = "MousePressed"; 
 static constexpr const char* const MouseReleased = "MouseReleased"; 
 static constexpr const char* const Clicked = "Clicked"; 
 static constexpr const char* const RightMousePressed = "RightMousePressed"; 
 static constexpr const char* const RightMouseReleased = "RightMouseReleased"; 
 static constexpr const char* const RightClicked = "RightClicked"; 
 };
 
 struct Button : public ClickableWidget
 {
 static constexpr const char* const Pressed = "Pressed"; 
 };
 
 struct ChildWindow : public Widget
 {
 static constexpr const char* const MousePressed = "MousePressed"; 
 static constexpr const char* const Closed = "Closed"; 
 static constexpr const char* const Minimized = "Minimized"; 
 static constexpr const char* const Maximized = "Maximized"; 
 static constexpr const char* const EscapeKeyPressed = "EscapeKeyPressed"; 
 };
 
 struct ColorPicker : public ChildWindow
 {
 static constexpr const char* const ColorChange = "ColorChanged"; 
 static constexpr const char* const OkPressed = "OkPressed"; 
 };
 
 struct ComboBox : public Widget
 {
 static constexpr const char* const ItemSelected = "ItemSelected"; 
 };
 
 struct EditBox : public ClickableWidget
 {
 static constexpr const char* const TextChanged = "TextChanged"; 
 static constexpr const char* const ReturnKeyPressed = "ReturnKeyPressed"; 
 };
 
 struct Knob : public Widget
 {
 static constexpr const char* const ValueChanged = "ValueChanged"; 
 };
 
 struct Label : public ClickableWidget
 {
 static constexpr const char* const DoubleClicked = "DoubleClicked"; 
 };
 
 struct ListBox : public Widget
 {
 static constexpr const char* const ItemSelected = "ItemSelected"; 
 static constexpr const char* const MousePressed = "MousePressed"; 
 static constexpr const char* const MouseReleased = "MouseReleased"; 
 static constexpr const char* const DoubleClicked = "DoubleClicked"; 
 };
 
 struct ListView : public Widget
 {
 static constexpr const char* const ItemSelected = "ItemSelected"; 
 static constexpr const char* const DoubleClicked = "DoubleClicked"; 
 static constexpr const char* const RightClicked = "RightClicked"; 
 static constexpr const char* const HeaderClicked = "HeaderClicked"; 
 };
 
 struct MenuBar : public Widget
 {
 static constexpr const char* const MenuItemClicked = "MenuItemClicked";
 };
 
 struct MessageBox : public ChildWindow
 {
 static constexpr const char* const ButtonPressed = "ButtonPressed"; 
 };
 
 struct Panel : public Widget
 {
 static constexpr const char* const MousePressed = "MousePressed"; 
 static constexpr const char* const MouseReleased = "MouseReleased"; 
 static constexpr const char* const Clicked = "Clicked"; 
 static constexpr const char* const RightMousePressed = "RightMousePressed"; 
 static constexpr const char* const RightMouseReleased = "RightMouseReleased"; 
 static constexpr const char* const RightClicked = "RightClicked"; 
 };
 
 struct Picture : public ClickableWidget
 {
 static constexpr const char* const DoubleClicked = "DoubleClicked"; 
 };
 
 struct ProgressBar : public ClickableWidget
 {
 static constexpr const char* const ValueChanged = "ValueChanged"; 
 static constexpr const char* const Full = "Full"; 
 };
 
 struct RadioButton : public ClickableWidget
 {
 static constexpr const char* const Checked = "Checked"; 
 static constexpr const char* const Unchecked = "Unchecked"; 
 static constexpr const char* const Changed = "Changed"; 
 };
 
 struct RangeSlider : public Widget
 {
 static constexpr const char* const RangeChanged = "RangeChanged"; 
 };
 
 struct Scrollbar : public Widget
 {
 static constexpr const char* const ValueChanged = "ValueChanged"; 
 };
 
 struct Slider : public Widget
 {
 static constexpr const char* const ValueChanged = "ValueChanged"; 
 };
 
 struct SpinButton : public ClickableWidget
 {
 static constexpr const char* const ValueChanged = "ValueChanged"; 
 };
 
 struct Tabs : public Widget
 {
 static constexpr const char* const TabSelected = "TabSelected"; 
 };
 
 struct TextBox : public Widget
 {
 static constexpr const char* const TextChanged = "TextChanged"; 
 static constexpr const char* const SelectionChanged = "SelectionChanged"; 
 };
 
 struct TreeView : public Widget
 {
 static constexpr const char* const ItemSelected = "ItemSelected"; 
 static constexpr const char* const DoubleClicked = "DoubleClicked"; 
 static constexpr const char* const Expanded = "Expanded"; 
 static constexpr const char* const Collapsed = "Collapsed"; 
 static constexpr const char* const RightClicked = "RightClicked"; 
 };
 
 using BitmapButton = Button;
 using CheckBox = RadioButton;
 using ScrollablePanel = Panel;
 }
 
 class TGUI_API Signal
 {
 public:
 
 using Delegate = std::function<void()>;
 using DelegateEx = std::function<void(std::shared_ptr<Widget>, const std::string&)>;
 
 
 virtual ~Signal() = default;
 
 
 Signal(std::string&& name, std::size_t extraParameters = 0) :
 m_name{std::move(name)}
 {
 if (1 + extraParameters > internal_signal::parameters.size())
 internal_signal::parameters.resize(1 + extraParameters);
 }
 
 
 Signal(const Signal& other);
 
 
 Signal(Signal&& other) noexcept = default;
 
 
 Signal& operator=(const Signal& other);
 
 
 Signal& operator=(Signal&& other) noexcept = default;
 
 
 unsigned int connect(const Delegate& handler);
 
 
 unsigned int connect(const DelegateEx& handler);
 
 
 bool disconnect(unsigned int id);
 
 
 void disconnectAll();
 
 
 bool emit(const Widget* widget)
 {
 if (m_handlers.empty() || !m_enabled)
 return false;
 
 internal_signal::parameters[0] = static_cast<const void*>(&widget);
 
 // Copy the handlers before calling them in case the widget (and this signal) gets destroyed during the handler
 auto handlers = m_handlers;
 for (auto& handler : handlers)
 handler.second();
 
 return true;
 }
 
 
 std::string getName() const
 {
 return m_name;
 }
 
 
 void setEnabled(bool enabled)
 {
 m_enabled = enabled;
 }
 
 
 bool isEnabled() const
 {
 return m_enabled;
 }
 
 
 virtual unsigned int validateTypes(std::initializer_list<std::type_index> unboundParameters) const;
 
 
 protected:
 
 static std::shared_ptr<Widget> getWidget();
 
 
 protected:
 
 bool m_enabled = true;
 std::string m_name;
 std::map<unsigned int, std::function<void()>> m_handlers;
 };
 
 #define TGUI_SIGNAL_VALUE_DECLARATION(TypeName, Type) \
 /**************************************************************************************************************************** \
 * @brief Signal to which the user can subscribe to get callbacks from
 ****************************************************************************************************************************/ \
 class TGUI_API Signal##TypeName : public Signal \
 { \
 public: \
 using Delegate##TypeName = std::function<void(Type)>; \
 using Delegate##TypeName##Ex = std::function<void(std::shared_ptr<Widget>, const std::string&, Type)>; \
 using Signal::connect; \
 \
 /************************************************************************************************************************ \
 * @brief Constructor
 ************************************************************************************************************************/ \
 Signal##TypeName(std::string&& name) : \
 Signal{std::move(name), 1} \
 { \
 } \
 \
 /************************************************************************************************************************ \
 * @brief Connects a signal handler that will be called when this signal is emitted
 *
 * @param handler Callback function that is given a Vector2f as argument
 *
 * @return Unique id of the connection
 ************************************************************************************************************************/ \
 unsigned int connect(const Delegate##TypeName& handler); \
 \
 /************************************************************************************************************************ \
 * @brief Connects a signal handler that will be called when this signal is emitted
 *
 * @param handler Callback function that is given a pointer to the widget, the name of the signal and a Vector2f as arguments
 *
 * @return Unique id of the connection
 ************************************************************************************************************************/ \
 unsigned int connect(const Delegate##TypeName##Ex& handler); \
 \
 /************************************************************************************************************************ \
 * @internal
 * @brief Call all connected signal handlers
 ************************************************************************************************************************/ \
 bool emit(const Widget* widget, Type param) \
 { \
 if (m_handlers.empty()) \
 return false; \
 \
 internal_signal::parameters[1] = static_cast<const void*>(&param); \
 return Signal::emit(widget); \
 } \
 \
 private: \
 /************************************************************************************************************************ \
 * @internal
 * @brief Checks whether the unbound parameters match with this signal
 * @return The index in the parameters list where the parameters will be stored
 ************************************************************************************************************************/ \
 unsigned int validateTypes(std::initializer_list<std::type_index> unboundParameters) const override; \
 };
 
 TGUI_SIGNAL_VALUE_DECLARATION(Int, int)
 TGUI_SIGNAL_VALUE_DECLARATION(UInt, unsigned int)
 TGUI_SIGNAL_VALUE_DECLARATION(Bool, bool)
 TGUI_SIGNAL_VALUE_DECLARATION(Float, float)
 TGUI_SIGNAL_VALUE_DECLARATION(String, const sf::String&)
 TGUI_SIGNAL_VALUE_DECLARATION(Vector2f, Vector2f)
 TGUI_SIGNAL_VALUE_DECLARATION(Color, Color)
 
 
 
 class TGUI_API SignalRange : public Signal
 {
 public:
 
 using DelegateRange = std::function<void(float, float)>;
 using DelegateRangeEx = std::function<void(std::shared_ptr<Widget>, const std::string&, float, float)>;
 using Signal::connect;
 
 SignalRange(std::string&& name) :
 Signal{std::move(name), 2}
 {
 }
 
 
 unsigned int connect(const DelegateRange& handler);
 
 
 unsigned int connect(const DelegateRangeEx& handler);
 
 
 bool emit(const Widget* widget, float value1, float value2);
 
 
 private:
 
 unsigned int validateTypes(std::initializer_list<std::type_index> unboundParameters) const override;
 
 
 };
 
 
 class TGUI_API SignalChildWindow : public Signal
 {
 public:
 
 using DelegateChildWindow = std::function<void(std::shared_ptr<ChildWindow>)>;
 using DelegateChildWindowEx = std::function<void(std::shared_ptr<Widget>, const std::string&, std::shared_ptr<ChildWindow>)>;
 using Signal::connect;
 
 
 SignalChildWindow(std::string&& name) :
 Signal{std::move(name), 1}
 {
 }
 
 
 unsigned int connect(const DelegateChildWindow& handler);
 
 
 unsigned int connect(const DelegateChildWindowEx& handler);
 
 
 bool emit(ChildWindow* param);
 
 
 private:
 
 unsigned int validateTypes(std::initializer_list<std::type_index> unboundParameters) const override;
 
 
 };
 
 
 class TGUI_API SignalItem : public Signal
 {
 public:
 
 using DelegateItem = std::function<void(const sf::String&)>;
 using DelegateItemAndId = std::function<void(const sf::String&, const sf::String&)>;
 using DelegateItemIndex = std::function<void(int)>;
 using DelegateItemEx = std::function<void(std::shared_ptr<Widget>, const std::string&, const sf::String&)>;
 using DelegateItemAndIdEx = std::function<void(std::shared_ptr<Widget>, const std::string&, const sf::String&, const sf::String&)>;
 using DelegateItemIndexEx = std::function<void(std::shared_ptr<Widget>, const std::string&, int)>;
 using Signal::connect;
 
 
 SignalItem(std::string&& name) :
 Signal{std::move(name), 3}
 {
 }
 
 
 unsigned int connect(const DelegateItem& handler);
 
 
 unsigned int connect(const DelegateItemEx& handler);
 
 
 unsigned int connect(const DelegateItemAndId& handler);
 
 
 unsigned int connect(const DelegateItemAndIdEx& handler);
 
 
 unsigned int connect(const DelegateItemIndex& handler);
 
 
 unsigned int connect(const DelegateItemIndexEx& handler);
 
 
 bool emit(const Widget* widget, const sf::String& item, const sf::String& id, int index)
 {
 if (m_handlers.empty())
 return false;
 
 internal_signal::parameters[1] = static_cast<const void*>(&item);
 internal_signal::parameters[2] = static_cast<const void*>(&id);
 internal_signal::parameters[3] = static_cast<const void*>(&index);
 return Signal::emit(widget);
 }
 
 
 private:
 
 unsigned int validateTypes(std::initializer_list<std::type_index> unboundParameters) const override;
 
 
 };
 
 
 class TGUI_API SignalAnimation : public Signal
 {
 public:
 
 SignalAnimation(std::string&& name) :
 Signal{std::move(name), 2}
 {
 }
 
 bool emit(const Widget* widget, ShowAnimationType type, bool visible)
 {
 if (m_handlers.empty())
 return false;
 
 internal_signal::parameters[1] = static_cast<const void*>(&type);
 internal_signal::parameters[2] = static_cast<const void*>(&visible);
 return Signal::emit(widget);
 }
 
 
 private:
 
 unsigned int validateTypes(std::initializer_list<std::type_index> unboundParameters) const override;
 
 
 };
 
 
 class TGUI_API SignalItemHierarchy : public Signal
 {
 public:
 
 using DelegateMenuItem = std::function<void(const sf::String&)>;
 using DelegateMenuItemFull = std::function<void(const std::vector<sf::String>&)>;
 using DelegateMenuItemEx = std::function<void(std::shared_ptr<Widget>, const std::string&, const sf::String&)>;
 using DelegateMenuItemFullEx = std::function<void(std::shared_ptr<Widget>, const std::string&, const std::vector<sf::String>&)>;
 using Signal::connect;
 
 
 SignalItemHierarchy(std::string&& name) :
 Signal{std::move(name), 2}
 {
 }
 
 
 unsigned int connect(const DelegateMenuItem& handler);
 
 
 unsigned int connect(const DelegateMenuItemEx& handler);
 
 
 unsigned int connect(const DelegateMenuItemFull& handler);
 
 
 unsigned int connect(const DelegateMenuItemFullEx& handler);
 
 
 bool emit(const Widget* widget, const sf::String& item, const std::vector<sf::String>& fullItem)
 {
 if (m_handlers.empty())
 return false;
 
 internal_signal::parameters[1] = static_cast<const void*>(&item);
 internal_signal::parameters[2] = static_cast<const void*>(&fullItem);
 return Signal::emit(widget);
 }
 
 
 private:
 
 unsigned int validateTypes(std::initializer_list<std::type_index> unboundParameters) const override;
 
 
 };
 
#ifndef TGUI_REMOVE_DEPRECATED_CODE
 using SignalMenuItem = SignalItemHierarchy;
#endif
 
 
 class TGUI_API SignalWidgetBase
 {
 public:
 
 virtual ~SignalWidgetBase() = default;
 
#if defined(__cpp_if_constexpr) && (__cpp_if_constexpr >= 201606L)
 template <typename Func, typename... BoundArgs>
 unsigned int connect(std::string signalName, Func&& handler, const BoundArgs&... args);
 
#else
 template <typename Func, typename... Args, typename std::enable_if<std::is_convertible<Func, std::function<void(const Args&...)>>::value>::type* = nullptr>
 unsigned int connect(std::string signalName, Func&& handler, const Args&... args);
 
 
 template <typename Func, typename... BoundArgs, typename std::enable_if<!std::is_convertible<Func, std::function<void(const BoundArgs&...)>>::value // Ambigious otherwise when passing bind expression
 && std::is_convertible<Func, std::function<void(const BoundArgs&..., std::shared_ptr<Widget>, const std::string&)>>::value>::type* = nullptr>
 unsigned int connect(std::string signalName, Func&& handler, BoundArgs&&... args);
 
 
 template <typename Func, typename... BoundArgs, typename std::enable_if<!std::is_convertible<Func, std::function<void(const BoundArgs&...)>>::value
 && !std::is_convertible<Func, std::function<void(const BoundArgs&..., std::shared_ptr<Widget>, const std::string&)>>::value>::type* = nullptr>
 unsigned int connect(std::string signalName, Func&& handler, BoundArgs&&... args);
#endif
 
 template <typename Func, typename... BoundArgs>
 unsigned int connect(std::initializer_list<std::string> signalNames, Func&& handler, BoundArgs&&... args);
 
 
 bool disconnect(unsigned int id);
 
 
 void disconnectAll(std::string signalName);
 
 
 void disconnectAll();
 
 
 virtual Signal& getSignal(std::string signalName) = 0;
 
 
 private:
 
 std::map<unsigned int, std::string> m_connectedSignals;
 
 
 };
 
}
 
 
#endif // TGUI_SIGNAL_HPP