tcUnicodeHelper.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 TC_UNICODE_FONTHELPER_H
#define TC_UNICODE_FONTHELPER_H
 
#include <string.h>
#include <inttypes.h>
#include "Utf8TextProcessor.h"
#include "UnicodeFontDefs.h"
 
#define TCUNICODE_API_VERSION 2
 
#if !defined(pgm_read_dword) && (defined(__MBED__) || defined(BUILD_FOR_PICO_CMAKE))
#define pgm_read_byte(addr) (*(const unsigned char *)(addr))
#define pgm_read_word(addr) (*(const unsigned short *)(addr))
#define pgm_read_dword(addr) (*(const unsigned long *)(addr))
#define pgm_read_float(addr) (*(const float *)(addr))
#define pgm_read_ptr(addr) (*(addr))
#define memcpy_P memcpy
#endif // pgm_read_byte

 
#if __has_include ("zio_local_definitions.h")
#    include "zio_local_definitions.h"
#endif
 
#ifndef TC_COORD_DEFINED
#define TC_COORD_DEFINED
 
namespace tcgfx {

    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
 
using namespace tcgfx;

class TextPlotPipeline {
public:
    virtual ~TextPlotPipeline() = default;
    virtual void drawPixel(uint16_t x, uint16_t y, uint32_t color) = 0;
    virtual void setCursor(const Coord& where) = 0;
    virtual Coord getCursor() = 0;
    virtual Coord getDimensions() = 0;
};
 
#define TC_UNICODE_CHAR_ERROR 0xffffffff

class GlyphWithBitmap {
private:
    const uint8_t *bitmapData = nullptr;
    const UnicodeFontGlyph *glyph = nullptr;
public:
    const uint8_t *getBitmapData() const {
        return bitmapData;
    }

    const UnicodeFontGlyph *getGlyph() const {
        return glyph;
    }
 
    void setBitmapData(const uint8_t *bm) {
        GlyphWithBitmap::bitmapData = bm;
    }
 
    void setGlyph(const UnicodeFontGlyph *g) {
        GlyphWithBitmap::glyph = g;
    }
};
 
void handleUtf8Drawing(void *userData, uint32_t ch);
 
#if __has_include (<Print.h>) || defined(ARDUINO_SAM_DUE)
#include <Print.h>
class UnicodeFontHandler : public Print {
#elif __has_include(<PrintCompat.h>)
#include <PrintCompat.h>
class UnicodeFontHandler : public Print {
#else
class UnicodeFontHandler {
#endif
 
public:
    enum HandlerMode {
        HANDLER_SIZING_TEXT, HANDLER_DRAWING_TEXT
    };
private:
    tccore::Utf8TextProcessor utf8;
    TextPlotPipeline *plotter;
    union {
        const UnicodeFont *unicodeFont;
        const GFXfont *adaFont;
    };
    bool fontAdafruit = false;
    HandlerMode handlerMode = HANDLER_DRAWING_TEXT;
    uint16_t xExtentCurrent = 0;
    int16_t calculatedBaseline = -1;
    uint32_t drawColor = 0;
public:
    explicit UnicodeFontHandler(TextPlotPipeline *plotter, tccore::UnicodeEncodingMode mode) : utf8(handleUtf8Drawing, this, mode),
                                                                                               plotter(plotter),
                                                                                               unicodeFont(nullptr) {}
    virtual ~UnicodeFontHandler() = default;

    TextPlotPipeline *getTextPlotPipeline() { return plotter; }

    void setTextPlotPipeline(TextPlotPipeline *newPipeline) { plotter = newPipeline; }

    void setFont(const UnicodeFont *font) {
        unicodeFont = font;
        fontAdafruit = false;
        calculatedBaseline = -1;
    }

    void setFont(const GFXfont *font) {
        adaFont = font;
        fontAdafruit = true;
        calculatedBaseline = -1;
    }

    void setCursor(int16_t x, int16_t y) { plotter->setCursor(Coord(x, y)); }

    void setCursor(const Coord& where) { plotter->setCursor(where); }

    void setDrawColor(uint32_t color) { this->drawColor = color; }

    void writeUnicode(uint32_t unicodeText);

    Coord textExtents(const char *text, int *baseline, bool progMem = false);

    Coord textExtents_P(const char *text, int *baseline) { return textExtents(text, baseline, true); }
 
#if !defined(__MBED__) && !defined(BUILD_FOR_PICO_CMAKE)

    Coord textExtents(const __FlashStringHelper *fh, int *baseline) {
        return textExtents((const char *) fh, baseline, true);
    }
 
#endif

    Coord textExtent(uint32_t theChar);

    size_t print_P(const char *textPgm);

    int getBaseline();

    size_t write(uint8_t data) override;

    bool findCharInFont(uint32_t ch, GlyphWithBitmap &glyphBitmap) const;
    int getYAdvance() const {
        if(adaFont == nullptr) return 0;
        return pgm_read_byte((fontAdafruit ? &adaFont->yAdvance : &unicodeFont->yAdvance));
    }

    void internalHandleUnicodeFont(uint32_t ch);
};
 
using namespace tccore;
 
#endif //TC_UNICODE_FONTHELPER_H