1

#include<glut.h>
2 #include<stdlib.h>
3 #include<math.h>
4 #include<stdio.h>
5 #include<windows.h>
6
7 GLsizei wh = 600, ww = 800,wx,wy, wx1=800, wy1=600;/*display window size*/
8
9 char* image;
10
11 int count=0;
12 int sub_menu;
13
14 int draw; /* to store draw option*/
15 int i,j,k;
16 float a[100][2], b[100][2]; /*to store the vertices of all the polygons drawn*/
17 int m, n;
18 int pol;
19 int flag=0, flag1;
20 int fill=0;
21 float textx,texty, textz=0.0;
22 float a1=0, a2=0, a3=0, b1=0, b2=0, b3=0; /* store vertices of the polygon to be drawn */
23 int size=1; /* pixel size */
24
25 int save=0;
26
27
28 float posx, posy;
29 void *currentfont;
30
31 FILE *fptr;
32 char fname[20];
33 int s=0;
34 int wel=0;
35
36
37 void drawstring(float x,float y,float z,char *string) /* to display text */
38 {
39 char *c;
40 glRasterPos3f(x,y,z);
41
42 for(c=string;*c!='\0';c++)
43 {
44 glutBitmapCharacter(currentfont,*c);
45 }
46 }
47
48
49
50 void setFont(void *font)
51 {
52 currentfont=font;
53 }
54
55
56
57
58 void drawpoint(int x, int y) /* to draw point */
59 {
60 y=wh-y;
61
62 if(x>wh/10+1 && wh/10<y && y<wh-31)
63 {
64 glPointSize(size);
65 glBegin(GL_POINTS);
66 glVertex2f(x, y);
67
68 glEnd();
69
70 glFlush();
71 }
72 }

 73
74
75
76
77 void paint(int x, int y) /* PAINT BRUSH function */
78 {
79 y=wh-y;
80
81
82
83 if(x>wh/10+1 && wh/10<y && y<wh-31)
84 {
85 glBegin(GL_POLYGON);
86 glVertex2f(x, y);
87 glVertex2f(x+4+size, y);
88 glVertex2f(x+4+size, y+4+size);
89 glVertex2f(x, y+4+size);
90 glEnd();
91 glFlush();
92 }
93
94 }
95
96
97
98 void eraser(int x, int y) /* ERASER function */
99 {
100 y=wh-y;
101
102 glColor3f(1, 1, 1);
103
104 if(x>wh/10+1 && wh/10<y && y<wh-31)
105 {
106 glBegin(GL_POLYGON);
107 glVertex2f(x, y);
108 glVertex2f(x+5, y);
109 glVertex2f(x+5, y+5);
110 glVertex2f(x, y+5);
111 glEnd();
112 glFlush();
113 }
114
115 }
116
117
118
119 void reset() /* resets the variables in which vertices are stored,after a polygon is drawn */
120 {
121 a1=0;
122 a2=0;
123 b1=0;
124 b2=0;
125 a3=0;
126 b3=0;
127 }
128
129
130
131 void palette(float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4) /* to draw the COLOR
PALETTE */
132 {
133 glBegin(GL_QUADS);
134 glVertex2f(x1, y1);
135 glVertex2f(x2, y2);
136 glVertex2f(x3, y3);
137 glVertex2f(x4, y4);
138 glEnd();
139 }
140
141
142
143 void draw_pixel(GLfloat x, GLfloat y) /*to draw the points of a circle */

 144 {
145 if(x>wh/10+1 && wh/10<y && y<wh-31)
146 {
147 if(fill==1)
148 glPointSize(3);
149 else
150 glPointSize(size);
151 glBegin(GL_POINTS);
152 glVertex2f(x, y);
153 glEnd();
154 }
155 }
156
157
158
159 void plotpixels(GLfloat p, GLfloat q, GLfloat x, GLfloat y)
160 {
161 draw_pixel(x+p, y+q);
162 draw_pixel(-x+p, y+q);
163 draw_pixel(x+p, -y+q);
164 draw_pixel(-x+p, -y+q);
165
166
167 draw_pixel(y+p, x+q);
168 draw_pixel(-y+p, x+q);
169 draw_pixel(y+p, -x+q);
170 draw_pixel(-y+p, -x+q);
171 }
172
173
174 void draw_circle(GLfloat p, GLfloat q, GLfloat r) /* to draw a CIRCLE using MIDPOINT CIRCLE DRAWING algorithm
*/
175 {
176 GLfloat d=1-r, x=0, y=r;
177
178 while(y>x)
179 {
180 plotpixels(p, q, x, y);
181 if(d<0) d+=2*x+3;
182 else
183 {
184 d+=2*(x-y)+5;
185 --y;
186 }
187 ++x;
188 }
189 plotpixels(p, q, x, y);
190 }
191
192
193 void draw_pixel1(GLfloat x, GLfloat y)
194 {
195
196 glBegin(GL_POINTS);
197 glVertex2f(x, y);
198 glEnd();
199
200 }
201
202 void plotpixels1(GLfloat p, GLfloat q, GLfloat x, GLfloat y) /* to draw the circle option on the tool bar */
203 {
204 draw_pixel1(x+p, y+q);
205 draw_pixel1(-x+p, y+q);
206 draw_pixel1(x+p, -y+q);
207 draw_pixel1(-x+p, -y+q);
208
209
210 draw_pixel1(y+p, x+q);
211 draw_pixel1(-y+p, x+q);
212 draw_pixel1(y+p, -x+q);
213 draw_pixel1(-y+p, -x+q);
214 }

 215
216 void draw_circle1(GLfloat p, GLfloat q, GLfloat r) /* to draw the circle option on the tool bar */
217 {
218 GLint d=1-r, x=0, y=r;
219
220 while(y>x)
221 {
222 plotpixels1(p, q, x, y);
223 if(d<0) d+=2*x+3;
224 else
225 {
226 d+=2*(x-y)+5;
227 --y;
228 }
229 ++x;
230 }
231 plotpixels1(p, q, x, y);
232 }
233
234
235
236
237 void edgedetect(float x1, float y1, float x2, float y2, int *le, int *re) /* to detect edges of the polygon to b
e filled */
238 {
239 float mx, x, temp;
240
241 if((y2-y1)<0)
242 {
243 temp=y1;
244 y1=y2;
245 y2=temp;
246
247 temp=x1;
248 x1=x2;
249 x2=temp;
250 }
251
252 if((y2-y1)!=0)
253 mx=(x2-x1)/(y2-y1);
254 else
255 mx=x2-x1;
256
257 x=x1;
258
259 for(i=y1;i<=y2;i++)
260 {
261 if(x<(float)le[i])
262 le[i]=(int)x;
263 if(x>(float)re[i])
264 re[i]=(int)x;
265 x+=mx;
266 }
267 }
268
269
270
271 void scanfill(GLint num1, GLint num2) /* to FILL a Polygon using SCAN LINE ALGORITHM*/
272 {
273 int le[1000], re[1000];
274 int p, q;
275 int bottom, top;
276
277 for(p=0;p<wh;p++)
278 {
279 le[p]=ww;
280 re[p]=0;
281 }
282
283 for(p=num1;p<num2;p++)
284 {
285 edgedetect(a[p][0], a[p][1], a[p+1][0], a[p+1][1], le, re);

 286 }
287
288 edgedetect(a[num2][0], a[num2][1], a[num1][0], a[num1][1], le, re);
289
290 for(q=0;q<wh;q++)
291 le[q]=le[q]+1;
292
293 bottom=0;
294 while(re[bottom]<le[bottom])
295 bottom++;
296
297 bottom++;
298
299 top=wh-1;
300 while(re[top]<le[top])
301 top--;
302
303
304 for(q=bottom;q<top;q++)
305 {
306 if(le[q]<=re[q])
307 {
308 for(p=(int)le[q];p<(int)re[q];p++)
309 draw_pixel(p, q);
310 }
311 }
312 }
313
314
315 void detect_point(GLint num1, GLint num2, int x, int y) /* to detect which POLYGON TO BE FILLED */
316 {
317 int le[1000], re[1000];
318 int p, q;
319
320 for(p=0;p<wh;p++)
321 {
322 le[p]=ww;
323 re[p]=0;
324 }
325
326 for(p=num1;p<num2;p++)
327 {
328 edgedetect(a[p][0], a[p][1], a[p+1][0], a[p+1][1], le, re);
329 }
330
331 edgedetect(a[num2][0], a[num2][1], a[num1][0], a[num1][1], le, re);
332
333 for(q=0;q<wh;q++)
334 {
335 if(le[q]<=re[q])
336 {
337 for(p=(int)le[q];p<(int)re[q];p++)
338 {
339 if(x==p && y==q)
340 flag=num1;
341 }
342 }
343 }
344 }
345
346
347
348 void display(void) /*DISPLAY function*/
349 {
350
351 glClearColor (1.0, 1.0, 1.0, 1.0);
352 glClear(GL_COLOR_BUFFER_BIT); /*Clears color buffer*/
353
354
355
356
357 if(wel==0 || wel==1)

 358 {
359
360
361
/* Welcome Screen */
362
363
364 glClearColor (0.0, 0.0, 0.0, 1.0);
365 glClear(GL_COLOR_BUFFER_BIT);
366
367
368 setFont(GLUT_BITMAP_HELVETICA_18);
369 glColor3f(0, 1, 1);
370 drawstring(22*wh/45, 42*wh/45 , 0.0, "A Mini Project On");
371
372 drawstring(8*wh/45, 40*wh/45, 0.0, "DESIGN AND IMPLEMENTION OF GRAPHICS EDITOR");
373
374
375
376 setFont(GLUT_BITMAP_HELVETICA_12);
377
378 drawstring(25*wh/45, 32*wh/45, 0.0, "BY:");
379 drawstring(8*wh/45, 29*wh/45, 0.0, "Name 1");
380 drawstring(8*wh/45, 27*wh/45, 0.0, "usn");
381
382
383 drawstring(35*wh/45, 29*wh/45, 0.0, "Name 2");
384 drawstring(35*wh/45, 27*wh/45, 0.0, "usn");
385
386
387
388 drawstring(20*wh/45, 20*wh/45, 0.0, "UNDER THE GUIDENCE OF:");
389
390 drawstring(5*wh/45, 17*wh/45, 0.0, "Teacher");
391 drawstring(5*wh/45, 15*wh/45, 0.0, "LECTURER, Dept. of CS&E");
392 drawstring(5*wh/45, 13*wh/45, 0.0, "College");
393
394 drawstring(38*wh/45, 17*wh/45, 0.0, "Teacher");
395 drawstring(38*wh/45, 15*wh/45, 0.0, "LECTURER, Dept. of CS&E");
396 drawstring(38*wh/45, 13*wh/45, 0.0, "College");
397
398
399 wel=1;
400
401 glFlush();
402 glClearColor (1.0, 1.0, 1.0, 1.0);
403 glClear(GL_COLOR_BUFFER_BIT);
404
405
406 }
407
408
409 if(wel==2)
410 {
411
412 count++;
413
414 if(count>1)
415 {
416
417 if(ww!=0 && wh!=0)
418 { wx=wx1;
419 wy=wy1;
420
421 wx1=ww;
422 wy1=wh;
423 }
424
425 glDrawBuffer(GL_FRONT); /* selecting GL_FRONT buffer to write*/
426 glRasterPos2f(posx, posy);
427 glDrawPixels(wx-wy/10-2, wy-wy/10-wy/20-1, GL_RGB, GL_UNSIGNED_BYTE, image); /* to write pixels i
nto the selected buffer */

 428
429 }
430
431
432
433
434 glColor3f(0.85, 0.85, 0.85);
435 glPointSize(1);
436 glLineWidth(1);
437 glRectf(0,wh/10+1,wh/10,wh-(wh/20)-1); /* to draw the TOOL BAR */
438
439 glRectf(0, 0, ww, wh/10); /* to draw COLOR AREA */
440
441 glRectf(0,wh-(wh/20), ww, wh); /* to draw MENU BAR*/
442
443
444 glColor3f(0.5, 0.5, 0.5);
445 glBegin(GL_LINES);
446 glVertex2f(wh/10, wh/10+2);
447 glVertex2f(wh/10, wh-(wh/20)+2);
448 glVertex2f(wh/10+1, wh/10+2);
449 glVertex2f(wh/10+1, wh-(wh/20)+2);
450 glEnd();
451
452 glColor3f(0.5, 0.5, 0.5);
453 glBegin(GL_LINES);
454 glVertex2f(wh/10+1, wh-(wh/20));
455 glVertex2f(ww, wh-(wh/20));
456 glVertex2f(wh/10+1, wh-(wh/20)+1);
457 glVertex2f(ww, wh-(wh/20)+1);
458 glEnd();
459
460 /* to draw COLOR PALETTE */
461
462 glColor3f(0, 0, 0);
463 palette(6*wh/60+1, wh/60, 6*wh/60+1, wh/20-1, 8*wh/60-1, wh/20-1, 8*wh/60-1, wh/60);
464
465 glColor3f(1, 1, 1);
466 palette(6*wh/60+1, wh/20+1, 6*wh/60+1, wh/12, 8*wh/60-1, wh/12, 8*wh/60-1, wh/20+1);
467
468
469 glColor3f(0, 0, 1);
470 palette(8*wh/60+1, wh/60, 8*wh/60+1, wh/20-1, 10*wh/60-1, wh/20-1, 10*wh/60-1, wh/60);
471
472
473 glColor3f(1, 0, 1);
474 palette(8*wh/60+1, wh/20+1, 8*wh/60+1, wh/12, 10*wh/60-1, wh/12, 10*wh/60-1, wh/20+1);
475
476 glColor3f(1, 1, 0);
477 palette(10*wh/60+1, wh/60, 10*wh/60+1, wh/20-1, 12*wh/60-1, wh/20-1, 12*wh/60-1, wh/60);
478
479 glColor3f(1, 0, 0);
480 palette(10*wh/60+1, wh/20+1, 10*wh/60+1, wh/12, 12*wh/60-1, wh/12, 12*wh/60-1, wh/20+1);
481
482 glColor3f(0, 1, 0);
483 palette(12*wh/60+1, wh/60, 12*wh/60+1, wh/20-1, 14*wh/60-1, wh/20-1, 14*wh/60-1, wh/60);
484
485
486 glColor3f(0, 1, 1);
487 palette(12*wh/60+1, wh/20+1, 12*wh/60+1, wh/12, 14*wh/60-1, wh/12, 14*wh/60-1, wh/20+1);
488
489
490 glColor3f(0.5, 0.5, 0);
491 palette(14*wh/60+1, wh/60, 14*wh/60+1, wh/20-1, 16*wh/60-1, wh/20-1, 16*wh/60-1, wh/60);
492
493
494 glColor3f(0.1, 0.4, 0.6);
495 palette(14*wh/60+1, wh/20+1, 14*wh/60+1, wh/12, 16*wh/60-1, wh/12, 16*wh/60-1, wh/20+1);
496
497 glColor3f(0.4, 0.1, 0.1);
498 palette(16*wh/60+1, wh/60, 16*wh/60+1, wh/20-1, 18*wh/60-1, wh/20-1, 18*wh/60-1, wh/60);
499

 500
501 glColor3f(0.9, 0.1, 0.5);
502 palette(16*wh/60+1, wh/20+1, 16*wh/60+1, wh/12, 18*wh/60-1, wh/12, 18*wh/60-1, wh/20+1);
503
504
505 glColor3f(0.5, 0.1, 0.5);
506 palette(18*wh/60+1, wh/60, 18*wh/60+1, wh/20-1, 20*wh/60-1, wh/20-1, 20*wh/60-1, wh/60);
507
508
509 glColor3f(0.3, 0.1, 0.5);
510 palette(18*wh/60+1, wh/20+1, 18*wh/60+1, wh/12, 20*wh/60-1, wh/12, 20*wh/60-1, wh/20+1);
511
512 glColor3f(0.0, 0.5, 0.1);
513 palette(20*wh/60+1, wh/60, 20*wh/60+1, wh/20-1, 22*wh/60-1, wh/20-1, 22*wh/60-1, wh/60);
514
515
516 glColor3f(0.9, 0.8, 0.0);
517 palette(20*wh/60+1, wh/20+1, 20*wh/60+1, wh/12, 22*wh/60-1, wh/12, 22*wh/60-1, wh/20+1);
518
519
520 glColor3f(0.7, 0.0, 0.0);
521 palette(22*wh/60+1, wh/60, 22*wh/60+1, wh/20-1, 24*wh/60-1, wh/20-1, 24*wh/60-1, wh/60);
522
523
524 glColor3f(0.5, 0.5, 0.5);
525 palette(22*wh/60+1, wh/20+1, 22*wh/60+1, wh/12, 24*wh/60-1, wh/12, 24*wh/60-1, wh/20+1);
526
527 /*end color palette */
528
529
530 glColor3f(0, 0, 0);
531
532
533 glBegin(GL_LINE_LOOP); /* to draw TOOL BOX */
534 glVertex2f(2, wh-(wh/20)-1);
535 glVertex2f(wh/10-2, wh-(wh/20)-1);
536 glVertex2f(wh/10-2,14*wh/20);
537 glVertex2f(2, 14*wh/20);
538 glEnd();
539
540
541 glBegin(GL_LINES);
542 glVertex2f(wh/20, wh-(wh/20)-1);
543 glVertex2f(wh/20, 14*wh/20);
544
545 glVertex2f(2, 18*wh/20);
546 glVertex2f(wh/10-2, 18*wh/20);
547
548 glVertex2f(2, 17*wh/20);
549 glVertex2f(wh/10-2, 17*wh/20);
550
551 glVertex2f(2, 16*wh/20);
552 glVertex2f(wh/10-2, 16*wh/20);
553
554 glVertex2f(2, 15*wh/20);
555 glVertex2f(wh/10-2, 15*wh/20);
556
557
558 glEnd();
559
560
561
562 glBegin(GL_LINES); /* to draw LINE OPTION on tool bar */
563 glVertex2f(4*wh/60, 18.8*wh/20);
564 glVertex2f(5*wh/60, 18.2*wh/20);
565 glEnd();
566
567
568 glBegin(GL_LINE_LOOP); /* to draw TRIANGLE OPTION on tool bar */
569 glVertex2f(wh/40, 17.8*wh/20);
570 glVertex2f(wh/120, 17.2*wh/20);
571 glVertex2f(5*wh/120, 17.2*wh/20);

 572 glEnd();
573
574 glBegin(GL_LINE_LOOP); /* to draw RECTANGLE OPTION on tool bar */
575 glVertex2f(7*wh/120, 17.8*wh/20);
576 glVertex2f(11*wh/120-2, 17.8*wh/20);
577 glVertex2f(11*wh/120-2, 17.2*wh/20);
578 glVertex2f(7*wh/120, 17.2*wh/20);
579 glEnd();
580
581
582 glBegin(GL_TRIANGLES); /* to draw PENCIL OPTION on tool bar */
583 glVertex2f(3*wh/120-1, 18.10*wh/20);
584 glVertex2f(wh/60+2, 18.3*wh/20);
585 glVertex2f(2*wh/60-4, 18.3*wh/20);
586 glEnd();
587
588 glBegin(GL_LINE_LOOP);
589 glVertex2f(wh/60+2, 18.3*wh/20);
590 glVertex2f(wh/60+2, 18.8*wh/20);
591 glVertex2f(2*wh/60-4, 18.8*wh/20);
592 glVertex2f(2*wh/60-4, 18.3*wh/20);
593 glEnd();
594
595 glColor3f(1, 1, 1);
596 glBegin(GL_QUADS); /* to draw ERASER OPTION on tool bar */
597 glVertex2f(4*wh/60, 15.7*wh/20);
598 glVertex2f(5*wh/60, 15.7*wh/20);
599 glVertex2f(5*wh/60, 15.3*wh/20);
600 glVertex2f(4*wh/60, 15.3*wh/20);
601 glEnd();
602
603 glColor3f(0, 0, 0);
604
605 glBegin(GL_LINE_LOOP); /* to draw PENCIL OPTION on tool bar */
606 glVertex2f(wh/120, 16.2*wh/20);
607 glVertex2f(5*wh/120, 16.2*wh/20);
608 glVertex2f(5*wh/120, 16.4*wh/20);
609 glVertex2f(3*wh/120, 16.4*wh/20);
610 glVertex2f(4*wh/120, 16.8*wh/20);
611 glVertex2f(2*wh/120, 16.8*wh/20);
612 glEnd();
613
614
615 draw_circle1(9*wh/120, 16.5*wh/20, wh/60); /* to draw CIRCLE OPTION on tool bar */
616
617
618
619 for(i=0;i<40;i++) /* to draw AIR BRUSH OPTION on tool b
ar */
620 {
621 j=rand()%15;
622 k=rand()%15;
623 glBegin(GL_POINTS);
624 glVertex2f(wh/120+j,15.8*wh/20-k);
625 glEnd();
626 }
627
628 glColor3f(0, 0.3, 1);
629 glBegin(GL_QUADS); /* to draw COLOUR FILL OPTION on tool bar */
630 glVertex2f(2*wh/120, 14.6*wh/20);
631 glVertex2f(3*wh/120+1, 14.2*wh/20);
632 glVertex2f(5*wh/120-2, 14.35*wh/20);
633 glVertex2f(4*wh/120-4, 14.75*wh/20);
634 glEnd();
635 glColor3f(0, 0, 0);
636
637 glPointSize(3);
638 glBegin(GL_POINTS);
639 glVertex2f(2*wh/120-2, 14.6*wh/20-2);
640 glEnd();
641
642 glPointSize(1.5);

 643 glBegin(GL_POINTS);
644 glVertex2f(2*wh/120-2, 14.6*wh/20-6);
645 glEnd();
646
647 glPointSize(1);
648
649
650 glColor3f(0.4, 0.1, 0.1);
651 glBegin(GL_QUADS); /* to draw BRUSH OPTION on tool bar */
652 glVertex2f(7*wh/120, 14.45*wh/20);
653 glVertex2f(10*wh/120, 14.45*wh/20);
654 glVertex2f(10*wh/120, 14.55*wh/20);
655 glVertex2f(7*wh/120, 14.55*wh/20);
656 glEnd();
657
658
659 glColor3f(0, 0, 0);
660
661 glBegin(GL_LINES);
662 glVertex2f(10*wh/120, 14.45*wh/20);
663 glVertex2f(11*wh/120, 14.4*wh/20);
664
665
666 glVertex2f(10*wh/120, 14.55*wh/20);
667 glVertex2f(11*wh/120, 14.6*wh/20);
668
669 glVertex2f(10*wh/120, 14.47*wh/20);
670 glVertex2f(11*wh/120, 14.47*wh/20);
671
672 glVertex2f(10*wh/120, 14.53*wh/20);
673 glVertex2f(11*wh/120, 14.53*wh/20);
674
675 glEnd();
676
677
678
679 setFont(GLUT_BITMAP_HELVETICA_12); /* to display text */
680 glColor3f(0, 0, 1);
681 drawstring(26*wh/60,wh/20,0.0,"Click the right mouse button to change pixel size or quit");
682
683 glColor3f(0, 0, 0);
684 drawstring(6*wh/60, 58*wh/60, 0.0, "Open");
685
686 drawstring(12*wh/60, 58*wh/60, 0.0, "Save");
687
688 drawstring(18*wh/60, 58*wh/60, 0.0, "Clear");
689
690
691
692
693 glFlush();
694
695
696 glReadBuffer(GL_FRONT);
697
698
699 glReadPixels(wh/10+2, wh/10, ww-wh/10-2, wh-wh/10-wh/20-1,GL_RGB, GL_UNSIGNED_BYTE, image); /* to
read pixels from buffer to memory */
700
701 posx=wh/10+2;
702 posy=wh/10;
703 }
704 }
705
706
707
708
709
710
711 void keys(unsigned char key, int x, int y) /* to get FILENAME from the KEYBOARD */
712 {
713 if(key=='a'||key=='b'||key=='c'||key=='d'||key=='e'||key=='f'||key=='g'||key=='h'||key=='i'||key=='j'||ke

y=='k'||key=='l'||key=='m')
714 {
715 fname[s]=key;
716
717 glRasterPos3f (textx, texty,textz);
718
719 glColor3f(0, 0, 0);
720 glutBitmapCharacter(GLUT_BITMAP_9_BY_15, fname[s]); /* to display FILENAME */
721 textx=textx+10;
722
723 s++;
724 }
725
726 if(key=='n'||key=='o'||key=='p'||key=='q'||key=='r'||key=='s'||key=='t'||key=='u'||key=='v'||key=='w'||ke
y=='x'||key=='y'||key=='z')
727 {
728 fname[s]=key;
729
730 glRasterPos3f (textx, texty,textz);
731 glColor3f(0, 0, 0);
732
733 glutBitmapCharacter(GLUT_BITMAP_9_BY_15, fname[s]);
734 textx=textx+10;
735
736
737 s++;
738 }
739
740 if(key=='A'||key=='B'||key=='C'||key=='D'||key=='E'||key=='F'||key=='G'||key=='H'||key=='I'||key=='J'||ke
y=='K'||key=='L'||key=='M')
741 {
742 fname[s]=key;
743
744 glRasterPos3f (textx, texty,textz);
745
746 glColor3f(0, 0, 0);
747 glutBitmapCharacter(GLUT_BITMAP_9_BY_15, fname[s]);
748 textx=textx+10;
749 s++;
750 }
751
752 if(key=='N'||key=='O'||key=='P'||key=='Q'||key=='R'||key=='S'||key=='T'||key=='U'||key=='V'||key=='W'||ke
y=='X'||key=='Y'||key=='Z')
753 {
754 fname[s]=key;
755 glRasterPos3f (textx, texty,textz);
756 glColor3f(0, 0, 0);
757
758 glutBitmapCharacter(GLUT_BITMAP_9_BY_15, fname[s]);
759 textx=textx+10;
760
761
762
763 s++;
764 }
765
766 if(key=='_'||key=='0'||key=='1'||key=='2'||key=='3'||key=='4'||key=='5'||key=='6'||key=='7'||key=='8'||ke
y=='9')
767 {
768 fname[s]=key;
769 glRasterPos3f (textx, texty,textz);
770
771 glColor3f(0, 0, 0);
772 glutBitmapCharacter(GLUT_BITMAP_9_BY_15, fname[s]);
773 textx=textx+10;
774
775
776
777 s++;
778 }
779 glFlush();
780

 781
782
783 if(key=='\r' && save==1) /* to SAVE current image on a file */
784 {
785
786
787 fname[s]='\0';
788
789
790
791
792 if ((fptr = fopen(fname,"w")) == NULL)
793 {
794 fprintf(stderr,"Failed to open file\n");
795 return;
796 }
797
798 save=0;
799 s=0;
800
801 glColor3f(0.85, 0.85, 0.85);
802 glRectf(0,wh-(wh/20), ww, wh);
803
804 setFont(GLUT_BITMAP_HELVETICA_12);
805 glColor3f(0, 0, 0);
806 drawstring(6*wh/60, 58*wh/60, 0.0, "Open");
807
808 drawstring(12*wh/60, 58*wh/60, 0.0, "Save");
809
810 drawstring(18*wh/60, 58*wh/60, 0.0, "Clear");
811
812 fwrite(image,ww*wh*3,1,fptr);
813
814 fclose(fptr);
815
816 }
817
818
819
820 if(key=='\r' && save==2)
821 { /* to OPEN an existing image file */
822
823 fname[s]='\0';
824
825
826 if ((fptr = fopen(fname,"r")) == NULL)
827 {
828 fprintf(stderr,"Failed to open file\n");
829 return;
830 }
831
832
833
834 save=0;
835 s=0;
836
837 fread(image,ww*wh*3,1,fptr);
838
839 fclose(fptr);
840
841 display();
842 }
843
844 }
845
846
847
848 void myMouse(int btn, int state, int x, int y)
849 {
850 GLfloat r, r1, r2;
851 int num1=0, num2=0;
852

 853 int i1, i2;

854 int flag2;
855
856 flag2=0;
857
858
859 if(btn==GLUT_LEFT_BUTTON && state==GLUT_DOWN)
860 {
861 /* to SELECT A COLOR */
862
863
864 if(wel==1)
865 {
866 wel=2;
867 display();
868 }
869
870
871 if(6*wh/60<x && x<8*wh/60 && wh/60<wh-y && wh-y<wh/20)
872 glColor3f(0, 0, 0);
873
874
875 else if(6*wh/60<x && x<8*wh/60 && wh/20<wh-y && wh-y<wh/12)
876 glColor3f(1, 1, 1);
877
878
879 else if(8*wh/60<x && x<10*wh/60 && wh/60<wh-y && wh-y<wh/20)
880 glColor3f(0, 0, 1);
881
882
883 else if(8*wh/60<x && x<10*wh/60 && wh/20<wh-y && wh-y<wh/12)
884 glColor3f(1, 0, 1);
885
886
887 else if(10*wh/60<x && x<12*wh/60 && wh/60<wh-y && wh-y<wh/20)
888 glColor3f(1, 1, 0);
889
890
891 else if(10*wh/60<x && x<12*wh/60 && wh/20<wh-y && wh-y<wh/12)
892 glColor3f(1, 0, 0);
893
894
895 else if(12*wh/60<x && x<14*wh/60 && wh/60<wh-y && wh-y<wh/20)
896 glColor3f(0, 1, 0);
897
898
899 else if(12*wh/60<x && x<14*wh/60 && wh/20<wh-y && wh-y<wh/12)
900 glColor3f(0, 1, 1);
901
902
903 else if(14*wh/60<x && x<16*wh/60 && wh/60<wh-y && wh-y<wh/20)
904 glColor3f(0.5, 0.5, 0);
905
906 else if(14*wh/60<x && x<16*wh/60 && wh/20<wh-y && wh-y<wh/12)
907 glColor3f(0.1, 0.4, 0.6);
908
909 else if(16*wh/60<x && x<18*wh/60 && wh/60<wh-y && wh-y<wh/20)
910 glColor3f(0.4, 0.1, 0.1);
911
912 else if(16*wh/60<x && x<18*wh/60 && wh/20<wh-y && wh-y<wh/12)
913 glColor3f(0.9, 0.1, 0.5);
914
915
916 else if(18*wh/60<x && x<20*wh/60 && wh/60<wh-y && wh-y<wh/20)
917 glColor3f(0.5, 0.1, 0.5);
918
919 else if(18*wh/60<x && x<20*wh/60 && wh/20<wh-y && wh-y<wh/12)
920 glColor3f(0.3, 0.1, 0.5);
921
922 else if(20*wh/60<x && x<22*wh/60 && wh/60<wh-y && wh-y<wh/20)
923 glColor3f(0.0, 0.5, 0.1);
924

 925 else if(20*wh/60<x && x<22*wh/60 && wh/20<wh-y && wh-y<wh/12)

926 glColor3f(0.9, 0.8, 0.0);
927
928
929 else if(22*wh/60<x && x<24*wh/60 && wh/60<wh-y && wh-y<wh/20)
930 glColor3f(0.7, 0.0, 0.0);
931
932
933 else if(22*wh/60<x && x<24*wh/60 && wh/20<wh-y && wh-y<wh/12)
934 glColor3f(0.5, 0.5, 0.5);
935
936
937 /*end select color */
938
939
940 /* to select WHAT TO DRAW */
941
942 if(2<x && x<wh/20 && 18*wh/20<wh-y && wh-y<wh-(wh/20)-1) /* selected option is
PENCIL*/
943 draw=1;
944
945
946 else if(wh/20<x && x<wh/10-2 && 18*wh/20<wh-y && wh-y<wh-(wh/20)-1) /* selected option is
LINE */
947 {
948
949 reset();
950 draw=2;
951 }
952
953
954 else if(2<x && x<wh/20 && 17*wh/20<wh-y && wh-y<18*wh/20) /* selected option i
s TRIANGLE */
955
956 {
957 reset();
958 draw=3;
959 }
960
961
962 else if(wh/20<x && x<wh/10-2 && 17*wh/20<wh-y && wh-y<18*wh/20) /* selected option
is RECTANGLE */
963 {
964
965 reset();
966 draw=4;
967 }
968
969
970 else if(2<x && x<wh/20 && 16*wh/20<wh-y && wh-y<17*wh/20) /* selected option
is POLYGON */
971 {
972
973 reset();
974 draw=5;
975 }
976
977
978 else if(wh/20<x && x<wh/10-2 && 16*wh/20<wh-y && wh-y<17*wh/20) /* selected option
is CIRCLE */
979 {
980 reset();
981 draw=6;
982 }
983
984
985 else if(2<x && x<wh/20 && 15*wh/20<wh-y && wh-y<16*wh/20) /* selected option
is AIRBRUSH */
986 {
987
988 reset();
989 draw=7;

 990 }
991
992
993 else if(wh/20<x && x<wh/10-2 && 15*wh/20<wh-y && wh-y<16*wh/20) /* selected option
is ERASER */
994 {
995 reset();
996 draw=8;
997 }
998
999
1000
1001 else if(2<x && x<wh/20 && 14*wh/20<wh-y && wh-y<15*wh/20) /* selected option
is COLOR FILL */
1002 {
1003
1004 reset();
1005 draw=9;
1006 }
1007
1008
1009 else if(wh/20<x && x<wh/10-2 && 14*wh/20<wh-y && wh-y<15*wh/20) /* selected option
is PAINT BRUSH */
1010 {
1011 reset();
1012 draw=10;
1013 }
1014
1015
1016
1017
1018
1019 if(draw==1) /* to draw using a PENCIL */
1020 {
1021 if(pol==1)
1022 {
1023 m++;
1024 a[m][0]='$';
1025 a[m][1]='$';
1026
1027 pol=0;
1028 }
1029
1030 if(x>wh/10+1 && wh/10<wh-y && wh-y<wh-31)
1031 glutMotionFunc(drawpoint);
1032
1033 }
1034
1035
1036 else if(draw==2) /* to draw a LINE */
1037 {
1038 if(pol==1)
1039 {
1040 m++;
1041 a[m][0]='$';
1042 a[m][1]='$';
1043
1044 pol=0;
1045 }
1046
1047
1048 if(x>wh/10+1 && wh/10<wh-y && wh-y<wh-31)
1049 {
1050 drawpoint(x, y);
1051
1052 a2=a1;
1053 b2=b1;
1054
1055 a1=x;
1056 b1=wh-y;
1057
1058

1059 if(a1>wh/10+1 && wh/10<b1 && b1<wh-31)

1060 {
1061 if(a2>wh/10+1 && wh/10<b2 && b2<wh-31)
1062 {
1063 glLineWidth(size);
1064 glBegin(GL_LINES);
1065 glVertex2f(a2, b2);
1066 glVertex2f(a1, b1);
1067 glEnd();
1068
1069 reset();
1070
1071 }
1072 }
1073 }
1074
1075 }
1076
1077
1078 else if(draw==3) /* to draw a TRIANGLE */
1079 {
1080 if(pol==1)
1081 {
1082 m++;
1083 a[m][0]='$';
1084 a[m][1]='$';
1085
1086 pol=0;
1087 }
1088
1089
1090
1091 if(x>wh/10+1 && wh/10<wh-y && wh-y<wh-31)
1092 {
1093 drawpoint(x, y);
1094
1095
1096 a3=a2;
1097 b3=b2;
1098
1099 a2=a1;
1100 b2=b1;
1101
1102 a1=x;
1103 b1=wh-y;
1104
1105
1106
1107
1108
1109 if(a1>wh/10+1 && wh/10<b1 && b1<wh-31)
1110 {
1111 if(a2>wh/10+1 && wh/10<b2 && b2<wh-31)
1112 {
1113 if(a3>wh/10+1 && wh/10<b3 && b3<wh-31)
1114
1115 {
1116 glLineWidth(size);
1117 glBegin(GL_LINE_LOOP);
1118 glVertex2f(a3, b3);
1119 glVertex2f(a2, b2);
1120 glVertex2f(a1, b1);
1121 glEnd();
1122
1123 m++;
1124 a[m][0]=a3;
1125 a[m][1]=b3;
1126
1127 m++;
1128 a[m][0]=a2;
1129 a[m][1]=b2;
1130

1131 m++;
1132 a[m][0]=a1;
1133 a[m][1]=b1;
1134
1135 m++;
1136 a[m][0]='$';
1137 a[m][1]='$';
1138
1139
1140
1141
1142
1143
1144 reset();
1145 }
1146 }
1147 }
1148 }
1149
1150 }
1151
1152
1153 else if(draw==4) /* to draw a RECTANGLE */
1154 {
1155
1156 if(pol==1)
1157 {
1158 m++;
1159 a[m][0]='$';
1160 a[m][1]='$';
1161
1162 pol=0;
1163 }
1164
1165 if(x>wh/10+1 && wh/10<wh-y && wh-y<wh-31)
1166 {
1167 drawpoint(x, y);
1168
1169 a2=a1;
1170 b2=b1;
1171
1172 a1=x;
1173 b1=wh-y;
1174
1175
1176 if(a1>wh/10+1 && wh/10<b1 && b1<wh-31)
1177 {
1178 if(a2>wh/10+1 && wh/10<b2 && b2<wh-31)
1179 {
1180 glLineWidth(size);
1181 glBegin(GL_LINE_LOOP);
1182 glVertex2f(a2, b2);
1183 glVertex2f(a1, b2);
1184 glVertex2f(a1, b1);
1185 glVertex2f(a2, b1);
1186 glEnd();
1187
1188
1189 m++;
1190 a[m][0]=a2;
1191 a[m][1]=b2;
1192
1193 m++;
1194 a[m][0]=a1;
1195 a[m][1]=b2;
1196
1197 m++;
1198 a[m][0]=a1;
1199 a[m][1]=b1;
1200
1201
1202 m++;

1203 a[m][0]=a2;
1204 a[m][1]=b1;
1205
1206 m++;
1207 a[m][0]='$';
1208 a[m][1]='$';
1209
1210
1211 reset();
1212
1213 }
1214 }
1215 }
1216
1217 }
1218
1219
1220 else if(draw==5) /* to draw a POLYGON */
1221 {
1222
1223 pol=1;
1224 if(x>wh/10+1 && wh/10<wh-y && wh-y<wh-31)
1225 {
1226 drawpoint(x, y);
1227
1228 a2=a1;
1229 b2=b1;
1230
1231 a1=x;
1232 b1=wh-y;
1233
1234 m++;
1235 a[m][0]=x;
1236 a[m][1]=wh-y;
1237
1238
1239
1240
1241 if(a1>wh/10+1 && wh/10<b1 && b1<wh-31)
1242 {
1243 if(a2>wh/10+1 && wh/10<b2 && b2<wh-31)
1244 {
1245 glLineWidth(size);
1246 glBegin(GL_LINES);
1247 glVertex2f(a2, b2);
1248 glVertex2f(a1, b1);
1249 glEnd();
1250 }
1251 }
1252
1253 }
1254
1255
1256
1257 }
1258
1259 else if(draw==6) /* to draw a CIRCLE */
1260 {
1261 if(pol==1)
1262 {
1263 m++;
1264 a[m][0]='$';
1265 a[m][1]='$';
1266
1267 pol=0;
1268 }
1269
1270
1271 if(x>wh/10+1 && wh/10<wh-y && wh-y<wh-31)
1272 {
1273 drawpoint(x, y);
1274

1275 a2=a1;
1276 b2=b1;
1277
1278 a1=x;
1279 b1=wh-y;
1280
1281 if(a1>wh/10+1 && wh/10<b1 && b1<wh-31)
1282 {
1283 if(a2>wh/10+1 && wh/10<b2 && b2<wh-31)
1284 {
1285 r=sqrt((a1-a2)*(a1-a2)+(b1-b2)*(b1-b2));
1286 draw_circle(a2, b2, r);
1287
1288 n++;
1289 b[n][0]=a2;
1290 b[n][1]=b2;
1291
1292 n++;
1293 b[n][0]=a1;
1294 b[n][1]=b1;
1295
1296 n++;
1297 b[n][0]='$';
1298 b[n][1]='$';
1299
1300 reset();
1301
1302 }
1303 }
1304 }
1305 }
1306
1307
1308
1309 else if(draw==7) /* to draw a AIRBRUSH */
1310 {
1311 if(pol==1)
1312 {
1313 m++;
1314 a[m][0]='$';
1315 a[m][1]='$';
1316
1317 pol=0;
1318 }
1319
1320 if(x>wh/10+1 && wh/10<wh-y && wh-y<wh-31)
1321 {
1322 for(i=0;i<60;i++)
1323 {
1324 j=rand()%17;
1325 k=rand()%17;
1326 drawpoint(x+j,y+k);
1327 }
1328
1329
1330
1331 }
1332 }
1333
1334
1335 else if(draw==9) /* to FILL A POLYGON with the selected color */
1336 {
1337 if(pol==1)
1338 {
1339 m++;
1340 a[m][0]='$';
1341 a[m][1]='$';
1342
1343 pol=0;
1344 }
1345
1346

1347 if(x>wh/10+1 && wh/10<wh-y && wh-y<wh-31)

1348 {
1349 y=wh-y;
1350
1351
1352 flag1=0;
1353 for(i=1;i<=m;i++)
1354 {
1355 num2=i-1;
1356 for(i1=i;a[i1][0]!='$';i1++)
1357 {
1358 num2++;
1359 }
1360 num1=i;
1361
1362 detect_point(num1, num2, x, y);
1363
1364 if(flag!=0)
1365 {
1366 scanfill(num1, num2);
1367 flag=0;
1368 flag1=1;
1369 }
1370 i=num2+1;
1371
1372 }
1373
1374 if(flag1==0 && flag2==0)
1375 {
1376
1377 for(i=1;i<=n;i++)
1378 {
1379 num2=i-1;
1380 for(i1=i;b[i1][0]!='$';i1++)
1381 {
1382 num2++;
1383 }
1384 num1=i;
1385
1386 r1=sqrt((b[num1][0]-b[num2][0])*(b[num1][0]-b[num2][0])+(b[num1][
1]-b[num2][1])*(b[num1][1]-b[num2][1]));
1387 r2=sqrt((b[num1][0]-x)*(b[num1][0]-x)+(b[num1][1]-y)*(b[num1][1]y));
1388
1389
1390 if(r2<r1)
1391 {
1392
1393
1394
1395 for(i2=0;i2<r1;i2=i2+2)
1396 {
1397 fill=1;
1398 draw_circle(b[num1][0], b[num1][1], i2);
1399 }
1400 fill=0;
1401
1402 flag2=1;
1403 }
1404
1405 i=num2+1;
1406 }
1407 }
1408
1409 }
1410 }
1411
1412
1413
1414
1415 if(draw==8) /* to ERASE */
1416

1417 {
1418 if(pol==1)
1419 {
1420 m++;
1421 a[m][0]='$';
1422 a[m][1]='$';
1423
1424 pol=0;
1425 }
1426
1427 if(x>wh/10+1 && wh/10<wh-y && wh-y<wh-31)
1428 glutMotionFunc(eraser);
1429 }
1430
1431 else if(draw==10)
1432 {
1433 if(pol==1)
1434 {
1435 m++;
1436 a[m][0]='$';
1437 a[m][1]='$';
1438
1439 pol=0;
1440 }
1441
1442
1443 if(x>wh/10+1 && wh/10<wh-y && wh-y<wh-31)
1444
1445 glutMotionFunc(paint);
1446
1447 }
1448
1449
1450
1451
1452
1453 else if(x>wh/10+1 && wh/10<wh-y && wh-y<wh-31)
1454 glutMotionFunc(drawpoint);
1455
1456
1457 if(x>=6*wh/60 && x<=12*wh/60 && wh-y>=57*wh/60 && wh-y<=wh) /* to OPEN an existing FILE */
1458 {
1459
1460 save=2;
1461
1462 setFont(GLUT_BITMAP_9_BY_15);
1463 glColor3f(0, 0, 0);
1464
1465 drawstring(40*wh/60, 58*wh/60, 0.0, "Enter filename: ");
1466 textx=60*wh/60;
1467 texty=58*wh/60;
1468
1469
1470
1471
1472 }
1473
1474
1475
1476 else if(x>=12*wh/60 && x<=18*wh/60 && wh-y>=57*wh/60 && wh-y<=wh) /* to SAVE the current image on
to a FILE */
1477 {
1478 save=1;
1479
1480 setFont(GLUT_BITMAP_9_BY_15);
1481 glColor3f(0, 0, 0);
1482
1483 drawstring(40*wh/60, 58*wh/60, 0.0, "Enter filename: ");
1484 textx=60*wh/60;
1485 texty=58*wh/60;
1486
1487

1488
1489 }
1490
1491
1492 else if(x>=18*wh/60 && x<=24*wh/60 && wh-y>=57*wh/60 && wh-y<=wh) /* to CLEAR the DRAWING AREA */
1493 {
1494
1495 for(i=1;i<=m;i++)
1496 a[i][0]=a[i][1]=0;
1497
1498
1499
1500
1501 for(i=1;i<=n;i++)
1502 b[i][0]=b[i][1]=0;
1503
1504 m=n=0;
1505
1506
1507 count=0;
1508 display();
1509 }
1510
1511
1512
1513
1514 palette(wh/30, 2*wh/30, 2*wh/30, 2*wh/30, 2*wh/30, wh/30, wh/30, wh/30); /* to display SELECTED
COLOUR */
1515
1516 glFlush();
1517
1518
1519 glReadBuffer(GL_FRONT);
1520
1521
1522 glReadPixels(wh/10+2, wh/10, ww-wh/10-2, wh-wh/10-wh/20-1,GL_RGB, GL_UNSIGNED_BYTE, image);
1523
1524 posx=wh/10+2;
1525 posy=wh/10;
1526
1527
1528
1529 }
1530
1531 if(btn==GLUT_LEFT_BUTTON && state==GLUT_UP)
1532 {
1533 glReadBuffer(GL_FRONT);
1534
1535
1536 glReadPixels(wh/10+2, wh/10, ww-wh/10-2, wh-wh/10-wh/20-1,GL_RGB, GL_UNSIGNED_BYTE, image);
1537
1538 posx=wh/10+2;
1539 posy=wh/10;
1540 }
1541
1542 }
1543
1544
1545
1546
1547 void myReshape(GLsizei w, GLsizei h) /* RESHAPE FUNCTION */
1548 {
1549
1550
1551 glMatrixMode(GL_PROJECTION);
1552 glLoadIdentity();
1553 glOrtho(0.0, (GLdouble)w, 0.0, (GLdouble)h, -1.0, 1.0);
1554
1555 glMatrixMode(GL_MODELVIEW);
1556
1557 glViewport(0,0,w,h);
1558

1559 glFlush();
1560
1561
1562 ww = w;
1563 wh = h;
1564
1565
1566 glutPostRedisplay();
1567
1568
1569
1570
1571 }
1572
1573
1574 void point_size(int id) /* to CHANGE THE PIXEL SIZE */
1575 {
1576
1577
1578
1579
1580 switch(id)
1581 {
1582 case 1:size++;
1583 break;
1584
1585 case 2:if(size>1)
1586 size--;
1587 break;
1588 }
1589
1590
1591
1592 }
1593
1594
1595 void right(int id) /* to QUIT the editor */
1596 {
1597
1598 if(id==2)
1599 exit(0);
1600 }
1601
1602
1603
1604
1605 int main(int argc, char **argv)
1606 {
1607
1608 image = malloc(3*1450*900*sizeof(char)); /* to ALLOCATE MEMORY required to SAVE the file */
1609
1610
1611 a[0][0]='$';
1612 a[0][1]='$';
1613 m=0;
1614
1615 b[0][0]='$';
1616 b[0][1]='$';
1617 n=0;
1618
1619
1620 glutInit(&argc,argv);
1621 glutInitDisplayMode (GLUT_SINGLE| GLUT_RGB);
1622
1623 glutInitWindowSize(ww,wh);
1624 glutInitWindowPosition(100, 100);
1625 glutCreateWindow("graphics editor");
1626
1627 /*TO CREATE MENU */
1628 sub_menu=glutCreateMenu(point_size);
1629 glutAddMenuEntry("increase", 1);
1630 glutAddMenuEntry("decrease", 2);

1631
1632
1633
1634 glutCreateMenu(right);
1635 glutAddSubMenu("Point Size", sub_menu);
1636 glutAddMenuEntry("Quit",2);
1637
1638 glutAttachMenu(GLUT_RIGHT_BUTTON);
1639
1640
1641 glutReshapeFunc(myReshape);
1642
1643 glutDisplayFunc(display);
1644
1645 glutMouseFunc(myMouse);
1646 glutKeyboardFunc(keys);
1647
1648
1649 glutMainLoop();
1650 }