base_container_widget.hpp

#pragma once
#include "base_widget.hpp"
 
#include <memory>
#include <vector>
#include <concepts>
#include <algorithm>
 
namespace bugui
{
struct base_container_widget : base_widget
{
  explicit base_container_widget(base_container_widget* parent);
 
  virtual void add_held(base_widget* widget) = 0;
  virtual void remove_held(base_widget* widget) = 0;
  virtual bool handle_child_Delete() = 0;

  const std::vector<base_widget*>& get_held() const { return held; }

  std::vector<base_widget*> get_unique_held() const;

  std::vector<base_widget*> get_deepest_held();

  void remove_widget(base_widget* widget);
 
protected:
  template <typename T, typename ...Args>
    requires std::derived_from<T, base_widget>
  base_widget* add_widget(Args& ...args);

  template <typename T, typename ...Args>
    requires std::derived_from<T, base_widget>
  base_widget* add_widget(Args&& ...args);

  template <class Pred>
    requires (!std::derived_from<std::remove_pointer_t<Pred>
                                , base_widget>)
  base_widget* remove_widget(Pred pred);
 
  std::vector<base_widget*> held;
  std::vector<std::unique_ptr<base_widget>> children;
 
private:
  void get_deeper_held(std::vector<base_widget*>& deepest
                       , base_container_widget* current_widget) const;
};
 
template<class Pred>
  requires (!std::derived_from<std::remove_pointer_t<Pred>
                              , base_widget>)
inline base_widget*
base_container_widget::remove_widget(Pred pred)
{
  const auto it{std::find_if(children.begin()
                             , children.end()
                             , pred)};
 
  if (it == children.end()) return nullptr;
  std::erase(held, it->get());
  std::erase(children, *it);
  return it->get();
}
 
template<typename T, typename ...Args>
  requires std::derived_from<T, base_widget>
inline base_widget*
base_container_widget::add_widget(Args&& ...args)
{
  children.emplace_back(
      std::make_unique<T>(std::forward<Args>(args)..., this));
  return children.back().get();
}
 
template<typename T, typename ...Args>
  requires std::derived_from<T, base_widget>
inline base_widget*
base_container_widget::add_widget(Args& ...args)
{
  children.emplace_back(std::make_unique<T>(args..., this));
  return children.back().get();
}
 
} // namespace bugui