buttons.hpp

#pragma once
#include "init.hpp"
#include "clear.hpp"
#include <bugui/hardware/common.hpp>
#include <bugui/hardware/base_hardware.hpp>
#include <bugui/hardware/protocol/protocol.hpp>
#include <bugui/io/button_presser.hpp>
#include <bugui/color/color_converter.hpp>
#include <bugui/concepts/device.hpp>
#include <bugui/labels.hpp>
 
namespace bugui
{
template <typename Device, typename Controller>
struct buttons { };

template <has_buttons Device, typename Controller>
struct buttons<Device, Controller>
    : virtual base_hardware
    , virtual common<Controller>
    , virtual init<component<Device, class Device::buttons>>
    , virtual clear<component<Device, class Device::buttons>>
    , virtual protocol<component<Device, class Device::buttons>>
{
  void set_button(const button_painter& p) override
  {
    this->send([&p, this](auto& formater)
    {
      color_cnvrtr b{p.get_color()};
 
#define reseter(F)                                    \
      if constexpr(device_##F##_button<Device>)       \
        if (p.get_label() == labels::F && F != b)     \
        {                                             \
          formater.set(Device::buttons::F##_id(), b); \
          F = b;                                      \
        }
// FIXME : find a more succinct macro
#define CALL_MACRO(r, data, elem) reseter(elem)
      FOR_EACH_LABEL(CALL_MACRO)
#undef CALL_MACRO
#undef call_func
    });
  }
 
protected:
  explicit buttons()
  {
    this->on_message_received
        ([this](auto id, auto value)
    { return set(id, value); });
  }
 
  void component_reset()
  {
    if constexpr(has_clear<typename Device::buttons>)
      this->clear<class component<Device, class Device::buttons>>
          ::component_reset();
    else
      this->send
          ([this](auto& formater)
      {
#define call_func(F)                                        \
        if constexpr(device_##F##_button<Device>)           \
              if (!F.is_clear())                            \
          {                                                 \
                F.clear();                                  \
                formater.set(Device::buttons::F##_id(), F); \
          }
// FIXME : find a more succinct macro
#define CALL_MACRO(r, data, elem) call_func(elem)
        FOR_EACH_LABEL(CALL_MACRO)
#undef CALL_MACRO
#undef reseters
      });
  }
 
private:
  using color_cnvrtr = color_converter
      <typename color_t<Device, class Device::buttons>::type>;
 
  bool set(uint8_t id, uint8_t midi)
  { // FIXME : Only set presser if the receiver returns true
    btn_prsr.set_midi(midi);
    return on_button_received(id);
  }
 
  bool set(auto id, bool boolean)
  { // FIXME : Only set presser if the receiver returns true
    btn_prsr.set_bool(boolean);
    return on_button_received(id);
  }
 
  bool on_button_received(auto id)
  {
#define call_ctrlr(F)                                   \
    if constexpr(F##_button<Device, Controller>)        \
          if (id == Device::buttons::F##_id())          \
      {                                                 \
            this->controller->on_##F(btn_prsr);         \
            this->controller->set_##F##_held(btn_prsr); \
            return true;                                \
      }
// FIXME : find more succinct macro
#define CALL_MACRO(r, data, elem) call_ctrlr(elem)
    FOR_EACH_LABEL(CALL_MACRO)
#undef CALL_MACRO
#undef call_ctrlr
 
    return false;
  }
 
#define converters(L) color_cnvrtr L{};
// FIXME : find a more succinct macro
#define CALL_MACRO(r, data, elem) converters(elem)
  FOR_EACH_LABEL(CALL_MACRO)
#undef CALL_MACRO
#undef converters
 
  button_presser btn_prsr;
};
 
} // namespace bugui