DrawableDashboard.h

Go to the documentation of this file.

 
#ifndef TCMENU_DRAWABLE_DASHBOARD_H
#define TCMENU_DRAWABLE_DASHBOARD_H
 
#include "BaseRenderers.h"
#include <tcUnicodeHelper.h>
#include <graphics/GraphicsDeviceRenderer.h>
#include <graphics/DeviceDrawableHelper.h>
 
class DashDrawParameters {
public:
    enum DashAlign {
        TITLE_LEFT_VALUE_LEFT, TITLE_LEFT_VALUE_RIGHT,
        NO_TITLE_VALUE_LEFT, NO_TITLE_VALUE_RIGHT,
        TITLE_RIGHT_VALUE_LEFT, TITLE_RIGHT_VALUE_RIGHT,
    };
protected:
    DashAlign alignment;
    color_t fgColor;
    color_t bgColor;
    DeviceFontDrawingMode fontMode;
public:
    DashDrawParameters(color_t fgColor_, color_t bgColor_, const GFXfont* font_, DashAlign align = TITLE_RIGHT_VALUE_RIGHT);
    DashDrawParameters(color_t fgColor_, color_t bgColor_, const UnicodeFont* font_, DashAlign align = TITLE_RIGHT_VALUE_RIGHT);
    DashDrawParameters(color_t fgColor_, color_t bgColor_, const NativeFontDesc& font_, DashAlign align = TITLE_RIGHT_VALUE_RIGHT);
 
    bool isTitleDrawn() { return alignment != NO_TITLE_VALUE_LEFT && alignment != NO_TITLE_VALUE_RIGHT; }
    bool isTitleLeftAlign() { return alignment == TITLE_LEFT_VALUE_LEFT || alignment == TITLE_LEFT_VALUE_RIGHT; }
    bool isValueLeftAlign() { return alignment == TITLE_RIGHT_VALUE_LEFT || alignment == TITLE_LEFT_VALUE_LEFT || alignment == NO_TITLE_VALUE_LEFT; }
 
    const DeviceFontDrawingMode& getFontMode() const { return fontMode; }
 
    virtual color_t getBgColor(MenuItem *item, bool updated)  { return bgColor; }
    virtual color_t getFgColor(MenuItem *item, bool updated)  { return fgColor; }
 
    virtual color_t getTitleBgColor(MenuItem *item, bool updated)  { return bgColor; }
    virtual color_t getTitleFgColor(MenuItem *item, bool updated)  { return fgColor; }
};
 
class DashDrawParametersUpdate : public DashDrawParameters {
private:
    color_t fgUpdateColor;
    color_t bgUpdateColor;
public:
    DashDrawParametersUpdate(color_t fgColor_, color_t bgColor_, color_t fgUpdateColor_, color_t bgUpdateColor_,
                                 const GFXfont* font_, DashAlign align = TITLE_RIGHT_VALUE_RIGHT) :
                                 DashDrawParameters(fgColor_, bgColor_, font_, align), fgUpdateColor(fgUpdateColor_),
                                 bgUpdateColor(bgUpdateColor_) {}
    DashDrawParametersUpdate(color_t fgColor_, color_t bgColor_, color_t fgUpdateColor_, color_t bgUpdateColor_,
                                 const UnicodeFont* font_, DashAlign align = TITLE_RIGHT_VALUE_RIGHT) :
                                 DashDrawParameters(fgColor_, bgColor_, font_, align), fgUpdateColor(fgUpdateColor_),
                                 bgUpdateColor(bgUpdateColor_) {}
    DashDrawParametersUpdate(color_t fgColor_, color_t bgColor_, color_t fgUpdateColor_, color_t bgUpdateColor_,
                                 const NativeFontDesc& font_, DashAlign align = TITLE_RIGHT_VALUE_RIGHT) :
                                 DashDrawParameters(fgColor_, bgColor_, font_, align), fgUpdateColor(fgUpdateColor_),
                                 bgUpdateColor(bgUpdateColor_) {}
 
    color_t getBgColor(MenuItem* item, bool updated) override { return updated ? bgUpdateColor : bgColor; }
 
    color_t getFgColor(MenuItem* item, bool updated) override { return updated ? fgUpdateColor : fgColor; }
};
 
class DashDrawParametersIntUpdateRange : public DashDrawParametersUpdate {
public:
    struct IntColorRange {
        color_t fgColor;
        color_t bgColor;
        int minValue;
        int maxValue;
    };
private:
    const IntColorRange* colorRanges;
    int numOfRanges;
    bool useUpdateColor;
public:
    DashDrawParametersIntUpdateRange(color_t fgColor_, color_t bgColor_, color_t fgUpdateColor_, color_t bgUpdateColor_,
                                     const GFXfont *font_, const IntColorRange colorRanges_[], int numberRanges,
                                     DashAlign align = TITLE_RIGHT_VALUE_RIGHT) :
            DashDrawParametersUpdate(fgColor_, bgColor_, fgUpdateColor_, bgUpdateColor_, font_, align),
            colorRanges(colorRanges_), numOfRanges(numberRanges), useUpdateColor(fgColor_ != fgUpdateColor_ || bgColor_ != bgUpdateColor_) { }
 
    DashDrawParametersIntUpdateRange(color_t fgColor_, color_t bgColor_, color_t fgUpdateColor_, color_t bgUpdateColor_,
                                     const UnicodeFont *font_, const IntColorRange colorRanges_[], int numberRanges,
                                     DashAlign align = TITLE_RIGHT_VALUE_RIGHT) :
            DashDrawParametersUpdate(fgColor_, bgColor_, fgUpdateColor_, bgUpdateColor_, font_, align),
            colorRanges(colorRanges_), numOfRanges(numberRanges), useUpdateColor(fgColor_ != fgUpdateColor_ || bgColor_ != bgUpdateColor_) { }
 
    DashDrawParametersIntUpdateRange(color_t fgColor_, color_t bgColor_, color_t fgUpdateColor_, color_t bgUpdateColor_,
                                     const NativeFontDesc& font_, const IntColorRange colorRanges_[], int numberRanges,
                                     DashAlign align = TITLE_RIGHT_VALUE_RIGHT) :
            DashDrawParametersUpdate(fgColor_, bgColor_, fgUpdateColor_, bgUpdateColor_, font_, align),
            colorRanges(colorRanges_), numOfRanges(numberRanges), useUpdateColor(fgColor_ != fgUpdateColor_ || bgColor_ != bgUpdateColor_) { }
private:
    int findIndexForChoice(MenuItem* item);
    color_t getBgColor(MenuItem *item, bool updated) override;
    color_t getFgColor(MenuItem *item, bool updated) override;
};
 
class DashDrawParametersTextUpdateRange : public DashDrawParametersUpdate {
public:
    struct TextColorOverride {
        const char* text;
        color_t fgColor;
        color_t bgColor;
    };
private:
    const TextColorOverride* colorOverrides;
    int numOfRanges;
    bool useUpdateColor;
public:
    DashDrawParametersTextUpdateRange(color_t fgColor_, color_t bgColor_, color_t fgUpdateColor_, color_t bgUpdateColor_,
                                     const GFXfont *font_, const TextColorOverride colorOverrides_[], int numberRanges,
                                     DashAlign align = TITLE_RIGHT_VALUE_RIGHT) :
            DashDrawParametersUpdate(fgColor_, bgColor_, fgUpdateColor_, bgUpdateColor_, font_, align), colorOverrides(colorOverrides_),
            numOfRanges(numberRanges), useUpdateColor(fgColor_ != fgUpdateColor_ || bgColor_ != bgUpdateColor_) {}
 
    DashDrawParametersTextUpdateRange(color_t fgColor_, color_t bgColor_, color_t fgUpdateColor_, color_t bgUpdateColor_,
                                     const UnicodeFont *font_, const TextColorOverride colorOverrides_[], int numberRanges,
                                     DashAlign align = TITLE_RIGHT_VALUE_RIGHT) :
            DashDrawParametersUpdate(fgColor_, bgColor_, fgUpdateColor_, bgUpdateColor_, font_, align), colorOverrides(colorOverrides_),
            numOfRanges(numberRanges), useUpdateColor(fgColor_ != fgUpdateColor_ || bgColor_ != bgUpdateColor_) {}
 
    DashDrawParametersTextUpdateRange(color_t fgColor_, color_t bgColor_, color_t fgUpdateColor_, color_t bgUpdateColor_,
                                      const NativeFontDesc &font_, const TextColorOverride colorOverrides_[], int numberRanges,
                                      DashAlign align = TITLE_RIGHT_VALUE_RIGHT) :
            DashDrawParametersUpdate(fgColor_, bgColor_, fgUpdateColor_, bgUpdateColor_, font_, align), colorOverrides(colorOverrides_),
            numOfRanges(numberRanges), useUpdateColor(fgColor_ != fgUpdateColor_ || bgColor_ != bgUpdateColor_) {}
private:
    int findIndexForChoice(MenuItem* item);
    color_t getBgColor(MenuItem *item, bool updated) override;
    color_t getFgColor(MenuItem *item, bool updated) override;
};
 
// forward reference
class DrawableDashboard;
 
class DashMenuItem {
private:
    DrawableDashboard* dashboard;
    MenuItem *item;
    Coord screenLoc;
    DashDrawParameters *parameters;
    int updateCountDown;
    Coord titleExtents;
    int numChars;
    int valueWidth;
    int countDownTicks;
    int baseline;
    char titleText[20];
public:
    DashMenuItem() : dashboard(nullptr), item(nullptr), screenLoc(0, 0), parameters(nullptr), updateCountDown(0), titleExtents(0, 0),
                     numChars(0), valueWidth(0), countDownTicks(0), baseline(0), titleText() {}
    DashMenuItem(DrawableDashboard* dashboard, MenuItem *theItem, Coord topLeft, DashDrawParameters* params, int numCharsInValue, const char* titleOverride, int countDownTicks);
    DashMenuItem(const DashMenuItem &other) = default;
    DashMenuItem& operator= (const DashMenuItem& other) = default;
 
    uint16_t getKey() const {
        return item != nullptr ? item->getId() : 0;
    }
 
    bool needsPainting();
    void paintTitle(DeviceDrawable* canvasDrawable);
    void paintItem(DeviceDrawable* canvasDrawable);
};
 
class DrawableDashboardDelegate {
public:
    virtual void dashboardDidClose() {}
    virtual bool dashboardWillOpen(BaseMenuRenderer* /*where*/) { return false; }
    virtual void dashboardDidOpen(BaseMenuRenderer* /*where*/) {}
    virtual void dashboardWillDraw(unsigned int /*currentValue*/, RenderPressMode /*mode*/) {}
    virtual void dashboardDidDraw(unsigned int /*currentValue*/, RenderPressMode /*mode*/) {}
    virtual void displayDidReset() {}
};
 
class DrawableDashboard : public CustomDrawing {
public:
    enum DashboardMode: uint8_t { DASH_ON_RESET_CLICK_EXIT, DASH_ON_RESET_MANUAL_EXIT, DASH_FULLY_MANUAL, DASH_MANUAL_START_CLICK_EXIT };
private:
    DrawableDashboardDelegate *delegate = nullptr;
    TitleWidget* firstWidget;
    BaseGraphicalRenderer *renderer;
    DeviceDrawable *drawable;
    BtreeList<uint16_t, DashMenuItem> drawingItems;
    color_t screenBg = 0;
    color_t coreItemFg = 0;
    DashboardMode drawingMode;
    bool running;
public:
    DrawableDashboard(DeviceDrawable *device, BaseGraphicalRenderer* renderer, TitleWidget* widgets, DashboardMode drawingMode)
            : firstWidget(widgets), renderer(renderer), drawable(device), drawingItems(), drawingMode(drawingMode), running(false) { }
    ~DrawableDashboard() override = default;
    void setBaseColors(color_t screenBgCol, color_t coreFgCol) {
        screenBg = screenBgCol;
        coreItemFg = coreFgCol;
    }
    void setDelegate(DrawableDashboardDelegate* dashDelegate) { this->delegate = dashDelegate; }
 
    void clearItems() { drawingItems.clear(); }
    void addDrawingItem(MenuItem *theItem, Coord topLeft, DashDrawParameters* params, int numCharsInValue,
                        const char* titleOverrideText = nullptr, int updateTicks = 5);
    void stop();
    void reset() override;
    void started(BaseMenuRenderer *currentRenderer) override;
 
    void renderLoop(unsigned int currentValue, RenderPressMode userClick) override;
 
    void drawWidgets(bool force);
 
    uint8_t getDisplayNumber() { return renderer->getDisplayNumber(); }
};
 
#endif //TCMENU_DRAWABLE_DASHBOARD_H