stack.hpp

#ifndef TERMOX_WIDGET_LAYOUTS_STACK_HPP
#define TERMOX_WIDGET_LAYOUTS_STACK_HPP
#include <algorithm>
#include <cstddef>
#include <iterator>
#include <memory>
#include <stdexcept>
#include <type_traits>
#include <utility>
#include <vector>
 
#include <signals_light/signal.hpp>
 
#include <termox/system/event.hpp>
#include <termox/system/system.hpp>
#include <termox/widget/area.hpp>
#include <termox/widget/detail/link_lifetimes.hpp>
#include <termox/widget/layout.hpp>
#include <termox/widget/point.hpp>
#include <termox/widget/widget.hpp>
 
namespace ox::layout {
 
 
template <typename Child_t = Widget>
class Stack : public Layout<Child_t> {
   public:
    sl::Signal<void(std::size_t)> page_changed;
 
   public:
    using Layout<Child_t>::Layout;
 
 
    void set_active_page(std::size_t index)
    {
        if (index > this->Stack::size())
            throw std::out_of_range{"Stack::set_active_page: index is invalid"};
        auto* previous = active_page_;
        active_page_   = std::addressof(this->get_children()[index]);
        if (active_page_ == previous)
            return;
        if (previous != nullptr)
            previous->disable();
 
        active_page_->enable(this->is_enabled());
        // TODO move if enabled and force move if disabled?
        this->move_active_page();
        this->resize_active_page();
        if (sets_focus_ && this->is_enabled())
            System::set_focus(*active_page_);
        this->page_changed(index);
    }
 
 
    void give_focus_on_change(bool sets_focus = true)
    {
        sets_focus_ = sets_focus;
    }
 
 
    template <typename Widget_t = Child_t, typename... Args>
    auto make_page(Args&&... args) -> Widget_t&
    {
        static_assert(std::is_base_of<Child_t, Widget_t>::value,
                      "Stack::make_page: Widget_t must be a Child_t type");
        return static_cast<Widget_t&>(this->append_page(
            std::make_unique<Widget_t>(std::forward<Args>(args)...)));
    }
 
 
    template <typename Widget_t>
    auto append_page(std::unique_ptr<Widget_t> w_ptr) -> Widget_t&
    {
        static_assert(std::is_base_of<Child_t, Widget_t>::value,
                      "Stack::append_page: Widget_t must be a Child_t type");
        auto& result = this->append_child(std::move(w_ptr));
        result.disable();
        return result;
    }
 
 
    template <typename Widget_t>
    auto append_page(Widget_t&& w) -> Child_t&
    {
        return this->append_page(
            std::make_unique<Widget_t>(std::forward<Widget_t>(w)));
    }
 
 
    auto insert_page(std::unique_ptr<Child_t> child, std::size_t index)
        -> Child_t&
    {
        auto& result = this->insert_child(std::move(child), index);
        result.disable();
        return result;
    }
 
 
    void delete_page(std::size_t index)
    {
        if (index >= this->Stack::size())
            throw std::out_of_range{"Stack::delete_page: index is invalid"};
        auto const* page_to_delete =
            std::addressof(this->get_children()[index]);
        if (page_to_delete == this->get_active_page())
            active_page_ = nullptr;
        this->remove_and_delete_child(page_to_delete);
    }
 
 
    [[nodiscard]] auto remove_page(std::size_t index) -> std::unique_ptr<Widget>
    {
        if (index >= this->size())
            throw std::out_of_range{"Stack::remove_page: index is invalid."};
        auto const* page_to_remove =
            std::addressof(this->get_children()[index]);
        if (page_to_remove == this->get_active_page())
            active_page_ = nullptr;
        return this->remove_child(page_to_remove);
    }
 
    void clear()
    {
        // Can't use a range-for loop, delete_page modifies the child_list_
        while (!this->get_children().empty())
            this->delete_page(0);
    }
 
    [[nodiscard]] auto size() const -> std::size_t
    {
        return this->child_count();
    }
 
    [[nodiscard]] auto get_active_page() const -> Child_t*
    {
        return active_page_;
    }
 
 
    [[nodiscard]] auto active_page_index() const -> std::size_t
    {
        if (active_page_ == nullptr)
            return Stack::invalid_index;
        auto begin     = std::cbegin(this->get_children());
        auto const end = std::cend(this->get_children());
        auto distance  = 0;
        for (; begin != end; ++begin) {
            if (std::addressof(*begin) == active_page_)
                break;
            else
                ++distance;
        }
        return distance;
    }
 
    static auto constexpr invalid_index = static_cast<std::size_t>(-1);
 
   protected:
    auto enable_event() -> bool override
    {
        if (active_page_ != nullptr)
            active_page_->enable();
        return Layout<Child_t>::enable_event();
    }
 
    auto disable_event() -> bool override
    {
        if (active_page_ != nullptr)
            active_page_->disable();
        return Layout<Child_t>::disable_event();
    }
 
    auto move_event(Point new_position, Point old_position) -> bool override
    {
        this->move_active_page();
        return Layout<Child_t>::move_event(new_position, old_position);
    }
 
    auto resize_event(Area new_size, Area old_size) -> bool override
    {
        this->resize_active_page();
        return Layout<Child_t>::resize_event(new_size, old_size);
    }
 
    auto focus_in_event() -> bool override
    {
        if (active_page_ != nullptr)
            ox::System::set_focus(*active_page_);
        return this->Layout<Child_t>::focus_in_event();
    }
 
   private:
    Child_t* active_page_ = nullptr;
    bool sets_focus_      = true;
 
   private:
    void move_active_page()
    {
        if (active_page_ != nullptr)
            System::post_event(Move_event{*active_page_, this->top_left()});
    }
 
    void resize_active_page()
    {
        if (active_page_ != nullptr)
            System::post_event(Resize_event{*active_page_, this->area()});
    }
};
 
template <typename Widget_t = Widget, typename... Args>
[[nodiscard]] auto stack(Args&&... args) -> std::unique_ptr<Stack<Widget_t>>
{
    return std::make_unique<Stack<Widget_t>>(std::forward<Args>(args)...);
}
 
}  // namespace ox::layout
 
// - - - - - - - - - - - - - - - - Slots - - - - - - - - - - - - - - - - - - - -
namespace ox::slot {
 
template <typename Child_t>
[[nodiscard]] auto set_active_page(layout::Stack<Child_t>& stack)
    -> sl::Slot<void(std::size_t)>
{
    return link_lifetimes(
        [&stack](auto index) { stack.set_active_page(index); }, stack);
}
 
template <typename Child_t>
[[nodiscard]] auto set_active_page(layout::Stack<Child_t>& stack,
                                   std::size_t index) -> sl::Slot<void()>
{
    return link_lifetimes([&stack, index] { stack.set_active_page(index); },
                          stack);
}
 
template <typename Child_t>
[[nodiscard]] auto delete_page(layout::Stack<Child_t>& stack)
    -> sl::Slot<void(std::size_t)>
{
    return link_lifetimes([&stack](auto index) { stack.delete_page(index); },
                          stack);
}
 
template <typename Child_t>
[[nodiscard]] auto delete_page(layout::Stack<Child_t>& stack, std::size_t index)
    -> sl::Slot<void()>
{
    return link_lifetimes([&stack, index] { stack.delete_page(index); }, stack);
}
 
template <typename Child_t>
[[nodiscard]] auto insert_page(layout::Stack<Child_t>& stack)
    -> sl::Slot<void(std::size_t, std::unique_ptr<Widget>)>
{
    return link_lifetimes(
        [&stack](auto index, auto widget) {
            stack.insert_page(index, std::move(widget));
        },
        stack);
}
 
template <typename Child_t>
[[nodiscard]] auto insert_page(layout::Stack<Child_t>& stack, std::size_t index)
    -> sl::Slot<void(std::unique_ptr<Widget>)>
{
    return link_lifetimes(
        [&stack, index](auto widget) {
            stack.insert_page(index, std::move(widget));
        },
        stack);
}
 
}  // namespace ox::slot
#endif  // TERMOX_WIDGET_LAYOUTS_STACK_HPP