forked from KolibriOS/kolibrios
2150 lines
44 KiB
C++
2150 lines
44 KiB
C++
/*
|
|
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);
|
|
}
|
|
|
|
|