grid.hpp

#pragma once
#include "base_hardware.hpp"
#include <io/presser.hpp>
#include <color/color_converter.hpp>
#include <concepts/device.hpp>
 
#include <chrono>
#include <list>
#include <iostream>
#include <functional>
 
namespace bugui
{
template <typename Device, typename Controller>
struct grid : virtual base_hardware
{ };

template <has_grid Device, typename Controller>
class grid<Device, Controller>
    : virtual public base_hardware
{
  using id_t = std::remove_cvref_t
      <decltype(Device::grid::ids()[0][0])>;
 
  using color_cnvtr = color_converter<typename Device::color>;
 
  int width() const override { return Device::grid::width(); }
  int height() const override { return Device::grid::height(); }
 
  color_converter<typename Device::color>
      color_grid[Device::grid::width()][Device::grid::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{};
 
public:
  ~grid()
  { std::cout << "presses size: " << presses.size() << '\n'; }
  presser& get_presser() { return prsr; }
 
protected:
  grid()
      : color_grid{}
  { }
 
  void paint(painter& paint
             , std::function
             <void(id_t, const color_cnvtr&)>
                 && func)
  {
    const auto& top_left{paint.get_top_left()};
    const auto& bottom_right{paint.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{paint.read_clear(j, i)};
        color_cnvtr& g{color_grid[i][j]};
 
        if (g == c) continue;
 
        g.set(c);
        func(Device::grid::ids()[i][j], g);
      }
  }
 
  void clear(std::function<void(id_t id)>&& func)
  {
    for (int i{0}; i < Device::grid::height(); i++)
      for (int j{0}; j < Device::grid::width(); j++)
      {
        color_converter<typename Device::color>&
            g{color_grid[i][j]};
 
        if (!g.is_clear())
          func(Device::grid::ids()[i][j]);
      }
  }
 
  bool on_grid_received(Controller* ctrlr, id_t id)
  {
    // FIXME : ignore the next unpress after a double press ?
    for (int i{0}; i < Device::grid::height(); i++)
      for (int j{0}; j < Device::grid::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);
                ctrlr->handle_presser(prsr);
                return true;
              }
              // looking for drop
              if (!down && it->down)
              {
                if (it->dragged)
                {
                  prsr.set_drop();
                  presses.erase(it);
                  ctrlr->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++;
                }
 
                ctrlr->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});
          ctrlr->handle_presser(prsr);
          return true;
        }
 
    return false;
  }
 
  presser prsr;
};
 
} // nemaspace bugui