grid.hpp

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

template <has_grid Device, typename Controller>
struct grid<Device, Controller>
    : virtual base_hardware
    , virtual common<Controller>
    , virtual init<component<Device, class Device::grid>>
    , virtual clear<component<Device, class Device::grid>>
    , virtual protocol<component<Device, class Device::grid>>
{
  void set_grid(painter& p) override
  {
    this->send([&p, this](auto& formater)
    {
      const auto& top_left{p.get_top_left()};
      const auto& bottom_right{p.get_bottom_right()};
 
      for (int i{top_left.y}; i < bottom_right.y; i++)
        for (int j{top_left.x}; j < bottom_right.x; j++)
        {
          color c{p.read_clear(j, i)};
          color_cnvrtr& g{color_grid[i][j]};
 
          if (g == c) continue;
 
          g.set(c);
          formater.set(Device::grid::ids()[i][j], g);
        }
    });
  }
 
protected:
  explicit grid()
      : color_grid{}
  {
    this->on_message_received
        ([this](auto id, auto value)
    { return set(id, value); });
  }
 
  void component_reset()
  {
    if constexpr(has_clear<typename Device::grid>)
      this->clear<class component<Device, class Device::grid>>
          ::component_reset();
    else
      this->send(
          [this](auto& formater)
      {
        for (int i{0}; i < m_height; i++)
          for (int j{0}; j < m_width; j++)
          {
            color c{};
            color_cnvrtr& g{color_grid[i][j]};
 
            if (g == c) continue;
 
            g.set(c);
            formater.set(Device::grid::ids()[i][j], g);
          }
      });
  }
 
private:
  using color_cnvrtr = color_converter
      <typename color_t<Device, class Device::grid>::type>;
 
  bool set(uint8_t id, uint8_t midi)
  { // FIXME : Only set presser if the receiver returns true
    prsr.set_midi(midi);
    return on_grid_received(id);
  }
 
  bool set(auto id, bool boolean)
  { // FIXME : Only set presser if the receiver returns true
    prsr.set_bool(boolean);
    return on_grid_received(id);
  }
 
  bool on_grid_received(auto id)
  {
    // FIXME : ignore the next unpress after a double press ?
    for (int i{0}; i < m_height; i++)
      for (int j{0}; j < m_width; j++)
        if (id == Device::grid::ids()[i][j])
        {
          prsr.set(j, i);
          bool down{prsr.get_bool()};
          auto it{presses.begin()};
 
          using namespace std;
          using namespace chrono;
          auto now{steady_clock::now()};
 
          while (it != presses.end())
          {
            if (!it->dragged && duration_cast<milliseconds>
                                   (now - it->t) > 200ms)
            {
              it = presses.erase(it);
              continue;
            }
 
            if (it->i == i && it->j == j)
            { // looking for double press
              if (down && !it->down)
              {
                prsr.button_presser::set_double_press();
                presses.erase(it);
                this->controller->handle_presser(prsr);
                return true;
              }
              // looking for drop
              if (!down && it->down)
              {
                if (it->dragged)
                {
                  prsr.set_drop();
                  presses.erase(it);
                  this->controller->handle_presser(prsr);
                  return true;
                }
              }
            }
            // looking for drag : presses one cell apart
            else if (sqrt(pow(it->i - i, 2) +
                         pow(it->j - j, 2)) == 1)
            {
              if (!down && it->down)
              {
                prsr.set_drag(it->j, it->i);
                it->dragged = true;
                // cleanup previous drag
                it++;
                while (it != presses.end())
                {
                  if (it->i == i && it->j == j && it->dragged)
                  {
                    presses.erase(it);
                    break;
                  }
                  else it++;
                }
 
                this->controller->handle_presser(prsr);
                return true;
              }
            }
 
            it++;
          };
 
          down ? presses.emplace_front(
                     previous_press{now, i, j, true})
               : presses.emplace_back(
                     previous_press{now, i , j, false});
          this->controller->handle_presser(prsr);
          return true;
        }
 
    return false;
  }
 
  static constexpr int m_width{Device::grid::ids()[0].size()};
  static constexpr int m_height{Device::grid::ids().size()};
  int width() const override { return m_width; }
  int height() const override { return m_height; }
 
  color_cnvrtr color_grid[m_width][m_height];
 
  struct previous_press
  {
    std::chrono::time_point<std::chrono::steady_clock> t;
    int i, j;
    bool down, dragged{false};
  };
 
  std::list<previous_press> presses{};
  presser prsr;
};
 
} // nemaspace bugui