GfxMenuConfig.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 _GFX_MENU_CONFIG_H_
#define _GFX_MENU_CONFIG_H_
 
#include <tcUtil.h>
#include <BTreeList.h>
#include "MenuItems.h"
#include "DrawingPrimitives.h"
#include <IoLogging.h>
 
 
namespace tcgfx {
 
#define SPECIAL_ID_EDIT_ICON 0xfffe
#define SPECIAL_ID_ACTIVE_ICON 0xfffd

    template<typename FONTPTR> struct ColorGfxMenuConfig {
        color_t bgTitleColor;
        color_t fgTitleColor;
        MenuPadding titlePadding;
        FONTPTR titleFont;
 
        color_t bgItemColor;
        color_t fgItemColor;
        MenuPadding itemPadding;
        FONTPTR itemFont;
 
        color_t bgSelectColor;
        color_t fgSelectColor;
        color_t widgetColor;
        MenuPadding widgetPadding;
 
        const uint8_t* activeIcon;
        const uint8_t* editIcon;
        uint8_t editIconWidth;
        uint8_t editIconHeight;
 
        uint8_t titleBottomMargin;
        uint8_t titleFontMagnification;
        uint8_t itemFontMagnification;
    };

    void prepareDefaultGfxConfig(ColorGfxMenuConfig<void*>* config);
 

    class GridPosition {
    public:
        enum GridDrawingMode : uint8_t {
            DRAW_TEXTUAL_ITEM,
            DRAW_INTEGER_AS_UP_DOWN,
            DRAW_INTEGER_AS_SCROLL,
            DRAW_AS_ICON_ONLY,
            DRAW_AS_ICON_TEXT,
            DRAW_TITLE_ITEM
        };

        enum GridJustification : uint8_t {
            CORE_JUSTIFY_LEFT = 1,
            CORE_JUSTIFY_RIGHT = 2,
            CORE_JUSTIFY_CENTER = 3,

            CORE_JUSTIFY_VALUE_REQUIRED = 0b1000,
            CORE_JUSTIFY_NAME_REQUIRED  = 0b0100,

            JUSTIFY_TITLE_LEFT_VALUE_RIGHT = 0,
            JUSTIFY_TITLE_LEFT_WITH_VALUE = CORE_JUSTIFY_LEFT | CORE_JUSTIFY_NAME_REQUIRED | CORE_JUSTIFY_VALUE_REQUIRED,
            JUSTIFY_CENTER_WITH_VALUE = CORE_JUSTIFY_CENTER | CORE_JUSTIFY_NAME_REQUIRED | CORE_JUSTIFY_VALUE_REQUIRED,
            JUSTIFY_RIGHT_WITH_VALUE = CORE_JUSTIFY_RIGHT | CORE_JUSTIFY_NAME_REQUIRED | CORE_JUSTIFY_VALUE_REQUIRED,
            JUSTIFY_LEFT_NO_VALUE = CORE_JUSTIFY_LEFT | CORE_JUSTIFY_NAME_REQUIRED,
            JUSTIFY_CENTER_NO_VALUE = CORE_JUSTIFY_CENTER | CORE_JUSTIFY_NAME_REQUIRED,
            JUSTIFY_RIGHT_NO_VALUE = CORE_JUSTIFY_RIGHT | CORE_JUSTIFY_NAME_REQUIRED,
            JUSTIFY_LEFT_VALUE_ONLY= CORE_JUSTIFY_LEFT | CORE_JUSTIFY_VALUE_REQUIRED,
            JUSTIFY_CENTER_VALUE_ONLY = CORE_JUSTIFY_CENTER | CORE_JUSTIFY_VALUE_REQUIRED,
            JUSTIFY_RIGHT_VALUE_ONLY = CORE_JUSTIFY_RIGHT | CORE_JUSTIFY_VALUE_REQUIRED
        };
    private:
        uint32_t gridSize: 3;
        uint32_t gridPosition: 3;
        uint32_t gridRowSpan: 2;
        uint32_t gridHeight: 9;
        uint32_t rowPosition: 7;
        uint32_t drawingMode: 4;
        uint32_t justification: 4;
    public:
        GridPosition() : gridSize(0), gridPosition(0), gridHeight(0), rowPosition(0), drawingMode(0),
                         justification(JUSTIFY_TITLE_LEFT_VALUE_RIGHT) {}
 
        GridPosition(const GridPosition &other) = default;
        GridPosition& operator=(const GridPosition &other) = default;

        GridPosition(GridDrawingMode mode, GridJustification justification, int row, int height = 0)
                : gridSize(1), gridPosition(1), gridHeight(height),rowPosition(row), drawingMode(mode), justification(justification) { }

        GridPosition(GridDrawingMode mode, GridJustification just, int size, int pos, int row, int hei)
                : gridSize(size), gridPosition(pos), gridHeight(hei), rowPosition(row), drawingMode(mode), justification(just) { }
 
        GridDrawingMode getDrawingMode() const { return static_cast<GridDrawingMode>(drawingMode); }
 
        GridJustification getJustification() const { return static_cast<GridJustification>(justification); }
 
        int getGridSize() const { return gridSize; }
 
        int getGridHeight() const { return gridHeight; }
 
        int getGridPosition() const { return gridPosition; }
 
        int getRow() const { return rowPosition; }
    };

    inline bool itemNeedsValue(GridPosition::GridJustification justification) {
        return justification == GridPosition::JUSTIFY_TITLE_LEFT_VALUE_RIGHT || (justification & GridPosition::CORE_JUSTIFY_VALUE_REQUIRED) != 0;
    }

    inline bool itemNeedsName(GridPosition::GridJustification justification) {
        return (justification & GridPosition::CORE_JUSTIFY_NAME_REQUIRED) != 0;
    }

    inline GridPosition::GridJustification coreJustification(GridPosition::GridJustification j) {
        return static_cast<GridPosition::GridJustification>(j & 0b11);
    }

    class GridPositionWithId {
    private:
        uint16_t menuId;
        GridPosition thePosition;
    public:
        GridPositionWithId() : menuId(0xffff), thePosition(GridPosition::DRAW_TEXTUAL_ITEM,
                                                           GridPosition::JUSTIFY_TITLE_LEFT_VALUE_RIGHT, 0) {}
 
        GridPositionWithId(const GridPositionWithId &other) = default;
        GridPositionWithId& operator=(const GridPositionWithId &other) = default;
 
        GridPositionWithId(uint16_t itemId, const GridPosition &pos) : menuId(itemId), thePosition(pos) {}
 
        const GridPosition &getPosition() { return thePosition; }
 
        uint16_t getKey() const { return menuId; }
 
        void setNewPosition(GridPosition newPosition) {
            thePosition = newPosition;
        }
    };

    class ItemDisplayProperties {
    public:
        enum ColorType: uint8_t {
            TEXT,
            BACKGROUND,
            HIGHLIGHT1,
            HIGHLIGHT2,
            SIZEOF_COLOR_ARRAY
        };

        enum ComponentType {
            COMPTYPE_TITLE,
            COMPTYPE_ITEM,
            COMPTYPE_ACTION,
        };
    private:
        uint32_t propsKey;
        color_t colors[SIZEOF_COLOR_ARRAY];
        const void* fontData;
        MenuPadding padding;
        MenuBorder borderWidths;
        GridPosition::GridJustification defaultJustification;
        uint8_t spaceAfter;
        uint8_t requiredHeight;
        uint8_t fontMagnification;
    public:
        ItemDisplayProperties() : propsKey(0), colors{}, fontData(nullptr), borderWidths(), defaultJustification(GridPosition::JUSTIFY_TITLE_LEFT_VALUE_RIGHT),
                        spaceAfter(0), requiredHeight(0), fontMagnification(1) {}
        ItemDisplayProperties(uint32_t key, const color_t* palette, const MenuPadding& pad, const void* font, uint8_t mag, uint8_t spacing,
                              uint8_t height, GridPosition::GridJustification defaultJustification, MenuBorder borderWidths)
                              : propsKey(key), fontData(font), padding{pad}, borderWidths(borderWidths), defaultJustification(defaultJustification), spaceAfter(spacing),
                                requiredHeight(height), fontMagnification(mag) {
            memcpy(colors, palette, sizeof colors);
        }
        ItemDisplayProperties(const ItemDisplayProperties& other) = default;
        ItemDisplayProperties& operator=(const ItemDisplayProperties& other) = default;
 
        [[nodiscard]] uint32_t getKey() const { return propsKey; }
 
        [[nodiscard]] GridPosition::GridJustification getDefaultJustification() const {
            return defaultJustification;
        }
 
        void setDefaultJustification(GridPosition::GridJustification justification) { defaultJustification = justification; }
 
        [[nodiscard]] uint8_t getSpaceAfter() const {return spaceAfter; }
 
        void setSpaceAfter(uint8_t space) { spaceAfter = space; }
 
        [[nodiscard]] uint8_t getRequiredHeight() const { return requiredHeight; }
 
        void setRequiredHeight(uint8_t newHeight) { requiredHeight = newHeight; }
 
        [[nodiscard]] color_t getColor(ColorType color) const {
            return (color < SIZEOF_COLOR_ARRAY) ? colors[color] : RGB(0,0,0);
        }
 
        void setColor(ColorType color, color_t value) {
            if(color >= SIZEOF_COLOR_ARRAY) return;
            colors[color] = value;
        }
 
        void setColors(const color_t* palette) {
            memcpy(colors, palette, sizeof colors);
        }
 
        [[nodiscard]] const MenuPadding& getPadding() const {
            return padding;
        }
 
        void setPadding(const MenuPadding& pad) {
            padding = pad;
        }
 
        [[nodiscard]] MenuBorder getBorder() const {
            return borderWidths;
        }
 
        void setBorder(MenuBorder border) {
            borderWidths = border;
        }
 
        [[nodiscard]] uint8_t getFontMagnification() const {
            return fontMagnification;
        }
 
        void setFontInfo(const void* font, uint8_t mag) {
            fontMagnification = mag;
            fontData = font;
        }
 
        const void* getFont() {
            return fontData;
        }
 
        color_t* getPalette() {
            return colors;
        }
    };

    class ItemDisplayPropertiesFactory {
    public:
        virtual ~ItemDisplayPropertiesFactory() = default;
        virtual ItemDisplayProperties* configFor(MenuItem* pItem, ItemDisplayProperties::ComponentType compType) = 0;

        virtual ItemDisplayProperties* configForCurrentSub(ItemDisplayProperties::ComponentType compType) = 0;

        virtual DrawableIcon* iconForMenuItem(uint16_t id) = 0;

        virtual GridPositionWithId* gridPositionForItem(MenuItem* pItem) = 0;

        virtual color_t getSelectedColor(ItemDisplayProperties::ColorType colorType, bool isUnderCursor = false)  = 0;

        virtual void addGridPosition(MenuItem* item, const GridPosition& position)  = 0;
    };

    class NullItemDisplayPropertiesFactory : public ItemDisplayPropertiesFactory {
    private:
        color_t anEmptyPalette[4] = {0};
        ItemDisplayProperties props = ItemDisplayProperties(0, anEmptyPalette, MenuPadding(0), nullptr, 1, 0, 1, GridPosition::JUSTIFY_TITLE_LEFT_VALUE_RIGHT, MenuBorder());
        BtreeList<uint16_t, GridPositionWithId> gridByItem;
    public:
        NullItemDisplayPropertiesFactory() : gridByItem(4) {}
 
        ItemDisplayProperties* configFor(MenuItem* pItem, ItemDisplayProperties::ComponentType /*compType*/) override {
            return &props;
        }
 
        ItemDisplayProperties* configForCurrentSub(ItemDisplayProperties::ComponentType /*compType*/) override {
            return &props;
        }
 
        DrawableIcon* iconForMenuItem(uint16_t /*id*/) override{
            return nullptr;
        }
 
        color_t getSelectedColor(ItemDisplayProperties::ColorType colorType, bool /*isUnderCursor*/ = false) override {
            return 0;
        }
 
        GridPositionWithId* gridPositionForItem(MenuItem* pItem) override {
            if(!pItem) return nullptr;
            return gridByItem.getByKey(pItem->getId());
        }
 
        void addGridPosition(MenuItem* pItem, const GridPosition& position) override {
            if(!pItem) return;
            auto* grid = gridByItem.getByKey(pItem->getId());
            if(grid) {
                grid->setNewPosition(position);
            }
            else {
                serlogF2(SER_TCMENU_DEBUG, "Adding grid ", pItem->getId());
                gridByItem.add(GridPositionWithId(pItem->getId(), position));
            }
        }
    };
 
#define MENUID_NOTSET 0xffff
 
    inline uint32_t MakePropsKey(uint16_t menuId, bool parentKey, ItemDisplayProperties::ComponentType ty) {
        return ((uint32_t)menuId) | (parentKey ? 0x10000UL : 0UL) | ((uint32_t)ty << 18UL);
    }

    enum EditCursorMode {
        CURSOR_MODE_UNDERLINE,
        CURSOR_MODE_BACKGROUND_BOX
    };

    class ConfigurableItemDisplayPropertiesFactory : public ItemDisplayPropertiesFactory {
    private:
        BtreeList<uint32_t, ItemDisplayProperties> displayProperties;
        BtreeList<uint16_t, DrawableIcon> iconsByItem;
        BtreeList<uint16_t, GridPositionWithId> gridByItem;
        color_t selectedTextColor = RGB(0,0,0);
        color_t selectedBackgroundColor = RGB(0, 100, 255);
        color_t editCursorColor = RGB(255, 255, 255);
        color_t editCursorTextColor = RGB(0, 0, 0);
        EditCursorMode editCursorMode = CURSOR_MODE_UNDERLINE;
    public:
        ConfigurableItemDisplayPropertiesFactory()
                : displayProperties(5, GROW_BY_5),
                  iconsByItem(6, GROW_BY_5) { }

        DrawableIcon* iconForMenuItem(uint16_t id) override {
            return iconsByItem.getByKey(id);
        }

        GridPositionWithId* gridPositionForItem(MenuItem* pItem) override {
            if(!pItem) return nullptr;
            return gridByItem.getByKey(pItem->getId());
        }

        ItemDisplayProperties* configFor(MenuItem* pItem, ItemDisplayProperties::ComponentType compType)  override;

        ItemDisplayProperties* configForCurrentSub(ItemDisplayProperties::ComponentType compType) override;

        color_t getSelectedColor(ItemDisplayProperties::ColorType colorType, bool isUnderCursor = false) override {
            if(isUnderCursor) {
                return colorType == ItemDisplayProperties::BACKGROUND ? editCursorColor : editCursorTextColor;
            }
            return colorType == ItemDisplayProperties::BACKGROUND ? selectedBackgroundColor : selectedTextColor;
        }

        void addGridPosition(MenuItem* pItem, const GridPosition& position) override {
            if(!pItem) return;
            auto* grid = gridByItem.getByKey(pItem->getId());
            if(grid) {
                grid->setNewPosition(position);
            }
            else {
                gridByItem.add(GridPositionWithId(pItem->getId(), position));
            }
        }

        void addImageToCache(const DrawableIcon& toAdd) {
            auto* current = iconsByItem.getByKey(toAdd.getKey());
            if(current) {
                current->setFromValues(toAdd.getDimensions(), toAdd.getIconType(), toAdd.getIcon(false), toAdd.getIcon(true));
            }
            else {
                iconsByItem.add(toAdd);
            }
        }

        void setDrawingPropertiesDefault(ItemDisplayProperties::ComponentType drawing, const color_t* palette, MenuPadding pad, const void *font, uint8_t mag,
                                         uint8_t spacing, uint8_t requiredHeight, GridPosition::GridJustification defaultJustification, MenuBorder border) {
 
            auto key = MakePropsKey(MENUID_NOTSET, false, drawing);
            serlogF2(SER_TCMENU_DEBUG, "Add def prop: ", key);
            setDrawingProperties(key, palette, pad, font, mag, spacing, requiredHeight, defaultJustification, border);
        }

        void setDrawingPropertiesForItem(ItemDisplayProperties::ComponentType drawing, uint16_t id, const color_t* palette, MenuPadding pad, const void *font, uint8_t mag,
                                         uint8_t spacing, uint8_t requiredHeight, GridPosition::GridJustification defaultJustification, MenuBorder border) {
            auto key = MakePropsKey(id, false, drawing);
            serlogF3(SER_TCMENU_DEBUG, "Add item prop: ", key, id);
            setDrawingProperties(key, palette, pad, font, mag, spacing, requiredHeight, defaultJustification, border);
        }

        void setDrawingPropertiesAllInSub(ItemDisplayProperties::ComponentType drawing, uint16_t id, const color_t* palette, MenuPadding pad, const void *font, uint8_t mag,
                                          uint8_t spacing, uint8_t requiredHeight, GridPosition::GridJustification defaultJustification, MenuBorder border) {
            auto key = MakePropsKey(id, true, drawing);
            serlogF3(SER_TCMENU_DEBUG, "Add sub prop: ", key, id);
            setDrawingProperties(key, palette, pad, font, mag, spacing, requiredHeight, defaultJustification, border);
        }

        void setSelectedColors(color_t background, color_t text) {
            selectedBackgroundColor = background;
            selectedTextColor = text;
        }

        void setEditCursorMode(EditCursorMode mode, color_t cursorCol, color_t textCol) {
            editCursorMode = mode;
            editCursorColor = cursorCol;
            editCursorTextColor = textCol;
        }

        static void refreshCache();
 
    private:
        void setDrawingProperties(uint32_t key, const color_t* palette, MenuPadding pad, const void* font, uint8_t mag, uint8_t spacing,
                                  uint8_t requiredHeight, GridPosition::GridJustification defaultJustification, MenuBorder border);
 
    };
 
} // namespace tcgfx

extern const uint8_t PROGMEM loResEditingIcon[];

extern const uint8_t PROGMEM loResActiveIcon[];

extern const uint8_t PROGMEM defActiveIcon[];

extern const uint8_t PROGMEM defEditingIcon[];
 
#endif // _GFX_MENU_CONFIG_H_