mirror of
https://codeberg.org/mclemens/ubitxv6.git
synced 2024-09-10 17:04:33 -04:00
1390 lines
36 KiB
C++
1390 lines
36 KiB
C++
// This is the PDQ re-mixed version of Adafruit's library from Xark
|
|
// here is the original copyright notice and license:
|
|
|
|
/*
|
|
This is the core graphics library for all our displays, providing a common
|
|
set of graphics primitives (points, lines, circles, etc.). It needs to be
|
|
paired with a hardware-specific library for each display device we carry
|
|
(to handle the lower-level functions).
|
|
|
|
Adafruit invests time and resources providing this open source code, please
|
|
support Adafruit & open-source hardware by purchasing products from Adafruit!
|
|
|
|
Copyright (c) 2013 Adafruit Industries. All rights reserved.
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
modification, are permitted provided that the following conditions are met:
|
|
|
|
- Redistributions of source code must retain the above copyright notice,
|
|
this list of conditions and the following disclaimer.
|
|
- Redistributions in binary form must reproduce the above copyright notice,
|
|
this list of conditions and the following disclaimer in the documentation
|
|
and/or other materials provided with the distribution.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
|
|
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
// This PDQ optimized version is by Xark
|
|
//
|
|
// Inspiration from Paul Stoffregen and the Teensy 3.1 community.
|
|
//
|
|
// GOALS:
|
|
// 1) Maintain "sketch" compatibility with original Adafruit libraries.
|
|
// 2) Be as much faster as is reasonably possible honoring goal 1. :-)
|
|
// 3) Be at least as small as Adafruit libraries.
|
|
//
|
|
// I believe all three of these have largely been achieved:
|
|
// 1) Near full compatibility. Only minor initialization changes in original sketch.
|
|
// 2) Between ~2.5 and ~12 times faster (fillRect ~2.5x, drawLine ~12x).
|
|
// An average of ~4x faster over entire "graphictest.ino" benchmark.
|
|
//
|
|
// Even if this library is faster, it was based on the Adafruit original.
|
|
// Adafruit deserves your support for making their library open-source (and
|
|
// for having some nice LCD modules and all kinds of other great parts too).
|
|
// Consider giving them your support if possible!
|
|
|
|
#ifndef _PDQ_GFX_H
|
|
#define _PDQ_GFX_H
|
|
|
|
#include "Arduino.h"
|
|
#include "Print.h"
|
|
|
|
#ifndef pgm_read_byte
|
|
#define pgm_read_byte(addr) (*(const unsigned char *)(addr))
|
|
#endif
|
|
#ifndef pgm_read_word
|
|
#define pgm_read_word(addr) (*(const unsigned short *)(addr))
|
|
#endif
|
|
#ifndef pgm_read_dword
|
|
#define pgm_read_dword(addr) (*(const unsigned long *)(addr))
|
|
#endif
|
|
#if !defined(__INT_MAX__) || (__INT_MAX__ > 0xFFFFL)
|
|
#define pgm_read_pointer(addr) ((void *)pgm_read_dword(addr))
|
|
#else
|
|
#define pgm_read_pointer(addr) ((void *)pgm_read_word(addr))
|
|
#endif
|
|
|
|
#include "gfxfont.h"
|
|
|
|
#define GFX_FONT_PACKED
|
|
|
|
typedef int coord_t; // type used for coordinates (signed) for parameters (int16_t used for storage)
|
|
typedef uint16_t color_t; // type used for colors (unsigned)
|
|
|
|
// swap any type
|
|
template<typename T>
|
|
static inline void swapValue(T& x, T& y)
|
|
{
|
|
T tmp = x;
|
|
x = y;
|
|
y = tmp;
|
|
}
|
|
|
|
// minimum value for any type
|
|
template<typename T>
|
|
static inline T minValue(T& x, T& y)
|
|
{
|
|
return x < y ? x : y;
|
|
}
|
|
|
|
// maximum value for any type
|
|
template<typename T>
|
|
static inline T maxValue(T& x, T& y)
|
|
{
|
|
return x >= y ? x : y;
|
|
}
|
|
|
|
template <class HW>
|
|
class PDQ_GFX : public Print {
|
|
|
|
public:
|
|
PDQ_GFX(coord_t w, coord_t h); // Constructor (called by HW driver)
|
|
|
|
// Graphic primitives
|
|
// drawPixel MUST be defined by the driver subclass (and has no generic fall-back):
|
|
|
|
// These are generic versions of routines for drivers that don't provide device-optimized code.
|
|
// Drivers are required to have these functions (without "_" postfix), but can fall back to using
|
|
// these if needed (they should not be called directly with "_" postfix or it will bypass any
|
|
// device-optimized implementations).
|
|
static void drawLine_(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color);
|
|
static void drawFastVLine_(coord_t x, coord_t y, coord_t h, color_t color);
|
|
static void drawFastHLine_(coord_t x, coord_t y, coord_t w, color_t color);
|
|
static void fillRect_(coord_t x, coord_t y, coord_t w, coord_t h, color_t color);
|
|
static void fillScreen_(color_t color);
|
|
|
|
// These are usually overridden in the driver subclass to be useful (but not internally referenced)
|
|
static void setRotation(uint8_t r); // only swaps width/height if not supported by driver
|
|
static void invertDisplay(boolean i); // only if supported by driver
|
|
|
|
// These exist in PDQ_GFX (and generally have no subclass override)
|
|
static void drawRect(coord_t x, coord_t y, coord_t w, coord_t h, color_t color);
|
|
static void drawCircle(coord_t x0, coord_t y0, coord_t r, color_t color);
|
|
static void drawCircleHelper(coord_t x0, coord_t y0, coord_t r, uint8_t cornername, color_t color);
|
|
static void fillCircle(coord_t x0, coord_t y0, coord_t r, color_t color);
|
|
static void fillCircleHelper(coord_t x0, coord_t y0, coord_t r, uint8_t cornername, coord_t delta, color_t color);
|
|
static void drawTriangle(coord_t x0, coord_t y0, coord_t x1, coord_t y1, coord_t x2, coord_t y2, color_t color);
|
|
static void fillTriangle(coord_t x0, coord_t y0, coord_t x1, coord_t y1, coord_t x2, coord_t y2, color_t color);
|
|
static void drawRoundRect(coord_t x0, coord_t y0, coord_t w, coord_t h, coord_t radius, color_t color);
|
|
static void fillRoundRect(coord_t x0, coord_t y0, coord_t w, coord_t h, coord_t radius, color_t color);
|
|
static void drawBitmap(coord_t x, coord_t y, const uint8_t *bitmap, coord_t w, coord_t h, color_t color);
|
|
static void drawBitmap(coord_t x, coord_t y, const uint8_t *bitmap, coord_t w, coord_t h, color_t color, color_t bg);
|
|
static void drawBitmap(coord_t x, coord_t y, uint8_t *bitmap, coord_t w, coord_t h, color_t color);
|
|
static void drawBitmap(coord_t x, coord_t y, uint8_t *bitmap, coord_t w, coord_t h, color_t color, color_t bg);
|
|
static void drawXBitmap(coord_t x, coord_t y, const uint8_t *bitmap, coord_t w, coord_t h, color_t color);
|
|
static void drawChar(coord_t x, coord_t y, unsigned char c, color_t color, color_t bg, uint8_t size);
|
|
static void drawCharGFX(coord_t x, coord_t y, unsigned char c, color_t color, color_t bg, uint8_t size);
|
|
static inline void setCursor(coord_t x, coord_t y);
|
|
static inline void setBound(coord_t x, coord_t y);
|
|
static inline void setTextColor(color_t c);
|
|
static inline void setTextColor(color_t c, color_t bg);
|
|
static inline void setTextSize(uint8_t s);
|
|
static inline void setTextWrap(boolean w);
|
|
static inline void cp437(boolean x=true);
|
|
static inline void setFont(const GFXfont *f = NULL);
|
|
|
|
static inline coord_t width() __attribute__ ((always_inline)) { return _width; }
|
|
static inline coord_t height() __attribute__ ((always_inline)) { return _height; }
|
|
static inline uint8_t getRotation() __attribute__ ((always_inline)) { return rotation; }
|
|
static inline coord_t getCursorX() __attribute__ ((always_inline)) { return cursor_x; }
|
|
static inline coord_t getCursorY() __attribute__ ((always_inline)) { return cursor_y; }
|
|
static inline void getTextBounds(char *string, coord_t x, coord_t y, int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h, coord_t wi = _width);
|
|
static inline void getTextBounds(const __FlashStringHelper *s, coord_t x, coord_t y, int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h, coord_t wi = _width);
|
|
|
|
virtual size_t write(uint8_t); // used by Arduino "Print.h" (and the one required virtual function)
|
|
|
|
protected:
|
|
static GFXfont* gfxFont;
|
|
static coord_t WIDTH, HEIGHT; // This is the 'raw' display w/h - never changes
|
|
static coord_t _width, _height; // Display w/h as modified by current rotation
|
|
static coord_t cursor_x, cursor_y;
|
|
static coord_t bound_x1, bound_x2;
|
|
static color_t textcolor, textbgcolor;
|
|
static uint8_t textsize;
|
|
static uint8_t rotation;
|
|
static boolean wrap; // If set, 'wrap' text at right edge of display
|
|
static boolean _cp437; // If set, use correct CP437 charset (default is off)
|
|
};
|
|
|
|
|
|
template <class HW>
|
|
class PDQ_GFX_Button_
|
|
{
|
|
public:
|
|
PDQ_GFX_Button_();
|
|
void initButton(PDQ_GFX<HW> *gfx, coord_t x, coord_t y, coord_t w, coord_t h, color_t outline, color_t fill, color_t textcolor, const char *label, uint8_t textsize);
|
|
void drawButton(boolean inverted = false);
|
|
boolean contains(coord_t x, coord_t y);
|
|
|
|
void press(boolean p);
|
|
boolean isPressed();
|
|
boolean justPressed();
|
|
boolean justReleased();
|
|
|
|
private:
|
|
PDQ_GFX<HW> *_gfx;
|
|
int16_t _x, _y;
|
|
int16_t _w, _h;
|
|
uint8_t _textsize;
|
|
color_t _outlinecolor, _fillcolor, _textcolor;
|
|
char _label[10];
|
|
|
|
boolean currstate, laststate;
|
|
};
|
|
|
|
// -----------------------------------------------
|
|
extern const unsigned char glcdfont[] PROGMEM;
|
|
|
|
template<class HW>
|
|
int16_t PDQ_GFX<HW>::WIDTH; // This is the 'raw' display w/h - never changes
|
|
template<class HW>
|
|
int16_t PDQ_GFX<HW>::HEIGHT;
|
|
template<class HW>
|
|
int16_t PDQ_GFX<HW>::_width; // Display w/h as modified by current rotation
|
|
template<class HW>
|
|
int16_t PDQ_GFX<HW>::_height;
|
|
template<class HW>
|
|
int16_t PDQ_GFX<HW>::cursor_x;
|
|
template<class HW>
|
|
int16_t PDQ_GFX<HW>::cursor_y;
|
|
template<class HW>
|
|
int16_t PDQ_GFX<HW>::bound_x1;
|
|
template<class HW>
|
|
int16_t PDQ_GFX<HW>::bound_x2;
|
|
template<class HW>
|
|
color_t PDQ_GFX<HW>::textcolor;
|
|
template<class HW>
|
|
color_t PDQ_GFX<HW>::textbgcolor;
|
|
template<class HW>
|
|
uint8_t PDQ_GFX<HW>::textsize;
|
|
template<class HW>
|
|
uint8_t PDQ_GFX<HW>::rotation;
|
|
template<class HW>
|
|
boolean PDQ_GFX<HW>::wrap; // If set, 'wrap' text at right edge of display
|
|
template<class HW>
|
|
boolean PDQ_GFX<HW>::_cp437; // If set, use correct CP437 charset (default is off)
|
|
template<class HW>
|
|
GFXfont *PDQ_GFX<HW>::gfxFont;
|
|
|
|
template<class HW>
|
|
PDQ_GFX<HW>::PDQ_GFX(coord_t w, coord_t h)
|
|
{
|
|
WIDTH = (int16_t)w;
|
|
HEIGHT = (int16_t)h;
|
|
_width = (int16_t)w;
|
|
_height = (int16_t)h;
|
|
cursor_x = 0;
|
|
cursor_y = 0;
|
|
bound_x1 = 0;
|
|
bound_x2 = WIDTH;
|
|
rotation = 0;
|
|
textsize = 1;
|
|
textcolor = 0xffff;
|
|
textbgcolor = 0xffff;
|
|
wrap = true;
|
|
_cp437 = false;
|
|
gfxFont = NULL;
|
|
}
|
|
|
|
// Draw a circle outline
|
|
template<class HW>
|
|
void PDQ_GFX<HW>::drawCircle(coord_t x0, coord_t y0, coord_t r, color_t color)
|
|
{
|
|
coord_t f = 1 - r;
|
|
coord_t ddF_x = 1;
|
|
coord_t ddF_y = -2 * r;
|
|
coord_t x = 0;
|
|
coord_t y = r;
|
|
|
|
HW::drawPixel(x0 , y0+r, color);
|
|
HW::drawPixel(x0 , y0-r, color);
|
|
HW::drawPixel(x0+r, y0 , color);
|
|
HW::drawPixel(x0-r, y0 , color);
|
|
|
|
while (x < y)
|
|
{
|
|
if (f >= 0)
|
|
{
|
|
y--;
|
|
ddF_y += 2;
|
|
f += ddF_y;
|
|
}
|
|
x++;
|
|
ddF_x += 2;
|
|
f += ddF_x;
|
|
|
|
HW::drawPixel(x0 + x, y0 + y, color);
|
|
HW::drawPixel(x0 - x, y0 + y, color);
|
|
HW::drawPixel(x0 + x, y0 - y, color);
|
|
HW::drawPixel(x0 - x, y0 - y, color);
|
|
HW::drawPixel(x0 + y, y0 + x, color);
|
|
HW::drawPixel(x0 - y, y0 + x, color);
|
|
HW::drawPixel(x0 + y, y0 - x, color);
|
|
HW::drawPixel(x0 - y, y0 - x, color);
|
|
}
|
|
}
|
|
|
|
template<class HW>
|
|
void PDQ_GFX<HW>::drawCircleHelper( coord_t x0, coord_t y0, coord_t r, uint8_t cornername, color_t color)
|
|
{
|
|
coord_t f = 1 - r;
|
|
coord_t ddF_x = 1;
|
|
coord_t ddF_y = -2 * r;
|
|
coord_t x = 0;
|
|
coord_t y = r;
|
|
|
|
while (x < y)
|
|
{
|
|
if (f >= 0)
|
|
{
|
|
y--;
|
|
ddF_y += 2;
|
|
f += ddF_y;
|
|
}
|
|
x++;
|
|
ddF_x += 2;
|
|
f += ddF_x;
|
|
if (cornername & 0x4)
|
|
{
|
|
HW::drawPixel(x0 + x, y0 + y, color);
|
|
HW::drawPixel(x0 + y, y0 + x, color);
|
|
}
|
|
if (cornername & 0x2)
|
|
{
|
|
HW::drawPixel(x0 + x, y0 - y, color);
|
|
HW::drawPixel(x0 + y, y0 - x, color);
|
|
}
|
|
if (cornername & 0x8)
|
|
{
|
|
HW::drawPixel(x0 - y, y0 + x, color);
|
|
HW::drawPixel(x0 - x, y0 + y, color);
|
|
}
|
|
if (cornername & 0x1)
|
|
{
|
|
HW::drawPixel(x0 - y, y0 - x, color);
|
|
HW::drawPixel(x0 - x, y0 - y, color);
|
|
}
|
|
}
|
|
}
|
|
|
|
template<class HW>
|
|
void PDQ_GFX<HW>::fillCircle(coord_t x0, coord_t y0, coord_t r, color_t color)
|
|
{
|
|
HW::drawFastVLine(x0, y0-r, 2*r+1, color);
|
|
fillCircleHelper(x0, y0, r, 3, 0, color);
|
|
}
|
|
|
|
// Used to do circles and roundrects
|
|
template<class HW>
|
|
void PDQ_GFX<HW>::fillCircleHelper(coord_t x0, coord_t y0, coord_t r, uint8_t cornername, coord_t delta, color_t color)
|
|
{
|
|
coord_t f = 1 - r;
|
|
coord_t ddF_x = 1;
|
|
coord_t ddF_y = -2 * r;
|
|
coord_t x = 0;
|
|
coord_t y = r;
|
|
|
|
while (x < y)
|
|
{
|
|
if (f >= 0)
|
|
{
|
|
y--;
|
|
ddF_y += 2;
|
|
f += ddF_y;
|
|
}
|
|
x++;
|
|
ddF_x += 2;
|
|
f += ddF_x;
|
|
|
|
if (cornername & 0x1)
|
|
{
|
|
HW::drawFastVLine(x0+x, y0-y, 2*y+1+delta, color);
|
|
HW::drawFastVLine(x0+y, y0-x, 2*x+1+delta, color);
|
|
}
|
|
if (cornername & 0x2)
|
|
{
|
|
HW::drawFastVLine(x0-x, y0-y, 2*y+1+delta, color);
|
|
HW::drawFastVLine(x0-y, y0-x, 2*x+1+delta, color);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Bresenham's algorithm - thx Wikipedia
|
|
template<class HW>
|
|
void PDQ_GFX<HW>::drawLine_(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color)
|
|
{
|
|
int8_t steep = abs(y1 - y0) > abs(x1 - x0);
|
|
if (steep)
|
|
{
|
|
swapValue(x0, y0);
|
|
swapValue(x1, y1);
|
|
}
|
|
|
|
if (x0 > x1)
|
|
{
|
|
swapValue(x0, x1);
|
|
swapValue(y0, y1);
|
|
}
|
|
|
|
coord_t dx, dy;
|
|
dx = x1 - x0;
|
|
dy = abs(y1 - y0);
|
|
|
|
coord_t err = dx / 2;
|
|
coord_t ystep;
|
|
|
|
if (y0 < y1)
|
|
{
|
|
ystep = 1;
|
|
}
|
|
else
|
|
{
|
|
ystep = -1;
|
|
}
|
|
|
|
for (; x0<=x1; x0++)
|
|
{
|
|
if (steep)
|
|
{
|
|
HW::drawPixel(y0, x0, color);
|
|
}
|
|
else
|
|
{
|
|
HW::drawPixel(x0, y0, color);
|
|
}
|
|
err -= dy;
|
|
if (err < 0)
|
|
{
|
|
y0 += ystep;
|
|
err += dx;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Draw a rectangle
|
|
template<class HW>
|
|
void PDQ_GFX<HW>::drawRect(coord_t x, coord_t y, coord_t w, coord_t h, color_t color)
|
|
{
|
|
HW::drawFastHLine(x , y , w, color);
|
|
HW::drawFastHLine(x , y+h-1, w, color);
|
|
HW::drawFastVLine(x , y , h, color);
|
|
HW::drawFastVLine(x+w-1, y , h, color);
|
|
}
|
|
|
|
template<class HW>
|
|
void PDQ_GFX<HW>::drawFastVLine_(coord_t x, coord_t y, coord_t h, color_t color)
|
|
{
|
|
// Used by driver when it has no special support
|
|
HW::drawLine(x, y, x, y+h-1, color);
|
|
}
|
|
|
|
template<class HW>
|
|
void PDQ_GFX<HW>::drawFastHLine_(coord_t x, coord_t y, coord_t w, color_t color)
|
|
{
|
|
// Used by driver when it has no special support
|
|
HW::drawLine(x, y, x+w-1, y, color);
|
|
}
|
|
|
|
template<class HW>
|
|
void PDQ_GFX<HW>::fillRect_(coord_t x, coord_t y, coord_t w, coord_t h, color_t color)
|
|
{
|
|
// Used by driver when it has no special support
|
|
for (coord_t i=x; i<x+w; i++)
|
|
{
|
|
HW::drawFastVLine(i, y, h, color);
|
|
}
|
|
}
|
|
|
|
template<class HW>
|
|
void PDQ_GFX<HW>::fillScreen_(color_t color)
|
|
{
|
|
// Used by driver when it has no special support
|
|
HW::fillRect(0, 0, _width, _height, color);
|
|
}
|
|
|
|
// Draw a rounded rectangle
|
|
template<class HW>
|
|
void PDQ_GFX<HW>::drawRoundRect(coord_t x, coord_t y, coord_t w, coord_t h, coord_t r, color_t color)
|
|
{
|
|
// smarter version
|
|
HW::drawFastHLine(x+r , y , w-2*r, color); // Top
|
|
HW::drawFastHLine(x+r , y+h-1, w-2*r, color); // Bottom
|
|
HW::drawFastVLine(x , y+r , h-2*r, color); // Left
|
|
HW::drawFastVLine(x+w-1, y+r , h-2*r, color); // Right
|
|
// draw four corners
|
|
drawCircleHelper(x+r , y+r , r, 1, color);
|
|
drawCircleHelper(x+w-r-1, y+r , r, 2, color);
|
|
drawCircleHelper(x+w-r-1, y+h-r-1, r, 4, color);
|
|
drawCircleHelper(x+r , y+h-r-1, r, 8, color);
|
|
}
|
|
|
|
// Fill a rounded rectangle
|
|
template<class HW>
|
|
void PDQ_GFX<HW>::fillRoundRect(coord_t x, coord_t y, coord_t w, coord_t h, coord_t r, color_t color)
|
|
{
|
|
// smarter version
|
|
HW::fillRect(x+r, y, w-2*r, h, color);
|
|
|
|
// draw four corners
|
|
fillCircleHelper(x+w-r-1, y+r, r, 1, h-2*r-1, color);
|
|
fillCircleHelper(x+r , y+r, r, 2, h-2*r-1, color);
|
|
}
|
|
|
|
// Draw a triangle
|
|
template<class HW>
|
|
void PDQ_GFX<HW>::drawTriangle(coord_t x0, coord_t y0, coord_t x1, coord_t y1, coord_t x2, coord_t y2, color_t color)
|
|
{
|
|
HW::drawLine(x0, y0, x1, y1, color);
|
|
HW::drawLine(x1, y1, x2, y2, color);
|
|
HW::drawLine(x2, y2, x0, y0, color);
|
|
}
|
|
|
|
// Fill a triangle
|
|
template<class HW>
|
|
void PDQ_GFX<HW>::fillTriangle( coord_t x0, coord_t y0, coord_t x1, coord_t y1, coord_t x2, coord_t y2, color_t color)
|
|
{
|
|
coord_t a, b, y, last;
|
|
|
|
// Sort coordinates by Y order (y2 >= y1 >= y0)
|
|
if (y0 > y1)
|
|
{
|
|
swapValue(y0, y1);
|
|
swapValue(x0, x1);
|
|
}
|
|
if (y1 > y2)
|
|
{
|
|
swapValue(y2, y1);
|
|
swapValue(x2, x1);
|
|
}
|
|
if (y0 > y1)
|
|
{
|
|
swapValue(y0, y1);
|
|
swapValue(x0, x1);
|
|
}
|
|
|
|
if (y0 == y2) // Handle awkward all-on-same-line case as its own thing
|
|
{
|
|
a = b = x0;
|
|
if (x1 < a)
|
|
a = x1;
|
|
else if (x1 > b)
|
|
b = x1;
|
|
if (x2 < a)
|
|
a = x2;
|
|
else if (x2 > b)
|
|
b = x2;
|
|
HW::drawFastHLine(a, y0, b-a+1, color);
|
|
return;
|
|
}
|
|
|
|
coord_t dx01 = x1 - x0;
|
|
coord_t dy01 = y1 - y0;
|
|
coord_t dx02 = x2 - x0;
|
|
coord_t dy02 = y2 - y0;
|
|
coord_t dx12 = x2 - x1;
|
|
coord_t dy12 = y2 - y1;
|
|
int32_t sa = 0;
|
|
int32_t sb = 0;
|
|
|
|
// For upper part of triangle, find scanline crossings for segments
|
|
// 0-1 and 0-2. If y1=y2 (flat-bottomed triangle), the scanline y1
|
|
// is included here (and second loop will be skipped, avoiding a /0
|
|
// error there), otherwise scanline y1 is skipped here and handled
|
|
// in the second loop...which also avoids a /0 error here if y0=y1
|
|
// (flat-topped triangle).
|
|
if (y1 == y2)
|
|
last = y1; // Include y1 scanline
|
|
else
|
|
last = y1-1; // Skip it
|
|
|
|
for (y = y0; y <= last; y++)
|
|
{
|
|
a = x0 + sa / dy01;
|
|
b = x0 + sb / dy02;
|
|
sa += dx01;
|
|
sb += dx02;
|
|
/* longhand:
|
|
a = x0 + (x1 - x0) * (y - y0) / (y1 - y0);
|
|
b = x0 + (x2 - x0) * (y - y0) / (y2 - y0);
|
|
*/
|
|
if (a > b)
|
|
swapValue(a, b);
|
|
HW::drawFastHLine(a, y, b-a+1, color);
|
|
}
|
|
|
|
// For lower part of triangle, find scanline crossings for segments
|
|
// 0-2 and 1-2. This loop is skipped if y1=y2.
|
|
sa = dx12 * (y - y1);
|
|
sb = dx02 * (y - y0);
|
|
for (; y <= y2; y++)
|
|
{
|
|
a = x1 + sa / dy12;
|
|
b = x0 + sb / dy02;
|
|
sa += dx12;
|
|
sb += dx02;
|
|
/* longhand:
|
|
a = x1 + (x2 - x1) * (y - y1) / (y2 - y1);
|
|
b = x0 + (x2 - x0) * (y - y0) / (y2 - y0);
|
|
*/
|
|
if (a > b)
|
|
swapValue(a, b);
|
|
HW::drawFastHLine(a, y, b-a+1, color);
|
|
}
|
|
}
|
|
|
|
// Draw a 1-bit image (bitmap) at the specified (x, y) position from the
|
|
// provided bitmap buffer (must be PROGMEM memory) using the specified
|
|
// foreground color (unset bits are transparent).
|
|
template<class HW>
|
|
void PDQ_GFX<HW>::drawBitmap(coord_t x, coord_t y, const uint8_t *bitmap, coord_t w, coord_t h, color_t color)
|
|
{
|
|
coord_t i, j, byteWidth = (w + 7) / 8;
|
|
uint8_t byte;
|
|
|
|
for (j = 0; j < h; j++)
|
|
{
|
|
for (i = 0; i < w; i++)
|
|
{
|
|
if (i % 8 == 0)
|
|
byte = pgm_read_byte(bitmap + j * byteWidth + i / 8);
|
|
else
|
|
byte <<= 1;
|
|
|
|
if (byte & 0x80)
|
|
HW::drawPixel(x+i, y+j, color);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Draw a 1-bit image (bitmap) at the specified (x, y) position from the
|
|
// provided bitmap buffer (must be PROGMEM memory) using the specified
|
|
// foreground (for set bits) and background (for clear bits) colors.
|
|
template<class HW>
|
|
void PDQ_GFX<HW>::drawBitmap(coord_t x, coord_t y, const uint8_t *bitmap, coord_t w, coord_t h, color_t color, color_t bg)
|
|
{
|
|
coord_t i, j, byteWidth = (w + 7) / 8;
|
|
uint8_t byte;
|
|
|
|
for (j = 0; j < h; j++)
|
|
{
|
|
for (i = 0; i < w; i++)
|
|
{
|
|
if (i % 8 == 0)
|
|
byte = pgm_read_byte(bitmap + j * byteWidth + i / 8);
|
|
else
|
|
byte <<= 1;
|
|
|
|
if (byte & 0x80)
|
|
HW::drawPixel(x+i, y+j, color);
|
|
else
|
|
HW::drawPixel(x+i, y+j, bg);
|
|
}
|
|
}
|
|
}
|
|
|
|
// drawBitmap() variant for RAM-resident (not PROGMEM) bitmaps.
|
|
template<class HW>
|
|
void PDQ_GFX<HW>::drawBitmap(coord_t x, coord_t y, uint8_t *bitmap, coord_t w, coord_t h, color_t color)
|
|
{
|
|
coord_t i, j, byteWidth = (w + 7) / 8;
|
|
uint8_t byte;
|
|
|
|
for (j = 0; j < h; j++)
|
|
{
|
|
for (i = 0; i < w; i++)
|
|
{
|
|
if (i % 8 == 0)
|
|
byte = bitmap[j * byteWidth + i / 8];
|
|
else
|
|
byte <<= 1;
|
|
|
|
if (byte & 0x80)
|
|
HW::drawPixel(x+i, y+j, color);
|
|
}
|
|
}
|
|
}
|
|
|
|
// drawBitmap() variant w/background for RAM-resident (not PROGMEM) bitmaps.
|
|
template<class HW>
|
|
void PDQ_GFX<HW>::drawBitmap(coord_t x, coord_t y, uint8_t *bitmap, coord_t w, coord_t h, color_t color, color_t bg)
|
|
{
|
|
coord_t i, j, byteWidth = (w + 7) / 8;
|
|
uint8_t byte;
|
|
|
|
for (j = 0; j < h; j++)
|
|
{
|
|
for (i = 0; i < w; i++)
|
|
{
|
|
if (i % 8 == 0)
|
|
byte = bitmap[j * byteWidth + i / 8];
|
|
else
|
|
byte <<= 1;
|
|
|
|
if (byte & 0x80)
|
|
HW::drawPixel(x+i, y+j, color);
|
|
else
|
|
HW::drawPixel(x+i, y+j, bg);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Draw XBitMap Files (*.xbm), exported from GIMP,
|
|
// Usage: Export from GIMP to *.xbm, rename *.xbm to *.c and open in editor.
|
|
// C Array can be directly used with this function
|
|
template<class HW>
|
|
void PDQ_GFX<HW>::drawXBitmap(coord_t x, coord_t y, const uint8_t *bitmap, coord_t w, coord_t h, color_t color)
|
|
{
|
|
coord_t i, j, byteWidth = (w + 7) / 8;
|
|
uint8_t byte;
|
|
|
|
for (j = 0; j < h; j++)
|
|
{
|
|
for (i = 0; i < w; i++)
|
|
{
|
|
if (i % 8 == 0)
|
|
byte = pgm_read_byte(bitmap + j * byteWidth + i / 8);
|
|
else
|
|
byte >>= 1;
|
|
|
|
if (byte & 0x01)
|
|
HW::drawPixel(x+i, y+j, color);
|
|
}
|
|
}
|
|
}
|
|
|
|
template<class HW>
|
|
size_t PDQ_GFX<HW>::write(uint8_t c)
|
|
{
|
|
// 'Classic' built-in font
|
|
if (!gfxFont)
|
|
{
|
|
if (c == '\n')
|
|
{
|
|
cursor_x = 0;
|
|
cursor_y += (coord_t)textsize*8;
|
|
}
|
|
else if (c != '\r')
|
|
{
|
|
HW::drawChar(cursor_x, cursor_y, c, textcolor, textbgcolor, textsize);
|
|
cursor_x += textsize*6;
|
|
if (wrap && (cursor_x > (_width - textsize*6)))
|
|
{
|
|
cursor_x = 0;
|
|
cursor_y += textsize*8;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(c == '\n')
|
|
{
|
|
cursor_x = bound_x1;
|
|
cursor_y += (coord_t)textsize * (uint8_t)pgm_read_byte(&gfxFont->yAdvance);
|
|
}
|
|
else if (c != '\r')
|
|
{
|
|
uint8_t first = pgm_read_byte(&gfxFont->first);
|
|
if ((c >= first) && (c <= (uint8_t)pgm_read_byte(&gfxFont->last)))
|
|
{
|
|
uint8_t c2 = c - pgm_read_byte(&gfxFont->first);
|
|
GFXglyph *glyph = &(((GFXglyph *)pgm_read_pointer(&gfxFont->glyph))[c2]);
|
|
uint8_t w = pgm_read_byte(&glyph->width);
|
|
uint8_t h = pgm_read_byte(&glyph->height);
|
|
// Is there an associated bitmap?
|
|
if ((w > 0) && (h > 0))
|
|
{
|
|
coord_t xo = (int8_t)pgm_read_byte(&glyph->xOffset); // sic
|
|
if(wrap && ((cursor_x + textsize * (xo + w)) >= bound_x2))
|
|
{
|
|
// Drawing character would go off right edge; wrap to new line
|
|
cursor_x = bound_x1;
|
|
cursor_y += (coord_t)textsize *
|
|
(uint8_t)pgm_read_byte(&gfxFont->yAdvance);
|
|
}
|
|
HW::drawCharGFX(cursor_x, cursor_y, c, textcolor, textbgcolor, textsize);
|
|
}
|
|
cursor_x += pgm_read_byte(&glyph->xAdvance) * (coord_t)textsize;
|
|
}
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
// Draw a character with built-in font
|
|
template<class HW>
|
|
void PDQ_GFX<HW>::drawChar(coord_t x, coord_t y, unsigned char c, color_t color, color_t bg, uint8_t size)
|
|
{
|
|
if ((x >= _width) ||
|
|
(y >= _height) ||
|
|
((x + (6 * size) - 1) < 0) ||
|
|
((y + (8 * size) - 1) < 0))
|
|
return;
|
|
|
|
uint8_t is_opaque = (bg != color);
|
|
|
|
if(!_cp437 && (c >= 176)) // Handle 'classic' charset behavior
|
|
c++;
|
|
|
|
for (int8_t i=0; i<6; i++)
|
|
{
|
|
uint8_t line;
|
|
|
|
if (i == 5)
|
|
line = 0x0;
|
|
else
|
|
line = pgm_read_byte(glcdfont+(c*5)+i);
|
|
|
|
if (size == 1)
|
|
{
|
|
for (int8_t j = 0; j < 8; j++)
|
|
{
|
|
if (line & 0x1)
|
|
{
|
|
HW::drawPixel(x+i, y+j, color);
|
|
}
|
|
else if (is_opaque)
|
|
{
|
|
HW::drawPixel(x+i, y+j, bg);
|
|
}
|
|
line >>= 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (int8_t j = 0; j < 8; j++)
|
|
{
|
|
if (line & 0x1)
|
|
{
|
|
HW::fillRect(x+(i*size), y+(j*size), size, size, color);
|
|
}
|
|
else if (is_opaque)
|
|
{
|
|
HW::fillRect(x+(i*size), y+(j*size), size, size, bg);
|
|
}
|
|
line >>= 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Draw a character with GFX font
|
|
template<class HW>
|
|
void PDQ_GFX<HW>::drawCharGFX(coord_t x, coord_t y, unsigned char c, color_t color, color_t bg, uint8_t size)
|
|
{
|
|
// Character is assumed previously filtered by write() to eliminate
|
|
// newlines, returns, non-printable characters, etc. Calling drawChar()
|
|
// directly with 'bad' characters of font may cause mayhem!
|
|
|
|
c -= pgm_read_byte(&gfxFont->first);
|
|
GFXglyph *glyph = &(((GFXglyph *)pgm_read_pointer(&gfxFont->glyph))[c]);
|
|
uint8_t *bitmap = (uint8_t *)pgm_read_pointer(&gfxFont->bitmap);
|
|
|
|
uint16_t bo = pgm_read_word(&glyph->bitmapOffset);
|
|
uint8_t w = pgm_read_byte(&glyph->width);
|
|
uint8_t h = pgm_read_byte(&glyph->height);
|
|
// uint8_t xa = pgm_read_byte(&glyph->xAdvance);
|
|
int8_t xo = pgm_read_byte(&glyph->xOffset);
|
|
int8_t yo = pgm_read_byte(&glyph->yOffset);
|
|
|
|
// Todo: Add character clipping here
|
|
|
|
// NOTE: THERE IS NO 'BACKGROUND' COLOR OPTION ON CUSTOM FONTS.
|
|
// THIS IS ON PURPOSE AND BY DESIGN. The background color feature
|
|
// has typically been used with the 'classic' font to overwrite old
|
|
// screen contents with new data. This ONLY works because the
|
|
// characters are a uniform size; it's not a sensible thing to do with
|
|
// proportionally-spaced fonts with glyphs of varying sizes (and that
|
|
// may overlap). To replace previously-drawn text when using a custom
|
|
// font, use the getTextBounds() function to determine the smallest
|
|
// rectangle encompassing a string, erase the area with fillRect(),
|
|
// then draw new text. This WILL infortunately 'blink' the text, but
|
|
// is unavoidable. Drawing 'background' pixels will NOT fix this,
|
|
// only creates a new set of problems. Have an idea to work around
|
|
// this (a canvas object type for MCUs that can afford the RAM and
|
|
// displays supporting setAddrWindow() and pushColors()), but haven't
|
|
// implemented this yet.
|
|
|
|
if (bo & 0x8000) {
|
|
// packed font
|
|
uint8_t bits_cnt = 0;
|
|
uint8_t bits;
|
|
uint8_t cnt,cnt2;
|
|
bo &= 0x7FFF;
|
|
coord_t _y = y+yo;
|
|
for (coord_t yy=0; yy<h; yy++, _y++)
|
|
{
|
|
coord_t _x = x+xo;
|
|
for (coord_t xx=0; xx<w; xx+=cnt2)
|
|
{
|
|
|
|
if (bits_cnt == 0)
|
|
{
|
|
bits = pgm_read_byte(&bitmap[bo++]);
|
|
bits_cnt = 2;
|
|
cnt = (bits & 0x7)+1;
|
|
}
|
|
|
|
if (xx+cnt >= w)
|
|
{
|
|
cnt2 = w-xx;
|
|
} else {
|
|
cnt2 = cnt;
|
|
}
|
|
|
|
if (bits & 0x8)
|
|
{
|
|
if (size == 1)
|
|
{
|
|
HW::drawFastHLine(_x, _y, cnt2, color);
|
|
_x += cnt2;
|
|
}
|
|
else
|
|
{
|
|
HW::fillRect(x+xo+xx*size, y+yo+yy*size, cnt2*size, size, color);
|
|
// _x not used if size > 1, so not need to increment it
|
|
}
|
|
} else {
|
|
_x += cnt2;
|
|
}
|
|
|
|
cnt -= cnt2;
|
|
if (cnt == 0) {
|
|
bits >>= 4;
|
|
cnt = (bits & 0x7)+1;
|
|
bits_cnt--;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
uint8_t bit = 0;
|
|
uint8_t bits = 0;
|
|
if (size == 1)
|
|
{
|
|
coord_t _y = y+yo;
|
|
for (coord_t yy=0; yy<h; yy++, _y++)
|
|
{
|
|
coord_t _x = x+xo;
|
|
for (coord_t xx=0; xx<w; xx++, _x++)
|
|
{
|
|
if (bit == 0)
|
|
{
|
|
bits = pgm_read_byte(&bitmap[bo++]);
|
|
}
|
|
bit = (bit+1) & 0x7;
|
|
|
|
if (bits & 0x80)
|
|
{
|
|
HW::drawPixel(_x, _y, color);
|
|
}
|
|
bits <<= 1;
|
|
}
|
|
}
|
|
} else {
|
|
for (coord_t yy=0; yy<h; yy++)
|
|
{
|
|
for (coord_t xx=0; xx<w; xx++)
|
|
{
|
|
if (bit == 0)
|
|
{
|
|
bits = pgm_read_byte(&bitmap[bo++]);
|
|
}
|
|
bit = (bit+1) & 0x7;
|
|
|
|
if (bits & 0x80)
|
|
{
|
|
HW::fillRect(x+xo+xx*size, y+yo+yy*size, size, size, color);
|
|
}
|
|
bits <<= 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
template<class HW>
|
|
void PDQ_GFX<HW>::setCursor(coord_t x, coord_t y)
|
|
{
|
|
cursor_x = (int16_t)x;
|
|
cursor_y = (int16_t)y;
|
|
}
|
|
|
|
template<class HW>
|
|
void PDQ_GFX<HW>::setBound(coord_t x1, coord_t x2)
|
|
{
|
|
bound_x1 = (int16_t)x1;
|
|
bound_x2 = (int16_t)x2;
|
|
}
|
|
|
|
template<class HW>
|
|
void PDQ_GFX<HW>::setTextSize(uint8_t s)
|
|
{
|
|
textsize = (s > 0) ? s : 1;
|
|
}
|
|
|
|
template<class HW>
|
|
void PDQ_GFX<HW>::setTextColor(color_t c)
|
|
{
|
|
// For 'transparent' background, we'll set the bg
|
|
// to the same as fg instead of using a flag
|
|
textcolor = c;
|
|
textbgcolor = c;
|
|
}
|
|
|
|
template<class HW>
|
|
void PDQ_GFX<HW>::setTextColor(color_t c, color_t b)
|
|
{
|
|
textcolor = c;
|
|
textbgcolor = b;
|
|
}
|
|
|
|
template<class HW>
|
|
void PDQ_GFX<HW>::setTextWrap(boolean w)
|
|
{
|
|
wrap = w;
|
|
}
|
|
|
|
template<class HW>
|
|
void PDQ_GFX<HW>::setRotation(uint8_t x)
|
|
{
|
|
// Used by driver when it has no special support
|
|
rotation = x & 3;
|
|
switch(rotation) {
|
|
case 0:
|
|
case 2:
|
|
_width = WIDTH;
|
|
_height = HEIGHT;
|
|
break;
|
|
case 1:
|
|
case 3:
|
|
_width = HEIGHT;
|
|
_height = WIDTH;
|
|
break;
|
|
}
|
|
}
|
|
|
|
template<class HW>
|
|
void PDQ_GFX<HW>::cp437(boolean x)
|
|
{
|
|
_cp437 = x;
|
|
}
|
|
|
|
template<class HW>
|
|
void PDQ_GFX<HW>::setFont(const GFXfont *f)
|
|
{
|
|
if (f) // Font struct pointer passed in?
|
|
{
|
|
if (!gfxFont) // And no current font struct?
|
|
{
|
|
// Switching from classic to new font behavior.
|
|
// Move cursor pos down 6 pixels so it's on baseline.
|
|
cursor_y += 6;
|
|
}
|
|
}
|
|
else if (gfxFont) // NULL passed. Current font struct defined?
|
|
{
|
|
// Switching from new to classic font behavior.
|
|
// Move cursor pos up 6 pixels so it's at top-left of char.
|
|
cursor_y -= 6;
|
|
}
|
|
gfxFont = (GFXfont *)f;
|
|
}
|
|
|
|
// Pass string and a cursor position, returns UL corner and W,H.
|
|
template<class HW>
|
|
void PDQ_GFX<HW>::getTextBounds(char *str, coord_t x, coord_t y, int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h, coord_t wi)
|
|
{
|
|
uint8_t c; // Current character
|
|
|
|
coord_t xs = x;
|
|
coord_t xe = xs+wi;
|
|
|
|
*x1 = x;
|
|
*y1 = y;
|
|
*w = *h = 0;
|
|
|
|
if (gfxFont)
|
|
{
|
|
GFXglyph *glyph;
|
|
uint8_t first = pgm_read_byte(&gfxFont->first);
|
|
uint8_t last = pgm_read_byte(&gfxFont->last);
|
|
uint8_t gw, gh, xa;
|
|
int8_t xo, yo;
|
|
int16_t minx = _width, miny = _height, maxx = -1, maxy = -1;
|
|
coord_t gx1, gy1, gx2, gy2;
|
|
coord_t ts = (coord_t)textsize, ya = (coord_t)textsize * (uint8_t)pgm_read_byte(&gfxFont->yAdvance);
|
|
|
|
while((c = *str++))
|
|
{
|
|
if (c != '\n') // Not a newline
|
|
{
|
|
if (c != '\r') // Not a carriage return, is normal char
|
|
{
|
|
if ((c >= first) && (c <= last)) // Char present in current font
|
|
{
|
|
c -= first;
|
|
glyph = &(((GFXglyph *)pgm_read_pointer(&gfxFont->glyph))[c]);
|
|
gw = pgm_read_byte(&glyph->width);
|
|
gh = pgm_read_byte(&glyph->height);
|
|
xa = pgm_read_byte(&glyph->xAdvance);
|
|
xo = pgm_read_byte(&glyph->xOffset);
|
|
yo = pgm_read_byte(&glyph->yOffset);
|
|
if (wrap && ((x + (((int16_t)xo + gw) * ts)) >= xe)) // Line wrap
|
|
{
|
|
x = xs; // Reset x to 0
|
|
y += ya; // Advance y by 1 line
|
|
}
|
|
gx1 = x + xo * ts;
|
|
gy1 = y + yo * ts;
|
|
gx2 = gx1 + gw * ts - 1;
|
|
gy2 = gy1 + gh * ts - 1;
|
|
if (gx1 < minx)
|
|
minx = gx1;
|
|
if (gy1 < miny)
|
|
miny = gy1;
|
|
if (gx2 > maxx)
|
|
maxx = gx2;
|
|
if (gy2 > maxy)
|
|
maxy = gy2;
|
|
x += xa * ts;
|
|
}
|
|
} // Carriage return = do nothing
|
|
}
|
|
else // Newline
|
|
{
|
|
x = xs; // Reset x
|
|
y += ya; // Advance y by 1 line
|
|
}
|
|
}
|
|
// End of string
|
|
*x1 = minx;
|
|
*y1 = miny;
|
|
if (maxx >= minx)
|
|
*w = maxx - minx + 1;
|
|
if (maxy >= miny)
|
|
*h = maxy - miny + 1;
|
|
|
|
}
|
|
else // Default font
|
|
{
|
|
uint16_t lineWidth = 0, maxWidth = 0; // Width of current, all lines
|
|
|
|
while((c = *str++))
|
|
{
|
|
if (c != '\n') // Not a newline
|
|
{
|
|
if (c != '\r') // Not a carriage return, is normal char
|
|
{
|
|
lineWidth += textsize * 6; // Includes interchar x gap
|
|
if (wrap && (cursor_x > (_width - textsize*6)))
|
|
{
|
|
x = 0;
|
|
y += textsize*8;
|
|
|
|
if (lineWidth > maxWidth) // Save widest line
|
|
maxWidth = lineWidth;
|
|
lineWidth = textsize * 6; // First char on new line
|
|
}
|
|
} // Carriage return = do nothing
|
|
}
|
|
else // Newline
|
|
{
|
|
x = 0; // Reset x to 0
|
|
y += textsize * 8; // Advance y by 1 line
|
|
if (lineWidth > maxWidth) // Save widest line
|
|
maxWidth = lineWidth;
|
|
lineWidth = 0; // Reset lineWidth for new line
|
|
}
|
|
}
|
|
// End of string
|
|
if (lineWidth) // Add height of last (or only) line
|
|
y += textsize * 8;
|
|
*w = maxWidth - 1; // Don't include last interchar x gap
|
|
*h = y - *y1;
|
|
|
|
} // End classic vs custom font
|
|
}
|
|
|
|
// Same as above, but for PROGMEM strings
|
|
template<class HW>
|
|
void PDQ_GFX<HW>::getTextBounds(const __FlashStringHelper *str, coord_t x, coord_t y, int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h, coord_t wi)
|
|
{
|
|
uint8_t *s = (uint8_t *)str;
|
|
uint8_t c;
|
|
coord_t xs = x;
|
|
coord_t xe = xs+wi;
|
|
|
|
*x1 = x;
|
|
*y1 = y;
|
|
*w = *h = 0;
|
|
|
|
if (gfxFont)
|
|
{
|
|
GFXglyph *glyph;
|
|
uint8_t first = pgm_read_byte(&gfxFont->first);
|
|
uint8_t last = pgm_read_byte(&gfxFont->last);
|
|
uint8_t gw, gh, xa;
|
|
int8_t xo, yo;
|
|
int16_t minx = _width, miny = _height, maxx = -1, maxy = -1;
|
|
coord_t gx1, gy1, gx2, gy2;
|
|
coord_t ts = (coord_t)textsize;
|
|
coord_t ya = ts * (uint8_t)pgm_read_byte(&gfxFont->yAdvance);
|
|
|
|
while((c = pgm_read_byte(s++)))
|
|
{
|
|
if (c != '\n') // Not a newline
|
|
{
|
|
if (c != '\r') // Not a carriage return, is normal char
|
|
{
|
|
if ((c >= first) && (c <= last)) // Char present in current font
|
|
{
|
|
c -= first;
|
|
glyph = &(((GFXglyph *)pgm_read_pointer(&gfxFont->glyph))[c]);
|
|
gw = pgm_read_byte(&glyph->width);
|
|
gh = pgm_read_byte(&glyph->height);
|
|
xa = pgm_read_byte(&glyph->xAdvance);
|
|
xo = pgm_read_byte(&glyph->xOffset);
|
|
yo = pgm_read_byte(&glyph->yOffset);
|
|
if (wrap && ((x + (((int16_t)xo + gw) * ts)) >= xe)) // Line wrap
|
|
{
|
|
x = xs; // Reset x to 0
|
|
y += ya; // Advance y by 1 line
|
|
}
|
|
gx1 = x + xo * ts;
|
|
gy1 = y + yo * ts;
|
|
gx2 = gx1 + gw * ts - 1;
|
|
gy2 = gy1 + gh * ts - 1;
|
|
if (gx1 < minx)
|
|
minx = gx1;
|
|
if (gy1 < miny)
|
|
miny = gy1;
|
|
if (gx2 > maxx)
|
|
maxx = gx2;
|
|
if (gy2 > maxy)
|
|
maxy = gy2;
|
|
x += xa * ts;
|
|
}
|
|
} // Carriage return = do nothing
|
|
}
|
|
else // Newline
|
|
{
|
|
x = xs; // Reset x
|
|
y += ya; // Advance y by 1 line
|
|
}
|
|
}
|
|
// End of string
|
|
*x1 = minx;
|
|
*y1 = miny;
|
|
if (maxx >= minx)
|
|
*w = maxx - minx + 1;
|
|
if (maxy >= miny)
|
|
*h = maxy - miny + 1;
|
|
|
|
}
|
|
else // Default font
|
|
{
|
|
uint16_t lineWidth = 0, maxWidth = 0; // Width of current, all lines
|
|
|
|
while((c = pgm_read_byte(s++)))
|
|
{
|
|
if (c != '\n') // Not a newline
|
|
{
|
|
if (c != '\r') // Not a carriage return, is normal char
|
|
{
|
|
if (wrap && ((x + textsize * 6) >= _width))
|
|
{
|
|
x = 0; // Reset x to 0
|
|
y += textsize * 8; // Advance y by 1 line
|
|
if (lineWidth > maxWidth) // Save widest line
|
|
maxWidth = lineWidth;
|
|
lineWidth = textsize * 6; // First char on new line
|
|
}
|
|
else // No line wrap, just keep incrementing X
|
|
{
|
|
lineWidth += textsize * 6; // Includes interchar x gap
|
|
}
|
|
} // Carriage return = do nothing
|
|
}
|
|
else // Newline
|
|
{
|
|
x = 0; // Reset x to 0
|
|
y += textsize * 8; // Advance y by 1 line
|
|
if (lineWidth > maxWidth) // Save widest line
|
|
maxWidth = lineWidth;
|
|
lineWidth = 0; // Reset lineWidth for new line
|
|
}
|
|
}
|
|
// End of string
|
|
if (lineWidth) // Add height of last (or only) line
|
|
y += textsize * 8;
|
|
*w = maxWidth - 1; // Don't include last interchar x gap
|
|
*h = y - *y1;
|
|
|
|
} // End classic vs custom font
|
|
}
|
|
|
|
template<class HW>
|
|
void PDQ_GFX<HW>::invertDisplay(boolean i)
|
|
{
|
|
// Used by driver when it has no special support
|
|
// Do nothing, must be supported by driver
|
|
}
|
|
|
|
/***************************************************************************/
|
|
// code for the GFX button UI element
|
|
|
|
template <class HW>
|
|
PDQ_GFX_Button_<HW>::PDQ_GFX_Button_()
|
|
{
|
|
_gfx = 0;
|
|
}
|
|
|
|
template <class HW>
|
|
void PDQ_GFX_Button_<HW>::initButton(PDQ_GFX<HW> *gfx, coord_t x, coord_t y, coord_t w, coord_t h, color_t outline, color_t fill, color_t textcolor, const char *label, uint8_t textsize)
|
|
{
|
|
_gfx = gfx;
|
|
_x = x;
|
|
_y = y;
|
|
_w = w;
|
|
_h = h;
|
|
_outlinecolor = outline;
|
|
_fillcolor = fill;
|
|
_textcolor = textcolor;
|
|
_textsize = textsize;
|
|
strncpy(_label, label, 9);
|
|
_label[9] = 0;
|
|
}
|
|
|
|
template <class HW>
|
|
void PDQ_GFX_Button_<HW>::drawButton(boolean inverted)
|
|
{
|
|
uint16_t fill, outline, text;
|
|
|
|
if (!inverted)
|
|
{
|
|
fill = _fillcolor;
|
|
outline = _outlinecolor;
|
|
text = _textcolor;
|
|
}
|
|
else
|
|
{
|
|
fill = _textcolor;
|
|
outline = _outlinecolor;
|
|
text = _fillcolor;
|
|
}
|
|
|
|
_gfx->fillRoundRect(_x - (_w/2), _y - (_h/2), _w, _h, min(_w,_h)/4, fill);
|
|
_gfx->drawRoundRect(_x - (_w/2), _y - (_h/2), _w, _h, min(_w,_h)/4, outline);
|
|
|
|
_gfx->setCursor(_x - strlen(_label)*3*_textsize, _y-4*_textsize);
|
|
_gfx->setTextColor(text);
|
|
_gfx->setTextSize(_textsize);
|
|
_gfx->print(_label);
|
|
}
|
|
|
|
template <class HW>
|
|
boolean PDQ_GFX_Button_<HW>::contains(coord_t x, coord_t y)
|
|
{
|
|
if ((x < (_x - _w/2)) || (x > (_x + _w/2)))
|
|
return false;
|
|
if ((y < (_y - _h/2)) || (y > (_y + _h/2)))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
template <class HW>
|
|
void PDQ_GFX_Button_<HW>::press(boolean p)
|
|
{
|
|
laststate = currstate;
|
|
currstate = p;
|
|
}
|
|
|
|
template <class HW>
|
|
boolean PDQ_GFX_Button_<HW>::isPressed()
|
|
{
|
|
return currstate;
|
|
}
|
|
|
|
template <class HW>
|
|
boolean PDQ_GFX_Button_<HW>::justPressed()
|
|
{
|
|
return (currstate && !laststate);
|
|
}
|
|
|
|
template <class HW>
|
|
boolean PDQ_GFX_Button_<HW>::justReleased()
|
|
{
|
|
return (!currstate && laststate);
|
|
}
|
|
|
|
#endif // _PDQ_GFX_H
|