i cannot see the mouse arrow

This is a discussion on i cannot see the mouse arrow within the C Programming forums, part of the General Programming Boards category; Code: /************************************************************************ DOSPAINT By Abhishek Dhingra written in Borland Turbo C (code not optmized) Anyone and Everyone is allowed to ...

  1. #1
    Registered User
    Join Date
    Dec 2006
    Posts
    9

    i cannot see the mouse arrow

    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: abhishekd@softhome.net
    
    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();
    	}
    }

  2. #2
    Registered User
    Join Date
    Dec 2006
    Posts
    9
    this don't show the mouse either.
    Code:
           #include <dos.h>   
    	   #include <graphics.h>
    	void   main()
           {  union REGS i,o;
    		   int gdriver=DETECT, gmode;
               initgraph(&gdriver, &gmode, "..\\bgi");
    
            
    
    	 clrscr();
    
    	 i.x.ax=0;
      	 int86(0x33,&i,&o);
    
      	 if(o.x.ax==0)
             {
    	    printf("No Mouse Available.....");
        	    exit();
             }
    
      	 i.x.ax=1;
    	 int86(0x33,&i,&o);
         getch(); 
    	 closegraph();
          }

  3. #3
    Registered User whiteflags's Avatar
    Join Date
    Apr 2006
    Location
    United States
    Posts
    7,752
    Your compiler is probably incompatible with your architecture, meaning that you're using an ancient 16-bit compiler on a 32-bit machine. Of course the graphics library won't work--you need something newer than that.

  4. #4
    Registered User
    Join Date
    Dec 2006
    Posts
    9

    Thumbs up

    i see, thank u ,i'll try it on Vc,i just finished download it

  5. #5
    Frequently Quite Prolix dwks's Avatar
    Join Date
    Apr 2005
    Location
    Canada
    Posts
    8,048
    void main() . . . ugh. http://faq.cprogramming.com/cgi-bin/...&id=1043284376

    MSVC won't be able to compile that. Nor will anything but a Borland compiler (or a compiler made to look like a Borland compiler), because you're using their graphics library.

    DJGPP comes close -- it would compile most of that except for the BGI code. You could try porting it to there.

    Or you could compile it with the ancient 16-bit Borland Turbo C compiler that it was written on.
    dwk

    Seek and ye shall find. quaere et invenies.

    "Simplicity does not precede complexity, but follows it." -- Alan Perlis
    "Testing can only prove the presence of bugs, not their absence." -- Edsger Dijkstra
    "The only real mistake is the one from which we learn nothing." -- John Powell


    Other boards: DaniWeb, TPS
    Unofficial Wiki FAQ: cpwiki.sf.net

    My website: http://dwks.theprogrammingsite.com/
    Projects: codeform, xuni, atlantis, nort, etc.

  6. #6
    Registered User
    Join Date
    Dec 2006
    Posts
    9
    i did run in turboc version2 and run in version3,neither work

    Code:
      #include <dos.h>   
    	   #include <graphics.h>
    	void   main()
           {  union REGS i,o;
    		   int gdriver=DETECT, gmode;
               initgraph(&gdriver, &gmode, "..\\bgi");
    
            
    
    	 clrscr();
    
    	 i.x.ax=0;
      	 int86(0x33,&i,&o);
    
      	 if(o.x.ax==0)
             {
    	    printf("No Mouse Available.....");
        	    exit();
             }
    
      	 i.x.ax=1;
    	 int86(0x33,&i,&o);
         getch(); 
    	 closegraph();
          }
    i read a tutorial, this should show the arrow,but it didn't

  7. #7
    Registered User
    Join Date
    Mar 2006
    Posts
    725
    This must be setting the record for the longest code dump ever.

    You have a few options, either:
    - Get an older system
    - Use a newer graphics library
    Code:
    #include <stdio.h>
    
    void J(char*a){int f,i=0,c='1';for(;a[i]!='0';++i)if(i==81){
    puts(a);return;}for(;c<='9';++c){for(f=0;f<9;++f)if(a[i-i%27+i%9
    /3*3+f/3*9+f%3]==c||a[i%9+f*9]==c||a[i-i%9+f]==c)goto e;a[i]=c;J(a);a[i]
    ='0';e:;}}int main(int c,char**v){int t=0;if(c>1){for(;v[1][
    t];++t);if(t==81){J(v[1]);return 0;}}puts("sudoku [0-9]{81}");return 1;}

Popular pages Recent additions subscribe to a feed

Similar Threads

  1. Mouse being controlled my arrow keys
    By vopo in forum Windows Programming
    Replies: 2
    Last Post: 11-05-2007, 12:33 AM
  2. need Help in Mouse Pointer
    By obaid in forum C++ Programming
    Replies: 3
    Last Post: 12-07-2006, 03:33 AM
  3. Problem in mouse position
    By Arangol in forum Game Programming
    Replies: 6
    Last Post: 08-08-2006, 08:07 AM
  4. Making a mouse hover button, API style
    By hanhao in forum C++ Programming
    Replies: 1
    Last Post: 05-27-2004, 07:17 AM
  5. Game Design Topic #2 - Keyboard or Mouse?
    By TechWins in forum Game Programming
    Replies: 4
    Last Post: 10-08-2002, 04:34 PM

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21