menu_stack.hpp

#ifndef TERMOX_WIDGET_WIDGETS_MENU_STACK_HPP
#define TERMOX_WIDGET_WIDGETS_MENU_STACK_HPP
#include <cstddef>
#include <memory>
#include <utility>
 
#include <termox/painter/glyph_string.hpp>
#include <termox/system/system.hpp>
#include <termox/widget/focus_policy.hpp>
#include <termox/widget/layouts/stack.hpp>
#include <termox/widget/widgets/menu.hpp>
 
namespace ox {
 
// maybe TODO
// You could simplify the index math if you hold:
// STuple<Main_menu, layout::Stack<Child_t>> and make it a template on Child_t
// Then the widgets are in their own stack, you arn't mixing, and you can also
// have a template parameter if you only want to hold a specific type of Widget,
// since this is a layout technically.
 
 
class Menu_stack : public layout::Stack<Widget> {
   private:
    static auto constexpr menu_index_ = 0uL;
 
   public:
    Menu_stack() : menu_{this->Stack::make_page<Menu>()}
    {
        this->Stack::set_active_page(menu_index_);
        this->focus_policy = Focus_policy::Direct;
    }
 
   public:
 
    template <typename Widget_t, typename... Args>
    auto make_page(Glyph_string title, Args&&... args) -> Widget_t&
    {
        static_assert(std::is_base_of<Widget, Widget_t>::value,
                      "Menu_stack::make_page: Widget_t must be a Widget type");
        auto& child =
            this->Stack::make_page<Widget_t>(std::forward<Args>(args)...);
        this->connect_to_menu(std::move(title), this->Stack::size() - 1);
        return child;
    }
 
    template <typename Widget_t>
    void append_page(Glyph_string title, std::unique_ptr<Widget_t> w_ptr)
    {
        static_assert(
            std::is_base_of<Child_t, Widget_t>::value,
            "Menu_stack::append_page: Widget_t must be a Child_t type");
        this->Stack::append_page(std::move(w_ptr));
        this->connect_to_menu(std::move(title), this->Stack::size() - 1);
    }
 
 
    void insert_page(Glyph_string title,
                     std::unique_ptr<Widget> widget,
                     std::size_t index)
    {
        this->Stack::insert_page(std::move(widget), index + 1);
        this->connect_to_menu(std::move(title), index + 1);
    }
 
 
    void delete_page(std::size_t index)
    {
        this->remove_from_menu(index + 1);
        this->Stack::delete_page(index + 1);
    }
 
 
    [[nodiscard]] auto remove_page(std::size_t index) -> std::unique_ptr<Widget>
    {
        this->remove_from_menu(index + 1);
        return this->Stack::remove_page(index + 1);
    }
 
    void clear()
    {
        this->goto_menu();
        // Can't use a range-for loop, delete_page modifies the child_list_
        while (this->child_count() > 1)
            this->delete_page(1);
    }
 
    [[nodiscard]] auto size() const -> std::size_t
    {
        return this->Stack::size() - 1;
    }
 
    [[nodiscard]] auto menu() -> Menu& { return menu_; }
 
    [[nodiscard]] auto menu() const -> Menu const& { return menu_; }
 
    void goto_menu() { this->Stack::set_active_page(menu_index_); }
 
    void set_active_page(std::size_t index)
    {
        this->Stack::set_active_page(index + 1);
    }
 
   private:
    Menu& menu_;
 
   private:
 
    void remove_from_menu(std::size_t index)
    {
        menu_.remove_item(index - 1);
        if (this->Stack::active_page_index() == index)
            this->Stack::set_active_page(menu_index_);
    }
 
 
    void connect_to_menu(Glyph_string title, std::size_t index)
    {
        auto& signal = menu_.insert_item(std::move(title), index - 1);
        signal.connect(slot::set_active_page(*this, index));
    }
};
 
template <typename... Args>
[[nodiscard]] auto menu_stack(Args&&... args) -> std::unique_ptr<Menu_stack>
{
    return std::make_unique<Menu_stack>(std::forward<Args>(args)...);
}
 
}  // namespace ox
#endif  // TERMOX_WIDGET_WIDGETS_MENU_STACK_HPP