kolibrios/programs/develop/libraries/libGUI/SRC/draw_controls.inc

/*
	functions for draw controls
*/

//---------------------------------------------------------------------------------
//				fill buffer by value
//---------------------------------------------------------------------------------
void FillArrea(void *buf,DWORD size,BYTE bits_per_pixel,DWORD value)
{
	DWORD	i,j;
	char	r,g,b;

	switch(bits_per_pixel)
	{
		case 32:
		{
			j=(size >> 2);
			for(i=0;i<j;i++)
			{
				*(DWORD*)buf=(DWORD)value;
				buf=(DWORD*)buf+1;
			}
			break;
		}
		case 24:
		{
			b=value & 0xff;
			value=value >> 8;
			g=value & 0xff;
			value=value >> 8;
			r=value & 0xff;

			j=(size/3);
			for(i=0;i<j;i++)
			{
				*(char*)buf=(char)b;
				*((char*)buf+1)=(char)g;
				*((char*)buf+2)=(char)r;
				buf=(char*)buf+3;
			}
			break;
		}
		case 16:
		{
			break;
		}
		case 8:
		{
			break;
		}
		case 4:
		{
			break;
		}
		default: break;
	}
}

//---------------------------------------------------------------------------------
//				draw pixel on screen
//---------------------------------------------------------------------------------
void DrawPixel(int x,int y,DWORD color)
{
	char		r,g,b;
	char		*ptr;
	DWORD	*ptr2;

	if (x>screen.size_x-1) {x=screen.size_x-1;}
	if (y>screen.size_y-1) {y=screen.size_y-1;}
	if (x<0) {x=0;}
	if (y<0) {y=0;}

	switch(screen.draw_output)
	{
		case DRAW_OUTPUT_SCREEN:
		{
			x+=screen.x;
			y+=screen.y;
			gui_ksys_put_pixel_window(x,y,color);
			break;
		}
		case DRAW_OUTPUT_BUFFER:
		{
			ptr=screen.buffer;
			switch(screen.bits_per_pixel)
			{
				case 24:
				{
					ptr=ptr+(y*screen.size_x+x)*3;
					b=color & 0xff;
					color=color >>8;
					g=color & 0xff;
					color=color >>8;
					r=color & 0xff;

					ptr[0]=b;
					ptr[1]=g;
					ptr[2]=r;
					break;
				}
				case 32:
				{
					ptr2=(DWORD*)ptr+y*screen.size_x+x;
					*ptr2=color;
					break;
				}
				default: break;
			}
			break;
		}
	}
}

//---------------------------------------------------------------------------------
//		libGUI function drawing pixels on screen with finition
//---------------------------------------------------------------------------------
void DrawPixelFinit(struct FINITION *fin,int x,int y,DWORD color)
{
	if (x>=fin->x && x<=fin->x+fin->sizex-1 &&
		y>=fin->y && y<=fin->y+fin->sizey-1) DrawPixel(x,y,color);
}


//---------------------------------------------------------------------------------
//			get color of pixel inc coordinates x,y
//---------------------------------------------------------------------------------
DWORD GetColorPixel(int x,int y)
{
	char		r,g,b;
	char		*ptr;
	DWORD	color,coordinates;
	DWORD	*ptr2;

	if (x>screen.size_x-1) {x=screen.size_x-1;}
	if (y>screen.size_y-1) {y=screen.size_y-1;}
	if (x<0) {x=0;}
	if (y<0) {y=0;}

	switch(screen.draw_output)
	{
		case DRAW_OUTPUT_SCREEN:
		{
			x+=screen.x;
			y+=screen.y;
			coordinates=x;
			coordinates=coordinates << 16;
			coordinates +=y;
			color=gui_ksys_get_color_pixel_window(coordinates);
			break;
		}
		case DRAW_OUTPUT_BUFFER:
		{
			ptr=screen.buffer;
			switch(screen.bits_per_pixel)
			{
				case 24:
				{
					ptr=ptr+(y*screen.size_x+x)*3;
					color=*ptr;
					color=color & 0xffffff;
					break;
				}
				case 32:
				{
					ptr2=(DWORD*)ptr+y*screen.size_x+x;
					color=*ptr2;
					break;
				}
				default: break;
			}
		}
	}
	return(color);
}

//---------------------------------------------------------------------------------
//				draw vertical line on screen
//---------------------------------------------------------------------------------
void DrawVerticalLine(int x,int y1,int y2,DWORD color)
{
	char		r,g,b;
	char		*ptr;
	DWORD	*ptr2;
	int		a,i,count;

	if (x>screen.size_x-1) {x=screen.size_x-1;}
	if (y1>screen.size_y-1) {y1=screen.size_y-1;}
	if (y2>screen.size_y-1) {y2=screen.size_y-1;}
	if (x<0) {x=0;}
	if (y1<0) {y1=0;}
	if (y2<0) {y2=0;}

	switch(screen.draw_output)
	{
		case DRAW_OUTPUT_SCREEN:
		{
			x+=screen.x;
			y1+=screen.y;
			y2+=screen.y;
			gui_ksys_draw_line_window(x,y1,x,y2,color);
			break;
		}
		case DRAW_OUTPUT_BUFFER:
		{
			if (y1<y2)	{a=y1;count=y2-y1;}
				else
					{a=y2;count=y1-y2;}

			ptr=screen.buffer;
			switch(screen.bits_per_pixel)
			{
				case 24:
				{
					ptr=ptr+(a*screen.size_x+x)*3;
					b=color & 0xff;
					color=color >>8;
					g=color & 0xff;
					color=color >>8;
					r=color & 0xff;

					a=screen.size_x*3;
					for(i=0;i<=count;i++)
					{
						ptr[0]=b;
						ptr[1]=g;
						ptr[2]=r;
						ptr+=a;
					}
					break;
				}
				case 32:
				{
					ptr2=(DWORD*)ptr+a*screen.size_x+x;
					a=screen.size_x;
					for(i=0;i<=count;i++)
					{
						*ptr2=color;
						ptr2+=a;
					}
					break;
				}
				default: break;
			}
		}
	}
}

//---------------------------------------------------------------------------------
//			draw finited vertical line on screen
//---------------------------------------------------------------------------------
void DrawVerticalLineFinit(struct FINITION *fin,int x,int y1,int y2,DWORD color)
{
	int	xmin,xmax,ymin,ymax,v,sy;

	xmin=fin->x;
	xmax=fin->x+fin->sizex-1;
	ymin=fin->y;
	ymax=fin->y+fin->sizey-1;

	if (y2<y1)
	{
		v=y1;
		y1=y2;
		y2=v;
	}

	if (x<xmin) return;
	if (x>xmax) return;
	if (y2<ymin) return;
	if (y1>ymax) return;

	//finit x coordinates and sizex
	sy=y1-ymin;

	if (sy>=0)
	{
		if (y2>ymax) y2=ymax;
	}
	else
	{
		y1=ymin;
		if (y2>ymax)	y2=ymax;
	}
	DrawVerticalLine(x,y1,y2,color);
}

//---------------------------------------------------------------------------------
//			draw horizontal line on screen
//---------------------------------------------------------------------------------
void DrawHorizontalLine(int x1,int x2,int y,DWORD color)
{
	char		r,g,b;
	char		*ptr;
	int		a,i,count;
	DWORD	*ptr2;

	if (y>screen.size_y-1) {y=screen.size_y-1;}
	if (x1>screen.size_x-1) {x1=screen.size_x-1;}
	if (x2>screen.size_x-1) {x2=screen.size_x-1;}
	if (y<0) {y=0;}
	if (x1<0) {x1=0;}
	if (x2<0) {x2=0;}

	switch(screen.draw_output)
	{
		case DRAW_OUTPUT_SCREEN:
		{
			x1+=screen.x;
			x2+=screen.x;
			y+=screen.y;
			gui_ksys_draw_line_window(x1,y,x2,y,color);
			break;
		}
		case DRAW_OUTPUT_BUFFER:
		{
			if (x1<x2)	{a=x1;count=x2-x1;}
				else
					{a=x2;count=x1-x2;}

			ptr=screen.buffer;
			switch(screen.bits_per_pixel)
			{
				case 24:
				{
					ptr=ptr+(y*screen.size_x+a)*3;
					b=color & 0xff;
					color=color >>8;
					g=color & 0xff;
					color=color >>8;
					r=color & 0xff;

					for(i=0;i<=count;i++)
					{
						ptr[0]=b;
						ptr[1]=g;
						ptr[2]=r;
						ptr=ptr+3;
					}
					break;
				}
				case 32:
				{
					ptr2=(DWORD*)ptr+y*screen.size_x+a;

					for(i=0;i<=count;i++)
					{
						*ptr2=color;ptr2++;
					}
					break;
				}
				default:break;
			}
		}
	}
}

//---------------------------------------------------------------------------------
//			draw finited vertical line on screen
//---------------------------------------------------------------------------------
void DrawHorizontalLineFinit(struct FINITION *fin,int x1,int x2,int y,DWORD color)
{
	int	xmin,xmax,ymin,ymax,v,sx;

	xmin=fin->x;
	xmax=fin->x+fin->sizex-1;
	ymin=fin->y;
	ymax=fin->y+fin->sizey-1;

	if (x2<x1)
	{
		v=x1;
		x1=x2;
		x2=v;
	}

	if (y<ymin) return;
	if (y>ymax) return;
	if (x2<xmin) return;
	if (x1>xmax) return;

	//finit x coordinates and sizex
	sx=x1-xmin;

	if (sx>=0)
	{
		if (x2>xmax) x2=xmax;
	}
	else
	{
		x1=xmin;
		if (x2>xmax)	x2=xmax;
	}
	DrawHorizontalLine(x1,x2,y,color);
}

//---------------------------------------------------------------------------------
//			libGUI function drawing line on screen
//---------------------------------------------------------------------------------
int sign(int value)
{
	if (value==0) return(0);
	if (value<0) {return(-1);}
	else {return(1);}
}

int abs(int value)
{
	if (value<0) {value=-value;}

	return(value);
}

void DrawLine(int x1, int y1, int x2, int y2,DWORD color)
{
    int x;
    int y;
    int dx;
    int dy;
    int sx;
    int sy;
    int z;
    int e;
    int i;
    char ch;

	switch(screen.draw_output)
	{
		case DRAW_OUTPUT_SCREEN:
		{
			if (y1>screen.size_y-1) {y1=screen.size_y-1;}
			if (y2>screen.size_y-1) {y2=screen.size_y-1;}
			if (x1>screen.size_x-1) {x1=screen.size_x-1;}
			if (x2>screen.size_x-1) {x2=screen.size_x-1;}
			if (y1<0) {y1=0;}
			if (y2<0) {y2=0;}
			if (x1<0) {x1=0;}
			if (x2<0) {x2=0;}

			x1+=screen.x;
			x2+=screen.x;
			y1+=screen.y;
			y2+=screen.y;
			gui_ksys_draw_line_window(x1,y1,x2,y2,color);
			break;
		}
		case DRAW_OUTPUT_BUFFER:
		{

			x = x1;
			y = y1;
			dx = abs(x2-x1);
			dy = abs(y2-y1);
			sx = sign(x2-x1);
			sy = sign(y2-y1);

			if( dx==0 && dy==0 )
			{
				DrawPixel(x1, y1,color);
				return;
			}
			if( dy>dx )
			{
				z = dx;
				dx = dy;
				dy = z;
				ch = 1;
			}
			else
			{
				ch = 0;
			}
			e = 2*dy-dx;
			i = 1;

			do
			{
				DrawPixel(x,y,color);
				while(e>=0)
				{
					if( ch==1 )	x = x+sx;
						else	y = y+sy;

					if( ch==1 )	y = y+sy;
						else	x = x+sx;

					e = e-2*dx;
				}
				if( ch==1 )		y = y+sy;
					else		x = x+sx;

				e = e+2*dy;
				i++;
			}
			while(i<=dx);
			DrawPixel(x, y,color);
			break;
		}
	}
}

//---------------------------------------------------------------------------------
//			libGUI function drawing rectangle on screen
//---------------------------------------------------------------------------------
void DrawRectangle(int x,int y,int size_x,int size_y,DWORD color)
{

	if (size_x==0 || size_y==0) return;

	DrawHorizontalLine(x,x+size_x-1,y,color);
	DrawVerticalLine(x+size_x-1,y,y+size_y-1,color);
	DrawHorizontalLine(x,x+size_x-1,y+size_y-1,color);
	DrawVerticalLine(x,y,y+size_y-1,color);
}

//---------------------------------------------------------------------------------
//			libGUI function drawing finited rectangle on screen
//---------------------------------------------------------------------------------
void DrawRectangleFinit(struct FINITION *fin,int x,int y,int size_x,int size_y,DWORD color)
{

	if (size_x==0 || size_y==0) return;

	DrawHorizontalLineFinit(fin,x,x+size_x-1,y,color);
	DrawVerticalLineFinit(fin,x+size_x-1,y,y+size_y-1,color);
	DrawHorizontalLineFinit(fin,x,x+size_x-1,y+size_y-1,color);
	DrawVerticalLineFinit(fin,x,y,y+size_y-1,color);
}

//---------------------------------------------------------------------------------
//			libGUI function drawing filled rectangle on screen
//---------------------------------------------------------------------------------
void DrawFilledRectangle(int x,int y,int size_x,int size_y,DWORD color)
{
	int	i,j;
	int	x1,y1,x2,y2;

	if (size_x==0 || size_y==0) return;

	switch(screen.draw_output)
	{
		case DRAW_OUTPUT_SCREEN:
		{
			x1=x;
			y1=y;
			x2=x+size_x-1;
			y2=y+size_y-1;
			if (y1>screen.size_y-1) {y1=screen.size_y-1;}
			if (y2>screen.size_y-1) {y2=screen.size_y-1;}
			if (x1>screen.size_x-1) {x1=screen.size_x-1;}
			if (x2>screen.size_x-1) {x2=screen.size_x-1;}
			if (y1<0) {y1=0;}
			if (y2<0) {y2=0;}
			if (x1<0) {x1=0;}
			if (x2<0) {x2=0;}

			size_x=x2-x1+1;
			size_y=y2-y1+1;
			x1+=screen.x;
			y1+=screen.y;

			gui_ksys_draw_filled_rectangle_window(x1,y1,size_x,size_y,color);
			break;
		}
		case DRAW_OUTPUT_BUFFER:
		{
			j=y;
			for(i=0;i<size_y;i++)
			{
				DrawHorizontalLine(x,x+size_x-1,j,color);
				j++;
			}
			break;
		}
	}
}

//---------------------------------------------------------------------------------
//	libGUI function drawing filled gradient up and down rectangles on screen
//---------------------------------------------------------------------------------
void DrawGradientUpDownFilledRectangle(char flag_up,int x,int y,int sizex,int sizey,DWORD color_from,DWORD color_to)
{
	unsigned	char	r_f,g_f,b_f;
	unsigned	char	r_t,g_t,b_t;
	unsigned	char	r,g,b;
	float			f_r,f_g,f_b;
	float			d_r,d_g,d_b;
	float			div;
	DWORD		color;
	int			i,j,dj;

	if (sizex==0 || sizey==0) return;

	color=color_from;
	b_f=color & 0xff;
	color=color >> 8;
	g_f=color & 0xff;
	color=color >> 8;
	r_f=color & 0xff;

	color=color_to;
	b_t=color & 0xff;
	color=color >> 8;
	g_t=color & 0xff;
	color=color >> 8;
	r_t=color & 0xff;

	div=sizey-1;
	d_r=(float)(r_t-r_f);
	d_r=d_r/div;
	d_g=(float)(g_t-g_f);
	d_g=d_g/div;
	d_b=(float)(b_t-b_f);
	d_b=d_b/div;

	f_r=r_f;
	f_g=g_f;
	f_b=b_f;

	r=r_f;
	g=g_f;
	b=b_f;

	if (flag_up==TRUE)
	{
		j=y+sizey-1;
		dj=-1;
	}
	else
	{
		j=y;
		dj=1;
	}


	for(i=0;i<sizey;i++)
	{
		color=0;
		color=color | r;
		color=color << 8;
		color=color | g;
		color=color << 8;
		color=color | b;

		DrawHorizontalLine(x,x+sizex-1,j,color);

		f_r=f_r+d_r;
		f_g=f_g+d_g;
		f_b=f_b+d_b;

		r=(char)f_r;
		g=(char)f_g;
		b=(char)f_b;

		j=j+dj;
	}

}

//---------------------------------------------------------------------------------
//	libGUI function drawing filled gradient left and right rectangles on screen
//---------------------------------------------------------------------------------
void DrawGradientLeftRightFilledRectangle(char flag_left,int x,int y,int sizex,int sizey,DWORD color_from,DWORD color_to)
{
	unsigned	char	r_f,g_f,b_f;
	unsigned	char	r_t,g_t,b_t;
	unsigned	char	r,g,b;
	float			f_r,f_g,f_b;
	float			d_r,d_g,d_b;
	float			div;
	DWORD		color;
	int			i,j,dj;

	if (sizex==0 || sizey==0) return;

	color=color_from;
	b_f=color & 0xff;
	color=color >> 8;
	g_f=color & 0xff;
	color=color >> 8;
	r_f=color & 0xff;

	color=color_to;
	b_t=color & 0xff;
	color=color >> 8;
	g_t=color & 0xff;
	color=color >> 8;
	r_t=color & 0xff;

	div=sizex-1;
	d_r=(float)(r_t-r_f);
	d_r=d_r/div;
	d_g=(float)(g_t-g_f);
	d_g=d_g/div;
	d_b=(float)(b_t-b_f);
	d_b=d_b/div;

	f_r=r_f;
	f_g=g_f;
	f_b=b_f;

	r=r_f;
	g=g_f;
	b=b_f;

	if (flag_left==TRUE)
	{
		j=x;
		dj=1;
	}
	else
	{
		j=x+sizex-1;
		dj=-1;
	}

	for(i=0;i<sizex;i++)
	{
		color=0;
		color=color | r;
		color=color << 8;
		color=color | g;
		color=color << 8;
		color=color | b;

		DrawVerticalLine(j,y,y+sizey-1,color);

		f_r=f_r+d_r;
		f_g=f_g+d_g;
		f_b=f_b+d_b;

		r=(char)f_r;
		g=(char)f_g;
		b=(char)f_b;

		j=j+dj;
	}

}

//---------------------------------------------------------------------------------
//			libGUI function drawing circle on screen
//---------------------------------------------------------------------------------
void DrawCircle(int xc, int yc, int r,DWORD color)
{
	int x;
	int y;
	int d;

	x = 0;
	y = r;
	d = 3-2*r;
	while(y>=x)
	{
		DrawPixel(x+xc,y+yc,color);
		DrawPixel(x+xc,-y+yc,color);
		DrawPixel(-x+xc,y+yc,color);
		DrawPixel(-x+xc,-y+yc,color);
		DrawPixel(y+xc,x+yc,color);
		DrawPixel(y+xc,-x+yc,color);
		DrawPixel(-y+xc,x+yc,color);
		DrawPixel(-y+xc,-x+yc,color);
		if( d<0 )
		{
			d = d+4*x+6;
		}
		else
		{
			d = d+4*(x-y)+10;
			y--;
		}
		x++;
	}
}

//---------------------------------------------------------------------------------
//		libGUI function drawing circle on screen with finition
//---------------------------------------------------------------------------------
void DrawCircleFinit(struct FINITION *fin,int xc, int yc, int r,DWORD color)
{
	int x;
	int y;
	int d;

	x = 0;
	y = r;
	d = 3-2*r;
	while(y>=x)
	{
		DrawPixelFinit(fin,x+xc,y+yc,color);
		DrawPixelFinit(fin,x+xc,-y+yc,color);
		DrawPixelFinit(fin,-x+xc,y+yc,color);
		DrawPixelFinit(fin,-x+xc,-y+yc,color);
		DrawPixelFinit(fin,y+xc,x+yc,color);
		DrawPixelFinit(fin,y+xc,-x+yc,color);
		DrawPixelFinit(fin,-y+xc,x+yc,color);
		DrawPixelFinit(fin,-y+xc,-x+yc,color);
		if( d<0 )
		{
			d = d+4*x+6;
		}
		else
		{
			d = d+4*(x-y)+10;
			y--;
		}
		x++;
	}
}

//---------------------------------------------------------------------------------
//		libGUI function drawing filled circle on screen
//---------------------------------------------------------------------------------
void DrawFilledCircle(int xc, int yc, int r,DWORD color)
{
	int		xl,yu,xr,yd;
	int		i,j;
	DWORD	pixcolor;

	DrawCircle(xc,yc,r,color);

	yu=yc;
	yd=yc;
	for(i=0;i<r;i++)
	{
		xl=xc;
		xr=xc+1;
		j=0;
		//fill left up
		while((pixcolor=GetColorPixel(xl,yu))!=color)
		{
			DrawPixel(xl,yu,color);
			xl--;
			j++;
			if (j>r) break;
		}
		j=0;
		//fill right up
		while((pixcolor=GetColorPixel(xr,yu))!=color)
		{
			DrawPixel(xr,yu,color);
			xr++;
			j++;
			if (j>r) break;
		}

		xl=xc;
		xr=xc+1;
		j=0;
		//fill left down
		while((pixcolor=GetColorPixel(xl,yd))!=color)
		{
			DrawPixel(xl,yd,color);
			xl--;
			j++;
			if (j>r) break;
		}
		j=0;
		//fill right down
		while((pixcolor=GetColorPixel(xr,yd))!=color)
		{
			DrawPixel(xr,yd,color);
			xr++;
			j++;
			if (j>r) break;
		}
		yu--;
		yd++;
	}
}

//---------------------------------------------------------------------------------
//	libGUI function drawing filled circle on screen with finition
//---------------------------------------------------------------------------------
void DrawFilledCircleFinit(struct FINITION *fin,int xc, int yc, int r,DWORD color)
{
	int		xl,yu,xr,yd;
	int		i,j;
	DWORD	pixcolor;

	DrawCircleFinit(fin,xc,yc,r,color);

	yu=yc;
	yd=yc;
	for(i=0;i<r;i++)
	{
		xl=xc;
		xr=xc+1;
		//fill left up
		for(j=0;j<r;j++)
		{
			if (xl>=fin->x && xl<=fin->x+fin->sizex &&
				yu>=fin->y && yu<=fin->y+fin->sizey)
			{
				pixcolor=GetColorPixel(xl,yu);
				if (pixcolor!=color)	DrawPixel(xl,yu,color);
					else break;
			}
			xl--;
		}
		//fill right up
		for(j=0;j<r;j++)
		{
			if (xr>=fin->x && xr<=fin->x+fin->sizex &&
				yu>=fin->y && yu<=fin->y+fin->sizey)
			{
				pixcolor=GetColorPixel(xr,yu);
				if (pixcolor!=color)	DrawPixel(xr,yu,color);
					else break;
			}
			xr++;
		}

		xl=xc;
		xr=xc+1;
		//fill left down
		for(j=0;j<r;j++)
		{
			if (xl>=fin->x && xl<=fin->x+fin->sizex &&
				yd>=fin->y && yd<=fin->y+fin->sizey)
			{
				pixcolor=GetColorPixel(xl,yd);
				if (pixcolor!=color)	DrawPixel(xl,yd,color);
					else break;
			}
			xl--;
		}
		//fill right down
		for(j=0;j<r;j++)
		{
			if (xr>=fin->x && xr<=fin->x+fin->sizex &&
				yd>=fin->y && yd<=fin->y+fin->sizey)
			{
				pixcolor=GetColorPixel(xr,yd);
				if (pixcolor!=color)	DrawPixel(xr,yd,color);
					else break;
			}
			xr++;
		}
		yu--;
		yd++;
	}
}

//---------------------------------------------------------------------------------
//			libGUI function drawing ellipse on screen
//---------------------------------------------------------------------------------
void DrawEllipse(int x,int y,int a,int b,DWORD color)
{
	int	col,i,row,bnew;
	long	a_square,b_square,two_a_square,two_b_square,four_a_square,four_b_square,d;

	b_square=b*b;
	a_square=a*a;
	row=b;
	col=0;
	two_a_square=a_square<<1;
	four_a_square=a_square<<2;
	four_b_square=b_square<<2;
	two_b_square=b_square<<1;
	d=two_a_square*((row-1)*(row))+a_square+two_b_square*(1-a_square);
	while(a_square*(row)>b_square*(col))
	{
		DrawPixel(col+x,row+y,color);
		DrawPixel(col+x,y-row,color);
		DrawPixel(x-col,row+y,color);
		DrawPixel(x-col,y-row,color);

		if (d>=0)
		{
			row--;
			d-=four_a_square*(row);
		}
		d+=two_b_square*(3+(col<<1));
		col++;
	}

	d=two_b_square*(col+1)*col+two_a_square*(row*(row-2)+1)+(1-two_a_square)*b_square;
	while ((row) + 1)
	{
		DrawPixel(col+x, row+y, color);
		DrawPixel(col+x, y-row, color);
		DrawPixel(x-col, row+y, color);
		DrawPixel(x-col, y-row, color);

		if (d<=0)
		{
			col++;
			d+=four_b_square*col;
		}
		row--;
		d+=two_a_square*(3-(row <<1));
	}
}

//---------------------------------------------------------------------------------
//		libGUI function drawing ellipse on screen with finition
//---------------------------------------------------------------------------------
void DrawEllipseFinit(struct FINITION *fin,int x,int y,int a,int b,DWORD color)
{
	int	col,i,row,bnew;
	long	a_square,b_square,two_a_square,two_b_square,four_a_square,four_b_square,d;

	b_square=b*b;
	a_square=a*a;
	row=b;
	col=0;
	two_a_square=a_square<<1;
	four_a_square=a_square<<2;
	four_b_square=b_square<<2;
	two_b_square=b_square<<1;
	d=two_a_square*((row-1)*(row))+a_square+two_b_square*(1-a_square);

	while(a_square*(row)>b_square*(col))
	{
		DrawPixelFinit(fin,col+x,row+y,color);
		DrawPixelFinit(fin,col+x,y-row,color);
		DrawPixelFinit(fin,x-col,row+y,color);
		DrawPixelFinit(fin,x-col,y-row,color);

		if (d>=0)
		{
			row--;
			d-=four_a_square*(row);
		}
		d+=two_b_square*(3+(col<<1));
		col++;
	}

	d=two_b_square*(col+1)*col+two_a_square*(row*(row-2)+1)+(1-two_a_square)*b_square;
	while ((row) + 1)
	{
		DrawPixelFinit(fin,col+x, row+y, color);
		DrawPixelFinit(fin,col+x, y-row, color);
		DrawPixelFinit(fin,x-col, row+y, color);
		DrawPixelFinit(fin,x-col, y-row, color);

		if (d<=0)
		{
			col++;
			d+=four_b_square*col;
		}
		row--;
		d+=two_a_square*(3-(row <<1));
	}
}

//---------------------------------------------------------------------------------
//		libGUI function drawing filled ellips on screen
//---------------------------------------------------------------------------------
void DrawFilledEllipse(int xc, int yc, int a,int b,DWORD color)
{
	int		xl,yu,xr,yd;
	int		i,j;
	DWORD	pixcolor;

	DrawEllipse(xc,yc,a,b,color);

	yu=yc;
	yd=yc;
	for(i=0;i<b;i++)
	{
		xl=xc;
		xr=xc+1;
		j=0;
		//fill left up
		while((pixcolor=GetColorPixel(xl,yu))!=color)
		{
			DrawPixel(xl,yu,color);
			xl--;
			j++;
			if (j>a) break;
		}
		j=0;
		//fill right up
		while((pixcolor=GetColorPixel(xr,yu))!=color)
		{
			DrawPixel(xr,yu,color);
			xr++;
			j++;
			if (j>a) break;
		}

		xl=xc;
		xr=xc+1;
		j=0;
		//fill left down
		while((pixcolor=GetColorPixel(xl,yd))!=color)
		{
			DrawPixel(xl,yd,color);
			xl--;
			j++;
			if (j>a) break;
		}
		j=0;
		//fill right down
		while((pixcolor=GetColorPixel(xr,yd))!=color)
		{
			DrawPixel(xr,yd,color);
			xr++;
			j++;
			if (j>a) break;
		}
		yu--;
		yd++;
	}
}

//---------------------------------------------------------------------------------
//	libGUI function drawing filled circle on screen with finition
//---------------------------------------------------------------------------------
void DrawFilledEllipseFinit(struct FINITION *fin,int xc, int yc, int a,int b,DWORD color)
{
	int		xl,yu,xr,yd;
	int		i,j;
	DWORD	pixcolor;

	DrawEllipseFinit(fin,xc,yc,a,b,color);

	yu=yc;
	yd=yc;
	for(i=0;i<b;i++)
	{
		xl=xc;
		xr=xc+1;
		//fill left up
		for(j=0;j<a;j++)
		{
			if (xl>=fin->x && xl<=fin->x+fin->sizex &&
				yu>=fin->y && yu<=fin->y+fin->sizey)
			{
				pixcolor=GetColorPixel(xl,yu);
				if (pixcolor!=color)	DrawPixel(xl,yu,color);
					else break;
			}
			xl--;
		}
		//fill right up
		for(j=0;j<a;j++)
		{
			if (xr>=fin->x && xr<=fin->x+fin->sizex &&
				yu>=fin->y && yu<=fin->y+fin->sizey)
			{
				pixcolor=GetColorPixel(xr,yu);
				if (pixcolor!=color)	DrawPixel(xr,yu,color);
					else break;
			}
			xr++;
		}

		xl=xc;
		xr=xc+1;
		//fill left down
		for(j=0;j<a;j++)
		{
			if (xl>=fin->x && xl<=fin->x+fin->sizex &&
				yd>=fin->y && yd<=fin->y+fin->sizey)
			{
				pixcolor=GetColorPixel(xl,yd);
				if (pixcolor!=color)	DrawPixel(xl,yd,color);
					else break;
			}
			xl--;
		}
		//fill right down
		for(j=0;j<a;j++)
		{
			if (xr>=fin->x && xr<=fin->x+fin->sizex &&
				yd>=fin->y && yd<=fin->y+fin->sizey)
			{
				pixcolor=GetColorPixel(xr,yd);
				if (pixcolor!=color)	DrawPixel(xr,yd,color);
					else break;
			}
			xr++;
		}
		yu--;
		yd++;
	}
}

//---------------------------------------------------------------------------------
//		libGUI function drawing image on screen
//---------------------------------------------------------------------------------
void	DrawImage(int x,int y,int sizex,int sizey,char bits_per_pixel,char *img)
{
	char			r,g,b;
	int			i,j,countx,county;
	int			x2,y2;
	DWORD			pitch_src,pitch_screen,add_src,add_screen;
	char			*ptr_src,*ptr_screen,ptr_max;
	char			*ptr_src2,*ptr_screen2;
	DWORD			*ptr_src3;

	if (img==NULL)	return;
	if (x>screen.size_x-1) return;
	if (y>screen.size_y-1) return;

	x2=x+sizex-1;
	y2=y+sizey-1;


	if (y2>screen.size_y-1) {y2=screen.size_y-1;}
	if (x2>screen.size_x-1) {x2=screen.size_x-1;}
	if (y<0) y=0;
	if (y2<0) y2=0;
	if (x<0) x=0;
	if (x2<0) x2=0;

	countx=x2-x+1;
	county=y2-y+1;

	switch(screen.draw_output)
	{
		case DRAW_OUTPUT_SCREEN:
		{
			x+=screen.x;
			y+=screen.y;

			switch(screen.bits_per_pixel)
			{
				case 32:
				case 24:
				{
					switch(bits_per_pixel)
					{//check bits per pixel in picture
						case 32:
						{//convert 32 bit image to 24 bit image
							j=sizex*sizey;
							ptr_src=img;
							ptr_screen=malloc(j*3);
							ptr_screen2=ptr_screen;
							for(i=0;i<j;i++)
							{
								*(char*)ptr_screen=*(char*)ptr_src;
								*((char*)ptr_screen+1)=*((char*)ptr_src+1);
								*((char*)ptr_screen+2)=*((char*)ptr_src+2);

								ptr_src+=4;
								ptr_screen+=3;
							}
							gui_ksys_put_image_window(ptr_screen2,x,y,countx,county);
							free(ptr_screen2);
							break;
						}
						case 24:
						{
							gui_ksys_put_image_window(img,x,y,countx,county);
							break;
						}
					}
					break;
				}
				default: break;
			}
			break;
		}
		case DRAW_OUTPUT_BUFFER:
		{
			switch(screen.bits_per_pixel)
			{
				case 24:
				{//check source image resolution
					switch(bits_per_pixel)
					{
						case 32://display 32 bit image in 24 bit mode
						{//convert and draw 32 bit image in 24 bit buffer
							ptr_screen=screen.buffer+(screen.size_x*y+x)*3;
							add_screen=(screen.size_x-countx)*3;
							ptr_src=img;
							//copy line of byte with size x
							for(i=0;i<county;i++)
							{
								for(j=0;j<countx;j++)
								{
									*(char*)ptr_screen=*(char*)ptr_src;
									*((char*)ptr_screen+1)=*((char*)ptr_src+1);
									*((char*)ptr_screen+2)=*((char*)ptr_src+2);
		
									ptr_src+=4;
									ptr_screen+=3;
								}
								ptr_screen+=add_screen;
							}
							break;
						}
						case 24:
						{//display 24 bit image in 24 bit buffer
							ptr_screen=screen.buffer+(screen.size_x*y+x)*3;
							add_screen=screen.size_x*3;
							add_src=countx*3;

							//copy line of byte with size x
							for(i=0;i<county;i++)
							{
								memmove(ptr_screen,img,add_src);
								ptr_screen+=add_screen;
								img+=add_src;
							}
							break;
						}
						default: break;
					}
					break;
				}
				case 32:
				{	//check source image resolution
					switch(bits_per_pixel)
					{
						case 32:
						{//display 32 bit image in 32 bit mode
							ptr_screen=screen.buffer+(screen.size_x*y+x)*4;
							add_screen=screen.size_x*4;
							add_src=countx*4;

							//copy line of byte with size x
							for(i=0;i<county;i++)
							{
								memmove(ptr_screen,img,add_src);
								ptr_screen+=add_screen;
								img+=add_src;
							}

							break;
						}
						case 24://display 24 bit image in 32 bit mode
						{
							ptr_screen=screen.buffer+(screen.size_x*y+x)*4;
							add_screen=(screen.size_x-countx)*4;
							ptr_src=img;
							//copy line of byte with size x
							for(i=0;i<county;i++)
							{
								for(j=0;j<countx;j++)
								{
									*(char*)ptr_screen=*(char*)ptr_src;
									*((char*)ptr_screen+1)=*((char*)ptr_src+1);
									*((char*)ptr_screen+2)=*((char*)ptr_src+2);
		
									ptr_src+=3;
									ptr_screen+=4;
								}
								ptr_screen+=add_screen;
							}
							break;
						}
						default: break;
					}
					default: break;
				}
			}
		}
	}
}

//---------------------------------------------------------------------------------
//	libGUI function drawing image on screen with finition
//---------------------------------------------------------------------------------
void	DrawImageFinit(finition_t *fin,int x,int y,int sizex,int sizey,char bits_per_pixel,char *img)
{
	int		x1,y1,x2,y2,sx,sy;
	int		xmin,xmax,ymin,ymax;
	int		countline,countx,county,i,j;
	DWORD	pitch_src,add_src;
	char		*ptr_dest,*ptr_src;
	char		bytes_per_pixel;
	char		*buf;

	xmin=fin->x;
	xmax=fin->x+fin->sizex-1;
	ymin=fin->y;
	ymax=fin->y+fin->sizey-1;

	x1=x;
	y1=y;
	x2=x1+sizex-1;
	y2=y1+sizey-1;

	if (x2<xmin) return;
	if (x1>xmax) return;
	if (y2<ymin) return;
	if (y1>ymax) return;

	if (x1>=xmin && x2<=xmax && y1>=ymin && y2<=ymax)
	{
		DrawImage(x,y,sizex,sizey,bits_per_pixel,img);
		return;
	}

	//finit x coordinates and sizex
	sx=x1-xmin;

	if (sx>=0)
	{
		if (x2>xmax) x2=xmax;
	}
	else
	{
		x1=xmin;
		if (x2>xmax) x2=xmax;
	}

	//finit y coordinates and sizey
	sy=y1-ymin;

	if (sy>=0)
	{
		if (y2>ymax) y2=ymax;
	}
	else
	{
		y1=ymin;
		if (y2>ymax) y2=ymax;
	}
	countx=x2-x1+1;
	county=y2-y1+1;

	//cut finited rectangle from image and move them into buffer

	bytes_per_pixel=bits_per_pixel >> 3;
	buf=malloc(countx*county*bytes_per_pixel);
	ptr_dest=buf;

	pitch_src=sizex*bytes_per_pixel;
	ptr_src=img+pitch_src*(y1-y)+(x1-x)*bytes_per_pixel;
	add_src=sizex*bytes_per_pixel;
	countline=countx*bytes_per_pixel;

	switch(bits_per_pixel)
	{
		case 32:
		case 24:
		case 16:
		case 8:
		{
			for(i=0;i<county;i++)
			{
				memmove(ptr_dest,ptr_src,countline);
				ptr_src+=add_src;
				ptr_dest+=countline;
			}
			break;
		}
		default: break;
	}
	//draw cutted by finition image
	DrawImage(x1,y1,countx,county,bits_per_pixel,buf);
	free(buf);
}

//---------------------------------------------------------------------------------
//				libGUI function draw
//---------------------------------------------------------------------------------
void Draw(struct FINITION *finition,int tool_name,...)
{
	va_list arguments;
	char		*img;
	char		first,second,bits_per_pixel;
	int		xmin,xmax,ymin,ymax;
	int		radius;
	int		x,y,x2,y2,x_i,y_i;
	int		sizex,sizey,sx,sy;
	float		x_l1,y_l1,x_l2,y_l2,k,b;
	DWORD	color,color_from,color_to;

	arguments=(va_list)&tool_name+sizeof(int);

	xmin=finition->x;
	xmax=finition->x+finition->sizex-1;
	ymin=finition->y;
	ymax=finition->y+finition->sizey-1;

	switch(tool_name)
	{
		//tool Pixel
		case TOOL_PIXEL:
		{
			x=va_arg(arguments,int);
			y=va_arg(arguments,int);
			color=va_arg(arguments,DWORD);

			if (finition->flags & FINITION_ON)
			{
				if (x>=finition->x && x<=finition->x+finition->sizex
					&& y>=finition->y && y<=finition->y+finition->sizey)
				{	//pixel inside finition arrea
					DrawPixel(x,y,color);
				}
			}
			else
			{	//no finition
				DrawPixel(x,y,color);
			}
			break;
		}
		//tool Line
		case TOOL_LINE:
		{
			x=va_arg(arguments,int);
			y=va_arg(arguments,int);
			x2=va_arg(arguments,int);
			y2=va_arg(arguments,int);
			color=va_arg(arguments,DWORD);

			if (finition->flags & FINITION_ON)
			{
				sizex=abs(x2-x);
				sizey=abs(y2-y);

				if (CheckCrossRectangles(finition->x,finition->y,finition->sizex,
								finition->sizey,x,y,sizex,sizey)==FALSE) break;

				if (x>=finition->x && x<=finition->x+finition->sizex &&
					y>=finition->y && y<=finition->y+finition->sizey &&
					x2>=finition->x && x2<=finition->x+finition->sizex &&
					y2>=finition->y && y2<=finition->y+finition->sizey)
				{
					//line inside finition arrea
					DrawLine(x,y,x2,y2,color);
					break;
				}


				if (x==x2) break;

				//find coefficients of line
				x_l1=x;
				y_l1=y;
				x_l2=x2;
				y_l2=y2;
				k=(y_l1-y_l2)/(x_l1-x_l2);
				b=(y_l2*x_l1-y_l1*x_l2)/(x_l1-x_l2);

				sx=x2-x;//vectore x
				sy=y2-y;//vectore y

				if (x>=finition->x && x<=finition->x+finition->sizex &&
					y>=finition->y && y<=finition->y+finition->sizey)
				{	//point x,y inside finition arrea
					//check cross with left vertical line of finition
					y_l1=k*finition->x+b;
					y_i=(int)y_l1;
					if (y_i>=finition->y && y_i<=finition->y+finition->sizey && sx<0)
					{	//first point for finited line
						x2=finition->x;
						y2=y_i;
						DrawLine(x,y,x2,y2,color);
						break;
					}
					//check cross with up horizontal line of finition
					x_l1=(finition->y-b)/k;
					x_i=(int)x_l1;
					if (x_i>=finition->x && x_i<=finition->x+finition->sizex && sy<0)
					{
						x2=x_i;
						y2=finition->y;
						DrawLine(x,y,x2,y2,color);
						break;
					}
					//check cross with right vertical line of finition
					y_l1=k*(finition->x+finition->sizex)+b;
					y_i=(int)y_l1;
					if (y_i>=finition->y && y_i<=finition->y+finition->sizey && sx>0)
					{
						x2=finition->x+finition->sizex;
						y2=y_i;
						DrawLine(x,y,x2,y2,color);
						break;
					}
					//check cross with down horizontal line of finition
					x_l1=((finition->y+finition->sizey)-b)/k;
					x_i=(int)x_l1;
					if (x_i>=finition->x && x_i<=finition->x+finition->sizex && sy>0)
					{
						x2=x_i;
						y2=finition->y+finition->sizey;
						DrawLine(x,y,x2,y2,color);
						break;
					}
				}

				if (x2>=finition->x && x2<=finition->x+finition->sizex &&
					y2>=finition->y && y2<=finition->y+finition->sizey)
				{	//point x,y inside finition arrea
					//check cross with left vertical line of finition
					y_l1=k*finition->x+b;
					y_i=(int)y_l1;
					if (y_i>=finition->y && y_i<=finition->y+finition->sizey && sx>0)
					{	//first point for finited line
						x=finition->x;
						y=y_i;
						DrawLine(x,y,x2,y2,color);
						break;
					}
					//check cross with up horizontal line of finition
					x_l1=(finition->y-b)/k;
					x_i=(int)x_l1;
					if (x_i>=finition->x && x_i<=finition->x+finition->sizex && sy>0)
					{
						x=x_i;
						y=finition->y;
						DrawLine(x,y,x2,y2,color);
						break;
					}
					//check cross with right vertical line of finition
					y_l1=k*(finition->x+finition->sizex)+b;
					y_i=(int)y_l1;
					if (y_i>=finition->y && y_i<=finition->y+finition->sizey && sx<0)
					{
						x=finition->x+finition->sizex;
						y=y_i;
						DrawLine(x,y,x2,y2,color);
						break;
					}
					//check cross with down horizontal line of finition
					x_l1=((finition->y+finition->sizey)-b)/k;
					x_i=(int)x_l1;
					if (x_i>=finition->x && x_i<=finition->x+finition->sizex && sy<0)
					{
						x=x_i;
						y=finition->y+finition->sizey;
						DrawLine(x,y,x2,y2,color);
						break;
					}
				}

				first=FALSE;
				second=FALSE;
				//check cross with left vertical line of finition
				y_l1=k*finition->x+b;
				y_i=(int)y_l1;
				if (y_i>=finition->y && y_i<=finition->y+finition->sizey)
				{	//first point for finited line
					x=finition->x;
					y=y_i;
					first=TRUE;
				}
				//check cross with up horizontal line of finition
				x_l1=(finition->y-b)/k;
				x_i=(int)x_l1;
				if (x_i>=finition->x && x_i<=finition->x+finition->sizex)
				{
					if (first==FALSE)
					{
						x=x_i;
						y=finition->y;
					}
					else
					{
						x2=x_i;
						y2=finition->y;
						second=TRUE;
					}
				}
				//check cross with right vertical line of finition
				y_l1=k*(finition->x+finition->sizex)+b;
				y_i=(int)y_l1;
				if (y_i>=finition->y && y_i<=finition->y+finition->sizey)
				{
					if (first==FALSE)
					{
						x=finition->x+finition->sizex;
						y=y_i;
					}
					else
					{
						x2=finition->x+finition->sizex;
						y2=y_i;
						second=TRUE;
					}
				}
				//check cross with down horizontal line of finition
				x_l1=((finition->y+finition->sizey)-b)/k;
				x_i=(int)x_l1;
				if (x_i>=finition->x && x_i<=finition->x+finition->sizex)
				{
					if (first==FALSE)
					{
						x=x_i;
						y=finition->y+finition->sizey;
					}
					else
					{
						x2=x_i;
						y2=finition->y+finition->sizey;
						second=TRUE;
					}
				}

				if (first==TRUE && second==TRUE)
				{
					//draw finited line
					DrawLine(x,y,x2,y2,color);
				}
				break;

			}
			else
			{	//no finition
				DrawLine(x,y,x2,y2,color);
			}
			break;
		}
		//tool VerticalLine
		case TOOL_VERTICAL_LINE:
		{
			x=va_arg(arguments,int);
			y=va_arg(arguments,int);
			y2=va_arg(arguments,int);
			color=va_arg(arguments,DWORD);

			if (finition->flags & FINITION_ON)
			{
				DrawVerticalLineFinit(finition,x,y,y2,color);
			}
			else
			{
				DrawVerticalLine(x,y,y2,color);
			}
			break;
		}
		//tool HorizontalLine
		case TOOL_HORIZONTAL_LINE:
		{
			x=va_arg(arguments,int);
			x2=va_arg(arguments,int);
			y=va_arg(arguments,int);
			color=va_arg(arguments,DWORD);

			if (finition->flags & FINITION_ON)
			{
				DrawHorizontalLineFinit(finition,x,x2,y,color);
			}
			else
			{
				DrawHorizontalLine(x,x2,y,color);
			}
			break;
		}

		//tool Rectangle
		case TOOL_RECTANGLE:
		{
			x=va_arg(arguments,int);
			y=va_arg(arguments,int);
			sizex=va_arg(arguments,int);
			sizey=va_arg(arguments,int);
			color=va_arg(arguments,DWORD);

			if (finition->flags & FINITION_ON)
			{
				x2=x+sizex-1;
				y2=y+sizey-1;

				if (x2<xmin) return;
				if (x>xmax) return;
				if (y2<ymin) return;
				if (y>ymax) return;

				DrawRectangleFinit(finition,x,y,sizex,sizey,color);
			}
			else
			{
				DrawRectangle(x,y,sizex,sizey,color);
			}
			break;
		}
		//tool FilledRectangle
		case TOOL_FILLED_RECTANGLE:
		{
			x=va_arg(arguments,int);
			y=va_arg(arguments,int);
			sizex=va_arg(arguments,int);
			sizey=va_arg(arguments,int);
			color=va_arg(arguments,DWORD);

			if (finition->flags & FINITION_ON)
			{
				x2=x+sizex-1;
				y2=y+sizey-1;

				if (x2<xmin) return;
				if (x>xmax) return;
				if (y2<ymin) return;
				if (y>ymax) return;

				//finit x coordinates and sizex
				sx=x-xmin;

				if (sx>=0)
				{
					if (x2>xmax) x2=xmax;
				}
				else
				{
					x=xmin;
					if (x2>xmax) x2=xmax;
				}

				//finit y coordinates and sizey
				sy=y-ymin;

				if (sy>=0)
				{
					if (y2>ymax) y2=ymax;
				}
				else
				{
					y=ymin;
					if (y2>ymax) y2=ymax;
				}

				sizex=x2-x+1;
				sizey=y2-y+1;

				DrawFilledRectangle(x,y,sizex,sizey,color);
			}
			else
			{
				DrawFilledRectangle(x,y,sizex,sizey,color);
			}
			break;
		}
		//tool GradientUpFilledRectangle
		case TOOL_GRADIENT_UP_FILLED_RECTANGLE:
		{
			x=va_arg(arguments,int);
			y=va_arg(arguments,int);
			sizex=va_arg(arguments,int);
			sizey=va_arg(arguments,int);
			color_from=va_arg(arguments,DWORD);
			color_to=va_arg(arguments,DWORD);

			if (finition->flags & FINITION_ON)
			{
				x2=x+sizex-1;
				y2=y+sizey-1;

				if (x2<xmin) return;
				if (x>xmax) return;
				if (y2<ymin) return;
				if (y>ymax) return;

				//finit x coordinates and sizex
				sx=x-xmin;

				if (sx>=0)
				{
					if (x2>xmax) x2=xmax;
				}
				else
				{
					x=xmin;
					if (x2>xmax) x2=xmax;
				}

				//finit y coordinates and sizey
				sy=y-ymin;

				if (sy>=0)
				{
					if (y2>ymax) y2=ymax;
				}
				else
				{
					y=ymin;
					if (y2>ymax) y2=ymax;
				}

				sizex=x2-x+1;
				sizey=y2-y+1;

				DrawGradientUpDownFilledRectangle(TRUE,x,y,sizex,sizey,color_from,color_to);
			}
			else
			{
				DrawGradientUpDownFilledRectangle(TRUE,x,y,sizex,sizey,color_from,color_to);
			}
			break;
		}
		//tool GradientDownFilledRectangle
		case TOOL_GRADIENT_DOWN_FILLED_RECTANGLE:
		{
			x=va_arg(arguments,int);
			y=va_arg(arguments,int);
			sizex=va_arg(arguments,int);
			sizey=va_arg(arguments,int);
			color_from=va_arg(arguments,DWORD);
			color_to=va_arg(arguments,DWORD);

			if (finition->flags & FINITION_ON)
			{
				x2=x+sizex-1;
				y2=y+sizey-1;

				if (x2<xmin) return;
				if (x>xmax) return;
				if (y2<ymin) return;
				if (y>ymax) return;

				//finit x coordinates and sizex
				sx=x-xmin;

				if (sx>=0)
				{
					if (x2>xmax) x2=xmax;
				}
				else
				{
					x=xmin;
					if (x2>xmax) x2=xmax;
				}

				//finit y coordinates and sizey
				sy=y-ymin;

				if (sy>=0)
				{
					if (y2>ymax) y2=ymax;
				}
				else
				{
					y=ymin;
					if (y2>ymax) y2=ymax;
				}

				sizex=x2-x+1;
				sizey=y2-y+1;

				DrawGradientUpDownFilledRectangle(FALSE,x,y,sizex,sizey,color_from,color_to);
			}
			else
			{
				DrawGradientUpDownFilledRectangle(FALSE,x,y,sizex,sizey,color_from,color_to);
			}
			break;
		}
		//tool GradientLeftFilledRectangle
		case TOOL_GRADIENT_LEFT_FILLED_RECTANGLE:
		{
			x=va_arg(arguments,int);
			y=va_arg(arguments,int);
			sizex=va_arg(arguments,int);
			sizey=va_arg(arguments,int);
			color_from=va_arg(arguments,DWORD);
			color_to=va_arg(arguments,DWORD);

			if (finition->flags & FINITION_ON)
			{
				x2=x+sizex-1;
				y2=y+sizey-1;

				if (x2<xmin) return;
				if (x>xmax) return;
				if (y2<ymin) return;
				if (y>ymax) return;

				//finit x coordinates and sizex
				sx=x-xmin;

				if (sx>=0)
				{
					if (x2>xmax) x2=xmax;
				}
				else
				{
					x=xmin;
					if (x2>xmax) x2=xmax;
				}

				//finit y coordinates and sizey
				sy=y-ymin;

				if (sy>=0)
				{
					if (y2>ymax) y2=ymax;
				}
				else
				{
					y=ymin;
					if (y2>ymax) y2=ymax;
				}

				sizex=x2-x+1;
				sizey=y2-y+1;

				DrawGradientLeftRightFilledRectangle(TRUE,x,y,sizex,sizey,color_from,color_to);
			}
			else
			{
				DrawGradientLeftRightFilledRectangle(TRUE,x,y,sizex,sizey,color_from,color_to);
			}
			break;
		}
		//tool GradientRightFilledRectangle
		case TOOL_GRADIENT_RIGHT_FILLED_RECTANGLE:
		{
			x=va_arg(arguments,int);
			y=va_arg(arguments,int);
			sizex=va_arg(arguments,int);
			sizey=va_arg(arguments,int);
			color_from=va_arg(arguments,DWORD);
			color_to=va_arg(arguments,DWORD);

			if (finition->flags & FINITION_ON)
			{
				x2=x+sizex-1;
				y2=y+sizey-1;

				if (x2<xmin) return;
				if (x>xmax) return;
				if (y2<ymin) return;
				if (y>ymax) return;

				//finit x coordinates and sizex
				sx=x-xmin;

				if (sx>=0)
				{
					if (x2>xmax) x2=xmax;
				}
				else
				{
					x=xmin;
					if (x2>xmax) x2=xmax;
				}

				//finit y coordinates and sizey
				sy=y-ymin;

				if (sy>=0)
				{
					if (y2>ymax) y2=ymax;
				}
				else
				{
					y=ymin;
					if (y2>ymax) y2=ymax;
				}

				sizex=x2-x+1;
				sizey=y2-y+1;

				DrawGradientLeftRightFilledRectangle(FALSE,x,y,sizex,sizey,color_from,color_to);
			}
			else
			{
				DrawGradientLeftRightFilledRectangle(FALSE,x,y,sizex,sizey,color_from,color_to);
			}
			break;
		}
		//tool Circle
		case TOOL_CIRCLE:
		{
			x=va_arg(arguments,int);
			y=va_arg(arguments,int);
			radius=va_arg(arguments,int);
			color=va_arg(arguments,DWORD);

			if (finition->flags & FINITION_ON)
			{
				DrawCircleFinit(finition,x,y,radius,color);
			}
			else
			{
				DrawCircle(x,y,radius,color);
			}
			break;
		}
		//tool FilledCircle
		case TOOL_FILLED_CIRCLE:
		{
			x=va_arg(arguments,int);
			y=va_arg(arguments,int);
			radius=va_arg(arguments,int);
			color=va_arg(arguments,DWORD);

			if (finition->flags & FINITION_ON)
			{
				DrawFilledCircleFinit(finition,x,y,radius,color);
			}
			else
			{
				DrawFilledCircle(x,y,radius,color);
			}
			break;
		}
		//tool Ellipse
		case TOOL_ELLIPSE:
		{
			x=va_arg(arguments,int);
			y=va_arg(arguments,int);
			sizex=va_arg(arguments,int);
			sizey=va_arg(arguments,int);
			color=va_arg(arguments,DWORD);

			if (finition->flags & FINITION_ON)
			{
				DrawEllipseFinit(finition,x,y,sizex,sizey,color);
			}
			else
			{
				DrawEllipse(x,y,sizex,sizey,color);
			}
			break;
		}
		//tool FilledEllipse
		case TOOL_FILLED_ELLIPSE:
		{
			x=va_arg(arguments,int);
			y=va_arg(arguments,int);
			sizex=va_arg(arguments,int);
			sizey=va_arg(arguments,int);
			color=va_arg(arguments,DWORD);

			if (finition->flags & FINITION_ON)
			{
				DrawFilledEllipseFinit(finition,x,y,sizex,sizey,color);
			}
			else
			{
				DrawFilledEllipse(x,y,sizex,sizey,color);
			}
			break;
		}
		//tool Image
		case TOOL_IMAGE:
		{
			x=va_arg(arguments,int);
			y=va_arg(arguments,int);
			sizex=va_arg(arguments,int);
			sizey=va_arg(arguments,int);
			bits_per_pixel=(char)va_arg(arguments,int);
			img=va_arg(arguments,char*);

			if (finition->flags & FINITION_ON)
			{
				DrawImageFinit(finition,x,y,sizex,sizey,bits_per_pixel,img);
			}
			else
			{
				DrawImage(x,y,sizex,sizey,bits_per_pixel,img);
			}
			break;
		}
	}
	va_end(arguments);
}