#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <avr/wdt.h>
#include <portbits.h>
#include "8x12_horizontal_MSB_1.h"
#include "global.h"
#include "lcd.h"

unsigned char * const mem=(unsigned char * const)DDRAM;
unsigned char cgram[16][8];
unsigned char viewstart;

void lcd_init(void)
{	cli();
	wdt_disable();
#ifdef WAITSTATE
	MCUCR=(1<<SRE)|(1<<SRW10);					// Enable XMEM + Waitstate
#else
	MCUCR=(1<<SRE)|(0<<SRW10);					// Enable XMEM
#endif

#ifdef HWLP
	OCR1A=10;
	OCR1B=RELOAD/2;
	ICR1=RELOAD-1;
	TCCR1A=(1<<COM1A1)|(1<<COM1B1)|(1<<COM1B0)|(1<<WGM11);	// Enable PWM/Framerate (Kontrast)
	TCCR1B=(1<<WGM12)|(1<<WGM13)|1;
	TIMSK|=(1<<TOIE1);
#else
	OCR1B=128;
	TCCR1A=(1<<COM1B1)|(1<<COM1B0)|(1<<WGM10);	// Enable PWM (Kontrast)
	TCCR1B=1;									// 8bit PWM

	OCR0=RELOAD-1;
	TCCR0=(1<<WGM01)|2;							// 2MHz Timer Takt, CTC
	TIMSK|=(1<<OCIE0);
#endif

	sei();
	lcd_clear();

	lcd_block(50,10,269,79,0,255);
	lcd_block(60,20,109,69,64,255);
	lcd_block(150,15,189,45,64,64);
	lcd_block(180,40,219,75,128,128);
	lcd_block(200,20,239,50,255,255);
	lcd_string(10,120,PSTR("320x240 LCD Controller"),255,0);
	lcd_string(15,140,PSTR("\xB8"" by Benedikt"),255,0);
#ifdef GRAYSCALE
#ifdef GRAY8
	lcd_string(7,200,PSTR("8 colour mode by Sebastian"),255,0);
	lcd_block(0,215,19,220,0xFF,0xFF);
	lcd_block(20,215,39,220,0xC0,0xC0);
	lcd_block(40,215,59,220,0xA0,0xA0);
	lcd_block(60,215,79,220,0x80,0x80);
	lcd_block(80,215,99,220,0x60,0x60);
	lcd_block(100,215,119,220,0x40,0x40);
	lcd_block(120,215,139,220,0x20,0x20);
	lcd_block(140,215,159,220,0x00,0x00);
	lcd_block(160,215,179,220,0x00,0x00);
	lcd_block(180,215,199,220,0x20,0x20);
	lcd_block(200,215,219,220,0x40,0x40);
	lcd_block(220,215,239,220,0x60,0x60);
	lcd_block(240,215,259,220,0x80,0x80);
	lcd_block(260,215,279,220,0xA0,0xA0);
	lcd_block(280,215,299,220,0xC0,0xC0);
	lcd_block(300,215,319,220,0xFF,0xFF);
#else
	lcd_string(15,200,PSTR("4 color mode"),255,0);
#endif
#else
	lcd_string(15,200,PSTR("2 color mode"),255,0);
#endif

	wdt_enable(WDTO_250MS);
	ENABLE_VLCD=1;	
}

void lcd_string(unsigned char x, unsigned char y, char *txt, unsigned char tcol, unsigned char bcol)
{	unsigned char c;
	for(;;)
	{	c=pgm_read_byte(txt++);
		if (!c)
			break;
		lcd_writechar(x++,y,c,tcol,bcol);
	}
}

void lcd_clear(void)
{	unsigned short i;
	for (i=0; i<(65536-DDRAM); i++)
		mem[i]=0;
}

void bresenham_line (unsigned short x1, unsigned short y1, unsigned short x2, unsigned short y2, unsigned char color)
{	signed short dx,dy,x,y;
	signed char sdx,sdy;
	unsigned short i,px,py;
	dx=x2-x1;      // the horizontal distance of the line
	dy=y2-y1;      // the vertical distance of the line
	if (dx==0)
		sdx=0;
	if (dx>0)
		sdx=1;
	else
	{  	sdx=-1;
		dx=-dx;
	}
	if (dy==0)
		sdy=0;
	if (dy>0)
		sdy=1;
	else
	{	sdy=-1;
		dy=-dy;
	}
	x=dx*2;
	y=dy*2;
	px=x1;
	py=y1;
	lcd_setpixel (px,py,color);

	if (dx>=dy)					 // the line is more horizontal than vertical
	{	for(i=0;i<dx;i++)
		{	y+=dy;
			if (y>=dx)
			{	y-=dx;
				py+=sdy;
			}
			px+=sdx;
			lcd_setpixel (px,py,color);
		}
	}
	else				 		// the line is more vertical than horizontal
	{	for(i=0;i<dy;i++)
		{	x+=dx;
			if (x>=dy)
			{	x-=dy;
				px+=sdx;
			}
			py+=sdy;
			lcd_setpixel (px,py,color);
		}
	}
}

void lcd_line (unsigned short x1, unsigned short y1, unsigned short x2, unsigned short y2, unsigned char color)
{   unsigned short temp;
	if (y1==y2)
	{	if (x1>x2)
		{	temp=x1;
			x1=x2;
			x2=temp;
		}
		for (temp=x1; temp<=x2; temp++)
			lcd_setpixel (temp,y1,color);

	}
	else if (x1==x2)
	{	if (y1>y2)
		{	temp=y1;
			y1=y2;
			y2=temp;
		}
		for (temp=y1; temp<=y2; temp++)
			lcd_setpixel (x1,temp,color);
	}
	else
		bresenham_line (x1, y1, x2, y2, color);
}

void lcd_circle(unsigned short xm, unsigned short ym, unsigned char r, unsigned char color1, unsigned char color2)
{	unsigned short x;
	unsigned char y=r;
	signed short p;
	if ((r>xm)||(r>ym)||(r<1))
		return;
	y=r;
	p=(3-(2*r));
	for (x=0; x<=y; x++)
	{	lcd_line(xm-x,ym+y,xm+x,ym+y,color1);
		lcd_line(xm-x,ym-y,xm+x,ym-y,color1);
		lcd_line(xm-y,ym+x,xm+y,ym+x,color1);
		lcd_line(xm-y,ym-x,xm+y,ym-x,color1);
		if(p<0)
			p+=((4*x)+6);
		else
		{	y--;
			p+=((4*(x-y))+10);
		}
	}
	y=r;
	p=(3-(2*r));
	for (x=0; x<=y; x++)
	{	lcd_setpixel((xm+x),(ym+y),color2);
		lcd_setpixel((xm+y),(ym+x),color2);
		lcd_setpixel((xm+y),(ym-x),color2);
		lcd_setpixel((xm+x),(ym-y),color2);
		lcd_setpixel((xm-x),(ym-y),color2);
		lcd_setpixel((xm-y),(ym-x),color2);
		lcd_setpixel((xm-y),(ym+x),color2);
		lcd_setpixel((xm-x),(ym+y),color2);
		if(p<0)
			p+=((4*x)+6);
		else
		{	y--;
			p+=((4*(x-y))+10);
		}
	}
}

void lcd_block (unsigned short x1, unsigned short y1, unsigned short x2, unsigned short y2, unsigned char color1, unsigned char color2)
{	unsigned short y;
	if (x2>x1+1)
	{	for (y=y1+1; y<y2; y++)
			lcd_line(x1+1,y,x2-1,y,color1);
	}
	lcd_line(x1,y1,x2,y1,color2);
	lcd_line(x2,y1,x2,y2,color2);
	lcd_line(x2,y2,x1,y2,color2);
	lcd_line(x1,y2,x1,y1,color2);
}

void lcd_writecgram(unsigned char x, unsigned char y, unsigned char nr,unsigned char textcol,unsigned char backcol)
{	nr&=15;
	lcd_writebyteex(x,y+0,cgram[nr][0],textcol, backcol);
	lcd_writebyteex(x,y+1,cgram[nr][0],textcol, backcol);
	lcd_writebyteex(x,y+2,cgram[nr][1],textcol, backcol);
	lcd_writebyteex(x,y+3,cgram[nr][2],textcol, backcol);
	lcd_writebyteex(x,y+4,cgram[nr][2],textcol, backcol);
	lcd_writebyteex(x,y+5,cgram[nr][3],textcol, backcol);
	lcd_writebyteex(x,y+6,cgram[nr][4],textcol, backcol);
	lcd_writebyteex(x,y+7,cgram[nr][5],textcol, backcol);
	lcd_writebyteex(x,y+8,cgram[nr][5],textcol, backcol);
	lcd_writebyteex(x,y+9,cgram[nr][6],textcol, backcol);
	lcd_writebyteex(x,y+10,cgram[nr][7],textcol, backcol);
	lcd_writebyteex(x,y+11,cgram[nr][7],textcol, backcol);
}






/*
//##########################################################
// Loads a bitmap from FLASH in 4 graustufen
void LoadBitmap_P(unsigned const char *bitmap,unsigned short xpos , unsigned char ypos, unsigned short width, unsigned char height)
//##########################################################
{
 unsigned char i,j,k;
 unsigned char mask,bwidth,yp;
 unsigned char by;
 unsigned short xend,xp;
  xend=(unsigned short)xpos + (unsigned short)width;
  if(xend>XSIZE) xend=XSIZE; //Bitmap abschneiden wenn außerhalb des Displays
 
 bwidth=width/8; //Anzahl Bytes horizontal /8
 if((width%8)!=0) bwidth++; //Bei Rest noch ein Byte mehr

 yp=ypos;
 for(i=0; i<height; i++) //Über die gesamte Höhe
  {
   xp=xpos; //Zum Beginn der Zeile
   
   for(j=0; j<46; j++) //Über die gesamte Breite in Bytes
    {
	//lässt sich nur der Flash-Speicher zwischen 0k.. 64k adressieren.
     by=pgm_read_byte(bitmap);
	 mask=0x80;         //Fängt bei MSB an
    
     for(k=0; k<4; k++) //Über ein Byte
      {
        //Nur vorhandene und keine Füllpixel,-bytes zeichnen
       if(xp < (unsigned short)xend)
        {
		 //lcd_writebyteg8(xp/8,yp,by ,by,by);
		lcd_writebyteg(xp/4,yp,by);
		 xp++; 
        }                               

       mask>>=1; //Nächstes Bit
      }//for k

     bitmap++;
    } //for j

   yp++; //Nächste Zeile
  } //for i
}



*/

//##########################################################
// Loads a bitmap from FLASH in 4 graustufen
void LoadBitmap_4gray(unsigned const char *bitmap,unsigned short xpos , unsigned char ypos, unsigned short width, unsigned char height)
//##########################################################
{
 unsigned char i,j,k;
 unsigned char mask,bwidth,yp;
 unsigned char by;
 unsigned short xend,xp;
  xend=(unsigned short)xpos + (unsigned short)width;
  if(xend>XSIZE) xend=XSIZE; //Bitmap abschneiden wenn außerhalb des Displays
 
 bwidth=width/8; //Anzahl Bytes horizontal /8
 if((width%8)!=0) bwidth++; //Bei Rest noch ein Byte mehr

 yp=ypos;
 for(i=0; i<height; i++) //Über die gesamte Höhe
  {
   xp=xpos; //Zum Beginn der Zeile
   
   for(j=0; j<bwidth*2; j++) //Über die gesamte Breite in Bytes
    {
	//lässt sich nur der Flash-Speicher zwischen 0k.. 64k adressieren.
     by=pgm_read_byte(bitmap);
	 mask=0x80;         //Fängt bei MSB an
    
     for(k=0; k<4; k++) //Über ein Byte
      {
        //Nur vorhandene und keine Füllpixel,-bytes zeichnen
       if(xp < (unsigned short)xend)
        {
		 //lcd_writebyteg8(xp/8,yp,by ,by,by);
		lcd_writebyteg(xp/4,yp,by);
		 xp++; 
        }                               

       mask>>=1; //Nächstes Bit
      }//for k

     bitmap++;
    } //for j

   yp++; //Nächste Zeile
  } //for i
}


//##########################################################
// Loads a bitmap from FLASH in 8 graustufen
void LoadBitmap_8gray(unsigned const char *bitmap,unsigned short xpos , unsigned char ypos, unsigned short width, unsigned char height)
//##########################################################
{
 unsigned char i,j,k;
 unsigned char mask,bwidth,yp;
 unsigned char by;
 unsigned short xend,xp;
  xend=(unsigned short)xpos + (unsigned short)width;
  if(xend>XSIZE) xend=XSIZE; //Bitmap abschneiden wenn außerhalb des Displays
 
 bwidth=width/8; //Anzahl Bytes horizontal /8
   
 if((width%8)!=0) bwidth++; //Bei Rest noch ein Byte mehr

 yp=ypos;
 for(i=0; i<height; i++) //Über die gesamte Höhe= 74
  {
   xp=xpos; //Zum Beginn der Zeile
   
   for(j=0; j<69; j++) //Über die gesamte Breite in Bytes 184/8=23*3=69
    {
	//lässt sich nur der Flash-Speicher zwischen 0k.. 64k adressieren.
     by=pgm_read_byte(bitmap);
	 mask=0x80;         //Fängt bei MSB an
    
     for(k=0; k<8 ; k++) //Über ein Byte
      {
        //Nur vorhandene und keine Füllpixel,-bytes zeichnen
       if(xp < (unsigned short)xend)
        {
		 lcd_writebyteg8(xp/8,yp,by,by,by);
		
		 xp++; 
        }                               

       mask>>=1; //Nächstes Bit
      }//for k

     bitmap++;
    } //for j

   yp++; //Nächste Zeile
  } //for i
}




 



void lcd_setstartx(unsigned char pos)
{
#ifdef GRAYSCALE
	if (pos>24)
		pos=24;	
	pos*=2;
#else
	if (pos>88)
		pos=88;
	pos*=2;
#endif
	viewstart=pos;
}