386 lines
13 KiB
C++
386 lines
13 KiB
C++
/*
|
|
ILI9341_due_gText.cpp - Used for rendering GLCD fonts on Arduino Due
|
|
|
|
Copyright (c) 2014 Marek Buriak
|
|
|
|
The library is based on GLCD library by Bill Perry and Michael Margolis:
|
|
https://code.google.com/p/glcd-arduino
|
|
|
|
This file is part of the Arduino ILI9341_due library.
|
|
Sources for this library can be found at https://github.com/marekburiak/ILI9341_Due.
|
|
|
|
Fonts .h files can be created with GLCDFontCreator2 (not the one MikroElektronika):
|
|
https://code.google.com/p/glcd-arduino/downloads/detail?name=GLCDFontCreator2.zip&can=2&q=
|
|
|
|
|
|
ILI9341_due is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation, either version 2.1 of the License, or
|
|
(at your option) any later version.
|
|
|
|
ILI9341_due is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with ILI9341_due. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
#ifndef ILI9341_GTEXT_H
|
|
#define ILI9341_GTEXT_H
|
|
|
|
//#include "WString.h"
|
|
//#include "../Streaming/Streaming.h"
|
|
#include "ILI9341_due.h"
|
|
|
|
#define INCLUDE_NOT_WORKING_YET 0
|
|
|
|
#define GTEXT_VERSION 1 // software version of this code
|
|
|
|
// Font Indices
|
|
#define GTEXT_FONT_LENGTH 0
|
|
#define GTEXT_FONT_FIXED_WIDTH 2
|
|
#define GTEXT_FONT_HEIGHT 3
|
|
#define GTEXT_FONT_FIRST_CHAR 4
|
|
#define GTEXT_FONT_CHAR_COUNT 5
|
|
#define GTEXT_FONT_WIDTH_TABLE 6
|
|
|
|
#define GTEXT_DRAW_DIRECTION_RIGHT 0
|
|
#define GTEXT_DRAW_DIRECTION_DOWN 1
|
|
#define GTEXT_DRAW_DIRECTION_LEFT 2
|
|
#define GTEXT_DRAW_DIRECTION_UP 3
|
|
|
|
typedef enum {
|
|
gTextFontMode_Solid = 0,
|
|
gTextFontMode_Transparent = 1
|
|
} gTextFontMode;
|
|
|
|
|
|
// the following returns true if the given font is fixed width
|
|
// zero length is flag indicating fixed width font (array does not contain width data entries)
|
|
#define isFixedWidthFont(font) (pgm_read_byte(font+GTEXT_FONT_LENGTH) == 0 && pgm_read_byte(font+GTEXT_FONT_LENGTH+1) == 0))
|
|
|
|
/*
|
|
* Coodinates for predefined areas are compressed into a single 32 bit token.
|
|
*
|
|
* This works as the coordinates are cuurenly only 8 bit values.
|
|
*
|
|
* This allows the creatation of an unlmited number of predefined areas with zero code or
|
|
* data space overhead.
|
|
*
|
|
* A macro is used to create the tokens from a set of x1,y1 x2,y2 coordinates.
|
|
*
|
|
* A union is used to extract the coordinates from the 32 bit token.
|
|
*
|
|
* WARNING:
|
|
* This is non portable code in that it will only work on little endian processors.
|
|
* If you use big endian you have to switch the byte ordering in the union.
|
|
*/
|
|
|
|
#define MK_TareaToken(x1, y1, x2, y2) \
|
|
(uint32_t) (((uint32_t) (x1) << 24) | ((uint32_t)(y1) << 16) | ((uint32_t)(x2) << 8) | (uint32_t)(y2))
|
|
|
|
/// @cond hide_from_doxygen
|
|
typedef union
|
|
{
|
|
struct
|
|
{
|
|
uint8_t y2;
|
|
uint8_t x2;
|
|
uint8_t y1;
|
|
uint8_t x1;
|
|
}coord;
|
|
|
|
uint32_t token; // swap byte order above for big endian
|
|
|
|
}TareaToken;
|
|
/// @endcond
|
|
|
|
typedef uint8_t textMode; // type holding mode for scrolling and future attributes like padding etc.
|
|
// the only textMode supported in the current release is scrolling
|
|
|
|
const textMode SCROLL_UP = 0;
|
|
const textMode SCROLL_DOWN = 1; // this was changed from -1 so it can used in a bitmask
|
|
const textMode DEFAULT_SCROLLDIR = SCROLL_UP;
|
|
|
|
/**
|
|
* @defgroup glcd_enum GLCD enumerations
|
|
*/
|
|
|
|
/**
|
|
* @ingroup glcd_enum
|
|
* @hideinitializer
|
|
* @brief Pre Defined Text areas
|
|
*
|
|
* These enumerations are used to easily define text areas
|
|
* using predefined display areas.\n
|
|
* They are used with the
|
|
* \ref gText::DefineArea(predefinedArea selection, textMode mode) "DefineArea()" function call.
|
|
*/
|
|
typedef enum {
|
|
|
|
//textAreaFULL = MK_TareaToken( 0, 0, DISPLAY_WIDTH -1, DISPLAY_HEIGHT -1 ),
|
|
///**<Entire GLCD display */
|
|
|
|
//textAreaTOP = MK_TareaToken( 0, 0, DISPLAY_WIDTH -1, DISPLAY_HEIGHT/2 -1 ),
|
|
///**<Top half of GLCD display */
|
|
|
|
//textAreaBOTTOM = MK_TareaToken( 0, DISPLAY_HEIGHT/2, DISPLAY_WIDTH -1, DISPLAY_HEIGHT -1 ),
|
|
///**<Bottom half of GLCD display */
|
|
|
|
//textAreaLEFT = MK_TareaToken( 0, 0, DISPLAY_WIDTH/2 -1, DISPLAY_HEIGHT -1 ),
|
|
///**<Left side of GLCD display */
|
|
|
|
//textAreaRIGHT = MK_TareaToken( DISPLAY_WIDTH/2, 0, DISPLAY_WIDTH -1, DISPLAY_HEIGHT -1 ),
|
|
///**<Right side of GLCD display */
|
|
|
|
//textAreaTOPLEFT = MK_TareaToken( 0, 0, DISPLAY_WIDTH/2 -1, DISPLAY_HEIGHT/2 -1 ),
|
|
///**<Upper left quarter of GLCD display */
|
|
|
|
//textAreaTOPRIGHT = MK_TareaToken( DISPLAY_WIDTH/2, 0, DISPLAY_WIDTH -1, DISPLAY_HEIGHT/2 -1 ),
|
|
///**<Upper right quarter of GLCD display */
|
|
|
|
//textAreaBOTTOMLEFT = MK_TareaToken( 0, DISPLAY_HEIGHT/2, DISPLAY_WIDTH/2 -1, DISPLAY_HEIGHT -1 ),
|
|
///**<Buttom left quarter of GLCD display */
|
|
|
|
//textAreaBOTTOMRIGHT = MK_TareaToken( DISPLAY_WIDTH/2, DISPLAY_HEIGHT/2, DISPLAY_WIDTH -1, DISPLAY_HEIGHT -1 )
|
|
///**<Bottom right quarter of GLCD display */
|
|
|
|
} predefinedArea;
|
|
|
|
|
|
typedef enum {
|
|
gTextAlignTopLeft,
|
|
gTextAlignTopCenter,
|
|
gTextAlignTopRight,
|
|
gTextAlignMiddleLeft,
|
|
gTextAlignMiddleCenter,
|
|
gTextAlignMiddleRight,
|
|
gTextAlignBottomLeft,
|
|
gTextAlignBottomCenter,
|
|
gTextAlignBottomRight
|
|
} gTextAlign;
|
|
|
|
typedef enum {
|
|
gTextPivotDefault,
|
|
gTextPivotTopLeft,
|
|
gTextPivotTopCenter,
|
|
gTextPivotTopRight,
|
|
gTextPivotMiddleLeft,
|
|
gTextPivotMiddleCenter,
|
|
gTextPivotMiddleRight,
|
|
gTextPivotBottomLeft,
|
|
gTextPivotBottomCenter,
|
|
gTextPivotBottomRight
|
|
} gTextPivot;
|
|
|
|
|
|
/*
|
|
* enums for ansi style erase function
|
|
* These values match the ANSI EraseInLine terminal primitive: CSI n K
|
|
*/
|
|
/**
|
|
* @ingroup glcd_enum
|
|
* @hideinitializer
|
|
* @brief Erase line options
|
|
* @details
|
|
* These enumerations are used with the
|
|
* \ref gText::EraseTextLine( eraseLine_t type) "EraseTextLine()" function call.\n
|
|
* They provide similar functionality to the
|
|
* ANSI EraseInLine terminal primitive: CSI n K
|
|
*
|
|
*/
|
|
typedef enum {
|
|
gTextEraseToEOL = 0x01, /**< Erase From cursor to end of Line */
|
|
gTextEraseFromBOL = 0x02, /**< Erase From Begining of Line to Cursor*/
|
|
gTextEraseFullLine = 0x03 /**< Erase Entire line */
|
|
} gTextEraseLine;
|
|
|
|
typedef const uint8_t* gTextFont;
|
|
//typedef uint8_t (*FontCallback)(gTextFont);
|
|
|
|
|
|
//static glcd_Device *device; // static pointer to the device instance
|
|
|
|
/// @cond hide_from_doxygen
|
|
typedef struct _area
|
|
{
|
|
uint16_t x1;
|
|
uint16_t y1;
|
|
uint16_t x2;
|
|
uint16_t y2;
|
|
int8_t mode;
|
|
} area;
|
|
/// @endcond
|
|
|
|
/**
|
|
* @class gText
|
|
* @brief Functions for Text Areas
|
|
* @details
|
|
* A text area acts like a terminal monitor and text output is displayed
|
|
* within the confines of a rectangle given in the DefineArea command.
|
|
* All of the following text area functions operate on a user defined text area.
|
|
*/
|
|
|
|
// graphical device text routines
|
|
class ILI9341_due_gText : public Print
|
|
{
|
|
private:
|
|
ILI9341_due *_ili;
|
|
//FontCallback ucg_pgm_read; // now static, move back here if each instance needs its own callback
|
|
uint16_t _fontColor;
|
|
uint16_t _fontBgColor;
|
|
gTextFont _font;
|
|
area _area;
|
|
int16_t _x;
|
|
int16_t _y;
|
|
uint8_t _scale;
|
|
uint8_t _letterSpacing;
|
|
bool _isLastChar;
|
|
uint8_t _fontMode;
|
|
|
|
#ifndef GLCD_NODEFER_SCROLL
|
|
uint8_t _needScroll; // set when text scroll has been defered
|
|
#endif
|
|
void specialChar(uint8_t c);
|
|
void drawSolidChar(char c, uint16_t index, uint16_t charWidth, uint16_t charHeight);
|
|
void drawTransparentChar(char c, uint16_t index, uint16_t charWidth, uint16_t charHeight);
|
|
// Scroll routines are private for now
|
|
void ScrollUp(uint8_t x1, uint8_t y1, uint8_t x2, uint8_t y2, uint8_t pixels, uint8_t color);
|
|
void ScrollDown(uint8_t x1, uint8_t y1, uint8_t x2, uint8_t y2, uint8_t pixels, uint8_t color);
|
|
void applyPivot(char *str, gTextPivot pivot);
|
|
|
|
public:
|
|
ILI9341_due_gText(ILI9341_due *ili); // default - uses the entire display
|
|
ILI9341_due_gText(ILI9341_due *ili, int16_t x1, int16_t y1, int16_t x2, int16_t y2); //, textMode mode=DEFAULT_SCROLLDIR);
|
|
|
|
ILI9341_due_gText(ILI9341_due *ili, int16_t x1, int16_t y1, int16_t columns, int16_t rows, gTextFont font); //, textMode mode=DEFAULT_SCROLLDIR);
|
|
|
|
|
|
bool defineArea(int16_t x1, int16_t y1, int16_t x2, int16_t y2); //, textMode mode=DEFAULT_SCROLLDIR);
|
|
bool defineArea(int16_t x1, int16_t y1, int16_t columns, int16_t rows, gTextFont font); //, textMode mode=DEFAULT_SCROLLDIR);
|
|
void clearArea(uint16_t color);
|
|
|
|
// Font Functions
|
|
void selectFont(gTextFont font);
|
|
void selectFont(gTextFont font, uint16_t color);
|
|
void selectFont(gTextFont font, uint16_t color, uint16_t backgroundColor);
|
|
void setFontColor(uint16_t color);
|
|
void setFontColor(uint8_t R, uint8_t G, uint8_t B);
|
|
void setFontColor(uint16_t color, uint16_t backgroundColor);
|
|
void setFontColor(uint8_t R, uint8_t G, uint8_t B, uint8_t bgR, uint8_t bgG, uint8_t bgB);
|
|
void setFontLetterSpacing(uint8_t letterSpacing);
|
|
uint8_t getFontLetterSpacing() {
|
|
return _letterSpacing;
|
|
};
|
|
void setFontMode(gTextFontMode fontMode);
|
|
|
|
int putChar(uint8_t c);
|
|
void puts(char *str);
|
|
void puts(const String &str); // for Arduino String Class
|
|
void puts_P(PGM_P str);
|
|
|
|
|
|
void drawString(String &str, int16_t x, int16_t y); // for Arduino String class
|
|
void drawString_P(PGM_P str, int16_t x, int16_t y);
|
|
|
|
void drawString(char *str, int16_t x, int16_t y);
|
|
void drawString(char *str, int16_t x, int16_t y, gTextEraseLine eraseLine);
|
|
void drawString(char *str, int16_t x, int16_t y, uint16_t pixelsClearedOnLeft, uint16_t pixelsClearedOnRight);
|
|
void drawString(char *str, gTextAlign align);
|
|
void drawString(char *str, gTextAlign align, gTextEraseLine eraseLine);
|
|
void drawString(char *str, gTextAlign align, uint16_t pixelsClearedOnLeft, uint16_t pixelsClearedOnRight);
|
|
|
|
void drawStringOffseted(char *str, gTextAlign align, uint16_t offsetX, uint16_t offsetY);
|
|
void drawStringOffseted(char *str, gTextAlign align, uint16_t offsetX, uint16_t offsetY, gTextEraseLine eraseLine);
|
|
void drawStringOffseted(char *str, gTextAlign align, uint16_t offsetX, uint16_t offsetY, uint16_t pixelsClearedOnLeft, uint16_t pixelsClearedOnRight);
|
|
|
|
void drawStringPivoted(char *str, int16_t x, int16_t y, gTextPivot pivot);
|
|
void drawStringPivoted(char *str, gTextAlign align, gTextPivot pivot);
|
|
void drawStringPivoted(char *str, gTextAlign align, gTextPivot pivot, gTextEraseLine eraseLine);
|
|
void drawStringPivoted(char *str, gTextAlign align, gTextPivot pivot, uint16_t pixelsClearedOnLeft, uint16_t pixelsClearedOnRight);
|
|
|
|
void drawStringPivotedOffseted(char *str, gTextAlign align, gTextPivot pivot, uint16_t offsetX, uint16_t offsetY);
|
|
void drawStringPivotedOffseted(char *str, gTextAlign align, gTextPivot pivot, uint16_t offsetX, uint16_t offsetY, gTextEraseLine eraseLine);
|
|
void drawStringPivotedOffseted(char *str, gTextAlign align, gTextPivot pivot, uint16_t offsetX, uint16_t offsetY, uint16_t pixelsClearedOnLeft, uint16_t pixelsClearedOnRight);
|
|
|
|
size_t write(uint8_t c); // character output for print base class
|
|
|
|
void cursorTo( uint8_t column, uint8_t row); // 0 based coordinates for character columns and rows
|
|
void cursorTo( int8_t column); // move cursor on the current row
|
|
void cursorToXY( int16_t x, int16_t y); // coordinates relative to active text area
|
|
|
|
inline __attribute__((always_inline))
|
|
uint8_t fontHeight() {
|
|
return pgm_read_byte(_font+GTEXT_FONT_HEIGHT);
|
|
};
|
|
|
|
inline __attribute__((always_inline))
|
|
uint8_t fontHeight(gTextFont font) {
|
|
return pgm_read_byte(font+GTEXT_FONT_HEIGHT);
|
|
};
|
|
|
|
uint16_t charWidth(uint8_t c);
|
|
uint16_t stringWidth(const char* str);
|
|
uint16_t stringWidth_P(PGM_P str);
|
|
uint16_t stringWidth_P(String &str);
|
|
|
|
void eraseTextLine(uint16_t color, gTextEraseLine type=gTextEraseToEOL); //ansi like line erase function
|
|
void eraseTextLine(uint16_t color, uint8_t row); // erase the entire text line in the given row and move cursor to left position
|
|
|
|
void printNumber(long n);
|
|
|
|
#if INCLUDE_NOT_WORKING_YET
|
|
ILI9341_due_gText(ILI9341_due *ili, predefinedArea selection); //, textMode mode=DEFAULT_SCROLLDIR);
|
|
bool defineArea(predefinedArea selection); //, textMode mode=DEFAULT_SCROLLDIR);
|
|
void setTextMode(textMode mode); // change to the given text mode
|
|
#endif
|
|
|
|
static uint16_t charWidth(uint8_t c, gTextFont font)
|
|
{
|
|
int16_t width = 0;
|
|
|
|
if(isFixedWidthFont(font){
|
|
width = pgm_read_byte(font+GTEXT_FONT_FIXED_WIDTH);
|
|
}
|
|
else{
|
|
// variable width font
|
|
uint8_t firstChar = pgm_read_byte(font+GTEXT_FONT_FIRST_CHAR);
|
|
uint8_t charCount = pgm_read_byte(font+GTEXT_FONT_CHAR_COUNT);
|
|
|
|
// read width data
|
|
if(c >= firstChar && c < (firstChar+charCount)) {
|
|
c -= firstChar;
|
|
width = pgm_read_byte(font+GTEXT_FONT_WIDTH_TABLE+c);
|
|
}
|
|
}
|
|
return width;
|
|
};
|
|
|
|
static uint16_t stringWidth(const char* str, gTextFont font, uint8_t letterSpacing)
|
|
{
|
|
uint16_t width = 0;
|
|
|
|
while(*str != 0) {
|
|
width += ILI9341_due_gText::charWidth(*str++, font) + letterSpacing;
|
|
}
|
|
if(width > 0)
|
|
width -= letterSpacing;
|
|
|
|
return width;
|
|
};
|
|
|
|
//#ifndef USE_ARDUINO_FLASHSTR
|
|
// // when the following function is supported in arduino it will be removed from this library
|
|
// void printFlash(FLASHSTRING str); //this overrides the Arduino print function to implicilty store the string in flash (progmem)
|
|
// void printFlashln(FLASHSTRING str);
|
|
//#endif
|
|
|
|
/*@}*/
|
|
|
|
};
|
|
|
|
#endif
|