From 4290f0b161660772c9f609011b1a052d1f601d9b Mon Sep 17 00:00:00 2001 From: me-no-dev Date: Thu, 23 Feb 2017 03:11:09 +0200 Subject: [PATCH] Implement transaction based drawing With using transactions to draw, we save huge amount of time in pin changing and SPI setup. This new model, together with the updated ILI9341 lib give a much better performance. --- Adafruit_GFX.cpp | 1542 ++++++++++++++++++++++++---------------------- Adafruit_GFX.h | 27 +- 2 files changed, 840 insertions(+), 729 deletions(-) mode change 100644 => 100755 Adafruit_GFX.h diff --git a/Adafruit_GFX.cpp b/Adafruit_GFX.cpp index 46d4d54..3cec535 100755 --- a/Adafruit_GFX.cpp +++ b/Adafruit_GFX.cpp @@ -29,15 +29,15 @@ 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. -*/ + */ -#ifdef __AVR__ - #include -#elif defined(ESP8266) - #include -#endif #include "Adafruit_GFX.h" #include "glcdfont.c" +#ifdef __AVR__ + #include +#elif defined(ESP8266) || defined(ESP32) + #include +#endif // Many (but maybe not all) non-AVR board installs define macros // for compatibility with existing PROGMEM-reading AVR code. @@ -71,399 +71,574 @@ POSSIBILITY OF SUCH DAMAGE. #endif Adafruit_GFX::Adafruit_GFX(int16_t w, int16_t h): - WIDTH(w), HEIGHT(h) +WIDTH(w), HEIGHT(h) { - _width = WIDTH; - _height = HEIGHT; - rotation = 0; - cursor_y = cursor_x = 0; - textsize = 1; - textcolor = textbgcolor = 0xFFFF; - wrap = true; - _cp437 = false; - gfxFont = NULL; + _width = WIDTH; + _height = HEIGHT; + rotation = 0; + cursor_y = cursor_x = 0; + textsize = 1; + textcolor = textbgcolor = 0xFFFF; + wrap = true; + _cp437 = false; + gfxFont = NULL; } +// Bresenham's algorithm - thx wikpedia +void Adafruit_GFX::writeLine(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_int16_t(x0, y0); + _swap_int16_t(x1, y1); + } + + if (x0 > x1) { + _swap_int16_t(x0, x1); + _swap_int16_t(y0, y1); + } + + 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) { + writePixel(y0, x0, color); + } else { + writePixel(x0, y0, color); + } + err -= dy; + if (err < 0) { + y0 += ystep; + err += dx; + } + } +} + +void Adafruit_GFX::startWrite(){ + // Overwrite in subclasses if desired! +} + +void Adafruit_GFX::writePixel(int16_t x, int16_t y, uint16_t color){ + // Overwrite in subclasses if startWrite is defined! + drawPixel(x, y, color); +} + +void Adafruit_GFX::writeFastVLine(int16_t x, int16_t y, + int16_t h, uint16_t color) { + // Overwrite in subclasses if startWrite is defined! + // Can be just writeLine(x, y, x, y+h-1, color); + // or writeFillRect(x, y, 1, h, color); + drawFastVLine(x, y, h, color); +} + +void Adafruit_GFX::writeFastHLine(int16_t x, int16_t y, + int16_t w, uint16_t color) { + // Overwrite in subclasses if startWrite is defined! + // Example: writeLine(x, y, x+w-1, y, color); + // or writeFillRect(x, y, w, 1, color); + drawFastHLine(x, y, w, color); +} + +void Adafruit_GFX::writeFillRect(int16_t x, int16_t y, int16_t w, int16_t h, + uint16_t color) { + // Overwrite in subclasses if desired! + fillRect(x,y,w,h,color); +} + +void Adafruit_GFX::endWrite(){ + // Overwrite in subclasses if startWrite is defined! +} + +void Adafruit_GFX::drawFastVLine(int16_t x, int16_t y, + int16_t h, uint16_t color) { + // Update in subclasses if desired! + startWrite(); + writeLine(x, y, x, y+h-1, color); + endWrite(); +} + +void Adafruit_GFX::drawFastHLine(int16_t x, int16_t y, + int16_t w, uint16_t color) { + // Update in subclasses if desired! + startWrite(); + writeLine(x, y, x+w-1, y, color); + endWrite(); +} + +void Adafruit_GFX::fillRect(int16_t x, int16_t y, int16_t w, int16_t h, + uint16_t color) { + // Update in subclasses if desired! + startWrite(); + for (int16_t i=x; i= 0) { - y--; - ddF_y += 2; - f += ddF_y; + while (x= 0) { + y--; + ddF_y += 2; + f += ddF_y; + } + x++; + ddF_x += 2; + f += ddF_x; + + writePixel(x0 + x, y0 + y, color); + writePixel(x0 - x, y0 + y, color); + writePixel(x0 + x, y0 - y, color); + writePixel(x0 - x, y0 - y, color); + writePixel(x0 + y, y0 + x, color); + writePixel(x0 - y, y0 + x, color); + writePixel(x0 + y, y0 - x, color); + writePixel(x0 - y, y0 - x, color); } - x++; - ddF_x += 2; - f += ddF_x; - - drawPixel(x0 + x, y0 + y, color); - drawPixel(x0 - x, y0 + y, color); - drawPixel(x0 + x, y0 - y, color); - drawPixel(x0 - x, y0 - y, color); - drawPixel(x0 + y, y0 + x, color); - drawPixel(x0 - y, y0 + x, color); - drawPixel(x0 + y, y0 - x, color); - drawPixel(x0 - y, y0 - x, color); - } + endWrite(); } void Adafruit_GFX::drawCircleHelper( 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; + 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= 0) { - y--; - ddF_y += 2; - f += ddF_y; + while (x= 0) { + y--; + ddF_y += 2; + f += ddF_y; + } + x++; + ddF_x += 2; + f += ddF_x; + if (cornername & 0x4) { + writePixel(x0 + x, y0 + y, color); + writePixel(x0 + y, y0 + x, color); + } + if (cornername & 0x2) { + writePixel(x0 + x, y0 - y, color); + writePixel(x0 + y, y0 - x, color); + } + if (cornername & 0x8) { + writePixel(x0 - y, y0 + x, color); + writePixel(x0 - x, y0 + y, color); + } + if (cornername & 0x1) { + writePixel(x0 - y, y0 - x, color); + writePixel(x0 - x, y0 - y, color); + } } - x++; - ddF_x += 2; - f += ddF_x; - if (cornername & 0x4) { - drawPixel(x0 + x, y0 + y, color); - drawPixel(x0 + y, y0 + x, color); - } - if (cornername & 0x2) { - drawPixel(x0 + x, y0 - y, color); - drawPixel(x0 + y, y0 - x, color); - } - if (cornername & 0x8) { - drawPixel(x0 - y, y0 + x, color); - drawPixel(x0 - x, y0 + y, color); - } - if (cornername & 0x1) { - drawPixel(x0 - y, y0 - x, color); - drawPixel(x0 - x, y0 - y, color); - } - } } void Adafruit_GFX::fillCircle(int16_t x0, int16_t y0, int16_t r, - uint16_t color) { - drawFastVLine(x0, y0-r, 2*r+1, color); - fillCircleHelper(x0, y0, r, 3, 0, color); + uint16_t color) { + startWrite(); + writeFastVLine(x0, y0-r, 2*r+1, color); + fillCircleHelper(x0, y0, r, 3, 0, color); + endWrite(); } // Used to do circles and roundrects void Adafruit_GFX::fillCircleHelper(int16_t x0, int16_t y0, int16_t r, - uint8_t cornername, int16_t delta, uint16_t color) { + uint8_t cornername, 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 f = 1 - r; + int16_t ddF_x = 1; + int16_t ddF_y = -2 * r; + int16_t x = 0; + int16_t y = r; - while (x= 0) { - y--; - ddF_y += 2; - f += ddF_y; + while (x= 0) { + y--; + ddF_y += 2; + f += ddF_y; + } + x++; + ddF_x += 2; + f += ddF_x; + + if (cornername & 0x1) { + writeFastVLine(x0+x, y0-y, 2*y+1+delta, color); + writeFastVLine(x0+y, y0-x, 2*x+1+delta, color); + } + if (cornername & 0x2) { + writeFastVLine(x0-x, y0-y, 2*y+1+delta, color); + writeFastVLine(x0-y, y0-x, 2*x+1+delta, color); + } } - x++; - ddF_x += 2; - f += ddF_x; - - if (cornername & 0x1) { - drawFastVLine(x0+x, y0-y, 2*y+1+delta, color); - drawFastVLine(x0+y, y0-x, 2*x+1+delta, color); - } - if (cornername & 0x2) { - drawFastVLine(x0-x, y0-y, 2*y+1+delta, color); - drawFastVLine(x0-y, y0-x, 2*x+1+delta, color); - } - } -} - -// Bresenham's algorithm - thx wikpedia -void Adafruit_GFX::drawLine(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_int16_t(x0, y0); - _swap_int16_t(x1, y1); - } - - if (x0 > x1) { - _swap_int16_t(x0, x1); - _swap_int16_t(y0, y1); - } - - 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) { - drawPixel(y0, x0, color); - } else { - drawPixel(x0, y0, color); - } - err -= dy; - if (err < 0) { - y0 += ystep; - err += dx; - } - } } // Draw a rectangle void Adafruit_GFX::drawRect(int16_t x, int16_t y, int16_t w, int16_t h, - uint16_t color) { - drawFastHLine(x, y, w, color); - drawFastHLine(x, y+h-1, w, color); - drawFastVLine(x, y, h, color); - drawFastVLine(x+w-1, y, h, color); -} - -void Adafruit_GFX::drawFastVLine(int16_t x, int16_t y, - int16_t h, uint16_t color) { - // Update in subclasses if desired! - drawLine(x, y, x, y+h-1, color); -} - -void Adafruit_GFX::drawFastHLine(int16_t x, int16_t y, - int16_t w, uint16_t color) { - // Update in subclasses if desired! - drawLine(x, y, x+w-1, y, color); -} - -void Adafruit_GFX::fillRect(int16_t x, int16_t y, int16_t w, int16_t h, - uint16_t color) { - // Update in subclasses if desired! - for (int16_t i=x; i= y1 >= y0) - if (y0 > y1) { - _swap_int16_t(y0, y1); _swap_int16_t(x0, x1); - } - if (y1 > y2) { - _swap_int16_t(y2, y1); _swap_int16_t(x2, x1); - } - if (y0 > y1) { - _swap_int16_t(y0, y1); _swap_int16_t(x0, x1); - } + // Sort coordinates by Y order (y2 >= y1 >= y0) + if (y0 > y1) { + _swap_int16_t(y0, y1); _swap_int16_t(x0, x1); + } + if (y1 > y2) { + _swap_int16_t(y2, y1); _swap_int16_t(x2, x1); + } + if (y0 > y1) { + _swap_int16_t(y0, y1); _swap_int16_t(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; - drawFastHLine(a, y0, b-a+1, color); - return; - } + startWrite(); + 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; + writeFastHLine(a, y0, b-a+1, color); + endWrite(); + return; + } - int16_t + int16_t dx01 = x1 - x0, dy01 = y1 - y0, dx02 = x2 - x0, dy02 = y2 - y0, dx12 = x2 - x1, dy12 = y2 - y1; - int32_t + 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 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: + 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_int16_t(a,b); - drawFastHLine(a, y, b-a+1, color); - } + */ + if(a > b) _swap_int16_t(a,b); + writeFastHLine(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: + // 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) _swap_int16_t(a,b); - drawFastHLine(a, y, b-a+1, color); - } + */ + if(a > b) _swap_int16_t(a,b); + writeFastHLine(a, y, b-a+1, color); + } + endWrite(); } // 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). void Adafruit_GFX::drawBitmap(int16_t x, int16_t y, - const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color) { + const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color) { - int16_t i, j, byteWidth = (w + 7) / 8; - uint8_t byte; + int16_t i, j, byteWidth = (w + 7) / 8; + uint8_t byte = 0; - for(j=0; j>= 1; - else byte = pgm_read_byte(bitmap + j * byteWidth + i / 8); - if(byte & 0x01) drawPixel(x+i, y+j, color); + startWrite(); + for(j=0; j>= 1; + else byte = pgm_read_byte(bitmap + j * byteWidth + i / 8); + if(byte & 0x01) writePixel(x+i, y+j, color); + } } - } + endWrite(); +} + +// Draw a character +void Adafruit_GFX::drawChar(int16_t x, int16_t y, unsigned char c, + uint16_t color, uint16_t bg, uint8_t size) { + + if(!gfxFont) { // 'Classic' built-in font + + if((x >= _width) || // Clip right + (y >= _height) || // Clip bottom + ((x + 6 * size - 1) < 0) || // Clip left + ((y + 8 * size - 1) < 0)) // Clip top + return; + + if(!_cp437 && (c >= 176)) c++; // Handle 'classic' charset behavior + + startWrite(); + for(int8_t i=0; i<6; i++ ) { + uint8_t line; + if(i < 5) line = pgm_read_byte(font+(c*5)+i); + else line = 0x0; + for(int8_t j=0; j<8; j++, line >>= 1) { + if(line & 0x1) { + if(size == 1) writePixel(x+i, y+j, color); + else writeFillRect(x+(i*size), y+(j*size), size, size, color); + } else if(bg != color) { + if(size == 1) writePixel(x+i, y+j, bg); + else writeFillRect(x+i*size, y+j*size, size, size, bg); + } + } + } + endWrite(); + + } else { // Custom font + + // 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), + h = pgm_read_byte(&glyph->height); + int8_t xo = pgm_read_byte(&glyph->xOffset), + yo = pgm_read_byte(&glyph->yOffset); + uint8_t xx, yy, bits = 0, bit = 0; + int16_t xo16 = 0, yo16 = 0; + + if(size > 1) { + xo16 = xo; + yo16 = yo; + } + + // 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. + + startWrite(); + for(yy=0; yy= 100 @@ -471,196 +646,105 @@ size_t Adafruit_GFX::write(uint8_t c) { #else void Adafruit_GFX::write(uint8_t c) { #endif + if(!gfxFont) { // 'Classic' built-in font - if(!gfxFont) { // 'Classic' built-in font + if(c == '\n') { + cursor_y += textsize*8; + cursor_x = 0; + } else if(c == '\r') { + // skip em + } else { + if(wrap && ((cursor_x + textsize * 6) >= _width)) { // Heading off edge? + cursor_x = 0; // Reset x to zero + cursor_y += textsize * 8; // Advance y one line + } + drawChar(cursor_x, cursor_y, c, textcolor, textbgcolor, textsize); + cursor_x += textsize * 6; + } - if(c == '\n') { - cursor_y += textsize*8; - cursor_x = 0; - } else if(c == '\r') { - // skip em - } else { - if(wrap && ((cursor_x + textsize * 6) >= _width)) { // Heading off edge? - cursor_x = 0; // Reset x to zero - cursor_y += textsize * 8; // Advance y one line - } - drawChar(cursor_x, cursor_y, c, textcolor, textbgcolor, textsize); - cursor_x += textsize * 6; - } + } else { // Custom font - } else { // Custom font - - if(c == '\n') { - cursor_x = 0; - cursor_y += (int16_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), - h = pgm_read_byte(&glyph->height); - if((w > 0) && (h > 0)) { // Is there an associated bitmap? - int16_t xo = (int8_t)pgm_read_byte(&glyph->xOffset); // sic - if(wrap && ((cursor_x + textsize * (xo + w)) >= _width)) { - // Drawing character would go off right edge; wrap to new line + if(c == '\n') { cursor_x = 0; cursor_y += (int16_t)textsize * - (uint8_t)pgm_read_byte(&gfxFont->yAdvance); - } - drawChar(cursor_x, cursor_y, c, textcolor, textbgcolor, 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), + h = pgm_read_byte(&glyph->height); + if((w > 0) && (h > 0)) { // Is there an associated bitmap? + int16_t xo = (int8_t)pgm_read_byte(&glyph->xOffset); // sic + if(wrap && ((cursor_x + textsize * (xo + w)) >= _width)) { + // Drawing character would go off right edge; wrap to new line + cursor_x = 0; + cursor_y += (int16_t)textsize * + (uint8_t)pgm_read_byte(&gfxFont->yAdvance); + } + drawChar(cursor_x, cursor_y, c, textcolor, textbgcolor, textsize); + } + cursor_x += pgm_read_byte(&glyph->xAdvance) * (int16_t)textsize; + } } - cursor_x += pgm_read_byte(&glyph->xAdvance) * (int16_t)textsize; - } - } - } + } #if ARDUINO >= 100 - return 1; + return 1; #endif } -// Draw a character -void Adafruit_GFX::drawChar(int16_t x, int16_t y, unsigned char c, - uint16_t color, uint16_t bg, uint8_t size) { - - if(!gfxFont) { // 'Classic' built-in font - - if((x >= _width) || // Clip right - (y >= _height) || // Clip bottom - ((x + 6 * size - 1) < 0) || // Clip left - ((y + 8 * size - 1) < 0)) // Clip top - return; - - if(!_cp437 && (c >= 176)) c++; // Handle 'classic' charset behavior - - for(int8_t i=0; i<6; i++ ) { - uint8_t line; - if(i < 5) line = pgm_read_byte(font+(c*5)+i); - else line = 0x0; - for(int8_t j=0; j<8; j++, line >>= 1) { - if(line & 0x1) { - if(size == 1) drawPixel(x+i, y+j, color); - else fillRect(x+(i*size), y+(j*size), size, size, color); - } else if(bg != color) { - if(size == 1) drawPixel(x+i, y+j, bg); - else fillRect(x+i*size, y+j*size, size, size, bg); - } - } - } - - } else { // Custom font - - // 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), - h = pgm_read_byte(&glyph->height), - xa = pgm_read_byte(&glyph->xAdvance); - int8_t xo = pgm_read_byte(&glyph->xOffset), - yo = pgm_read_byte(&glyph->yOffset); - uint8_t xx, yy, bits, bit = 0; - int16_t xo16, yo16; - - if(size > 1) { - xo16 = xo; - yo16 = yo; - } - - // 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. - - for(yy=0; yy 0) ? s : 1; + textsize = (s > 0) ? s : 1; } void Adafruit_GFX::setTextColor(uint16_t c) { - // For 'transparent' background, we'll set the bg - // to the same as fg instead of using a flag - textcolor = textbgcolor = c; + // For 'transparent' background, we'll set the bg + // to the same as fg instead of using a flag + textcolor = textbgcolor = c; } void Adafruit_GFX::setTextColor(uint16_t c, uint16_t b) { - textcolor = c; - textbgcolor = b; + textcolor = c; + textbgcolor = b; } void Adafruit_GFX::setTextWrap(boolean w) { - wrap = w; + wrap = w; } uint8_t Adafruit_GFX::getRotation(void) const { - return rotation; + return rotation; } void Adafruit_GFX::setRotation(uint8_t x) { - rotation = (x & 3); - switch(rotation) { - case 0: - case 2: - _width = WIDTH; - _height = HEIGHT; - break; - case 1: - case 3: - _width = HEIGHT; - _height = WIDTH; - break; - } + rotation = (x & 3); + switch(rotation) { + case 0: + case 2: + _width = WIDTH; + _height = HEIGHT; + break; + case 1: + case 3: + _width = HEIGHT; + _height = WIDTH; + break; + } } // Enable (or disable) Code Page 437-compatible charset. @@ -671,273 +755,283 @@ void Adafruit_GFX::setRotation(uint8_t x) { // original 'wrong' behavior and old sketches will still work. Pass 'true' // to this function to use correct CP437 character values in your code. void Adafruit_GFX::cp437(boolean x) { - _cp437 = x; + _cp437 = x; } void Adafruit_GFX::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; + 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; } - } 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; + gfxFont = (GFXfont *)f; } // Pass string and a cursor position, returns UL corner and W,H. void Adafruit_GFX::getTextBounds(char *str, int16_t x, int16_t y, - int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h) { - uint8_t c; // Current character + int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h) { + uint8_t c; // Current character - *x1 = x; - *y1 = y; - *w = *h = 0; + *x1 = x; + *y1 = y; + *w = *h = 0; - if(gfxFont) { + if(gfxFont) { - GFXglyph *glyph; - uint8_t first = pgm_read_byte(&gfxFont->first), - last = pgm_read_byte(&gfxFont->last), - gw, gh, xa; - int8_t xo, yo; - int16_t minx = _width, miny = _height, maxx = -1, maxy = -1, - gx1, gy1, gx2, gy2, ts = (int16_t)textsize, - ya = ts * (uint8_t)pgm_read_byte(&gfxFont->yAdvance); + GFXglyph *glyph; + uint8_t first = pgm_read_byte(&gfxFont->first), + last = pgm_read_byte(&gfxFont->last), + gw, gh, xa; + int8_t xo, yo; + int16_t minx = _width, miny = _height, maxx = -1, maxy = -1, + gx1, gy1, gx2, gy2, ts = (int16_t)textsize, + ya = ts * (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)) >= _width)) { - // Line wrap - x = 0; // Reset x to 0 - y += ya; // Advance y by 1 line + 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)) >= _width)) { + // Line wrap + x = 0; // 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 = 0; // Reset x + 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 = 0; // 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; + } + // End of string + *x1 = minx; + *y1 = miny; + if(maxx >= minx) *w = maxx - minx + 1; + if(maxy >= miny) *h = maxy - miny + 1; - } else { // Default font + } else { // Default font - uint16_t lineWidth = 0, maxWidth = 0; // Width of current, all lines + 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 - if(wrap && ((x + textsize * 6) >= _width)) { - x = 0; // Reset x to 0 - y += textsize * 8; // Advance y by 1 line - if(lineWidth > maxWidth) maxWidth = lineWidth; // Save widest line - 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) maxWidth = lineWidth; // Save widest line - lineWidth = 0; // Reset lineWidth for new line - } - } - // End of string - if(lineWidth) y += textsize * 8; // Add height of last (or only) line - if(lineWidth > maxWidth) maxWidth = lineWidth; // Is the last or only line the widest? - *w = maxWidth - 1; // Don't include last interchar x gap - *h = y - *y1; + while((c = *str++)) { + 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) maxWidth = lineWidth; // Save widest line + 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) maxWidth = lineWidth; // Save widest line + lineWidth = 0; // Reset lineWidth for new line + } + } + // End of string + if(lineWidth) y += textsize * 8; // Add height of last (or only) line + if(lineWidth > maxWidth) maxWidth = lineWidth; // Is the last or only line the widest? + *w = maxWidth - 1; // Don't include last interchar x gap + *h = y - *y1; - } // End classic vs custom font + } // End classic vs custom font } // Same as above, but for PROGMEM strings void Adafruit_GFX::getTextBounds(const __FlashStringHelper *str, - int16_t x, int16_t y, int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h) { - uint8_t *s = (uint8_t *)str, c; + int16_t x, int16_t y, int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h) { + uint8_t *s = (uint8_t *)str, c; - *x1 = x; - *y1 = y; - *w = *h = 0; + *x1 = x; + *y1 = y; + *w = *h = 0; - if(gfxFont) { + if(gfxFont) { - GFXglyph *glyph; - uint8_t first = pgm_read_byte(&gfxFont->first), - last = pgm_read_byte(&gfxFont->last), - gw, gh, xa; - int8_t xo, yo; - int16_t minx = _width, miny = _height, maxx = -1, maxy = -1, - gx1, gy1, gx2, gy2, ts = (int16_t)textsize, - ya = ts * (uint8_t)pgm_read_byte(&gfxFont->yAdvance); + GFXglyph *glyph; + uint8_t first = pgm_read_byte(&gfxFont->first), + last = pgm_read_byte(&gfxFont->last), + gw, gh, xa; + int8_t xo, yo; + int16_t minx = _width, miny = _height, maxx = -1, maxy = -1, + gx1, gy1, gx2, gy2, ts = (int16_t)textsize, + 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)) >= _width)) { - // Line wrap - x = 0; // Reset x to 0 - y += ya; // Advance y by 1 line + 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)) >= _width)) { + // Line wrap + x = 0; // 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 = 0; // Reset x + 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 = 0; // 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; + } + // End of string + *x1 = minx; + *y1 = miny; + if(maxx >= minx) *w = maxx - minx + 1; + if(maxy >= miny) *h = maxy - miny + 1; - } else { // Default font + } else { // Default font - uint16_t lineWidth = 0, maxWidth = 0; // Width of current, all lines + 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) maxWidth = lineWidth; // Save widest line - 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) maxWidth = lineWidth; // Save widest line - lineWidth = 0; // Reset lineWidth for new line - } - } - // End of string - if(lineWidth) y += textsize * 8; // Add height of last (or only) line - if(lineWidth > maxWidth) maxWidth = lineWidth; // Is the last or only line the widest? - *w = maxWidth - 1; // Don't include last interchar x gap - *h = y - *y1; + 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) maxWidth = lineWidth; // Save widest line + 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) maxWidth = lineWidth; // Save widest line + lineWidth = 0; // Reset lineWidth for new line + } + } + // End of string + if(lineWidth) y += textsize * 8; // Add height of last (or only) line + if(lineWidth > maxWidth) maxWidth = lineWidth; // Is the last or only line the widest? + *w = maxWidth - 1; // Don't include last interchar x gap + *h = y - *y1; - } // End classic vs custom font + } // End classic vs custom font } // Return the size of the display (per current rotation) int16_t Adafruit_GFX::width(void) const { - return _width; + return _width; } int16_t Adafruit_GFX::height(void) const { - return _height; + return _height; } void Adafruit_GFX::invertDisplay(boolean i) { - // Do nothing, must be subclassed if supported by hardware + // Do nothing, must be subclassed if supported by hardware } /***************************************************************************/ // code for the GFX button UI element Adafruit_GFX_Button::Adafruit_GFX_Button(void) { - _gfx = 0; + _gfx = 0; + laststate = 0; + _fillcolor = 0; + _textsize = 1; + _w = 0; + _x = 0; + currstate = 0; + _textcolor = 0; + _outlinecolor = 0; + _h = 0; + _y = 0; } void Adafruit_GFX_Button::initButton( - Adafruit_GFX *gfx, int16_t x, int16_t y, uint8_t w, uint8_t h, - uint16_t outline, uint16_t fill, uint16_t textcolor, - char *label, uint8_t textsize) + Adafruit_GFX *gfx, int16_t x, int16_t y, uint8_t w, uint8_t h, + uint16_t outline, uint16_t fill, uint16_t textcolor, + char *label, uint8_t textsize) { - _x = x; - _y = y; - _w = w; - _h = h; - _outlinecolor = outline; - _fillcolor = fill; - _textcolor = textcolor; - _textsize = textsize; - _gfx = gfx; - strncpy(_label, label, 9); - _label[9] = 0; + _x = x; + _y = y; + _w = w; + _h = h; + _outlinecolor = outline; + _fillcolor = fill; + _textcolor = textcolor; + _textsize = textsize; + _gfx = gfx; + strncpy(_label, label, 9); + _label[9] = 0; } void Adafruit_GFX_Button::drawButton(boolean inverted) { - uint16_t fill, outline, text; + uint16_t fill, outline, text; - if(!inverted) { - fill = _fillcolor; - outline = _outlinecolor; - text = _textcolor; - } else { - fill = _textcolor; - outline = _outlinecolor; - text = _fillcolor; - } + 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->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); + _gfx->setCursor(_x - strlen(_label)*3*_textsize, _y-4*_textsize); + _gfx->setTextColor(text); + _gfx->setTextSize(_textsize); + _gfx->print(_label); } boolean Adafruit_GFX_Button::contains(int16_t x, int16_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; + if ((x < (_x - _w/2)) || (x > (_x + _w/2))) return false; + if ((y < (_y - _h/2)) || (y > (_y + _h/2))) return false; + return true; } void Adafruit_GFX_Button::press(boolean p) { - laststate = currstate; - currstate = p; + laststate = currstate; + currstate = p; } boolean Adafruit_GFX_Button::isPressed() { return currstate; } @@ -962,110 +1056,110 @@ boolean Adafruit_GFX_Button::justReleased() { return (!currstate && laststate); // NOT EXTENSIVELY TESTED YET. MAY CONTAIN WORST BUGS KNOWN TO HUMANKIND. GFXcanvas1::GFXcanvas1(uint16_t w, uint16_t h) : Adafruit_GFX(w, h) { - uint16_t bytes = ((w + 7) / 8) * h; - if((buffer = (uint8_t *)malloc(bytes))) { - memset(buffer, 0, bytes); - } + uint16_t bytes = ((w + 7) / 8) * h; + if((buffer = (uint8_t *)malloc(bytes))) { + memset(buffer, 0, bytes); + } } GFXcanvas1::~GFXcanvas1(void) { - if(buffer) free(buffer); + if(buffer) free(buffer); } uint8_t* GFXcanvas1::getBuffer(void) { - return buffer; + return buffer; } void GFXcanvas1::drawPixel(int16_t x, int16_t y, uint16_t color) { - // Bitmask tables of 0x80>>X and ~(0x80>>X), because X>>Y is slow on AVR - static const uint8_t PROGMEM + // Bitmask tables of 0x80>>X and ~(0x80>>X), because X>>Y is slow on AVR + static const uint8_t PROGMEM GFXsetBit[] = { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 }, GFXclrBit[] = { 0x7F, 0xBF, 0xDF, 0xEF, 0xF7, 0xFB, 0xFD, 0xFE }; - if(buffer) { - if((x < 0) || (y < 0) || (x >= _width) || (y >= _height)) return; + if(buffer) { + if((x < 0) || (y < 0) || (x >= _width) || (y >= _height)) return; - int16_t t; - switch(rotation) { - case 1: - t = x; - x = WIDTH - 1 - y; - y = t; - break; - case 2: - x = WIDTH - 1 - x; - y = HEIGHT - 1 - y; - break; - case 3: - t = x; - x = y; - y = HEIGHT - 1 - t; - break; + int16_t t; + switch(rotation) { + case 1: + t = x; + x = WIDTH - 1 - y; + y = t; + break; + case 2: + x = WIDTH - 1 - x; + y = HEIGHT - 1 - y; + break; + case 3: + t = x; + x = y; + y = HEIGHT - 1 - t; + break; + } + + uint8_t *ptr = &buffer[(x / 8) + y * ((WIDTH + 7) / 8)]; + if(color) *ptr |= pgm_read_byte(&GFXsetBit[x & 7]); + else *ptr &= pgm_read_byte(&GFXclrBit[x & 7]); } - - uint8_t *ptr = &buffer[(x / 8) + y * ((WIDTH + 7) / 8)]; - if(color) *ptr |= pgm_read_byte(&GFXsetBit[x & 7]); - else *ptr &= pgm_read_byte(&GFXclrBit[x & 7]); - } } void GFXcanvas1::fillScreen(uint16_t color) { - if(buffer) { - uint16_t bytes = ((WIDTH + 7) / 8) * HEIGHT; - memset(buffer, color ? 0xFF : 0x00, bytes); - } + if(buffer) { + uint16_t bytes = ((WIDTH + 7) / 8) * HEIGHT; + memset(buffer, color ? 0xFF : 0x00, bytes); + } } GFXcanvas16::GFXcanvas16(uint16_t w, uint16_t h) : Adafruit_GFX(w, h) { - uint16_t bytes = w * h * 2; - if((buffer = (uint16_t *)malloc(bytes))) { - memset(buffer, 0, bytes); - } + uint16_t bytes = w * h * 2; + if((buffer = (uint16_t *)malloc(bytes))) { + memset(buffer, 0, bytes); + } } GFXcanvas16::~GFXcanvas16(void) { - if(buffer) free(buffer); + if(buffer) free(buffer); } uint16_t* GFXcanvas16::getBuffer(void) { - return buffer; + return buffer; } void GFXcanvas16::drawPixel(int16_t x, int16_t y, uint16_t color) { - if(buffer) { - if((x < 0) || (y < 0) || (x >= _width) || (y >= _height)) return; + if(buffer) { + if((x < 0) || (y < 0) || (x >= _width) || (y >= _height)) return; - int16_t t; - switch(rotation) { - case 1: - t = x; - x = WIDTH - 1 - y; - y = t; - break; - case 2: - x = WIDTH - 1 - x; - y = HEIGHT - 1 - y; - break; - case 3: - t = x; - x = y; - y = HEIGHT - 1 - t; - break; + int16_t t; + switch(rotation) { + case 1: + t = x; + x = WIDTH - 1 - y; + y = t; + break; + case 2: + x = WIDTH - 1 - x; + y = HEIGHT - 1 - y; + break; + case 3: + t = x; + x = y; + y = HEIGHT - 1 - t; + break; + } + + buffer[x + y * WIDTH] = color; } - - buffer[x + y * WIDTH] = color; - } } void GFXcanvas16::fillScreen(uint16_t color) { - if(buffer) { - uint8_t hi = color >> 8, lo = color & 0xFF; - if(hi == lo) { - memset(buffer, lo, WIDTH * HEIGHT * 2); - } else { - uint16_t i, pixels = WIDTH * HEIGHT; - for(i=0; i> 8, lo = color & 0xFF; + if(hi == lo) { + memset(buffer, lo, WIDTH * HEIGHT * 2); + } else { + uint16_t i, pixels = WIDTH * HEIGHT; + for(i=0; i