screen.h

#pragma once
#include "../core/include/subsystems/odometry/odometry_base.h"
#include "../core/include/utils/controls/pid.h"
#include "../core/include/utils/controls/pidff.h"
#include "../core/include/utils/graph_drawer.h"
#include "vex.h"
#include <cassert>
#include <functional>
#include <map>
#include <vector>
 
namespace screen {
class ButtonWidget {
public:
  ButtonWidget(std::function<void(void)> onpress, Rect rect, std::string name)
      : onpress(onpress), rect(rect), name(name) {}
  ButtonWidget(void (*onpress)(), Rect rect, std::string name) : onpress(onpress), rect(rect), name(name) {}
 
  bool update(bool was_pressed, int x, int y);
  void draw(vex::brain::lcd &, bool first_draw, unsigned int frame_number);
 
private:
  std::function<void(void)> onpress;
  Rect rect;
  std::string name = "";
  bool was_pressed_last = false;
};
 
class SliderWidget {
public:
  SliderWidget(double &val, double low, double high, Rect rect, std::string name)
      : value(val), low(low), high(high), rect(rect), name(name) {}
 
  bool update(bool was_pressed, int x, int y);
  void draw(vex::brain::lcd &, bool first_draw, unsigned int frame_number);
 
private:
  double &value;
 
  double low;
  double high;
 
  Rect rect;
  std::string name = "";
};
 
struct WidgetConfig;
 
struct SliderConfig {
  double &val;
  double low;
  double high;
};
struct ButtonConfig {
  std::function<void()> onclick;
};
struct CheckboxConfig {
  std::function<void(bool)> onupdate;
};
struct LabelConfig {
  std::string label;
};
 
struct TextConfig {
  std::function<std::string()> text;
};
struct SizedWidget {
  int size;
  WidgetConfig &widget;
};
struct WidgetConfig {
  enum Type {
    Col,
    Row,
    Slider,
    Button,
    Checkbox,
    Label,
    Text,
    Graph,
  };
  Type type;
  union {
    std::vector<SizedWidget> widgets;
    SliderConfig slider;
    ButtonConfig button;
    CheckboxConfig checkbox;
    LabelConfig label;
    TextConfig text;
    GraphDrawer *graph;
  } config;
};
 
class Page;
class Page {
public:
  virtual void update(bool was_pressed, int x, int y);
  virtual void draw(vex::brain::lcd &screen, bool first_draw, unsigned int frame_number);
};
 
struct ScreenRect {
  uint32_t x1;
  uint32_t y1;
  uint32_t x2;
  uint32_t y2;
};
void draw_widget(WidgetConfig &widget, ScreenRect rect);
 
class WidgetPage : public Page {
public:
  WidgetPage(WidgetConfig &cfg) : base_widget(cfg) {}
  void update(bool was_pressed, int x, int y) override;
 
  void draw(vex::brain::lcd &, bool first_draw, unsigned int frame_number) override {
    draw_widget(base_widget, {.x1 = 20, .y1 = 0, .x2 = 440, .y2 = 240});
  }
 
private:
  WidgetConfig &base_widget;
};
 
void start_screen(vex::brain::lcd &screen, std::vector<Page *> pages, int first_page = 0);
 
void next_page();
void prev_page();
void goto_page(size_t page);
 
void stop_screen();
 
using update_func_t = std::function<void(bool, int, int)>;
 
using draw_func_t = std::function<void(vex::brain::lcd &screen, bool, unsigned int)>;
 
class StatsPage : public Page {
public:
  StatsPage(std::map<std::string, vex::motor &> motors);
  void update(bool was_pressed, int x, int y) override;
  void draw(vex::brain::lcd &, bool first_draw, unsigned int frame_number) override;
 
private:
  void draw_motor_stats(const std::string &name, vex::motor &mot, unsigned int frame, int x, int y,
                        vex::brain::lcd &scr);
 
  std::map<std::string, vex::motor &> motors;
  static const int y_start = 0;
  static const int per_column = 4;
  static const int row_height = 20;
  static const int row_width = 200;
};
 
class OdometryPage : public Page {
public:
  OdometryPage(OdometryBase &odom, double robot_width, double robot_height, bool do_trail);
  void update(bool was_pressed, int x, int y) override;
  void draw(vex::brain::lcd &, bool first_draw, unsigned int frame_number) override;
 
private:
  static const int path_len = 40;
  static constexpr char const *field_filename = "vex_field_240p.png";
 
  OdometryBase &odom;
  double robot_width;
  double robot_height;
  uint8_t *buf = nullptr;
  int buf_size = 0;
  pose_t path[path_len];
  int path_index = 0;
  bool do_trail;
  GraphDrawer velocity_graph;
};
 
class FunctionPage : public Page {
public:
  FunctionPage(update_func_t update_f, draw_func_t draw_t);
  void update(bool was_pressed, int x, int y) override;
  void draw(vex::brain::lcd &, bool first_draw, unsigned int frame_number) override;
 
private:
  update_func_t update_f;
  draw_func_t draw_f;
};
 
class PIDPage : public Page {
public:
  PIDPage(
      PID &pid, std::string name, std::function<void(void)> onchange = []() {});
  PIDPage(
      PIDFF &pidff, std::string name, std::function<void(void)> onchange = []() {});
 
  void update(bool was_pressed, int x, int y) override;
  void draw(vex::brain::lcd &, bool first_draw, unsigned int frame_number) override;
 
private:
  void zero_d_f() { cfg.d = 0; }
  void zero_i_f() { cfg.i = 0; }
 
  PID::pid_config_t &cfg;
  PID &pid;
  const std::string name;
  std::function<void(void)> onchange;
 
  SliderWidget p_slider;
  SliderWidget i_slider;
  SliderWidget d_slider;
  ButtonWidget zero_i;
  ButtonWidget zero_d;
 
  GraphDrawer graph;
};
 
} // namespace screen