RuntimeMenuItem.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 _RUNTIME_MENUITEM_H_
#define _RUNTIME_MENUITEM_H_
 
#include "MenuItems.h"
#include "tcUtil.h"

#ifndef RANDOM_ID_START
#define RANDOM_ID_START 30000
#endif

menuid_t nextRandomId();

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

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

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

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

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

enum MultiEditWireType : uint8_t {
    EDITMODE_PLAIN_TEXT = 0,
    EDITMODE_IP_ADDRESS = 1,
    EDITMODE_TIME_24H = 2,
    EDITMODE_TIME_12H = 3,
    EDITMODE_TIME_HUNDREDS_24H = 4,
    EDITMODE_GREGORIAN_DATE = 5,
    EDITMODE_TIME_DURATION_SECONDS = 6,
    EDITMODE_TIME_DURATION_HUNDREDS = 7,
    EDITMODE_TIME_24H_HHMM = 8,
    EDITMODE_TIME_12H_HHMM = 9,
};

class RuntimeMenuItem : public MenuItem {
protected:
    menuid_t id;
    uint8_t itemPosition;
    uint8_t noOfParts;
public:
    RuntimeMenuItem(MenuType menuType, menuid_t id, RuntimeRenderingFn renderFn,
                    uint8_t itemPosition, uint8_t numberOfRows, MenuItem* next = nullptr);
 
    RuntimeMenuItem(const AnyMenuInfo* rtInfo, bool isPgm, MenuType menuType, RuntimeRenderingFn renderFn,
                    uint8_t itemPosition, uint8_t numberOfRows, MenuItem* next = nullptr);
 
    void copyValue(char* buffer, int bufferSize) const {
        renderFn((RuntimeMenuItem*)this, itemPosition, RENDERFN_VALUE, buffer, bufferSize);
    }
 
    void runCallback() const { renderFn((RuntimeMenuItem*)this, itemPosition, RENDERFN_INVOKE, nullptr, 0); }
    [[nodiscard]] int getRuntimeId() const { return int(id); }
    [[nodiscard]] int getRuntimeEeprom() const { return renderFn((RuntimeMenuItem*)this, itemPosition, RENDERFN_EEPROM_POS, nullptr, 0); }
    [[nodiscard]] uint8_t getNumberOfParts() const { return noOfParts; }
    void copyRuntimeName(char* buffer, int bufferSize) const { renderFn((RuntimeMenuItem*)this, itemPosition, RENDERFN_NAME, buffer, bufferSize);}
 
    [[nodiscard]] uint8_t getNumberOfRows() const { return noOfParts; }
    [[nodiscard]] uint8_t getItemPosition() const { return itemPosition; }
 
    void setNumberOfRows(uint8_t rows) {
        noOfParts = rows;
        setChanged(true); 
        setSendRemoteNeededAll(); 
    }
};

class BackMenuItem : public RuntimeMenuItem {
private:
    const char* namePtr;
public:
    BackMenuItem(RuntimeRenderingFn renderFn, MenuItem* next) 
        : RuntimeMenuItem(MENUTYPE_BACK_VALUE, nextRandomId(), renderFn, 0, 1, next), namePtr(nullptr) { }

    BackMenuItem(const SubMenuInfo* info, MenuItem* next, bool infoInPgm);

    [[nodiscard]] const char* getNameUnsafe() const { return namePtr; }
};

class SubMenuItem : public RuntimeMenuItem {
private:
    MenuItem* child;
public:
    SubMenuItem(const SubMenuInfo* info, MenuItem* child, MenuItem* next = nullptr, bool infoInPgm = INFO_LOCATION_PGM)
                : RuntimeMenuItem(info, infoInPgm, MENUTYPE_SUB_VALUE, backSubItemRenderFn, 0, 1, next) {
        this->child = child;
    }

    SubMenuItem(menuid_t id, RuntimeRenderingFn renderFn, MenuItem* child, MenuItem* next = nullptr)
            : RuntimeMenuItem(MENUTYPE_SUB_VALUE, id, renderFn,
                              0, 1, next) {
        this->child = child;
    }

    [[nodiscard]] MenuItem* getChild() const { return child; }
    void setChild(MenuItem* firstChildItem) { this->child = firstChildItem; }
};
 
#define LIST_PARENT_ITEM_POS 0xff

class ListRuntimeMenuItem : public RuntimeMenuItem {
public:
    enum ListMode: uint8_t { CUSTOM_RENDER, RAM_ARRAY, FLASH_ARRAY };
private:
    const char* const* dataArray;
    uint8_t activeItem;
    ListMode listMode = CUSTOM_RENDER;
public:
    ListRuntimeMenuItem(const AnyMenuInfo* info, int numberOfRows, const char* const* array, ListMode listMode, MenuItem* next = nullptr, bool isPgm = INFO_LOCATION_PGM);
    ListRuntimeMenuItem(const AnyMenuInfo* info, int numberOfRows, RuntimeRenderingFn renderFn, MenuItem* next = nullptr, bool isPgm = INFO_LOCATION_PGM);
    ListRuntimeMenuItem(menuid_t id, int numberOfRows, RuntimeRenderingFn renderFn, MenuItem* next = nullptr);
 
    RuntimeMenuItem* getChildItem(int pos);
    RuntimeMenuItem* asParent();
    RuntimeMenuItem* asBackMenu();
 
    [[nodiscard]] ListMode getListMode() const {return listMode;}
    [[nodiscard]] bool isActingAsParent() const { return itemPosition == LIST_PARENT_ITEM_POS; }
    [[nodiscard]] uint8_t getActiveIndex() const { return activeItem; }
    void setActiveIndex(uint8_t idx) {
        activeItem = idx;
        setChanged(true);
    }
    const char* const* getDataArray() { return dataArray; }
};
 
int defaultRtListCallback(RuntimeMenuItem* item, uint8_t row, RenderFnMode mode, char* buffer, int bufferSize);

class EditableMultiPartMenuItem : public RuntimeMenuItem {
public:
    EditableMultiPartMenuItem(MenuType type, menuid_t id, int numberOfParts, RuntimeRenderingFn renderFn, MenuItem* next = nullptr)
            : RuntimeMenuItem(type, id, renderFn, 0, numberOfParts, next) {
    }
    EditableMultiPartMenuItem(const AnyMenuInfo* rtInfo, bool isPgm, MenuType type, int numberOfParts, RuntimeRenderingFn renderFn, MenuItem* next = nullptr)
            : RuntimeMenuItem(rtInfo, isPgm, type, renderFn, 0, numberOfParts, next) {
    }
 
    uint8_t beginMultiEdit();
 
    int changeEditBy(int amt);
 
    int previousPart();
 
    int nextPart();
 
    [[nodiscard]] int getCurrentRange() const {
        return renderFn((RuntimeMenuItem*)this, itemPosition, RENDERFN_GETRANGE, nullptr, 0);
    }
    
    void stopMultiEdit();
 
    [[nodiscard]] int getPartValueAsInt() const {
        return renderFn((RuntimeMenuItem*)this, itemPosition, RENDERFN_GETPART, nullptr, 0);
    }
 
    bool valueChanged(int newVal);
};
 
// number of characters in the edit set.
#define ALLOWABLE_CHARS_ENCODER_SIZE 94

class TextMenuItem : public EditableMultiPartMenuItem {
private:
    char* data;
    bool passwordField;
public:
    TextMenuItem(RuntimeRenderingFn customRenderFn, menuid_t id, int size, MenuItem* next = nullptr);
    TextMenuItem(RuntimeRenderingFn customRenderFn, const char* initial, menuid_t id, int size, MenuItem* next = nullptr);
    TextMenuItem(const AnyMenuInfo* info, const char* initial, int size, MenuItem* next = nullptr, bool isPgm = INFO_LOCATION_PGM);

    TextMenuItem(const AnyMenuInfo* info, RuntimeRenderingFn customRenderFn, const char* initial, int size, MenuItem* next = nullptr, bool isPgm = INFO_LOCATION_PGM);
 
    void setPasswordField(bool pwd) {
        this->passwordField = pwd;
    }

    [[nodiscard]] bool isPasswordField() const {
        return this->passwordField;
    }
 
    ~TextMenuItem() { delete[] data; }

    [[nodiscard]] uint8_t textLength() const { return noOfParts; }

    void setTextValue(const char* text, bool silent = false);

    [[nodiscard]] const char* getTextValue() const { return data; }

    void cleanUpArray();

    bool setCharValue(uint8_t location, char val);

    bool valueChangedFromKeyboard(char keyPress);
private:
    void initTextItem(const char* initialData);
};

int findPositionInEditorSet(char ch);

class IpAddressStorage {
private:
    uint8_t data[4];
public:
    explicit IpAddressStorage(const char* address);
    IpAddressStorage(uint8_t p1, uint8_t p2, uint8_t p3, uint8_t p4);
    IpAddressStorage(const IpAddressStorage& other) = default;
    IpAddressStorage& operator=(const IpAddressStorage& other) = default;
 
    void setPart(int part, uint8_t newValue) { data[part] = newValue; }
    uint8_t* underlyingArray() { return data; }
};

class IpAddressMenuItem : public EditableMultiPartMenuItem {
private:
    IpAddressStorage data;
public:
    IpAddressMenuItem(RuntimeRenderingFn renderFn, menuid_t id, MenuItem* next = nullptr)
        : EditableMultiPartMenuItem(MENUTYPE_IPADDRESS, id, 4, renderFn, next), data(127, 0, 0, 1) {}

    IpAddressMenuItem(RuntimeRenderingFn renderFn, const IpAddressStorage& initialIp, menuid_t id, MenuItem* next = nullptr)
        : EditableMultiPartMenuItem(MENUTYPE_IPADDRESS, id, 4, renderFn, next), data(initialIp) {}

    IpAddressMenuItem(const AnyMenuInfo* info, RuntimeRenderingFn renderFn, const IpAddressStorage& initialIp, MenuItem* next = nullptr, bool isPgm = INFO_LOCATION_PGM)
            : EditableMultiPartMenuItem(info, isPgm, MENUTYPE_IPADDRESS, 4, renderFn, next), data(initialIp) {}

    IpAddressMenuItem(const AnyMenuInfo* info, const IpAddressStorage& initialIp, MenuItem* next = nullptr, bool isPgm = INFO_LOCATION_PGM)
            : EditableMultiPartMenuItem(info, isPgm, MENUTYPE_IPADDRESS, 4, ipAddressRenderFn, next), data(initialIp) {}
 
    void setIpAddress(const char* source);

    void setIpAddress(uint8_t p1, uint8_t p2, uint8_t p3, uint8_t p4) {
        data = IpAddressStorage(p1, p2, p3, p4);
    }

    uint8_t* getIpAddress() { return data.underlyingArray(); }
 
    void setUnderlying(const IpAddressStorage& other);
 
    IpAddressStorage& getUnderlying() { return data; }
    
    void setIpPart(uint8_t part, uint8_t newVal);
};

struct TimeStorage {
    TimeStorage() {
        this->hours = this->minutes = this->seconds = this->hundreds = 0;
    }
    TimeStorage(uint8_t hours, uint8_t minutes, uint8_t seconds = 0, uint8_t hundreds = 0) {
        this->hours = hours;
        this->minutes = minutes;
        this->seconds = seconds;
        this->hundreds = hundreds;
    }
    TimeStorage(const TimeStorage& other) = default;
    TimeStorage& operator=(const TimeStorage& other) = default;
 
    uint8_t hours;
    uint8_t minutes;
    uint8_t seconds;
    uint8_t hundreds;
};

struct DateStorage {
    uint8_t day;
    uint8_t month;
    uint16_t year;
 
    DateStorage() {
        year = day = month = 0;
    }
 
    DateStorage(int day, int month, int year) {
        this->day = day;
        this->month = month;
        this->year = year;
    }
 
    DateStorage(const DateStorage& other) = default;
    DateStorage& operator=(const DateStorage& other)=default;
};

class TimeFormattedMenuItem : public EditableMultiPartMenuItem {
private:
    MultiEditWireType format;
    TimeStorage data;
public:
    TimeFormattedMenuItem(RuntimeRenderingFn renderFn, menuid_t id, MultiEditWireType format, MenuItem* next = nullptr);
    TimeFormattedMenuItem(RuntimeRenderingFn renderFn, const TimeStorage& initial, menuid_t id, MultiEditWireType format, MenuItem* next = nullptr);
    TimeFormattedMenuItem(const AnyMenuInfo* info, RuntimeRenderingFn renderFn, const TimeStorage& initial, MultiEditWireType format, MenuItem* next = nullptr, bool isPgm = INFO_LOCATION_PGM);
    TimeFormattedMenuItem(const AnyMenuInfo* info, const TimeStorage& initial, MultiEditWireType format, MenuItem* next = nullptr, bool isPgm = INFO_LOCATION_PGM);

    [[nodiscard]] TimeStorage getTime() const { return data; }
    
    void setTime(TimeStorage newTime) { data = newTime; }

    void setTimeFromString(const char* time);

    [[nodiscard]] MultiEditWireType  getFormat() const { return format; }
 
    TimeStorage* getUnderlyingData() {return &data;}
};

class DateFormattedMenuItem : public EditableMultiPartMenuItem {
public:
    enum DateFormatOption { DD_MM_YYYY, MM_DD_YYYY, YYYY_MM_DD };
private:
    DateStorage data;
    static char separator;
    static DateFormatOption dateFormatMode;
public:
    DateFormattedMenuItem(RuntimeRenderingFn renderFn, menuid_t id, MenuItem* next = nullptr)
            : EditableMultiPartMenuItem(MENUTYPE_DATE, id, 3, renderFn, next), data(1, 1, 2020) {}
 
    DateFormattedMenuItem(RuntimeRenderingFn renderFn, const DateStorage& initial, menuid_t id, MenuItem* next = nullptr)
            : EditableMultiPartMenuItem(MENUTYPE_DATE, id, 3, renderFn, next), data(initial) {}
 
    DateFormattedMenuItem(const AnyMenuInfo* info, RuntimeRenderingFn renderFn, const DateStorage& initial, menuid_t /*id*/, MenuItem* next = nullptr, bool isPgm = INFO_LOCATION_PGM)
            : EditableMultiPartMenuItem(info, isPgm, MENUTYPE_DATE, 3, renderFn, next), data(initial) {}
 
    DateFormattedMenuItem(const AnyMenuInfo* info, const DateStorage& initial, MenuItem* next = nullptr, bool isPgm = INFO_LOCATION_PGM)
            : EditableMultiPartMenuItem(info, isPgm, MENUTYPE_DATE, 3, dateItemRenderFn, next), data(initial) {}

    static void setDateSeparator(char sep) {
        separator = sep;
    }

    static char getDateSeparator() {
        return separator;
    }

    static void setDateFormatStyle(DateFormatOption fmt) {
        dateFormatMode = fmt;
    }

    static DateFormatOption getDateFormatStyle() {
        return dateFormatMode;
    }
 
    [[nodiscard]] DateStorage getDate() const { return data; }
 
    void setDate(DateStorage newDate) { data = newDate; }
 
    void setDateFromString(const char *dateText);
 
    DateStorage* getUnderlyingData() { return &data; }
};

long parseIntUntilSeparator(const char* ptr, int& offset, size_t maxDigits=10);

inline void invokeIfSafe(MenuCallbackFn cb, MenuItem* pItem) { if(cb && pItem) cb(pItem->getId()); }

#define RENDERING_CALLBACK_NAME_INVOKE(fnName, parent, namepgm, eepromPosition, invoke) \
const char fnName##Pgm[] PROGMEM = namepgm; \
int fnName(RuntimeMenuItem* item, uint8_t row, RenderFnMode mode, char* buffer, int buffSize) { \
    switch(mode) { \
    case RENDERFN_NAME: \
        safeProgCpy(buffer, fnName##Pgm, buffSize); \
        return true; \
    case RENDERFN_INVOKE: \
        invokeIfSafe(invoke, item); \
        return true; \
    case RENDERFN_EEPROM_POS: \
        return eepromPosition; \
    default: \
        return parent(item, row, mode, buffer, buffSize); \
    } \
}

#define RENDERING_CALLBACK_NAME_OVERRIDDEN(fnName, customFn, namepgm, eepromPosition) \
const char fnName##Pgm[] PROGMEM = namepgm; \
int fnName(RuntimeMenuItem* item, uint8_t row, RenderFnMode mode, char* buffer, int buffSize) { \
    switch(mode) { \
    case RENDERFN_NAME: \
        if(customFn(item, row, mode, buffer, buffSize) == false) {  \
            safeProgCpy(buffer, fnName##Pgm, buffSize); \
        } \
        return true; \
    case RENDERFN_EEPROM_POS: \
        return eepromPosition; \
    default: \
        return customFn(item, row, mode, buffer, buffSize); \
    } \
}
 
#endif //_RUNTIME_MENUITEM_H_