TcThemeBuilder.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 TCCLIBSDK_TCTHEMEBUILDER_H
#define TCCLIBSDK_TCTHEMEBUILDER_H
 
#include "GfxMenuConfig.h"
#include <graphics/GraphicsDeviceRenderer.h>
 
#define COL_COUNT_FLAG_BULK_MODE 0x80
 
namespace tcgfx {
    class TcThemeBuilder;

    class ThemePropertiesBuilder {
    public:
        enum ThemeLevel : uint8_t {
            THEME_GLOBAL, THEME_SUB, THEME_ITEM, THEME_ITEM_NEEDS_PROPS, THEME_ITEM_NEEDS_GRID, THEME_ITEM_NEEDS_BOTH
        };
    private:
        // do not reorder these fields, they are ordered this way to reduce the size, IE the packing overhead.
        TcThemeBuilder *themeBuilder;
        color_t palette[4]{};
        const void* fontData{};
        MenuItem* menuItem = nullptr;
        MenuPadding padding {};
        MenuBorder border{};
        uint16_t gridHeight {};
        ItemDisplayProperties::ComponentType componentType = ItemDisplayProperties::COMPTYPE_ITEM;
        ThemeLevel currentLevel = THEME_GLOBAL;
        uint8_t fontMag{};
        uint8_t spacing{};
        GridPosition::GridDrawingMode drawingMode{};
        GridPosition::GridJustification justification = GridPosition::JUSTIFY_TITLE_LEFT_VALUE_RIGHT;
        uint8_t row {};
        uint8_t colPos {};
        uint8_t colCount {};
    public:
        explicit ThemePropertiesBuilder(TcThemeBuilder *themeBuilder): themeBuilder(themeBuilder) {}

        ThemePropertiesBuilder& withBorder(const MenuBorder& b) {
            border = b;
            needsProps();
            return *this;
        }

        ThemePropertiesBuilder& withAdaFont(const GFXfont* font, int mag = 1) {
            fontData = font;
            fontMag = internal_min(1, mag);
            needsProps();
            return *this;
        }

        ThemePropertiesBuilder& withTcUnicodeFont(const UnicodeFont* font) {
            fontData = font;
            fontMag = 0;
            needsProps();
            return *this;
        }

        ThemePropertiesBuilder& withNativeFont(const void* data, uint8_t mag) {
            fontData = data;
            fontMag = mag;
            needsProps();
            return *this;
        }

        ThemePropertiesBuilder& withPadding(MenuPadding p) {
            padding = p;
            needsProps();
            return *this;
        }

        ThemePropertiesBuilder& withSpacing(uint8_t s) {
            spacing = s;
            needsGrid(true);
            return *this;
        }

        ThemePropertiesBuilder& withJustification(GridPosition::GridJustification j) {
            justification = j;
            needsGrid(true);
            return *this;
        }

        ThemePropertiesBuilder& withPalette(const color_t* p) {
            needsProps();
            memcpy(palette, p, sizeof(palette));
            return *this;
        }

        ThemePropertiesBuilder& withRowHeight(uint16_t height) {
            gridHeight = height;
            needsGrid(false);
            return *this;
        }

        ThemePropertiesBuilder& withImageOfType(Coord size, DrawableIcon::IconType iconType, const uint8_t* regIcon,
                                                const uint8_t* selIcon, const color_t* palette = nullptr);

        ThemePropertiesBuilder& withImageXbmp(Coord size, const uint8_t* regIcon, const uint8_t* selIcon = nullptr) {
            withImageOfType(size, DrawableIcon::ICON_XBITMAP, regIcon, selIcon);
            return *this;
        }

        ThemePropertiesBuilder& withImage2bpp(Coord size, const color_t* imgPalette, const uint8_t* regIcon, const uint8_t* selIcon = nullptr) {
            withImageOfType(size, DrawableIcon::ICON_PALLETE_2BPP, regIcon, selIcon, imgPalette);
            return *this;
        }

        ThemePropertiesBuilder& withImage4bpp(Coord size, const color_t* imgPalette, const uint8_t* regIcon, const uint8_t* selIcon = nullptr) {
            withImageOfType(size, DrawableIcon::ICON_PALLETE_4BPP, regIcon, selIcon, imgPalette);
            return *this;
        }

        ThemePropertiesBuilder& withMonoBitmap(Coord size, const uint8_t* regIcon, const uint8_t* selIcon = nullptr) {
            withImageOfType(size, DrawableIcon::ICON_MONO, regIcon, selIcon);
            return *this;
        }
 

        ThemePropertiesBuilder& withDrawingMode(GridPosition::GridDrawingMode dm) {
            drawingMode = dm;
            needsGrid(false);
            return *this;
        }

        ThemePropertiesBuilder& onRowCol(uint8_t actRow, uint8_t column, uint8_t numberOfCols) {
            row = actRow;
            colPos = column;
            colCount = numberOfCols;
            return *this;
        }

        ThemePropertiesBuilder& onRow(uint8_t actualRow) {
            colPos = 1;
            colCount = 1;
            row = actualRow;
            return *this;
        }

        void apply();
 
    protected:
        void initForLevel(TcThemeBuilder *b, ItemDisplayProperties::ComponentType compType, ThemeLevel level, MenuItem *item = nullptr);
 
        void needsProps() {
            if(currentLevel == THEME_SUB || currentLevel == THEME_GLOBAL) return;
            if(currentLevel == THEME_ITEM) currentLevel = THEME_ITEM_NEEDS_PROPS;
            else currentLevel = THEME_ITEM_NEEDS_BOTH;
        }
 
        void needsGrid(bool propsOk) {
            if(currentLevel == THEME_SUB || currentLevel == THEME_GLOBAL) return;
            if(currentLevel == THEME_ITEM_NEEDS_PROPS && propsOk) return;
            if(currentLevel == THEME_ITEM) currentLevel = THEME_ITEM_NEEDS_GRID;
            else currentLevel = THEME_ITEM_NEEDS_BOTH;
        }
 
        friend TcThemeBuilder;
    };

    class TcThemeBuilder {
    private:
        GraphicsDeviceRenderer &renderer;
        ConfigurableItemDisplayPropertiesFactory &factory;
        ThemePropertiesBuilder propertiesBuilder;
        color_t defaultPalette[4] = {};
        MenuPadding globalItemPadding;
        MenuPadding globalTitlePadding;
        const void *fontData;
        uint8_t fontMag;
        uint8_t defaultSpacing;
    public:
        explicit TcThemeBuilder(GraphicsDeviceRenderer& renderer) : renderer(renderer), factory(renderer.getGraphicsPropertiesFactory()),
                                                                    propertiesBuilder(this) {
            auto titleDef = factory.configFor(nullptr, ItemDisplayProperties::COMPTYPE_TITLE);
            globalTitlePadding = titleDef->getPadding();
            auto itemDef = factory.configFor(nullptr, ItemDisplayProperties::COMPTYPE_ITEM);
            memcpy(defaultPalette, itemDef->getPalette(), sizeof defaultPalette);
            globalItemPadding = itemDef->getPadding();
            fontData = itemDef->getFont();
            fontMag = itemDef->getFontMagnification();
            defaultSpacing = itemDef->getSpaceAfter();
        }

        TcThemeBuilder &withSelectedColors(color_t bg, color_t fg) {
            factory.setSelectedColors(bg, fg);
            return *this;
        }

        TcThemeBuilder& withAdaFont(const GFXfont* font, int mag = 1) {
            fontData = font;
            fontMag = internal_min(1, mag);
            return *this;
        }

        TcThemeBuilder& withTcUnicodeFont(const UnicodeFont* font) {
            fontData = font;
            fontMag = 0;
            return *this;
        }

        TcThemeBuilder& withNativeFont(const void* data, uint8_t mag) {
            fontData = data;
            fontMag = mag;
            return *this;
        }

        TcThemeBuilder & enableTcUnicode();

        TcThemeBuilder & enablingTcUnicode() {return enableTcUnicode();}

        TcThemeBuilder &withCursorIconsXbmp(Coord size, const uint8_t *editIcon, const uint8_t *activeIcon);

        TcThemeBuilder &withStandardLowResCursorIcons();

        TcThemeBuilder &withStandardMedResCursorIcons();

        TcThemeBuilder &withSpacing(uint8_t spacing) {
            defaultSpacing = spacing;
            return *this;
        }

        TcThemeBuilder &withItemPadding(MenuPadding padding) {
            globalItemPadding = padding;
            return *this;
        }

        TcThemeBuilder &withTitlePadding(MenuPadding padding) {
            globalTitlePadding = padding;
            return *this;
        }

        ThemePropertiesBuilder &defaultItemProperties() {
            propertiesBuilder.initForLevel(this, ItemDisplayProperties::COMPTYPE_ITEM, ThemePropertiesBuilder::THEME_GLOBAL);
            return propertiesBuilder;
        }

        ThemePropertiesBuilder &defaultTitleProperties() {
            propertiesBuilder.initForLevel(this, ItemDisplayProperties::COMPTYPE_TITLE, ThemePropertiesBuilder::THEME_GLOBAL);
            return propertiesBuilder;
        }

        ThemePropertiesBuilder &defaultActionProperties() {
            propertiesBuilder.initForLevel(this, ItemDisplayProperties::COMPTYPE_ACTION, ThemePropertiesBuilder::THEME_GLOBAL);
            return propertiesBuilder;
        }

        ThemePropertiesBuilder &menuItemOverride(MenuItem &item);

        ThemePropertiesBuilder &menuItemOverride(MenuItem &item, ItemDisplayProperties::ComponentType componentType);

        ThemePropertiesBuilder &submenuPropertiesItemOverride(SubMenuItem &item) {
            propertiesBuilder.initForLevel(this, ItemDisplayProperties::COMPTYPE_ITEM, ThemePropertiesBuilder::THEME_SUB, &item);
            return propertiesBuilder;
        }

        ThemePropertiesBuilder &submenuPropertiesActionOverride(SubMenuItem &item) {
            propertiesBuilder.initForLevel(this, ItemDisplayProperties::COMPTYPE_ACTION, ThemePropertiesBuilder::THEME_SUB, &item);
            return propertiesBuilder;
        }

        ThemePropertiesBuilder &submenuPropertiesTitleOverride(SubMenuItem &item) {
            propertiesBuilder.initForLevel(this, ItemDisplayProperties::COMPTYPE_TITLE, ThemePropertiesBuilder::THEME_SUB, &item);
            return propertiesBuilder;
        }

        TcThemeBuilder& withPalette(const color_t* cols);

        TcThemeBuilder& withRenderingSettings(BaseGraphicalRenderer::TitleMode mode, bool useAnalogSliders) {
            renderer.setTitleMode(mode);
            renderer.setUseSliderForAnalog(useAnalogSliders);
            return *this;
        }

        TcThemeBuilder& dimensionsFromRenderer();

        TcThemeBuilder& manualDimensions(int x, int y);

        TcThemeBuilder& enableCardLayoutWithXbmImages(Coord iconSize, const uint8_t* leftIcon, const uint8_t* rightIcon, bool isMono);
        TcThemeBuilder& setMenuAsCard(SubMenuItem& item, bool on);
        
        TcThemeBuilder& addingTitleWidget(TitleWidget& theWidget);

        void apply();
 
        ConfigurableItemDisplayPropertiesFactory& getItemFactory() { return factory; }
 
        MenuPadding getPaddingFor(ItemDisplayProperties::ComponentType type) {
            return type == ItemDisplayProperties::COMPTYPE_TITLE ? globalTitlePadding : globalItemPadding;
        }
 
        uint8_t getDefaultSpacing() const {
            return defaultSpacing;
        }
 
        GraphicsDeviceRenderer& getRenderer() {
            return renderer;
        }
 
        const color_t* getDefaultPalette() {
            return defaultPalette;
        }
 
        const void* getDefaultFontData() {
            return fontData;
        }
 
        uint8_t getDefaultFontMag() const {
            return fontMag;
        }
    };
 
}
#endif //TCCLIBSDK_TCTHEMEBUILDER_H