tcMenu.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 TCMENU_MANAGER_H
#define TCMENU_MANAGER_H
 
#include <IoAbstraction.h>
#include "tcUtil.h"
#include "MenuItems.h"
#include "MenuHistoryNavigator.h"
#include "RuntimeMenuItem.h"
#include "BaseRenderers.h"
#include "RemoteAuthentication.h"
#include "EepromItemStorage.h"
 
// forward reference
class MenuRenderer;
 
class SecuredMenuPopup;
 
class MenuManagerObserver {
public:
    virtual void structureHasChanged()=0;
 
    virtual bool menuEditStarting(MenuItem* item)=0;
 
    virtual void menuEditEnded(MenuItem* item)=0;
 
    virtual void activeItemHasChanged(MenuItem* /*newActive*/) {}
};
 
class CommitCallbackObserver : public MenuManagerObserver {
private:
    MenuCallbackFn commitCb;
public:
    explicit CommitCallbackObserver(MenuCallbackFn callbackFn) {
        commitCb = callbackFn;
    }
 
    void structureHasChanged() override {}
    bool menuEditStarting(MenuItem*) override { return true; }
    void menuEditEnded(MenuItem* item) override {
        commitCb(item->getId());
    }
};
 
#ifndef MAX_MENU_NOTIFIERS
#define MAX_MENU_NOTIFIERS 4
#endif
 
class EncoderWrapOverride {
private:
    menuid_t itemId;
    bool overrideValue;
public:
    EncoderWrapOverride() = default;
    EncoderWrapOverride(const EncoderWrapOverride &other) = default;
    EncoderWrapOverride &operator=(const EncoderWrapOverride &other) = default;
    EncoderWrapOverride(menuid_t itemId, bool overrideValue) : itemId(itemId), overrideValue(overrideValue) {}
 
    menuid_t getKey() const { return itemId; }
 
    menuid_t getMenuId() const { return itemId; }
    bool getOverrideValue() const { return overrideValue; }
};
 
class CurrentEditorRenderingHints {
public:
    enum EditorRenderingType {
        EDITOR_REGULAR = 0,
        EDITOR_WHOLE_ONLY = 0x0001, EDITOR_FRACTION_ONLY = 0x0002,
        EDITOR_RUNTIME_TEXT = 0x0004,
        EDITOR_OVERRIDE_LOCK = 0x8000
    };
private:
    EditorRenderingType renderingType = EDITOR_REGULAR;
    int editStart = 0;
    int editEnd = 0;
public:
    CurrentEditorRenderingHints() = default;
    void changeEditingParams(EditorRenderingType ty, int startOffset, int endOffset);
    void lockEditor(bool lock) { renderingType = lock ? EDITOR_OVERRIDE_LOCK : EDITOR_REGULAR; }
    EditorRenderingType getEditorRenderingType() const { return renderingType; }
    int getStartIndex() const { return editStart; }
    int getEndIndex() const { return editEnd; }
};
 
class MenuManager {
private:
    tcnav::MenuNavigationStore navigator{};
    MenuItem* currentEditor;
    MenuRenderer* renderer;
    SecuredMenuPopup* securedMenuPopup;
    AuthenticationManager *authenticationManager;
    EepromAbstraction* eepromRef;
    MenuManagerObserver* structureNotifier[MAX_MENU_NOTIFIERS];
    bool useWrapAroundByDefault = false;
    BtreeList<menuid_t, EncoderWrapOverride> encoderWrapOverrides;
    CurrentEditorRenderingHints renderingHints;
public:
    static SubMenuItem ROOT;
    MenuManager();
 
    void setUseWrapAroundEncoder(bool wrapAround) {
        useWrapAroundByDefault = wrapAround;
    }
 
    void addEncoderWrapOverride(MenuItem& item, bool override);
 
    bool isWrapAroundEncoder(MenuItem* item);
 
    void initForEncoder(MenuRenderer* renderer, MenuItem* root, pinid_t encoderPinA, pinid_t encoderPinB, pinid_t encoderButton, EncoderType type = FULL_CYCLE);
    
    void initForUpDownOk(MenuRenderer* renderer, MenuItem* root, pinid_t downPin, pinid_t upPin, pinid_t okPin, int speed=20);
 
    void initFor4WayJoystick(MenuRenderer* renderer, MenuItem* root, pinid_t downPin, pinid_t upPin, pinid_t leftPin,
                             pinid_t rightPin, pinid_t okPin, int speed=20);
 
    void initForTwoButton(MenuRenderer* renderer, MenuItem* root, pinid_t upPin, pinid_t downPin);
 
    void initWithoutInput(MenuRenderer* renderer, MenuItem* root);
 
    void setBackButton(pinid_t backButtonPin);
 
    void setNextButton(pinid_t nextButtonPin);
 
    void setRootMenu(MenuItem* menuItem) {
        navigator.setRootItem(menuItem);
    }
 
    void setAuthenticator(AuthenticationManager* manager) { authenticationManager = manager; }
 
    AuthenticationManager* getAuthenticator() {
        if(authenticationManager == nullptr) authenticationManager = new NoAuthenticationManager();
        return authenticationManager;
    }
 
    void setItemCommittedHook(MenuCallbackFn commitCallback) {
        addChangeNotification(new CommitCallbackObserver(commitCallback));
    }
 
    void valueChanged(int value);
 
    void onMenuSelect(bool held);
 
    void performDirectionMove(bool dirIsBack);
 
    void setItemsInCurrentMenu(int size, int offs = 0);
 
    EepromAbstraction* getEepromAbstraction() { return eepromRef; }
 
    void setEepromRef(EepromAbstraction* globalRom) {
        eepromRef = globalRom;
    }
 
    void load(EepromAbstraction& eeprom, uint16_t magicKey = 0xfade, TimerFn onEepromEmpty = nullptr);
 
 
    void load(uint16_t magicKey = 0xfade, TimerFn onEepromEmpty = nullptr);
 
 
    void save(uint16_t magicKey = 0xfade) { if(eepromRef) saveMenuStructure(eepromRef, magicKey); }
 
    void save(EepromAbstraction& eeprom, uint16_t magicKey = 0xfade) { saveMenuStructure(&eeprom, magicKey); }
 
    MenuItem* findCurrentActive();
 
    MenuItem* getRoot() { return ROOT.getChild(); }
 
    MenuRenderer* getRenderer() { return renderer; }
 
    MenuItem* getCurrentEditor() { return currentEditor; }
 
    void setCurrentEditor(MenuItem* editor);
 
    void setItemActive(MenuItem* item);
 
    void changeMenu(MenuItem* possibleActive=nullptr);
 
    void navigateToMenu(MenuItem* theNewItem, MenuItem* possibleActive = nullptr, bool skipHistory = false);
 
    void resetMenu(bool completeReset);
 
    MenuItem* getCurrentMenu() { return navigator.getCurrentRoot(); }
 
    MenuItem* getCurrentSubMenu() { return navigator.getCurrentSubMenu(); }
 
    tcnav::MenuNavigationStore& getNavigationStore() { return navigator; }
 
    MenuItem* getParentAndReset();
 
    int getCurrentRangeValue() {
        return switches.getEncoder() != nullptr ? switches.getEncoder()->getCurrentReading() : 0;
    }
 
    SecuredMenuPopup* secureMenuInstance();
 
    void stopEditingCurrentItem(bool doMultiPartNext);
 
    void addMenuAfter(MenuItem* existing, MenuItem* toAdd, bool silent = false);
 
    void notifyStructureChanged();
 
    void addChangeNotification(MenuManagerObserver* observer);
 
    void recalculateListIfOnDisplay(RuntimeMenuItem* runtimeItem);
 
    void setEditorHints(CurrentEditorRenderingHints::EditorRenderingType hint, size_t start=0, size_t end=0);
    const CurrentEditorRenderingHints& getEditorHints() { return renderingHints; }
 
    void setEditorHintsLocked(bool locked);
 
    void resetObservers();
 
    void setupForEditing(MenuItem* item);
protected:
    void actionOnCurrentItem(MenuItem * toEdit);
    void actionOnSubMenu(MenuItem* nextSub);
 
    void notifyEditEnd(MenuItem *pItem);
    bool notifyEditStarting(MenuItem *pItem);
 
    void setRootItem(MenuItem *pItem);
};
 
inline bool editorHintNeedsCursor(CurrentEditorRenderingHints::EditorRenderingType ty) {
    return ty != CurrentEditorRenderingHints::EDITOR_REGULAR && ty != CurrentEditorRenderingHints::EDITOR_OVERRIDE_LOCK;
}
 
extern MenuManager menuMgr;
 
#endif // TCMENU_MANAGER_H