BaseRenderers.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 _BASE_RENDERERS_H_
#define _BASE_RENDERERS_H_
 
#include "tcMenu.h"
#include "RuntimeMenuItem.h"
#include "MenuIterator.h"
#include <TaskManager.h>
 
bool isItemActionable(MenuItem* item);
 
// forward reference.
class BaseDialog;
 
#ifndef TC_DISPLAY_UPDATES_PER_SECOND
#define TC_DISPLAY_UPDATES_PER_SECOND 4
#endif // TC_DISPLAY_UPDATES_PER_SECOND
 
// The updates per second value that indicates the display is not updating, and doesn't schedule rendering.
#define UPDATES_SEC_DISPLAY_OFF 0xFFU
 
#define RENDERER_MAXIMUM_TICK_MASK 0x1FFF
#define RENDERER_RESET_OFF 0x8000
#define RENDERER_RESET_NOTIFY_ONLY 0x4000
 
bool isItemActionable(MenuItem* item);
 
enum RenderPressMode: uint8_t {
    RPRESS_NONE = 0,
    RPRESS_PRESSED = 1,
    RPRESS_HELD = 2
};
 
typedef void (*RendererCallbackFn)(unsigned int currentValue, RenderPressMode userClicked);
 
class BaseMenuRenderer;
 
class CustomDrawing {
public:
    virtual ~CustomDrawing() = default;
    virtual void started(BaseMenuRenderer* currentRenderer) = 0;
    virtual void reset() = 0;
    virtual void renderLoop(unsigned int currentValue, RenderPressMode userClick) = 0;
};
 
typedef void (*ResetCallbackFn)();
 
class ResetCallbackFunctionCustomDraw : public CustomDrawing {
    ResetCallbackFn resetFn;
public:
    ResetCallbackFunctionCustomDraw(ResetCallbackFn fn): resetFn(fn) {}
    void started(BaseMenuRenderer* /*currentRenderer*/) override { }
    void reset() override {resetFn();}
    void renderLoop(unsigned int /*currentValue*/, RenderPressMode /*userClick*/) override {}
};
 
class TitleWidget {
private:
    const uint8_t* const* iconData;
    volatile uint8_t currentState;
    volatile bool changed;
    uint8_t width;
    uint8_t height;
    uint8_t maxStateIcons;
    TitleWidget* next;
public:
    TitleWidget(const uint8_t* const* icons, uint8_t maxStateIcons, uint8_t width, uint8_t height, TitleWidget* next = NULL);
    uint8_t getCurrentState() const {return currentState;}
#ifdef __AVR__
    const uint8_t* getCurrentIcon() {
        changed = false;
        return (const uint8_t *)pgm_read_ptr(&iconData[currentState]);
    }
    const uint8_t* getIcon(int num) {
        if(num >= maxStateIcons) num = 0;
        return (const uint8_t *)pgm_read_ptr(&iconData[num]);
    }
#else
    const uint8_t* getCurrentIcon() {
        changed = false;
        return iconData[currentState];
    }
    const uint8_t* getIcon(int num) {
        if(num >= maxStateIcons) num = 0;
        return iconData[num];
    }
#endif
 
    void setCurrentState(uint8_t state) {
        // if outside of allowable icons or value hasn't changed just return.
        if (state >= maxStateIcons || currentState == state) return; 
        
        this->currentState = state;
        this->changed = true;
    }
 
    bool isChanged() {return this->changed;}
 
    void setChanged(bool ch) { changed = ch; }
 
    uint8_t getWidth() {return width;}
 
    uint8_t getHeight() {return height;}
 
    uint8_t getMaxValue() { return maxStateIcons; }
 
    TitleWidget* getNext() {return next;}
    
    void setNext(TitleWidget* next) {this->next = next;}
};
 
enum RendererType: uint8_t { RENDER_TYPE_NOLOCAL, RENDER_TYPE_BASE, RENDER_TYPE_CONFIGURABLE };
 
class MenuRenderer {
protected:
    static MenuRenderer* theInstance;
    char *buffer;
    uint8_t bufferSize;
    RendererType rendererType;
public:
    MenuRenderer(RendererType rendererType, int bufferSize) { 
        buffer = new char[bufferSize+1]; 
        this->bufferSize = bufferSize; 
        this->rendererType = rendererType;
    }
    virtual void initialise() = 0;
 
    virtual bool tryTakeSelectIfNeeded(int currentReading, RenderPressMode press) = 0;
 
    virtual BaseDialog* getDialog() = 0;
 
    virtual ~MenuRenderer() { }
 
    /* Gets the rendering instance */
    static MenuRenderer* getInstance() { return theInstance; }
 
    char* getBuffer() {return buffer;}
    
    uint8_t getBufferSize() {return bufferSize;}
 
    RendererType getRendererType() { return rendererType; }
};
 
enum MenuRedrawState: uint8_t {
    MENUDRAW_NO_CHANGE = 0, MENUDRAW_EDITOR_CHANGE, MENUDRAW_COMPLETE_REDRAW
};
 
class NoRenderer : public MenuRenderer {
private:
    BaseDialog* dialog;
public:
    NoRenderer() : MenuRenderer(RENDER_TYPE_NOLOCAL, 20) { MenuRenderer::theInstance = this; dialog = nullptr;}
    ~NoRenderer() override = default;
    bool tryTakeSelectIfNeeded(int, RenderPressMode) override { return false; }
    void initialise() override { }
    BaseDialog* getDialog() override;
};
 
class RemoteMenuItem; // forward reference.
 
class BaseMenuRenderer : public MenuRenderer, Executable {
public:
    enum DisplayTakeoverMode { NOT_TAKEN_OVER, TAKEN_OVER_FN, START_CUSTOM_DRAW, RUNNING_CUSTOM_DRAW };
 
protected:
    uint8_t lastOffset;
    uint8_t updatesPerSecond;
    uint8_t displayNumber = 0;
    MenuRedrawState redrawMode;
    uint16_t ticksToReset;
    uint16_t resetValInTicks;
    TitleWidget* firstWidget;
    CustomDrawing *customDrawing;
    BaseDialog* dialog;
    DisplayTakeoverMode displayTakenMode;
    RenderPressMode renderFnPressType;
    RendererCallbackFn renderCallback;
    MenuItem* activeItem = nullptr;
public:
    BaseMenuRenderer(int bufferSize, RendererType rType = RENDER_TYPE_BASE, uint8_t displayNum = 0);
    
    ~BaseMenuRenderer() override {delete buffer;}
    
    void initialise() override;
 
    void setUpdatesPerSecond(int updatesSec);
 
    void turnOffDisplayUpdates(bool /*updatesEnabled*/) {
        updatesPerSecond = UPDATES_SEC_DISPLAY_OFF;
    }
 
    void setResetIntervalTimeSeconds(uint16_t interval) {
        resetValInTicks = (interval * updatesPerSecond) & RENDERER_MAXIMUM_TICK_MASK;
    }
 
    void turnOffResetLogic() {
        resetValInTicks = RENDERER_RESET_OFF;
    }
 
    void resetNotifiesOnly(uint16_t ticks) {
        resetValInTicks = (ticks & RENDERER_MAXIMUM_TICK_MASK) | RENDERER_RESET_NOTIFY_ONLY;
    }
 
    void setResetCallback(ResetCallbackFn resetFn) {
        customDrawing = new ResetCallbackFunctionCustomDraw(resetFn);
    }
 
    void setCustomDrawingHandler(CustomDrawing* customDrawingParam) {
        customDrawing = customDrawingParam;
    }
 
    CustomDrawing* getCurrentCustomDrawing() {
        return customDrawing;
    }
 
    void exec() override;
 
    virtual void render() = 0;
 
    bool tryTakeSelectIfNeeded(int currentReading, RenderPressMode pressMode) override;
 
    virtual MenuItem *getMenuItemAtIndex(MenuItem *pItem, uint8_t idx);
 
    virtual int findItemIndex(MenuItem *root, MenuItem *toFind);
 
    virtual uint8_t itemCount(MenuItem* item, bool includeNonVisible);
 
     virtual uint8_t setActiveItem(MenuItem* item);
 
     MenuItem* getActiveItem() { return activeItem; }
 
    int findActiveItem(MenuItem* root);
 
 
    void setFirstWidget(TitleWidget* widget);
    TitleWidget* getFirstWidget() { return this->firstWidget; }
 
    void menuAltered() { ticksToReset = resetValInTicks; }
 
    void takeOverDisplay(RendererCallbackFn displayFn = nullptr);
 
    void giveBackDisplay();
 
    void resetToDefault();
 
    void redrawRequirement(MenuRedrawState state) { if (state > redrawMode) redrawMode = state; }
 
    void invalidateAll() { redrawMode = MENUDRAW_COMPLETE_REDRAW; }
 
    static BaseMenuRenderer* getInstance() { return reinterpret_cast<BaseMenuRenderer *>(theInstance); }
 
protected:
    void countdownToDefaulting();
};
 
bool isCardLayoutActive(MenuItem* root);
 
#endif