DrawingPrimitives.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_DRAWING_PRIMITIVES_H
#define TCMENU_DRAWING_PRIMITIVES_H
 
#include <PlatformDetermination.h>
 
namespace tcgfx {
 
#define DRAW_NO_MASK 0xff
 
 
#ifdef NEED_32BIT_COLOR_T_ALPHA
    typedef uint32_t color_t;
#define RGB(r, g, b) (uint32_t)( 0xff000000UL | ((r)<<16UL) | ((g)<<8UL) | (b) )
#else
    typedef uint16_t color_t;
#define RGB(r, g, b) (uint16_t)( (((r)>>3)<<11) | (((g)>>2)<<5) | ((b)>>3) )
#endif
 
     struct MenuFontDef {
         const void* fontData;
         const uint8_t fontMag;
 
         MenuFontDef(const void* data, uint8_t mag) : fontData(data), fontMag(mag) { }
     };
 
    struct MenuPadding {
        uint16_t top: 4;
        uint16_t right: 4;
        uint16_t bottom: 4;
        uint16_t left: 4;
 
        MenuPadding(int top_, int right_, int bottom_, int left_) {
            top = top_;
            bottom = bottom_;
            right = right_;
            left = left_;
        }
 
        explicit MenuPadding(int equalAll = 0) {
            top = bottom = right = left = equalAll;
        }
    };
 
    inline void makePadding(MenuPadding& padding, int top, int right, int bottom, int left) {
        padding.top = top;
        padding.right = right;
        padding.bottom = bottom;
        padding.left = left;
    }
 
    struct MenuBorder {
        uint8_t top:2;
        uint8_t left:2;
        uint8_t bottom:2;
        uint8_t right:2;
 
        MenuBorder() = default;
 
        explicit MenuBorder(uint8_t equalSides) {
            top = left = bottom = right = equalSides;
        }
 
        MenuBorder(uint8_t top_, uint8_t right_, uint8_t bottom_, uint8_t left_) {
            top = top_;
            right = right_;
            left = left_;
            bottom = bottom_;
        }
 
        bool areAllBordersEqual() const {
            return (top == left) && (left == right) && (right == bottom);
        }
 
        bool isBorderOff() const {
            return areAllBordersEqual() && top == 0;
        }
    };
 
#ifndef TC_COORD_DEFINED
#define TC_COORD_DEFINED
    struct Coord {
        Coord() {
            x = y = 0;
        }
 
        Coord(int x, int y) {
            this->x = x;
            this->y = y;
        }
 
        Coord(const Coord &other) = default;
        Coord& operator = (const Coord& other) = default;
 
        int16_t x;
        int16_t y;
    };
 
#endif // TC_COORD_DEFINED
 
    class DrawableIcon {
    public:
        enum IconType : uint8_t {
            ICON_XBITMAP,
            ICON_MONO,
            ICON_PALLETE_2BPP,
            ICON_PALLETE_4BPP,
            ICON_NATIVE
        };
        enum MemoryLocation : uint8_t {
            STORED_IN_ROM,
            STORED_IN_RAM,
            LOAD_FROM_STORAGE
        };
    private:
        uint16_t menuId;
        Coord dimensions;
        IconType iconType;
        MemoryLocation location;
        const uint8_t *normalIcon;
        const uint8_t *selectedIcon;
        const color_t* palette;
    public:
        DrawableIcon() : menuId(0), dimensions(0, 0), iconType(ICON_XBITMAP), location(STORED_IN_ROM),
                         normalIcon(nullptr), selectedIcon(nullptr), palette(nullptr) {}
 
        DrawableIcon(const DrawableIcon &other) = default;
        DrawableIcon& operator=(const DrawableIcon& other) = default;
 
        DrawableIcon(uint16_t id, const Coord &size, IconType ty, const uint8_t *normal,
                     const uint8_t *selected = nullptr)
                : menuId(id), dimensions(size), iconType(ty), location(STORED_IN_ROM), normalIcon(normal),
                  selectedIcon(selected), palette(nullptr) {}
        DrawableIcon(uint16_t id, const Coord &size, IconType ty, const color_t* paletteEntries, const uint8_t *normal,
                     const uint8_t *selected = nullptr)
                : menuId(id), dimensions(size), iconType(ty), location(STORED_IN_ROM), normalIcon(normal),
                  selectedIcon(selected), palette(paletteEntries) {}
 
        const uint8_t *getIcon(bool selected) const {
            return (selected && selectedIcon != nullptr) ? selectedIcon : normalIcon;
        }
 
        const color_t* getPalette() const {
            return palette;
        }
 
        Coord getDimensions() const {
            return dimensions;
        };
 
        IconType getIconType() const {
            return iconType;
        }
 
        uint16_t getKey() const {
            return menuId;
        }
 
        void setFromValues(const Coord &size, IconType ty, const uint8_t *normal, const uint8_t *selected = nullptr) {
            this->dimensions = size;
            this->iconType = ty;
            this->normalIcon = normal;
            this->selectedIcon = selected;
        }
    };
 
} // namespace tcgfx
 
#endif //TCMENU_DRAWING_PRIMITIVES_H