selectable.hpp

#ifndef TERMOX_WIDGET_WIDGETS_SELECTABLE_HPP
#define TERMOX_WIDGET_WIDGETS_SELECTABLE_HPP
#include <termox/painter/trait.hpp>
#include <termox/widget/pipe.hpp>
 
namespace ox {
 
template <typename Widget_t,
          typename Select_method   = void,
          typename Unselect_method = void>
class Selectable : public Widget_t {
   public:
    Selectable(Select_method s, Unselect_method u)
        : Widget_t{}, select_{std::move(s)}, unselect_{std::move(u)}
    {}
 
    Selectable(Select_method s,
               Unselect_method u,
               typename Widget_t::Parameters p)
        : Widget_t{std::move(p)}, select_{std::move(s)}, unselect_{std::move(u)}
    {}
 
   public:
    void select() { select_(*this); }
 
    void unselect() { unselect_(*this); }
 
   private:
    Select_method select_;
    Unselect_method unselect_;
};
 
template <typename Widget_t, typename Select_method, typename Unselect_method>
[[nodiscard]] auto selectable(Select_method s, Unselect_method u)
    -> std::unique_ptr<Selectable<Widget_t, Select_method, Unselect_method>>
{
    return std::make_unique<
        Selectable<Widget_t, Select_method, Unselect_method>>(std::move(s),
                                                              std::move(u));
}
 
template <typename Widget_t, typename Select_method, typename Unselect_method>
[[nodiscard]] auto selectable(Select_method s,
                              Unselect_method u,
                              typename Widget_t::Parameters p)
    -> std::unique_ptr<Selectable<Widget_t, Select_method, Unselect_method>>
{
    return std::make_unique<
        Selectable<Widget_t, Select_method, Unselect_method>>(
        std::move(s), std::move(u), std::move(p));
}
 
template <typename Widget_t>
class Selectable<Widget_t, void, void> : public Widget_t {
   public:
    using Parameters = typename Widget_t::Parameters;
 
   public:
    Selectable() = default;
 
    Selectable(Parameters p) : Widget_t{std::move(p)} {}
 
   public:
    void select()
    {
        *this | Trait::Inverse;
        *this | pipe::descendants() | Trait::Inverse;
    }
 
    void unselect()
    {
        *this | pipe::discard(Trait::Inverse);
        *this | pipe::descendants() | pipe::discard(Trait::Inverse);
    }
};
 
template <typename Widget_t>
[[nodiscard]] auto selectable() -> std::unique_ptr<Selectable<Widget_t>>
{
    return std::make_unique<Selectable<Widget_t>>();
}
 
template <typename Widget_t>
[[nodiscard]] auto selectable(typename Selectable<Widget_t>::Parameters p)
    -> std::unique_ptr<Selectable<Widget_t>>
{
    return std::make_unique<Selectable<Widget_t>>(std::move(p));
}
 
}  // namespace ox
#endif  // TERMOX_WIDGET_WIDGETS_SELECTABLE_HPP