Code:
/************************************************************************
						DOSPAINT
						By Abhishek Dhingra
						written in
						Borland Turbo C
						(code not optmized)

Anyone and Everyone is allowed to use this code freely without any
conditions.
I wrote most of this code as a part of a college assignment in my
Computer Graphics Lab when I was in the 6th semester of Engineering.
I am a student of R.V College of Engineering, Bangalore.
(Computer Science and Engineering, Batch of 2002).
I have no intentions of working to improve this code, so please feel free
to add the extra features that you might require.
Do mail me, however with your comments :-)
I'll reply to the mails ASAP.

	mailto: [email protected]

Dated : 02/08/2001 (dd-mm-yyyy)

If you would prefer contacting me via snail mail, you could reach me at the
following address:

	Abhishek Dhingra
	"Elysium", #63, Versova Layout,
	Kagdaspura Road, C.V Raman Nagar Post,
	Bangalore,
	Karnataka,
	India.
	PIN : 560093
************************************************************************/




#include <graphics.h>
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <dos.h>
#include <math.h>
/*#include <alloc.h>*/

#define MIN_X 83
#define MAX_X 629
#define MIN_Y 30
#define MAX_Y 409
#define MAX_BUTTONS 22
#define MAX_COLPAT 28

#define CLEAR      0
#define MARK_OP    8
#define CLIP_OP    10
#define TRANS_OP   11
#define ROTATE_OP 12
#define DELETE_OP 13
#define FLIP      14
#define MIRROR    15
#define LOAD_OP   16
#define SAVE_OP   17
#define SCALE_OP  18



typedef struct button_desc
{
	int xmin,ymin,xmax,ymax;
	int button_no;
	char* desc;
}button;

button buttons[MAX_BUTTONS];

typedef struct color_button
{
	int xmin,ymin,xmax,ymax;
	int color;
	int colflag;
}color_but;

color_but colorbuttons[28];
/*/color_but patternbuttons[16];*/

/*/ structure to mark an area      */
struct
{
	int top,left,bottom,right;
}marker;

int marked=0; /*/ to store whether marked or not*/

char FileName[40]="Untitled";
int  saved=1;/*/to store if file has been saved or not*/
int  LeftButtonPressed;
int  RightButtonPressed;
int  mousex,mousey;
int  prevx,prevy;
int  Current_Color=BLACK; /*/ to  Store the current color           */
int  Current_Pattern=EMPTY_FILL;/*/ to store the current Pattern*/
int  Current_Button=1;/*/ to store the current button pressed*/
int  Prev_Button=1;/*/ to store the previous button              */


void init();
void init_button(int,int,int,int,int,char*);
void init_color_button(int,int,int,int,int,int);
void New_ico(int x1, int y1);
void Open_ico(int x1, int y1);
void Save_ico(int x1, int y1);
void Line_ico(int x1, int y1);
void Rectangle_ico(int x1, int y1);
void Circle_ico(int x1, int y1);
void Ellipse_ico(int x1,int y1);
void Sphere_ico(int x1, int y1);
void Spiral_ico(int x1,int y1);
void Brush_ico(int x1, int y1);
void Erase_ico(int x1, int y1);
void Alphabet_ico(int x, int y);
void Mark_ico(int x1, int y1);
void Clip_ico(int x1, int y1);
void Translate_ico(int x, int y);
void Rotate_ico(int x, int y);
void Scale_ico(int x, int y);
void Bucket_ico(int x,int y);
void Cube_ico(int x, int y);
void Del_ico(int x, int y);
void color_ico(int x1, int y1, int c);
void size_up_ico(int x, int y);
void size_down_ico(int x, int y);
void flip_ico(int x, int y);
void mirror_ico(int x, int y);
void draw_button_border(int );
void undraw_button_border(int no);
void draw_color_button_border(int,int);
void start_up();

void check_if_exit();
int check_mouse_on(int,int,int,int);
int check_if_button_pressed();
int check_if_color();
int check_if_pattern();

void disp_filename();
void disp_coord();
void ShowStatus(char*);
void ClearStatus();
char* readline();

void showmouse();
void hidemouse();
void wheremouse(int *, int *);
int buttclicked();
void reset();
void getxy();
void startmouse(int,int);
void restrictmouse(int,int,int,int);

void Diagram();
void freehand();
void drawline();
void drawrectangle();
void erase();
void beep();
void drawtext();
void plotellipsepoints(int,int,int,int);
void algoellipse(int,int,float,float);
void algospiral(int,int,float,float);
void drawellipse();
void drawspiral();
void drawcircle();
void Bucket();
void Cube();
void sphere();
void insert(int,int);
void ffill(int,int,int,int);


void save();
void Load();

void mirror();
void flip();

void mark();
void unmark();
void delete();
void translate();
void rotate();
void scale();
void clip();
/*
void title(int,int,int,int);
*/



/*
void title(int x,int y,int x1,int y1)
{
	int pc;
	int i;
	hidemouse();
	setcolor(LIGHTGRAY);
	for(i=y;i<=y1;i++)
		line(x,i,x1,i);
	setcolor(WHITE);
	for(i=0;i<=5;i++)
	{
		line(x+i,y+i,x1-i,y+i);
		line(x+i,y+i,x+i,y1-i);
	}
	setcolor(BLACK);
	line(x1,y1,x1,y);
	line(x1,y1,x,y1);
	setcolor(DARKGRAY);
	for(i=1;i<=5;i++)
	{
		line(x1-i,y1-i,x+i,y1-i);
		line(x1-i,y1-i,x1-i,y+i);
	}
	showmouse();
}
*/
void init()
{
	int x1=10,y1=30,x2=44,y2=MAX_Y+28,ywidth=30,xwidth=30;
	int butt=0,i,j;


	New_ico(x1,y1);
	init_button(butt,x1,y1,xwidth,ywidth,"New File");
	draw_button_border(butt);
	butt++;

	Line_ico(x2,y1);
	init_button(butt,x2,y1,xwidth,ywidth,"Line Drawing Tool");
	draw_button_border(butt);
	butt++;


	y1=y1+ywidth;
	Rectangle_ico(x1,y1);
	init_button(butt,x1,y1,xwidth,ywidth,"Rectangle Drawing Tool");
	draw_button_border(butt);
	butt++;

	Circle_ico(x2,y1);
	init_button(butt,x2,y1,xwidth,ywidth,"Circle Drawing Tool");
	draw_button_border(butt);
	butt++;

	y1=y1+ywidth;
	Ellipse_ico(x1,y1);
	init_button(butt,x1,y1,xwidth,ywidth,"Ellipse Drawing Tool");
	draw_button_border(butt);
	butt++;


	Spiral_ico(x2,y1);
	init_button(butt,x2,y1,xwidth,ywidth,"Spiral Drawing Tool");
	draw_button_border(butt);
	butt++;


	y1=y1+ywidth;
	Brush_ico(x1,y1);
	init_button(butt,x1,y1,xwidth,ywidth,"Free Hand");
	draw_button_border(butt);
	butt++;

	Erase_ico(x2,y1);
	init_button(butt,x2,y1,xwidth,ywidth,"Eraser");
	draw_button_border(butt);
	butt++;

	y1=y1+ywidth;
	Mark_ico(x1,y1);
	init_button(butt,x1,y1,xwidth,ywidth,"Marking Tool");
	draw_button_border(butt);
	butt++;

	Alphabet_ico(x2,y1);
	init_button(butt,x2,y1,xwidth,ywidth,"Text");
	draw_button_border(butt);
	butt++;



	y1=y1+ywidth;
	Clip_ico(x1,y1);
	init_button(butt,x1,y1,xwidth,ywidth,"Clipping (Works with Mark)");
	draw_button_border(butt);
	butt++;

	Translate_ico(x2,y1);
	init_button(butt,x2,y1,xwidth,ywidth,"Translate (Works with Mark)");
	draw_button_border(butt);
	butt++;

	y1=y1+ywidth;
	Rotate_ico(x1,y1);
	init_button(butt,x1,y1,xwidth,ywidth,"Rotate (Works with mark)");
	draw_button_border(butt);
	butt++;

	Del_ico(x2,y1);
	init_button(butt,x2,y1,xwidth,ywidth,"Delete (Works with mark)");
	draw_button_border(butt);
	butt++;

	y1=y1+ywidth;
	flip_ico(x1,y1);
	init_button(butt,x1,y1,xwidth,ywidth,"Flip Canvas");
	draw_button_border(butt);
	butt++;

	mirror_ico(x2,y1);
	init_button(butt,x2,y1,xwidth,ywidth,"Mirror Canvas");
	draw_button_border(butt);
	butt++;

	y1=y1+ywidth;
	Open_ico(x1,y1);
	init_button(butt,x1,y1,xwidth,ywidth,"Open File");
	draw_button_border(butt);
	butt++;

	Save_ico(x2,y1);
	init_button(butt,x2,y1,xwidth,ywidth,"Save File");
	draw_button_border(butt);
	butt++;

	y1=y1+ywidth;
	Scale_ico(x1,y1);
	init_button(butt,x1,y1,xwidth,ywidth,"Scaling (Works with Mark)");
	draw_button_border(butt);
	butt++;


	Bucket_ico(x2,y1);
	init_button(butt,x2,y1,xwidth,ywidth,"Bucket Fill");
	draw_button_border(butt);
	butt++;

	y1=y1+ywidth;
	Sphere_ico(x1,y1);
	init_button(butt,x1,y1,xwidth,ywidth,"3D Ellipse Drawing Tool");
	draw_button_border(butt);
	butt++;

	Cube_ico(x2,y1);
	init_button(butt,x2,y1,xwidth,ywidth,"Cuboid Drawing Tool");
	draw_button_border(butt);
	butt++;

	butt=0;
	x1=MIN_X+8;
	y1=MAX_Y+9;
	xwidth=19;ywidth=15;
	for(i=0;i<8;i++)
	{
		init_color_button(butt,x1,y1,xwidth,ywidth,1);
		draw_color_button_border(butt,1);
		butt++;

		init_color_button(butt,x1,y2,xwidth,ywidth,1);
		draw_color_button_border(butt,1);
		butt++;

		x1=x1+xwidth;

	}

	butt=0;
	x1=x1+25;
	for(i=0;i<6;i++)
	{
		init_color_button(butt,x1,y1,xwidth,ywidth,0);
		draw_color_button_border(butt,0);
		butt++;

		init_color_button(butt,x1,y2,xwidth,ywidth,0);
		draw_color_button_border(butt,0);
		butt++;

		x1=x1+xwidth;

	}
	setfillstyle(Current_Pattern,Current_Color);
	bar(20,MAX_Y+7,65,MAX_Y+7+35);
	setcolor(BLACK);
	rectangle(20,MAX_Y+7,65,MAX_Y+7+35);
	setcolor(Current_Color);
}

void init_color_button(int color,int xmin,int ymin,int xwidth,int ywidth,int colflag)
{
	int xgap=4;
	if (colflag)
	{
		colorbuttons[color].xmin=xmin;
		colorbuttons[color].xmax=xmin+xwidth-xgap;
		colorbuttons[color].ymin=ymin;
		colorbuttons[color].ymax=ymin+ywidth;
		colorbuttons[color].color=color;
		colorbuttons[color].colflag=colflag;
	}
	else
	{
		colorbuttons[color+16].xmin=xmin;
		colorbuttons[color+16].xmax=xmin+xwidth-xgap;
		colorbuttons[color+16].ymin=ymin;
		colorbuttons[color+16].ymax=ymin+ywidth;
		colorbuttons[color+16].color=color;
		colorbuttons[color+16].colflag=colflag;
	}
}

void init_button(int no,int xmin,int ymin,int xwidth,int ywidth,char* desc)
{
	int ygap=4;
	buttons[no].xmin=xmin;
	buttons[no].ymin=ymin;
	buttons[no].xmax=xmin+xwidth;
	buttons[no].ymax=ymin+ywidth-ygap;
	buttons[no].desc=(char *) malloc(strlen(desc)+1);
	if(buttons[no].desc==NULL)
	{
		cleardevice();
		printf("\n No MEMORY ");
	}
	strcpy(buttons[no].desc,desc);
}


void draw_button_border(int no)
{
	int color=getcolor();
	hidemouse();
	setcolor(WHITE);
	line(buttons[no].xmin,buttons[no].ymin,buttons[no].xmax,buttons[no].ymin);
	line(buttons[no].xmin,buttons[no].ymin,buttons[no].xmin,buttons[no].ymax);
	setcolor(DARKGRAY);
	line(buttons[no].xmax,buttons[no].ymax,buttons[no].xmax,buttons[no].ymin);
	line(buttons[no].xmax,buttons[no].ymax,buttons[no].xmin,buttons[no].ymax);
	setcolor(color);
	showmouse();
}

void undraw_button_border(int no)
{
	int color=getcolor();
	hidemouse();
	setcolor(DARKGRAY);
	line(buttons[no].xmin,buttons[no].ymin,buttons[no].xmax,buttons[no].ymin);
	line(buttons[no].xmin,buttons[no].ymin,buttons[no].xmin,buttons[no].ymax);
	setcolor(WHITE);
	line(buttons[no].xmax,buttons[no].ymax,buttons[no].xmax,buttons[no].ymin);
	line(buttons[no].xmax,buttons[no].ymax,buttons[no].xmin,buttons[no].ymax);
	setcolor(color);
	showmouse();
}

void draw_color_button_border(int no,int colflag)
{
	int color=getcolor();
	setcolor(BLACK);
	if (colflag)
	{
		line(colorbuttons[no].xmin,colorbuttons[no].ymin,colorbuttons[no].xmax,colorbuttons[no].ymin);
		line(colorbuttons[no].xmin,colorbuttons[no].ymin,colorbuttons[no].xmin,colorbuttons[no].ymax);
		line(colorbuttons[no].xmax,colorbuttons[no].ymax,colorbuttons[no].xmax,colorbuttons[no].ymin);
		line(colorbuttons[no].xmax,colorbuttons[no].ymax,colorbuttons[no].xmin,colorbuttons[no].ymax);
		setfillstyle(1,no);
		floodfill(colorbuttons[no].xmin+1,colorbuttons[no].ymin+1,BLACK);
	}
	else
	{
		line(colorbuttons[no+16].xmin,colorbuttons[no+16].ymin,colorbuttons[no+16].xmax,colorbuttons[no+16].ymin);
		line(colorbuttons[no+16].xmin,colorbuttons[no+16].ymin,colorbuttons[no+16].xmin,colorbuttons[no+16].ymax);
		line(colorbuttons[no+16].xmax,colorbuttons[no+16].ymax,colorbuttons[no+16].xmax,colorbuttons[no+16].ymin);
		line(colorbuttons[no+16].xmax,colorbuttons[no+16].ymax,colorbuttons[no+16].xmin,colorbuttons[no+16].ymax);
		setfillstyle(no,LIGHTBLUE);
		floodfill(colorbuttons[no+16].xmin+1,colorbuttons[no+16].ymin+1,BLACK);
	}
	setcolor(color);
}

void New_ico(int x1, int y1)
{
	setlinestyle(0, 1, 1);
	setcolor(BLACK);
	line(9+x1, 4+y1, 9+x1, 20+y1);
	line(9+x1, 20+y1, 21+x1, 20+y1);
	line(21+x1, 20+y1, 21+x1, 8+y1);
	line(9+x1, 4+y1, 17+x1, 4+y1);
	line(17+x1, 4+y1, 17+x1, 8+y1);
	line(17+x1, 8+y1, 21+x1, 8+y1);
	line(21+x1, 8+y1, 17+x1, 4+y1);

	setfillstyle(1, WHITE);
	floodfill(10+x1, 9+y1, BLACK);
}

void Open_ico(int x1, int y1)
{
	setlinestyle(0, 1, 1);
	setcolor(BLACK);
	line(5+x1, 20+y1, 17+x1, 20+y1);
	line(17+x1, 20+y1, 24+x1, 15+y1);
	line(24+x1, 15+y1, 12+x1, 15+y1);
	line(12+x1, 15+y1, 5+x1, 20+y1);
	setfillstyle(1, DARKGRAY);
	floodfill(10+x1, 18+y1, BLACK);

	line(5+x1, 20+y1, 5+x1, 10+y1);
	line(5+x1, 10+y1, 6+x1, 8+y1);
	line(6+x1, 8+y1, 8+x1, 8+y1);
	line(8+x1, 8+y1, 9+x1, 10+y1);
	line(9+x1, 10+y1, 17+x1, 10+y1);
	line(17+x1, 10+y1, 17+x1, 15+y1);
	setfillstyle(1, YELLOW);
	floodfill(6+x1, 12+y1, BLACK);
	line(15+x1, 7+y1, 17+x1, 5+y1);
	line(17+x1, 5+y1, 22+x1, 7+y1);
	line(22+x1, 7+y1, 24+x1, 12+y1);
	line(24+x1, 12+y1, 20+x1, 10+y1);
	line(24+x1, 12+y1, 26+x1, 9+y1);
}

void Save_ico(int x1, int y1)
{
	setlinestyle(0, 1, 1);
	setcolor(BLACK);
	line(6+x1, 4+y1, 24+x1, 4+y1);
	line(24+x1, 4+y1, 24+x1, 20+y1);
	line(24+x1, 20+y1, 8+x1, 20+y1);
	line(8+x1, 20+y1, 6+x1, 18+y1);
	line(6+x1, 18+y1, 6+x1, 4+y1);

	line(9+x1, 4+y1, 9+x1, 12+y1);
	line(9+x1, 12+y1, 21+x1, 12+y1);
	line(21+x1, 12+y1, 21+x1, 4+y1);

	line(10+x1, 20+y1, 10+x1, 15+y1);
	line(10+x1, 15+y1, 20+x1, 15+y1);
	line(20+x1, 15+y1, 20+x1, 20+y1);

	line(17+x1, 15+y1, 17+x1, 20+y1);

	line(21+x1, 7+y1, 24+x1, 7+y1);

	setfillstyle(1, WHITE);
	floodfill(10+x1, 5+y1, BLACK);

	setfillstyle(1, LIGHTBLUE);
	floodfill(7+x1, 5+y1, BLACK);

	setfillstyle(1, DARKGRAY);
	floodfill(11+x1, 19+y1, BLACK);
}


void Line_ico(int x1, int y1)
{
	line(8+x1, 5+y1, 22+x1, 19+y1);
}

void Rectangle_ico(int x1, int y1)
{
	rectangle(8+x1, 5+y1, 22+x1, 19+y1);
}

void Circle_ico(int x1, int y1)
{
	circle(15+x1, 12+y1, 8);
}

void Spiral_ico(int x1, int y1)
{
	int xrad=3,yrad=1;
	int i;
	x1=15+x1;
	y1=14+y1;
	for( i = 1; i <=4; ++i )
	{
		ellipse( x1, y1, 90, 270, xrad, yrad );
		xrad += 1;
		yrad += 1;
		y1 -= 1;
		ellipse( x1, y1, 270, 90, xrad, yrad );
		xrad += 1;
		yrad += 1;
		y1 += 1;
	}
}


void Ellipse_ico(int x1,int y1)
{
	ellipse(15+x1, 13+y1, 0, 360, 8, 6);
}

void Brush_ico(int x1, int y1)
{
	setcolor(BLACK);
	setlinestyle(0, 1, 3);
	line(19+x1, 21+y1, 10+x1, 9+y1);
	setlinestyle(0, 1, 1);
	line(11+x1, 9+y1, 11+x1, 6+y1);
	line(11+x1, 6+y1, 6+x1, 4+y1);
	line(6+x1, 4+y1, 7+x1, 9+y1);
	line(7+x1, 9+y1, 11+x1, 9+y1);
}

void Fill_ico(int x1, int y1)
{
	setlinestyle(0, 1, 1);
	setcolor(BLACK);
	line(10+x1, 11+y1, 16+x1, 19+y1);
	line(16+x1, 19+y1, 25+x1, 12+y1);
	line(25+x1, 12+y1, 20+x1, 5+y1);

	line(10+x1, 11+y1, 24+x1, 11+y1);
	setfillstyle(1, RED);
	floodfill( 12+x1, 12+y1, BLACK);
	setcolor(RED);
	line(10+x1, 11+y1, 8+x1, 14+y1);
	line(8+x1, 14+y1, 8+x1, 16+y1);
}

void Cube_ico(int x, int y)
{
	rectangle(8+x, 5+y, 24+x, 17+y);
	rectangle(5+x, 9+y, 21+x, 21+y);
	line(5+x, 9+y, 8+x, 5+y);
	line(21+x, 21+y, 24+x, 17+y);
	line(21+x, 9+y, 24+x, 5+y);
	line(5+x, 21+y, 8+x, 17+y);
}

void Erase_ico(int x1, int y1)
{
	setlinestyle(0, 1, 1);
	setcolor(BLACK);
	line(14+x1, 20+y1, 25+x1, 7+y1);
	line(25+x1, 7+y1, 23+x1, 4+y1);
	line(23+x1, 4+y1, 12+x1, 17+y1);
	line(12+x1, 17+y1, 14+x1, 20+y1);

	line(14+x1, 20+y1, 5+x1, 20+y1);
	line(5+x1, 20+y1, 5+x1, 17+y1);
	line(5+x1, 17+y1, 12+x1, 17+y1);

	line(5+x1, 17+y1, 16+x1, 4+y1);
	line(16+x1, 4+y1, 23+x1, 4+y1);

	setfillstyle(1, DARKGRAY);
	floodfill(14+x1, 18+y1, BLACK);
	setfillstyle(1, WHITE);
	floodfill(16+x1, 5+y1, BLACK);
}

void Alphabet_ico(int x, int y)
{
	setcolor(BLACK);
	setlinestyle(0, 1, 3);
	line(8+x, 20+y, 18+x, 4+y);
	line(18+x, 4+y, 18+x, 20+y);
	setlinestyle(0, 1, 1);
	line(12+x, 14+y, 19+x, 14+y);
	line(6+x, 20+y, 12+x, 20+y);
	line(15+x, 20+y, 21+x, 20+y);
}

void Mark_ico(int x1, int y1)
{
	setlinestyle(0, 1, 1);
	setcolor(BLACK);
	setlinestyle(3, 1, 1);
	rectangle(5+x1, 5+y1, 25+x1, 19+y1);
	setlinestyle(0, 1, 1);
}

void Clip_ico(int x1, int y1)
{
	setlinestyle(0, 1, 1);
	setcolor(BLACK);
	rectangle(5+x1, 5+y1, 25+x1, 19+y1);
	setfillstyle(1, WHITE);
	floodfill(15+x1, 12+y1, BLACK);
	setfillstyle(1,BLACK);
	bar(12+x1, 10+y1, 23+x1, 17+y1);
}

void Translate_ico(int x, int y)
{
	setcolor(BLACK);
	line(6+x, 3+y, 20+x, 3+y);
	line(20+x, 3+y, 20+x, 8+y);
	line(6+x, 3+y, 6+x, 16+y);
	line(6+x, 16+y, 12+x, 16+y);

	line(25+x, 8+y, 12+x, 8+y);
	line(12+x, 8+y, 12+x, 20+y);
	line(12+x, 20+y, 25+x, 20+y);
	line(25+x, 20+y, 25+x, 8+y);
	setfillstyle(1, LIGHTRED);
	floodfill(8+x, 5+y, BLACK);
	floodfill(20+x, 18+y, BLACK);
}

void Rotate_ico(int x, int y)
{
	setcolor(BLACK);
	line(6+x, 5+y, 20+x, 5+y);
	line(20+x, 5+y, 20+x, 8+y);
	line(6+x, 5+y, 6+x, 18+y);
	line(6+x, 18+y, 12+x, 18+y);

	line(15+x, 7+y, 26+x, 11+y);
	line(26+x, 11+y, 21+x, 20+y);
	line(21+x, 20+y, 11+x, 16+y);
	line(11+x, 16+y, 15+x, 7+y);
	setfillstyle(1, LIGHTRED);
	floodfill(8+x, 7+y, BLACK);
	floodfill(20+x, 18+y, BLACK);
}

void Del_ico(int x, int y)
{
	setcolor(RED);
	setlinestyle(0, 1, 3);
	line(9+x, 5+y, 16+x, 11+y);
	line(16+x, 11+y, 21+x, 18+y);

	line(20+x, 5+y, 11+x, 12+y);
	line(11+x, 12+y, 8+x, 19+y);
	setcolor(BLACK);
	setlinestyle(0, 1, 1);
}

void color_ico(int x1, int y1, int c)
{
	setcolor(BLACK);
	rectangle(x1, y1, x1+9, y1+8);
	setfillstyle(1, c);
	floodfill(x1+1, y1+1, BLACK);
}

void size_up_ico(int x, int y)
{
	x-=6;
	y-=4;
	setcolor(BLACK);
	line(x+10, y+12, x+22, y+7);
	line(x+22, y+7, x+34, y+12);
	line(x+10, y+12, x+34, y+12);
	setfillstyle(1, BLACK);
	floodfill(x+20, y+10, BLACK);
}

void size_down_ico(int x, int y)
{
	x-=6;
	y-=3;
	setcolor(BLACK);
	line(x+10, y+7, x+22, y+12);
	line(x+22, y+12, x+34, y+7);
	line(x+10, y+7, x+34, y+7);
	setfillstyle(1, BLACK);
	putpixel(x+20, y+10, WHITE);
	floodfill(x+20, y+10, BLACK);
}

void Sphere_ico(int x1, int y1)
{
	setlinestyle(0, 1, 1);
	setcolor(BLACK);
	circle(x1+15,y1+13,8);
	ellipse(x1+15,y1+13,0,360,4,8);
	ellipse(x1+15,y1+13,0,360,8,4);
}

void Bucket_ico(int x, int y)
{
	setlinestyle(0, 1, 1);
	setcolor(BLACK);
	line(7+x, 8+y, 11+x, 20+y);
	line(11+x, 20+y, 21+x, 16+y);
	line(21+x, 16+y, 17+x, 4+y);
	line(7+x, 8+y, 17+x, 4+y);
	line(17+x, 4+y, 7+x, 8+y);

	line(3+x, 12+y, 7+x, 8+y);
	line(3+x, 12+y, 5+x, 15+y);
	line(5+x, 15+y, 7+x, 8+y);

	setfillstyle(1, BLUE);
	floodfill(10+x, 9+y, BLACK);

	setfillstyle(1, YELLOW);
	floodfill(5+x, 13+y, BLACK);


}

void flip_ico(int x, int y)
{
	setcolor(BLACK);
	line(14+x, 4+y, 8+x, 8+y);
	line(8+x, 8+y, 12+x, 8+y);
	line(12+x, 8+y, 12+x, 15+y);
	line(12+x, 15+y, 8+x, 15+y);
	line(8+x, 15+y, 14+x, 19+y);
	line(14+x, 19+y, 20+x, 15+y);
	line(20+x, 15+y, 16+x, 15+y);
	line(16+x, 15+y, 16+x, 8+y);
	line(16+x, 8+y, 20+x, 8+y);
	line(20+x, 8+y, 14+x, 4+y);
	setfillstyle(1, CYAN);
	floodfill(14+x, 10+y, BLACK);
}

void mirror_ico(int x, int y)
{
	setcolor(BLACK);
	line(6+x, 12+y, 10+x, 17+y);
	line(11+x, 18+y, 11+x, 15+y);
	line(11+x, 15+y, 18+x, 15+y);
	line(18+x, 15+y, 18+x, 18+y);
	line(18+x, 18+y, 23+x, 12+y);
	line(23+x, 12+y, 18+x, 6+y);
	line(18+x, 6+y, 18+x, 10+y);
	line(18+x, 10+y, 11+x, 10+y);
	line(11+x, 10+y, 11+x, 6+y);
	line(11+x, 6+y, 6+x, 12+y);
	setfillstyle(1, CYAN);
	floodfill(9+x, 12+y, BLACK);
}

void Scale_ico(int x,int y)
{
	int i;
	setcolor(BLUE);
	line(x+5,y+5,x+5,y+20);
	line(x+25,y+5,x+25,y+20);
	setcolor(RED);
	for(i=y+7;i<y+19;i+=2)
	   line(x+7,i,x+23,i);
}

void start_up()
{
	setfillstyle(1, LIGHTGRAY);

	floodfill(200, 200, 1);

	/* FOR MAIN WINDOW */
	setcolor(15);
	line(0, 0, 639, 0);
	line(0, 0+1, 639-1, 0+1);
	line(0, 0, 0, 479-1);
	line(0+1, 0, 0+1, 479-2);
	setcolor(8);
	line(639, 0+1, 639, 479);
	line(639-1, 0+2, 639-1, 479-1);
	line(639, 479, 0, 479);
	line(639, 479-1, 0+1, 479-1);

	/* for drawing window */
	setcolor(WHITE);
	rectangle(MIN_X, MIN_Y, MAX_X, MAX_Y);
	setfillstyle(1, WHITE);
	floodfill(300, 300, WHITE);

	setcolor(8);
	line(MIN_X, MIN_Y, MAX_X, MIN_Y);
	line(MIN_X, MIN_Y+1, MAX_X-1, MIN_Y+1);
	line(MIN_X, MIN_Y, MIN_X, MAX_Y-1);
	line(MIN_X+1, MIN_Y, MIN_X+1, MAX_Y-2);
	setcolor(8);
	line(MAX_X, MIN_Y+1, MAX_X, MAX_Y);
	line(MAX_X-1, MIN_Y+2, MAX_X-1, MAX_Y-1);
	line(MAX_X, MAX_Y, MIN_X, MAX_Y);
	line(MAX_X, MAX_Y-1, MIN_X+1, MAX_Y-1);

	/* for status bar */
	setcolor(8);
	line(10, 460, 629, 460);
	line(10, 460, 10, 479 - 5-1);
	setcolor(15);
	line(629, 460 , 629, 479 - 5);
	line(629, 479 - 5, 10, 479 - 5);

	/*/ For color*/
	setcolor(15);
	line(MIN_X, MAX_Y+4, 251, MAX_Y+4);
	line(MIN_X, MAX_Y+4, MIN_X,MAX_Y+47);
	setcolor(0);
	line(251, MAX_Y+47 , MIN_X, MAX_Y+47);
	line(251, MAX_Y+47, 251, MAX_Y+4);

	/*/ For background */
	setcolor(15);
	line(258, MAX_Y+4, 386, MAX_Y+4);
	line(258, MAX_Y+4, 258,MAX_Y+47);
	setcolor(0);
	line(386, MAX_Y+47 , 258, MAX_Y+47);
	line(386, MAX_Y+47, 386, MAX_Y+4);

	/* For Names */
	setcolor(15);
	line(8, 365, 76,365);
	line(8, 365, 8,MAX_Y-10);
	setcolor(0);
	line(76, MAX_Y-10 ,8, MAX_Y-10);
	line(76, MAX_Y-10, 76,365);
	setcolor(BLUE);
	outtextxy(35,MAX_Y-40,"By");
	outtextxy(12,MAX_Y-30,"Abhishek");
	outtextxy(15,MAX_Y-20,"Dhingra");


	/* For college */
	setcolor(15);
	line(400, MAX_Y+4, 630, MAX_Y+4);
	line(400, MAX_Y+4, 400,MAX_Y+47);
	setcolor(0);
	line(630, MAX_Y+47 , 400, MAX_Y+47);
	line(630, MAX_Y+47, 630, MAX_Y+4);
	setcolor(BLUE);
	outtextxy(410,MAX_Y+15,"Developed At :");
	outtextxy(410,MAX_Y+31,"R.V College of Engineering");

}

void disp_filename()
{
	char name[60];
	int  xpos;
	setfillstyle(SOLID_FILL,BLUE);
	bar(10,5,629,18);
	strcpy(name,"DOS Paint - ");
	strcat(name,FileName);
	xpos=(getmaxx()-textwidth(name))/2;
	setcolor(LIGHTRED);
	outtextxy(xpos,8,name);
	setfillstyle(SOLID_FILL,BLUE);
	bar(614,6,628,17);
	outtextxy(620,8,"X");
}

void disp_coord()
{
	char xy[25];
	int color;
	if(prevx!=mousex||prevy!=mousey)
	if( (mousex>MIN_X+1)&&(mousex<MAX_X-1)&&(mousey>MIN_Y+1)&&(mousey<MAX_Y-1))
	{
		sprintf(xy," x : %d  y : %d",mousex-MIN_X-2,mousey-MIN_Y-2);
		color=getcolor();
		setcolor(LIGHTGRAY);
		outtextxy(475,464,"aaaaaaaa ");/* ALT 219*/
		setcolor(BLACK);
		outtextxy(475,464,xy);
		setcolor(color);
	}

}

void reset()
{
	union REGS regs;
	regs.x.ax=0;
	int86(0x33,&regs,&regs);
	if(regs.x.ax==0)
	{
		printf("\n No Mouse Drivers ");
		exit(0);
	}
}

void showmouse()
{
	union REGS regs;
	regs.x.ax=1;
	int86(0x33,&regs,&regs);
}

void hidemouse()
{
	union REGS regs;
	regs.x.ax=2;
	int86(0x33,&regs,&regs);
}

int buttclicked()
{
union REGS regs;
regs.x.ax=3;
int86(0x33,&regs,&regs);

return regs.x.bx;

}

void wheremouse(int *x,int*y)
{
union REGS regs;
regs.x.ax=3;
int86(0x33,&regs,&regs);
*x=regs.x.cx;
*y=regs.x.dx;
}

void getxy()
{
	union REGS regs;
	regs.x.ax=3;
	int86(0x33,&regs,&regs);

	prevx=mousex;
	prevy=mousey;
	if(regs.x.bx&1)
		LeftButtonPressed=1;
	else
		LeftButtonPressed=0;
	if(regs.x.bx&2)
		RightButtonPressed=1;
	else
		RightButtonPressed=0;

	mousex=regs.x.cx;
	mousey=regs.x.dx;
}

void startmouse(int x,int y)
{
	union REGS regs;
	regs.x.ax=4;
	regs.x.cx=x;
	regs.x.dx=y;
	int86(0x33,&regs,&regs);
}

void restrictmouse(int minx,int miny,int maxx,int maxy)
{
	union REGS regs;

	regs.x.cx=minx;
	regs.x.dx=maxx;
	regs.x.ax=0x7;
	int86(0x33,&regs,&regs);
	regs.x.cx=miny;
	regs.x.dx=maxy;
	regs.x.ax=0x8;
	int86(0x33,&regs,&regs);
}

int check_mouse_on(int minx,int miny,int maxx,int maxy)
{
	if(mousex<minx)
		return 0;
	if(mousex>maxx)
		return 0;
	if(mousey<miny)
		return 0;
	if(mousey>maxy)
		return 0;

	return 1;
}

void check_if_exit()
{
	if( (check_mouse_on(614,6,628,17))&&LeftButtonPressed)
	{
		flushall();
		closegraph();
		exit(0);
	}
}

int check_if_button_pressed()
{
	int ret_value=-1;
	int i;
	char ch;

	for(i=0;i<MAX_BUTTONS;++i)
	{
		if(check_mouse_on(buttons[i].xmin,buttons[i].ymin,buttons[i].xmax,buttons[i].ymax))
		{
			if(LeftButtonPressed && i!=Current_Button)
			{
				ret_value=i;
				draw_button_border(Current_Button);
				Prev_Button=Current_Button;
				undraw_button_border(i);
				Current_Button=i;

				switch(Current_Button)
				{
					case CLEAR : if(marked) unmark();
						 hidemouse();
						 if(!saved)
						 {
							ShowStatus("Save Changes ? ");
							ch=getch();
							if(ch=='y'||ch=='Y')
								save();

						 }
						 strcpy(FileName,"Untitled");
						 disp_filename();
						 setfillstyle(SOLID_FILL,WHITE);
						 bar(MIN_X+2,MIN_Y+2,MAX_X-2,MAX_Y-2);
						 draw_button_border(Current_Button);
						 undraw_button_border(Prev_Button);
						 Current_Button=Prev_Button;
						 setfillstyle(Current_Pattern,Current_Color);
						 showmouse();
						 break;

					case LOAD_OP: if(marked) unmark();
						 hidemouse();
						 Load();
						 draw_button_border(Current_Button);
						 undraw_button_border(Prev_Button);
						 Current_Button=Prev_Button;
						 setfillstyle(Current_Pattern,Current_Color);
						 showmouse();
						 break;

					case SAVE_OP:if(marked) unmark();
						 hidemouse();
						 save();
						 draw_button_border(Current_Button);
						 undraw_button_border(Prev_Button);
						 Current_Button=Prev_Button;
						 setfillstyle(Current_Pattern,Current_Color);
						 showmouse();
						 break;

					case MIRROR:if(marked) unmark();
						 hidemouse();
						 mirror();
						 draw_button_border(Current_Button);
						 undraw_button_border(Prev_Button);
						 Current_Button=Prev_Button;
						 setfillstyle(Current_Pattern,Current_Color);
						 showmouse();
						 break;

					case FLIP: if(marked) unmark();
						 hidemouse();
						 flip();
						 draw_button_border(Current_Button);
						 undraw_button_border(Prev_Button);
						 Current_Button=Prev_Button;
						 setfillstyle(Current_Pattern,Current_Color);
						 showmouse();
						 break;

					case DELETE_OP:
						 hidemouse();
						 delete();
						 draw_button_border(Current_Button);
						 undraw_button_border(Prev_Button);
						 Current_Button=Prev_Button;
						 setfillstyle(Current_Pattern,Current_Color);
						 showmouse();
						 break;

					case ROTATE_OP:
						 hidemouse();
						 rotate();
						 draw_button_border(Current_Button);
						 undraw_button_border(Prev_Button);
						 Current_Button=Prev_Button;
						 setfillstyle(Current_Pattern,Current_Color);
						 showmouse();
						 break;
					case CLIP_OP:
						 hidemouse();
						 clip();
						 draw_button_border(Current_Button);
						 undraw_button_border(Prev_Button);
						 Current_Button=Prev_Button;
						 setfillstyle(Current_Pattern,Current_Color);
						 showmouse();
						 break;
					case SCALE_OP:
						 hidemouse();
						 scale();
						 draw_button_border(Current_Button);
						 undraw_button_border(Prev_Button);
						 Current_Button=Prev_Button;
						 setfillstyle(Current_Pattern,Current_Color);
						 showmouse();
						 break;


				}
				if(Current_Button!=MARK_OP&&Current_Button!=TRANS_OP)
				{
					if(marked) unmark();
				}
			}

			if(prevx!=mousex||prevy!=mousey)
				ShowStatus(buttons[i].desc);

			return ret_value;
		}
	}

	ClearStatus();
	return ret_value;
}

int check_if_color()
{
	int i=0;
	for(i=0;i<MAX_COLPAT;i++)
	{
		if(check_mouse_on(colorbuttons[i].xmin,colorbuttons[i].ymin,colorbuttons[i].xmax,colorbuttons[i].ymax))
		{
			if(colorbuttons[i].colflag)
			{
				Current_Color=colorbuttons[i].color;
			}
			else
				Current_Pattern=colorbuttons[i].color;
			if (Current_Pattern==EMPTY_FILL)
				setfillstyle(SOLID_FILL,Current_Color);
			else
				setfillstyle(Current_Pattern,Current_Color);
			bar(20,MAX_Y+7,65,MAX_Y+7+35);
			setcolor(BLACK);
			rectangle(20,MAX_Y+7,65,MAX_Y+7+35);
			setcolor(Current_Color);
			return 1;
		}
	}
	return 0;

}



void ShowStatus(char* str)
{
	int color=getcolor();
	int i;

	ClearStatus();
	setcolor(BLACK);
	outtextxy(12,464,str);
	setcolor(color);
}

void ClearStatus()
{

	static int first_time;
	static char text[59];
	int i;

	setcolor(LIGHTGRAY);
	if(!first_time)
	{
		strcpy(text,"");
		for(i=0;i<58;++i)
			strcat(text,"?");
			text[58]='\0';
		first_time=1;
	}
	outtextxy(12,464,text);

}

void Diagram()
{
	restrictmouse(MIN_X+2,MIN_Y+2,MAX_X-2,MAX_Y-2);
	hidemouse();
	switch(Current_Button)
	{
	case 1: drawline();
		break;
	case 2: drawrectangle();
		break;
	case 3: drawcircle();
		break;
	case 4: drawellipse();
		break;
	case 5: drawspiral();
		break;
	case 6: freehand();
		break;
	case 7: erase();
		break;
	case MARK_OP:
		mark();
		break;
	case 9: drawtext();
		break;
	case TRANS_OP:
		translate();
		break;
	case 19: Bucket();
		 break;
	case 20: sphere();
		 break;
	case 21: Cube();
		 break;

	}
	showmouse();
	restrictmouse(0,0,639,479);
}


void freehand()
{
	setcolor(Current_Color);
	if(prevx<MIN_X+2||prevx>MAX_X-2||prevy>MAX_Y-2||prevy<MIN_Y+2)
		return;

	while(LeftButtonPressed)
	{

		disp_coord();

		line(mousex,mousey,prevx,prevy);
		getxy();

	}
}

void drawline()
{
	int color=15-Current_Color;
	int x,y;
	setcolor(color);
	setwritemode(XOR_PUT);

	x=mousex;
	y=mousey;

	if(x<MIN_X+2||x>MAX_X-2||y>MAX_Y-2||y<MIN_Y+2)
		return;

	while(LeftButtonPressed)
	{
		disp_coord();
		line(x,y,mousex,mousey);
		getxy();
		line(x,y,mousex,mousey);
	}
	setwritemode(COPY_PUT);
	setcolor(Current_Color);
	line(x,y,mousex,mousey);

}

void drawrectangle()
{
	int color=15-Current_Color;
	int x,y;
	setcolor(color);
	setwritemode(XOR_PUT);

	x=mousex;
	y=mousey;

	while(LeftButtonPressed)
	{
		disp_coord();
		rectangle(x,y,mousex,mousey);
		getxy();
		rectangle(x,y,mousex,mousey);
	}
	setwritemode(COPY_PUT);
	setcolor(Current_Color);
	if(Current_Pattern==EMPTY_FILL)
		rectangle(x,y,mousex,mousey);
	else
	{
		setfillstyle(Current_Pattern,Current_Color);
		bar(x,y,mousex,mousey);
	}
}

void erase()
{
	int i,j;
	while(LeftButtonPressed)
	{

		disp_coord();
		for(i=mousex;i<mousex+10&&i<=MAX_X-2;++i)
			for(j=mousey;j<mousey+10&&j<=MAX_Y-2;++j)
				putpixel(i,j,WHITE);
		getxy();

	}
}

void beep()
{
	sound(7);
	delay(1000);
	nosound();
}

void drawtext()
{
	int size=0,max_char,i=0;
	char ch;
	char str[68]; /*/ ( (MAX_X-2)-(MIN_X+2) )/8 ,8 being width & height of a char*/
	char blank[68]; /*/ to write blank*/

	max_char=(MAX_X-2-mousex)/8;
	if((MAX_Y-2-mousey<9) || (max_char<1))
	{
		ShowStatus(" Not Enough Space to Write ");
		beep();
		ClearStatus();
		return;
	}

	ShowStatus("Press <Enter> or <Esc> to exit");
	fflush(stdin);
	str[0]='\0';

	ch=getch();

	while(ch!=13 && ch!=27)
	{
		if (ch==8)
		{
			if(size<1)
				beep();
			else
			{
				setcolor(WHITE);
				strcpy(blank,"");
				for(i=0;i<size;++i)
					blank[i]='?';
				blank[size]='\0';
				outtextxy(mousex,mousey,blank);

				setcolor(Current_Color);
				size--;
				str[size]='\0';
				outtextxy(mousex,mousey,str);
			}
		}
		else if(size==max_char)
		{
			beep();
		}
		else
		{
			size++;
			setcolor(WHITE);
			strcpy(blank,"");
			for(i=0;i<size;++i)
				blank[i]='?';
			blank[size]='\0';
			outtextxy(mousex,mousey,blank);

			str[size-1]=ch;
			setcolor(Current_Color);
			str[size]='\0';
			outtextxy(mousex,mousey,str);
		}
		ch=getch();
	}
	ClearStatus();
}

struct node1
{
	int x,y;
	struct node1* next;
};
struct node1 *last1,*root1,*p1;

void insert(int x,int y)
{
	struct node1 *new1;
	new1=(struct node1*)malloc(sizeof(struct node1));
	new1->x=x;
	new1->y=y;
	new1->next=NULL;
	last1->next=new1;
	last1=new1;
	return;
}


void Bucket()
{
	int x,y,bgcolor;
	while(LeftButtonPressed)
	{
		disp_coord();
		getxy();
	}
	setwritemode(COPY_PUT);
	x=mousex;
	y=mousey;
	bgcolor=getpixel(x,y);
	ffill(x,y,bgcolor,Current_Color);
}

void ffill(int x,int y,int backColor,int fill_color)
{
	if(backColor==fill_color)
		return;
	last1=root1=(struct node1*)malloc(sizeof(struct node1));
	root1->x=x;
	root1->y=y;
	root1->next=NULL;
	while(root1!=NULL)
	{
		putpixel(x,y,fill_color);
		if(getpixel(x,y-1)==backColor)
		{
			putpixel(x,y-1,fill_color);
			insert(x,y-1);
		}
		if(getpixel(x+1,y)==backColor)
		{
			putpixel(x+1,y,fill_color);
			insert(x+1,y);
		}
		if(getpixel(x,y+1)==backColor)
		{
			putpixel(x,y+1,fill_color);
			insert(x,y+1);
		}
		if(getpixel(x-1,y)==backColor)
		{
			putpixel(x-1,y,fill_color);
			insert(x-1,y);
		}
		p1=root1;
		root1=root1->next;
		free(p1);
		x=root1->x;
		y=root1->y;
	}
}

void Cube()
{
	int color=15-Current_Color;
	int temp,x,y,mousex1,mousey1;
	restrictmouse((MIN_X+5),(MIN_Y+5),(MAX_X-30),(MAX_Y-30));
	setcolor(color);
	setwritemode(XOR_PUT);

	x=mousex;
	y=mousey;

	while(LeftButtonPressed)
	{
		disp_coord();
/*		rectangle(x,y,mousex,mousey); */
		getxy();
/*		rectangle(x,y,mousex,mousey); */
	}
	setwritemode(COPY_PUT);
	mousex1=mousex;
	mousey1=mousey;
	if(mousex1<x || mousey1<y)
	{
		temp=x;
		x=mousex1;
		mousex1=temp;
		temp=y;
		y=mousey1;
		mousey1=temp;
	}
	if(mousex1-x>1 && mousey1-y>1)
	{
		if(Current_Pattern==EMPTY_FILL)
		{
			setcolor(Current_Color);
			rectangle(x,y,mousex1,mousey1);
			rectangle(x+25, y+25, mousex1+25, mousey1+25);
			line(x,y,x+25,y+25);
			line(mousex1,mousey1,mousex1+25,mousey1+25);
			line(x,mousey1,x+25,mousey1+25);
			line(mousex1,y,mousex1+25,y+25);
		}
		else
		{
			setfillstyle(Current_Pattern,Current_Color);
			bar(x,y,mousex1,mousey1);
			bar(x+25, y+25, mousex1+25, mousey1+25);
			setcolor(BLACK);
			rectangle(x,y,mousex1,mousey1);
			rectangle(x+25, y+25, mousex1+25, mousey1+25);
			line(x,y,x+25,y+25);
			line(mousex1,mousey1,mousex1+25,mousey1+25);
			line(x,mousey1,x+25,mousey1+25);
			line(mousex1,y,mousex1+25,y+25);
			floodfill(mousex1+5,y+10,BLACK);
			floodfill(x+10,mousey1+5,BLACK);
			floodfill(mousex1+2,mousey1,BLACK);
		}
	}
	restrictmouse(0,0,640,480);
}

void drawellipse()
{
	int x1,y1,x2,y2,color,xmid,ymid;
	float radx,rady;
	x1 = mousex;
	y1 = mousey;
	setwritemode(XOR_PUT);
	while(LeftButtonPressed)
	{
		disp_coord();
		x2 = mousex;
		y2 = mousey;
		xmid = (x1 + x2)/2;
		ymid = (y1 + y2)/2;
		radx = abs((x2 - x1)/2);
		rady = abs((y2 - y1)/2);
		if (radx < 1)
			radx = 1;
		if (rady < 1)
			rady = 1;
		color = 15 - Current_Color;
		setcolor(color);
		algoellipse(xmid,ymid,radx,rady);
		delay(20);
		getxy();
		algoellipse(xmid,ymid,radx,rady);
	}
	setwritemode(COPY_PUT);
	setcolor(Current_Color);
	x2 = mousex;
	y2 = mousey;
	xmid = (x1 + x2)/2;
	ymid = (y1 + y2)/2;
	radx = abs((x2 - x1)/2);
	rady = abs((y2 - y1)/2);
	if(Current_Pattern==EMPTY_FILL)
		algoellipse(xmid,ymid,radx,rady);
	else
	{
		setfillstyle(Current_Pattern,Current_Color);
		fillellipse(xmid,ymid,radx,rady);
	}

}


void algoellipse(int xcen,int ycen,float radx,float rady)
{
	float p,px,py,x,y,ry,rx,tworx,twory;
	ry = rady * rady;
	rx = radx * radx;
	twory = 2 * ry;
	tworx = 2 * rx;
	x = 0;
	y = rady;
	plotellipsepoints(xcen,ycen,x,y);
	p = (ry - rx*rady + (0.25 * rx));
	px = 0;
	py = tworx * y;
	while (px < py)
	{       x++;
		px = px + twory;
		if (p >= 0)
		{       y--;
			py = py - tworx;
		}
		if (p < 0)
			p = p + ry + px;
		else
			p = p + ry + px - py;
		plotellipsepoints(xcen,ycen,x,y);
	}
	p = (ry * (x + 0.5) * (x + 0.5) + rx * (y-1) * (y-1) - rx * ry);
	while (y > 0)
	{       y--;
		py = py - tworx;
		if (p <= 0)
		{       x++;
			px = px + twory;
		}
		if (p > 0)
			p = p + rx - py;
		else
			p = p + rx - py + px;
		plotellipsepoints(xcen,ycen,x,y);
	}
}

void plotellipsepoints(int xcen,int ycen,int x,int y)
{
	if (xcen+x >= MIN_X && xcen+x <= MAX_X && ycen+y >= MIN_Y && ycen+y <= MAX_Y)
	   line(xcen+x,ycen+y,xcen+x,ycen+y);
	if (xcen-x >= MIN_X && xcen-x <= MAX_X && ycen+y >= MIN_Y && ycen+y <= MAX_Y)
		line(xcen-x,ycen+y,xcen-x,ycen+y);
	if (xcen+x >= MIN_X && xcen+x <= MAX_X && ycen-y >= MIN_Y && ycen-y <= MAX_Y)
		line(xcen+x,ycen-y,xcen+x,ycen-y);
	if (xcen-x >= MIN_X && xcen-x <= MAX_X && ycen-y >= MIN_Y && ycen-y <= MAX_Y)
		line(xcen-x,ycen-y,xcen-x,ycen-y);
}

/*
void algospiral(int xcen,int ycen,float radx,float rady)
{
	float rx=5,ry,ratio,ryold;
	int i;
	ratio=radx/rady;
	ryold=ry=rx/ratio;
	while(((xcen+rx)<=MAX_X) || ((ycen+ry)<=MAX_Y) || ((xcen-rx)>=MIN_X) || ((ycen-ry)>=MIN_Y))
	{
		ellipse( xcen, ycen, 90, 270, rx, ry );
		rx += 5;
		ry += rx/ratio;
		ycen -= ry-ryold;
		ryold=ry;
		ellipse( xcen, ycen, 270, 90, rx, ry );
		rx += 5;
		ry += rx/ratio;
		ycen += ry-ryold;
		ryold=ry;
	}
}
*/

void algospiral(int xcen,int ycen,float radx,float rady)
{
	float rx=5,ry=5;
	/* while(rx<=(MAX_X-xcen) || ry<=(MAX_Y-ycen) || rx<=(xcen-MIN_X) || ry<=(ycen-MIN_Y)) */
	while(rx<radx || ry<rady)
	{
		ellipse( xcen, ycen, 90, 270, rx, ry );
		rx += 5;
		ry += 5;
		ycen -= 5;
		ellipse( xcen, ycen, 270, 90, rx, ry );
		rx += 5;
		ry += 5;
		ycen += 5;
	}
}


/*  -- Problem with limiting Spiral to Screen Boundaries --
void drawspiral()
{
	int x1,y1,x2,y2,color,xmid,ymid;
	float radx,rady;
	x1 = mousex;
	y1 = mousey;
	setwritemode(XOR_PUT);
	while(LeftButtonPressed)
	{
		disp_coord();
		x2 = mousex;
		y2 = mousey;
		xmid = (x1 + x2)/2;
		ymid = (y1 + y2)/2;
		radx = abs((x2 - x1)/2);
		rady = abs((y2 - y1)/2);
		if (radx < 1)
			radx = 1;
		if (rady < 1)
			rady = 1;
		color = 15 - Current_Color;
		setcolor(color);
		if((xmid+radx)>MAX_X)
			radx=MAX_X-xmid;
		if((xmid-radx)<MIN_X)
			radx=xmid-MIN_X;
		if((ymid+rady)>MAX_Y)
			rady=MAX_Y-ymid;
		if((ymid-rady)<MIN_Y)
			rady=ymid-MIN_Y;
		rectangle(xmid-radx,ymid-rady,xmid+radx,ymid+rady);
		getxy();
		if((xmid+radx)>MAX_X)
			radx=MAX_X-xmid;
		if((xmid-radx)<MIN_X)
			radx=xmid-MIN_X;
		if((ymid+rady)>MAX_Y)
			rady=MAX_Y-ymid;
		if((ymid-rady)<MIN_Y)
			rady=ymid-MIN_Y;
		rectangle(xmid-radx,ymid-rady,xmid+radx,ymid+rady);
	}
	setwritemode(COPY_PUT);
	setcolor(Current_Color);
	x2 = mousex;
	y2 = mousey;
	xmid = (x1 + x2)/2;
	ymid = (y1 + y2)/2;
	radx = abs((x2 - x1)/2);
	rady = abs((y2 - y1)/2);
	if((xmid+radx)>MAX_X)
		radx=MAX_X-xmid;
	if((xmid-radx)<MIN_X)
		radx=xmid-MIN_X;
	if((ymid+rady)>MAX_Y)
		rady=MAX_Y-ymid;
	if((ymid-rady)<MIN_Y)
		rady=ymid-MIN_Y;
	algospiral(xmid,ymid,radx,rady);
}
*/

/* Problem Corrected in Algo below. Using Circle Drawing concept */
void drawspiral()
{
	int x1,y1,x2,y2,color,xmid,ymid;
	float radx;
	x1 = mousex;
	y1 = mousey;
	setwritemode(XOR_PUT);
	while(LeftButtonPressed)
	{
		disp_coord();
		x2 = mousex;
		y2 = mousey;
		xmid = (x1 + x2)/2;
		ymid = (y1 + y2)/2;
		radx = abs((x2 - x1)/2);
		if (radx < 1)
			radx = 1;
		color = 15 - Current_Color;
		setcolor(color);
		if((xmid+radx)>(MAX_X-2))
			radx=(MAX_X-2)-xmid;
		if((xmid-radx)<(MIN_X+2))
			radx=xmid-(MIN_X+2);
		if((ymid+radx)>(MAX_Y-2))
			radx=(MAX_Y-2)-ymid;
		if((ymid-radx)<(MIN_Y+8))
			radx=ymid-(MIN_Y+8);
		algoellipse(xmid,ymid,radx,radx);
/*		circle(xmid,ymid,radx);           */
		delay(20);
		getxy();
		if((xmid+radx)>(MAX_X-2))
			radx=(MAX_X-2)-xmid;
		if((xmid-radx)<(MIN_X+2))
			radx=xmid-(MIN_X+2);
		if((ymid+radx)>(MAX_Y-2))
			radx=(MAX_Y-2)-ymid;
		if((ymid-radx)<(MIN_Y+8))
			radx=ymid-(MIN_Y+8);
		algoellipse(xmid,ymid,radx,radx);
	}
	setwritemode(COPY_PUT);
	setcolor(Current_Color);
	x2 = mousex;
	y2 = mousey;
	xmid = (x1 + x2)/2;
	ymid = (y1 + y2)/2;
	radx = abs((x2 - x1)/2);
	if((xmid+radx)>(MAX_X-2))
		radx=(MAX_X-2)-xmid;
	if((xmid-radx)<(MIN_X+2))
		radx=xmid-(MIN_X+2);
	if((ymid+radx)>(MAX_Y-2))
		radx=(MAX_Y-2)-ymid;
	if((ymid-radx)<(MIN_Y+8))
		radx=ymid-(MIN_Y+8);
	/*circle(xmid,ymid,radx);*/
	algospiral(xmid,ymid,radx,radx);
}


void drawcircle()
{
	int x1,y1,x2,y2,color,xmid,ymid;
	float radx;
	x1 = mousex;
	y1 = mousey;
	setwritemode(XOR_PUT);
	while(LeftButtonPressed)
	{
		disp_coord();
		x2 = mousex;
		y2 = mousey;
		xmid = (x1 + x2)/2;
		ymid = (y1 + y2)/2;
		radx = abs((x2 - x1)/2);
		if (radx < 1)
			radx = 1;
		color = 15 - Current_Color;
		setcolor(color);
		if((xmid+radx)>(MAX_X-2))
			radx=(MAX_X-2)-xmid;
		if((xmid-radx)<(MIN_X+2))
			radx=xmid-(MIN_X+2);
		if((ymid+radx)>(MAX_Y-2))
			radx=(MAX_Y-2)-ymid;
		if((ymid-radx)<(MIN_Y+2))
			radx=ymid-(MIN_Y+2);
		algoellipse(xmid,ymid,radx,radx);
/*		circle(xmid,ymid,radx);           */
		delay(20);
		getxy();
		if((xmid+radx)>(MAX_X-2))
			radx=(MAX_X-2)-xmid;
		if((xmid-radx)<(MIN_X+2))
			radx=xmid-(MIN_X+2);
		if((ymid+radx)>(MAX_Y-2))
			radx=(MAX_Y-2)-ymid;
		if((ymid-radx)<(MIN_Y+2))
			radx=ymid-(MIN_Y+2);
		algoellipse(xmid,ymid,radx,radx);
/*		circle(xmid,ymid,radx); */
	}
	setwritemode(COPY_PUT);
	setcolor(Current_Color);
	x2 = mousex;
	y2 = mousey;
	xmid = (x1 + x2)/2;
	ymid = (y1 + y2)/2;
	radx = abs((x2 - x1)/2);
	if(Current_Pattern==EMPTY_FILL)
	{
		if((xmid+radx)>(MAX_X-2))
			radx=(MAX_X-2)-xmid;
		if((xmid-radx)<(MIN_X+2))
			radx=xmid-(MIN_X+2);
		if((ymid+radx)>(MAX_Y-2))
			radx=(MAX_Y-2)-ymid;
		if((ymid-radx)<(MIN_Y+2))
			radx=ymid-(MIN_Y+2);
		/*circle(xmid,ymid,radx);*/
		algoellipse(xmid,ymid,radx,radx);

	}
	else
	{
		setfillstyle(Current_Pattern,Current_Color);
		if((xmid+radx)>(MAX_X-2))
			radx=(MAX_X-2)-xmid;
		if((xmid-radx)<(MIN_X+2))
			radx=xmid-(MIN_X+2);
		if((ymid+radx)>(MAX_Y-2))
			radx=(MAX_Y-2)-ymid;
		if((ymid-radx)<(MIN_Y+2))
			radx=ymid-(MIN_Y+2);
		fillellipse(xmid,ymid,radx,radx);
	}

}

void save()
{
	char* name;
	FILE* out;
	char ch;
	int  row,col;
	int  byte;

	if(strcmp(FileName,"Untitled")==0)
	{
		name=readline("Save File As  : ");
		if(name==NULL) return;
	}
	else
	{	name=malloc(strlen(FileName)+1);
		strcpy(name,FileName);
	}

	out=fopen(name,"w");
	if(out==NULL)
	{
		ShowStatus(" Error Opening File !");
		delay(1000);
		ClearStatus();
		return;
	}

	ShowStatus(" Saving File (Please Wait) ");

	for(row=MIN_Y+2;row<=MAX_Y-2;++row)
	{
		for(col=MIN_X+2;col<=MAX_X-2;)
		{
			byte=getpixel(col,row);
			byte=byte<<4;
			col++;
			byte+=getpixel(col,row);
			col++;
			if(fputc(byte,out)==EOF)
			{
				ShowStatus("Error Writing FIle ! ");
				delay(1000);
				ClearStatus();
				free(name);
				fclose(out);
			}
		}
	}
	ClearStatus();
	strcpy(FileName,name);
	disp_filename();
	free(name);
	fclose(out);
	saved=1;

}

char* readline(char* msg)
{
	char* Line;
	char  temp[40];
	char  Disp_Line[60];
	char ch;
	int i=0,length=0;
	int max=((475-12)-strlen(msg)*8)/8;/*/ find maximum number of characters*/

	ClearStatus();
	setcolor(BLACK);
	outtextxy(12,464,msg);
	strcpy(Disp_Line,msg);

	ch=getch();
	while( (ch!=27)&& (ch!=13))
	{
		switch (ch)
		{
		case '\b'  : if(i==0)
				beep();
			  else
			  {
				i--;
				ClearStatus();
				length=strlen(Disp_Line);
				Disp_Line[length-1]='\0';
				setcolor(BLACK);
				outtextxy(12,464,Disp_Line);

			  }

			  break;
		default : if(i > max)
				beep();
			  else
			  {
				length=strlen(Disp_Line);
				Disp_Line[length]=ch;
				Disp_Line[length+1]='\0';
				outtextxy(12,464,Disp_Line);
				temp[i++]=ch;
			  }
			  break;
		}
		ch=getch();
	}

	temp[i]='\0';
	ClearStatus();
	if(ch==27)
		return NULL;
	else
	{
		Line=malloc(strlen(temp)+1);
		strcpy(Line,temp);
	}
	return Line;
}

void Load()
{
	FILE* in;
	char* name;
	char ch;
	int byte;
	int row,col;
	int temp;

	if(!saved)
	{
		ShowStatus(" Save Current File ? ");
		ch=getch();
		if(ch=='y'||ch=='Y')
		{
			save();
		}
	}

	name=readline(" Enter File To Load : ");
	if(name==NULL)
		return;

	in=fopen(name,"r");
	if(fopen==NULL)
	{
		ShowStatus(" Error Opening File ");
		delay(1000);
		ClearStatus();
		return;
	}

	byte=fgetc(in);
	/*if(byte==EOF)
	{
		ShowStatus(" Error Reading ");
		delay(1000);
		ClearStatus();
		free(name);
		fclose(in);
		return;
	}*/

	for(row=MIN_Y+2;row<=MAX_Y-2;row++)
	{
		for(col=MIN_X+2;col<=MAX_X-2;)
		{
			temp=(byte&0xf0)>>4;
			putpixel(col,row,temp);
			col++;
			temp=(byte&0x0f);
			putpixel(col,row,temp);
			col++;
			byte=fgetc(in);
			if(byte==EOF)
			{
				/*ShowStatus(" Error Reading ");
				delay(1000);
				ClearStatus();
				free(name);
				fclose(in);*/
				return;
			}
		}
	}
	strcpy(FileName,name);
	disp_filename();
	free(name);
	fclose(in);
	saved=1;
}

void mirror()
{
	int row;
	int x1,x2;
	int color1,color2;

	for(row=MIN_Y+2;row<=MAX_Y-2;++row)
	{
		x1=MIN_X+2;
		x2=MAX_X-2;
		while(x1<x2)
		{
			color1=getpixel(x1,row);
			color2=getpixel(x2,row);
			putpixel(x2,row,color1);
			putpixel(x1,row,color2);
			x1++;
			x2--;
		}
	}
}

void flip()
{
	int col;
	int y1,y2;
	int color1,color2;

	for(col=MIN_X+2;col<=MAX_X-2;++col)
	{
		y1=MIN_Y+2;
		y2=MAX_Y-2;
		while(y1<y2)
		{
			color1=getpixel(col,y1);
			color2=getpixel(col,y2);
			putpixel(col,y2,color1);
			putpixel(col,y1,color2);
			y1++;
			y2--;
		}
	}
}

void mark()
{
	int color=15-BLACK;
	int x,y;

	if(marked)
		unmark();

	setcolor(color);
	setwritemode(XOR_PUT);

	x=mousex;
	y=mousey;

	setlinestyle(DOTTED_LINE,1,1);
	while(LeftButtonPressed)
	{
		disp_coord();
		rectangle(x,y,mousex,mousey);
		getxy();
		rectangle(x,y,mousex,mousey);
	}
	setlinestyle(SOLID_LINE,1,1);

	if(x<mousex)
	{
		marker.left=x;
		marker.right=mousex;
		if(y<mousey)
		{
			marker.top=y;
			marker.bottom=mousey;
		}
		else
		{
			marker.top=mousey;
			marker.bottom=y;
		}
	}
	else
	{
		marker.left=mousex;
		marker.right=x;
		if(y<mousey)
		{
			marker.top=y;
			marker.bottom=mousey;
		}
		else
		{
			marker.top=mousey;
			marker.bottom=y;
		}
	}
	marked=1;
	setwritemode(COPY_PUT);
}

void unmark()
{
	int color=15-BLACK;
	setcolor(color);
	setwritemode(XOR_PUT);
	setlinestyle(DOTTED_LINE,1,1);
	rectangle(marker.left,marker.top,marker.right,marker.bottom);
	setlinestyle(SOLID_LINE,1,1);
	setwritemode(COPY_PUT);
	marked=0;

}

void delete()
{
	if(marked)
	{
		unmark();
		setfillstyle(SOLID_FILL,WHITE);
		bar(marker.left,marker.top,marker.right,marker.bottom);
	}
}

void translate()
{
	int left,right,bottom,top;
	int diffx,diffy;
	int color=15-BLACK;
	char* image;
	int   size;


	if(!marked) return;
	if(check_mouse_on(marker.left,marker.top,marker.right,marker.bottom))
	{
		setwritemode(XOR_PUT);
		setcolor(color);
		setlinestyle(DOTTED_LINE,1,1);

		left=marker.left;
		right=marker.right;
		top=marker.top;
		bottom=marker.bottom;

		while(LeftButtonPressed)
		{
			rectangle(left,top,right,bottom);
			getxy();
			diffx=prevx-mousex;
			diffy=prevy-mousey;
			left=left-diffx;
			right=right-diffx;
			bottom=bottom-diffy;
			top=top-diffy;
			if( (left<MIN_X+2)||(right>MAX_X-2)||(top<MIN_Y+2)||(bottom>MAX_Y-2) )
			{
				left=left+diffx;
				right=right+diffx;
				bottom=bottom+diffy;
				top=top+diffy;
			}
			rectangle(left,top,right,bottom);
		}

		marked=0;
		setwritemode(COPY_PUT);
		size=imagesize(marker.left,marker.top,marker.right,marker.bottom);
		if(size!=-1)
		{
			image=malloc(size);
			if(image!=NULL)
			{
				getimage(marker.left,marker.top,marker.right,marker.bottom,image);
				setfillstyle(SOLID_FILL,WHITE);
				bar(marker.left,marker.top,marker.right,marker.bottom);
				putimage(left,top,image,COPY_PUT);
				free(image);
			}
			else
			{
				ShowStatus(" No Memory! ");
				delay(1000);
				ClearStatus();
			}
		}
		else
		{
			ShowStatus(" No Memory! ");
			delay(1000);
			ClearStatus();
		}
		setlinestyle(SOLID_LINE,1,1);
	}


}

void rotate()
{
	char* charangle;
	int angle;
	float rad;
	int x,y;
	int xf=marker.left;/*/(marker.left-marker.right)/2+marker.left;*/
	int yf=marker.bottom;/*/(marker.bottom-marker.top)/2+marker.top;  */
	int row,col;
	int pixel;
	FILE* temp; /* added code*/

	if(!marked) return;

	charangle=readline(" Enter The Angle Of Rotation (?0,?80,?70) : ");
	if(charangle==NULL) return;
	angle=atoi(charangle);
/*	if(abs(angle)!=90&&abs(angle)!=180&&abs(angle)!=270)
	{
		ShowStatus(" Invalid Angle! ");
		delay(1000);
		ClearStatus();
		return;
	}
*/
	/*added code begins*/
	temp=fopen("work","w");
		if(temp==NULL)
		{
			ShowStatus("Cannot Proceed!");
			delay(1000);
			ClearStatus();
			return;
		}

		for(row=marker.top+1;row<marker.bottom;++row)
		{
			for(col=marker.left+1;col<marker.right;++col)
			{
				pixel=getpixel(col,row);
				fputc(pixel,temp);
			}
		}
		fclose(temp);

		temp=fopen("work","r");
		if(temp==NULL)
		{
			ShowStatus(" Cannot Proceed ! ");
			delay(1000);
			ClearStatus();
			return;
		}
/*	 added code ends */
	rad=angle*M_PI/180.0;

	unmark();
	setwritemode(COPY_PUT);
	for(row=marker.top;row<=marker.bottom;++row)
		for(col=marker.left;col<=marker.right;++col)
			putpixel(col,row,WHITE);
	for(row=marker.top+1;row<marker.bottom;++row)
	{
		for(col=marker.left+1;col<marker.right;++col)
		{
		/*	pixel=getpixel(col,row); */
			pixel=fgetc(temp);
			x=ceil((1-cos(rad))*(xf)+sin(rad)*(yf)+col*cos(rad)-row*sin(rad));
			y=ceil((1-cos(rad))*(yf)-sin(rad)*(xf)+col*sin(rad)+row*cos(rad));
			/*x=(col-xf)*cos(rad)+(yf-row)*sin(rad)+xf;*/
			/*y=(col-xf)*sin(rad)+(row-yf)*cos(rad)+yf;*/
			if(x>=MIN_X+2&&x<=MAX_X-2&&y>=MIN_Y+2&&y<=MAX_Y-2)
			{
				putpixel(x,y,pixel);
				putpixel(x+1,y,pixel);
				putpixel(x,y+1,pixel);
				putpixel(x,y-1,pixel);
				putpixel(x-1,y,pixel);
			}

		 }
	}

}

void scale()
{
	int   left,right,bottom,top;
	float x,y;
	float Sx,Sy;
	float i,j;
	int   row,col;
	int   pixel;
	int   check_scale_done=0;
	FILE* temp;

	if(!marked) return;

	while(1)
	{
	if(RightButtonPressed)
		return;
	else
	{
		showmouse();
		if(!check_mouse_on(marker.left,marker.top,marker.right,marker.bottom))
		{
			startmouse(marker.right,marker.bottom);
			setcolor(15-BLACK);
			setlinestyle(DOTTED_LINE,1,1);
			setwritemode(XOR_PUT);
		}
		left=marker.left;right=marker.right;top=marker.top;bottom=marker.bottom;
		restrictmouse(left,top,MAX_X-2,MAX_Y-2);
		delay(1000);
		while(LeftButtonPressed)
/*		while(buttclicked()==1)  */
		{
			rectangle(left,top,right,bottom);
			getxy();
			right=mousex;
			bottom=mousey;
			rectangle(left,top,right,bottom);
			disp_coord();
		}
		rectangle(left,top,right,bottom);

		marked=0;
		setlinestyle(SOLID_LINE,1,1);
		setwritemode(COPY_PUT);

		Sx=((float)(right-left))/(marker.right-marker.left);
		Sy=((float)(bottom-top))/(marker.bottom-marker.top);

		temp=fopen("work","w");
		if(temp==NULL)
		{
			ShowStatus("Cannot Proceed!");
			delay(1000);
			ClearStatus();
			return;
		}

		for(row=marker.top;row<=marker.bottom;++row)
		{
			for(col=marker.left;col<=marker.right;++col)
			{
				pixel=getpixel(col,row);
				fputc(pixel,temp);
			}
		}
		fclose(temp);

		temp=fopen("work","r");
		if(temp==NULL)
		{
			ShowStatus(" Cannot Proceed ! ");
			delay(1000);
			ClearStatus();
			return;
		}

		for(y=top;y<=bottom;y+=Sy)
		{
			for(x=left;x<=right;x+=Sx)
			{
				pixel=fgetc(temp);
				for(j=0;j<=Sy;j++)
				{
					for(i=0;i<=Sx;i++)
					{
						putpixel((int)(ceil(x+i)),(int)(ceil(y+j)),pixel);
					}
				}

			}
		}


		/*
		for(row=marker.top;row<=marker.bottom;++row)
		{
			for(col=marker.left;col<=marker.right;++col)
			{
				pixel=fgetc(temp);
				putpixel((int)(ceil(col+50)),(int)(ceil(row+50)),pixel);
			}
		}
		*/

		check_scale_done=1;
	}/* end of else*/
	if(check_scale_done==1)
	{
		check_scale_done=0;
		break;
	}
	}
fclose(temp);
restrictmouse(0,0,640,480);

}

void clip()
{
	int i,j;
	if(!marked) return;

	unmark();
	for(j=MIN_Y+2;j<=MAX_Y-2;++j)
	{
		for(i=MIN_X+2;i<=MAX_X-2;++i)
		{
			if( (i>=marker.left&&i<=marker.right) &&( j>=marker.top && j<=marker.bottom ) )
			{
			}
			else
				putpixel(i,j,WHITE);
		}
	}
}

int over(int x,int y,int w,int h)
{
int x1,y1;

x1=x+w;
y1=y+h;
wheremouse(&mousex,&mousey);

	if( (mousex>x) && (mousex<x1) && (mousey>y) && (mousey <y1) )
		return 1;
	else
		return 0;
}


void sphere()
{
int i,r;
int px,py;
int ex,ey;

		setcolor(Current_Color);

	if(over(40,50,MAX_X-60,MAX_Y-65)==0)return;
		{

			wheremouse(&mousex,&mousey);
			px=mousex;py=mousey;
			setwritemode(XOR_PUT);
			if(over(40,50,MAX_X-60,MAX_Y-65)==0)return;

			if(buttclicked()==1)
			while(1)
			{

			hidemouse();
			line(px,py,px,mousey);/*    pxpy      mxpy */
			line(px,py,mousex,py);/*    pxmy      mxmy */
			line(mousex,mousey,px,mousey);
			line(mousex,mousey,mousex,py);
			showmouse();

			if(buttclicked()!=1)break;
			wheremouse(&mousex,&mousey);
			if(over(40,50,MAX_X-60,MAX_Y-65)==0)
				while(over(40,50,MAX_X-60,MAX_Y-65)==0);
			if(buttclicked()!=1)break;

			hidemouse();
			line(px,py,px,mousey);
			line(px,py,mousex,py);
			line(mousex,mousey,px,mousey);
			line(mousex,mousey,mousex,py);
			showmouse();
			}
			hidemouse();
			setcolor(WHITE);

			setwritemode(COPY_PUT);
			setcolor(Current_Color);
			ex= (px+mousex)/2;
			ey=(py+mousey)/2 ;
	ellipse( ex , ey , 0,360, abs((px-mousex)/2) ,abs((py-mousey)/2));
	r=abs( (py-mousey)/2);
	for(i=4;i<= r;i+=5)
		{
		ellipse( ex , ey , 0,360, abs((px-mousex)/2) ,i);
		}
	r= abs( (px-mousex)/2);
	for(i=4;i<=r;i+=5)
		{
		ellipse( ex , ey , 0,360, i,abs((py-mousey)/2));
		}


			showmouse();

		}

}





void main()
{
	int i,j,gd=DETECT,gm=DETECT;
	initgraph(&gd,&gm,"");
	if(graphresult())
	{
		printf("\n Could not initialise graphics \n");
		exit(0);
	}


	/*
	cleardevice();
	setcolor(DARKGRAY);
	title(getmaxx()/2-180,getmaxy()/2-150,getmaxx()/2+180,getmaxy()/2+150);
	settextstyle(0,0,1);
	settextjustify(LEFT_TEXT,TOP_TEXT);
	setusercharsize(1,1,1,1);
	setcolor(WHITE);
	outtextxy(getmaxx()/2-150,getmaxy()/2-100,"Abhishek Dhingra's");
	setcolor(DARKGRAY);
	outtextxy(170,285,"for DOS environment");
	settextstyle(8,0,2);
	setusercharsize(3,2,5,1);
	setcolor(BLACK);
	for(i=0;i<=6;i++)
	outtextxy(getmaxx()/2-150+i,getmaxy()/2-150,"DOS Paint");
	settextstyle(8,0,1);
	setusercharsize(1,1,1,1);
	setfillstyle(1,BLACK);
	rectangle(170,275,430,280);
	floodfill(175,277,BLACK);
	circle(429,186,5);
	settextstyle(2,0,4);
	outtextxy(427,180,"R");
	settextstyle(6,0,1);
	outtextxy(150,355,"Version 1.0");
	settextstyle(2,0,4);
	outtextxy(330,330,"This product is licensed to");
	outtextxy(395,345,"R.V.C.E");
	flushall();
	getch();
	flushall();

	closegraph();
	initgraph(&gd,&gm,"c:\\turboc2\\include");
	if(graphresult())
	{
		printf("\n Could not initialise graphics \n");
		exit(0);
	}
	*/
	reset();
	start_up();
	showmouse();
	startmouse(300,300);
	disp_filename();
	/*setfillstyle(SOLID_FILL,LIGHTGRAY);*/
	/*bar(8,25,78,270);                  */


	init();
	undraw_button_border(Current_Button);
	while(1)
	{
		getxy();
		disp_coord();
		if(LeftButtonPressed)
		{
			if(check_if_button_pressed()>=0);
			else if(check_if_color())
				ClearStatus();
			else if(check_mouse_on(MIN_X+2,MIN_Y+2,MAX_X-2,MAX_Y-2))
			{
				ClearStatus();
				saved=0;/* file has been altered; */
				Diagram();
			}
			else check_if_exit();
		}
		else check_if_button_pressed();
	}
}