layout.hpp

#ifndef TERMOX_WIDGET_LAYOUT_HPP
#define TERMOX_WIDGET_LAYOUT_HPP
#include <algorithm>
#include <cstddef>
#include <memory>
#include <type_traits>
#include <utility>
#include <vector>
 
#include <termox/common/transform_view.hpp>
#include <termox/system/event.hpp>
#include <termox/system/system.hpp>
#include <termox/widget/area.hpp>
#include <termox/widget/point.hpp>
#include <termox/widget/widget.hpp>
 
namespace ox::layout {
 
 
template <typename Child = Widget>
class Layout : public Widget {
   public:
    using Child_t = Child;
 
    struct Parameters {
        std::vector<std::unique_ptr<Child_t>> children;
    };
 
    static_assert(std::is_base_of_v<Widget, Child_t>,
                  "Layout: Child type must be a Widget type.");
 
   private:
    template <typename UnaryPredicate>
    using enable_if_invocable = std::enable_if_t<
        std::is_invocable_v<UnaryPredicate,
                            std::add_lvalue_reference_t<Child_t>>,
        int>;
 
   public:
    template <typename... Widgets>
    Layout(std::unique_ptr<Widgets>... children)
    {
        (this->append_child(std::move(children)), ...);
    }
 
    Layout(Parameters parameters)
    {
        for (auto& child : parameters.children)
            this->append_child(std::move(child));
    }
 
   public:
    [[nodiscard]] auto get_children()
    {
        auto constexpr downcast = [](auto& widg_ptr) -> Child_t& {
            return static_cast<Child_t&>(*widg_ptr);
        };
        return Transform_view(children_, downcast);
    }
 
    [[nodiscard]] auto get_children() const
    {
        auto constexpr downcast = [](auto const& widg_ptr) -> Child_t const& {
            return static_cast<Child_t const&>(*widg_ptr);
        };
        return Transform_view(children_, downcast);
    }
 
 
    template <typename Widget_t>
    auto insert_child(std::unique_ptr<Widget_t> w, std::size_t index)
        -> Widget_t&
    {
        static_assert(std::is_base_of_v<Child_t, Widget_t>,
                      "Layout::insert: Widget_t must be a Child_t type");
        assert(index <= this->child_count());
        auto& inserted = *w;
        children_.emplace(this->iter_at(index), std::move(w));
        inserted.set_parent(this);
        inserted.enable(this->is_enabled());
        System::post_event(Child_added_event{*this, inserted});
        return inserted;
    }
 
 
    template <typename Widget_t>
    auto append_child(std::unique_ptr<Widget_t> w) -> Widget_t&
    {
        return this->insert_child(std::move(w), this->child_count());
    }
 
 
    template <typename Widget_t = Child_t, typename... Args>
    auto make_child(Args&&... args) -> Widget_t&
    {
        return this->append_child(
            std::make_unique<Widget_t>(std::forward<Args>(args)...));
    }
 
    template <typename Widget_t = Child_t>
    auto make_child(typename Widget_t::Parameters p) -> Widget_t&
    {
        return this->append_child(std::make_unique<Widget_t>(std::move(p)));
    }
 
 
    [[nodiscard]] auto remove_child(Child_t const* child)
        -> std::unique_ptr<Widget>
    {
        auto const at = this->find_iter(child);
        if (at == std::end(children_))
            return nullptr;
        auto removed = this->iter_remove(at);
        this->uninitialize(*removed);
        return removed;
    }
 
 
    template <typename UnaryPredicate,
              typename = enable_if_invocable<UnaryPredicate>>
    [[nodiscard]] auto remove_child_if(UnaryPredicate&& predicate)
        -> std::unique_ptr<Widget>
    {
        Widget* found =
            this->find_child_if(std::forward<UnaryPredicate>(predicate));
        return this->remove_child(found);
    }
 
 
    [[nodiscard]] auto remove_child_at(std::size_t index)
        -> std::unique_ptr<Widget>
    {
        if (index >= this->child_count())
            return nullptr;
        auto removed = this->iter_remove(this->iter_at(index));
        this->uninitialize(*removed);
        return removed;
    }
 
 
    auto remove_and_delete_child(Child_t const* child) -> bool
    {
        auto removed = this->remove_child(child);
        if (removed == nullptr)
            return false;
        System::post_event(Delete_event{std::move(removed)});
        return true;
    }
 
 
    template <typename UnaryPredicate,
              typename = enable_if_invocable<UnaryPredicate>>
    auto remove_and_delete_child_if(UnaryPredicate&& predicate) -> bool
    {
        Widget* found =
            this->find_child_if(std::forward<UnaryPredicate>(predicate));
        if (found == nullptr)
            return false;
        this->remove_and_delete_child(found);
        return true;
    }
 
 
    auto remove_and_delete_child_at(std::size_t index) -> bool
    {
        auto removed = this->remove_child_at(index);
        if (removed == nullptr)
            return false;
        System::post_event(Delete_event{std::move(removed)});
        return true;
    }
 
    void delete_all_children()
    {
        while (this->child_count() != 0)
            this->remove_and_delete_child_at(0);
    }
 
    void swap_children(std::size_t index_a, std::size_t index_b)
    {
        std::iter_swap(this->iter_at(index_a), this->iter_at(index_b));
        System::post_event(Child_polished_event{*this, *children_[index_b]});
        System::post_event(Child_polished_event{*this, *children_[index_a]});
    }
 
 
    template <typename UnaryPredicate>
    [[nodiscard]] auto find_child_if(UnaryPredicate&& predicate) const
        -> Child_t const*
    {
        auto const view = this->get_children();
        auto const found =
            std::find_if(std::cbegin(view), std::cend(view),
                         std::forward<UnaryPredicate>(predicate));
        return found == std::cend(view) ? nullptr : std::addressof(*found);
    }
 
 
    template <typename UnaryPredicate>
    [[nodiscard]] auto find_child_if(UnaryPredicate&& predicate) -> Child_t*
    {
        auto view = this->get_children();
        auto const found =
            std::find_if(std::begin(view), std::end(view),
                         std::forward<UnaryPredicate>(predicate));
        return found == std::end(view) ? nullptr : std::addressof(*found);
    }
 
    [[nodiscard]] auto find_child_by_name(std::string const& name) -> Child_t*
    {
        return this->find_child_if(
            [&](Child_t const& w) { return w.name() == name; });
    }
 
    [[nodiscard]] auto find_child_by_name(std::string const& name) const
        -> Child_t const*
    {
        return this->find_child_if(
            [&](Child_t const& w) { return w.name() == name; });
    }
 
 
    [[nodiscard]] auto find_child_position(Widget const* w) const -> std::size_t
    {
        auto const found = std::find_if(
            std::cbegin(children_), std::cend(children_),
            [w](std::unique_ptr<Widget> const& x) { return x.get() == w; });
        if (found == std::cend(children_))
            return -1uL;
        return std::distance(std::cbegin(children_), found);
    }
 
    [[nodiscard]] auto contains_child(Widget const* w) const -> bool
    {
        auto const begin = std::cbegin(children_);
        auto const end   = std::cend(children_);
        return std::find_if(begin, end, [w](auto const& w_ptr) {
                   return w_ptr.get() == w;
               }) != end;
    }
 
 
    [[nodiscard]] auto contains_descendant(Widget const* descendant) const
        -> bool
    {
        auto const d = this->get_descendants();
        return std::find(std::begin(d), std::end(d), descendant) != std::end(d);
    }
 
    void update() final override {}
 
   protected:
    struct Dimensions {
        Widget* widget;
        std::size_t width;
        std::size_t height;
    };
 
    struct Dimensions_reference {
        Widget* widget;
        std::size_t* width;
        std::size_t* height;
    };
 
   private:
    [[nodiscard]] auto iter_at(std::size_t index) -> Children_t::iterator
    {
        return std::next(std::begin(children_), index);
    }
 
    [[nodiscard]] auto iter_at(std::size_t index) const
        -> Children_t::const_iterator
    {
        return std::next(std::cbegin(children_), index);
    }
 
    [[nodiscard]] auto is_target(Child_t const* target)
    {
        return [target](std::unique_ptr<Widget> const& w) -> bool {
            return w.get() == target;
        };
    }
 
    [[nodiscard]] auto find_iter(Child_t const* w) const
        -> Children_t::const_iterator
    {
        return std::find_if(std::cbegin(children_), std::cend(children_),
                            is_target(w));
    }
 
    [[nodiscard]] auto find_iter(Child_t const* w) -> Children_t::iterator
    {
        return std::find_if(std::begin(children_), std::end(children_),
                            is_target(w));
    }
 
    [[nodiscard]] auto iter_remove(Children_t::iterator at)
        -> std::unique_ptr<Widget>
    {
        auto removed = std::move(*at);
        children_.erase(at);
        return removed;
    }
 
    void uninitialize(Widget& w)
    {
        w.disable();
        System::post_event(Child_removed_event{*this, w});
        w.set_parent(nullptr);
    }
 
    [[nodiscard]] auto is_layout_type() const -> bool final override
    {
        return true;
    }
};
 
}  // namespace ox::layout
#endif  // TERMOX_WIDGET_LAYOUT_HPP