Menu.hh

Go to the documentation of this file.

#ifndef COSA_MENU_HH
#define COSA_MENU_HH

#include "Cosa/LCD.hh"
#include "Cosa/IOStream.hh"

#include <Rotary.h>
#include "Cosa/Button.hh"
#include "Cosa/Keypad.hh"

class Menu {
public:
  enum type_t {
    ITEM,                       
    ITEM_LIST,                  
    ONE_OF,                     
    ZERO_OR_MANY,               
    BCD_RANGE,                  
    INT_RANGE,                  
    ACTION                      
  } __attribute__((packed));

  struct item_t {
    type_t type;                
    str_P name;                 
  };
  typedef const PROGMEM item_t* item_P;
  typedef const PROGMEM item_P* item_vec_P;

  struct item_list_t {
    item_t item;                
    item_vec_P list;            
  };
  typedef const PROGMEM item_list_t* item_list_P;

  struct one_of_t {
    item_t item;                
    item_vec_P list;            
    uint16_t* value;            
  };
  typedef const PROGMEM one_of_t* one_of_P;
  static void print(IOStream& outs, one_of_P var);

  typedef one_of_t zero_or_many_t;
  typedef const PROGMEM zero_or_many_t* zero_or_many_P;
  static void print(IOStream& outs, zero_or_many_P var, bool selected, uint8_t bv);

  struct bcd_range_t {
    item_t item;                
    uint8_t low;                
    uint8_t high;               
    uint8_t* value;             
  };
  typedef const PROGMEM bcd_range_t* bcd_range_P;

  struct int_range_t {
    item_t item;                
    int16_t low;                
    int16_t high;               
    int16_t* value;             
  };
  typedef const PROGMEM int_range_t* int_range_P;
  static void print(IOStream& outs, int_range_P var, bool selected);

  class Action {
  public:
    virtual bool run(Menu::item_P item) = 0;
  };

  struct action_t {
    item_t item;                
    Action* obj;                
  };
  typedef const PROGMEM action_t* action_P;

  class Walker {
  private:
    static const uint8_t STACK_MAX = 8;
    Menu::item_list_P m_stack[STACK_MAX];
    uint8_t m_top;

    uint8_t m_ix;

    uint8_t m_bv;

    bool m_selected;

    IOStream m_out;

    void on_key_down(uint8_t nr, zero_or_many_P var);

  public:
    enum {
      NO_KEY = 0,
      SELECT_KEY,
      LEFT_KEY,
      DOWN_KEY,
      UP_KEY,
      RIGHT_KEY
    } __attribute__((packed));

    Walker(LCD::Device* lcd, item_list_P root) :
      m_top(0),
      m_ix(0),
      m_bv(0),
      m_selected(false),
      m_out(lcd)
    {
      m_stack[m_top] = root;
    }

    void on_key_down(uint8_t nr);

    friend IOStream& operator<<(IOStream& outs, Walker& walker);

    void begin(bool flag = true)
    {
      if (flag) m_out << clear << *this;
    }

    Menu::type_t type();
  };

  class KeypadController : public LCD::Keypad {
  public:
    Walker* m_walker;

  public:
    KeypadController(Walker* walker, Job::Scheduler* scheduler) :
      LCD::Keypad(scheduler),
      m_walker(walker)
    {}

    virtual void on_key_down(uint8_t nr)
    {
      m_walker->on_key_down(nr);
    }
  };

  class RotaryController : public Rotary::Encoder {
  private:
    class RotaryButton : public Button {
    private:
      Menu::Walker* m_walker;

    public:
      RotaryButton(Menu::Walker* walker,
                   Job::Scheduler* scheduler,
                   Board::DigitalPin pin = Board::D2) :
        Button(scheduler, pin, Button::ON_FALLING_MODE),
        m_walker(walker)
      {}

      virtual void on_change(uint8_t type)
      {
        UNUSED(type);
        m_walker->on_key_down(Menu::Walker::SELECT_KEY);
      }
    };

    Menu::Walker* m_walker;

    RotaryButton m_sw;

  public:
    RotaryController(Menu::Walker* walker,
                     Job::Scheduler* scheduler,
                     Board::InterruptPin clk = Board::PCI4,
                     Board::InterruptPin dt = Board::PCI3,
                     Board::DigitalPin sw = Board::D2) :
      Rotary::Encoder(clk, dt),
      m_walker(walker),
      m_sw(walker, scheduler, sw)
    {}

    virtual void on_event(uint8_t type, uint16_t direction);

    void begin()
    {
      PinChangeInterrupt::begin();
      m_sw.start();
    }
  };
};

#define MENU_BEGIN(var,name)                            \
  const char var ## _name[] __PROGMEM = name;           \
  const Menu::item_P var ## _list[] __PROGMEM = {

#define MENU_ITEM(var)                                  \
  &var.item,

#define MENU_END(var)                                   \
    0                                                   \
  };                                                    \
  const Menu::item_list_t var __PROGMEM = {             \
  {                                                     \
    Menu::ITEM_LIST,                                    \
    (str_P) var ## _name                                \
  },                                                    \
  var ## _list                                          \
};

#define MENU_SYMB(var,name)                             \
  const char var ## _name[] __PROGMEM = name;           \
  const Menu::item_t var __PROGMEM = {                  \
    Menu::ITEM,                                         \
    (str_P) var ## _name                                \
  };

#define MENU_ENUM_BEGIN(var)                            \
  const Menu::item_P var ## _list[] __PROGMEM = {

#define MENU_ENUM_ITEM(var)                             \
  &var,

#define MENU_ENUM_END(var)                              \
  0                                                     \
  };

#define MENU_ONE_OF(type,var,name,value)                \
  const char var ## _name[] __PROGMEM = name;           \
  const Menu::one_of_t var __PROGMEM = {                \
  {                                                     \
    Menu::ONE_OF,                                       \
    (str_P) var ## _name                                \
  },                                                    \
  type ## _list,                                        \
  &value                                                \
};

#define MENU_ZERO_OR_MANY(type,var,name,value)          \
  const char var ## _name[] __PROGMEM = name;           \
  const Menu::zero_or_many_t var __PROGMEM = {          \
  {                                                     \
    Menu::ZERO_OR_MANY,                                 \
    (str_P) var ## _name                                \
  },                                                    \
  type ## _list,                                        \
  &value                                                \
};

#define MENU_INT_RANGE(var,name,low,high,value)         \
  const char var ## _name[] __PROGMEM = name;           \
  const Menu::int_range_t var __PROGMEM = {             \
  {                                                     \
    Menu::INT_RANGE,                                    \
    (str_P) var ## _name                                \
  },                                                    \
  low,                                                  \
  high,                                                 \
  &value                                                \
};

#define MENU_ACTION(var,name,obj)                       \
  const char var ## _name[] __PROGMEM = name;           \
  const Menu::action_t var __PROGMEM = {                \
  {                                                     \
    Menu::ACTION,                                       \
    (str_P) var ## _name                                \
  },                                                    \
  &obj                                                  \
  };
#endif