toggle_delegate.hpp

 
 
#pragma once
 
#include "../dispatch/dispatch.hpp"
#include "../observer/observer.hpp"
#include "../GUI/GUI.hpp"
#include "../utility/utility.hpp"
 
hi_export_module(hikogui.widgets.toggle_delegate);
 
hi_export namespace hi {
inline namespace v1 {
 
class toggle_delegate {
public:
    virtual ~toggle_delegate() = default;
 
    virtual void init(widget_intf const& sender) noexcept {}
 
    virtual void deinit(widget_intf const& sender) noexcept {}
 
    virtual void activate(widget_intf const& sender) noexcept {}
 
    [[nodiscard]] virtual widget_value state(widget_intf const& sender) const noexcept
    {
        return widget_value::off;
    }
 
    template<forward_of<void()> Func>
    [[nodiscard]] callback<void()> subscribe(Func&& func, callback_flags flags = callback_flags::synchronous) noexcept
    {
        return _notifier.subscribe(std::forward<Func>(func), flags);
    }
 
protected:
    notifier<void()> _notifier;
};
 
template<std::equality_comparable T>
class default_toggle_delegate : public toggle_delegate {
public:
    using value_type = T;
    constexpr static bool can_make_defaults =
        std::is_same_v<value_type, bool> or std::is_integral_v<value_type> or std::is_enum_v<value_type>;
 
    observer<value_type> value;
    observer<value_type> on_value;
    observer<value_type> off_value;
 
    template<
        forward_of<observer<value_type>> Value,
        forward_of<observer<value_type>> OnValue,
        forward_of<observer<value_type>> OffValue>
    default_toggle_delegate(Value&& value, OnValue&& on_value, OffValue&& off_value) noexcept :
        value(std::forward<Value>(value)), on_value(std::forward<OnValue>(on_value)), off_value(std::forward<OffValue>(off_value))
    {
        // clang-format off
        _value_cbt = this->value.subscribe([&](auto...){ this->_notifier(); });
        _on_value_cbt = this->on_value.subscribe([&](auto...){ this->_notifier(); });
        _off_value_cbt = this->off_value.subscribe([&](auto...){ this->_notifier(); });
        // clang-format on
    }
 
    template<forward_of<observer<value_type>> Value, forward_of<observer<value_type>> OnValue>
    default_toggle_delegate(
        Value&& value,
        OnValue&& on_value) noexcept requires can_make_defaults
        : default_toggle_delegate(std::forward<Value>(value), std::forward<OnValue>(on_value), value_type{})
    {
    }
 
    template<forward_of<observer<value_type>> Value>
    default_toggle_delegate(Value&& value) noexcept requires can_make_defaults
        : default_toggle_delegate(std::forward<Value>(value), value_type{1}, value_type{})
    {
    }
 
    [[nodiscard]] widget_value state(widget_intf const& sender) const noexcept override
    {
        if (*value == *on_value) {
            return widget_value::on;
        } else if (*value == *off_value) {
            return widget_value::off;
        } else {
            return widget_value::other;
        }
    }
 
    void activate(widget_intf const& sender) noexcept override
    {
        if (*value == *off_value) {
            value = *on_value;
        } else {
            value = *off_value;
        }
    }
private:
    callback<void(value_type)> _value_cbt;
    callback<void(value_type)> _on_value_cbt;
    callback<void(value_type)> _off_value_cbt;
};
 
template<typename Value>
default_toggle_delegate(Value&&) -> default_toggle_delegate<observer_decay_t<Value>>;
 
template<typename Value, typename OnValue>
default_toggle_delegate(Value&&, OnValue&&) -> default_toggle_delegate<observer_decay_t<Value>>;
 
template<typename Value, typename OnValue, typename OffValue>
default_toggle_delegate(Value&&, OnValue&&, OffValue&&) -> default_toggle_delegate<observer_decay_t<Value>>;
 
} // namespace v1
}