controller.hpp

#pragma once
#include "ctrlr_shifter.hpp"
#include "ctrlr_deleter.hpp"
#include <bugui/io/painter.hpp>
#include <bugui/devices/all.hpp>
#include <bugui/io/button_painter.hpp>
#include <bugui/widgets/container_widget.hpp>
 
#include <string_view>
 
namespace bugui
{
struct base_hardware;
template <typename T>
struct controller
    : ctrlr_shifter<T>
    , ctrlr_deleter<T>
{
  // FIXME : a lot of duplicates from container_widget
  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;
 
  stdx::error set_midi_in_port
      (const libremidi::observer& observer
       , std::string_view port_name)
  { return this->hdw->set_midi_in_port(observer, port_name); };
 
  stdx::error set_midi_out_port
      (const libremidi::observer& observer
       , std::string_view port_name)
  {
    auto ret{this->hdw->set_midi_out_port(observer, port_name)};
    repaint();
    return ret;
  };
 
protected:
  explicit controller(std::string_view device_name)
      // FIXME : Passing list of device Macro as variadic
      // template, is this a good idea ?
      : ctrlr_deleter<T>
      {hardware_factory<T, BUGUI_DEVICES>
       ::get(device_name, static_cast<T*>(this))}
  { }
 
  void repaint() override final;

  bool handle_child_Delete() override final { return true; };
};
 
template<typename T>
inline void controller<T>::update()
{
  if constexpr (has_set<T>)
    static_cast<T*>(this)->set();
 
  for (auto& c : this->children) c->update();
}
 
template<typename T>
inline void controller<T>::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>
inline void controller<T>::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>
inline void controller<T>::handle_painter(painter& painter) const
{
  if constexpr (has_paint<T>)
  {
    auto x{this->get_x()};
    auto y{this->get_y()};
 
    painter.ofset(x, y);
    static_cast<const T*>(this)->paint(painter);
    painter.ofset(-x, -y);
  }
 
  for (const auto& c : this->children) c->handle_painter(painter);
}
 
template<typename T>
inline bool controller<T>::handle_presser(presser& presser)
{
  for (const auto& c : this->children)
    if (c->handle_presser(presser))
      return true;
 
  presser.ofset(-this->get_x(), -this->get_y());
 
  if (!this->overlap(presser))
    return false;
 
  if constexpr (has_double_press<T>)
    if (presser.get_state() == presser::doubled)
      static_cast<T*>(this)->on_double_press(presser);
 
  if constexpr (has_drag<T>)
    if (presser.get_state() == presser::dragged)
      static_cast<T*>(this)->on_drag(presser);
 
  if constexpr (has_drop<T>)
    if (presser.get_state() == presser::dropped)
      static_cast<T*>(this)->on_drop(presser);
 
  if constexpr (has_press<T>)
    if (presser.get_state() == presser::single)
      static_cast<T*>(this)->on_press(presser);
 
  return true;
}
 
template<typename T>
inline void controller<T>::repaint()
{
  this->paint.set(this->get_x(), this->get_y());
  this->paint.bound_at_offset(this);
 
  if constexpr (has_paint<T>)
    static_cast<T*>(this)->paint(this->paint);
 
  this->paint.reset();
  for (const auto& c : this->children)
    c->handle_painter(this->paint);
 
  this->hdw->set_grid(this->paint);
}
 
} // namespace bugui