BaseGraphicalRenderer.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_BASEGRAPHICALRENDERER_H
#define TCMENU_BASEGRAPHICALRENDERER_H
 
#include <BaseRenderers.h>
#include "GfxMenuConfig.h"
#include "RuntimeTitleMenuItem.h"
 
#define GFX_LAST_ROW_FIT_FLAG 0
#define GFX_USING_RAW_TOUCH 1
#define GFX_USING_TOUCH_INTERFACE 2
#define GFX_SLIDER_FOR_ANALOG 3
#define GFX_TITLE_ON_DISPLAY 4
#define GFX_EDIT_STATUS_ICONS_ENABLED 5
 
namespace tcgfx {
 
    inline uint16_t rowCol(int row, int col) {
        return (row * 100) + col;
    }
 
    class DrawingFlags {
    private:
        uint16_t flags;
    public:
        DrawingFlags(bool drawAll, bool active, bool editing) : flags(0) {
            bitWrite(flags, 0, drawAll);
            bitWrite(flags, 1, active);
            bitWrite(flags, 2, editing);
        }
        DrawingFlags(const DrawingFlags& other) = default;
        DrawingFlags& operator=(const DrawingFlags& other) = default;
 
        bool isDrawingAll() const { return bitRead(flags, 0); }
        bool isActive() const { return bitRead(flags, 1); }
        bool isEditing() const { return bitRead(flags, 2); }
    };
 
    class GridPositionRowCacheEntry {
    private:
        MenuItem *menuItem;
        GridPosition thePosition;
        ItemDisplayProperties *properties;
    public:
        GridPositionRowCacheEntry() : menuItem(nullptr), thePosition(GridPosition::DRAW_TEXTUAL_ITEM, GridPosition::JUSTIFY_TITLE_LEFT_VALUE_RIGHT, 0), properties(nullptr) {}
 
        GridPositionRowCacheEntry(const GridPositionRowCacheEntry &other) = default;
        GridPositionRowCacheEntry& operator=(const GridPositionRowCacheEntry &other) = default;
 
        GridPositionRowCacheEntry(MenuItem *item, const GridPosition &pos, ItemDisplayProperties *props) : menuItem(item), thePosition(pos), properties(props) {}
 
        const GridPosition &getPosition() { return thePosition; }
 
        ItemDisplayProperties *getDisplayProperties() { return properties; }
 
        uint16_t getKey() const { return rowCol(thePosition.getRow(), thePosition.getGridPosition()); }
 
        uint16_t getHeight() {
            return thePosition.getGridHeight() != 0 ? thePosition.getGridHeight() : properties->getRequiredHeight();
        }
 
        MenuItem *getMenuItem() { return menuItem; }
    };
 
    enum LayoutMode: uint8_t {
        LAYOUT_VERTICAL_DEFAULT,
        LAYOUT_CARD_SIDEWAYS
    };
 
    class BaseGraphicalRenderer;
 
    class RenderingNavigationListener : public tcnav::NavigationListener {
    private:
        BaseGraphicalRenderer* renderer;
    public:
        explicit RenderingNavigationListener(BaseGraphicalRenderer* r);
        void navigationHasChanged(MenuItem *newItem, bool completelyReset) override;
    };
 
    class CachedDrawingLocation {
    private:
        uint16_t startY;
        uint8_t currentOffset;
    public:
        CachedDrawingLocation() = default;
        CachedDrawingLocation(uint16_t startY, uint8_t currentOffset) : startY(startY), currentOffset(currentOffset) {}
        CachedDrawingLocation(const CachedDrawingLocation& other) = default;
        CachedDrawingLocation& operator=(const CachedDrawingLocation& other) = default;
 
        uint16_t getStartY() const {
            return startY;
        }
 
        uint8_t getCurrentOffset() const {
            return currentOffset;
        }
    };
 
    class BaseGraphicalRenderer : public BaseMenuRenderer {
    public:
        enum TitleMode : uint8_t {
            NO_TITLE,
            TITLE_FIRST_ROW,
            TITLE_ALWAYS
        };
        enum RenderDrawingCommand {
            DRAW_COMMAND_CLEAR,
            DRAW_COMMAND_START,
            DRAW_COMMAND_ENDED
        };
 
        MenuItem *getCurrentRendererRoot() { return currentRootMenu; }
 
    private:
        RenderingNavigationListener navigationListener;
        MenuItem *currentRootMenu;
        const char *pgmTitle;
        GridPositionRowCacheEntry cachedEntryItem;
    protected:
        BtreeList<uint16_t, GridPositionRowCacheEntry> itemOrderByRow;
        TitleMode titleMode = TITLE_FIRST_ROW;
        uint16_t width, height;
        CachedDrawingLocation drawingLocation;
        uint8_t flags;
    public:
        BaseGraphicalRenderer(int bufferSize, int wid, int hei, bool lastRowExact, const char *appTitle);
        void initialise() override;
 
        void setTitleMode(TitleMode mode);
 
        void setDisplayNumber(uint8_t displayNum) { this->displayNumber = displayNum; }
 
        uint8_t getDisplayNumber() { return this->displayNumber; }
 
        void setUseSliderForAnalog(bool useSlider) { bitWrite(flags, GFX_SLIDER_FOR_ANALOG, useSlider); }
        void setHasTouchInterface(bool hasTouch) { bitWrite(flags, GFX_USING_TOUCH_INTERFACE, hasTouch); }
        void setTitleOnDisplay(bool titleOn) { bitWrite(flags, GFX_TITLE_ON_DISPLAY, titleOn); }
        void setLastRowExactFit(bool exact) { bitWrite(flags, GFX_LAST_ROW_FIT_FLAG, exact); }
        void setRawTouchMode(bool rawTouch) { bitWrite(flags, GFX_USING_RAW_TOUCH, rawTouch); }
        void setEditStatusIconsEnabled(bool ena) { bitWrite(flags, GFX_EDIT_STATUS_ICONS_ENABLED, ena); }
        bool isUseSliderForAnalog() const { return bitRead(flags, GFX_SLIDER_FOR_ANALOG); }
        bool isHasTouchInterface() const { return bitRead(flags, GFX_USING_TOUCH_INTERFACE); }
        bool isTitleOnDisplay() const { return bitRead(flags, GFX_TITLE_ON_DISPLAY); }
        bool isLastRowExactFit() const { return bitRead(flags, GFX_LAST_ROW_FIT_FLAG); }
        bool isRawTouchMode() const { return bitRead(flags, GFX_USING_RAW_TOUCH); }
        bool isEditStatusIconEnabled() const { return bitRead(flags, GFX_EDIT_STATUS_ICONS_ENABLED); }
 
        void render() override;
 
        void setDisplayDimensions(int w, int h) {
            serlogF3(SER_TCMENU_INFO, "Set dimensions: ", w, h);
            width = w;
            height = h;
        }
 
        virtual LayoutMode getLayoutMode(MenuItem* rootItem) { return LAYOUT_VERTICAL_DEFAULT; }
 
        virtual void drawWidget(Coord where, TitleWidget *widget, color_t colorFg, color_t colorBg) = 0;
 
        virtual void drawMenuItem(GridPositionRowCacheEntry *entry, Coord where, Coord areaSize, const DrawingFlags& drawFlags) = 0;
 
        virtual void drawingCommand(RenderDrawingCommand command) = 0;
 
        virtual void fillWithBackgroundTo(int endPoint) = 0;
 
        virtual ItemDisplayPropertiesFactory &getDisplayPropertiesFactory() = 0;
 
        int findItemIndex(MenuItem *root, MenuItem *toFind) override;
 
        uint8_t itemCount(MenuItem* root, bool) override;
 
        GridPositionRowCacheEntry* findMenuEntryAndDimensions(const Coord &screenPos, Coord &localStart, Coord &localSize);
 
        MenuItem *getMenuItemAtIndex(MenuItem* currentRoot, uint8_t idx) override;
 
        BaseDialog *getDialog() override;
 
        int getWidth() const { return width; }
 
        int getHeight() const { return height; }
 
        void displayPropertiesHaveChanged();
 
        void rootHasChanged(MenuItem* newItem);
 
        uint8_t setActiveItem(MenuItem *item) override;
    protected:
        virtual void subMenuRender(MenuItem* rootItem, uint8_t& locRedrawMode, bool& forceDrawWidgets);
        int heightOfRow(int row, bool includeSpace=false);
    private:
        bool drawTheMenuItems(int startRow, int startY, bool drawEveryLine);
 
        void renderList();
 
        void recalculateDisplayOrder(MenuItem *pItem, bool safeMode);
 
        void redrawAllWidgets(bool forceRedraw);
 
        bool areRowsOutOfOrder();
 
        int calculateHeightTo(int index, MenuItem *pItem);
 
        ItemDisplayProperties::ComponentType toComponentType(GridPosition::GridDrawingMode mode, MenuItem *pMenuItem);
 
        GridPositionRowCacheEntry *firstItemOnRow(int row);
 
        int skipRow(int row);
    };
 
    inline int analogRangeToScreen(AnalogMenuItem *item, int screenWidth) {
        float ratio = (float) screenWidth / (float) item->getMaximumValue();
        return int((float) item->getCurrentValue() * ratio);
    }
 
    void preparePropertiesFromConfig(ConfigurableItemDisplayPropertiesFactory &factory,
                                     const ColorGfxMenuConfig<const void *> *gfxConfig, int titleHeight,
                                     int itemHeight);
} // namespace tcgfx
 
#endif //TCMENU_BASEGRAPHICALRENDERER_H