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 ~MenuManagerObserver() = default;
    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