noisymime
/
Arduino
mirror of https://github.com/noisymime/Arduino.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Latest Adafruit_GFX fixes + moved GFX lib to utility folder 

Updated constructor and dependent code, other minor fixes. Robot LCD
examples all compile, but not yet tested against actual hardware.
This commit is contained in:
Phillip Burgess 2013-09-03 11:44:08 -07:00
parent 0f0d5fe01e
commit a06ccb7f1c
4 changed files with 167 additions and 164 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
libraries/Robot_Control/Arduino_LCD.cpp
View File

@ -25,8 +25,9 @@
// Constructor when using software SPI. All output pins are configurable. // Constructor when using software SPI. All output pins are configurable.
Arduino_LCD::Arduino_LCD(uint8_t cs, uint8_t rs, uint8_t sid, Arduino_LCD::Arduino_LCD(uint8_t cs, uint8_t rs, uint8_t sid, uint8_t sclk,
uint8_t sclk, uint8_t rst) { uint8_t rst) : Adafruit_GFX(ILI9163C_TFTWIDTH, ILI9163C_TFTHEIGHT)
{
_cs = cs; _cs = cs;
_rs = rs; _rs = rs;
_sid = sid; _sid = sid;
@ -38,7 +39,8 @@ Arduino_LCD::Arduino_LCD(uint8_t cs, uint8_t rs, uint8_t sid,
// Constructor when using hardware SPI. Faster, but must use SPI pins // Constructor when using hardware SPI. Faster, but must use SPI pins
// specific to each board type (e.g. 11,13 for Uno, 51,52 for Mega, etc.) // specific to each board type (e.g. 11,13 for Uno, 51,52 for Mega, etc.)
Arduino_LCD::Arduino_LCD(uint8_t cs, uint8_t rs, uint8_t rst) { Arduino_LCD::Arduino_LCD(uint8_t cs, uint8_t rs, uint8_t rst) :
Adafruit_GFX(ILI9163C_TFTWIDTH, ILI9163C_TFTHEIGHT) {
_cs = cs; _cs = cs;
_rs = rs; _rs = rs;
_rst = rst; _rst = rst;
@ -325,8 +327,7 @@ void Arduino_LCD::commandList(uint8_t *addr) {
//void Arduino_LCD::commonInit(prog_uchar *cmdList) { //void Arduino_LCD::commonInit(prog_uchar *cmdList) {
void Arduino_LCD::commonInit(uint8_t *cmdList) { void Arduino_LCD::commonInit(uint8_t *cmdList) {
constructor(ILI9163C_TFTWIDTH, ILI9163C_TFTHEIGHT); colstart = rowstart = 0; // May be overridden in init func
colstart = rowstart = 0; // May be overridden in init func
pinMode(_rs, OUTPUT); pinMode(_rs, OUTPUT);
pinMode(_cs, OUTPUT); pinMode(_cs, OUTPUT);

2
libraries/Robot_Control/Arduino_LCD.h
View File

@ -25,7 +25,7 @@
#else #else
#include "WProgram.h" #include "WProgram.h"
#endif #endif
#include "Adafruit_GFX.h" #include "utility/Adafruit_GFX.h"
//#include <avr/pgmspace.h> //#include <avr/pgmspace.h>
// some flags for initR() :( // some flags for initR() :(

206
libraries/Robot_Control/Adafruit_GFX.cpp → libraries/Robot_Control/utility/Adafruit_GFX.cpp
View File

@ -1,53 +1,69 @@
/****************************************************************** /*
This is the core graphics library for all our displays, providing This is the core graphics library for all our displays, providing a common
basic graphics primitives (points, lines, circles, etc.). It needs set of graphics primitives (points, lines, circles, etc.). It needs to be
to be paired with a hardware-specific library for each display paired with a hardware-specific library for each display device we carry
device we carry (handling the lower-level functions). (to handle the lower-level functions).
Adafruit invests time and resources providing this open Adafruit invests time and resources providing this open source code, please
source code, please support Adafruit and open-source hardware support Adafruit & open-source hardware by purchasing products from Adafruit!
by purchasing products from Adafruit!
Copyright (c) 2013 Adafruit Industries. All rights reserved.
Written by Limor Fried/Ladyada for Adafruit Industries.
BSD license, check license.txt for more information. Redistribution and use in source and binary forms, with or without
All text above must be included in any redistribution. 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 "Adafruit_GFX.h"
#include "glcdfont.c" #include "glcdfont.c"
#include <avr/pgmspace.h> #ifdef __AVR__
#include <avr/pgmspace.h>
#else
#define pgm_read_byte(addr) (*(const unsigned char *)(addr))
#endif
void Adafruit_GFX::constructor(int16_t w, int16_t h) { Adafruit_GFX::Adafruit_GFX(int16_t w, int16_t h):
_width = WIDTH = w; WIDTH(w), HEIGHT(h)
_height = HEIGHT = h; {
_width = WIDTH;
rotation = 0; _height = HEIGHT;
cursor_y = cursor_x = 0; rotation = 0;
textsize = 1; cursor_y = cursor_x = 0;
textsize = 1;
textcolor = textbgcolor = 0xFFFF; textcolor = textbgcolor = 0xFFFF;
wrap = true; wrap = true;
strokeColor = 0;
useStroke = true;
fillColor = 0;
useFill = false;
} }
// Draw a circle outline
// draw a circle outline void Adafruit_GFX::drawCircle(int16_t x0, int16_t y0, int16_t r,
void Adafruit_GFX::drawCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color) {
uint16_t color) {
int16_t f = 1 - r; int16_t f = 1 - r;
int16_t ddF_x = 1; int16_t ddF_x = 1;
int16_t ddF_y = -2 * r; int16_t ddF_y = -2 * r;
int16_t x = 0; int16_t x = 0;
int16_t y = r; int16_t y = r;
drawPixel(x0, y0+r, color); drawPixel(x0 , y0+r, color);
drawPixel(x0, y0-r, color); drawPixel(x0 , y0-r, color);
drawPixel(x0+r, y0, color); drawPixel(x0+r, y0 , color);
drawPixel(x0-r, y0, color); drawPixel(x0-r, y0 , color);
while (x<y) { while (x<y) {
if (f >= 0) { if (f >= 0) {
@ -67,7 +83,6 @@ void Adafruit_GFX::drawCircle(int16_t x0, int16_t y0, int16_t r,
drawPixel(x0 - y, y0 + x, color); drawPixel(x0 - y, y0 + x, color);
drawPixel(x0 + y, y0 - x, color); drawPixel(x0 + y, y0 - x, color);
drawPixel(x0 - y, y0 - x, color); drawPixel(x0 - y, y0 - x, color);
} }
} }
@ -107,15 +122,15 @@ void Adafruit_GFX::drawCircleHelper( int16_t x0, int16_t y0,
} }
} }
void Adafruit_GFX::fillCircle(int16_t x0, int16_t y0, int16_t r, void Adafruit_GFX::fillCircle(int16_t x0, int16_t y0, int16_t r,
uint16_t color) { uint16_t color) {
drawFastVLine(x0, y0-r, 2*r+1, color); drawFastVLine(x0, y0-r, 2*r+1, color);
fillCircleHelper(x0, y0, r, 3, 0, color); fillCircleHelper(x0, y0, r, 3, 0, color);
} }
// used to do circles and roundrects! // Used to do circles and roundrects
void Adafruit_GFX::fillCircleHelper(int16_t x0, int16_t y0, int16_t r, void Adafruit_GFX::fillCircleHelper(int16_t x0, int16_t y0, int16_t r,
uint8_t cornername, int16_t delta, uint16_t color) { uint8_t cornername, int16_t delta, uint16_t color) {
int16_t f = 1 - r; int16_t f = 1 - r;
int16_t ddF_x = 1; int16_t ddF_x = 1;
@ -144,9 +159,9 @@ void Adafruit_GFX::fillCircleHelper(int16_t x0, int16_t y0, int16_t r,
} }
} }
// bresenham's algorithm - thx wikpedia // Bresenham's algorithm - thx wikpedia
void Adafruit_GFX::drawLine(int16_t x0, int16_t y0, void Adafruit_GFX::drawLine(int16_t x0, int16_t y0,
int16_t x1, int16_t y1, int16_t x1, int16_t y1,
uint16_t color) { uint16_t color) {
int16_t steep = abs(y1 - y0) > abs(x1 - x0); int16_t steep = abs(y1 - y0) > abs(x1 - x0);
if (steep) { if (steep) {
@ -186,10 +201,9 @@ void Adafruit_GFX::drawLine(int16_t x0, int16_t y0,
} }
} }
// Draw a rectangle
// draw a rectangle void Adafruit_GFX::drawRect(int16_t x, int16_t y,
void Adafruit_GFX::drawRect(int16_t x, int16_t y, int16_t w, int16_t h,
int16_t w, int16_t h,
uint16_t color) { uint16_t color) {
drawFastHLine(x, y, w, color); drawFastHLine(x, y, w, color);
drawFastHLine(x, y+h-1, w, color); drawFastHLine(x, y+h-1, w, color);
@ -197,40 +211,38 @@ void Adafruit_GFX::drawRect(int16_t x, int16_t y,
drawFastVLine(x+w-1, y, h, color); drawFastVLine(x+w-1, y, h, color);
} }
void Adafruit_GFX::drawFastVLine(int16_t x, int16_t y, void Adafruit_GFX::drawFastVLine(int16_t x, int16_t y,
int16_t h, uint16_t color) { int16_t h, uint16_t color) {
// stupidest version - update in subclasses if desired! // Update in subclasses if desired!
drawLine(x, y, x, y+h-1, color); drawLine(x, y, x, y+h-1, color);
} }
void Adafruit_GFX::drawFastHLine(int16_t x, int16_t y,
void Adafruit_GFX::drawFastHLine(int16_t x, int16_t y,
int16_t w, uint16_t color) { int16_t w, uint16_t color) {
// stupidest version - update in subclasses if desired! // Update in subclasses if desired!
drawLine(x, y, x+w-1, y, color); drawLine(x, y, x+w-1, y, color);
} }
void Adafruit_GFX::fillRect(int16_t x, int16_t y, int16_t w, int16_t h, void Adafruit_GFX::fillRect(int16_t x, int16_t y, int16_t w, int16_t h,
uint16_t color) { uint16_t color) {
// stupidest version - update in subclasses if desired! // Update in subclasses if desired!
for (int16_t i=x; i<x+w; i++) { for (int16_t i=x; i<x+w; i++) {
drawFastVLine(i, y, h, color); drawFastVLine(i, y, h, color);
} }
} }
void Adafruit_GFX::fillScreen(uint16_t color) { void Adafruit_GFX::fillScreen(uint16_t color) {
fillRect(0, 0, _width, _height, color); fillRect(0, 0, _width, _height, color);
} }
// draw a rounded rectangle! // Draw a rounded rectangle
void Adafruit_GFX::drawRoundRect(int16_t x, int16_t y, int16_t w, void Adafruit_GFX::drawRoundRect(int16_t x, int16_t y, int16_t w,
int16_t h, int16_t r, uint16_t color) { int16_t h, int16_t r, uint16_t color) {
// smarter version // smarter version
drawFastHLine(x+r , y , w-2*r, color); // Top drawFastHLine(x+r , y , w-2*r, color); // Top
drawFastHLine(x+r , y+h-1, w-2*r, color); // Bottom drawFastHLine(x+r , y+h-1, w-2*r, color); // Bottom
drawFastVLine( x , y+r , h-2*r, color); // Left drawFastVLine(x , y+r , h-2*r, color); // Left
drawFastVLine( x+w-1, y+r , h-2*r, color); // Right drawFastVLine(x+w-1, y+r , h-2*r, color); // Right
// draw four corners // draw four corners
drawCircleHelper(x+r , y+r , r, 1, color); drawCircleHelper(x+r , y+r , r, 1, color);
drawCircleHelper(x+w-r-1, y+r , r, 2, color); drawCircleHelper(x+w-r-1, y+r , r, 2, color);
@ -238,7 +250,7 @@ void Adafruit_GFX::drawRoundRect(int16_t x, int16_t y, int16_t w,
drawCircleHelper(x+r , y+h-r-1, r, 8, color); drawCircleHelper(x+r , y+h-r-1, r, 8, color);
} }
// fill a rounded rectangle! // Fill a rounded rectangle
void Adafruit_GFX::fillRoundRect(int16_t x, int16_t y, int16_t w, void Adafruit_GFX::fillRoundRect(int16_t x, int16_t y, int16_t w,
int16_t h, int16_t r, uint16_t color) { int16_t h, int16_t r, uint16_t color) {
// smarter version // smarter version
@ -249,18 +261,18 @@ void Adafruit_GFX::fillRoundRect(int16_t x, int16_t y, int16_t w,
fillCircleHelper(x+r , y+r, r, 2, h-2*r-1, color); fillCircleHelper(x+r , y+r, r, 2, h-2*r-1, color);
} }
// draw a triangle! // Draw a triangle
void Adafruit_GFX::drawTriangle(int16_t x0, int16_t y0, void Adafruit_GFX::drawTriangle(int16_t x0, int16_t y0,
int16_t x1, int16_t y1, int16_t x1, int16_t y1,
int16_t x2, int16_t y2, uint16_t color) { int16_t x2, int16_t y2, uint16_t color) {
drawLine(x0, y0, x1, y1, color); drawLine(x0, y0, x1, y1, color);
drawLine(x1, y1, x2, y2, color); drawLine(x1, y1, x2, y2, color);
drawLine(x2, y2, x0, y0, color); drawLine(x2, y2, x0, y0, color);
} }
// fill a triangle! // Fill a triangle
void Adafruit_GFX::fillTriangle ( int16_t x0, int16_t y0, void Adafruit_GFX::fillTriangle ( int16_t x0, int16_t y0,
int16_t x1, int16_t y1, int16_t x1, int16_t y1,
int16_t x2, int16_t y2, uint16_t color) { int16_t x2, int16_t y2, uint16_t color) {
int16_t a, b, y, last; int16_t a, b, y, last;
@ -336,7 +348,7 @@ void Adafruit_GFX::fillTriangle ( int16_t x0, int16_t y0,
} }
} }
void Adafruit_GFX::drawBitmap(int16_t x, int16_t y, void Adafruit_GFX::drawBitmap(int16_t x, int16_t y,
const uint8_t *bitmap, int16_t w, int16_t h, const uint8_t *bitmap, int16_t w, int16_t h,
uint16_t color) { uint16_t color) {
@ -351,7 +363,6 @@ void Adafruit_GFX::drawBitmap(int16_t x, int16_t y,
} }
} }
#if ARDUINO >= 100 #if ARDUINO >= 100
size_t Adafruit_GFX::write(uint8_t c) { size_t Adafruit_GFX::write(uint8_t c) {
#else #else
@ -359,7 +370,7 @@ void Adafruit_GFX::write(uint8_t c) {
#endif #endif
if (c == '\n') { if (c == '\n') {
cursor_y += textsize*8; cursor_y += textsize*8;
cursor_x = 0; cursor_x = 0;
} else if (c == '\r') { } else if (c == '\r') {
// skip em // skip em
} else { } else {
@ -375,13 +386,13 @@ void Adafruit_GFX::write(uint8_t c) {
#endif #endif
} }
// draw a character // Draw a character
void Adafruit_GFX::drawChar(int16_t x, int16_t y, unsigned char c, void Adafruit_GFX::drawChar(int16_t x, int16_t y, unsigned char c,
uint16_t color, uint16_t bg, uint8_t size) { uint16_t color, uint16_t bg, uint8_t size) {
if((x >= _width) || // Clip right if((x >= _width) || // Clip right
(y >= _height) || // Clip bottom (y >= _height) || // Clip bottom
((x + 5 * size - 1) < 0) || // Clip left ((x + 6 * size - 1) < 0) || // Clip left
((y + 8 * size - 1) < 0)) // Clip top ((y + 8 * size - 1) < 0)) // Clip top
return; return;
@ -403,7 +414,7 @@ void Adafruit_GFX::drawChar(int16_t x, int16_t y, unsigned char c,
drawPixel(x+i, y+j, bg); drawPixel(x+i, y+j, bg);
else { // big size else { // big size
fillRect(x+i*size, y+j*size, size, size, bg); fillRect(x+i*size, y+j*size, size, size, bg);
} }
} }
line >>= 1; line >>= 1;
} }
@ -415,71 +426,62 @@ void Adafruit_GFX::setCursor(int16_t x, int16_t y) {
cursor_y = y; cursor_y = y;
} }
void Adafruit_GFX::setTextSize(uint8_t s) { void Adafruit_GFX::setTextSize(uint8_t s) {
textsize = (s > 0) ? s : 1; textsize = (s > 0) ? s : 1;
} }
void Adafruit_GFX::setTextColor(uint16_t c) { void Adafruit_GFX::setTextColor(uint16_t c) {
textcolor = c; // For 'transparent' background, we'll set the bg
textbgcolor = c;
// for 'transparent' background, we'll set the bg
// to the same as fg instead of using a flag // to the same as fg instead of using a flag
textcolor = textbgcolor = c;
} }
void Adafruit_GFX::setTextColor(uint16_t c, uint16_t b) { void Adafruit_GFX::setTextColor(uint16_t c, uint16_t b) {
textcolor = c; textcolor = c;
textbgcolor = b; textbgcolor = b;
} }
void Adafruit_GFX::setTextWrap(boolean w) { void Adafruit_GFX::setTextWrap(boolean w) {
wrap = w; wrap = w;
} }
uint8_t Adafruit_GFX::getRotation(void) { uint8_t Adafruit_GFX::getRotation(void) {
rotation %= 4;
return rotation; return rotation;
} }
void Adafruit_GFX::setRotation(uint8_t x) { void Adafruit_GFX::setRotation(uint8_t x) {
x %= 4; // cant be higher than 3 rotation = (x & 3);
rotation = x; switch(rotation) {
switch (x) { case 0:
case 0: case 2:
case 2: _width = WIDTH;
_width = WIDTH;
_height = HEIGHT; _height = HEIGHT;
break; break;
case 1: case 1:
case 3: case 3:
_width = HEIGHT; _width = HEIGHT;
_height = WIDTH; _height = WIDTH;
break; break;
} }
} }
void Adafruit_GFX::invertDisplay(boolean i) { // Return the size of the display (per current rotation)
// do nothing, can be subclassed int16_t Adafruit_GFX::width(void) {
} return _width;
// return the size of the display which depends on the rotation!
int16_t Adafruit_GFX::width(void) {
return _width;
} }
int16_t Adafruit_GFX::height(void) { int16_t Adafruit_GFX::height(void) {
return _height; return _height;
} }
void Adafruit_GFX::invertDisplay(boolean i) {
// Do nothing, must be subclassed if supported
}
uint16_t Adafruit_GFX::newColor(uint8_t r, uint8_t g, uint8_t b) { uint16_t Adafruit_GFX::newColor(uint8_t r, uint8_t g, uint8_t b) {
return ((r & 0xF8) << 8) | ((g & 0xFC) << 3) | (b >> 3); return ((r & 0xF8) << 8) | ((g & 0xFC) << 3) | (b >> 3);
} }
void Adafruit_GFX::background(uint8_t red, uint8_t green, uint8_t blue) { void Adafruit_GFX::background(uint8_t red, uint8_t green, uint8_t blue) {
background(newColor(red, green, blue)); background(newColor(red, green, blue));
} }

112
libraries/Robot_Control/Adafruit_GFX.h → libraries/Robot_Control/utility/Adafruit_GFX.h
View File

@ -41,61 +41,59 @@ typedef uint16_t color;
class Adafruit_GFX : public Print { class Adafruit_GFX : public Print {
public: public:
//Adafruit_GFX(); Adafruit_GFX(int16_t w, int16_t h); // Constructor
// i have no idea why we have to formally call the constructor. kinda sux
void constructor(int16_t w, int16_t h);
// this must be defined by the subclass // This MUST be defined by the subclass:
virtual void drawPixel(int16_t x, int16_t y, uint16_t color); virtual void drawPixel(int16_t x, int16_t y, uint16_t color) = 0;
virtual void invertDisplay(boolean i);
// these are 'generic' drawing functions, so we can share them! // These MAY be overridden by the subclass to provide device-specific
virtual void drawLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1, // optimized code. Otherwise 'generic' versions are used.
uint16_t color); virtual void
virtual void drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color); drawLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t color),
virtual void drawFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color); drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color),
virtual void drawRect(int16_t x, int16_t y, int16_t w, int16_t h, drawFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color),
uint16_t color); drawRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color),
virtual void fillRect(int16_t x, int16_t y, int16_t w, int16_t h, fillRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color),
uint16_t color); fillScreen(uint16_t color),
virtual void fillScreen(uint16_t color); invertDisplay(boolean i);
void drawCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color); // These exist only with Adafruit_GFX (no subclass overrides)
void drawCircleHelper(int16_t x0, int16_t y0, void
int16_t r, uint8_t cornername, uint16_t color); drawCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color),
void fillCircle(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,
void fillCircleHelper(int16_t x0, int16_t y0, int16_t r, uint16_t color),
uint8_t cornername, int16_t delta, 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),
drawChar(int16_t x, int16_t y, unsigned char c, uint16_t color,
uint16_t bg, uint8_t size),
setCursor(int16_t x, int16_t y),
setTextColor(uint16_t c),
setTextColor(uint16_t c, uint16_t bg),
setTextSize(uint8_t s),
setTextWrap(boolean w),
setRotation(uint8_t r);
void drawTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1,
int16_t x2, int16_t y2, uint16_t color);
void fillTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1,
int16_t x2, int16_t y2, uint16_t color);
void drawRoundRect(int16_t x0, int16_t y0, int16_t w, int16_t h,
int16_t radius, uint16_t color);
void fillRoundRect(int16_t x0, int16_t y0, int16_t w, int16_t h,
int16_t radius, uint16_t color);
void drawBitmap(int16_t x, int16_t y,
const uint8_t *bitmap, int16_t w, int16_t h,
uint16_t color);
void drawChar(int16_t x, int16_t y, unsigned char c,
uint16_t color, uint16_t bg, uint8_t size);
#if ARDUINO >= 100 #if ARDUINO >= 100
virtual size_t write(uint8_t); virtual size_t write(uint8_t);
#else #else
virtual void write(uint8_t); virtual void write(uint8_t);
#endif #endif
void setCursor(int16_t x, int16_t y);
void setTextColor(uint16_t c);
void setTextColor(uint16_t c, uint16_t bg);
void setTextSize(uint8_t s);
void setTextWrap(boolean w);
int16_t height(void); int16_t
int16_t width(void); height(void),
width(void);
void setRotation(uint8_t r);
uint8_t getRotation(void); uint8_t getRotation(void);
@ -166,14 +164,19 @@ class Adafruit_GFX : public Print {
// void image(PImage & img, uint16_t x, uint16_t y); // void image(PImage & img, uint16_t x, uint16_t y);
protected: protected:
int16_t WIDTH, HEIGHT; // this is the 'raw' display w/h - never changes const int16_t
int16_t _width, _height; // dependent on rotation WIDTH, HEIGHT; // This is the 'raw' display w/h - never changes
int16_t cursor_x, cursor_y; int16_t
uint16_t textcolor, textbgcolor; _width, _height, // Display w/h as modified by current rotation
uint8_t textsize; cursor_x, cursor_y;
uint8_t rotation; uint16_t
boolean wrap; // If set, 'wrap' text at right edge of display textcolor, textbgcolor;
uint8_t
textsize,
rotation;
boolean
wrap; // If set, 'wrap' text at right edge of display
/* /*
* Processing-style graphics state * Processing-style graphics state
*/ */
@ -184,7 +187,4 @@ class Adafruit_GFX : public Print {
bool useFill; bool useFill;
}; };
#endif // _ADAFRUIT_GFX_H
#endif