Subversion Repositories group.electronics

/*

 * gfx.c

 *

 *  Created on: 28/11/2013

 *      Author: pfowler

 */

#include <avr/io.h>

#include <stdlib.h>

#include <avr/pgmspace.h>

#include <string.h>

#include "avrutil.h"

#include "gfx.h"

void gfx_init(uint8_t* buffer, uint8_t width, uint8_t height) {

	gfx.width = width;

	gfx.height = height;

	gfx.buffer = buffer;

	gfx_font.cursor_x = 0;

	gfx_font.cursor_y = 0;

	gfx_font.textsize = 1;

	gfx_font.textcolor = 1;

	gfx_font.textbgcolor = 1;

	gfx_font.wrap = 1;

}

uint8_t gfx_getRotation(void) {

	return gfx.rotation;

}

void gfx_setRotation(uint8_t x) {

	gfx.rotation = (x & 3);

	uint8_t ow = gfx.width;

	uint8_t oh = gfx.height;

	switch(gfx.rotation) {

		case 0:

		case 2:

			gfx.width  = ow;

			gfx.height = oh;

			break;

		case 1:

		case 3:

			gfx.width  = oh;

			gfx.height = ow;

			break;

	}

}

void gfx_setDrawFunc(pixelptr ptr) {

	gfx.drawPixel = ptr;

}

void gfx_setFlipFunc(flipptr ptr) {

	gfx.flip = ptr;

}

void gfx_flip(void) {

	(*gfx.flip)();

}

void gfx_clear(void) {

	memset(gfx.buffer, 0x00, (gfx.width * gfx.height / 8));

}

void gfx_drawPixel(uint16_t x, uint16_t y, uint8_t color) {

	if (gfx.drawPixel) {

		(*gfx.drawPixel)(gfx.buffer, x, y, color);

		return;

	}

	if (color)

		gfx.buffer[x+ (y/8)*gfx.width] |= _BV((y%8));

	else

		gfx.buffer[x+ (y/8)*gfx.width] &= ~_BV((y%8));

}

void gfx_drawFastVLine(uint8_t x, uint8_t y, uint8_t h, uint8_t color) {

	gfx_drawLine(x, y, x, y+h-1, color);

}

void gfx_drawFastHLine(uint8_t x, uint8_t y, uint8_t w, uint8_t color) {

	gfx_drawLine(x, y, x+w-1, y, color);

}

void gfx_drawRect(uint8_t x, uint8_t y, uint8_t w, uint8_t h, uint8_t color) {

	gfx_drawFastHLine(x, y, w, color);

	gfx_drawFastHLine(x, y+h-1, w, color);

	gfx_drawFastVLine(x, y, h, color);

	gfx_drawFastVLine(x+w-1, y, h, color);

}

void gfx_fillRect(uint8_t x, uint8_t y, uint8_t w, uint8_t h, uint8_t color) {

	uint8_t i;

	for (i=x; i<x+w; i++) {

		gfx_drawFastVLine(i, y, h, color);

	}

}

void gfx_fillScreen(uint8_t color) {

	gfx_fillRect(0, 0, gfx.width, gfx.height, 1);

}

void gfx_drawLine(uint8_t x0, uint8_t y0, uint8_t x1, uint8_t y1, uint8_t color) {

	int8_t steep = abs(y1 - y0) > abs(x1 - x0);

	//uint8_t t = 0;

	if (steep) {

		swapu(&x0, &y0);

		swapu(&x1, &y1);

	}

	if (x0 > x1) {

		swapu(&x0, &x1);

		swapu(&y0, &y1);

	}

	int8_t dx, dy;

	dx = x1 - x0;

	dy = abs(y1-y0);

	int8_t err = dx /2;

	int8_t ystep;

	if (y0 < y1)

		ystep = 1;

	else

		ystep = -1;

	for (; x0<=x1; x0++) {

		if (steep)

			gfx_drawPixel(y0, x0, color);

		else

			gfx_drawPixel(x0, y0, color);

		err -= dy;

		if (err < 0) {

			y0 += ystep;

			err += dx;

		}

	}

}

void gfx_drawChar(uint8_t x, uint8_t y, unsigned char c, uint8_t color, uint8_t bg, uint8_t size) {

	if((x >= gfx.width)             || // Clip right

		(y >= gfx.height)           || // Clip bottom

		((x + 6 * size - 1) < 0) || // Clip left

		((y + 8 * size - 1) < 0))   // Clip top

		return;

	uint8_t i;

	for (i=0; i<6; i++) {

		uint8_t line;

		if (i == 5)

			line = 0x0;

		else

			line = pgm_read_byte(gfx_font_data + (c*5)+i);

		uint8_t j;

		for (j=0; j<8; j++) {

			if (line & 0x01) {

				if (size == 1)

					gfx_drawPixel(x+i, y+j, color);

				else

					gfx_fillRect(x+(i*size), y+(j*size), size, size, color);

			} else if (bg != color) {

				if (size==1)

					gfx_drawPixel(x+i, y+j, bg);

				else

					gfx_fillRect(x+i*size, y+j*size, size, size, bg);

			}

			line >>= 1;

		}

	}

}

void gfx_writec(uint8_t c) {

	if (c == '\n') {

		gfx_font.cursor_y += gfx_font.textsize*8;

		gfx_font.cursor_x = 0;

	} else if (c == '\r') {

	} else {

		gfx_drawChar(gfx_font.cursor_x, gfx_font.cursor_y, c,

				gfx_font.textcolor, gfx_font.textbgcolor, gfx_font.textsize);

		gfx_font.cursor_x += gfx_font.textsize * 6;

		if (gfx_font.wrap &&

				(gfx_font.cursor_x > (gfx.width - gfx_font.textsize*6))) {

			gfx_font.cursor_y += gfx_font.textsize = 8;

			gfx_font.cursor_x = 0;

		}

	}

}

void gfx_writeb(uint8_t *buffer, size_t size) {

	while (size--)

		gfx_writec(*buffer++);

}

void gfx_writes(char* s) {

	while (*s)

		gfx_writec(*s++);

}

void gfx_printNumber(unsigned long n, uint8_t base) {

	unsigned char buf[8 * sizeof(long)];

	unsigned long i = 0;

	if (n==0) {

		gfx_writec('0');

		return;

	}

	while (n > 0) {

		buf[i++] = n % base;

		n /= base;

	}

	for (; i>0; i--)

		gfx_writec((buf[i-1]<10) ?

				'0' + buf[i-1] :

				'A' + buf[i-1]-10);

}

void gfx_printFloat(double number, uint8_t digits) {

	if (number < 0.0) {

		gfx_writec('-');

		number = -number;

	}

	double rounding = 0.5;

	uint8_t i;

	for (i=0; i<digits; ++i)

		rounding /= 10.0;

	number += rounding;

	unsigned long int_part = (unsigned long)number;

	double remainder = number - (double)int_part;

	gfx_printNumber(int_part, 10);

	if (digits > 0)

		gfx_writec('.');

	while (digits-- > 0) {

		remainder *= 10.0;

		unsigned long toPrint = (unsigned long)remainder;

		gfx_printNumber(toPrint, 10);

		remainder -= toPrint;

	}

}

void gfx_setCursor(uint8_t x, uint8_t y) {

	gfx_font.cursor_x = x;

	gfx_font.cursor_y = y;

}

void gfx_setTextSize(uint8_t s) {

	gfx_font.textsize = (s>0)? s : 1;

}

void gfx_setTextColor(uint8_t c) {

	gfx_font.textcolor = c;

}

void gfx_setTextBgColor(uint8_t bg) {

	gfx_font.textbgcolor = bg;

}

void gfx_setTextWrap(uint8_t w) {

	gfx_font.wrap = w;

}