implemented SUPER key/modifier support on windows
[freeglut] / demos / CallbackMaker / CallbackMaker.c
1 /* CallbackMaker.c */
2 /*
3  * Program to invoke all the callbacks that "freeglut" supports
4  */
5
6
7 #include <GL/freeglut.h>
8 #include <stdio.h>
9 #include <stdlib.h>
10 #include <stdarg.h>
11 #include <string.h>
12
13 static int sequence_number = 0 ;
14
15 #define CALLBACKMAKER_N_WINDOWS 4
16 int windows[CALLBACKMAKER_N_WINDOWS] = {0};
17
18 /* define status vars showing whether given callback has been called for given window */
19 #define CALLBACK_CALLED_VAR(name)                            int name##_called[CALLBACKMAKER_N_WINDOWS]   = {0}
20 #define CALLBACK_0V(name)                                    int name##_seq[CALLBACKMAKER_N_WINDOWS]      = {-1}; CALLBACK_CALLED_VAR(name)
21 #define CALLBACK_1V(name,field)                              int name##_##field[CALLBACKMAKER_N_WINDOWS]  = {-1}; CALLBACK_0V(name)
22 #define CALLBACK_2V(name,field1,field2)                      int name##_##field2[CALLBACKMAKER_N_WINDOWS] = {-1}; CALLBACK_1V(name,field1)
23 #define CALLBACK_3V(name,field1,field2,field3)               int name##_##field3[CALLBACKMAKER_N_WINDOWS] = {-1}; CALLBACK_2V(name,field1,field2)
24 #define CALLBACK_4V(name,field1,field2,field3,field4)        int name##_##field4[CALLBACKMAKER_N_WINDOWS] = {-1}; CALLBACK_3V(name,field1,field2,field3)
25 #define CALLBACK_5V(name,field1,field2,field3,field4,field5) int name##_##field5[CALLBACKMAKER_N_WINDOWS] = {-1}; CALLBACK_4V(name,field1,field2,field3,field4)
26 CALLBACK_2V(reshape,width,height);
27 CALLBACK_2V(position,top,left);
28 CALLBACK_1V(visibility,vis);
29 CALLBACK_1V(windowStatus,state);
30 CALLBACK_4V(key,key,x,y,mod);
31 CALLBACK_4V(keyup,key,x,y,mod);
32 CALLBACK_4V(special,key,x,y,mod);
33 CALLBACK_4V(specialup,key,x,y,mod);
34 CALLBACK_4V(joystick,a,b,c,d);
35 CALLBACK_5V(mouse,button,updown,x,y,mod);
36 CALLBACK_5V(mousewheel,number,direction,x,y,mod);
37 CALLBACK_3V(motion,x,y,mod);
38 CALLBACK_3V(passivemotion,x,y,mod);
39 CALLBACK_1V(entry,state);
40 CALLBACK_0V(close);
41 /* menudestroy is registered on each menu, not a window */
42 int menudestroy_called = 0;
43 /* menustatus and menustate are global callbacks, set for all menus at the same time */
44 int menustatus_called = 0;
45 int menustate_called = 0;
46
47 #define STRING_LENGTH   10
48
49 static void
50 bitmapPrintf (const char *fmt, ...)
51 {
52     static char buf[256];
53     va_list args;
54
55     va_start(args, fmt);
56 #if defined(WIN32) && !defined(__CYGWIN__)
57     (void) _vsnprintf (buf, sizeof(buf), fmt, args);
58 #else
59     (void) vsnprintf (buf, sizeof(buf), fmt, args);
60 #endif
61     va_end(args);
62     glutBitmapString ( GLUT_BITMAP_HELVETICA_12, (unsigned char*)buf ) ;
63 }
64
65 static int
66 getWindowAndIdx(int *winIdx)
67 {
68     int window = glutGetWindow();
69
70     if (winIdx)
71         (*winIdx) = window==windows[0] ? 0 :
72                     window==windows[1] ? 1 :
73                     window==windows[2] ? 2 : 3;
74
75     return window;
76 }
77
78 static void
79 Mod2Text(int mods, char *text)
80 {
81     if (mods&GLUT_ACTIVE_CTRL)
82         strcat(text,"CTRL");
83     if (mods&GLUT_ACTIVE_SHIFT)
84     {
85         if (text[0])
86             strcat(text,"+SHIFT");
87         else
88             strcat(text,"SHIFT");
89     }
90     if (mods&GLUT_ACTIVE_ALT)
91     {
92         if (text[0])
93             strcat(text,"+ALT");
94         else
95             strcat(text,"ALT");
96     }
97
98     if (!text[0])
99         strcat(text,"none");
100 }
101
102 static void 
103 Display(void)
104 {
105   int winIdx;
106   int window = getWindowAndIdx(&winIdx);
107   glClear ( GL_COLOR_BUFFER_BIT );
108
109   glDisable ( GL_DEPTH_TEST );
110   glMatrixMode ( GL_PROJECTION );
111   glPushMatrix();
112   glLoadIdentity();
113   glOrtho(0, glutGet ( GLUT_WINDOW_WIDTH ), 
114           0, glutGet ( GLUT_WINDOW_HEIGHT ), -1, 1 );
115   glMatrixMode ( GL_MODELVIEW );
116   glPushMatrix ();
117   glLoadIdentity ();
118   glColor3ub ( 0, 0, 0 );
119   glRasterPos2i ( 10, glutGet ( GLUT_WINDOW_HEIGHT ) - 20 );    /* 10pt margin above 10pt letters */
120
121   if ( entry_called[winIdx] )
122   {
123     bitmapPrintf ( "Entry %d:  %d\n", entry_seq[winIdx], entry_state[winIdx] );
124   }
125   
126   if ( visibility_called[winIdx] )
127   {
128     bitmapPrintf ( "Visibility %d:  %d\n", visibility_seq[winIdx], visibility_vis[winIdx] );
129   }
130
131   if ( windowStatus_called[winIdx] )
132   {
133     bitmapPrintf ( "WindowStatus %d:  %d\n", windowStatus_seq[winIdx], windowStatus_state[winIdx] );
134   }
135
136   if ( reshape_called[winIdx] )
137   {
138     bitmapPrintf ( "Reshape %d:  %d %d\n", reshape_seq[winIdx], reshape_width[winIdx], reshape_height[winIdx] );
139   }
140
141   if ( position_called[winIdx] )
142   {
143     bitmapPrintf ( "Position %d:  %d %d\n", position_seq[winIdx], position_left[winIdx], position_top[winIdx] );
144   }
145
146   if ( key_called[winIdx] )
147   {
148     char mods[50] = {0};
149     Mod2Text(key_mod[winIdx],mods);
150     bitmapPrintf ( "Key %d:  %d(%c) %d %d (mod: %s)\n", key_seq[winIdx], key_key[winIdx], key_key[winIdx], key_x[winIdx], key_y[winIdx], mods );
151   }
152
153   if ( keyup_called[winIdx] )
154   {
155     char mods[50] = {0};
156     Mod2Text(keyup_mod[winIdx],mods);
157     bitmapPrintf ( "Key Up %d:  %d(%c) %d %d (mod: %s)\n", keyup_seq[winIdx], keyup_key[winIdx], keyup_key[winIdx], keyup_x[winIdx], keyup_y[winIdx], mods );
158   }
159
160   if ( special_called[winIdx] )
161   {
162     char mods[50] = {0};
163     Mod2Text(special_mod[winIdx],mods);
164     bitmapPrintf ( "Special %d:  %d(%c) %d %d (mod: %s)\n", special_seq[winIdx], special_key[winIdx], special_key[winIdx], special_x[winIdx], special_y[winIdx], mods );
165   }
166
167   if ( specialup_called[winIdx] )
168   {
169     char mods[50] = {0};
170     Mod2Text(specialup_mod[winIdx],mods);
171     bitmapPrintf ( "Special Up %d:  %d(%c) %d %d (mod: %s)\n", specialup_seq[winIdx], specialup_key[winIdx], specialup_key[winIdx], specialup_x[winIdx], specialup_y[winIdx], mods );
172   }
173
174   if ( joystick_called[winIdx] )
175   {
176     bitmapPrintf ( "Joystick %d:  %d %d %d %d\n", joystick_seq[winIdx], joystick_a[winIdx], joystick_b[winIdx], joystick_c[winIdx], joystick_d[winIdx] );
177   }
178
179   if ( mouse_called[winIdx] )
180   {
181     char mods[50] = {0};
182     Mod2Text(mouse_mod[winIdx],mods);
183     bitmapPrintf ( "Mouse %d:  %d %d %d %d (mod: %s)\n", mouse_seq[winIdx], mouse_button[winIdx], mouse_updown[winIdx], mouse_x[winIdx], mouse_y[winIdx], mods );
184   }
185
186   if ( mousewheel_called[winIdx] )
187   {
188     char mods[50] = {0};
189     Mod2Text(mousewheel_mod[winIdx],mods);
190     bitmapPrintf ( "Mouse Wheel %d:  %d %d %d %d (mod: %s)\n", mousewheel_seq[winIdx], mousewheel_number[winIdx], mousewheel_direction[winIdx], mousewheel_x[winIdx], mousewheel_y[winIdx], mods );
191   }
192
193   if ( motion_called[winIdx] )
194   {
195     char mods[50] = {0};
196     Mod2Text(motion_mod[winIdx],mods);
197     bitmapPrintf ( "Motion %d:  %d %d (mod: %s)\n", motion_seq[winIdx], motion_x[winIdx], motion_y[winIdx], mods );
198   }
199
200   if ( passivemotion_called[winIdx] )
201   {
202     char mods[50] = {0};
203     Mod2Text(passivemotion_mod[winIdx],mods);
204     bitmapPrintf ( "Passive Motion %d:  %d %d (mod: %s)\n", passivemotion_seq[winIdx], passivemotion_x[winIdx], passivemotion_y[winIdx], mods );
205   }
206
207   glMatrixMode ( GL_PROJECTION );
208   glPopMatrix ();
209   glMatrixMode ( GL_MODELVIEW );
210   glPopMatrix ();
211   glEnable ( GL_DEPTH_TEST );
212
213   printf ( "%6d Window %d Display Callback\n",
214             ++sequence_number, window ) ;
215   glutSwapBuffers();
216 }
217
218 static void
219 Warning(const char *fmt, va_list ap)
220 {
221     printf("%6d Warning callback:\n",++sequence_number);
222
223     /* print warning message */
224     vprintf(fmt, ap);
225 }
226
227 static void
228 Error(const char *fmt, va_list ap)
229 {
230     char dummy_string[STRING_LENGTH];
231     printf("%6d Error callback:\n",++sequence_number);
232
233     /* print warning message */
234     vprintf(fmt, ap);
235     printf("\n");
236
237     /* terminate program, after pause for input so user can see */
238     printf ( "Please enter something to exit: " );
239     fgets ( dummy_string, STRING_LENGTH, stdin );
240
241     /* Call exit directly as freeglut is messed
242      * up internally when an error is called. 
243      */
244     exit(1);
245 }
246
247 static void 
248 Reshape(int width, int height)
249 {
250   int winIdx;
251   int window = getWindowAndIdx(&winIdx);
252   printf ( "%6d Window %d Reshape Callback:  %d %d\n",
253             ++sequence_number, window, width, height ) ;
254   reshape_called[winIdx] = 1 ;
255   reshape_width[winIdx] = width ;
256   reshape_height[winIdx] = height ;
257   reshape_seq[winIdx] = sequence_number ;
258   glViewport(0,0,width,height);
259   glutPostRedisplay () ;
260 }
261
262 static void 
263 Position(int left, int top)
264 {
265   int winIdx;
266   int window = getWindowAndIdx(&winIdx);
267   printf ( "%6d Window %d Position Callback:  %d %d\n",
268             ++sequence_number, window, left, top ) ;
269   position_called[winIdx] = 1 ;
270   position_left[winIdx] = left ;
271   position_top[winIdx] = top ;
272   position_seq[winIdx] = sequence_number ;
273   glutPostRedisplay () ;
274 }
275
276 static void 
277 Key(unsigned char key, int x, int y)
278 {
279   int winIdx;
280   int window = getWindowAndIdx(&winIdx);
281   printf ( "%6d Window %d Keyboard Callback:  %d %d %d\n",
282             ++sequence_number, window, key, x, y ) ;
283   key_called[winIdx] = 1 ;
284   key_key[winIdx] = key ;
285   key_x[winIdx] = x ;
286   key_y[winIdx] = y ;
287   key_seq[winIdx] = sequence_number ;
288   key_mod[winIdx] = glutGetModifiers() ;
289   glutPostRedisplay () ;
290 }
291
292 static void 
293 KeyUp(unsigned char key, int x, int y)
294 {
295   int winIdx;
296   int window = getWindowAndIdx(&winIdx);
297   printf ( "%6d Window %d Key Release Callback:  %d %d %d\n",
298             ++sequence_number, window, key, x, y ) ;
299   keyup_called[winIdx] = 1 ;
300   keyup_key[winIdx] = key ;
301   keyup_x[winIdx] = x ;
302   keyup_y[winIdx] = y ;
303   keyup_seq[winIdx] = sequence_number ;
304   keyup_mod[winIdx] = glutGetModifiers() ;
305   glutPostRedisplay () ;
306 }
307
308 static void 
309 Special(int key, int x, int y)
310 {
311   int winIdx;
312   int window = getWindowAndIdx(&winIdx);
313   printf ( "%6d Window %d Special Key Callback:  %d %d %d\n",
314             ++sequence_number, window, key, x, y ) ;
315   special_called[winIdx] = 1 ;
316   special_key[winIdx] = key ;
317   special_x[winIdx] = x ;
318   special_y[winIdx] = y ;
319   special_seq[winIdx] = sequence_number ;
320   special_mod[winIdx] = glutGetModifiers() ;
321   glutPostRedisplay () ;
322 }
323
324 static void 
325 SpecialUp(int key, int x, int y)
326 {
327   int winIdx;
328   int window = getWindowAndIdx(&winIdx);
329   printf ( "%6d Window %d Special Key Release Callback:  %d %d %d\n",
330             ++sequence_number, window, key, x, y ) ;
331   specialup_called[winIdx] = 1 ;
332   specialup_key[winIdx] = key ;
333   specialup_x[winIdx] = x ;
334   specialup_y[winIdx] = y ;
335   specialup_seq[winIdx] = sequence_number ;
336   specialup_mod[winIdx] = glutGetModifiers() ;
337   glutPostRedisplay () ;
338 }
339
340 static void 
341 Joystick( unsigned int a, int b, int c, int d)  /* Need meaningful names */
342 {
343   int winIdx;
344   int window = getWindowAndIdx(&winIdx);
345   printf ( "%6d Window %d Joystick Callback:  %d %d %d %d\n",
346             ++sequence_number, window, a, b, c, d ) ;
347   joystick_called[winIdx] = 1 ;
348   joystick_a[winIdx] = a ;
349   joystick_b[winIdx] = b ;
350   joystick_c[winIdx] = c ;
351   joystick_d[winIdx] = d ;
352   joystick_seq[winIdx] = sequence_number ;
353   glutPostRedisplay () ;
354 }
355
356 static void 
357 Mouse(int button, int updown, int x, int y)
358 {
359   int winIdx;
360   int window = getWindowAndIdx(&winIdx);
361   printf ( "%6d Window %d Mouse Click Callback:  %d %d %d %d\n",
362             ++sequence_number, window, button, updown, x, y ) ;
363   mouse_called[winIdx] = 1 ;
364   mouse_button[winIdx] = button ;
365   mouse_updown[winIdx] = updown ;
366   mouse_x[winIdx] = x ;
367   mouse_y[winIdx] = y ;
368   mouse_seq[winIdx] = sequence_number ;
369   mouse_mod[winIdx] = glutGetModifiers() ;
370   glutPostRedisplay () ;
371 }
372
373 static void 
374 MouseWheel(int wheel_number, int direction, int x, int y)
375 {
376   int winIdx;
377   int window = getWindowAndIdx(&winIdx);
378   printf ( "%6d Window %d Mouse Wheel Callback:  %d %d %d %d\n",
379             ++sequence_number, window, wheel_number, direction, x, y ) ;
380   mousewheel_called[winIdx] = 1 ;
381   mousewheel_number[winIdx] = wheel_number ;
382   mousewheel_direction[winIdx] = direction ;
383   mousewheel_x[winIdx] = x ;
384   mousewheel_y[winIdx] = y ;
385   mousewheel_seq[winIdx] = sequence_number ;
386   mousewheel_mod[winIdx] = glutGetModifiers() ;
387   glutPostRedisplay () ;
388 }
389
390 static void 
391 Motion(int x, int y)
392 {
393   int winIdx;
394   int window = getWindowAndIdx(&winIdx);
395   printf ( "%6d Window %d Mouse Motion Callback:  %d %d\n",
396             ++sequence_number, window, x, y ) ;
397   motion_called[winIdx] = 1 ;
398   motion_x[winIdx] = x ;
399   motion_y[winIdx] = y ;
400   motion_seq[winIdx] = sequence_number ;
401   motion_mod[winIdx] = glutGetModifiers() ;
402   glutPostRedisplay () ;
403 }
404
405 static void 
406 PassiveMotion(int x, int y)
407 {
408   int winIdx;
409   int window = getWindowAndIdx(&winIdx);
410   printf ( "%6d Window %d Mouse Passive Motion Callback:  %d %d\n",
411             ++sequence_number, window, x, y ) ;
412   passivemotion_called[winIdx] = 1 ;
413   passivemotion_x[winIdx] = x ;
414   passivemotion_y[winIdx] = y ;
415   passivemotion_seq[winIdx] = sequence_number ;
416   passivemotion_mod[winIdx] = glutGetModifiers() ;
417   glutPostRedisplay () ;
418 }
419
420 static void 
421 Entry(int state)
422 {
423   int winIdx;
424   int window = getWindowAndIdx(&winIdx);
425   printf ( "%6d Window %d Entry Callback:  %d\n",
426             ++sequence_number, window, state ) ;
427   entry_called[winIdx] = 1 ;
428   entry_seq[winIdx] = sequence_number;
429   entry_state[winIdx] = state;
430   glutPostRedisplay () ;
431 }
432
433 static void 
434 Close(void)
435 {
436   int window = getWindowAndIdx(NULL);
437   printf ( "%6d Window %d Close Callback\n",
438             ++sequence_number, window ) ;
439 }
440
441 static void 
442 OverlayDisplay(void)
443 {
444   int window = getWindowAndIdx(NULL);
445   printf ( "%6d Window %d OverlayDisplay Callback\n",
446             ++sequence_number, window ) ;
447   glutPostRedisplay () ;
448 }
449
450 static void 
451 Visibility(int vis)
452 {
453   int winIdx;
454   int window = getWindowAndIdx(&winIdx);
455   printf ( "%6d Window %d Visibility Callback:  %d\n",
456             ++sequence_number, window, vis ) ;
457   visibility_called[winIdx] = 1 ;
458   visibility_vis[winIdx] = vis ;
459   visibility_seq[winIdx] = sequence_number ;
460   glutPostRedisplay () ;
461 }
462
463 static void 
464 WindowStatus(int state)
465 {
466   int winIdx;
467   int window = getWindowAndIdx(&winIdx);
468   printf ( "%6d Window %d WindowStatus Callback:  %d\n",
469             ++sequence_number, window, state ) ;
470   windowStatus_called[winIdx] = 1 ;
471   windowStatus_state[winIdx] = state ;
472   windowStatus_seq[winIdx] = sequence_number ;
473   glutPostRedisplay () ;
474 }
475
476 static void 
477 SpaceMotion(int x, int y, int z)
478 {
479   int window = getWindowAndIdx(NULL);
480   printf ( "%6d Window %d SpaceMotion Callback:  %d %d %d\n",
481             ++sequence_number, window, x, y, z ) ;
482   glutPostRedisplay () ;
483 }
484
485 static void 
486 SpaceRotation(int x, int y, int z)
487 {
488   int window = getWindowAndIdx(NULL);
489   printf ( "%6d Window %d SpaceRotation Callback:  %d %d %d\n",
490             ++sequence_number, window, x, y, z ) ;
491   glutPostRedisplay () ;
492 }
493
494 static void 
495 SpaceButton(int button, int updown)
496 {
497   int window = getWindowAndIdx(NULL);
498   printf ( "%6d Window %d SpaceButton Callback:  %d %d\n",
499             ++sequence_number, window, button, updown ) ;
500   glutPostRedisplay () ;
501 }
502
503 static void 
504 Dials(int x, int y)
505 {
506   int window = getWindowAndIdx(NULL);
507   printf ( "%6d Window %d Dials Callback:  %d %d\n",
508             ++sequence_number, window, x, y ) ;
509   glutPostRedisplay () ;
510 }
511
512 static void 
513 ButtonBox(int button, int updown)
514 {
515   int window = getWindowAndIdx(NULL);
516   printf ( "%6d Window %d ButtonBox Callback:  %d %d\n",
517             ++sequence_number, window, button, updown ) ;
518   glutPostRedisplay () ;
519 }
520
521 static void 
522 TabletMotion(int x, int y)
523 {
524   int window = getWindowAndIdx(NULL);
525   printf ( "%6d Window %d TabletMotion Callback:  %d %d\n",
526             ++sequence_number, window, x, y ) ;
527   glutPostRedisplay () ;
528 }
529
530 static void 
531 TabletButton(int button, int updown, int x, int y)
532 {
533   int window = getWindowAndIdx(NULL);
534   printf ( "%6d Window %d TabletButton Callback:  %d %d %d %d\n",
535             ++sequence_number, window, button, updown, x, y ) ;
536   glutPostRedisplay () ;
537 }
538
539 static void
540 MenuCallback ( int value )
541 {
542   int menu = glutGetMenu();
543   int window = getWindowAndIdx(NULL);
544   printf( "%6d Menu %d MenuCallback for menu opened in Window %d - value is %d\n",
545           ++sequence_number, menu, window, value );
546 }
547
548 static void 
549 MenuDestroy( void )
550 {
551   int menu = glutGetMenu();
552   menudestroy_called = 1 ;
553   printf ( "%6d Menu %d MenuDestroy Callback\n",
554             ++sequence_number, menu ) ;
555 }
556
557 static void 
558 MenuStatus( int status, int x, int y )
559 {
560   /* Menu and window for which this event is triggered are current when the callback is called */
561   int menu = glutGetMenu();
562   int window = getWindowAndIdx(NULL);
563   menustatus_called = 1 ;
564   printf ( "%6d Menu %d MenuStatus Callback in Window %d:  %d %d %d\n",
565             ++sequence_number, menu, window, status, x, y ) ;
566   glutPostRedisplay () ;
567 }
568
569
570 static void 
571 MenuState( int status )
572 {
573   /* Menu and window for which this event is triggered are current when the callback is called */
574   int menu = glutGetMenu();
575   int window = getWindowAndIdx(NULL);
576   menustate_called = 1 ;
577   printf ( "%6d Menu %d MenuState Callback in Window %d:  %d\n",
578             ++sequence_number, menu, window, status) ;
579   glutPostRedisplay () ;
580 }
581
582 static void Idle ( void )
583 {
584   ++sequence_number ;
585 }
586
587 static void SetWindowCallbacks( int first )
588 {
589     /* All these callbacks are set for only the current window */
590     glutDisplayFunc( Display );
591     glutReshapeFunc( Reshape );
592     glutPositionFunc( Position );
593     glutKeyboardFunc( Key );
594     glutSpecialFunc( Special );
595     glutKeyboardUpFunc( KeyUp );
596     glutSpecialUpFunc( SpecialUp );
597     if (first)
598         glutJoystickFunc( Joystick, 100 );
599     glutMouseFunc ( Mouse ) ;
600     glutMouseWheelFunc ( MouseWheel ) ;
601     glutMotionFunc ( Motion ) ;
602     glutPassiveMotionFunc ( PassiveMotion ) ;
603     glutEntryFunc ( Entry ) ;
604     glutCloseFunc ( Close ) ;
605     glutOverlayDisplayFunc ( OverlayDisplay ) ;
606     glutSpaceballMotionFunc ( SpaceMotion ) ;
607     glutSpaceballRotateFunc ( SpaceRotation ) ;
608     glutSpaceballButtonFunc ( SpaceButton ) ;
609     glutButtonBoxFunc ( ButtonBox ) ;
610     glutDialsFunc ( Dials ) ;
611     glutTabletMotionFunc ( TabletMotion ) ;
612     glutTabletButtonFunc ( TabletButton ) ;
613     /* glutVisibilityFunc is deprecated in favor of glutWindowStatusFunc, which provides more detail.
614      * Setting one of these overwrites the other (see docs).
615      */
616     glutVisibilityFunc ( Visibility );  /* This will thus never be called, as glutWindowStatusFunc is set afterwards */
617     glutWindowStatusFunc ( WindowStatus ) ;
618 }
619
620 int 
621 main(int argc, char *argv[])
622 {
623   char dummy_string[STRING_LENGTH];
624
625   int menuID, subMenuA, subMenuB;
626
627   glutInitWarningFunc(Warning);
628   glutInitErrorFunc(Error);
629   glutInitWindowSize(500, 250);
630   glutInitWindowPosition ( 140, 140 );
631   glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE );
632   glutInit(&argc, argv);
633   /* global setting: mainloop does not return when a window is closed, only returns when all windows are closed */
634   glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE,GLUT_ACTION_CONTINUE_EXECUTION);
635   /* global setting: repeated keys generating by keeping the key pressed down are passed on to the keyboard callback */
636   /* There are two functions to control this behavior, glutSetKeyRepeat to set it globally, and glutIgnoreKeyRepeat to set it per window.
637    * These two interact however. If key repeat is globally switched off (glutSetKeyRepeat(GLUT_KEY_REPEAT_OFF)), it cannot be overridden
638    * (switched back on) for a specific window with glutIgnoreKeyRepeat. However, if key repeat is globally switched on
639    * (glutSetKeyRepeat(GLUT_KEY_REPEAT_ON)), it can be overridden (switched off) with glutIgnoreKeyRepeat on a per-window basis. That is
640    * what we demonstrate here.
641    */
642   glutSetKeyRepeat(GLUT_KEY_REPEAT_ON);
643
644   /* Set other global callback (global as in not associated with any specific menu or window) */
645   glutIdleFunc ( Idle );
646   glutMenuStatusFunc ( MenuStatus );
647   glutMenuStateFunc  ( MenuState ); /* Note that glutMenuStatusFunc is an enhanced version of the deprecated glutMenuStateFunc. */
648
649
650   /* Open first window */
651   windows[0] = glutCreateWindow( "Callback Demo" );
652   printf ( "Creating window %d as 'Callback Demo'\n", windows[0] ) ;
653
654   glClearColor(1.0, 1.0, 1.0, 1.0);
655
656   /* callbacks, settings and menus for this window */
657   SetWindowCallbacks( 1 );
658   glutIgnoreKeyRepeat(GL_TRUE);
659   glutSetIconTitle("Icon Test - Callback Demo");
660
661   subMenuA = glutCreateMenu( MenuCallback );
662   glutAddMenuEntry( "Sub menu A1 (01)", 11 );
663   glutAddMenuEntry( "Sub menu A2 (02)", 12 );
664   glutAddMenuEntry( "Sub menu A3 (03)", 13 );
665   glutMenuDestroyFunc ( MenuDestroy );  /* callback specific to this menu */
666   /* Change font for this menu */
667   glutSetMenuFont(subMenuA, GLUT_BITMAP_HELVETICA_12);
668
669   subMenuB = glutCreateMenu( MenuCallback );
670   glutAddMenuEntry( "Sub menu B1 (04)", 14 );
671   glutAddMenuEntry( "Sub menu B2 (05)", 15 );
672   glutAddMenuEntry( "Sub menu B3 (06)", 16 );
673   glutAddSubMenu( "Going to sub menu A", subMenuA );
674   glutMenuDestroyFunc ( MenuDestroy );  /* callback specific to this menu */
675   glutSetMenuFont(subMenuB, GLUT_BITMAP_9_BY_15);
676
677   menuID = glutCreateMenu( MenuCallback );
678   glutAddMenuEntry( "Entry one",   21 );
679   glutAddMenuEntry( "Entry two",   22 );
680   glutAddMenuEntry( "Entry three", 23 );
681   glutAddMenuEntry( "Entry four",  24 );
682   glutAddMenuEntry( "Entry five",  25 );
683   glutAddSubMenu( "Enter sub menu A", subMenuA );
684   glutAddSubMenu( "Enter sub menu B", subMenuB );
685   glutMenuDestroyFunc ( MenuDestroy );  /* callback specific to this menu */
686
687   glutAttachMenu( GLUT_LEFT_BUTTON );
688
689
690   /* Position second window right next to the first */
691   glutInitWindowPosition ( 140+500+2*glutGet(GLUT_WINDOW_BORDER_WIDTH), 140 );
692   glutInitWindowSize(600, 600);
693   windows[1] = glutCreateWindow( "Second Window" );
694   printf ( "Creating window %d as 'Second Window'\n", windows[1] ) ;
695
696   glClearColor(1.0, 1.0, 1.0, 1.0);
697
698   /* callbacks, settings and menus for this window */
699   SetWindowCallbacks( 0 );
700   glutIgnoreKeyRepeat(GL_TRUE);
701
702   glutSetMenu(subMenuB);
703   glutAttachMenu( GLUT_RIGHT_BUTTON );
704
705
706   /* position a third window as a subwindow of the second */
707   windows[2] = glutCreateSubWindow(windows[1],0,300,600,300);
708   printf ( "Creating window %d as subwindow to 'Second Window'\n", windows[2] ) ;
709
710   glClearColor(0.7f, 0.7f, 0.7f, 1.0);
711
712   /* callbacks, settings and menus for this window */
713   SetWindowCallbacks( 0 );
714   glutSetCursor(GLUT_CURSOR_CROSSHAIR); /* Cursors are per window */
715
716   glutSetMenu(subMenuA);
717   glutAttachMenu( GLUT_RIGHT_BUTTON );
718
719
720   /* position a fourth window as a subsubwindow (grandchild) of the second */
721   windows[3] = glutCreateSubWindow(windows[2],300,0,300,300);
722   printf ( "Creating window %d as subsubwindow to 'Second Window'\n", windows[3] ) ;
723
724   glClearColor(0.4f, 0.4f, 0.4f, 1.0);
725
726   /* callbacks and menus for this window */
727   SetWindowCallbacks( 0 );
728   glutSetCursor(GLUT_CURSOR_INHERIT);   /* Inherit cursor look from parent (this is default on window creation) - comment the below to see in action */
729   glutSetCursor(GLUT_CURSOR_CYCLE);
730
731
732   printf ( "Please enter something to continue: " );
733   fgets ( dummy_string, STRING_LENGTH, stdin );
734
735   glutMainLoop();
736
737   printf ( "Back from the 'freeglut' main loop\n" ) ;
738
739   return EXIT_SUCCESS;
740 }