Changing to use an Adafruit_GFX library from components repo.

1 files changed, 0 insertions, 2671 deletions

diff --git a/main/Adafruit_GFX.cpp b/main/Adafruit_GFX.cpp
deleted file mode 100644
index b7b465f..0000000
--- a/main/Adafruit_GFX.cpp
+++ /dev/null
@@ -1,2671 +0,0 @@
-/*
-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 "Adafruit_GFX.h"
-#include "glcdfont.c"
-#ifdef __AVR__
-#include <avr/pgmspace.h>
-#elif defined(ESP8266) || defined(ESP32)
-#include <pgmspace.h>
-#endif
-
-#include <cstring>
-
-// Many (but maybe not all) non-AVR board installs define macros
-// for compatibility with existing PROGMEM-reading AVR code.
-// Do our own checks and defines here for good measure...
-
-#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
-
-// Pointers are a peculiar case...typically 16-bit on AVR boards,
-// 32 bits elsewhere.  Try to accommodate both...
-
-#if !defined(__INT_MAX__) || (__INT_MAX__ > 0xFFFF)
-#define pgm_read_pointer(addr) ((void *)pgm_read_dword(addr))
-#else
-#define pgm_read_pointer(addr) ((void *)pgm_read_word(addr))
-#endif
-
-inline GFXglyph *pgm_read_glyph_ptr(const GFXfont *gfxFont, uint8_t c) {
-#ifdef __AVR__
-  return &(((GFXglyph *)pgm_read_pointer(&gfxFont->glyph))[c]);
-#else
-  // expression in __AVR__ section may generate "dereferencing type-punned
-  // pointer will break strict-aliasing rules" warning In fact, on other
-  // platforms (such as STM32) there is no need to do this pointer magic as
-  // program memory may be read in a usual way So expression may be simplified
-  return gfxFont->glyph + c;
-#endif //__AVR__
-}
-
-inline uint8_t *pgm_read_bitmap_ptr(const GFXfont *gfxFont) {
-#ifdef __AVR__
-  return (uint8_t *)pgm_read_pointer(&gfxFont->bitmap);
-#else
-  // expression in __AVR__ section generates "dereferencing type-punned pointer
-  // will break strict-aliasing rules" warning In fact, on other platforms (such
-  // as STM32) there is no need to do this pointer magic as program memory may
-  // be read in a usual way So expression may be simplified
-  return gfxFont->bitmap;
-#endif //__AVR__
-}
-
-#ifndef min
-#define min(a, b) (((a) < (b)) ? (a) : (b))
-#endif
-
-#ifndef _swap_int16_t
-#define _swap_int16_t(a, b)                                                    \
-  {                                                                            \
-    int16_t t = a;                                                             \
-    a = b;                                                                     \
-    b = t;                                                                     \
-  }
-#endif
-
-/**************************************************************************/
-/*!
-   @brief    Instatiate a GFX context for graphics! Can only be done by a
-   superclass
-   @param    w   Display width, in pixels
-   @param    h   Display height, in pixels
-*/
-/**************************************************************************/
-Adafruit_GFX::Adafruit_GFX(int16_t w, int16_t h) : WIDTH(w), HEIGHT(h) {
-  _width = WIDTH;
-  _height = HEIGHT;
-  rotation = 0;
-  cursor_y = cursor_x = 0;
-  textsize_x = textsize_y = 1;
-  textcolor = textbgcolor = 0xFFFF;
-  wrap = true;
-  _cp437 = false;
-  gfxFont = NULL;
-}
-
-/**************************************************************************/
-/*!
-   @brief    Write 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 Adafruit_GFX::writeLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1,
-                             uint16_t color) {
-#if defined(ESP8266)
-  yield();
-#endif
-  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;
-    }
-  }
-}
-
-/**************************************************************************/
-/*!
-   @brief    Start a display-writing routine, overwrite in subclasses.
-*/
-/**************************************************************************/
-void Adafruit_GFX::startWrite() {}
-
-/**************************************************************************/
-/*!
-   @brief    Write a pixel, overwrite in subclasses if startWrite is defined!
-    @param   x   x coordinate
-    @param   y   y coordinate
-   @param    color 16-bit 5-6-5 Color to fill with
-*/
-/**************************************************************************/
-void Adafruit_GFX::writePixel(int16_t x, int16_t y, uint16_t color) {
-  drawPixel(x, y, color);
-}
-
-/**************************************************************************/
-/*!
-   @brief    Write a perfectly vertical line, overwrite in subclasses if
-   startWrite is defined!
-    @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 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);
-}
-
-/**************************************************************************/
-/*!
-   @brief    Write a perfectly horizontal line, overwrite in subclasses if
-   startWrite is defined!
-    @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 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);
-}
-
-/**************************************************************************/
-/*!
-   @brief    Write a rectangle completely with one color, overwrite in
-   subclasses if startWrite is defined!
-    @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 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);
-}
-
-/**************************************************************************/
-/*!
-   @brief    End a display-writing routine, overwrite in subclasses if
-   startWrite is defined!
-*/
-/**************************************************************************/
-void Adafruit_GFX::endWrite() {}
-
-/**************************************************************************/
-/*!
-   @brief    Draw a perfectly vertical line (this is often optimized in a
-   subclass!)
-    @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 Adafruit_GFX::drawFastVLine(int16_t x, int16_t y, int16_t h,
-                                 uint16_t color) {
-  startWrite();
-  writeLine(x, y, x, y + h - 1, color);
-  endWrite();
-}
-
-/**************************************************************************/
-/*!
-   @brief    Draw a perfectly horizontal line (this is often optimized in a
-   subclass!)
-    @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 Adafruit_GFX::drawFastHLine(int16_t x, int16_t y, int16_t w,
-                                 uint16_t color) {
-  startWrite();
-  writeLine(x, y, x + w - 1, y, color);
-  endWrite();
-}
-
-/**************************************************************************/
-/*!
-   @brief    Fill a rectangle completely with one color. Update in subclasses if
-   desired!
-    @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 Adafruit_GFX::fillRect(int16_t x, int16_t y, int16_t w, int16_t h,
-                            uint16_t color) {
-  startWrite();
-  for (int16_t i = x; i < x + w; i++) {
-    writeFastVLine(i, y, h, color);
-  }
-  endWrite();
-}
-
-/**************************************************************************/
-/*!
-   @brief    Fill the screen completely with one color. Update in subclasses if
-   desired!
-    @param    color 16-bit 5-6-5 Color to fill with
-*/
-/**************************************************************************/
-void Adafruit_GFX::fillScreen(uint16_t color) {
-  fillRect(0, 0, _width, _height, color);
-}
-
-/**************************************************************************/
-/*!
-   @brief    Draw a line
-    @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 Adafruit_GFX::drawLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1,
-                            uint16_t color) {
-  // Update in subclasses if desired!
-  if (x0 == x1) {
-    if (y0 > y1)
-      _swap_int16_t(y0, y1);
-    drawFastVLine(x0, y0, y1 - y0 + 1, color);
-  } else if (y0 == y1) {
-    if (x0 > x1)
-      _swap_int16_t(x0, x1);
-    drawFastHLine(x0, y0, x1 - x0 + 1, color);
-  } else {
-    startWrite();
-    writeLine(x0, y0, x1, y1, color);
-    endWrite();
-  }
-}
-
-/**************************************************************************/
-/*!
-   @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 Adafruit_GFX::drawCircle(int16_t x0, int16_t y0, int16_t r,
-                              uint16_t color) {
-#if defined(ESP8266)
-  yield();
-#endif
-  int16_t f = 1 - r;
-  int16_t ddF_x = 1;
-  int16_t ddF_y = -2 * r;
-  int16_t x = 0;
-  int16_t y = r;
-
-  startWrite();
-  writePixel(x0, y0 + r, color);
-  writePixel(x0, y0 - r, color);
-  writePixel(x0 + r, y0, color);
-  writePixel(x0 - r, y0, color);
-
-  while (x < y) {
-    if (f >= 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);
-  }
-  endWrite();
-}
-
-/**************************************************************************/
-/*!
-    @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 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;
-
-  while (x < y) {
-    if (f >= 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);
-    }
-  }
-}
-
-/**************************************************************************/
-/*!
-   @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 Adafruit_GFX::fillCircle(int16_t x0, int16_t y0, int16_t r,
-                              uint16_t color) {
-  startWrite();
-  writeFastVLine(x0, y0 - r, 2 * r + 1, color);
-  fillCircleHelper(x0, y0, r, 3, 0, color);
-  endWrite();
-}
-
-/**************************************************************************/
-/*!
-    @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 Adafruit_GFX::fillCircleHelper(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)
-        writeFastVLine(x0 + x, y0 - y, 2 * y + delta, color);
-      if (corners & 2)
-        writeFastVLine(x0 - x, y0 - y, 2 * y + delta, color);
-    }
-    if (y != py) {
-      if (corners & 1)
-        writeFastVLine(x0 + py, y0 - px, 2 * px + delta, color);
-      if (corners & 2)
-        writeFastVLine(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 Adafruit_GFX::drawRect(int16_t x, int16_t y, int16_t w, int16_t h,
-                            uint16_t color) {
-  startWrite();
-  writeFastHLine(x, y, w, color);
-  writeFastHLine(x, y + h - 1, w, color);
-  writeFastVLine(x, y, h, color);
-  writeFastVLine(x + w - 1, y, h, color);
-  endWrite();
-}
-
-/**************************************************************************/
-/*!
-   @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 Adafruit_GFX::drawRoundRect(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
-  startWrite();
-  writeFastHLine(x + r, y, w - 2 * r, color);         // Top
-  writeFastHLine(x + r, y + h - 1, w - 2 * r, color); // Bottom
-  writeFastVLine(x, y + r, h - 2 * r, color);         // Left
-  writeFastVLine(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);
-  endWrite();
-}
-
-/**************************************************************************/
-/*!
-   @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 Adafruit_GFX::fillRoundRect(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
-  startWrite();
-  writeFillRect(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);
-  endWrite();
-}
-
-/**************************************************************************/
-/*!
-   @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 Adafruit_GFX::drawTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1,
-                                int16_t x2, int16_t y2, uint16_t color) {
-  drawLine(x0, y0, x1, y1, color);
-  drawLine(x1, y1, x2, y2, color);
-  drawLine(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 Adafruit_GFX::fillTriangle(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_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);
-  }
-
-  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 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_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 = (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_int16_t(a, b);
-    writeFastHLine(a, y, b - a + 1, color);
-  }
-  endWrite();
-}
-
-// BITMAP / XBITMAP / GRAYSCALE / RGB BITMAP FUNCTIONS ---------------------
-
-/**************************************************************************/
-/*!
-   @brief      Draw a PROGMEM-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
-*/
-/**************************************************************************/
-void Adafruit_GFX::drawBitmap(int16_t x, int16_t y, const uint8_t bitmap[],
-                              int16_t w, int16_t h, uint16_t color) {
-
-  int16_t byteWidth = (w + 7) / 8; // Bitmap scanline pad = whole byte
-  uint8_t b = 0;
-
-  startWrite();
-  for (int16_t j = 0; j < h; j++, y++) {
-    for (int16_t i = 0; i < w; i++) {
-      if (i & 7)
-        b <<= 1;
-      else
-        b = pgm_read_byte(&bitmap[j * byteWidth + i / 8]);
-      if (b & 0x80)
-        writePixel(x + i, y, color);
-    }
-  }
-  endWrite();
-}
-
-/**************************************************************************/
-/*!
-   @brief      Draw a PROGMEM-resident 1-bit image at the specified (x,y)
-   position, using the specified foreground (for set bits) and background (unset
-   bits) colors.
-    @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 pixels with
-    @param    bg 16-bit 5-6-5 Color to draw background with
-*/
-/**************************************************************************/
-void Adafruit_GFX::drawBitmap(int16_t x, int16_t y, const uint8_t bitmap[],
-                              int16_t w, int16_t h, uint16_t color,
-                              uint16_t bg) {
-
-  int16_t byteWidth = (w + 7) / 8; // Bitmap scanline pad = whole byte
-  uint8_t b = 0;
-
-  startWrite();
-  for (int16_t j = 0; j < h; j++, y++) {
-    for (int16_t i = 0; i < w; i++) {
-      if (i & 7)
-        b <<= 1;
-      else
-        b = pgm_read_byte(&bitmap[j * byteWidth + i / 8]);
-      writePixel(x + i, y, (b & 0x80) ? color : bg);
-    }
-  }
-  endWrite();
-}
-
-/**************************************************************************/
-/*!
-   @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
-*/
-/**************************************************************************/
-void Adafruit_GFX::drawBitmap(int16_t x, int16_t y, uint8_t *bitmap, int16_t w,
-                              int16_t h, uint16_t color) {
-
-  int16_t byteWidth = (w + 7) / 8; // Bitmap scanline pad = whole byte
-  uint8_t b = 0;
-
-  startWrite();
-  for (int16_t j = 0; j < h; j++, y++) {
-    for (int16_t i = 0; i < w; i++) {
-      if (i & 7)
-        b <<= 1;
-      else
-        b = bitmap[j * byteWidth + i / 8];
-      if (b & 0x80)
-        writePixel(x + i, y, color);
-    }
-  }
-  endWrite();
-}
-
-/**************************************************************************/
-/*!
-   @brief      Draw a RAM-resident 1-bit image at the specified (x,y) position,
-   using the specified foreground (for set bits) and background (unset bits)
-   colors.
-    @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 pixels with
-    @param    bg 16-bit 5-6-5 Color to draw background with
-*/
-/**************************************************************************/
-void Adafruit_GFX::drawBitmap(int16_t x, int16_t y, uint8_t *bitmap, int16_t w,
-                              int16_t h, uint16_t color, uint16_t bg) {
-
-  int16_t byteWidth = (w + 7) / 8; // Bitmap scanline pad = whole byte
-  uint8_t b = 0;
-
-  startWrite();
-  for (int16_t j = 0; j < h; j++, y++) {
-    for (int16_t i = 0; i < w; i++) {
-      if (i & 7)
-        b <<= 1;
-      else
-        b = bitmap[j * byteWidth + i / 8];
-      writePixel(x + i, y, (b & 0x80) ? color : bg);
-    }
-  }
-  endWrite();
-}
-
-/**************************************************************************/
-/*!
-   @brief      Draw PROGMEM-resident 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.
-   There is no RAM-resident version of this function; if generating bitmaps
-   in RAM, use the format defined by drawBitmap() and call that instead.
-    @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 pixels with
-*/
-/**************************************************************************/
-void Adafruit_GFX::drawXBitmap(int16_t x, int16_t y, const uint8_t bitmap[],
-                               int16_t w, int16_t h, uint16_t color) {
-
-  int16_t byteWidth = (w + 7) / 8; // Bitmap scanline pad = whole byte
-  uint8_t b = 0;
-
-  startWrite();
-  for (int16_t j = 0; j < h; j++, y++) {
-    for (int16_t i = 0; i < w; i++) {
-      if (i & 7)
-        b >>= 1;
-      else
-        b = pgm_read_byte(&bitmap[j * byteWidth + i / 8]);
-      // Nearly identical to drawBitmap(), only the bit order
-      // is reversed here (left-to-right = LSB to MSB):
-      if (b & 0x01)
-        writePixel(x + i, y, color);
-    }
-  }
-  endWrite();
-}
-
-/**************************************************************************/
-/*!
-   @brief   Draw a PROGMEM-resident 8-bit image (grayscale) at the specified
-   (x,y) pos. Specifically for 8-bit display devices such as IS31FL3731; no
-   color reduction/expansion is performed.
-    @param    x   Top left corner x coordinate
-    @param    y   Top left corner y coordinate
-    @param    bitmap  byte array with grayscale bitmap
-    @param    w   Width of bitmap in pixels
-    @param    h   Height of bitmap in pixels
-*/
-/**************************************************************************/
-void Adafruit_GFX::drawGrayscaleBitmap(int16_t x, int16_t y,
-                                       const uint8_t bitmap[], int16_t w,
-                                       int16_t h) {
-  startWrite();
-  for (int16_t j = 0; j < h; j++, y++) {
-    for (int16_t i = 0; i < w; i++) {
-      writePixel(x + i, y, (uint8_t)pgm_read_byte(&bitmap[j * w + i]));
-    }
-  }
-  endWrite();
-}
-
-/**************************************************************************/
-/*!
-   @brief   Draw a RAM-resident 8-bit image (grayscale) at the specified (x,y)
-   pos. Specifically for 8-bit display devices such as IS31FL3731; no color
-   reduction/expansion is performed.
-    @param    x   Top left corner x coordinate
-    @param    y   Top left corner y coordinate
-    @param    bitmap  byte array with grayscale bitmap
-    @param    w   Width of bitmap in pixels
-    @param    h   Height of bitmap in pixels
-*/
-/**************************************************************************/
-void Adafruit_GFX::drawGrayscaleBitmap(int16_t x, int16_t y, uint8_t *bitmap,
-                                       int16_t w, int16_t h) {
-  startWrite();
-  for (int16_t j = 0; j < h; j++, y++) {
-    for (int16_t i = 0; i < w; i++) {
-      writePixel(x + i, y, bitmap[j * w + i]);
-    }
-  }
-  endWrite();
-}
-
-/**************************************************************************/
-/*!
-   @brief   Draw a PROGMEM-resident 8-bit image (grayscale) with a 1-bit mask
-   (set bits = opaque, unset bits = clear) at the specified (x,y) position.
-   BOTH buffers (grayscale and mask) must be PROGMEM-resident.
-   Specifically for 8-bit display devices such as IS31FL3731; no color
-   reduction/expansion is performed.
-    @param    x   Top left corner x coordinate
-    @param    y   Top left corner y coordinate
-    @param    bitmap  byte array with grayscale bitmap
-    @param    mask  byte array with mask bitmap
-    @param    w   Width of bitmap in pixels
-    @param    h   Height of bitmap in pixels
-*/
-/**************************************************************************/
-void Adafruit_GFX::drawGrayscaleBitmap(int16_t x, int16_t y,
-                                       const uint8_t bitmap[],
-                                       const uint8_t mask[], int16_t w,
-                                       int16_t h) {
-  int16_t bw = (w + 7) / 8; // Bitmask scanline pad = whole byte
-  uint8_t b = 0;
-  startWrite();
-  for (int16_t j = 0; j < h; j++, y++) {
-    for (int16_t i = 0; i < w; i++) {
-      if (i & 7)
-        b <<= 1;
-      else
-        b = pgm_read_byte(&mask[j * bw + i / 8]);
-      if (b & 0x80) {
-        writePixel(x + i, y, (uint8_t)pgm_read_byte(&bitmap[j * w + i]));
-      }
-    }
-  }
-  endWrite();
-}
-
-/**************************************************************************/
-/*!
-   @brief   Draw a RAM-resident 8-bit image (grayscale) with a 1-bit mask
-   (set bits = opaque, unset bits = clear) at the specified (x,y) position.
-   BOTH buffers (grayscale and mask) must be RAM-residentt, no mix-and-match
-   Specifically for 8-bit display devices such as IS31FL3731; no color
-   reduction/expansion is performed.
-    @param    x   Top left corner x coordinate
-    @param    y   Top left corner y coordinate
-    @param    bitmap  byte array with grayscale bitmap
-    @param    mask  byte array with mask bitmap
-    @param    w   Width of bitmap in pixels
-    @param    h   Height of bitmap in pixels
-*/
-/**************************************************************************/
-void Adafruit_GFX::drawGrayscaleBitmap(int16_t x, int16_t y, uint8_t *bitmap,
-                                       uint8_t *mask, int16_t w, int16_t h) {
-  int16_t bw = (w + 7) / 8; // Bitmask scanline pad = whole byte
-  uint8_t b = 0;
-  startWrite();
-  for (int16_t j = 0; j < h; j++, y++) {
-    for (int16_t i = 0; i < w; i++) {
-      if (i & 7)
-        b <<= 1;
-      else
-        b = mask[j * bw + i / 8];
-      if (b & 0x80) {
-        writePixel(x + i, y, bitmap[j * w + i]);
-      }
-    }
-  }
-  endWrite();
-}
-
-/**************************************************************************/
-/*!
-   @brief   Draw a PROGMEM-resident 16-bit image (RGB 5/6/5) at the specified
-   (x,y) position. For 16-bit display devices; no color reduction performed.
-    @param    x   Top left corner x coordinate
-    @param    y   Top left corner y coordinate
-    @param    bitmap  byte array with 16-bit color bitmap
-    @param    w   Width of bitmap in pixels
-    @param    h   Height of bitmap in pixels
-*/
-/**************************************************************************/
-void Adafruit_GFX::drawRGBBitmap(int16_t x, int16_t y, const uint16_t bitmap[],
-                                 int16_t w, int16_t h) {
-  startWrite();
-  for (int16_t j = 0; j < h; j++, y++) {
-    for (int16_t i = 0; i < w; i++) {
-      writePixel(x + i, y, pgm_read_word(&bitmap[j * w + i]));
-    }
-  }
-  endWrite();
-}
-
-/**************************************************************************/
-/*!
-   @brief   Draw a RAM-resident 16-bit image (RGB 5/6/5) at the specified (x,y)
-   position. For 16-bit display devices; no color reduction performed.
-    @param    x   Top left corner x coordinate
-    @param    y   Top left corner y coordinate
-    @param    bitmap  byte array with 16-bit color bitmap
-    @param    w   Width of bitmap in pixels
-    @param    h   Height of bitmap in pixels
-*/
-/**************************************************************************/
-void Adafruit_GFX::drawRGBBitmap(int16_t x, int16_t y, uint16_t *bitmap,
-                                 int16_t w, int16_t h) {
-  startWrite();
-  for (int16_t j = 0; j < h; j++, y++) {
-    for (int16_t i = 0; i < w; i++) {
-      writePixel(x + i, y, bitmap[j * w + i]);
-    }
-  }
-  endWrite();
-}
-
-/**************************************************************************/
-/*!
-   @brief   Draw a PROGMEM-resident 16-bit image (RGB 5/6/5) with a 1-bit mask
-   (set bits = opaque, unset bits = clear) at the specified (x,y) position. BOTH
-   buffers (color and mask) must be PROGMEM-resident. For 16-bit display
-   devices; no color reduction performed.
-    @param    x   Top left corner x coordinate
-    @param    y   Top left corner y coordinate
-    @param    bitmap  byte array with 16-bit color bitmap
-    @param    mask  byte array with monochrome mask bitmap
-    @param    w   Width of bitmap in pixels
-    @param    h   Height of bitmap in pixels
-*/
-/**************************************************************************/
-void Adafruit_GFX::drawRGBBitmap(int16_t x, int16_t y, const uint16_t bitmap[],
-                                 const uint8_t mask[], int16_t w, int16_t h) {
-  int16_t bw = (w + 7) / 8; // Bitmask scanline pad = whole byte
-  uint8_t b = 0;
-  startWrite();
-  for (int16_t j = 0; j < h; j++, y++) {
-    for (int16_t i = 0; i < w; i++) {
-      if (i & 7)
-        b <<= 1;
-      else
-        b = pgm_read_byte(&mask[j * bw + i / 8]);
-      if (b & 0x80) {
-        writePixel(x + i, y, pgm_read_word(&bitmap[j * w + i]));
-      }
-    }
-  }
-  endWrite();
-}
-
-/**************************************************************************/
-/*!
-   @brief   Draw a RAM-resident 16-bit image (RGB 5/6/5) with a 1-bit mask (set
-   bits = opaque, unset bits = clear) at the specified (x,y) position. BOTH
-   buffers (color and mask) must be RAM-resident. For 16-bit display devices; no
-   color reduction performed.
-    @param    x   Top left corner x coordinate
-    @param    y   Top left corner y coordinate
-    @param    bitmap  byte array with 16-bit color bitmap
-    @param    mask  byte array with monochrome mask bitmap
-    @param    w   Width of bitmap in pixels
-    @param    h   Height of bitmap in pixels
-*/
-/**************************************************************************/
-void Adafruit_GFX::drawRGBBitmap(int16_t x, int16_t y, uint16_t *bitmap,
-                                 uint8_t *mask, int16_t w, int16_t h) {
-  int16_t bw = (w + 7) / 8; // Bitmask scanline pad = whole byte
-  uint8_t b = 0;
-  startWrite();
-  for (int16_t j = 0; j < h; j++, y++) {
-    for (int16_t i = 0; i < w; i++) {
-      if (i & 7)
-        b <<= 1;
-      else
-        b = mask[j * bw + i / 8];
-      if (b & 0x80) {
-        writePixel(x + i, y, bitmap[j * w + i]);
-      }
-    }
-  }
-  endWrite();
-}
-
-// TEXT- AND CHARACTER-HANDLING FUNCTIONS ----------------------------------
-
-// Draw a character
-/**************************************************************************/
-/*!
-   @brief   Draw a single character
-    @param    x   Bottom left corner x coordinate
-    @param    y   Bottom left corner y coordinate
-    @param    c   The 8-bit font-indexed character (likely ascii)
-    @param    color 16-bit 5-6-5 Color to draw chraracter with
-    @param    bg 16-bit 5-6-5 Color to fill background with (if same as color,
-   no background)
-    @param    size  Font magnification level, 1 is 'original' size
-*/
-/**************************************************************************/
-void Adafruit_GFX::drawChar(int16_t x, int16_t y, unsigned char c,
-                            uint16_t color, uint16_t bg, uint8_t size) {
-  drawChar(x, y, c, color, bg, size, size);
-}
-
-// Draw a character
-/**************************************************************************/
-/*!
-   @brief   Draw a single character
-    @param    x   Bottom left corner x coordinate
-    @param    y   Bottom left corner y coordinate
-    @param    c   The 8-bit font-indexed character (likely ascii)
-    @param    color 16-bit 5-6-5 Color to draw chraracter with
-    @param    bg 16-bit 5-6-5 Color to fill background with (if same as color,
-   no background)
-    @param    size_x  Font magnification level in X-axis, 1 is 'original' size
-    @param    size_y  Font magnification level in Y-axis, 1 is 'original' size
-*/
-/**************************************************************************/
-void Adafruit_GFX::drawChar(int16_t x, int16_t y, unsigned char c,
-                            uint16_t color, uint16_t bg, uint8_t size_x,
-                            uint8_t size_y) {
-
-  if (!gfxFont) { // 'Classic' built-in font
-
-    if ((x >= _width) ||              // Clip right
-        (y >= _height) ||             // Clip bottom
-        ((x + 6 * size_x - 1) < 0) || // Clip left
-        ((y + 8 * size_y - 1) < 0))   // Clip top
-      return;
-
-    if (!_cp437 && (c >= 176))
-      c++; // Handle 'classic' charset behavior
-
-    startWrite();
-    for (int8_t i = 0; i < 5; i++) { // Char bitmap = 5 columns
-      uint8_t line = pgm_read_byte(&font[c * 5 + i]);
-      for (int8_t j = 0; j < 8; j++, line >>= 1) {
-        if (line & 1) {
-          if (size_x == 1 && size_y == 1)
-            writePixel(x + i, y + j, color);
-          else
-            writeFillRect(x + i * size_x, y + j * size_y, size_x, size_y,
-                          color);
-        } else if (bg != color) {
-          if (size_x == 1 && size_y == 1)
-            writePixel(x + i, y + j, bg);
-          else
-            writeFillRect(x + i * size_x, y + j * size_y, size_x, size_y, bg);
-        }
-      }
-    }
-    if (bg != color) { // If opaque, draw vertical line for last column
-      if (size_x == 1 && size_y == 1)
-        writeFastVLine(x + 5, y, 8, bg);
-      else
-        writeFillRect(x + 5 * size_x, y, size_x, 8 * size_y, 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 -= (uint8_t)pgm_read_byte(&gfxFont->first);
-    GFXglyph *glyph = pgm_read_glyph_ptr(gfxFont, c);
-    uint8_t *bitmap = pgm_read_bitmap_ptr(gfxFont);
-
-    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_x > 1 || size_y > 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 < h; yy++) {
-      for (xx = 0; xx < w; xx++) {
-        if (!(bit++ & 7)) {
-          bits = pgm_read_byte(&bitmap[bo++]);
-        }
-        if (bits & 0x80) {
-          if (size_x == 1 && size_y == 1) {
-            writePixel(x + xo + xx, y + yo + yy, color);
-          } else {
-            writeFillRect(x + (xo16 + xx) * size_x, y + (yo16 + yy) * size_y,
-                          size_x, size_y, color);
-          }
-        }
-        bits <<= 1;
-      }
-    }
-    endWrite();
-
-  } // End classic vs custom font
-}
-/**************************************************************************/
-/*!
-    @brief  Print one byte/character of data, used to support print()
-    @param  c  The 8-bit ascii character to write
-*/
-/**************************************************************************/
-/* size_t Adafruit_GFX::write(uint8_t c) { */
-/*   if (!gfxFont) { // 'Classic' built-in font */
-
-/*     if (c == '\n') {              // Newline? */
-/*       cursor_x = 0;               // Reset x to zero, */
-/*       cursor_y += textsize_y * 8; // advance y one line */
-/*     } else if (c != '\r') {       // Ignore carriage returns */
-/*       if (wrap && ((cursor_x + textsize_x * 6) > _width)) { // Off right? */
-/*         cursor_x = 0;                                       // Reset x to zero, */
-/*         cursor_y += textsize_y * 8; // advance y one line */
-/*       } */
-/*       drawChar(cursor_x, cursor_y, c, textcolor, textbgcolor, textsize_x, */
-/*                textsize_y); */
-/*       cursor_x += textsize_x * 6; // Advance x one char */
-/*     } */
-
-/*   } else { // Custom font */
-
-/*     if (c == '\n') { */
-/*       cursor_x = 0; */
-/*       cursor_y += */
-/*           (int16_t)textsize_y * (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))) { */
-/*         GFXglyph *glyph = pgm_read_glyph_ptr(gfxFont, c - first); */
-/*         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_x * (xo + w)) > _width)) { */
-/*             cursor_x = 0; */
-/*             cursor_y += (int16_t)textsize_y * */
-/*                         (uint8_t)pgm_read_byte(&gfxFont->yAdvance); */
-/*           } */
-/*           drawChar(cursor_x, cursor_y, c, textcolor, textbgcolor, textsize_x, */
-/*                    textsize_y); */
-/*         } */
-/*         cursor_x += */
-/*             (uint8_t)pgm_read_byte(&glyph->xAdvance) * (int16_t)textsize_x; */
-/*       } */
-/*     } */
-/*   } */
-/*   return 1; */
-/* } */
-
-/**************************************************************************/
-/*!
-    @brief   Set text 'magnification' size. Each increase in s makes 1 pixel
-   that much bigger.
-    @param  s  Desired text size. 1 is default 6x8, 2 is 12x16, 3 is 18x24, etc
-*/
-/**************************************************************************/
-void Adafruit_GFX::setTextSize(uint8_t s) { setTextSize(s, s); }
-
-/**************************************************************************/
-/*!
-    @brief   Set text 'magnification' size. Each increase in s makes 1 pixel
-   that much bigger.
-    @param  s_x  Desired text width magnification level in X-axis. 1 is default
-    @param  s_y  Desired text width magnification level in Y-axis. 1 is default
-*/
-/**************************************************************************/
-void Adafruit_GFX::setTextSize(uint8_t s_x, uint8_t s_y) {
-  textsize_x = (s_x > 0) ? s_x : 1;
-  textsize_y = (s_y > 0) ? s_y : 1;
-}
-
-/**************************************************************************/
-/*!
-    @brief      Set rotation setting for display
-    @param  x   0 thru 3 corresponding to 4 cardinal rotations
-*/
-/**************************************************************************/
-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;
-  }
-}
-
-/**************************************************************************/
-/*!
-    @brief Set the font to display when print()ing, either custom or default
-    @param  f  The GFXfont object, if NULL use built in 6x8 font
-*/
-/**************************************************************************/
-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;
-    }
-  } 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;
-}
-
-/**************************************************************************/
-/*!
-    @brief  Helper to determine size of a character with current font/size.
-            Broke this out as it's used by both the PROGMEM- and RAM-resident
-            getTextBounds() functions.
-    @param  c     The ASCII character in question
-    @param  x     Pointer to x location of character. Value is modified by
-                  this function to advance to next character.
-    @param  y     Pointer to y location of character. Value is modified by
-                  this function to advance to next character.
-    @param  minx  Pointer to minimum X coordinate, passed in to AND returned
-                  by this function -- this is used to incrementally build a
-                  bounding rectangle for a string.
-    @param  miny  Pointer to minimum Y coord, passed in AND returned.
-    @param  maxx  Pointer to maximum X coord, passed in AND returned.
-    @param  maxy  Pointer to maximum Y coord, passed in AND returned.
-*/
-/**************************************************************************/
-void Adafruit_GFX::charBounds(unsigned char c, int16_t *x, int16_t *y,
-                              int16_t *minx, int16_t *miny, int16_t *maxx,
-                              int16_t *maxy) {
-
-  if (gfxFont) {
-
-    if (c == '\n') { // Newline?
-      *x = 0;        // Reset x to zero, advance y by one line
-      *y += textsize_y * (uint8_t)pgm_read_byte(&gfxFont->yAdvance);
-    } else if (c != '\r') { // Not a carriage return; is normal char
-      uint8_t first = pgm_read_byte(&gfxFont->first),
-              last = pgm_read_byte(&gfxFont->last);
-      if ((c >= first) && (c <= last)) { // Char present in this font?
-        GFXglyph *glyph = pgm_read_glyph_ptr(gfxFont, c - first);
-        uint8_t gw = pgm_read_byte(&glyph->width),
-                gh = 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);
-        if (wrap && ((*x + (((int16_t)xo + gw) * textsize_x)) > _width)) {
-          *x = 0; // Reset x to zero, advance y by one line
-          *y += textsize_y * (uint8_t)pgm_read_byte(&gfxFont->yAdvance);
-        }
-        int16_t tsx = (int16_t)textsize_x, tsy = (int16_t)textsize_y,
-                x1 = *x + xo * tsx, y1 = *y + yo * tsy, x2 = x1 + gw * tsx - 1,
-                y2 = y1 + gh * tsy - 1;
-        if (x1 < *minx)
-          *minx = x1;
-        if (y1 < *miny)
-          *miny = y1;
-        if (x2 > *maxx)
-          *maxx = x2;
-        if (y2 > *maxy)
-          *maxy = y2;
-        *x += xa * tsx;
-      }
-    }
-
-  } else { // Default font
-
-    if (c == '\n') {        // Newline?
-      *x = 0;               // Reset x to zero,
-      *y += textsize_y * 8; // advance y one line
-      // min/max x/y unchaged -- that waits for next 'normal' character
-    } else if (c != '\r') { // Normal char; ignore carriage returns
-      if (wrap && ((*x + textsize_x * 6) > _width)) { // Off right?
-        *x = 0;                                       // Reset x to zero,
-        *y += textsize_y * 8;                         // advance y one line
-      }
-      int x2 = *x + textsize_x * 6 - 1, // Lower-right pixel of char
-          y2 = *y + textsize_y * 8 - 1;
-      if (x2 > *maxx)
-        *maxx = x2; // Track max x, y
-      if (y2 > *maxy)
-        *maxy = y2;
-      if (*x < *minx)
-        *minx = *x; // Track min x, y
-      if (*y < *miny)
-        *miny = *y;
-      *x += textsize_x * 6; // Advance x one char
-    }
-  }
-}
-
-/**************************************************************************/
-/*!
-    @brief  Helper to determine size of a string with current font/size.
-            Pass string and a cursor position, returns UL corner and W,H.
-    @param  str  The ASCII string to measure
-    @param  x    The current cursor X
-    @param  y    The current cursor Y
-    @param  x1   The boundary X coordinate, returned by function
-    @param  y1   The boundary Y coordinate, returned by function
-    @param  w    The boundary width, returned by function
-    @param  h    The boundary height, returned by function
-*/
-/**************************************************************************/
-void Adafruit_GFX::getTextBounds(const 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 minx = 0x7FFF, miny = 0x7FFF, maxx = -1, maxy = -1; // Bound rect
-  // Bound rect is intentionally initialized inverted, so 1st char sets it
-
-  *x1 = x; // Initial position is value passed in
-  *y1 = y;
-  *w = *h = 0; // Initial size is zero
-
-  while ((c = *str++)) {
-    // charBounds() modifies x/y to advance for each character,
-    // and min/max x/y are updated to incrementally build bounding rect.
-    charBounds(c, &x, &y, &minx, &miny, &maxx, &maxy);
-  }
-
-  if (maxx >= minx) {     // If legit string bounds were found...
-    *x1 = minx;           // Update x1 to least X coord,
-    *w = maxx - minx + 1; // And w to bound rect width
-  }
-  if (maxy >= miny) { // Same for height
-    *y1 = miny;
-    *h = maxy - miny + 1;
-  }
-}
-
-/**************************************************************************/
-/*!
-    @brief    Helper to determine size of a string with current font/size. Pass
-   string and a cursor position, returns UL corner and W,H.
-    @param    str    The ascii string to measure (as an arduino String() class)
-    @param    x      The current cursor X
-    @param    y      The current cursor Y
-    @param    x1     The boundary X coordinate, set by function
-    @param    y1     The boundary Y coordinate, set by function
-    @param    w      The boundary width, set by function
-    @param    h      The boundary height, set by function
-*/
-/**************************************************************************/
-void Adafruit_GFX::getTextBounds(const std::string &str, int16_t x, int16_t y,
-                                 int16_t *x1, int16_t *y1, uint16_t *w,
-                                 uint16_t *h) {
-  if (str.length() != 0) {
-    getTextBounds(const_cast<char *>(str.c_str()), x, y, x1, y1, w, h);
-  }
-}
-
-/**************************************************************************/
-/*!
-    @brief    Helper to determine size of a PROGMEM string with current
-   font/size. Pass string and a cursor position, returns UL corner and W,H.
-    @param    str     The flash-memory ascii string to measure
-    @param    x       The current cursor X
-    @param    y       The current cursor Y
-    @param    x1      The boundary X coordinate, set by function
-    @param    y1      The boundary Y coordinate, set by function
-    @param    w      The boundary width, set by function
-    @param    h      The boundary height, set by function
-*/
-/**************************************************************************/
-/* 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; */
-
-/*   *x1 = x; */
-/*   *y1 = y; */
-/*   *w = *h = 0; */
-
-/*   int16_t minx = _width, miny = _height, maxx = -1, maxy = -1; */
-
-/*   while ((c = pgm_read_byte(s++))) */
-/*     charBounds(c, &x, &y, &minx, &miny, &maxx, &maxy); */
-
-/*   if (maxx >= minx) { */
-/*     *x1 = minx; */
-/*     *w = maxx - minx + 1; */
-/*   } */
-/*   if (maxy >= miny) { */
-/*     *y1 = miny; */
-/*     *h = maxy - miny + 1; */
-/*   } */
-/* } */
-
-/**************************************************************************/
-/*!
-    @brief      Invert the display (ideally using built-in hardware command)
-    @param   i  True if you want to invert, false to make 'normal'
-*/
-/**************************************************************************/
-void Adafruit_GFX::invertDisplay(bool i) {
-  // Do nothing, must be subclassed if supported by hardware
-  (void)i; // disable -Wunused-parameter warning
-}
-
-/***************************************************************************/
-
-/**************************************************************************/
-/*!
-   @brief    Create a simple drawn button UI element
-*/
-/**************************************************************************/
-Adafruit_GFX_Button::Adafruit_GFX_Button(void) { _gfx = 0; }
-
-/**************************************************************************/
-/*!
-   @brief    Initialize button with our desired color/size/settings
-   @param    gfx     Pointer to our display so we can draw to it!
-   @param    x       The X coordinate of the center of the button
-   @param    y       The Y coordinate of the center of the button
-   @param    w       Width of the buttton
-   @param    h       Height of the buttton
-   @param    outline  Color of the outline (16-bit 5-6-5 standard)
-   @param    fill  Color of the button fill (16-bit 5-6-5 standard)
-   @param    textcolor  Color of the button label (16-bit 5-6-5 standard)
-   @param    label  Ascii string of the text inside the button
-   @param    textsize The font magnification of the label text
-*/
-/**************************************************************************/
-// Classic initButton() function: pass center & size
-void Adafruit_GFX_Button::initButton(Adafruit_GFX *gfx, int16_t x, int16_t y,
-                                     uint16_t w, uint16_t h, uint16_t outline,
-                                     uint16_t fill, uint16_t textcolor,
-                                     char *label, uint8_t textsize) {
-  // Tweak arguments and pass to the newer initButtonUL() function...
-  initButtonUL(gfx, x - (w / 2), y - (h / 2), w, h, outline, fill, textcolor,
-               label, textsize);
-}
-
-/**************************************************************************/
-/*!
-   @brief    Initialize button with our desired color/size/settings
-   @param    gfx     Pointer to our display so we can draw to it!
-   @param    x       The X coordinate of the center of the button
-   @param    y       The Y coordinate of the center of the button
-   @param    w       Width of the buttton
-   @param    h       Height of the buttton
-   @param    outline  Color of the outline (16-bit 5-6-5 standard)
-   @param    fill  Color of the button fill (16-bit 5-6-5 standard)
-   @param    textcolor  Color of the button label (16-bit 5-6-5 standard)
-   @param    label  Ascii string of the text inside the button
-   @param    textsize_x The font magnification in X-axis of the label text
-   @param    textsize_y The font magnification in Y-axis of the label text
-*/
-/**************************************************************************/
-// Classic initButton() function: pass center & size
-void Adafruit_GFX_Button::initButton(Adafruit_GFX *gfx, int16_t x, int16_t y,
-                                     uint16_t w, uint16_t h, uint16_t outline,
-                                     uint16_t fill, uint16_t textcolor,
-                                     char *label, uint8_t textsize_x,
-                                     uint8_t textsize_y) {
-  // Tweak arguments and pass to the newer initButtonUL() function...
-  initButtonUL(gfx, x - (w / 2), y - (h / 2), w, h, outline, fill, textcolor,
-               label, textsize_x, textsize_y);
-}
-
-/**************************************************************************/
-/*!
-   @brief    Initialize button with our desired color/size/settings, with
-   upper-left coordinates
-   @param    gfx     Pointer to our display so we can draw to it!
-   @param    x1       The X coordinate of the Upper-Left corner of the button
-   @param    y1       The Y coordinate of the Upper-Left corner of the button
-   @param    w       Width of the buttton
-   @param    h       Height of the buttton
-   @param    outline  Color of the outline (16-bit 5-6-5 standard)
-   @param    fill  Color of the button fill (16-bit 5-6-5 standard)
-   @param    textcolor  Color of the button label (16-bit 5-6-5 standard)
-   @param    label  Ascii string of the text inside the button
-   @param    textsize The font magnification of the label text
-*/
-/**************************************************************************/
-void Adafruit_GFX_Button::initButtonUL(Adafruit_GFX *gfx, int16_t x1,
-                                       int16_t y1, uint16_t w, uint16_t h,
-                                       uint16_t outline, uint16_t fill,
-                                       uint16_t textcolor, char *label,
-                                       uint8_t textsize) {
-  initButtonUL(gfx, x1, y1, w, h, outline, fill, textcolor, label, textsize,
-               textsize);
-}
-
-/**************************************************************************/
-/*!
-   @brief    Initialize button with our desired color/size/settings, with
-   upper-left coordinates
-   @param    gfx     Pointer to our display so we can draw to it!
-   @param    x1       The X coordinate of the Upper-Left corner of the button
-   @param    y1       The Y coordinate of the Upper-Left corner of the button
-   @param    w       Width of the buttton
-   @param    h       Height of the buttton
-   @param    outline  Color of the outline (16-bit 5-6-5 standard)
-   @param    fill  Color of the button fill (16-bit 5-6-5 standard)
-   @param    textcolor  Color of the button label (16-bit 5-6-5 standard)
-   @param    label  Ascii string of the text inside the button
-   @param    textsize_x The font magnification in X-axis of the label text
-   @param    textsize_y The font magnification in Y-axis of the label text
-*/
-/**************************************************************************/
-void Adafruit_GFX_Button::initButtonUL(Adafruit_GFX *gfx, int16_t x1,
-                                       int16_t y1, uint16_t w, uint16_t h,
-                                       uint16_t outline, uint16_t fill,
-                                       uint16_t textcolor, char *label,
-                                       uint8_t textsize_x, uint8_t textsize_y) {
-  _x1 = x1;
-  _y1 = y1;
-  _w = w;
-  _h = h;
-  _outlinecolor = outline;
-  _fillcolor = fill;
-  _textcolor = textcolor;
-  _textsize_x = textsize_x;
-  _textsize_y = textsize_y;
-  _gfx = gfx;
-  strncpy(_label, label, 9);
-  _label[9] = 0; // strncpy does not place a null at the end.
-                 // When 'label' is >9 characters, _label is not terminated.
-}
-
-/**************************************************************************/
-/*!
-   @brief    Draw the button on the screen
-   @param    inverted Whether to draw with fill/text swapped to indicate
-   'pressed'
-*/
-/**************************************************************************/
-void Adafruit_GFX_Button::drawButton(bool inverted) {
-  uint16_t fill, outline, text;
-
-  if (!inverted) {
-    fill = _fillcolor;
-    outline = _outlinecolor;
-    text = _textcolor;
-  } else {
-    fill = _textcolor;
-    outline = _outlinecolor;
-    text = _fillcolor;
-  }
-
-  uint8_t r = min(_w, _h) / 4; // Corner radius
-  _gfx->fillRoundRect(_x1, _y1, _w, _h, r, fill);
-  _gfx->drawRoundRect(_x1, _y1, _w, _h, r, outline);
-
-  _gfx->setCursor(_x1 + (_w / 2) - (strlen(_label) * 3 * _textsize_x),
-                  _y1 + (_h / 2) - (4 * _textsize_y));
-  _gfx->setTextColor(text);
-  _gfx->setTextSize(_textsize_x, _textsize_y);
-  /* _gfx->print(_label); */
-}
-
-/**************************************************************************/
-/*!
-    @brief    Helper to let us know if a coordinate is within the bounds of the
-   button
-    @param    x       The X coordinate to check
-    @param    y       The Y coordinate to check
-    @returns  True if within button graphics outline
-*/
-/**************************************************************************/
-bool Adafruit_GFX_Button::contains(int16_t x, int16_t y) {
-  return ((x >= _x1) && (x < (int16_t)(_x1 + _w)) && (y >= _y1) &&
-          (y < (int16_t)(_y1 + _h)));
-}
-
-/**************************************************************************/
-/*!
-   @brief    Query whether the button was pressed since we last checked state
-   @returns  True if was not-pressed before, now is.
-*/
-/**************************************************************************/
-bool Adafruit_GFX_Button::justPressed() { return (currstate && !laststate); }
-
-/**************************************************************************/
-/*!
-   @brief    Query whether the button was released since we last checked state
-   @returns  True if was pressed before, now is not.
-*/
-/**************************************************************************/
-bool Adafruit_GFX_Button::justReleased() { return (!currstate && laststate); }
-
-// -------------------------------------------------------------------------
-
-// GFXcanvas1, GFXcanvas8 and GFXcanvas16 (currently a WIP, don't get too
-// comfy with the implementation) provide 1-, 8- and 16-bit offscreen
-// canvases, the address of which can be passed to drawBitmap() or
-// pushColors() (the latter appears only in a couple of GFX-subclassed TFT
-// libraries at this time).  This is here mostly to help with the recently-
-// added proportionally-spaced fonts; adds a way to refresh a section of the
-// screen without a massive flickering clear-and-redraw...but maybe you'll
-// find other uses too.  VERY RAM-intensive, since the buffer is in MCU
-// memory and not the display driver...GXFcanvas1 might be minimally useful
-// on an Uno-class board, but this and the others are much more likely to
-// require at least a Mega or various recent ARM-type boards (recommended,
-// as the text+bitmap draw can be pokey).  GFXcanvas1 requires 1 bit per
-// pixel (rounded up to nearest byte per scanline), GFXcanvas8 is 1 byte
-// per pixel (no scanline pad), and GFXcanvas16 uses 2 bytes per pixel (no
-// scanline pad).
-// NOT EXTENSIVELY TESTED YET.  MAY CONTAIN WORST BUGS KNOWN TO HUMANKIND.
-
-#ifdef __AVR__
-// Bitmask tables of 0x80>>X and ~(0x80>>X), because X>>Y is slow on AVR
-const uint8_t PROGMEM GFXcanvas1::GFXsetBit[] = {0x80, 0x40, 0x20, 0x10,
-                                                 0x08, 0x04, 0x02, 0x01};
-const uint8_t PROGMEM GFXcanvas1::GFXclrBit[] = {0x7F, 0xBF, 0xDF, 0xEF,
-                                                 0xF7, 0xFB, 0xFD, 0xFE};
-#endif
-
-/**************************************************************************/
-/*!
-   @brief    Instatiate a GFX 1-bit canvas context for graphics
-   @param    w   Display width, in pixels
-   @param    h   Display height, in pixels
-*/
-/**************************************************************************/
-GFXcanvas1::GFXcanvas1(uint16_t w, uint16_t h) : Adafruit_GFX(w, h) {
-  uint32_t bytes = ((w + 7) / 8) * h;
-  if ((buffer = (uint8_t *)malloc(bytes))) {
-    memset(buffer, 0, bytes);
-  }
-}
-
-/**************************************************************************/
-/*!
-   @brief    Delete the canvas, free memory
-*/
-/**************************************************************************/
-GFXcanvas1::~GFXcanvas1(void) {
-  if (buffer)
-    free(buffer);
-}
-
-/**************************************************************************/
-/*!
-    @brief  Draw a pixel to the canvas framebuffer
-    @param  x     x coordinate
-    @param  y     y coordinate
-    @param  color Binary (on or off) color to fill with
-*/
-/**************************************************************************/
-void GFXcanvas1::drawPixel(int16_t x, int16_t y, uint16_t color) {
-  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;
-    }
-
-    uint8_t *ptr = &buffer[(x / 8) + y * ((WIDTH + 7) / 8)];
-#ifdef __AVR__
-    if (color)
-      *ptr |= pgm_read_byte(&GFXsetBit[x & 7]);
-    else
-      *ptr &= pgm_read_byte(&GFXclrBit[x & 7]);
-#else
-    if (color)
-      *ptr |= 0x80 >> (x & 7);
-    else
-      *ptr &= ~(0x80 >> (x & 7));
-#endif
-  }
-}
-
-/**********************************************************************/
-/*!
-        @brief    Get the pixel color value at a given coordinate
-        @param    x   x coordinate
-        @param    y   y coordinate
-        @returns  The desired pixel's binary color value, either 0x1 (on) or 0x0
-   (off)
-*/
-/**********************************************************************/
-bool GFXcanvas1::getPixel(int16_t x, int16_t y) const {
-  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;
-  }
-  return getRawPixel(x, y);
-}
-
-/**********************************************************************/
-/*!
-        @brief    Get the pixel color value at a given, unrotated coordinate.
-              This method is intended for hardware drivers to get pixel value
-              in physical coordinates.
-        @param    x   x coordinate
-        @param    y   y coordinate
-        @returns  The desired pixel's binary color value, either 0x1 (on) or 0x0
-   (off)
-*/
-/**********************************************************************/
-bool GFXcanvas1::getRawPixel(int16_t x, int16_t y) const {
-  if ((x < 0) || (y < 0) || (x >= WIDTH) || (y >= HEIGHT))
-    return 0;
-  if (buffer) {
-    uint8_t *ptr = &buffer[(x / 8) + y * ((WIDTH + 7) / 8)];
-
-#ifdef __AVR__
-    return ((*ptr) & pgm_read_byte(&GFXsetBit[x & 7])) != 0;
-#else
-    return ((*ptr) & (0x80 >> (x & 7))) != 0;
-#endif
-  }
-  return 0;
-}
-
-/**************************************************************************/
-/*!
-    @brief  Fill the framebuffer completely with one color
-    @param  color Binary (on or off) color to fill with
-*/
-/**************************************************************************/
-void GFXcanvas1::fillScreen(uint16_t color) {
-  if (buffer) {
-    uint32_t bytes = ((WIDTH + 7) / 8) * HEIGHT;
-    memset(buffer, color ? 0xFF : 0x00, bytes);
-  }
-}
-
-/**************************************************************************/
-/*!
-   @brief  Speed optimized vertical line drawing
-   @param  x      Line horizontal start point
-   @param  y      Line vertical start point
-   @param  h      Length of vertical line to be drawn, including first point
-   @param  color  Color to fill with
-*/
-/**************************************************************************/
-void GFXcanvas1::drawFastVLine(int16_t x, int16_t y, int16_t h,
-                               uint16_t color) {
-
-  if (h < 0) { // Convert negative heights to positive equivalent
-    h *= -1;
-    y -= h - 1;
-    if (y < 0) {
-      h += y;
-      y = 0;
-    }
-  }
-
-  // Edge rejection (no-draw if totally off canvas)
-  if ((x < 0) || (x >= width()) || (y >= height()) || ((y + h - 1) < 0)) {
-    return;
-  }
-
-  if (y < 0) { // Clip top
-    h += y;
-    y = 0;
-  }
-  if (y + h > height()) { // Clip bottom
-    h = height() - y;
-  }
-
-  if (getRotation() == 0) {
-    drawFastRawVLine(x, y, h, color);
-  } else if (getRotation() == 1) {
-    int16_t t = x;
-    x = WIDTH - 1 - y;
-    y = t;
-    x -= h - 1;
-    drawFastRawHLine(x, y, h, color);
-  } else if (getRotation() == 2) {
-    x = WIDTH - 1 - x;
-    y = HEIGHT - 1 - y;
-
-    y -= h - 1;
-    drawFastRawVLine(x, y, h, color);
-  } else if (getRotation() == 3) {
-    int16_t t = x;
-    x = y;
-    y = HEIGHT - 1 - t;
-    drawFastRawHLine(x, y, h, color);
-  }
-}
-
-/**************************************************************************/
-/*!
-   @brief  Speed optimized horizontal line drawing
-   @param  x      Line horizontal start point
-   @param  y      Line vertical start point
-   @param  w      Length of horizontal line to be drawn, including first point
-   @param  color  Color to fill with
-*/
-/**************************************************************************/
-void GFXcanvas1::drawFastHLine(int16_t x, int16_t y, int16_t w,
-                               uint16_t color) {
-  if (w < 0) { // Convert negative widths to positive equivalent
-    w *= -1;
-    x -= w - 1;
-    if (x < 0) {
-      w += x;
-      x = 0;
-    }
-  }
-
-  // Edge rejection (no-draw if totally off canvas)
-  if ((y < 0) || (y >= height()) || (x >= width()) || ((x + w - 1) < 0)) {
-    return;
-  }
-
-  if (x < 0) { // Clip left
-    w += x;
-    x = 0;
-  }
-  if (x + w >= width()) { // Clip right
-    w = width() - x;
-  }
-
-  if (getRotation() == 0) {
-    drawFastRawHLine(x, y, w, color);
-  } else if (getRotation() == 1) {
-    int16_t t = x;
-    x = WIDTH - 1 - y;
-    y = t;
-    drawFastRawVLine(x, y, w, color);
-  } else if (getRotation() == 2) {
-    x = WIDTH - 1 - x;
-    y = HEIGHT - 1 - y;
-
-    x -= w - 1;
-    drawFastRawHLine(x, y, w, color);
-  } else if (getRotation() == 3) {
-    int16_t t = x;
-    x = y;
-    y = HEIGHT - 1 - t;
-    y -= w - 1;
-    drawFastRawVLine(x, y, w, color);
-  }
-}
-
-/**************************************************************************/
-/*!
-   @brief    Speed optimized vertical line drawing into the raw canvas buffer
-   @param    x   Line horizontal start point
-   @param    y   Line vertical start point
-   @param    h   length of vertical line to be drawn, including first point
-   @param    color   Binary (on or off) color to fill with
-*/
-/**************************************************************************/
-void GFXcanvas1::drawFastRawVLine(int16_t x, int16_t y, int16_t h,
-                                  uint16_t color) {
-  // x & y already in raw (rotation 0) coordinates, no need to transform.
-  int16_t row_bytes = ((WIDTH + 7) / 8);
-  uint8_t *ptr = &buffer[(x / 8) + y * row_bytes];
-
-  if (color > 0) {
-#ifdef __AVR__
-    uint8_t bit_mask = pgm_read_byte(&GFXsetBit[x & 7]);
-#else
-    uint8_t bit_mask = (0x80 >> (x & 7));
-#endif
-    for (int16_t i = 0; i < h; i++) {
-      *ptr |= bit_mask;
-      ptr += row_bytes;
-    }
-  } else {
-#ifdef __AVR__
-    uint8_t bit_mask = pgm_read_byte(&GFXclrBit[x & 7]);
-#else
-    uint8_t bit_mask = ~(0x80 >> (x & 7));
-#endif
-    for (int16_t i = 0; i < h; i++) {
-      *ptr &= bit_mask;
-      ptr += row_bytes;
-    }
-  }
-}
-
-/**************************************************************************/
-/*!
-   @brief    Speed optimized horizontal line drawing into the raw canvas buffer
-   @param    x   Line horizontal start point
-   @param    y   Line vertical start point
-   @param    w   length of horizontal line to be drawn, including first point
-   @param    color   Binary (on or off) color to fill with
-*/
-/**************************************************************************/
-void GFXcanvas1::drawFastRawHLine(int16_t x, int16_t y, int16_t w,
-                                  uint16_t color) {
-  // x & y already in raw (rotation 0) coordinates, no need to transform.
-  int16_t rowBytes = ((WIDTH + 7) / 8);
-  uint8_t *ptr = &buffer[(x / 8) + y * rowBytes];
-  size_t remainingWidthBits = w;
-
-  // check to see if first byte needs to be partially filled
-  if ((x & 7) > 0) {
-    // create bit mask for first byte
-    uint8_t startByteBitMask = 0x00;
-    for (int8_t i = (x & 7); ((i < 8) && (remainingWidthBits > 0)); i++) {
-#ifdef __AVR__
-      startByteBitMask |= pgm_read_byte(&GFXsetBit[i]);
-#else
-      startByteBitMask |= (0x80 >> i);
-#endif
-      remainingWidthBits--;
-    }
-    if (color > 0) {
-      *ptr |= startByteBitMask;
-    } else {
-      *ptr &= ~startByteBitMask;
-    }
-
-    ptr++;
-  }
-
-  // do the next remainingWidthBits bits
-  if (remainingWidthBits > 0) {
-    size_t remainingWholeBytes = remainingWidthBits / 8;
-    size_t lastByteBits = remainingWidthBits % 8;
-    uint8_t wholeByteColor = color > 0 ? 0xFF : 0x00;
-
-    memset(ptr, wholeByteColor, remainingWholeBytes);
-
-    if (lastByteBits > 0) {
-      uint8_t lastByteBitMask = 0x00;
-      for (size_t i = 0; i < lastByteBits; i++) {
-#ifdef __AVR__
-        lastByteBitMask |= pgm_read_byte(&GFXsetBit[i]);
-#else
-        lastByteBitMask |= (0x80 >> i);
-#endif
-      }
-      ptr += remainingWholeBytes;
-
-      if (color > 0) {
-        *ptr |= lastByteBitMask;
-      } else {
-        *ptr &= ~lastByteBitMask;
-      }
-    }
-  }
-}
-
-/**************************************************************************/
-/*!
-   @brief    Instatiate a GFX 8-bit canvas context for graphics
-   @param    w   Display width, in pixels
-   @param    h   Display height, in pixels
-*/
-/**************************************************************************/
-GFXcanvas8::GFXcanvas8(uint16_t w, uint16_t h) : Adafruit_GFX(w, h) {
-  uint32_t bytes = w * h;
-  if ((buffer = (uint8_t *)malloc(bytes))) {
-    memset(buffer, 0, bytes);
-  }
-}
-
-/**************************************************************************/
-/*!
-   @brief    Delete the canvas, free memory
-*/
-/**************************************************************************/
-GFXcanvas8::~GFXcanvas8(void) {
-  if (buffer)
-    free(buffer);
-}
-
-/**************************************************************************/
-/*!
-    @brief  Draw a pixel to the canvas framebuffer
-    @param  x   x coordinate
-    @param  y   y coordinate
-    @param  color 8-bit Color to fill with. Only lower byte of uint16_t is used.
-*/
-/**************************************************************************/
-void GFXcanvas8::drawPixel(int16_t x, int16_t y, uint16_t color) {
-  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;
-    }
-
-    buffer[x + y * WIDTH] = color;
-  }
-}
-
-/**********************************************************************/
-/*!
-        @brief    Get the pixel color value at a given coordinate
-        @param    x   x coordinate
-        @param    y   y coordinate
-        @returns  The desired pixel's 8-bit color value
-*/
-/**********************************************************************/
-uint8_t GFXcanvas8::getPixel(int16_t x, int16_t y) const {
-  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;
-  }
-  return getRawPixel(x, y);
-}
-
-/**********************************************************************/
-/*!
-        @brief    Get the pixel color value at a given, unrotated coordinate.
-              This method is intended for hardware drivers to get pixel value
-              in physical coordinates.
-        @param    x   x coordinate
-        @param    y   y coordinate
-        @returns  The desired pixel's 8-bit color value
-*/
-/**********************************************************************/
-uint8_t GFXcanvas8::getRawPixel(int16_t x, int16_t y) const {
-  if ((x < 0) || (y < 0) || (x >= WIDTH) || (y >= HEIGHT))
-    return 0;
-  if (buffer) {
-    return buffer[x + y * WIDTH];
-  }
-  return 0;
-}
-
-/**************************************************************************/
-/*!
-    @brief  Fill the framebuffer completely with one color
-    @param  color 8-bit Color to fill with. Only lower byte of uint16_t is used.
-*/
-/**************************************************************************/
-void GFXcanvas8::fillScreen(uint16_t color) {
-  if (buffer) {
-    memset(buffer, color, WIDTH * HEIGHT);
-  }
-}
-
-/**************************************************************************/
-/*!
-   @brief  Speed optimized vertical line drawing
-   @param  x      Line horizontal start point
-   @param  y      Line vertical start point
-   @param  h      Length of vertical line to be drawn, including first point
-   @param  color  8-bit Color to fill with. Only lower byte of uint16_t is
-                  used.
-*/
-/**************************************************************************/
-void GFXcanvas8::drawFastVLine(int16_t x, int16_t y, int16_t h,
-                               uint16_t color) {
-  if (h < 0) { // Convert negative heights to positive equivalent
-    h *= -1;
-    y -= h - 1;
-    if (y < 0) {
-      h += y;
-      y = 0;
-    }
-  }
-
-  // Edge rejection (no-draw if totally off canvas)
-  if ((x < 0) || (x >= width()) || (y >= height()) || ((y + h - 1) < 0)) {
-    return;
-  }
-
-  if (y < 0) { // Clip top
-    h += y;
-    y = 0;
-  }
-  if (y + h > height()) { // Clip bottom
-    h = height() - y;
-  }
-
-  if (getRotation() == 0) {
-    drawFastRawVLine(x, y, h, color);
-  } else if (getRotation() == 1) {
-    int16_t t = x;
-    x = WIDTH - 1 - y;
-    y = t;
-    x -= h - 1;
-    drawFastRawHLine(x, y, h, color);
-  } else if (getRotation() == 2) {
-    x = WIDTH - 1 - x;
-    y = HEIGHT - 1 - y;
-
-    y -= h - 1;
-    drawFastRawVLine(x, y, h, color);
-  } else if (getRotation() == 3) {
-    int16_t t = x;
-    x = y;
-    y = HEIGHT - 1 - t;
-    drawFastRawHLine(x, y, h, color);
-  }
-}
-
-/**************************************************************************/
-/*!
-   @brief  Speed optimized horizontal line drawing
-   @param  x      Line horizontal start point
-   @param  y      Line vertical start point
-   @param  w      Length of horizontal line to be drawn, including 1st point
-   @param  color  8-bit Color to fill with. Only lower byte of uint16_t is
-                  used.
-*/
-/**************************************************************************/
-void GFXcanvas8::drawFastHLine(int16_t x, int16_t y, int16_t w,
-                               uint16_t color) {
-
-  if (w < 0) { // Convert negative widths to positive equivalent
-    w *= -1;
-    x -= w - 1;
-    if (x < 0) {
-      w += x;
-      x = 0;
-    }
-  }
-
-  // Edge rejection (no-draw if totally off canvas)
-  if ((y < 0) || (y >= height()) || (x >= width()) || ((x + w - 1) < 0)) {
-    return;
-  }
-
-  if (x < 0) { // Clip left
-    w += x;
-    x = 0;
-  }
-  if (x + w >= width()) { // Clip right
-    w = width() - x;
-  }
-
-  if (getRotation() == 0) {
-    drawFastRawHLine(x, y, w, color);
-  } else if (getRotation() == 1) {
-    int16_t t = x;
-    x = WIDTH - 1 - y;
-    y = t;
-    drawFastRawVLine(x, y, w, color);
-  } else if (getRotation() == 2) {
-    x = WIDTH - 1 - x;
-    y = HEIGHT - 1 - y;
-
-    x -= w - 1;
-    drawFastRawHLine(x, y, w, color);
-  } else if (getRotation() == 3) {
-    int16_t t = x;
-    x = y;
-    y = HEIGHT - 1 - t;
-    y -= w - 1;
-    drawFastRawVLine(x, y, w, color);
-  }
-}
-
-/**************************************************************************/
-/*!
-   @brief    Speed optimized vertical line drawing into the raw canvas buffer
-   @param    x   Line horizontal start point
-   @param    y   Line vertical start point
-   @param    h   length of vertical line to be drawn, including first point
-   @param    color   8-bit Color to fill with. Only lower byte of uint16_t is
-   used.
-*/
-/**************************************************************************/
-void GFXcanvas8::drawFastRawVLine(int16_t x, int16_t y, int16_t h,
-                                  uint16_t color) {
-  // x & y already in raw (rotation 0) coordinates, no need to transform.
-  uint8_t *buffer_ptr = buffer + y * WIDTH + x;
-  for (int16_t i = 0; i < h; i++) {
-    (*buffer_ptr) = color;
-    buffer_ptr += WIDTH;
-  }
-}
-
-/**************************************************************************/
-/*!
-   @brief    Speed optimized horizontal line drawing into the raw canvas buffer
-   @param    x   Line horizontal start point
-   @param    y   Line vertical start point
-   @param    w   length of horizontal line to be drawn, including first point
-   @param    color   8-bit Color to fill with. Only lower byte of uint16_t is
-   used.
-*/
-/**************************************************************************/
-void GFXcanvas8::drawFastRawHLine(int16_t x, int16_t y, int16_t w,
-                                  uint16_t color) {
-  // x & y already in raw (rotation 0) coordinates, no need to transform.
-  memset(buffer + y * WIDTH + x, color, w);
-}
-
-/**************************************************************************/
-/*!
-   @brief    Instatiate a GFX 16-bit canvas context for graphics
-   @param    w   Display width, in pixels
-   @param    h   Display height, in pixels
-*/
-/**************************************************************************/
-GFXcanvas16::GFXcanvas16(uint16_t w, uint16_t h) : Adafruit_GFX(w, h) {
-  uint32_t bytes = w * h * 2;
-  if ((buffer = (uint16_t *)malloc(bytes))) {
-    memset(buffer, 0, bytes);
-  }
-}
-
-/**************************************************************************/
-/*!
-   @brief    Delete the canvas, free memory
-*/
-/**************************************************************************/
-GFXcanvas16::~GFXcanvas16(void) {
-  if (buffer)
-    free(buffer);
-}
-
-/**************************************************************************/
-/*!
-    @brief  Draw a pixel to the canvas framebuffer
-    @param  x   x coordinate
-    @param  y   y coordinate
-    @param  color 16-bit 5-6-5 Color to fill with
-*/
-/**************************************************************************/
-void GFXcanvas16::drawPixel(int16_t x, int16_t y, uint16_t color) {
-  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;
-    }
-
-    buffer[x + y * WIDTH] = color;
-  }
-}
-
-/**********************************************************************/
-/*!
-        @brief    Get the pixel color value at a given coordinate
-        @param    x   x coordinate
-        @param    y   y coordinate
-        @returns  The desired pixel's 16-bit 5-6-5 color value
-*/
-/**********************************************************************/
-uint16_t GFXcanvas16::getPixel(int16_t x, int16_t y) const {
-  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;
-  }
-  return getRawPixel(x, y);
-}
-
-/**********************************************************************/
-/*!
-        @brief    Get the pixel color value at a given, unrotated coordinate.
-              This method is intended for hardware drivers to get pixel value
-              in physical coordinates.
-        @param    x   x coordinate
-        @param    y   y coordinate
-        @returns  The desired pixel's 16-bit 5-6-5 color value
-*/
-/**********************************************************************/
-uint16_t GFXcanvas16::getRawPixel(int16_t x, int16_t y) const {
-  if ((x < 0) || (y < 0) || (x >= WIDTH) || (y >= HEIGHT))
-    return 0;
-  if (buffer) {
-    return buffer[x + y * WIDTH];
-  }
-  return 0;
-}
-
-/**************************************************************************/
-/*!
-    @brief  Fill the framebuffer completely with one color
-    @param  color 16-bit 5-6-5 Color to fill with
-*/
-/**************************************************************************/
-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 {
-      uint32_t i, pixels = WIDTH * HEIGHT;
-      for (i = 0; i < pixels; i++)
-        buffer[i] = color;
-    }
-  }
-}
-
-/**************************************************************************/
-/*!
-    @brief  Reverses the "endian-ness" of each 16-bit pixel within the
-            canvas; little-endian to big-endian, or big-endian to little.
-            Most microcontrollers (such as SAMD) are little-endian, while
-            most displays tend toward big-endianness. All the drawing
-            functions (including RGB bitmap drawing) take care of this
-            automatically, but some specialized code (usually involving
-            DMA) can benefit from having pixel data already in the
-            display-native order. Note that this does NOT convert to a
-            SPECIFIC endian-ness, it just flips the bytes within each word.
-*/
-/**************************************************************************/
-void GFXcanvas16::byteSwap(void) {
-  if (buffer) {
-    uint32_t i, pixels = WIDTH * HEIGHT;
-    for (i = 0; i < pixels; i++)
-      buffer[i] = __builtin_bswap16(buffer[i]);
-  }
-}
-
-/**************************************************************************/
-/*!
-   @brief    Speed optimized vertical line drawing
-   @param    x   Line horizontal start point
-   @param    y   Line vertical start point
-   @param    h   length of vertical line to be drawn, including first point
-   @param    color   color 16-bit 5-6-5 Color to draw line with
-*/
-/**************************************************************************/
-void GFXcanvas16::drawFastVLine(int16_t x, int16_t y, int16_t h,
-                                uint16_t color) {
-  if (h < 0) { // Convert negative heights to positive equivalent
-    h *= -1;
-    y -= h - 1;
-    if (y < 0) {
-      h += y;
-      y = 0;
-    }
-  }
-
-  // Edge rejection (no-draw if totally off canvas)
-  if ((x < 0) || (x >= width()) || (y >= height()) || ((y + h - 1) < 0)) {
-    return;
-  }
-
-  if (y < 0) { // Clip top
-    h += y;
-    y = 0;
-  }
-  if (y + h > height()) { // Clip bottom
-    h = height() - y;
-  }
-
-  if (getRotation() == 0) {
-    drawFastRawVLine(x, y, h, color);
-  } else if (getRotation() == 1) {
-    int16_t t = x;
-    x = WIDTH - 1 - y;
-    y = t;
-    x -= h - 1;
-    drawFastRawHLine(x, y, h, color);
-  } else if (getRotation() == 2) {
-    x = WIDTH - 1 - x;
-    y = HEIGHT - 1 - y;
-
-    y -= h - 1;
-    drawFastRawVLine(x, y, h, color);
-  } else if (getRotation() == 3) {
-    int16_t t = x;
-    x = y;
-    y = HEIGHT - 1 - t;
-    drawFastRawHLine(x, y, h, color);
-  }
-}
-
-/**************************************************************************/
-/*!
-   @brief  Speed optimized horizontal line drawing
-   @param  x      Line horizontal start point
-   @param  y      Line vertical start point
-   @param  w      Length of horizontal line to be drawn, including 1st point
-   @param  color  Color 16-bit 5-6-5 Color to draw line with
-*/
-/**************************************************************************/
-void GFXcanvas16::drawFastHLine(int16_t x, int16_t y, int16_t w,
-                                uint16_t color) {
-  if (w < 0) { // Convert negative widths to positive equivalent
-    w *= -1;
-    x -= w - 1;
-    if (x < 0) {
-      w += x;
-      x = 0;
-    }
-  }
-
-  // Edge rejection (no-draw if totally off canvas)
-  if ((y < 0) || (y >= height()) || (x >= width()) || ((x + w - 1) < 0)) {
-    return;
-  }
-
-  if (x < 0) { // Clip left
-    w += x;
-    x = 0;
-  }
-  if (x + w >= width()) { // Clip right
-    w = width() - x;
-  }
-
-  if (getRotation() == 0) {
-    drawFastRawHLine(x, y, w, color);
-  } else if (getRotation() == 1) {
-    int16_t t = x;
-    x = WIDTH - 1 - y;
-    y = t;
-    drawFastRawVLine(x, y, w, color);
-  } else if (getRotation() == 2) {
-    x = WIDTH - 1 - x;
-    y = HEIGHT - 1 - y;
-
-    x -= w - 1;
-    drawFastRawHLine(x, y, w, color);
-  } else if (getRotation() == 3) {
-    int16_t t = x;
-    x = y;
-    y = HEIGHT - 1 - t;
-    y -= w - 1;
-    drawFastRawVLine(x, y, w, color);
-  }
-}
-
-/**************************************************************************/
-/*!
-   @brief    Speed optimized vertical line drawing into the raw canvas buffer
-   @param    x   Line horizontal start point
-   @param    y   Line vertical start point
-   @param    h   length of vertical line to be drawn, including first point
-   @param    color   color 16-bit 5-6-5 Color to draw line with
-*/
-/**************************************************************************/
-void GFXcanvas16::drawFastRawVLine(int16_t x, int16_t y, int16_t h,
-                                   uint16_t color) {
-  // x & y already in raw (rotation 0) coordinates, no need to transform.
-  uint16_t *buffer_ptr = buffer + y * WIDTH + x;
-  for (int16_t i = 0; i < h; i++) {
-    (*buffer_ptr) = color;
-    buffer_ptr += WIDTH;
-  }
-}
-
-/**************************************************************************/
-/*!
-   @brief    Speed optimized horizontal line drawing into the raw canvas buffer
-   @param    x   Line horizontal start point
-   @param    y   Line vertical start point
-   @param    w   length of horizontal line to be drawn, including first point
-   @param    color   color 16-bit 5-6-5 Color to draw line with
-*/
-/**************************************************************************/
-void GFXcanvas16::drawFastRawHLine(int16_t x, int16_t y, int16_t w,
-                                   uint16_t color) {
-  // x & y already in raw (rotation 0) coordinates, no need to transform.
-  uint32_t buffer_index = y * WIDTH + x;
-  for (uint32_t i = buffer_index; i < buffer_index + w; i++) {
-    buffer[i] = color;
-  }
-}