interfaces.h

/********************************************************************
*                   Open Source Cartridge Reader                    *
********************************************************************/
#pragma once
#ifndef OSCR_INTERFACES_H_
#define OSCR_INTERFACES_H_
 
#include "syslibinc.h"
#include "config.h"
#include "common/specializations.h"
#include "common/Util.h"
#include "api/Storage.h"
 
#define menuoptionsize(menu) (size_t)sizeof(menu.options[0])
#define menusize(menu) (size_t)(sizeof(menu.options)/sizeof(menu.options[0]))
 
namespace OSCR
{
  namespace UI
  {
    extern bool const kSupportsLineAdjments;

    extern uint8_t const kDisplayWidth;

    extern uint8_t const kDisplayHeight;

    extern uint8_t const kLineHeight;

    extern uint8_t const kDisplayLines;

    extern uint8_t const kDisplayLineStart;

    template <uint8_t optionCount, uint8_t optionLength>
    struct MenuOptions
    {
        char options[optionCount][optionLength];
        OSCR::Util::clamped_value<uint8_t, 0, optionCount> count = optionCount;
        uint8_t const length = optionLength;
        uint8_t const max = optionCount;
 
        char * operator[](size_t idx) { return options[idx]; }
        char const * operator[](size_t idx) const { return options[idx]; }
    };

    extern void drowse();

    extern void sleep();

    extern void wake();

    extern void wait();

    extern void waitButton();

    extern UserInput waitInput();

    extern void setup();

    extern void blinkLED();

    extern void update();

    extern void clear();

    extern void clearLine();

    extern UserInput checkButton();
 
    class RangeSelect
    {
    public:
      RangeSelect(__FlashStringHelper const * menuTitle, uint16_t const rangeMin = 0, uint16_t const rangeMax = UINT16_MAX);
 
      // From UI submodule
      void render();

      uint16_t select();

      uint16_t select(uint16_t const startAt);

      void valueIncrement();

      void valueDecrement();
 
    protected:
      __FlashStringHelper const * title;
      uint16_t minValue;
      uint16_t maxValue;
      uint16_t currentValue;
 
      uint8_t positions;
      uint8_t currentPosition = 0;
      bool rendered = false;
 
      bool valueInBounds(uint32_t newValue);
      int32_t diffValue(bool willRollover, int32_t tens, int8_t rolloverNumber, int8_t step);
      bool adjustValue(bool willRollover, int32_t tens, int8_t rolloverNumber, int8_t step);
 
      uint8_t getPositionsFor(uint16_t value);
      int8_t getNumberAt(uint16_t value, uint8_t position);
      void _setup();
 
      // From UI submodule
      void navigate(NavDir direction);
      void onSelectionChange();
    };

    class MenuRenderer
    {
    public:
      MenuRenderer(char const * menuTitle);
      MenuRenderer(char const * menuTitle, uint16_t entryCount);
 
      MenuRenderer(__FlashStringHelper const * menuTitle);
      MenuRenderer(__FlashStringHelper const * menuTitle, uint16_t entryCount);
 
      virtual ~MenuRenderer() {}; // Virtual destructor
 
      uint16_t getPage();
      uint16_t getPageCount();
      bool isLast();
      uint16_t getPageEntryCount();
      uint16_t getPageEntryOffset();
      uint16_t getEntryIndex();
      void gotoPage(uint16_t page);
      void navNext();
      void navPrev();
      void nextPage();
      void prevPage();
 
      // From UI submodule
      void render();

      uint16_t select();
 
    protected:
      char title[30] = {};
      uint16_t count;
      uint16_t totalPages;
      uint16_t pageEntriesLast;
 
      uint16_t currentPage = 1;
      uint16_t selection = 0;
      bool rendered = false;
 
      char pageEntries[UI_PAGE_SIZE][UI_PAGE_ENTRY_LENTH_MAX];
 
      // From UI submodule
      void navigate(NavDir direction);
      void onSelectionChange();
 
      // Implementation
      virtual bool onConfirm() = 0;
      virtual void setup() = 0;
      virtual void onPageChange() = 0;
    };

    class MenuBase: public MenuRenderer
    {
    public:
      MenuBase(char const * menuTitle, uint8_t entryCount, MenuMode menuBaseMode, uint8_t entryLength = UI_PAGE_ENTRY_LENTH_MAX);
      MenuBase(__FlashStringHelper const * menuTitle, uint8_t entryCount, MenuMode menuBaseMode, uint8_t entryLength = UI_PAGE_ENTRY_LENTH_MAX);
 
    protected:
      MenuMode menuMode;
      uint8_t entryLengthMax;
 
      // Must be implemented in UI submodule
      void setup();
      bool onConfirm();
    };

    class Menu: public MenuBase
    {
    public:
      Menu(char const * menuTitle, char const * const menuEntries[], uint8_t entryCount);
      Menu(__FlashStringHelper const * menuTitle, char const * const menuEntries[], uint8_t entryCount);
 
      Menu(char const * menuTitle, __FlashStringHelper const * const * menuEntries, uint8_t entryCount);
      Menu(__FlashStringHelper const * menuTitle, __FlashStringHelper const * const * menuEntries, uint8_t entryCount);

      Menu(char const * menuTitle, char * menuEntries[], uint8_t entryCount, uint8_t entryLength = UI_PAGE_ENTRY_LENTH_MAX);
      Menu(__FlashStringHelper const * menuTitle, char * menuEntries[], uint8_t entryCount, uint8_t entryLength = UI_PAGE_ENTRY_LENTH_MAX);
 
    protected:
      char const * const * entries;
 
      // Must be implemented in UI submodule
      void onPageChange();
    };
 
    template<uint8_t optionCount, uint8_t optionLength>
    class MenuOptionsMenu : public MenuBase
    {
    public:
      MenuOptionsMenu(char const * menuTitle, MenuOptions<optionCount, optionLength> & menuEntries);
      MenuOptionsMenu(__FlashStringHelper const * menuTitle, MenuOptions<optionCount, optionLength> & menuEntries);
 
    protected:
      __FlashStringHelper const * templateString;
      MenuOptions<optionCount, optionLength> * entries;
 
      // Must be implemented in UI submodule
      void onPageChange();
    };
 
    class FlashTemplateMenu : public MenuBase
    {
    public:
      FlashTemplateMenu(char const * menuTitle, __FlashStringHelper const * templateStr, char const * const menuEntries[], uint8_t entryCount);
      FlashTemplateMenu(__FlashStringHelper const * menuTitle, __FlashStringHelper const * templateStr, char const * const menuEntries[], uint8_t entryCount);
 
    protected:
      __FlashStringHelper const * templateString;
      char const * const * entries;
 
      // Must be implemented in UI submodule
      void onPageChange();
    };
 
    template <typename T,
              OSCR::Util::if_is_integer_t<T> Enable = true>
    class IntegerTemplateMenu : public MenuBase
    {
    public:
      IntegerTemplateMenu(char const * menuTitle, __FlashStringHelper const * templateStr, T const * menuEntries, uint8_t entryCount);
      IntegerTemplateMenu(__FlashStringHelper const * menuTitle, __FlashStringHelper const * templateStr, T const * menuEntries, uint8_t entryCount);
 
    protected:
      __FlashStringHelper const * templateString;
      T const * entries;
 
      // Must be implemented in UI submodule
      void onPageChange();
    };
 
    uint16_t rangeSelect(__FlashStringHelper const * menuTitle, uint16_t const rangeMax);
    uint16_t rangeSelect(__FlashStringHelper const * menuTitle, uint16_t const rangeMin, uint16_t const rangeMax);
    uint16_t rangeSelect(__FlashStringHelper const * menuTitle, uint16_t const rangeMin, uint16_t const rangeMax, uint16_t const startAt);

    extern uint8_t menu(__FlashStringHelper const * menuTitle, char const * const menuEntries[], uint8_t entryCount);
    extern uint8_t menu(char const * menuTitle, char const * const menuEntries[], uint8_t entryCount);

    extern uint8_t menu(__FlashStringHelper const * menuTitle, __FlashStringHelper const * const * menuEntries, uint8_t entryCount);
    extern uint8_t menu(char const * menuTitle, __FlashStringHelper const * const * menuEntries, uint8_t entryCount);

    extern uint8_t menu(__FlashStringHelper const * menuTitle, char * menuEntries[], uint8_t entryCount, uint8_t entryLength = UI_PAGE_ENTRY_LENTH_MAX);
    extern uint8_t menu(char const * menuTitle, char * menuEntries[], uint8_t entryCount, uint8_t entryLength = UI_PAGE_ENTRY_LENTH_MAX);
 
    extern uint8_t menu(__FlashStringHelper const * menuTitle, __FlashStringHelper const * templateStr, char const * const menuEntries[], uint8_t entryCount);
    extern uint8_t menu(char const * menuTitle, __FlashStringHelper const * templateStr, char const * const menuEntries[], uint8_t entryCount);
 
    template <typename T,
              OSCR::Util::enable_if_t<OSCR::Util::is_integer<T>::value, bool> Enable = true>
    extern uint8_t menu(__FlashStringHelper const * menuTitle, __FlashStringHelper const * templateStr, T const * menuEntries, uint8_t entryCount);
 
    template <typename T,
              OSCR::Util::enable_if_t<OSCR::Util::is_integer<T>::value, bool> Enable = true>
    extern uint8_t menu(char const * menuTitle, __FlashStringHelper const * templateStr, T const * menuEntries, uint8_t entryCount);

    template class IntegerTemplateMenu<uint8_t>;
    template class IntegerTemplateMenu<uint16_t>;

    template<uint8_t optionCount, uint8_t optionLength>
    extern uint8_t menu(__FlashStringHelper const * menuTitle, MenuOptions<optionCount, optionLength> & menuEntries);
 
    template<uint8_t optionCount, uint8_t optionLength>
    extern uint8_t menu(char const * menuTitle, MenuOptions<optionCount, optionLength> & menuEntries);

    template class MenuOptionsMenu< 7, 20>;
    template class MenuOptionsMenu<10, 20>;

    extern void printHeader(char const * title);
    extern void printHeader(__FlashStringHelper const * title);

    extern void printNotificationHeader(char const * title);
    extern void printNotificationHeader(__FlashStringHelper const * title);

    extern void printErrorHeader(char const * title);
    extern void printErrorHeader(__FlashStringHelper const * title);

    extern void printFatalErrorHeader(char const * title);
    extern void printFatalErrorHeader(__FlashStringHelper const * title);

    template <bool prfx = true,
              typename T,
              OSCR::Util::if_is_any_unsigned_t<T> Enable = true>
    extern void printHex(T number);

    template <bool prfx = true,
              typename T,
              OSCR::Util::if_is_any_unsigned_t<T> Enable = true>
    extern void printHexLine(T number);

    template <bool sync = false,
              typename T,
              OSCR::Util::enable_if_t<!(OSCR::Util::is_number<T>::value), bool> Enable = true,
              OSCR::Util::enable_if_t<!(OSCR::Util::is_printable<T>::value), bool> NonPrintable = true>
    extern void print(T string);

    template <bool sync = false,
              typename T,
              OSCR::Util::enable_if_t<!(OSCR::Util::is_number<T>::value), bool> Enable = true,
              OSCR::Util::enable_if_t<!(OSCR::Util::is_printable<T>::value), bool> NonPrintable = true>
    extern void printLine(T string);

    template <typename T,
              OSCR::Util::enable_if_t<!(OSCR::Util::is_number<T>::value), bool> Enable = true,
              OSCR::Util::enable_if_t<!(OSCR::Util::is_printable<T>::value), bool> NonPrintable = true>
    inline void printSync(T string)
    {
      OSCR::UI::print<true>(string);
    }

    template <typename T,
              OSCR::Util::enable_if_t<!(OSCR::Util::is_number<T>::value), bool> Enable = true,
              OSCR::Util::enable_if_t<!(OSCR::Util::is_printable<T>::value), bool> NonPrintable = true>
    inline void printLineSync(T string)
    {
      OSCR::UI::printLine<true>(string);
    }

    template <bool sync = false>
    extern void printLine(void);

    inline void printLineSync(void)
    {
      OSCR::UI::printLine<true>();
    }

    template <bool sync = false,
              typename Tint,
              OSCR::Util::enable_if_t<OSCR::Util::is_integer<Tint>::value, bool> Enable = true>
    extern void print(Tint number, int base = DEC);

    template <bool sync = false,
              typename Tint,
              OSCR::Util::enable_if_t<OSCR::Util::is_integer<Tint>::value, bool> Enable = true>
    extern void printLine(Tint number, int base = DEC);

    template <bool sync = false,
              typename Tint,
              OSCR::Util::enable_if_t<OSCR::Util::is_integer<Tint>::value, bool> Enable = true>
    inline void printSync(Tint number, int base = DEC)
    {
      OSCR::UI::print<true>(number, base);
    }

    template <bool sync = false,
              typename Tint,
              OSCR::Util::enable_if_t<OSCR::Util::is_integer<Tint>::value, bool> Enable = true>
    extern void printLineSync(Tint number, int base = DEC)
    {
      OSCR::UI::printLine<true>(number, base);
    }

    //inline void print(double number, int digits = 1) = delete;
    //inline void printSync(double number, int digits = 1) = delete;

    //inline void printLine(double number, int digits = 1) = delete;
    //inline void printLineSync(double number, int digits = 1) = delete;

    extern void setLineRel(int8_t numLines);

    extern void gotoLast();

    extern void gotoLine(uint8_t lineNumber);

    extern void gotoLineBottom(uint8_t lineNumber);

    extern bool overlapsCurrentLine(uint8_t lineNumber);

    extern bool overlapsCurrentLineBottom(uint8_t lineNumber);

    extern void _notificationFormat();

    extern void _notification(void);

    extern void _errorFormat();

    extern void _error();

    extern void _fatalErrorFormat();

    [[ noreturn ]] extern void _fatalError();

    extern void notification(void);

    template <typename T,
              OSCR::Util::enable_if_t<!(OSCR::Util::is_number<T>::value), bool> Enable = true>
    extern void notification(T message);

    extern void error(void);

    template <typename T,
              OSCR::Util::enable_if_t<!(OSCR::Util::is_number<T>::value), bool> Enable = true>
    extern void error(T message);

    extern void fatalError(void);

    template <typename T,
              OSCR::Util::enable_if_t<!(OSCR::Util::is_number<T>::value), bool> Enable = true>
    [[ noreturn ]] extern void fatalError(T message);

    [[ noreturn ]] extern void ncFatalErrorStorage();

    [[ noreturn ]] extern void fatalErrorStorage();

    [[ noreturn ]] extern void fatalErrorBufferOverflow();

    [[ noreturn ]] extern void fatalErrorNameOverflow();

    [[ noreturn ]] extern void fatalErrorNoBuffer();

    [[ noreturn ]] extern void fatalErrorInvalidData();

    namespace ProgressBar
    {
      extern __constinit uint32_t current;

      extern __constinit uint32_t total;

      extern void init(uint32_t maxProgress);

      extern void init(uint32_t maxProgress, uint8_t lineOffset);

      extern void advance(uint32_t steps = 1);

      extern void finish();

      extern void render(bool end = false);
    }
  }
}
 
#endif /* OSCR_INTERFACES_H_ */