// used to do circles and roundrects!
void Adafruit_GFX::fillCircleHelper(int16 x0, int16 y0, int16 r,
uint8 cornername, int16 delta, uint32 color) {
int16 f = 1 - r;
int16 ddF_x = 1;
int16 ddF_y = -2 * r;
int16 x = 0;
int16 y = r;
while (x<y) {
if (f >= 0) {
y--;
ddF_y += 2;
f += ddF_y;
}
x++;
ddF_x += 2;
f += ddF_x;
if (cornername & 0x1) {
drawFastVLine(x0+x, y0-y, 2*y+1+delta, color);
drawFastVLine(x0+y, y0-x, 2*x+1+delta, color);
}
if (cornername & 0x2) {
drawFastVLine(x0-x, y0-y, 2*y+1+delta, color);
drawFastVLine(x0-y, y0-x, 2*x+1+delta, color);
}
}
}
void FramebufferGFX::fillCircleHelper(int16_t x0, int16_t y0, int16_t r, uint8_t cornername, int16_t delta, uint16_t color) {
// From Adafruit library
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 & 0x1) {
drawFastVLine(x0+x, y0-y, 2*y+1+delta, color);
drawFastVLine(x0+y, y0-x, 2*x+1+delta, color);
}
if (cornername & 0x2) {
drawFastVLine(x0-x, y0-y, 2*y+1+delta, color);
drawFastVLine(x0-y, y0-x, 2*x+1+delta, color);
}
}
}
// Rounded rectangles
void FramebufferGFX::drawRoundRect(int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t r, uint16_t color) {
// From Adafruit library (modified)
int16_t w = x1 - x0;
int16_t h = y1 - y0;
int16_t x = x0;
int16_t y = y0;
if (x0 > x1) {
x = x1;
w = -w;
}
if (y0 > y1) {
y = y1;
h = -h;
}
// smarter version
drawFastHLine(x+r , y , w-2*r, color); // Top
drawFastHLine(x+r , y+h-1, w-2*r, color); // Bottom
drawFastVLine(x , y+r , h-2*r, color); // Left
drawFastVLine(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);
}
// Used to do circles and roundrects
ICACHE_FLASH_ATTR void Adafruit_GFX_AS::fillCircleHelper(int16_t x0, int16_t y0, int16_t r,
uint8_t cornername, int16_t delta, uint16_t color) {
int16_t f = 1 - r;
int16_t ddF_x = 1;
int16_t ddF_y = -2 * r;
int16_t x = 0;
int16_t y = r;
while (x<y) {
if (f >= 0) {
y--;
ddF_y += 2;
f += ddF_y;
}
x++;
ddF_x += 2;
f += ddF_x;
if (cornername & 0x1) {
drawFastVLine(x0+x, y0-y, 2*y+1+delta, color);
drawFastVLine(x0+y, y0-x, 2*x+1+delta, color);
}
if (cornername & 0x2) {
drawFastVLine(x0-x, y0-y, 2*y+1+delta, color);
drawFastVLine(x0-y, y0-x, 2*x+1+delta, color);
}
}
}
// used to do circles and roundrects!
void GOFi2cOLED::fillCircleHelper(uint8_t x0, uint8_t y0, uint8_t r,
uint8_t cornername, int16_t delta, uint8_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 & 0x1) {
drawFastVLine(x0+x, y0-y, 2*y+1+delta, color);
drawFastVLine(x0+y, y0-x, 2*x+1+delta, color);
}
if (cornername & 0x2) {
drawFastVLine(x0-x, y0-y, 2*y+1+delta, color);
drawFastVLine(x0-y, y0-x, 2*x+1+delta, color);
}
}
}
// Draw a rectangle
void Adafruit_GFX::drawRect(int16_t x, int16_t y, int16_t w, int16_t h,
uint16_t color) {
drawFastHLine(x, y, w, color);
drawFastHLine(x, y+h-1, w, color);
drawFastVLine(x, y, h, color);
drawFastVLine(x+w-1, y, h, color);
}
// draw a rectangle
void Adafruit_GFX::drawRect(int16 x, int16 y,
int16 w, int16 h,
uint32 color) {
drawFastHLine(x, y, w, color);
drawFastHLine(x, y+h-1, w, color);
drawFastVLine(x, y, h, color);
drawFastVLine(x+w-1, y, h, color);
}
// draw a rectangle
void GOFi2cOLED::drawRect(uint8_t x, uint8_t y,
uint8_t w, uint8_t h,
uint8_t color) {
drawFastHLine(x, y, w, color);
drawFastHLine(x, y+h-1, w, color);
drawFastVLine(x, y, h, color);
drawFastVLine(x+w-1, y, h, color);
}
void Arduboy::drawRect
(int16_t x, int16_t y, int16_t w, int16_t h, uint8_t color)
{
drawFastHLine(x, y, w, color);
drawFastHLine(x, y+h-1, w, color);
drawFastVLine(x, y, h, color);
drawFastVLine(x+w-1, y, h, color);
}
void SmartMatrix::drawRoundRectangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1,
uint16_t radius, const rgb24& outlineColor) {
if (x1 < x0)
SWAPint(x1, x0);
if (y1 < y0)
SWAPint(y1, y0);
// decrease large radius that would break shape
if(radius > (x1-x0)/2)
radius = (x1-x0)/2;
if(radius > (y1-y0)/2)
radius = (y1-y0)/2;
int a = radius, b = 0;
int radiusError = 1 - a;
// draw straight part of outline
drawFastHLine(x0 + radius, x1 - radius, y0, outlineColor);
drawFastHLine(x0 + radius, x1 - radius, y1, outlineColor);
drawFastVLine(x0, y0 + radius, y1 - radius, outlineColor);
drawFastVLine(x1, y0 + radius, y1 - radius, outlineColor);
// convert coordinates to point at center of rounded sections
x0 += radius;
x1 -= radius;
y0 += radius;
y1 -= radius;
while (a >= b)
{
// this pair sweeps from far left towards right
drawPixel(-a + x0, -b + y0, outlineColor);
drawPixel(-a + x0, b + y1, outlineColor);
// this pair sweeps from far right towards left
drawPixel(a + x1, -b + y0, outlineColor);
drawPixel(a + x1, b + y1, outlineColor);
// this pair sweeps from very top towards bottom
drawPixel(-b + x0, -a + y0, outlineColor);
drawPixel(b + x1, -a + y0, outlineColor);
// this pair sweeps from bottom up
drawPixel(-b + x0, a + y1, outlineColor);
drawPixel(b + x1, a + y1, outlineColor);
b++;
if (radiusError < 0) {
radiusError += 2 * b + 1;
} else {
a--;
radiusError += 2 * (b - a + 1);
}
}
}
// draw a rounded rectangle!
void GOFi2cOLED::drawRoundRect(uint8_t x, uint8_t y, uint8_t w, uint8_t h, uint8_t r, uint8_t color) {
// smarter version
drawFastHLine(x+r , y , w-2*r, color); // Top
drawFastHLine(x+r , y+h-1, w-2*r, color); // Bottom
drawFastVLine( x , y+r , h-2*r, color); // Left
drawFastVLine( 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);
}
// Draw a rounded rectangle
void Adafruit_GFX_AS::drawRoundRect(int16_t x, int16_t y, int16_t w,
int16_t h, int16_t r, uint16_t color) {
// smarter version
drawFastHLine(x+r , y , w-2*r, color); // Top
drawFastHLine(x+r , y+h-1, w-2*r, color); // Bottom
drawFastVLine(x , y+r , h-2*r, color); // Left
drawFastVLine(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);
}
void Adafruit_GFX_AS::fillRect(int16_t x, int16_t y, int16_t w, int16_t h,
uint16_t color) {
// Update in subclasses if desired!
for (int16_t i=x; i<x+w; i++) {
drawFastVLine(i, y, h, color);
}
}
void Adafruit_GFX::fillRect(int16 x, int16 y, int16 w, int16 h,
uint32 color) {
// stupidest version - update in subclasses if desired!
for (int16 i=x; i<x+w; i++) {
drawFastVLine(i, y, h, color);
}
}
void GOFi2cOLED::fillRect(uint8_t x, uint8_t y, uint8_t w, uint8_t h,
uint8_t color) {
// stupidest version - update in subclasses if desired!
for (uint8_t i=x; i<x+w; i++) {
drawFastVLine(i, y, h, color);
}
}
void fillRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color)
{
// stupidest version - update in subclasses if desired!
for (int16_t i=x; i<x+w; i++)
{
drawFastVLine(i, y, h, color);
}
}
void Arduboy::fillCircleHelper
(
int16_t x0,
int16_t y0,
int16_t r,
uint8_t cornername,
int16_t delta,
uint8_t color
)
{
// used to do circles and roundrects!
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 & 0x1)
{
drawFastVLine(x0+x, y0-y, 2*y+1+delta, color);
drawFastVLine(x0+y, y0-x, 2*x+1+delta, color);
}
if (cornername & 0x2)
{
drawFastVLine(x0-x, y0-y, 2*y+1+delta, color);
drawFastVLine(x0-y, y0-x, 2*x+1+delta, color);
}
}
}
// Rectangles
void FramebufferGFX::drawRect(int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t color) {
int16_t w = x1 - x0;
int16_t h = y1 - y0;
int16_t x = x0;
int16_t y = y0;
if (x0 > x1) {
x = x1;
w = -w;
}
if (y0 > y1) {
y = y1;
h = -h;
}
// (x, y) is lower corner
drawFastHLine(x, y, w, color); // top
drawFastHLine(x, y + h, w, color); // bottom
drawFastVLine(x, y, h, color); // left
drawFastVLine(x + w, y, h, color); // right
}
//*****************************************************************************
void testfastlines(unsigned int color1, unsigned int color2) {
unsigned int x;
unsigned int y;
fillScreen(BLACK);
for (y = 0; y < height() - 1; y += 8) {
drawFastHLine(0, y, width() - 1, color1);
}
delay(100);
for (x = 0; x < width() - 1; x += 8) {
drawFastVLine(x, 0, height() - 1, color2);
}
delay(100);
}
size_t screenkeys::write(uint8_t c){
if (_cursor_x > _width || _cursor_y > _height) return 1;
struct FontHeader header;
memcpy_P(&header, _font, sizeof(FontHeader));
//char too high.
if (_cursor_y+header.height < 0) return 1;
if (_cursor_x > 0) drawLine(_cursor_x - 1,_cursor_y,_cursor_x - 1,(_cursor_y + header.height) - 1, _background);
if(c == '\n') { // Newline
_cursor_y = _cursor_y - header.height - 1;
} else if (c == '\r') {
} else {
//write char and get his heigh!
int charWide = drawChar(_cursor_x, _cursor_y, c, _foreground, _background);
if (charWide > 0) {//char writed, erase following to avoid garbage
#if defined(_PRECLN)
drawFastVLine(_cursor_x + charWide, _cursor_y, _cursor_y + header.height-1, _background);
#endif
}
}
return 1;
}
void screenkeys::fillRect(uint8_t x,uint8_t y,uint8_t w,uint8_t h,bool color) {
uint8_t i;
for (i=x; i<x+w; i++) {
drawFastVLine(i, y, h, color);
}
}
void SmartMatrix::drawRectangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1, const rgb24& color) {
drawFastHLine(x0, x1, y0, color);
drawFastHLine(x0, x1, y1, color);
drawFastVLine(x0, y0, y1, color);
drawFastVLine(x1, y0, y1, color);
}
void SmartMatrix::fillRoundRectangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1,
uint16_t radius, const rgb24& outlineColor, const rgb24& fillColor) {
if (x1 < x0)
SWAPint(x1, x0);
if (y1 < y0)
SWAPint(y1, y0);
// decrease large radius that would break shape
if(radius > (x1-x0)/2)
radius = (x1-x0)/2;
if(radius > (y1-y0)/2)
radius = (y1-y0)/2;
int a = radius, b = 0;
int radiusError = 1 - a;
if (radius == 0) {
fillRectangle(x0, y0, x1, y1, outlineColor, fillColor);
}
// draw straight part of outline
drawFastHLine(x0 + radius, x1 - radius, y0, outlineColor);
drawFastHLine(x0 + radius, x1 - radius, y1, outlineColor);
drawFastVLine(x0, y0 + radius, y1 - radius, outlineColor);
drawFastVLine(x1, y0 + radius, y1 - radius, outlineColor);
// convert coordinates to point at center of rounded sections
x0 += radius;
x1 -= radius;
y0 += radius;
y1 -= radius;
// only draw one line per row/column, skipping the sides
bool hlineDrawn = true;
bool vlineDrawn = true;
while (a >= b)
{
// this pair sweeps from far left towards right
drawPixel(-a + x0, -b + y0, outlineColor);
drawPixel(-a + x0, b + y1, outlineColor);
// this pair sweeps from far right towards left
drawPixel(a + x1, -b + y0, outlineColor);
drawPixel(a + x1, b + y1, outlineColor);
if (!vlineDrawn) {
drawFastVLine(-a + x0, (-b + 1) + y0, (b - 1) + y1, fillColor);
drawFastVLine(a + x1, (-b + 1) + y0, (b - 1) + y1, fillColor);
vlineDrawn = true;
}
// this pair sweeps from very top towards bottom
drawPixel(-b + x0, -a + y0, outlineColor);
drawPixel(b + x1, -a + y0, outlineColor);
// this pair sweeps from bottom up
drawPixel(-b + x0, a + y1, outlineColor);
drawPixel(b + x1, a + y1, outlineColor);
if (!hlineDrawn) {
drawFastHLine((-b + 1) + x0, (b - 1) + x1, -a + y0, fillColor);
drawFastHLine((-b + 1) + x0, (b - 1) + x1, a + y1, fillColor);
hlineDrawn = true;
}
b++;
if (radiusError < 0) {
radiusError += 2 * b + 1;
} else {
a--;
hlineDrawn = false;
vlineDrawn = false;
radiusError += 2 * (b - a + 1);
}
}
// draw rectangle in center
fillRectangle(x0 - a, y0 - a, x1 + a, y1 + a, fillColor);
}
void Adafruit_GFX::fillCircle(int16 x0, int16 y0, int16 r,
uint32 color) {
drawFastVLine(x0, y0-r, 2*r+1, color);
fillCircleHelper(x0, y0, r, 3, 0, color);
}
uint8_t screenkeys::drawChar(uint8_t x,uint8_t y, unsigned char c,bool colour,bool _background){
if (x >= _width || y >= _height) {
return 0;
}
struct FontHeader header;
memcpy_P(&header, (void*)_font, sizeof(FontHeader));
if (c == ' ') {//write an empty
uint8_t charWide = charWidth(' ');
fillRect(x,y-1,x + charWide,y + header.height,_background);
return charWide;
}
//char out of range!
if (c < header.firstChar || c >= (header.firstChar + header.charCount)) {
return 0;
}
uint8_t width = 0;
uint16_t index = 0;
//how many bytes it's a col?
uint8_t bytes = (header.height + 7) / 8;
//calculate char
c -= header.firstChar;
// Fixed Width or Variabile?
if (header.size == 0) {//fixed width
width = header.fixedWidth;
//questo calcola quanto è grande l'indice intero di tutti i bits del font
//lenght of index of all font-bits
index = sizeof(FontHeader) + (c*(bytes * width));
} else {
// variable width font, read width data, to get the index
for (uint8_t i = 0; i < c; i++) {
index += pgm_read_byte(this->_font + sizeof(FontHeader) + i);
}
index = index * bytes + sizeof(FontHeader) + header.charCount;
width = pgm_read_byte(this->_font + sizeof(FontHeader) + c);
}
//char is inside screen?
if (x < -width || y < -header.height) return 0;
//to prevent garbage
#if defined(_PRECLN)
drawFastVLine(x>0?x:0,y>0?y:0,(y+header.height)>(_height-1)?(_height-1):(y+header.height)-1,_background);
#endif
for (int16_t ox = 0; ox < width; ox++) {
if (ox+x >= _width) break;
int16_t oy = 0;
for (int8_t byte_y = bytes-1; byte_y >= 0; byte_y--) {
uint8_t data = pgm_read_byte(this->_font + index + ox + (byte_y * width));
int8_t start_bit;
int8_t end_bit;
if (bytes == 1) {
start_bit = header.height-1;
end_bit = 0;
} else {
start_bit = 7;
end_bit = (byte_y < (bytes-1)) ? 0: 7-((header.height-1)%8);
}
for(int8_t bit_y = start_bit; bit_y >= end_bit; bit_y--) {
if ((oy + y) < _height && (ox + x) >= 0 && (oy + y) >= 0) {
//drawPixel(x+ox,y+(((header.height-1)-bit_y)-(byte_y*(1+start_bit-end_bit))), (data & 1<<bit_y) ? colour : _background);
drawPixel(x+ox,y+(((header.height-1)-bit_y)-(byte_y*(1+start_bit-end_bit))),(data & (1 << bit_y)) ? colour : _background);
}
oy++;
if (oy == header.height) break;
}
}
_cursor_x++;//cursor
}
_cursor_x++;//cursor
return width;
}
void FramebufferGFX::fillCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color) {
// From Adafruit library
drawFastVLine(x0, y0-r, 2*r+1, color);
fillCircleHelper(x0, y0, r, 3, 0, color);
}
void Arduboy::fillCircle(int16_t x0, int16_t y0, int16_t r, uint8_t color)
{
drawFastVLine(x0, y0-r, 2*r+1, color);
fillCircleHelper(x0, y0, r, 3, 0, color);
}
ICACHE_FLASH_ATTR void Adafruit_GFX_AS::fillCircle(int16_t x0, int16_t y0, int16_t r,
uint16_t color) {
drawFastVLine(x0, y0-r, 2*r+1, color);
fillCircleHelper(x0, y0, r, 3, 0, color);
}
void GOFi2cOLED::fillCircle(uint8_t x0, uint8_t y0, uint8_t r,
uint8_t color) {
drawFastVLine(x0, y0-r, 2*r+1, color);
fillCircleHelper(x0, y0, r, 3, 0, color);
}
void screenkeys::fillCircle(uint8_t x0, uint8_t y0, uint16_t r,bool color) {
drawFastVLine(x0, y0-r, 2*r+1, color);
fillCircleHelper(x0, y0, r, 3, 0, color);
}
