// /*
//   This is just a copy of the Adafruit GFX library renamed to use with BMC
//   and to avoid conflicts with other installations
  
//   https://github.com/adafruit/Adafruit-GFX-Library
// */

// #ifndef BMC_GFX_H
// #define BMC_GFX_H

// #if ARDUINO >= 100
//  #include "Arduino.h"
//  #include "Print.h"
// #else
//  #include "WProgram.h"
// #endif
// #include "display/drivers/BMC-DisplayStruct.h"
// #include "display/drivers/BMC-gfxfont.h"

// /// A generic graphics superclass that can handle all sorts of drawing. At a minimum you can subclass and provide drawPixel(). At a maximum you can do a ton of overriding to optimize. Used for any/all Adafruit displays!
// class BMCGFX : public Print {

//  public:

//   BMCGFX(int16_t w, int16_t h); // Constructor

//   // This MUST be defined by the subclass:
//   virtual void drawPixel(int16_t x, int16_t y, uint16_t color) = 0;    ///< Virtual drawPixel() function to draw to the screen/framebuffer/etc, must be overridden in subclass. @param x X coordinate.  @param y Y coordinate. @param color 16-bit pixel color.

//   // TRANSACTION API / CORE DRAW API
//   // These MAY be overridden by the subclass to provide device-specific
//   // optimized code.  Otherwise 'generic' versions are used.
//   virtual void startWrite(void);
//   virtual void writePixel(int16_t x, int16_t y, uint16_t color);
//   virtual void writeFillRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color);
//   virtual void writeFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color);
//   virtual void writeFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color);
//   virtual void writeLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t color);
//   virtual void endWrite(void);

//   // CONTROL API
//   // These MAY be overridden by the subclass to provide device-specific
//   // optimized code.  Otherwise 'generic' versions are used.
//   virtual void setRotation(uint8_t r);
//   virtual void invertDisplay(boolean i);

//   // BASIC DRAW API
//   // These MAY be overridden by the subclass to provide device-specific
//   // optimized code.  Otherwise 'generic' versions are used.
//   virtual void
//     // It's good to implement those, even if using transaction API
//     drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color),
//     drawFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color),
//     fillRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color),
//     fillScreen(uint16_t color),
//     // Optional and probably not necessary to change
//     drawLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t color),
//     drawRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color);

//   // These exist only with BMCGFX (no subclass overrides)
//   void
//     drawCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color),
//     drawCircleHelper(int16_t x0, int16_t y0, int16_t r, uint8_t cornername,
//       uint16_t color),
//     fillCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color),
//     fillCircleHelper(int16_t x0, int16_t y0, int16_t r, uint8_t cornername,
//       int16_t delta, uint16_t color),
//     drawTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1,
//       int16_t x2, int16_t y2, uint16_t color),
//     fillTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1,
//       int16_t x2, int16_t y2, uint16_t color),
//     drawRoundRect(int16_t x0, int16_t y0, int16_t w, int16_t h,
//       int16_t radius, uint16_t color),
//     fillRoundRect(int16_t x0, int16_t y0, int16_t w, int16_t h,
//       int16_t radius, uint16_t color),
//     drawBitmap(int16_t x, int16_t y, const uint8_t bitmap[],
//       int16_t w, int16_t h, uint16_t color),
//     drawBitmap(int16_t x, int16_t y, const uint8_t bitmap[],
//       int16_t w, int16_t h, uint16_t color, uint16_t bg),
//     drawBitmap(int16_t x, int16_t y, uint8_t *bitmap,
//       int16_t w, int16_t h, uint16_t color),
//     drawBitmap(int16_t x, int16_t y, uint8_t *bitmap,
//       int16_t w, int16_t h, uint16_t color, uint16_t bg),
//     drawXBitmap(int16_t x, int16_t y, const uint8_t bitmap[],
//       int16_t w, int16_t h, uint16_t color),
//     drawGrayscaleBitmap(int16_t x, int16_t y, const uint8_t bitmap[],
//       int16_t w, int16_t h),
//     drawGrayscaleBitmap(int16_t x, int16_t y, uint8_t *bitmap,
//       int16_t w, int16_t h),
//     drawGrayscaleBitmap(int16_t x, int16_t y,
//       const uint8_t bitmap[], const uint8_t mask[],
//       int16_t w, int16_t h),
//     drawGrayscaleBitmap(int16_t x, int16_t y,
//       uint8_t *bitmap, uint8_t *mask, int16_t w, int16_t h),
//     drawRGBBitmap(int16_t x, int16_t y, const uint16_t bitmap[],
//       int16_t w, int16_t h),
//     drawRGBBitmap(int16_t x, int16_t y, uint16_t *bitmap,
//       int16_t w, int16_t h),
//     drawRGBBitmap(int16_t x, int16_t y,
//       const uint16_t bitmap[], const uint8_t mask[],
//       int16_t w, int16_t h),
//     drawRGBBitmap(int16_t x, int16_t y,
//       uint16_t *bitmap, uint8_t *mask, int16_t w, int16_t h),
//     drawChar(int16_t x, int16_t y, unsigned char c, uint16_t color,
//       uint16_t bg, uint8_t size),
//     drawChar(int16_t x, int16_t y, unsigned char c, uint16_t color,
// 	      uint16_t bg, uint8_t size_x, uint8_t size_y),
//     getTextBounds(const char *string, int16_t x, int16_t y,
//       int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h),
//     getTextBounds(const __FlashStringHelper *s, int16_t x, int16_t y,
//       int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h),
//     getTextBounds(const String &str, int16_t x, int16_t y,
//       int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h),
//     setTextSize(uint8_t s),
//     setTextSize(uint8_t sx, uint8_t sy),
//     setFont(const BMCGFXfont *f = NULL);

//   int16_t strPixelLen(const char * str){
//     if(!str){
//       return 0;
//     }
//     int16_t x1, y1;
// 		uint16_t w1, h1;
// 		getTextBounds(str, cursor_x, cursor_y, &x1, &y1, &w1, &h1);
//     return w1;
//   }
//   BMCTextPixelSize strPixelSize(const char * str){
//     BMCTextPixelSize t;
//     if(!str){
//       return t;
//     }
// 		getTextBounds(str, cursor_x, cursor_y, &t.x, &t.y, &t.w, &t.h);
//     return t;
//   }

//   BMCTextPixelSize strPixelSize(const char * str, uint16_t t_x, uint16_t t_y){
//     BMCTextPixelSize t;
//     if(!str){
//       return t;
//     }
// 		getTextBounds(str, t_x, t_y, &t.x, &t.y, &t.w, &t.h);
//     return t;
//   }

//   /**********************************************************************/
//   /*!
//     @brief  Set text cursor location
//     @param  x    X coordinate in pixels
//     @param  y    Y coordinate in pixels
//   */
//   /**********************************************************************/
//   void setCursor(int16_t x, int16_t y) { cursor_x = x; cursor_y = y; }

//   /**********************************************************************/
//   /*!
//     @brief   Set text font color with transparant background
//     @param   c   16-bit 5-6-5 Color to draw text with
//     @note    For 'transparent' background, background and foreground
//              are set to same color rather than using a separate flag.
//   */
//   /**********************************************************************/
//   void setTextColor(uint16_t c) { textcolor = textbgcolor = c; }

//   /**********************************************************************/
//   /*!
//     @brief   Set text font color with custom background color
//     @param   c   16-bit 5-6-5 Color to draw text with
//     @param   bg  16-bit 5-6-5 Color to draw background/fill with
//   */
//   /**********************************************************************/
//   void setTextColor(uint16_t c, uint16_t bg) {
//     textcolor   = c;
//     textbgcolor = bg;
//   }

//   /**********************************************************************/
//   /*!
//   @brief  Set whether text that is too long for the screen width should
//           automatically wrap around to the next line (else clip right).
//   @param  w  true for wrapping, false for clipping
//   */
//   /**********************************************************************/
//   void setTextWrap(boolean w) { wrap = w; }

//   /**********************************************************************/
//   /*!
//     @brief  Enable (or disable) Code Layer 437-compatible charset.
//             There was an error in glcdfont.c for the longest time -- one
//             character (#176, the 'light shade' block) was missing -- this
//             threw off the index of every character that followed it.
//             But a TON of code has been written with the erroneous
//             character indices. By default, the library uses the original
//             'wrong' behavior and old sketches will still work. Pass
//             'true' to this function to use correct CP437 character values
//             in your code.
//     @param  x  true = enable (new behavior), false = disable (old behavior)
//   */
//   /**********************************************************************/
//   void cp437(boolean x=true) { _cp437 = x; }

// #if ARDUINO >= 100
//   virtual size_t write(uint8_t);
// #else
//   virtual void   write(uint8_t);
// #endif

//   /************************************************************************/
//   /*!
//     @brief      Get width of the display, accounting for current rotation
//     @returns    Width in pixels
//   */
//   /************************************************************************/
//   int16_t width(void) const { return _width; };

//   /************************************************************************/
//   /*!
//     @brief      Get height of the display, accounting for current rotation
//     @returns    Height in pixels
//   */
//   /************************************************************************/
//   int16_t height(void) const { return _height; }

//   /************************************************************************/
//   /*!
//     @brief      Get rotation setting for display
//     @returns    0 thru 3 corresponding to 4 cardinal rotations
//   */
//   /************************************************************************/
//   uint8_t getRotation(void) const { return rotation; }

//   // get current cursor position (get rotation safe maximum values,
//   // using: width() for x, height() for y)
//   /************************************************************************/
//   /*!
//     @brief  Get text cursor X location
//     @returns    X coordinate in pixels
//   */
//   /************************************************************************/
//   int16_t getCursorX(void) const { return cursor_x; }

//   /************************************************************************/
//   /*!
//     @brief      Get text cursor Y location
//     @returns    Y coordinate in pixels
//   */
//   /************************************************************************/
//   int16_t getCursorY(void) const { return cursor_y; };

  

//  protected:
//   void
//     charBounds(char c, int16_t *x, int16_t *y,
//       int16_t *minx, int16_t *miny, int16_t *maxx, int16_t *maxy);
//   int16_t
//     WIDTH,          ///< This is the 'raw' display width - never changes
//     HEIGHT;         ///< This is the 'raw' display height - never changes
//   int16_t
//     _width,         ///< Display width as modified by current rotation
//     _height,        ///< Display height as modified by current rotation
//     cursor_x,       ///< x location to start print()ing text
//     cursor_y;       ///< y location to start print()ing text
//   uint16_t
//     textcolor,      ///< 16-bit background color for print()
//     textbgcolor;    ///< 16-bit text color for print()
//   uint8_t
//     textsize_x,      ///< Desired magnification in X-axis of text to print()
//     textsize_y,      ///< Desired magnification in Y-axis of text to print()
//     rotation;       ///< Display rotation (0 thru 3)
//   boolean
//     wrap,           ///< If set, 'wrap' text at right edge of display
//     _cp437;         ///< If set, use correct CP437 charset (default is off)
//   BMCGFXfont
//     *gfxFont;       ///< Pointer to special font
// };


// /// A simple drawn button UI element
// class BMCGFX_Button {

//  public:
//   BMCGFX_Button(void);
//   // "Classic" initButton() uses center & size
//   void initButton(BMCGFX *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);
//   void initButton(BMCGFX *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);
//   // New/alt initButton() uses upper-left corner & size
//   void initButtonUL(BMCGFX *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);
//   void initButtonUL(BMCGFX *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);
//   void drawButton(boolean inverted = false);
//   boolean contains(int16_t x, int16_t y);

//   /**********************************************************************/
//   /*!
//     @brief    Sets button state, should be done by some touch function
//     @param    p  True for pressed, false for not.
//   */
//   /**********************************************************************/
//   void press(boolean p) { laststate = currstate; currstate = p; }

//   boolean justPressed();
//   boolean justReleased();

//   /**********************************************************************/
//   /*!
//     @brief    Query whether the button is currently pressed
//     @returns  True if pressed
//   */
//   /**********************************************************************/
//   boolean isPressed(void) { return currstate; };

//  private:
//   BMCGFX *_gfx;
//   int16_t       _x1, _y1; // Coordinates of top-left corner
//   uint16_t      _w, _h;
//   uint8_t       _textsize_x;
//   uint8_t       _textsize_y;
//   uint16_t      _outlinecolor, _fillcolor, _textcolor;
//   char          _label[10];

//   boolean currstate, laststate;
// };


// /// A GFX 1-bit canvas context for graphics
// class BMCGFXcanvas1 : public BMCGFX {
//  public:
//   BMCGFXcanvas1(uint16_t w, uint16_t h);
//   ~BMCGFXcanvas1(void);
//   void     drawPixel(int16_t x, int16_t y, uint16_t color),
//            fillScreen(uint16_t color);
//   /**********************************************************************/
//   /*!
//     @brief    Get a pointer to the internal buffer memory
//     @returns  A pointer to the allocated buffer
//   */
//   /**********************************************************************/
//   uint8_t *getBuffer(void) const { return buffer; }
//  private:
//   uint8_t *buffer;
// };


// /// A GFX 8-bit canvas context for graphics
// class BMCGFXcanvas8 : public BMCGFX {
//  public:
//   BMCGFXcanvas8(uint16_t w, uint16_t h);
//   ~BMCGFXcanvas8(void);
//   void     drawPixel(int16_t x, int16_t y, uint16_t color),
//            fillScreen(uint16_t color),
//            writeFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color);
//   /**********************************************************************/
//   /*!
//    @brief    Get a pointer to the internal buffer memory
//    @returns  A pointer to the allocated buffer
//   */
//   /**********************************************************************/
//   uint8_t *getBuffer(void) const { return buffer; }
//  private:
//   uint8_t *buffer;
// };


// ///  A GFX 16-bit canvas context for graphics
// class BMCGFXcanvas16 : public BMCGFX {
//  public:
//   BMCGFXcanvas16(uint16_t w, uint16_t h);
//   ~BMCGFXcanvas16(void);
//   void      drawPixel(int16_t x, int16_t y, uint16_t color),
//             fillScreen(uint16_t color),
//             byteSwap(void);
//   /**********************************************************************/
//   /*!
//     @brief    Get a pointer to the internal buffer memory
//     @returns  A pointer to the allocated buffer
//   */
//   /**********************************************************************/
//   uint16_t *getBuffer(void) const { return buffer; }
//  private:
//   uint16_t *buffer;
// };

// #endif // BMC_GFX_H
