#include "ImageData.h"
#include "GraphBase.h"
#include "GraphLow.h"

void TRect::Set(int aLeft, int aTop, int aRight, int aBottom)
{
	Left=aLeft;
	Top=aTop;
	Right=aRight;
	Bottom=aBottom;
	Width=Right-Left+1;
	Height=Bottom-Top+1;
	CenterPoint.x=(Left+Right)/2;
	CenterPoint.y=(Top+Bottom)/2;
}

void TRect::SetBySize(int aLeft, int aTop, int aWidth, int aHeight)
{
	Left=aLeft;
	Top=aTop;
	Width=aWidth;
	Height=aHeight;
	Right=Left+Width-1;
	Bottom=Top+Height-1;
	CenterPoint.x=(Left+Right)/2;
	CenterPoint.y=(Top+Bottom)/2;
}

void TRect::SetBy2Point(TPoint aPLT, TPoint aPRB)
{
	Left=aPLT.x;
	Top=aPLT.y;
	Right=aPRB.x;
	Bottom=aPRB.y;
	Width=Right-Left+1;
	Height=Bottom-Top+1;
	CenterPoint.x=(Left+Right)/2;
	CenterPoint.y=(Top+Bottom)/2;	
}

void TRect::SetLeftTop(int aL, int aT)
{
	SetLeft(aL);
	SetTop(aT);
	CenterPoint.x=(Left+Right)/2;
	CenterPoint.y=(Top+Bottom)/2;
}	

void TRect::SetLeft(int aL)
{
	Left=aL;
	Right=Left+Width-1;
	CenterPoint.x=(Left+Right)/2;
	CenterPoint.y=(Top+Bottom)/2;
}

void TRect::SetTop(int aT)
{
	Top=aT;
	Bottom=Top+Height-1;
	CenterPoint.x=(Left+Right)/2;
	CenterPoint.y=(Top+Bottom)/2;
}


void TRect::SetRight(int aR)
{
	Right=aR;
	Left=Right-Width+1;
	CenterPoint.x=(Left+Right)/2;
	CenterPoint.y=(Top+Bottom)/2;
}

void TRect::SetBottom(int aB)
{
	Bottom=aB;
	Top=Bottom-Height+1;
	CenterPoint.x=(Left+Right)/2;
	CenterPoint.y=(Top+Bottom)/2;
}

void TRect::SetWidth(int aW)
{
	Width=aW;
	Right=Left+Width-1;
	CenterPoint.x=(Left+Right)/2;
	CenterPoint.y=(Top+Bottom)/2;
}

void TRect::SetHeight(int aH)
{
	Height=aH;
	Bottom=Top+Height-1;
	CenterPoint.x=(Left+Right)/2;
	CenterPoint.y=(Top+Bottom)/2;
}


void TCircle::Plot4Points(int x, int y)
{
	PixelRender((Center.x + x), (Center.y + y), PenWidth, PenColor);
	if (x != 0) PixelRender((Center.x - x), (Center.y + y), PenWidth, PenColor);
	if (y != 0) PixelRender((Center.x + x), (Center.y - y), PenWidth, PenColor);
	if (x != 0 && y != 0) PixelRender((Center.x - x), (Center.y - y), PenWidth, PenColor);
}

void TCircle::Plot4PointsFill(int x, int y)
{
	BoxRender2D((Center.x-x), (Center.y+y), (Center.x+x), (Center.y+y), PenColor);
	BoxRender2D((Center.x-x), (Center.y-y), (Center.x+x), (Center.y-y), PenColor);
}


void TCircle::Plot8Points(int x, int y)
{
	if(BrushStyle) {
		Plot4PointsFill(x, y);
		if (x != y) Plot4PointsFill(y, x);
	}else{
		Plot4Points( x, y);
		if (x != y) Plot4Points(y, x);
	}
}

void TCircle::Render(void)   //draw circle
{
	int tmp = static_cast<int>(Radius);
	int error =  (-1 *  tmp);
	unsigned int x = Radius;
	unsigned int y = 0;
 
	// The following while loop may altered to 'while (x > y)' for a
	// performance benefit, as long as a call to 'plot4points' follows
	// the body of the loop. This allows for the elimination of the
	// '(x != y') test in 'plot8points', providing a further benefit.
	//
	// For the sake of clarity, this is not shown here.
	while (x >= y){
		Plot8Points(x, y);
 
		error += y;
		++y;
		error += y;
 
		// The following test may be implemented in assembly language in
		// most machines by testing the carry flag after adding 'y' to
		// the value of 'error' in the previous step, since 'error'
		// nominally has a negative value.
		if (error >= 0){
			--x;
			error -= x;
			error -= x;
		}
	}
}

//在指定位置画一个指定大小的圆
//(x,y):中心点
//r    :半径
void TCircle::Render2(void)
{
	int a,b;
	int di;
	a=0;b=Radius;	  
	di=3-(Radius<<1);             //判断下个点位置的标志
	while(a<=b)
	{
		PixelRender(Center.x+a,Center.y-b,PenColor);             //5
 		PixelRender(Center.x+b,Center.y-a,PenColor);             //0           
		PixelRender(Center.x+b,Center.y+a,PenColor);             //4               
		PixelRender(Center.x+a,Center.y+b,PenColor);             //6 
		PixelRender(Center.x-a,Center.y+b,PenColor);             //1       
 		PixelRender(Center.x-b,Center.y+a,PenColor);             
		PixelRender(Center.x-a,Center.y-b,PenColor);             //2             
  		PixelRender(Center.x-b,Center.y-a,PenColor);             //7     	         
		a++;
		//Bresenham algorithm    
		if(di<0)di +=4*a+6;	  
		else
		{
			di+=10+4*(a-b);   
			b--;
		} 						    
	}
} 	

void TCircle::sPlot4Points(int cx, int cy, int x, int y, unsigned int aClr)
{
	PixelRender((cx + x), (cy + y), 1, aClr);
	if (x != 0) PixelRender((cx - x), (cy + y), 1, aClr);
	if (y != 0) PixelRender((cx + x), (cy - y), 1, aClr);
	if (x != 0 && y != 0) PixelRender((cx - x), (cy - y), 1, aClr);
}

void TCircle::sPlot4PointsFill(int cx, int cy, int x, int y, unsigned int aClr)
{
	BoxRender2D((cx-x), (cy+y), (cx+x), (cy+y), aClr);
	BoxRender2D((cx-x), (cy-y), (cx+x), (cy-y), aClr);
}

void TCircle::sPlot8Points(int cx, int cy, int x, int y, unsigned int aClr, int IsFill)
{
	if(IsFill) {
		sPlot4PointsFill(cx, cy, x, y, aClr);
		if (x != y) sPlot4PointsFill(cx, cy, y, x, aClr);
	}else{
		sPlot4Points(cx, cy, x, y, aClr);
		if (x != y) sPlot4Points(cx, cy, y, x, aClr);
	}
}

void TCircle::sRender(int ax, int ay, int aR, unsigned int aClr, int IsFill)
{
	int tmp = static_cast<int>(aR);
	int error =  (-1 *  tmp);
	unsigned int x = aR;
	unsigned int y = 0;
 
	// The following while loop may altered to 'while (x > y)' for a
	// performance benefit, as long as a call to 'plot4points' follows
	// the body of the loop. This allows for the elimination of the
	// '(x != y') test in 'plot8points', providing a further benefit.
	//
	// For the sake of clarity, this is not shown here.
	while (x >= y){
		sPlot8Points(ax, ay, x, y, aClr, IsFill);
 
		error += y;
		++y;
		error += y;
 
		// The following test may be implemented in assembly language in
		// most machines by testing the carry flag after adding 'y' to
		// the value of 'error' in the previous step, since 'error'
		// nominally has a negative value.
		if (error >= 0){
			--x;
			error -= x;
			error -= x;
		}
	}	
}

//在指定位置画一个指定大小的圆
//(x,y):中心点
//r    :半径
void TCircle::sRender2(int x, int y, int aR, unsigned int aClr)
{
	int a,b;
	int di;
	a=0;b=aR;	  
	di=3-(aR<<1);             //判断下个点位置的标志
	while(a<=b)
	{
		PixelRender(x+a,y-b,aClr);             //5
 		PixelRender(x+b,y-a,aClr);             //0           
		PixelRender(x+b,y+a,aClr);             //4               
		PixelRender(x+a,y+b,aClr);             //6 
		PixelRender(x-a,y+b,aClr);             //1       
 		PixelRender(x-b,y+a,aClr);             
		PixelRender(x-a,y-b,aClr);             //2             
  		PixelRender(x-b,y-a,aClr);             //7     	         
		a++;
		//Bresenham algorithm    
		if(di<0)di +=4*a+6;	  
		else
		{
			di+=10+4*(a-b);   
			b--;
		} 						    
	}
} 	



void TCircle::Plot4PointsQuadrant(int x, int y, int quadrant)
{
	switch(quadrant) 
	{
		case 0:
			if (y != 0) PixelRender((Center.x + x), (Center.y - y), PenWidth, PenColor);
			break;
		case 1: 
			PixelRender((Center.x + x), (Center.y + y), PenWidth, PenColor);
			break;
		case 2:
			if (x != 0) PixelRender((Center.x - x), (Center.y + y), PenWidth, PenColor);
			break;
		case 3:
			if (x != 0 && y != 0) PixelRender((Center.x - x),(Center.y - y), PenWidth, PenColor);
		break;
	}
}

void TCircle::Plot4PointsFillQuadrant(int x, int y,int quadrant)
{
	switch(quadrant) 
	{
		case 0:
			BoxRender2D((Center.x), (Center.y-y), (Center.x+x), (Center.y-y), BrushColor);
			break;
		case 1:
			BoxRender2D((Center.x),(Center.y+y), (Center.x+x), (Center.y+y), BrushColor);
			break;
		case 2:
			BoxRender2D((Center.x-x),(Center.y+y), (Center.x), (Center.y+y), BrushColor);
			break;
		case 3:
			BoxRender2D((Center.x-x),(Center.y-y), (Center.x), (Center.y-y), BrushColor);
			break;
	}
}


void TCircle::Plot8PointsQuadrant(int x, int y, int quadrant)
{
	if(BrushStyle) {
		Plot4PointsFillQuadrant(x, y, quadrant);
		if (x != y) Plot4PointsFillQuadrant(y, x, quadrant);
	}else{
		Plot4PointsFillQuadrant(x, y, quadrant);
		if (x != y) Plot4PointsFillQuadrant(y, x, quadrant);
	}
}

void TCircle::RenderQuadrant(int quadrant)   //draw circle
{
	int tmp = Radius;
	signed int error =  (-1 * tmp);
	unsigned int x = Radius;
	unsigned int y = 0;
 
  if(!Radius)
  {
    PixelRender(Center.x, Center.y, PenWidth, PenColor);
    return;
  }
 
  // The following while loop may altered to 'while (x > y)' for a
  // performance benefit, as long as a call to 'plot4points' follows
  // the body of the loop. This allows for the elimination of the
  // '(x != y') test in 'plot8points', providing a further benefit.
  //
  // For the sake of clarity, this is not shown here.
  while (x >= y)
  {
    Plot8PointsQuadrant(x, y, quadrant);
 
    error += y;
    ++y;
    error += y;
 
    // The following test may be implemented in assembly language in
    // most machines by testing the carry flag after adding 'y' to
    // the value of 'error' in the previous step, since 'error'
    // nominally has a negative value.
    if (error >= 0)
    {
      --x;
      error -= x;
      error -= x;
    }
  }
}

void TCircle::sPlot4PointsFillQuadrant(int ax, int ay, int x, int y, int quadrant, u32 aClr)
{
	switch(quadrant) 
	{
		case 0:
			BoxRender2D((ax), (ay-y), (ax+x), (ay-y), aClr);
			break;
		case 1:
			BoxRender2D((ax),(ay+y), (ax+x), (ay+y), aClr);
			break;
		case 2:
			BoxRender2D((ax-x),(ay+y), (ax), (ay+y), aClr);
			break;
		case 3:
			BoxRender2D((ax-x),(ay-y), (ax), (ay-y), aClr);
			break;
	}
}


void TCircle::sPlot8PointsQuadrant(int ax, int ay, int x, int y, int quadrant,u32 aClr)
{
	sPlot4PointsFillQuadrant(ax,ay,x, y, quadrant,aClr);
	if (x != y) sPlot4PointsFillQuadrant(ax,ay,y, x, quadrant,aClr);
}

void TCircle::sPlot8PointsFillQuadrant(int ax, int ay, int x, int y, int quadrant, u32 aClr)
{
		sPlot4PointsFillQuadrant(ax,ay,x, y, quadrant,aClr);
		if (x != y) sPlot4PointsFillQuadrant(ax,ay,y, x, quadrant,aClr);
}

void TCircle::sRenderQuadrant(int ax, int ay, int aR, int quadrant, u32 aClr, int IsFill)   //draw circle
{
	int tmp = aR;
	signed int error =  (-1 * tmp);
	unsigned int x = aR;
	unsigned int y = 0;
 
  if(!aR)
  {
    PixelRender(ax, ay, 1, aClr);
    return;
  }
 
  // The following while loop may altered to 'while (x > y)' for a
  // performance benefit, as long as a call to 'plot4points' follows
  // the body of the loop. This allows for the elimination of the
  // '(x != y') test in 'plot8points', providing a further benefit.
  //
  // For the sake of clarity, this is not shown here.
  while (x >= y)
  {
	if(IsFill)
		sPlot8PointsFillQuadrant(ax,ay,x, y, quadrant,aClr);
	else
		sPlot8PointsQuadrant(ax,ay,x, y, quadrant,aClr);
 
    error += y;
    ++y;
    error += y;
 
    // The following test may be implemented in assembly language in
    // most machines by testing the carry flag after adding 'y' to
    // the value of 'error' in the previous step, since 'error'
    // nominally has a negative value.
    if (error >= 0)
    {
      --x;
      error -= x;
      error -= x;
    }
  }
}

void TImageList::SetData(unsigned int aSize, unsigned int aIndex)
{
	unsigned int i,j;
	if(aSize == 16){

	}else
	if(aSize == 24){
		
	}else
	if(aSize == 32){
		
	}		
}

void TImageList::LoadFromFlash(unsigned int aSize, unsigned int aIndex)
{
	/*
	unsigned int i,j;
	if(aSize == 16){
		if(aIndex < dICON16_COUNT){
			for(i=0; i<16; i++){
				for(j=0; j<16; j++){
					Size16[aIndex].HV[i][j] = 0;
				}
			}
		}
	}else
	if(aSize == 24){
		
	}else
	if(aSize == 32){
		
	}*/		
}

void TImageList::LoadFromFlash(void)
{
	/*
	unsigned int i;
	for(i=0;i<dICON16_COUNT;i++) LoadFromFlash(16,i);
	for(i=0;i<dICON24_COUNT;i++) LoadFromFlash(24,i);
	for(i=0;i<dICON32_COUNT;i++) LoadFromFlash(32,i);
	*/
}

void TImageList::ClearAllFlash(void)
{
	
}
void TImageList::WriteToFlash(unsigned int Index)
{
	
}

void TImageList::Render(unsigned int aSize, unsigned int aIndex, unsigned int aLeft, unsigned int aTop)
{
	unsigned int x,y,z;
	unsigned int Ram_addr;
	if(aSize == 16){
		if(aIndex < dICON16_COUNT){
			z = FLASH_USER_PIC_16X16 + aIndex * FLASH_USER_PIC_16X16_UINT;
			TranparrentColor = *(volatile unsigned int *)(z);
			Ram_addr = ((aTop - 1) * 800 + aLeft) *4 + LcdBaseAddr;
			for(y=0; y<16; y++){
				for(x=0;x<16;x++){
					if(TranparrentColor != (*(volatile unsigned int *)(z))  )
						*(volatile unsigned int *)(Ram_addr)  = (*(volatile unsigned int *)(z));
					z+=4;
					Ram_addr += 4;
				}
				Ram_addr += (800 - 16) *4 ;
			}
		}
	}else
	if(aSize == 22){
		
	}else
	if(aSize == 24){
		if(aIndex < dICON24_COUNT){
			z = FLASH_USER_PIC_24X24 + aIndex * FLASH_USER_PIC_24X24_UINT;
			TranparrentColor = *(volatile unsigned int *)(z);
			Ram_addr = ((aTop - 1) * 800 + aLeft) *4 + LcdBaseAddr;
			for(y=0; y<24; y++){
				for(x=0;x<24;x++){
					if(TranparrentColor != (*(volatile unsigned int *)(z)) )
						*(volatile unsigned int *)(Ram_addr)  = (*(volatile unsigned int *)(z));
					z+=4;
					Ram_addr += 4;
				}
				Ram_addr += (800 - 24) *4 ;
			}
		}
	}else
	if(aSize == 32){
		if(aIndex < dICON32_COUNT){
			z = FLASH_USER_PIC_32X32 + aIndex * FLASH_USER_PIC_32X32_UINT;
			TranparrentColor = *(volatile unsigned int *)(z);
			Ram_addr = ((aTop - 1) * 800 + aLeft) *4 + LcdBaseAddr;
			for(y=0; y<32; y++){
				for(x=0;x<32;x++){
					if(TranparrentColor != (*(volatile unsigned int *)(z)) )
						*(volatile unsigned int *)(Ram_addr)  = *(volatile unsigned int *)(z);
					z+=4;
					Ram_addr += 4;
				}
				Ram_addr += (800 - 32) *4 ;
			}
		}		
	}
}

void TImageList::Render(unsigned int aSize, unsigned int aIndex, unsigned int aLeft, unsigned int aTop, unsigned int xLimit, unsigned int yLimit)
{
	unsigned int x,y,z;
	unsigned int Ram_addr;
	unsigned int i,j,axL,ayL;
	if(aSize == 16){
		if(aIndex < dICON16_COUNT){
			z = FLASH_USER_PIC_16X16 + aIndex * FLASH_USER_PIC_16X16_UINT;
			TranparrentColor = *(volatile unsigned int *)(z);
			Ram_addr = ((aTop - 1) * 800 + aLeft) *4 + LcdBaseAddr;			
			ayL = aTop;
			for(y=0; y<16; y++){
				if(ayL >= yLimit)break;
				axL = aLeft;
				for(x=0;x<16;x++){
					if(axL >= xLimit){
						z = z + 16 - x;
						Ram_addr += 4 * (16-x);
						break;
					}
					if(TranparrentColor != (*(volatile unsigned int *)(z))  )
						*(volatile unsigned int *)(Ram_addr)  = (*(volatile unsigned int *)(z));
					z += 4;
					Ram_addr += 4;
					axL++;
				}
				Ram_addr += (800 - 16) *4 ;
				ayL++; 
			}
		}
	}else
	if(aSize == 22){
		if(aIndex < dICON16_COUNT){
			
		}
	}else
	if(aSize == 24){
		if(aIndex < dICON24_COUNT){
			z = FLASH_USER_PIC_24X24 + aIndex * FLASH_USER_PIC_24X24_UINT;
			TranparrentColor = *(volatile unsigned int *)(z);
			Ram_addr = ((aTop - 1) * 800 + aLeft) *4 + LcdBaseAddr;
			ayL = aTop;
			for(y=0; y<24; y++){
				if(ayL >= yLimit)break;
				axL = aLeft;
				for(x=0;x<24;x++){
					if(axL >= xLimit){
						z = z + 24 - x;
						Ram_addr += 4 * (24-x);
						break;
					}
					if(TranparrentColor != (*(volatile unsigned int *)(z)) )
						*(volatile unsigned int *)(Ram_addr)  = (*(volatile unsigned int *)(z));
					z += 4;
					Ram_addr += 4;
					axL++;
				}
				Ram_addr += (800 - 24) *4 ;
				ayL++; 
			}
		}			
	}else
	if(aSize == 32){
		if(aIndex < dICON32_COUNT){
			z = FLASH_USER_PIC_32X32 + aIndex * FLASH_USER_PIC_32X32_UINT;
			TranparrentColor = *(volatile unsigned int *)(z);
			Ram_addr = ((aTop - 1) * 800 + aLeft) *4 + LcdBaseAddr;
			ayL = aTop;
			for(y=0; y<32; y++){
				if(ayL >= yLimit)break;
				axL = aLeft;
				for(x=0;x<32;x++){
					if(axL >= xLimit){
						z = z + 32 - x;
						Ram_addr += 4 * (32-x);
						break;
					}
					if(TranparrentColor != (*(volatile unsigned int *)(z)))
						*(volatile unsigned int *)(Ram_addr)  = (*(volatile unsigned int *)(z));
					z+=4;
					Ram_addr += 4;
					axL++;
				}
				Ram_addr += (800 - 32) *4 ;
				ayL++; 
			}	
		}		
	}
}

unsigned int TImageList::GetSize16Count(void)
{
	return dICON16_COUNT;
}

unsigned int TImageList::GetSize24Count(void)
{
	return dICON24_COUNT;
}

unsigned int TImageList::GetSize32Count(void)
{
	return dICON32_COUNT;
}

void TVScrollBar::sDrawByPoint(int x, int y, int Right, int Bottom, u32 aClr, u32 aBClr, int aItemsCount, int aLineCount, int aTopIndex)
{
	int aW, aH;
	int RibbonHeight;
	int RibbonBottom;
	int RibbonTop;
	float f1,f2,f3,f4,f5;
	
	int CenterPoint;
	
	if(aItemsCount <1){
		RectFillRender(x, y, Right, Bottom, aBClr);
		return;
	}
	
	aW = Right - x +1;
	aH = Bottom - y +1;

	VertLineRender(x,			  y, 		aH,		0xFF808080);
	VertLineRender(Right,		 y ,		aH,		0xFF808080);
	HorizLineRender(x , 	       y,  	      aW, 		0xFF808080);
	HorizLineRender(x,	   Bottom,		aW,		0xFF808080);
	
	if(aItemsCount <= aLineCount){
		RibbonTop = y+1;
		RibbonBottom = Bottom - 1;
		RibbonHeight = aH - 2;
	}else{
		f1 = static_cast<float>(aTopIndex);
		f2 = static_cast<float>(aLineCount);
		f3 = static_cast<float>(aItemsCount);
		f4 = static_cast<float>(aH-2);
		f5 = (f1 + (f2/2.0)) / f3 * f4;
		CenterPoint = (static_cast<int>(f5)) + y +1;
		RibbonHeight = static_cast<int>(f2 / f3 * f4);
		if(RibbonHeight < 10)RibbonHeight =10;
		if(RibbonHeight > (aH-2) )RibbonHeight = aH-2;
		RibbonTop = CenterPoint - RibbonHeight /2 +1;
		RibbonBottom = CenterPoint + RibbonHeight /2 +1;
		if(RibbonTop  <= y){
			RibbonTop = y+1;
			RibbonBottom = RibbonTop + RibbonHeight;
			if(RibbonBottom > (Bottom-1)){
				RibbonBottom = Bottom-1;
			}
		}
		if(RibbonBottom > (Bottom-1)){
			RibbonBottom = Bottom-1;
			RibbonTop = RibbonBottom - RibbonHeight;
			if(RibbonTop <= y){
				RibbonTop = y+1;
			}
		}
	}
	
	//Draw Vert ScrollBar BackGround
	RectFillRender(x, y, Right, Bottom, aBClr);
	//Draw Vert ScrollBar Ribbon
	RectFillRender(x, RibbonTop, Right, RibbonBottom, aClr);
	//RectFillRender(x, 90, Right, 160, aClr);
}

void TVScrollBar::sDrawBySize(int x, int y, int aW, int aH, u32 aClr, u32 aBClr, int aItemsCount, int aLineCount, int aTopIndex)
{
	int Right, Bottom;

	Right = x + aW -1;
	Bottom = y + aH -1;
	
	sDrawByPoint(x, y, Right, Bottom, aClr, aBClr, aItemsCount, aLineCount, aTopIndex);	
}

void TProgressBar::sDrawByPoint(int x, int y, int Right, int Bottom, int aPercent, int aMax, u32 aClr, u32 aBClr, u32 aTClr)
{
	int aW, aH, x1,y1,x2,y2;
	float f1,f2,f3,f4;
	
	aW = Right - x +1;
	aH = Bottom - y +1;
	
	VertLineRender(x,			  y, 		aH,		0xFF808080);
	VertLineRender(Right,		 y ,		aH,		0xFF808080);
	HorizLineRender(x , 	       y,  	      aW, 		0xFF808080);
	HorizLineRender(x,	   Bottom,		aW,		0xFF808080);
	
	aW = aW-2;
	if(aW < 1)aW = 1;
	x1 = x+1;
	y1 = y+1;
	x2 = Right - 1;
	y2 = Bottom -1;
	f1 = static_cast<float>(aPercent);
	f2 = static_cast<float>(aMax);
	f3 = static_cast<float>(aW);
	f4 = f1 / f2 * f3;
	aW = static_cast<int>(f4);
	x2 = x1 + aW;
	RectFillRender(x1, y1, x2, y2, aClr);
	x2 = Right - 1;
	x1 = x2 +1; 
	if(x1 < (Right-1))
		RectFillRender(x1, y1, x2, y2, aBClr);
	
	x1 = x + (aW / 2) - 18;
	y1 = y + ((aH -24) /2);
	//TextDigitRender2Right24(x1,y1 ,aTClr, aPercent);
	
}

void TProgressBar::sDrawBySize(int x, int y, int aW, int aH, int aPercent, int aMax, u32 aClr, u32 aBClr, u32 aTClr)
{
	int W, x1,y1,x2,y2;
	int Right, Bottom;

	float f1,f2,f3,f4;
	
	Right = x + aW -1;
	Bottom = y + aH -1;
	
	VertLineRender(x,			  y, 		aH,		0xFF808080);
	VertLineRender(Right,		 y ,		aH,		0xFF808080);
	HorizLineRender(x , 	       y,  	      aW, 		0xFF808080);
	HorizLineRender(x,	   Bottom,		aW,		0xFF808080);
	
	W = aW-2;
	if(W < 1)W = 1;
	x1 = x+1;
	y1 = y+1;
	x2 = Right - 1;
	y2 = Bottom -1;
	if(aPercent < 1){
		RectFillRender(x1, y1, x2, y2, aBClr);
		return;
	}
	f1 = static_cast<float>(aPercent);
	f2 = static_cast<float>(aMax);
	f3 = static_cast<float>(W);
	f4 = f1 / f2 * f3;
	W = static_cast<int>(f4);
	x2 = x1 + W;
	RectFillRender(x1, y1, x2, y2, aClr);
	x2 = Right - 1;
	x1 = x2 +1; 
	if(x1 < (Right-1))
		RectFillRender(x1, y1, x2, y2, aBClr);
	
	x1 = x + (aW / 2) - 18;
	y1 = y + ((aH -24) /2);
	//TextDigitRender3Right24(x1,y1 ,aTClr, aPercent);
}

void TImage::Render(unsigned int xLimit, unsigned int yLimit)
{
	unsigned int x,y,z;
	unsigned int Ram_addr;
	unsigned int i,j,axL,ayL;

	if(Width > 300)Width = 300;
	if(Height == 24){
			z = FLASH_USER_PIC_LOGO24;
			TranparrentColor = 0xFF000000;
			Ram_addr = ((Top - 1) * 800 + Left) *4 + LcdBaseAddr;
			ayL = Top;
			for(y=0; y<24; y++){
				if(ayL >= yLimit)break;
				axL = Left;
				for(x=0;x<Width;x++){
					if(axL >= xLimit){
						z = z + 24 - x;
						Ram_addr += 4 * (24-x);
						break;
					}
					if(TranparrentColor != (*(volatile unsigned int *)(z)) )
						*(volatile unsigned int *)(Ram_addr)  = (*(volatile unsigned int *)(z));
					z += 4;
					Ram_addr += 4;
					axL++;
				}
				Ram_addr += (800 - Width) *4 ;
				ayL++; 
			}			
	}else
	if(Height == 32){
			z = FLASH_USER_PIC_LOGO32;
			TranparrentColor = 0xFF000000;
			Ram_addr = ((Top - 1) * 800 + Left) *4 + LcdBaseAddr;
			ayL = Top;
			for(y=0; y<32; y++){
				if(ayL >= yLimit)break;
				axL = Left;
				for(x=0;x<Width;x++){
					if(axL >= xLimit){
						z = z + 32 - x;
						Ram_addr += 4 * (32-x);
						break;
					}
					if(TranparrentColor != (*(volatile unsigned int *)(z)))
						*(volatile unsigned int *)(Ram_addr)  = (*(volatile unsigned int *)(z));
					z+=4;
					Ram_addr += 4;
					axL++;
				}
				Ram_addr += (800 - Width) *4 ;
				ayL++; 
			}			
	}
}

void TRoundSquare::sDrawBySize(int ax, int ay, int aW, int aH, int RoundR, u32 aClr, int Active)
{
	TPoint Lt, Lb, Rt, Rb;
	Lt.x = ax + RoundR; 		Lt.y = ay + RoundR;
	Lb.x = Lt.x;			Lb.y = ay + aH -1 - RoundR;
	Rt.x = ax + aW -1 - RoundR;	Rt.y = Lt.y;
	Rb.x = Rt.x;			Rb.y = Lb.y;
	
	TCircle::sRenderQuadrant(Lt.x, Lt.y, RoundR, 3, aClr,  1);
	TCircle::sRenderQuadrant(Rt.x, Rt.y, RoundR, 0, aClr,  1);
	TCircle::sRenderQuadrant(Lb.x, Lb.y, RoundR, 2, aClr,  1);
	TCircle::sRenderQuadrant(Rb.x, Rb.y, RoundR, 1, aClr,  1);
	
	BoxRender2D((ax), (ay+RoundR-1), (ax+aW-1), (ay+aH-1-RoundR), aClr);
	BoxRender2D((ax+RoundR-1), (ay), (ax+aW-1-RoundR), (ay+RoundR-1), aClr);
	BoxRender2D((ax+RoundR-1), (ay+aH-1-RoundR), (ax+aW-1-RoundR), (ay+aH-1), aClr);
	
	if(Active){
		TPoint Gp;
		const int PenWidth = (aW * aH) / 200 ;
		const int OffSet0 = (aW * aH) / 120;
		const int OffSet1 = OffSet0 * 23 / 10;
		Gp.x = ax + (aW * 10 / 45);
		Gp.y = ay + (aH / 2);
		
		LineRender(Gp.x, Gp.y, Gp.x +OffSet0, Gp.y +OffSet0, PenWidth, clNearBlack);
		LineRender(Gp.x +OffSet0, Gp.y +OffSet0, Gp.x +OffSet0 + OffSet1, Gp.y +OffSet0 - OffSet1, PenWidth, clNearBlack);
	}
}

void TRoundSquare::sSelected(int ax, int ay, int aW, int aH, int aThick, u32 aColor)
{
	int x,y;
	const int Thick = aThick;
	TPoint rP[4];
	rP[0].x = ax - Thick; 			rP[0].y = ay -Thick;	//Left Top
	rP[1].x = ax +aW -1 +1; 		rP[1].y = rP[0].y;	//Right Top
	rP[2].x = rP[0].x; 			rP[2].y = ay + aH -1;	//Left Bottom
	rP[3].x = rP[1].x; 			rP[3].y = rP[2].y;	//Right Bottom

	for(int i=0; i<4; i++){
		for(x=0; x<Thick;x++){
			for(y=0;y<Thick;y++){
				PixelRender(rP[i].x +x, rP[i].y+y, aColor);
			}
		}
	}
}

void TRoundRect::sDrawBySize(int ax, int ay, int aW, int aH, int RoundR, u32 aClr, char *Text, int LeftSpace, u32 TextClr)
{
	TPoint Lt, Lb, Rt, Rb;
	Lt.x = ax + RoundR; 		Lt.y = ay + RoundR;
	Lb.x = Lt.x;			Lb.y = ay + aH -1 - RoundR;
	Rt.x = ax + aW -1 - RoundR;	Rt.y = Lt.y;
	Rb.x = Rt.x;			Rb.y = Lb.y;
	
	TCircle::sRenderQuadrant(Lt.x, Lt.y, RoundR, 3, aClr,  1);
	TCircle::sRenderQuadrant(Rt.x, Rt.y, RoundR, 0, aClr,  1);
	TCircle::sRenderQuadrant(Lb.x, Lb.y, RoundR, 2, aClr,  1);
	TCircle::sRenderQuadrant(Rb.x, Rb.y, RoundR, 1, aClr,  1);
	
	BoxRender2D((ax), (ay+RoundR-1), (ax+aW-1), (ay+aH-1-RoundR), aClr);
	BoxRender2D((ax+RoundR-1), (ay), (ax+aW-1-RoundR), (ay+RoundR-1), aClr);
	BoxRender2D((ax+RoundR-1), (ay+aH-1-RoundR), (ax+aW-1-RoundR), (ay+aH-1), aClr);
	
	int TextY = ay + ((aH - 24) /2);
	TextRender_string24(ax + LeftSpace, TextY, TextClr, aClr, Text);
}

int TTriangleLeftRight::sDrawByHight(int x, int y, int aH, unsigned int aClr)
{
	int x2,y2,IsOdd;
	int WidthHasDarw;
	int StartH;
	if(aH & 0x00000001){
		StartH =1;
		IsOdd = 1; 
		y2 = y + (aH/2);
	}else{
		StartH =2;
		IsOdd = 0;
		y2 = y + (aH/2) -1;
	}
	WidthHasDarw = 0;
	
	x2 = x;
	for(int h=StartH; h<=aH; h+=2){
		VertLineRender(x2, y2, h, aClr);
		y2--;
		x2++;
		WidthHasDarw ++;
	}

	WidthHasDarw += aH /5;
	x2 += aH /5;
	
	y2 = y;
	for(int h=aH; h>=StartH; h-=2){
		VertLineRender(x2, y2, h, aClr);
		x2++;
		y2++;
		WidthHasDarw ++;
	}
	return WidthHasDarw;
}

int TTriangleLeftRight::sDrawLeftByHight(int x, int y, int aH, unsigned int aClr)
{
	int x2,y2,IsOdd;
	int WidthHasDarw;
	int StartH;
	if(aH & 0x00000001){
		StartH =1;
		IsOdd = 1; 
		y2 = y + (aH/2);
	}else{
		StartH =2;
		IsOdd = 0;
		y2 = y + (aH/2) -1;
	}
	WidthHasDarw = 0;
	
	x2 = x;
	for(int h=StartH; h<=aH; h+=2){
		VertLineRender(x2, y2, h, aClr);
		y2--;
		x2++;
		WidthHasDarw ++;
	}

	WidthHasDarw += aH /5;
	return WidthHasDarw;
}

int TTriangleLeftRight::sDrawRightByHight(int x, int y, int aH, unsigned int aClr)
{
	int x2,y2,IsOdd;
	int WidthHasDarw;
	int StartH;
	if(aH & 0x00000001){
		StartH =1;
		IsOdd = 1; 
		y2 = y + (aH/2);
	}else{
		StartH =2;
		IsOdd = 0;
		y2 = y + (aH/2) -1;
	}
	WidthHasDarw = 0;
	
	x2 = x;
	y2 = y;
	for(int h=aH; h>=StartH; h-=2){
		VertLineRender(x2, y2, h, aClr);
		x2++;
		y2++;
		WidthHasDarw ++;
	}
	return WidthHasDarw;
}








































