MenuIterator.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.
 */
 
#include <PlatformDetermination.h>
#include "ScrollChoiceMenuItem.h"

 
#ifndef _MENUITERATOR_H
#define _MENUITERATOR_H
 
#ifndef MAX_MENU_DEPTH
# define MAX_MENU_DEPTH 4
#endif // MAX_MENU_DEPTH
 
class EditableLargeNumberMenuItem;
// forward reference of menu item
class MenuItem;

typedef void (*MenuVisitorFn)(MenuItem* item);

MenuItem* getParentRootAndVisit(MenuItem* current, MenuVisitorFn visitor);

inline MenuItem* getParentRoot(MenuItem* current) { return getParentRootAndVisit(current, nullptr); }

MenuItem* getSubMenuFor(MenuItem* current);

MenuItem* getMenuItemById(menuid_t id);

int offsetOfCurrentActive(MenuItem* root);

int offsetOfItem(MenuItem* itemToFind);

uint8_t itemCount(MenuItem* item,  bool includeNonVisble = false);
 

class MenuItemPredicate {
public:
    virtual ~MenuItemPredicate() = default;
    virtual bool matches(MenuItem* item)=0;
};

class RemoteNoMenuItemPredicate : public MenuItemPredicate {
private:
    uint8_t remoteNo;
public:
    explicit RemoteNoMenuItemPredicate(int remoteNo) { this->remoteNo = remoteNo; }

    bool matches(MenuItem* item) override;

    void setRemoteNo(uint8_t newRemoteNum) { remoteNo = newRemoteNum; }
};
 
// the modes that can be passed to the type predicate
#define TM_REGULAR  0
#define TM_INVERTED  1
#define TM_REGULAR_LOCAL_ONLY  8
#define TM_INVERTED_LOCAL_ONLY  9
#define TM_EXTRA_INCLUDE_SUBMENUS 16
#define TM_BIT_INVERT 0U
#define TM_BIT_LOCAL_ONLY 3U
#define TM_BIT_INCLUDE_SUBMENU 4U

class MenuItemTypePredicate : public MenuItemPredicate {
private:
    MenuType filterType;
    uint8_t mode;
public:
    MenuItemTypePredicate(MenuType filterType, uint8_t mode = 0) { 
        this->filterType = filterType; 
        this->mode = mode;
    }

    bool matches(MenuItem* item) override;
};

class MenuItemIterator {
private:
    MenuItem* currentItem;
    MenuItemPredicate* predicate;
    MenuItem* parentItems[MAX_MENU_DEPTH];
    uint8_t level;
    bool processingSubMenu;
public:
    MenuItemIterator() { 
        reset(); 
        predicate = nullptr;
    }

    void setPredicate(MenuItemPredicate* predicate) { this->predicate = predicate; }

    void reset();

    MenuItem* nextItem();

    MenuItem* currentParent();
};
 
template<typename T>
inline T *asMenuItem(MenuItem *item, MenuType expectedType, const char *typeName) {
    if (item == nullptr || item->getMenuType() != expectedType) {
        while (1) {
            // literally stop here if we get a fault, continuing will lead to worse.
            serlog2(SER_ERROR, typeName, item == nullptr ? 0 : item->getId());
            delay(1000);
        }
    }
    return reinterpret_cast<T *>(item);
}
 
inline AnalogMenuItem &asAnalogItem(MenuItem *item) {
    return *asMenuItem<AnalogMenuItem>(item, MENUTYPE_INT_VALUE, "Item not analog");
}
inline AnalogMenuItem& getAnalogItemById(menuid_t id) { return asAnalogItem(getMenuItemById(id)); }
 
 
inline EnumMenuItem &asEnumItem(MenuItem *item) {
    return *asMenuItem<EnumMenuItem>(item, MENUTYPE_ENUM_VALUE, "Item not enum");
}
inline EnumMenuItem& getEnumItemById(menuid_t id) { return asEnumItem(getMenuItemById(id)); }
 
 
inline BooleanMenuItem &asBooleanItem(MenuItem *item) {
    return *asMenuItem<BooleanMenuItem>(item, MENUTYPE_BOOLEAN_VALUE, "Item not bool");
}
inline BooleanMenuItem& getBooleanItemById(menuid_t id) { return asBooleanItem(getMenuItemById(id)); }
 
inline TextMenuItem& asTextItem(MenuItem *item) {
    return *asMenuItem<TextMenuItem>(item, MENUTYPE_TEXT_VALUE, "Item not text");
}
inline TextMenuItem& getTextItemById(menuid_t id) { return asTextItem(getMenuItemById(id)); }
 
inline FloatMenuItem& asFloatItem(MenuItem *item) {
    return *asMenuItem<FloatMenuItem>(item, MENUTYPE_FLOAT_VALUE, "Item not float");
}
inline FloatMenuItem& getFloatItemById(menuid_t id) { return asFloatItem(getMenuItemById(id)); }
 
inline SubMenuItem &asSubMenu(MenuItem *item) {
    return *asMenuItem<SubMenuItem>(item, MENUTYPE_SUB_VALUE, "Item not submenu");
}
inline SubMenuItem& getSubMenuById(menuid_t id) { return asSubMenu(getMenuItemById(id)); }
 
inline ActionMenuItem &asActionItem(MenuItem *item) {
    return *asMenuItem<ActionMenuItem>(item, MENUTYPE_ACTION_VALUE, "Item not action");
}
inline ActionMenuItem& getActionItemById(menuid_t id) { return asActionItem(getMenuItemById(id)); }
 
inline IpAddressMenuItem &asIpAddressItem(MenuItem *item) {
    return *asMenuItem<IpAddressMenuItem>(item, MENUTYPE_IPADDRESS, "Item not IP");
}
inline IpAddressMenuItem& getIpAddressItemById(menuid_t id) { return asIpAddressItem(getMenuItemById(id)); }
 
inline BackMenuItem &asBackMenu(MenuItem *item) {
    return *asMenuItem<BackMenuItem>(item, MENUTYPE_BACK_VALUE, "Item not back");
}
inline BackMenuItem& getBackMenuById(menuid_t id) { return asBackMenu(getMenuItemById(id)); }
 
inline ScrollChoiceMenuItem &asScrollChoiceItem(MenuItem *item) {
    return *asMenuItem<ScrollChoiceMenuItem>(item, MENUTYPE_SCROLLER_VALUE, "Item not scroll");
}
inline ScrollChoiceMenuItem& getScrollChoiceItemById(menuid_t id) { return asScrollChoiceItem(getMenuItemById(id)); }
 
inline TimeFormattedMenuItem &asTimeItem(MenuItem *item) {
    return *asMenuItem<TimeFormattedMenuItem>(item, MENUTYPE_TIME, "Item not time");
}
inline TimeFormattedMenuItem& getTimeItemById(menuid_t id) { return asTimeItem(getMenuItemById(id)); }
 
inline DateFormattedMenuItem &asDateItem(MenuItem *item) {
    return *asMenuItem<DateFormattedMenuItem>(item, MENUTYPE_DATE, "Item not date");
}
inline DateFormattedMenuItem& getDateItemById(menuid_t id) { return asDateItem(getMenuItemById(id)); }
 
inline Rgb32MenuItem &asRgb32Item(MenuItem *item) {
    return *asMenuItem<Rgb32MenuItem>(item, MENUTYPE_COLOR_VALUE, "Item not rgb32");
}
inline Rgb32MenuItem& getRgb32ItemById(menuid_t id) { return asRgb32Item(getMenuItemById(id)); }
 
inline EditableLargeNumberMenuItem &asLargeNumberItem(MenuItem *item) {
    return *asMenuItem<EditableLargeNumberMenuItem>(item, MENUTYPE_LARGENUM_VALUE, "Item not lgenum");
}
inline EditableLargeNumberMenuItem& getLargeNumberItemById(menuid_t id) { return asLargeNumberItem(getMenuItemById(id)); }
 
inline ListRuntimeMenuItem &asListItem(MenuItem *item) {
    return *asMenuItem<ListRuntimeMenuItem>(item, MENUTYPE_RUNTIME_LIST, "Item not list");
}
inline ListRuntimeMenuItem& getListItemById(menuid_t id) { return asListItem(getMenuItemById(id)); }
 
class RemoteMenuItem; // forward declaration
class EepromAuthenticationInfoMenuItem; // forward declaration
 
RemoteMenuItem& asIoTRemoteItem(MenuItem *item);
inline RemoteMenuItem& getIoTRemoteMenuById(menuid_t id) { return asIoTRemoteItem(getMenuItemById(id)); }
 
EepromAuthenticationInfoMenuItem& asAuthenticationMenuItem(MenuItem *item);
inline EepromAuthenticationInfoMenuItem& getAuthenticationMenuById(menuid_t id) { return asAuthenticationMenuItem(getMenuItemById(id));}
 
 
#endif