selecting.hpp

#ifndef TERMOX_WIDGET_LAYOUTS_SELECTING_HPP
#define TERMOX_WIDGET_LAYOUTS_SELECTING_HPP
#include <algorithm>
#include <cstddef>
#include <memory>
#include <stdexcept>
#include <type_traits>
#include <utility>
#include <vector>
 
#include <termox/system/key.hpp>
#include <termox/system/system.hpp>
#include <termox/widget/pipe.hpp>
 
namespace ox::layout {
 
 
template <typename Layout_t, bool unselect_on_focus_out = true>
class Selecting : public Layout_t {
   private:
    using Key_codes = std::vector<Key>;
 
    template <typename Unary_predicate>
    using Enable_if_invocable_with_child_t = std::enable_if_t<
        std::is_invocable_v<Unary_predicate,
                            std::add_const_t<std::add_lvalue_reference_t<
                                typename Layout_t::Child_t>>>,
        int>;
 
   public:
    Selecting() { *this | pipe::strong_focus(); }
 
    Selecting(Key_codes increment_selection_keys,
              Key_codes decrement_selection_keys,
              Key_codes increment_scroll_keys,
              Key_codes decrement_scroll_keys)
        : increment_selection_keys_{increment_selection_keys},
          decrement_selection_keys_{decrement_selection_keys},
          increment_scroll_keys_{increment_scroll_keys},
          decrement_scroll_keys_{decrement_scroll_keys}
    {
        *this | pipe::strong_focus();
    }
 
   public:
    void set_increment_selection_keys(Key_codes keys)
    {
        increment_selection_keys_ = std::move(keys);
    }
 
    void set_decrement_selection_keys(Key_codes keys)
    {
        decrement_selection_keys_ = std::move(keys);
    }
 
    void set_increment_scroll_keys(Key_codes keys)
    {
        increment_scroll_keys_ = std::move(keys);
    }
 
    void set_decrement_scroll_keys(Key_codes keys)
    {
        decrement_scroll_keys_ = std::move(keys);
    }
 
   public:
 
    [[nodiscard]] auto is_child_selected() const -> bool
    {
        return selected_ != nullptr;
    }
 
    [[nodiscard]] auto selected_child() const ->
        typename Layout_t::Child_t const&
    {
        if (selected_ != nullptr)
            return *selected_;
        throw std::out_of_range{"Selecting::select_child(): No Child Selected"};
    }
 
    auto selected_child() -> typename Layout_t::Child_t&
    {
        if (selected_ != nullptr)
            return *selected_;
        throw std::out_of_range{"Selecting::select_child(): No Child Selected"};
    }
 
 
    auto selected_index() const -> std::size_t
    {
        return this->find_child_position(selected_);
    }
 
    void select_first_child()
    {
        if (this->child_count() > 0)
            this->set_selected_by_index(this->get_child_offset());
    }
 
   protected:
    auto key_press_event(Key k) -> bool override
    {
        if (contains(k, increment_selection_keys_))
            this->increment_selected_and_scroll_if_necessary();
        else if (contains(k, decrement_selection_keys_))
            this->decrement_selected_and_scroll_if_necessary();
        else if (contains(k, increment_scroll_keys_))
            this->increment_offset_and_increment_selected();
        else if (contains(k, decrement_scroll_keys_))
            this->decrement_offset_and_decrement_selected();
        return Layout_t::key_press_event(k);
    }
 
    auto mouse_wheel_event_filter(Widget&, Mouse const& m) -> bool override
    {
        switch (m.button) {
            case Mouse::Button::ScrollUp:
                this->decrement_selected_and_scroll_if_necessary();
                break;
            case Mouse::Button::ScrollDown:
                this->increment_selected_and_scroll_if_necessary();
                break;
            default: break;
        }
        return true;
    }
 
    auto mouse_press_event_filter(Widget& w, Mouse const& m) -> bool override
    {
        if (!this->contains_child(&w))
            return false;
        switch (m.button) {
            case Mouse::Button::Left:
                this->set_selected_by_pointer(
                    static_cast<typename Layout_t::Child_t*>(&w));
                break;
            default: break;
        }
        return true;
    }
 
    auto resize_event(ox::Area new_size, ox::Area old_size) -> bool override
    {
        auto const base_result = Layout_t::resize_event(new_size, old_size);
        this->reset_selected_if_necessary();
        return base_result;
    }
 
    // This has a focus in event..
    auto focus_in_event() -> bool override
    {
        this->reset_selected_if_necessary();
        if (this->is_child_selected())
            this->selected_child().select();
        else if (this->child_count() > 0)
            this->select_first_child();
        return Layout_t::focus_in_event();
    }
 
    auto focus_out_event() -> bool override
    {
        if constexpr (unselect_on_focus_out) {
            if (this->is_child_selected())
                this->selected_child().unselect();
        }
        return Layout_t::focus_out_event();
    }
 
    auto enable_event() -> bool override
    {
        if (this->is_child_selected() && System::focus_widget() == this)
            this->selected_child().select();
        return Layout_t::enable_event();
    }
 
    auto disable_event() -> bool override
    {
        if (this->is_child_selected())
            this->selected_child().unselect();
        return Layout_t::disable_event();
    }
 
    auto child_added_event(Widget& child) -> bool override
    {
        if (this->child_count() == 1)
            this->select_first_child();
        child.install_event_filter(*this);
        return Layout_t::child_added_event(child);
    }
 
    auto child_removed_event(Widget& child) -> bool override
    {
        if (&child == selected_) {
            if (this->child_count() > 0)
                this->set_selected_by_index(this->get_child_offset());
            else
                selected_ = nullptr;
        }
        return Layout_t::child_removed_event(child);
    }
 
   private:
    typename Layout_t::Child_t* selected_{nullptr};
    Key_codes increment_selection_keys_;
    Key_codes decrement_selection_keys_;
    Key_codes increment_scroll_keys_;
    Key_codes decrement_scroll_keys_;
 
   private:
    void increment_selected()
    {
        auto const next = this->selected_index() + 1;
        if (next >= this->child_count())
            return;
        this->set_selected_by_index(next);
    }
 
    void increment_selected_and_scroll_if_necessary()
    {
        if (!this->is_child_selected())
            return;
        this->increment_selected();
        if (!this->selected_child().is_enabled())
            this->increment_offset();
    }
 
    void decrement_selected()
    {
        auto const current = this->selected_index();
        if (current == 0)
            return;
        this->set_selected_by_index(current - 1);
    }
 
    void decrement_selected_and_scroll_if_necessary()
    {
        if (!this->is_child_selected())
            return;
        this->decrement_selected();
        if (!this->selected_child().is_enabled())
            this->decrement_offset();
    }
 
    void increment_offset_and_increment_selected()
    {
        this->increment_offset();
        this->increment_selected();
    }
 
    void decrement_offset_and_decrement_selected()
    {
        if (this->get_child_offset() == 0)
            return;
        this->decrement_offset();
        this->decrement_selected();
    }
 
 
    void set_selected_by_index(std::size_t index)
    {
        if (index < this->child_count())
            this->set_selected_by_pointer(&(this->get_children()[index]));
        else
            throw std::out_of_range{"Selecting::set_selected_by_index"};
    }
 
    void set_selected_by_pointer(typename Layout_t::Child_t* child)
    {
        if (this->is_child_selected())
            selected_->unselect();
        selected_ = child;
        selected_->select();
    }
 
 
    auto find_bottom_row_index() const -> std::size_t
    {
        auto const children = this->Widget::get_children();
        auto const count    = this->child_count();
        auto const offset   = this->get_child_offset();
        for (auto i = offset + 1; i < count; ++i) {
            if (children[i].is_enabled())
                continue;
            else
                return i - 1;
        }
        return offset;
    }
 
    void reset_selected_if_necessary()
    {
        if (this->is_child_selected()) {
            if (this->selected_child().is_enabled())
                return;
            else
                this->set_selected_by_index(this->find_bottom_row_index());
        }
    }
 
    [[nodiscard]] static auto contains(Key k, Key_codes const& codes) -> bool
    {
        return std::any_of(std::begin(codes), std::end(codes),
                           [=](auto code) { return code == k; });
    }
};
 
template <typename Layout_t,
          bool unselect_on_focus_out = true,
          typename... Args>
[[nodiscard]] auto selecting(Args&&... args)
    -> std::unique_ptr<Selecting<Layout_t, unselect_on_focus_out>>
{
    return std::make_unique<Selecting<Layout_t, unselect_on_focus_out>>(
        std::forward<Args>(args)...);
}
 
}  // namespace ox::layout
#endif  // TERMOX_WIDGET_LAYOUTS_SELECTING_HPP