GitHub/EPD-nRF52-hema213
1
0
Fork 0
mirror of https://github.com/jam422470459/EPD-nRF52-hema213.git synced 2025-12-07 00:52:49 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
e88cb50d6f9a9afa5422f8b92474cc5c336667df
EPD-nRF52-hema213/GUI/Adafruit_GFX.c
Shuanglei Tao f9b6f2753d add partial window support
2025-06-24 21:53:34 +08:00

1064 lines
33 KiB
C
Raw Blame History

/*
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.
*/
#include <stdarg.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "Adafruit_GFX.h"
#ifndef ABS
#define ABS(x) ((x) > 0 ? (x) : -(x))
#endif
#ifndef MIN
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
#endif
#ifndef SWAP
#define SWAP(a, b, T) do { T t = a; a = b; b = t; } while (0)
#endif
#ifndef CONTAINER_OF
#define CONTAINER_OF(ptr, type, member) (type *)((char *)ptr - offsetof(type, member))
#endif
static void GFX_u8g2_draw_hv_line(u8g2_font_t *u8g2, int16_t x, int16_t y,
int16_t len, uint8_t dir, uint16_t color)
{
Adafruit_GFX *gfx = CONTAINER_OF(u8g2, Adafruit_GFX, u8g2);
switch(dir) {
case 0:
GFX_drawFastHLine(gfx, x, y, len, color);
break;
case 1:
GFX_drawFastVLine(gfx, x, y, len, color);
break;
case 2:
GFX_drawFastHLine(gfx, x - len + 1, y, len, color);
break;
case 3:
GFX_drawFastVLine(gfx, x, y - len + 1, len, color);
break;
}
}
/**************************************************************************/
/*!
@brief Instatiate a GFX context for graphics
@param w Display width, in pixels
@param h Display height, in pixels
@param buffer_height Page buffer height
*/
/**************************************************************************/
void GFX_begin(Adafruit_GFX *gfx, int16_t w, int16_t h, int16_t buffer_height) {
memset(gfx, 0, sizeof(Adafruit_GFX));
memset(&gfx->u8g2, 0, sizeof(gfx->u8g2));
gfx->WIDTH = gfx->_width = w;
gfx->HEIGHT = gfx->_height = h;
gfx->u8g2.draw_hv_line = GFX_u8g2_draw_hv_line;
gfx->buffer = malloc(((gfx->WIDTH + 7) / 8) * buffer_height);
gfx->page_height = buffer_height;
gfx->total_pages = (gfx->HEIGHT / gfx->page_height) + (gfx->HEIGHT % gfx->page_height > 0);
GFX_setWindow(gfx, 0, 0, gfx->WIDTH, gfx->HEIGHT);
}
/**************************************************************************/
/*!
@brief Instatiate a 3-color GFX context for graphics
@param w Display width, in pixels
@param h Display height, in pixels
@param buffer_height Page buffer height, should be multiple of 2
*/
/**************************************************************************/
void GFX_begin_3c(Adafruit_GFX *gfx, int16_t w, int16_t h, int16_t buffer_height) {
GFX_begin(gfx, w, h, buffer_height);
gfx->page_height /= 2;
gfx->color = gfx->buffer + ((gfx->WIDTH + 7) / 8) * gfx->page_height;
gfx->total_pages = (gfx->HEIGHT / gfx->page_height) + (gfx->HEIGHT % gfx->page_height > 0);
}
/**************************************************************************/
/*!
@brief Instatiate a 4-color GFX context for graphics
@param w Display width, in pixels
@param h Display height, in pixels
@param buffer_height Page buffer height, should be multiple of 2
*/
/**************************************************************************/
void GFX_begin_4c(Adafruit_GFX *gfx, int16_t w, int16_t h, int16_t buffer_height) {
GFX_begin(gfx, w, h, buffer_height);
gfx->page_height /= 2;
gfx->color = gfx->buffer;
gfx->total_pages = (gfx->HEIGHT / gfx->page_height) + (gfx->HEIGHT % gfx->page_height > 0);
}
void GFX_end(Adafruit_GFX *gfx) {
if (gfx->buffer) free(gfx->buffer);
}
void GFX_firstPage(Adafruit_GFX *gfx) {
GFX_fillScreen(gfx, GFX_WHITE);
gfx->current_page = 0;
}
bool GFX_nextPage(Adafruit_GFX *gfx, buffer_callback callback) {
if (callback) {
int16_t page_ys = gfx->current_page * gfx->page_height;
if (gfx->px != 0 || gfx->py != 0 || gfx->pw != gfx->_width || gfx->ph != gfx->_height) {
int16_t page_ye = gfx->current_page < gfx->total_pages - 1 ? page_ys + gfx->page_height : gfx->HEIGHT;
uint16_t dest_ys = gfx->py + page_ys; // transposed
uint16_t dest_ye = MIN(gfx->py + gfx->ph, gfx->py + page_ye);
if (dest_ye > dest_ys)
callback(gfx->buffer, gfx->color, gfx->px, dest_ys, gfx->pw, dest_ye - dest_ys);
} else {
int16_t height = MIN(gfx->page_height, gfx->HEIGHT - page_ys);
callback(gfx->buffer, gfx->color, 0, page_ys, gfx->WIDTH, height);
}
}
gfx->current_page++;
GFX_fillScreen(gfx, GFX_WHITE);
return gfx->current_page < gfx->total_pages;
}
/**************************************************************************/
/*!
@brief Set rotation setting for display
@param r 0 thru 3 corresponding to 4 cardinal rotations
*/
/**************************************************************************/
void GFX_setRotation(Adafruit_GFX *gfx, GFX_Rotate r) {
gfx->rotation = r;
switch (gfx->rotation) {
case GFX_ROTATE_0:
case GFX_ROTATE_180:
gfx->_width = gfx->WIDTH;
gfx->_height = gfx->HEIGHT;
break;
case GFX_ROTATE_90:
case GFX_ROTATE_270:
gfx->_width = gfx->HEIGHT;
gfx->_height = gfx->WIDTH;
break;
}
}
/**************************************************************************/
/*!
setWindow, use parameters according to actual rotation.
x and w should be multiple of 8, for rotation 0 or 2,
y and h should be multiple of 8, for rotation 1 or 3,
else window is increased as needed,
this is an addressing limitation of the e-paper controllers
*/
/**************************************************************************/
void GFX_setWindow(Adafruit_GFX *gfx, uint16_t x, uint16_t y, uint16_t w, uint16_t h)
{
gfx->px = MIN(x, gfx->_width);
gfx->py = MIN(y, gfx->_height);
gfx->pw = MIN(w, gfx->_width - gfx->px);
gfx->ph = MIN(h, gfx->_height - gfx->py);
switch(gfx->rotation) {
case GFX_ROTATE_0:
break;
case GFX_ROTATE_90:
SWAP(gfx->px, gfx->py, uint16_t);
SWAP(gfx->pw, gfx->ph, uint16_t);
gfx->px = gfx->WIDTH - gfx->px - gfx->pw;
break;
case GFX_ROTATE_180:
gfx->px = gfx->WIDTH - gfx->px - gfx->pw;
gfx->py = gfx->HEIGHT - gfx->py - gfx->ph;
break;
case GFX_ROTATE_270:
SWAP(gfx->px, gfx->py, uint16_t);
SWAP(gfx->pw, gfx->ph, uint16_t);
gfx->py = gfx->HEIGHT - gfx->py - gfx->ph;
break;
}
gfx->pw += gfx->px % 8;
if (gfx->pw % 8 > 0) gfx->pw += 8 - (gfx->pw % 8);
gfx->px -= gfx->px % 8;
}
static uint8_t color4(uint16_t color) {
static uint16_t _prev_color = GFX_BLACK;
static uint8_t _prev_color4 = 0x00; // black
if (color == _prev_color) return _prev_color4;
uint8_t cv4 = 0x00;
switch (color)
{
case GFX_BLACK: cv4 = 0x00; break;
case GFX_WHITE: cv4 = 0x01; break;
case GFX_GREEN: cv4 = 0x02; break; // use yellow?
case GFX_BLUE: cv4 = 0x00; break; // use black
case GFX_RED: cv4 = 0x03; break;
case GFX_YELLOW: cv4 = 0x02; break;
case GFX_ORANGE: cv4 = 0x02; break; // use yellow?
default: {
uint16_t red = color & 0xF800;
uint16_t green = (color & 0x07E0) << 5;
uint16_t blue = (color & 0x001F) << 11;
if ((red < 0x8000) && (green < 0x8000) && (blue < 0x8000)) cv4 = 0x00; // black
else if ((red >= 0x8000) && (green >= 0x8000) && (blue >= 0x8000)) cv4 = 0x01; // white
else if ((red >= 0x8000) && (blue >= 0x8000)) cv4 = 0x03; // red, blue > red
else if ((green >= 0x8000) && (blue >= 0x8000)) cv4 = 0x01; // green, blue > white
else if ((red >= 0x8000) && (green >= 0xC000)) cv4 = 0x02; // yellow
else if ((red >= 0x8000) && (green >= 0x4000)) cv4 = 0x03; // orange > red
else if (red >= 0x8000) cv4 = 0x03; // red
else if (green >= 0x8000) cv4 = 0x00; // green > black
else cv4 = 0x03; // blue
} break;
}
_prev_color = color;
_prev_color4 = cv4;
return cv4;
}
/**************************************************************************/
/*!
@brief Draw a pixel
@param x x coordinate
@param y y coordinate
@param color 16-bit 5-6-5 Color to fill with
*/
/**************************************************************************/
void GFX_drawPixel(Adafruit_GFX *gfx, int16_t x, int16_t y, uint16_t color) {
if (x < 0 || x >= gfx->_width || y < 0 || y >= gfx->_height) return;
switch (gfx->rotation) {
case GFX_ROTATE_0:
break;
case GFX_ROTATE_90:
SWAP(x, y, int16_t);
x = gfx->WIDTH - x - 1;
break;
case GFX_ROTATE_180:
x = gfx->WIDTH - x - 1;
y = gfx->HEIGHT - y - 1;
break;
case GFX_ROTATE_270:
SWAP(x, y, int16_t);
y = gfx->HEIGHT - y - 1;
break;
}
// transpose partial window to 0,0
x -= gfx->px;
y -= gfx->py;
// clip to (partial) window
if (x < 0 || x >= gfx->pw || y < 0 || y >= gfx->ph) return;
// adjust for current page
y -= gfx->current_page * gfx->page_height;
// check if in current page
if (y < 0 || y >= gfx->page_height) return;
if (gfx->color == gfx->buffer) { // 4c
uint32_t i = x / 4 + ((uint32_t)y) * (gfx->pw / 4);
uint8_t pv = color4(color);
switch(x % 4) {
case 0: gfx->buffer[i] = (gfx->buffer[i] & 0x3F) | (pv << 6); break;
case 1: gfx->buffer[i] = (gfx->buffer[i] & 0xCF) | (pv << 4); break;
case 2: gfx->buffer[i] = (gfx->buffer[i] & 0xF3) | (pv << 2); break;
case 3: gfx->buffer[i] = (gfx->buffer[i] & 0xFC) | pv; break;
}
} else if (gfx->color != NULL) { // 3c
uint16_t i = x / 8 + y * (gfx->pw / 8);
gfx->buffer[i] |= 0x80 >> (x & 7); // white
gfx->color[i] |= 0x80 >> (x & 7);
if (color == GFX_BLACK)
gfx->buffer[i] &= ~(0x80 >> (x & 7));
else if (color != GFX_WHITE)
gfx->color[i] &= ~(0x80 >> (x & 7));
} else {
uint16_t i = x / 8 + y * (gfx->pw / 8);
if (color == GFX_WHITE)
gfx->buffer[i] |= 0x80 >> (x & 7);
else
gfx->buffer[i] &= ~(0x80 >> (x & 7));
}
}
/**************************************************************************/
/*!
@brief Draw a line. Bresenham's algorithm - thx wikpedia
@param x0 Start point x coordinate
@param y0 Start point y coordinate
@param x1 End point x coordinate
@param y1 End point y coordinate
@param color 16-bit 5-6-5 Color to draw with
*/
/**************************************************************************/
void GFX_drawLine(Adafruit_GFX *gfx, int16_t x0, int16_t y0, int16_t x1, int16_t y1,
uint16_t color) {
int16_t steep = ABS(y1 - y0) > ABS(x1 - x0);
if (steep) {
SWAP(x0, y0, int16_t);
SWAP(x1, y1, int16_t);
}
if (x0 > x1) {
SWAP(x0, x1, int16_t);
SWAP(y0, y1, int16_t);
}
int16_t dx, dy;
dx = x1 - x0;
dy = ABS(y1 - y0);
int16_t err = dx / 2;
int16_t ystep;
if (y0 < y1) {
ystep = 1;
} else {
ystep = -1;
}
for (; x0 <= x1; x0++) {
if (steep) {
GFX_drawPixel(gfx, y0, x0, color);
} else {
GFX_drawPixel(gfx, x0, y0, color);
}
err -= dy;
if (err < 0) {
y0 += ystep;
err += dx;
}
}
}
/**************************************************************************/
/*!
@brief Draw a perfectly vertical line
@param x Top-most x coordinate
@param y Top-most y coordinate
@param h Height in pixels
@param color 16-bit 5-6-5 Color to fill with
*/
/**************************************************************************/
void GFX_drawFastVLine(Adafruit_GFX *gfx, int16_t x, int16_t y, int16_t h,
uint16_t color) {
GFX_drawLine(gfx, x, y, x, y + h - 1, color);
}
/**************************************************************************/
/*!
@brief Draw a perfectly horizontal line
@param x Left-most x coordinate
@param y Left-most y coordinate
@param w Width in pixels
@param color 16-bit 5-6-5 Color to fill with
*/
/**************************************************************************/
void GFX_drawFastHLine(Adafruit_GFX *gfx, int16_t x, int16_t y, int16_t w,
uint16_t color) {
GFX_drawLine(gfx, x, y, x + w - 1, y, color);
}
/**************************************************************************/
/*!
@brief Fill a rectangle completely with one color.
@param x Top left corner x coordinate
@param y Top left corner y coordinate
@param w Width in pixels
@param h Height in pixels
@param color 16-bit 5-6-5 Color to fill with
*/
/**************************************************************************/
void GFX_fillRect(Adafruit_GFX *gfx, int16_t x, int16_t y, int16_t w, int16_t h,
uint16_t color) {
for (int16_t i = x; i < x + w; i++) {
GFX_drawFastVLine(gfx, i, y, h, color);
}
}
/**************************************************************************/
/*!
@brief Fill the screen completely with one color.
@param color 16-bit 5-6-5 Color to fill with
*/
/**************************************************************************/
void GFX_fillScreen(Adafruit_GFX *gfx, uint16_t color) {
uint32_t size = ((gfx->WIDTH + 7) / 8) * gfx->page_height;
if (gfx->color == gfx->buffer) { // 4c
uint8_t pv = color4(color) * 0x55; // 0b01010101
memset(gfx->buffer, pv, size * 2);
} else {
memset(gfx->buffer, color == GFX_WHITE ? 0xFF : 0x00, size);
if (gfx->color != NULL)
memset(gfx->color, color == GFX_RED ? 0x00 : 0xFF, size);
}
}
/**************************************************************************/
/*!
@brief Draw a circle outline
@param x0 Center-point x coordinate
@param y0 Center-point y coordinate
@param r Radius of circle
@param color 16-bit 5-6-5 Color to draw with
*/
/**************************************************************************/
void GFX_drawCircle(Adafruit_GFX *gfx, int16_t x0, int16_t y0, int16_t r,
uint16_t color) {
int16_t f = 1 - r;
int16_t ddF_x = 1;
int16_t ddF_y = -2 * r;
int16_t x = 0;
int16_t y = r;
GFX_drawPixel(gfx, x0, y0 + r, color);
GFX_drawPixel(gfx, x0, y0 - r, color);
GFX_drawPixel(gfx, x0 + r, y0, color);
GFX_drawPixel(gfx, x0 - r, y0, color);
while (x < y) {
if (f >= 0) {
y--;
ddF_y += 2;
f += ddF_y;
}
x++;
ddF_x += 2;
f += ddF_x;
GFX_drawPixel(gfx, x0 + x, y0 + y, color);
GFX_drawPixel(gfx, x0 - x, y0 + y, color);
GFX_drawPixel(gfx, x0 + x, y0 - y, color);
GFX_drawPixel(gfx, x0 - x, y0 - y, color);
GFX_drawPixel(gfx, x0 + y, y0 + x, color);
GFX_drawPixel(gfx, x0 - y, y0 + x, color);
GFX_drawPixel(gfx, x0 + y, y0 - x, color);
GFX_drawPixel(gfx, x0 - y, y0 - x, color);
}
}
/**************************************************************************/
/*!
@brief Quarter-circle drawer, used to do circles and roundrects
@param x0 Center-point x coordinate
@param y0 Center-point y coordinate
@param r Radius of circle
@param cornername Mask bit #1 or bit #2 to indicate which quarters of
the circle we're doing
@param color 16-bit 5-6-5 Color to draw with
*/
/**************************************************************************/
void GFX_drawCircleHelper(Adafruit_GFX *gfx, int16_t x0, int16_t y0, int16_t r,
uint8_t cornername, uint16_t color) {
int16_t f = 1 - r;
int16_t ddF_x = 1;
int16_t ddF_y = -2 * r;
int16_t x = 0;
int16_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) {
GFX_drawPixel(gfx, x0 + x, y0 + y, color);
GFX_drawPixel(gfx, x0 + y, y0 + x, color);
}
if (cornername & 0x2) {
GFX_drawPixel(gfx, x0 + x, y0 - y, color);
GFX_drawPixel(gfx, x0 + y, y0 - x, color);
}
if (cornername & 0x8) {
GFX_drawPixel(gfx, x0 - y, y0 + x, color);
GFX_drawPixel(gfx, x0 - x, y0 + y, color);
}
if (cornername & 0x1) {
GFX_drawPixel(gfx, x0 - y, y0 - x, color);
GFX_drawPixel(gfx, x0 - x, y0 - y, color);
}
}
}
/**************************************************************************/
/*!
@brief Draw a circle with filled color
@param x0 Center-point x coordinate
@param y0 Center-point y coordinate
@param r Radius of circle
@param color 16-bit 5-6-5 Color to fill with
*/
/**************************************************************************/
void GFX_fillCircle(Adafruit_GFX *gfx, int16_t x0, int16_t y0, int16_t r,
uint16_t color) {
GFX_drawFastVLine(gfx, x0, y0 - r, 2 * r + 1, color);
GFX_fillCircleHelper(gfx, x0, y0, r, 3, 0, color);
}
/**************************************************************************/
/*!
@brief Quarter-circle drawer with fill, used for circles and roundrects
@param x0 Center-point x coordinate
@param y0 Center-point y coordinate
@param r Radius of circle
@param corners Mask bits indicating which quarters we're doing
@param delta Offset from center-point, used for round-rects
@param color 16-bit 5-6-5 Color to fill with
*/
/**************************************************************************/
void GFX_fillCircleHelper(Adafruit_GFX *gfx, int16_t x0, int16_t y0, int16_t r,
uint8_t corners, int16_t delta, uint16_t color) {
int16_t f = 1 - r;
int16_t ddF_x = 1;
int16_t ddF_y = -2 * r;
int16_t x = 0;
int16_t y = r;
int16_t px = x;
int16_t py = y;
delta++; // Avoid some +1's in the loop
while (x < y) {
if (f >= 0) {
y--;
ddF_y += 2;
f += ddF_y;
}
x++;
ddF_x += 2;
f += ddF_x;
// These checks avoid double-drawing certain lines, important
// for the SSD1306 library which has an INVERT drawing mode.
if (x < (y + 1)) {
if (corners & 1)
GFX_drawFastVLine(gfx, x0 + x, y0 - y, 2 * y + delta, color);
if (corners & 2)
GFX_drawFastVLine(gfx, x0 - x, y0 - y, 2 * y + delta, color);
}
if (y != py) {
if (corners & 1)
GFX_drawFastVLine(gfx, x0 + py, y0 - px, 2 * px + delta, color);
if (corners & 2)
GFX_drawFastVLine(gfx, x0 - py, y0 - px, 2 * px + delta, color);
py = y;
}
px = x;
}
}
/**************************************************************************/
/*!
@brief Draw a rectangle with no fill color
@param x Top left corner x coordinate
@param y Top left corner y coordinate
@param w Width in pixels
@param h Height in pixels
@param color 16-bit 5-6-5 Color to draw with
*/
/**************************************************************************/
void GFX_drawRect(Adafruit_GFX *gfx, int16_t x, int16_t y, int16_t w, int16_t h,
uint16_t color) {
GFX_drawFastHLine(gfx, x, y, w, color);
GFX_drawFastHLine(gfx, x, y + h - 1, w, color);
GFX_drawFastVLine(gfx, x, y, h, color);
GFX_drawFastVLine(gfx, x + w - 1, y, h, color);
}
/**************************************************************************/
/*!
@brief Draw a rounded rectangle with no fill color
@param x Top left corner x coordinate
@param y Top left corner y coordinate
@param w Width in pixels
@param h Height in pixels
@param r Radius of corner rounding
@param color 16-bit 5-6-5 Color to draw with
*/
/**************************************************************************/
void GFX_drawRoundRect(Adafruit_GFX *gfx, int16_t x, int16_t y, int16_t w,
int16_t h, int16_t r, uint16_t color) {
int16_t max_radius = ((w < h) ? w : h) / 2; // 1/2 minor axis
if (r > max_radius)
r = max_radius;
// smarter version
GFX_drawFastHLine(gfx, x + r, y, w - 2 * r, color); // Top
GFX_drawFastHLine(gfx, x + r, y + h - 1, w - 2 * r, color); // Bottom
GFX_drawFastVLine(gfx, x, y + r, h - 2 * r, color); // Left
GFX_drawFastVLine(gfx, x + w - 1, y + r, h - 2 * r, color); // Right
// draw four corners
GFX_drawCircleHelper(gfx, x + r, y + r, r, 1, color);
GFX_drawCircleHelper(gfx, x + w - r - 1, y + r, r, 2, color);
GFX_drawCircleHelper(gfx, x + w - r - 1, y + h - r - 1, r, 4, color);
GFX_drawCircleHelper(gfx, x + r, y + h - r - 1, r, 8, color);
}
/**************************************************************************/
/*!
@brief Draw a rounded rectangle with fill color
@param x Top left corner x coordinate
@param y Top left corner y coordinate
@param w Width in pixels
@param h Height in pixels
@param r Radius of corner rounding
@param color 16-bit 5-6-5 Color to draw/fill with
*/
/**************************************************************************/
void GFX_fillRoundRect(Adafruit_GFX *gfx, int16_t x, int16_t y, int16_t w,
int16_t h, int16_t r, uint16_t color) {
int16_t max_radius = ((w < h) ? w : h) / 2; // 1/2 minor axis
if (r > max_radius)
r = max_radius;
// smarter version
GFX_fillRect(gfx, x + r, y, w - 2 * r, h, color);
// draw four corners
GFX_fillCircleHelper(gfx, x + w - r - 1, y + r, r, 1, h - 2 * r - 1, color);
GFX_fillCircleHelper(gfx, x + r, y + r, r, 2, h - 2 * r - 1, color);
}
/**************************************************************************/
/*!
@brief Draw a triangle with no fill color
@param x0 Vertex #0 x coordinate
@param y0 Vertex #0 y coordinate
@param x1 Vertex #1 x coordinate
@param y1 Vertex #1 y coordinate
@param x2 Vertex #2 x coordinate
@param y2 Vertex #2 y coordinate
@param color 16-bit 5-6-5 Color to draw with
*/
/**************************************************************************/
void GFX_drawTriangle(Adafruit_GFX *gfx, int16_t x0, int16_t y0, int16_t x1,
int16_t y1, int16_t x2, int16_t y2, uint16_t color) {
GFX_drawLine(gfx, x0, y0, x1, y1, color);
GFX_drawLine(gfx, x1, y1, x2, y2, color);
GFX_drawLine(gfx, x2, y2, x0, y0, color);
}
/**************************************************************************/
/*!
@brief Draw a triangle with color-fill
@param x0 Vertex #0 x coordinate
@param y0 Vertex #0 y coordinate
@param x1 Vertex #1 x coordinate
@param y1 Vertex #1 y coordinate
@param x2 Vertex #2 x coordinate
@param y2 Vertex #2 y coordinate
@param color 16-bit 5-6-5 Color to fill/draw with
*/
/**************************************************************************/
void GFX_fillTriangle(Adafruit_GFX *gfx, int16_t x0, int16_t y0, int16_t x1,
int16_t y1, int16_t x2, int16_t y2, uint16_t color) {
int16_t a, b, y, last;
// Sort coordinates by Y order (y2 >= y1 >= y0)
if (y0 > y1) {
SWAP(y0, y1, int16_t);
SWAP(x0, x1, int16_t);
}
if (y1 > y2) {
SWAP(y2, y1, int16_t);
SWAP(x2, x1, int16_t);
}
if (y0 > y1) {
SWAP(y0, y1, int16_t);
SWAP(x0, x1, int16_t);
}
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;
GFX_drawFastHLine(gfx, a, y0, b - a + 1, color);
return;
}
int16_t dx01 = x1 - x0, dy01 = y1 - y0, dx02 = x2 - x0, dy02 = y2 - y0,
dx12 = x2 - x1, dy12 = y2 - y1;
int32_t sa = 0, 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)
SWAP(a, b, int16_t);
GFX_drawFastHLine(gfx, 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 = (int32_t)dx12 * (y - y1);
sb = (int32_t)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)
SWAP(a, b, int16_t);
GFX_drawFastHLine(gfx, a, y, b - a + 1, color);
}
}
/**************************************************************************/
/*!
@brief Draw a RAM-resident 1-bit image at the specified (x,y) position,
using the specified foreground color (unset bits are transparent).
@param x Top left corner x coordinate
@param y Top left corner y coordinate
@param bitmap byte array with monochrome bitmap
@param w Width of bitmap in pixels
@param h Height of bitmap in pixels
@param color 16-bit 5-6-5 Color to draw with
@param invert When true, will invert the bitmap
*/
/**************************************************************************/
void GFX_drawBitmap(Adafruit_GFX *gfx, int16_t x, int16_t y, const uint8_t bitmap[],
int16_t w, int16_t h, uint16_t color, bool invert) {
int16_t byteWidth = (w + 7) / 8; // Bitmap scanline pad = whole byte
uint8_t byte = 0;
for (int16_t j = 0; j < h; j++) {
for (int16_t i = 0; i < w; i++) {
if (i & 7)
byte <<= 1;
else
byte = bitmap[j * byteWidth + i / 8];
if (((byte & 0x80) == 0x80) ^ invert)
GFX_drawPixel(gfx, x + i, y + j, color);
}
}
}
/*
U8g2_for_Adafruit_GFX.cpp
Add unicode support and U8g2 fonts to Adafruit GFX libraries.
U8g2 for Adafruit GFX Lib (https://github.com/olikraus/U8g2_for_Adafruit_GFX)
Copyright (c) 2018, olikraus@gmail.com
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.
*/
void GFX_setCursor(Adafruit_GFX *gfx, int16_t x, int16_t y) {
gfx->tx = x;
gfx->ty = y;
gfx->utf8_state = 0;
}
void GFX_setFont(Adafruit_GFX *gfx, const uint8_t *font) {
u8g2_SetFont(&gfx->u8g2, font);
}
void GFX_setFontMode(Adafruit_GFX *gfx, uint8_t is_transparent) {
u8g2_SetFontMode(&gfx->u8g2, is_transparent);
}
void GFX_setFontDirection(Adafruit_GFX *gfx, GFX_Rotate d) {
u8g2_SetFontDirection(&gfx->u8g2, (uint8_t)d);
}
void GFX_setTextColor(Adafruit_GFX *gfx, uint16_t fg, uint16_t bg) {
u8g2_SetForegroundColor(&gfx->u8g2, fg);
u8g2_SetBackgroundColor(&gfx->u8g2, bg);
}
int8_t GFX_getFontAscent(Adafruit_GFX *gfx) {
return gfx->u8g2.font_info.ascent_A;
}
int8_t GFX_getFontDescent(Adafruit_GFX *gfx) {
return gfx->u8g2.font_info.descent_g;
}
int16_t GFX_drawGlyph(Adafruit_GFX *gfx, int16_t x, int16_t y, uint16_t e) {
return u8g2_DrawGlyph(&gfx->u8g2, x, y, e);
}
int16_t GFX_drawStr(Adafruit_GFX *gfx, int16_t x, int16_t y, const char *s) {
return u8g2_DrawStr(&gfx->u8g2, x, y, s);
}
static uint16_t utf8_next(Adafruit_GFX *gfx, uint8_t b)
{
if ( b == 0 ) /* '\n' terminates the string to support the string list procedures */
return 0x0ffff; /* end of string detected, pending UTF8 is discarded */
if ( gfx->utf8_state == 0 )
{
if ( b >= 0xfc ) /* 6 byte sequence */
{
gfx->utf8_state = 5;
b &= 1;
}
else if ( b >= 0xf8 )
{
gfx->utf8_state = 4;
b &= 3;
}
else if ( b >= 0xf0 )
{
gfx->utf8_state = 3;
b &= 7;
}
else if ( b >= 0xe0 )
{
gfx->utf8_state = 2;
b &= 15;
}
else if ( b >= 0xc0 )
{
gfx->utf8_state = 1;
b &= 0x01f;
}
else
{
/* do nothing, just use the value as encoding */
return b;
}
gfx->encoding = b;
return 0x0fffe;
}
else
{
gfx->utf8_state--;
/* The case b < 0x080 (an illegal UTF8 encoding) is not checked here. */
gfx->encoding<<=6;
b &= 0x03f;
gfx->encoding |= b;
if ( gfx->utf8_state != 0 )
return 0x0fffe; /* nothing to do yet */
}
return gfx->encoding;
}
int16_t GFX_drawUTF8(Adafruit_GFX *gfx, int16_t x, int16_t y, const char *str)
{
uint16_t e;
int16_t delta, sum;
gfx->utf8_state = 0;
sum = 0;
for(;;)
{
e = utf8_next(gfx, (uint8_t)*str);
if ( e == 0x0ffff )
break;
str++;
if ( e != 0x0fffe )
{
delta = u8g2_DrawGlyph(&gfx->u8g2, x, y, e);
switch(gfx->u8g2.font_decode.dir)
{
case 0:
x += delta;
break;
case 1:
y += delta;
break;
case 2:
x -= delta;
break;
case 3:
y -= delta;
break;
}
sum += delta;
}
}
return sum;
}
int16_t GFX_getUTF8Width(Adafruit_GFX *gfx, const char *str)
{
uint16_t e;
int16_t dx, w;
gfx->u8g2.font_decode.glyph_width = 0;
gfx->utf8_state = 0;
w = 0;
dx = 0;
for(;;)
{
e = utf8_next(gfx, (uint8_t)*str);
if ( e == 0x0ffff )
break;
str++;
if ( e != 0x0fffe )
{
dx = u8g2_GetGlyphWidth(&gfx->u8g2, e);
w += dx;
}
}
/* adjust the last glyph, check for issue #16: do not adjust if width is 0 */
if ( gfx->u8g2.font_decode.glyph_width != 0 )
{
w -= dx;
w += gfx->u8g2.font_decode.glyph_width; /* the real pixel width of the glyph, sideeffect of GetGlyphWidth */
/* issue #46: we have to add the x offset also */
w += gfx->u8g2.glyph_x_offset; /* this value is set as a side effect of u8g2_GetGlyphWidth() */
}
return w;
}
size_t GFX_print(Adafruit_GFX *gfx, const char c) {
int16_t delta;
uint16_t e = utf8_next(gfx, (uint8_t)c);
if ( e == '\n' )
{
gfx->tx = 0;
gfx->ty += gfx->u8g2.font_info.ascent_para - gfx->u8g2.font_info.descent_para;
}
else if ( e == '\r' )
{
gfx->tx = 0;
}
else if ( e < 0x0fffe )
{
delta = u8g2_DrawGlyph(&gfx->u8g2, gfx->tx, gfx->ty, e);
switch(gfx->u8g2.font_decode.dir)
{
case 0:
gfx->tx += delta;
break;
case 1:
gfx->ty += delta;
break;
case 2:
gfx->tx -= delta;
break;
case 3:
gfx->ty -= delta;
break;
}
}
return 1;
}
size_t GFX_write(Adafruit_GFX *gfx, const char *buffer, size_t size) {
size_t cnt = 0;
while( size > 0 ) {
cnt += GFX_print(gfx, *buffer++);
size--;
}
return cnt;
}
size_t GFX_printf(Adafruit_GFX *gfx, const char* format, ...) {
va_list va;
char tmp[64] = {0};
char *buf = tmp;
size_t len;
va_start(va, format);
len = vsnprintf(tmp, sizeof(tmp), format, va);
va_end(va);
if (len > sizeof(tmp) - 1)
{
buf = malloc(len + 1);
if (buf == NULL)
return 0;
va_start(va, format);
vsnprintf(buf, len + 1, format, va);
va_end(va);
}
len = GFX_write(gfx, buf, len);
if (buf != tmp)
free(buf);
return len;
}
Reference in New Issue View Git Blame Copy Permalink