canvas.h

Go to the documentation of this file.

 
#pragma once

#define FONT_WIDTH_INDEX 0
#define FONT_HEIGHT_INDEX 1
#define BYTE_SIZE 8
 
#include "pico/stdlib.h"
#include <stdio.h>
#include <map>

enum class ColorIndex
{
    BLACK = 0, // "BLACK" must be coded with code 0x0 for monochrome display device
    WHITE = 1, // "WHITE" must be coded with code 0x1 for monochrome display device
 
    BLUE, //     {ColorIndex::BLUE, {0x00, 0x00, 0xFF}},
    LIME, //     {ColorIndex::LIME, {0x00, 0xFF, 0x00}},
    RED,  //     {ColorIndex::RED, {0xFF, 0x00, 0x00}},
 
    CYAN,    //     {ColorIndex::CYAN, {0x00, 0xFF, 0xFF}},
    YELLOW,  //     {ColorIndex::YELLOW, {0xFF, 0xFF, 0x00}},
    MAGENTA, //     {ColorIndex::MAGENTA, {0xFF, 0x00, 0xFF}},
 
    NAVY,     //     {ColorIndex::NAVY, {0x00, 0x00, 0x80}},
    GREEN,    //     {ColorIndex::GREEN, {0x00, 0x80, 0x00}},
    PHOSPHOR, //     {ColorIndex::PHOSPHOR, {0x00, 0x80, 0x00}},
    TEAL,     //     {ColorIndex::TEAL, {0xAA, 0xFF, 0x00}},
    BURGUNDY, //     {ColorIndex::BURGUNDY, {0x80, 0x00, 0x00}},
    PURPLE,   //     {ColorIndex::PURPLE, {0x80, 0x00, 0x80}},
    OLIVE,    //     {ColorIndex::OLIVE, {0x80, 0x80, 0x00}},
    GRAY,     //     {ColorIndex::GRAY, {0x80, 0x80, 0x80}},
 
    SILVER, //     {ColorIndex::SILVER, {0xC0, 0xC0, 0xC0}},
    MAROON, //     {ColorIndex::MAROON, {0xA5, 0x2A, 0x2A}},
    ORANGE, //     {ColorIndex::ORANGE, {0xFF, 0xA5, 0x00}},
    GOLD,   //     {ColorIndex::GOLD, {0xFF, 0xD7, 0x00}},
    FOREST  //     {ColorIndex::FOREST, {0x22, 0x8B, 0x22}}};
};

extern std::map<ColorIndex, uint16_t> color565_palette;

enum class CanvasFormat
{
    MONO_VLSB,
    MONO_HLSB,
    MONO_HMSB,
    RGB_COLOR_INDEX_8b,
    RGB565_16b
};

struct struct_ConfigGraphicWidget
{
    size_t canvas_width_pixel;
    size_t canvas_height_pixel;
    ColorIndex canvas_foreground_color{ColorIndex::WHITE};
    ColorIndex canvas_background_color{ColorIndex::BLACK};
    uint8_t widget_anchor_x{0};
    uint8_t widget_anchor_y{0};
    bool widget_with_border{false};
};

struct struct_ConfigTextWidget
{
    uint8_t number_of_column{0};
    uint8_t number_of_line{0};
    uint8_t widget_anchor_x{0};
    uint8_t widget_anchor_y{0};
    const unsigned char *font{nullptr};
    uint8_t tab_size{2};
    ColorIndex fg_color{ColorIndex::WHITE};
    ColorIndex bg_color{ColorIndex::BLACK};
    bool wrap{true};
    bool auto_next_char{true};
    bool widget_with_border{false};
};

class Canvas
{
protected:
public:
    CanvasFormat canvas_format;
    ColorIndex fg_color;
    ColorIndex bg_color;

    virtual void create_canvas_buffer() = 0;

    virtual void fill_canvas_with_color(ColorIndex color) = 0;

    uint8_t canvas_width_pixel;

    uint8_t canvas_height_pixel;

    size_t canvas_buffer_size_byte;

    size_t canvas_buffer_size_pixel;

    uint8_t *canvas_buffer{nullptr};

    uint16_t *canvas_16buffer{nullptr};

    Canvas(uint8_t canvas_width_pixel,
           uint8_t canvas_height_pixel);
 
    virtual ~Canvas();

    virtual void clear_canvas_buffer();

    virtual void draw_pixel(const int x, const int y,
                            const ColorIndex color = ColorIndex::WHITE) = 0;
};

class CanvasVLSB : public Canvas
{
private:
    void create_canvas_buffer();
 
public:
    CanvasVLSB(uint8_t canvas_width_pixel,
               uint8_t canvas_height_pixel);
    ~CanvasVLSB();

    void fill_canvas_with_color(ColorIndex color);
 
    void draw_pixel(const int x, const int y,
                    const ColorIndex color = ColorIndex::WHITE);
};

class CanvasRGB : public Canvas
{
private:
    void create_canvas_buffer();
 
public:
    CanvasRGB(uint8_t canvas_width_pixel,
              uint8_t canvas_height_pixel);
    ~CanvasRGB();

    void fill_canvas_with_color(ColorIndex color);
 
    void draw_pixel(const int x, const int y,
                    const ColorIndex color = ColorIndex::WHITE);
};

class CanvasTrueRGB : public Canvas
{
private:
    void create_canvas_buffer();
 
public:
    CanvasTrueRGB(uint8_t canvas_width_pixel,
                  uint8_t canvas_height_pixel);
    ~CanvasTrueRGB();

    virtual void clear_canvas_buffer();

    void fill_canvas_with_color(ColorIndex color);
 
    void draw_pixel(const int x, const int y,
                    const ColorIndex color = ColorIndex::WHITE);
};

class CanvasHMSB : public Canvas
{
private:
    void create_canvas_buffer();
 
public:
    CanvasHMSB(uint8_t canvas_width_pixel,
               uint8_t canvas_height_pixel);
    ~CanvasHMSB();
    void fill_canvas_with_color(ColorIndex color);
 
    void draw_pixel(const int x, const int y,
                    const ColorIndex color = ColorIndex::WHITE);
};