widget.hpp

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

  void handle_painter(painter& painter) const override final;

  bool handle_presser(presser& presser) override final;
 
protected:
  using deleter<T, base_widget, can_delete>::deleter;
};
 
template <typename T, bool can_delete>
inline void widget<T, can_delete>::update()
{
  if constexpr (has_set<T>)
    static_cast<T*>(this)->set();
}
 
template <typename T, bool can_delete>
inline void widget<T, can_delete>::handle_painter(painter &painter) const
{
  if constexpr (has_paint<T>)
  {
    auto x_offset{this->parent->get_x() + this->get_x()};
    auto y_offset{this->parent->get_y() + this->get_y()};
 
    painter.ofset(x_offset, y_offset);
    static_cast<const T*>(this)->paint(painter);
    painter.ofset(-x_offset, -y_offset);
  }
}
 
template <typename T, bool can_delete>
inline bool 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;
  }
 
  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(-x_offset, -y_offset);
    return true;
  }
 
  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)
    {
      this->parent->remove_held(this);
      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;
}
 
} // namespace bugui