MenuItems.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018 https://www.thecoderscorner.com (Dave Cherry).
 * This product is licensed under an Apache license, see the LICENSE file in the top-level directory.
 */

 
#ifndef _MENUITEMS_h
#define _MENUITEMS_h
 
#define INFO_LOCATION_PGM true
#define INFO_LOCATION_RAM false
 
#include <PlatformDetermination.h>
#include <IoAbstraction.h>

#define MAXIMUM_ID_ALLOWED 32000
 
typedef uint16_t menuid_t;

#define INVALID_MENU_ID 0xffff

#ifndef NAME_SIZE_T
#define NAME_SIZE_T 20
#endif // NAME_SIZE_T

#ifndef UNIT_SIZE_T
#define UNIT_SIZE_T 5
#endif // NAME_SIZE_T

#define NO_CALLBACK NULL

typedef void (*MenuCallbackFn)(int id);

struct AnyMenuInfo { 
    char name[NAME_SIZE_T];
    menuid_t id;
    uint16_t eepromAddr;
    uint16_t maxValue;
    MenuCallbackFn callback;
};

struct AnalogMenuInfo { 
    char name[NAME_SIZE_T];
    menuid_t id;
    uint16_t eepromAddr;
    uint16_t maxValue;
    MenuCallbackFn callback;

    int16_t offset;
    uint16_t divisor;
    char unitName[UNIT_SIZE_T];
};

struct EnumMenuInfo { 
    char name[NAME_SIZE_T];
    menuid_t id;
    uint16_t eepromAddr;
    uint16_t maxValue;
    MenuCallbackFn callback;

    const char * const *menuItems;
};

enum BooleanNaming : uint8_t {
    NAMING_TRUE_FALSE = 0,
    NAMING_ON_OFF,
    NAMING_YES_NO,
    NAMING_CHECKBOX
};

struct BooleanMenuInfo { 
    char name[NAME_SIZE_T];
    menuid_t id;
    uint16_t eepromAddr;
    uint16_t maxValue;
    MenuCallbackFn callback;

    BooleanNaming naming;
};

typedef AnyMenuInfo SubMenuInfo;

struct FloatMenuInfo { 
    char name[NAME_SIZE_T];
    menuid_t id;
    uint16_t eepromAddr;
    uint16_t numDecimalPlaces;
    MenuCallbackFn callback;
};
 
union AllMenuInfoTypes {
    AnyMenuInfo anyInfo;
    AnalogMenuInfo analogInfo;
    EnumMenuInfo enumInfo;
    BooleanMenuInfo booleanInfo;
    SubMenuInfo subInfo;
    FloatMenuInfo floatInfo;
};

enum Flags : uint8_t {
    MENUITEM_CHANGED = 0,
    MENUITEM_CHANGED_1 = 1,
    MENUITEM_READONLY = 3,
    MENUITEM_LOCAL_ONLY = 4,
    MENUITEM_PIN_SECURED = 5,
    MENUITEM_PIN_VISIBLE = 6,
    MENUITEM_INFO_STRUCT_PGM = 7,

    MENUITEM_REMOTE_SEND0 = 10,
    MENUITEM_REMOTE_SEND1 = 11,
    MENUITEM_REMOTE_SEND2 = 12,
    MENUITEM_REMOTE_SEND3 = 13,
    MENUITEM_REMOTE_SEND4 = 14,
    MENUITEM_REMOTE_SEND5 = 15
};
 
#define MENUITEM_ALL_REMOTES 0xFC00
#define MENUITEM_ALL_CHANGE 0x0003

enum MenuType : uint8_t {
    MENUTYPE_INT_VALUE = 1, 
    MENUTYPE_ENUM_VALUE = 2,
    MENUTYPE_BOOLEAN_VALUE = 3,
    MENUTYPE_FLOAT_VALUE = 101,
    MENUTYPE_ACTION_VALUE = 102,
    MENUTYPE_RUNTIME_VALUE = 150,
    MENUTYPE_RUNTIME_LIST = 151,
    MENUTYPE_BACK_VALUE = 152,
    MENUTYPE_ACTIVATE_SUBMENU = 153,
    MENUTYPE_SCROLLER_VALUE = 154,
    MENUTYPE_SUB_VALUE = 155,
    MENUTYPE_TITLE_ITEM = 156,
    MENUTYPE_DIALOG_BUTTON = 157,

    MENUTYPE_TEXT_VALUE = 200,
    MENUTYPE_IPADDRESS = 201,
    MENUTYPE_TIME = 202,
    MENUTYPE_DATE = 203,
    MENUTYPE_LARGENUM_VALUE = 210,
    MENUTYPE_COLOR_VALUE = 211
};

enum RenderFnMode : uint8_t {
    RENDERFN_VALUE,
    RENDERFN_NAME,
    RENDERFN_EEPROM_POS,
    RENDERFN_INVOKE,
    RENDERFN_ACTIVATE,
    RENDERFN_SET_VALUE,
    RENDERFN_GETRANGE,
    RENDERFN_GETPART,
    RENDERFN_SET_TEXT_VALUE
};
 
// forward reference
class RuntimeMenuItem;

typedef int(*RuntimeRenderingFn)(RuntimeMenuItem* item, uint8_t row, RenderFnMode mode, char* buffer, int bufferSize);

class MenuItem {
protected:
    uint16_t flags;
    MenuItem* next;
    const AnyMenuInfo *info = nullptr;
    RuntimeRenderingFn renderFn = nullptr;
    MenuType menuType;
public:
    MenuItem(const MenuItem&) = delete;
    MenuItem& operator=(const MenuItem&) = delete;

    uint8_t copyNameToBuffer(char* sz, int size) const { return copyNameToBuffer(sz, 0, size);}

    uint8_t copyNameToBuffer(char* sz, int offset, int size) const;
    menuid_t getId() const;
    uint16_t getMaximumValue() const;
    uint16_t getEepromPosition() const;
    MenuType getMenuType() const { return menuType; }
    void triggerCallback() const;
 
    bool isInfoProgMem() const { return bitRead(flags, MENUITEM_INFO_STRUCT_PGM); }

    void setChanged(bool changed);
    void setChanged(int num, bool changed) { bitWrite(flags, (num & 3), changed); }
    bool isChanged(int num = 0) const { return bitRead(flags, (num & 3)); }
    bool isSendRemoteNeeded(uint8_t remoteNo) const;
    void setSendRemoteNeededAll();
    void clearSendRemoteNeededAll();
    void setSendRemoteNeeded(uint8_t remoteNo, bool needed);

    void setReadOnly(bool active) { bitWrite(flags, MENUITEM_READONLY, active); }
    bool isReadOnly() const { return bitRead(flags, MENUITEM_READONLY); }

    void setLocalOnly(bool localOnly) { bitWrite(flags, MENUITEM_LOCAL_ONLY, localOnly); }
    bool isLocalOnly() const { return bitRead(flags, MENUITEM_LOCAL_ONLY); }

    void setSecured(bool secured) { bitWrite(flags, MENUITEM_PIN_SECURED, secured); }
    bool isSecured() const { return bitRead(flags, MENUITEM_PIN_SECURED); }

    void setVisible(bool visible) { bitWrite(flags, MENUITEM_PIN_VISIBLE, visible); }
    bool isVisible() const { return bitRead(flags, MENUITEM_PIN_VISIBLE); }

    MenuItem* getNext() const { return next; }
    void setNext(MenuItem* pNext) { this->next = pNext; }

    void changeOccurred(bool silent);
protected:
    MenuItem(MenuType menuType, const AnyMenuInfo* menuInfo, MenuItem* next, bool infoProgMem);
 
};

class ValueMenuItem : public MenuItem {
protected:
    uint16_t currentValue;

    ValueMenuItem(MenuType menuType, const AnyMenuInfo* info, uint16_t defaultVal, MenuItem* next, bool infoPgm)
            : MenuItem(menuType, info, next, infoPgm) {
        this->currentValue = defaultVal;
    }
public:
    void setCurrentValue(uint16_t val, bool silent = false);

    uint16_t getCurrentValue() const { return currentValue; }
};

struct WholeAndFraction {
public:
    WholeAndFraction() {
        this->whole = this->fraction = this->negative = 0;
    }
 
    WholeAndFraction(const WholeAndFraction& that) {
        this->whole = that.whole;
        this->fraction = that.fraction;
        this->negative = that.negative;
    }
 
    WholeAndFraction(uint16_t whole, uint16_t fract, bool negative) {
        this->whole = whole;
        this->fraction = fract;
        this->negative = negative;
    }
    uint32_t whole: 15;
    uint32_t fraction: 16;
    uint32_t negative: 1;
};

class AnalogMenuItem : public ValueMenuItem {
private:
    int8_t step = 1;
public:
    AnalogMenuItem(const AnalogMenuInfo* info, uint16_t defaultVal, MenuItem* next = nullptr, bool infoInPgm = INFO_LOCATION_PGM)
            : ValueMenuItem(MENUTYPE_INT_VALUE, (const AnyMenuInfo*)info, defaultVal, next, infoInPgm) {;}

    int getOffset() const;

    int getStep() const { return step; }

    void setStep(int newStep) { step = newStep; }

    uint16_t getDivisor() const;

    int unitNameLength() const;

    void copyUnitToBuffer(char* unitBuff, uint8_t size = 5) const;

    void copyValue(char* buffer, uint8_t bufferSize) const;
 

    float getAsFloatingPointValue() const;

    void setFromFloatingPointValue(float value);
 
    int getIntValueIncludingOffset() { return (int)currentValue + (int)getOffset(); }

    WholeAndFraction getWholeAndFraction() const;

    void setFromWholeAndFraction(WholeAndFraction wf);

    uint8_t getDecimalPlacesForDivisor() const;

    uint16_t getActualDecimalDivisor() const;
};

class EnumMenuItem : public ValueMenuItem {
public:
    EnumMenuItem(const EnumMenuInfo *info, uint8_t defaultVal, MenuItem* next = nullptr, bool infoInPgm = INFO_LOCATION_PGM)
            : ValueMenuItem(MENUTYPE_ENUM_VALUE, (const AnyMenuInfo*)info, defaultVal, next, infoInPgm) {;}
 
    void copyEnumStrToBuffer(char* buffer, int size, int idx) const;

    int getLengthOfEnumStr(int idx) const;
};

class BooleanMenuItem : public ValueMenuItem {
public:
    BooleanMenuItem(const BooleanMenuInfo* info, bool defaultVal, MenuItem* next = nullptr, bool infoInPgm = INFO_LOCATION_PGM)
            : ValueMenuItem(MENUTYPE_BOOLEAN_VALUE, (const AnyMenuInfo*)info, defaultVal, next, infoInPgm) {;}

    BooleanNaming getBooleanNaming() const;

    bool getBoolean() const {return currentValue != 0;}
    void setBoolean(bool b, bool silent = false) {setCurrentValue(b, silent);}
};

class FloatMenuItem : public MenuItem {
private:
    float currValue;
public:
    FloatMenuItem(const FloatMenuInfo* info, MenuItem* next, bool infoInPgm = INFO_LOCATION_PGM)
            : MenuItem(MENUTYPE_FLOAT_VALUE, (const AnyMenuInfo*)info, next, infoInPgm) { currValue = 0; }

    FloatMenuItem(const FloatMenuInfo* info, float current, MenuItem* next, bool infoInPgm = INFO_LOCATION_PGM)
            : MenuItem(MENUTYPE_FLOAT_VALUE, (const AnyMenuInfo*)info, next, infoInPgm) { currValue = current; }

    int getDecimalPlaces() const;

    void setFloatValue(float newVal, bool silent = false);

    float getFloatValue() const { return currValue; }
};
 

class ActionMenuItem : public MenuItem {
public:
    ActionMenuItem(const AnyMenuInfo* info, MenuItem* next, bool infoInProgmem = INFO_LOCATION_PGM)
            : MenuItem(MENUTYPE_ACTION_VALUE, info, next, infoInProgmem) {;}
};
 
// forward reference
class RuntimeMenuItem;

void copyMenuItemValue(const MenuItem* item, char* buffer, size_t bufferSize, bool active = false);

void copyMenuItemNameAndValue(const MenuItem* item, char* buffer, size_t bufferSize, char additionalSep = ':', bool active = false);

void copyMenuItemValueDefault(const MenuItem* item, char* buffer, size_t bufferSize, const char* defValue, bool active = false);

inline bool isMenuBasedOnValueItem(const MenuItem* item) {
    if(item == nullptr) return false;
    auto ty =  uint8_t(item->getMenuType());
    return ty == MENUTYPE_INT_VALUE || ty == MENUTYPE_ENUM_VALUE || ty == MENUTYPE_BOOLEAN_VALUE;
}

inline bool isMenuRuntime(const MenuItem* t) {
    return t && (uint8_t(t->getMenuType()) >= uint8_t(MENUTYPE_RUNTIME_VALUE));
}

inline bool isMenuRuntimeMultiEdit(const MenuItem* t) {
    return t && (uint8_t(t->getMenuType()) >= uint8_t(MENUTYPE_TEXT_VALUE));
}

inline const RuntimeMenuItem* asRuntimeItem(const MenuItem* i) {
    return reinterpret_cast<const RuntimeMenuItem*>(i);
}
 
#endif