container_widget.hpp

#pragma once
#include "deleter.hpp"
#include "base_container_widget.hpp"
#include <concepts/widget.hpp>
 
namespace bugui
{
template <typename T, bool can_delete = true>
struct container_widget
    : deleter<T, base_container_widget, can_delete>
{
  void update() override final;

  void add_held(base_widget* widget) override final;

  void remove_held(base_widget* widget) override final;

  void handle_painter(painter& painter) const override final;

  bool handle_presser(presser& presser) override final;

  bool handle_child_Delete() override final;
 
protected:
  using deleter<T, base_container_widget, can_delete>::deleter;
};
 
template <typename T, bool can_delete>
inline void container_widget<T, can_delete>::update()
{
  if constexpr (has_set<T>)
    static_cast<T*>(this)->set();
 
  for (auto& c : this->children) c->update();
}
 
template <typename T, bool can_delete>
inline void container_widget<T, can_delete>::add_held(base_widget* widget)
{
  this->held.push_back(widget);
 
  if constexpr (has_held_added<T>)
    static_cast<T*>(this)->on_held_added();
}
 
template <typename T, bool can_delete>
inline void container_widget<T, can_delete>::remove_held(base_widget* widget)
{
  if (this->held.empty()) return;
 
  const auto it{std::find(this->held.begin()
                          , this->held.end(), widget)};
  if (it == this->held.end()) return;
 
  this->held.erase(it);
  if constexpr (has_held_removed<T>)
    static_cast<T*>(this)->on_held_removed();
}
 
template <typename T, bool can_delete>
inline void container_widget<T, can_delete>::handle_painter(painter& painter) const
{
  auto x_offset{this->parent->get_x()};
  auto y_offset{this->parent->get_y()};
 
  if constexpr (has_paint<T>)
  {
    auto x{this->get_x()};
    auto y{this->get_y()};
 
    painter.ofset(x_offset + x, y_offset + y);
    static_cast<const T*>(this)->paint(painter);
    painter.ofset(-x, -y);
  }
  else
    painter.ofset(x_offset, y_offset);
 
  for (const auto& c : this->children) c->handle_painter(painter);
 
  painter.ofset(-x_offset, -y_offset);
}
 
template <typename T, bool can_delete>
inline bool container_widget<T, can_delete>::handle_presser(presser& presser)
{
  auto p_x{this->parent->get_x()};
  auto p_y{this->parent->get_y()};
 
  presser.ofset(p_x, p_y);
 
  if (!this->overlap(presser))
  {
    presser.ofset(-p_x, -p_y);
    return false;
  }
 
  for (const auto& c : this->children)
    if (c->handle_presser(presser))
    {
      switch (presser.get_state())
      {
        case presser::single :
          presser.get_bool() ? this->parent->add_held(this)
                             : this->parent->remove_held(this);
          break;
        case presser::dragged :
        case presser::dropped :
          this->parent->remove_held(this);
          break;
        default: break;
      }
 
      presser.ofset(-p_x, -p_y);
      return true;
    }
 
  auto x{this->get_x()};
  auto y{this->get_y()};
  auto x_offset{x + p_x};
  auto y_offset{y + p_y};
 
  presser.ofset(x, y);
 
  if constexpr (!has_any_press<T>)
  {
    presser.ofset(-p_x, -p_y);
    return true;
  }
 
  presser.ofset(x, y);
 
  if constexpr (has_double_press<T>)
    if (presser.get_state() == presser::doubled)
    {
      static_cast<T*>(this)->on_double_press(presser);
      presser.ofset(-x_offset, -y_offset);
      return true;
    }
 
  if constexpr (has_drag<T>)
    if (presser.get_state() == presser::dragged)
    {
      static_cast<T*>(this)->on_drag(presser);
      presser.ofset(-x_offset, -y_offset);
      return true;
    }
 
  if constexpr (has_drop<T>)
    if (presser.get_state() == presser::dropped)
    {
      this->parent->remove_held(this);
      static_cast<T*>(this)->on_drop(presser);
      presser.ofset(-x_offset, -y_offset);
      return true;
    }
 
  if (presser.get_state() == presser::single)
    presser.get_bool() ? this->parent->add_held(this)
                       : this->parent->remove_held(this);
 
  if constexpr (has_press<T>)
    static_cast<T*>(this)->on_press(presser);
 
  presser.ofset(-x_offset, -y_offset);
  return true;
}
 
template <typename T, bool can_delete>
inline bool container_widget<T, can_delete>::handle_child_Delete()
{
  if constexpr (has_child_Delete<T>)
  {
    static_cast<T*>(this)->on_child_Delete();
    return true;
  }
  else return false;
}
 
} // namespace bugui