Resolve bug 806008 -- let Microsoft's compiler know to use Windows libraries even...
[freeglut] / src / freeglut_menu.c
1 /*
2  * freeglut_menu.c
3  *
4  * Pull-down menu creation and handling.
5  *
6  * Copyright (c) 1999-2000 Pawel W. Olszta. All Rights Reserved.
7  * Written by Pawel W. Olszta, <olszta@sourceforge.net>
8  * Creation date: Thu Dec 16 1999
9  *
10  * Permission is hereby granted, free of charge, to any person obtaining a
11  * copy of this software and associated documentation files (the "Software"),
12  * to deal in the Software without restriction, including without limitation
13  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
14  * and/or sell copies of the Software, and to permit persons to whom the
15  * Software is furnished to do so, subject to the following conditions:
16  *
17  * The above copyright notice and this permission notice shall be included
18  * in all copies or substantial portions of the Software.
19  *
20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
21  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
23  * PAWEL W. OLSZTA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
24  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
25  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
26  */
27
28 #ifdef HAVE_CONFIG_H
29 #include "config.h"
30 #endif
31
32 #define  G_LOG_DOMAIN  "freeglut-menu"
33
34 #include "../include/GL/freeglut.h"
35 #include "freeglut_internal.h"
36
37 /*
38  * TODO BEFORE THE STABLE RELEASE:
39  *
40  * It would be cool if the submenu entries were somehow marked, for example with a dings
41  * on the right menu border or something like that. Think about the possibility of doing
42  * the menu on layers *or* using the native window system instead of OpenGL.
43  */
44
45 /* -- DEFINITIONS ---------------------------------------------------------- */
46
47 /*
48  * We'll be using freeglut fonts to draw the menu
49  */
50 #define  FREEGLUT_MENU_FONT    GLUT_BITMAP_8_BY_13
51 #define  FREEGLUT_MENU_HEIGHT  15
52 #define  FREEGLUT_MENU_BORDER   8
53
54
55 /* -- PRIVATE FUNCTIONS ---------------------------------------------------- */
56
57 /*
58  * Private static function to find a menu entry by index
59  */
60 static SFG_MenuEntry *fghFindMenuEntry( SFG_Menu* menu, int index )
61 {
62     SFG_MenuEntry *entry;
63     int i = 1;
64
65     for( entry = (SFG_MenuEntry *)menu->Entries.First; entry; entry = (SFG_MenuEntry *)entry->Node.Next)
66     {
67         if (i == index)
68             break;
69         ++i;
70     }
71
72     return entry;
73 }
74
75 /*
76  * Private static function to check for the current menu/sub menu activity state
77  */
78 static GLboolean fghCheckMenuStatus( SFG_Window* window, SFG_Menu* menu )
79 {
80   SFG_MenuEntry* menuEntry;
81   int x, y;
82
83   /*
84    * First of all check any of the active sub menus...
85    */
86   for( menuEntry = (SFG_MenuEntry *)menu->Entries.First; menuEntry;
87        menuEntry = (SFG_MenuEntry *)menuEntry->Node.Next )
88   {
89     /*
90      * Is that an active sub menu by any case?
91      */
92     if( menuEntry->SubMenu != NULL && menuEntry->IsActive == TRUE )
93     {
94       /*
95        * OK, have the sub-menu checked, too. If it returns TRUE, it will mean
96        * that it caught the mouse cursor and we do not need to regenerate
97        * the activity list, and so our parents do...
98        */
99       GLboolean return_status = fghCheckMenuStatus( window, menuEntry->SubMenu ) ;
100
101       /*
102        * Reactivate the submenu as the checkMenuStatus may have turned it off if the mouse
103        * is in its parent menu entry.
104        */
105       menuEntry->SubMenu->IsActive = TRUE ;
106       if ( return_status == TRUE )
107         return( TRUE );
108     }
109   }
110
111   /*
112    * That much about our sub menus, let's get to checking the current menu:
113    */
114   x = window->State.MouseX;
115   y = window->State.MouseY;
116
117   /*
118    * Mark all menu entries inactive...
119    */
120   for( menuEntry = (SFG_MenuEntry *)menu->Entries.First; menuEntry;
121        menuEntry = (SFG_MenuEntry *)menuEntry->Node.Next )
122   {
123     menuEntry->IsActive = FALSE;
124   }
125
126
127   menu->IsActive = FALSE;
128
129   /*
130    * Check if the mouse cursor is contained within the current menu box
131    */
132   if ( ( x >= 0 ) && ( x < menu->Width ) && ( y >= 0 ) && ( y < menu->Height ) && ( window == menu->Window ) )
133   {
134     /*
135      * Calculation of the highlighted menu item is easy enough now:
136      */
137     int menuID = y / FREEGLUT_MENU_HEIGHT;
138
139     /*
140      * The mouse cursor is somewhere over our box, check it out.
141      */
142     menuEntry = fghFindMenuEntry( menu, menuID + 1 );
143     assert( menuEntry != NULL );
144
145     /*
146      * Mark the menu as active...
147      */
148     menuEntry->IsActive = TRUE;
149     menuEntry->Ordinal = menuID;
150
151     /*
152      * If this is not the same as the last active menu entry, deactivate the previous entry.
153      * Specifically, if the previous active entry was a submenu then deactivate it.
154      */
155     if ( menu->ActiveEntry && ( menuEntry != menu->ActiveEntry ) )
156     {
157       if ( menu->ActiveEntry->SubMenu != NULL )
158         fgDeactivateSubMenu ( menu->ActiveEntry ) ;
159     }
160
161     menu->ActiveEntry = menuEntry ;
162
163     /*
164      * Don't forget about marking the current menu as active, too:
165      */
166
167     menu->IsActive = TRUE;
168
169     /*
170      * OKi, we have marked that entry as active, but it would be also
171      * nice to have its contents updated, in case it's a sub menu.
172      * Also, ignore the return value of the check function:
173      */
174     if( menuEntry->SubMenu != NULL )
175     {
176       if ( ! menuEntry->SubMenu->IsActive )
177       {
178         SFG_Window *current_window = fgStructure.Window ;
179
180         /*
181          * Set up the initial menu position now...
182          */
183
184         /*
185          * Mark the menu as active, so that it gets displayed:
186          */
187         menuEntry->SubMenu->IsActive = TRUE ;
188
189         /*
190          * Set up the initial submenu position now:
191          */
192         menuEntry->SubMenu->X = menu->X + menu->Width ;
193         menuEntry->SubMenu->Y = menu->Y + menuEntry->Ordinal * FREEGLUT_MENU_HEIGHT ;
194
195         fgSetWindow ( menuEntry->SubMenu->Window ) ;
196         glutPositionWindow ( menuEntry->SubMenu->X, menuEntry->SubMenu->Y ) ;
197         glutReshapeWindow ( menuEntry->SubMenu->Width, menuEntry->SubMenu->Height ) ;
198         glutPopWindow () ;
199         glutShowWindow () ;
200         menuEntry->SubMenu->Window->ActiveMenu = menuEntry->SubMenu ;
201         fgSetWindow ( current_window ) ;
202       }
203
204       /*
205        * ...then check the submenu's state:
206        */
207       fghCheckMenuStatus( window, menuEntry->SubMenu );
208
209       /*
210        * Even if the submenu turned up inactive, activate it because its parent entry is active
211        */
212       menuEntry->SubMenu->IsActive = TRUE ;
213     }
214
215     /*
216      * Report back that we have caught the menu cursor
217      */
218     return( TRUE );
219   }
220
221   /*
222    * Looks like the menu cursor is somewhere else...
223    */
224   return( FALSE );
225 }
226
227 /*
228  * Displays a menu box and all of its submenus (if they are active)
229  */
230 static void fghDisplayMenuBox( SFG_Menu* menu )
231 {
232   SFG_MenuEntry *menuEntry;
233   int i;
234
235   /*
236    * Have the menu box drawn first. The +- values are
237    * here just to make it more nice-looking...
238    */
239   glColor4f( 0.1289f, 0.2257f, 0.28516f, 1.0f ); /* a non-black dark version of the below. */
240   glBegin( GL_QUADS );
241     glVertex2i( 0          , 0            );
242     glVertex2i( menu->Width, 0            );
243     glVertex2i( menu->Width, menu->Height );
244     glVertex2i( 0          , menu->Height );
245   glEnd();
246
247   glColor4f( 0.3f, 0.4f, 0.5f, 1.0f );
248   glBegin( GL_QUADS );
249     glVertex2i(             1, 1             );
250     glVertex2i( menu->Width-1, 1             );
251     glVertex2i( menu->Width-1, menu->Height-1);
252     glVertex2i(             1, menu->Height-1);
253   glEnd();
254
255   /*
256    * Check if any of the submenus is currently active...
257    */
258   for( menuEntry = (SFG_MenuEntry *)menu->Entries.First; menuEntry;
259        menuEntry = (SFG_MenuEntry *)menuEntry->Node.Next )
260   {
261     /*
262      * Has the menu been marked as active, maybe?
263      */
264     if( menuEntry->IsActive == TRUE )
265     {
266       /*
267        * That's truly right, and we need to have it highlighted.
268        * There is an assumption that mouse cursor didn't move
269        * since the last check of menu activity state:
270        */
271       int menuID = menuEntry->Ordinal;
272
273       /*
274        * So have the highlight drawn...
275        */
276       glColor4f( 0.2f, 0.3f, 0.4f, 1.0f );
277       glBegin( GL_QUADS );
278         glVertex2i( 2            , (menuID + 0)*FREEGLUT_MENU_HEIGHT + 1 );
279         glVertex2i( menu->Width-2, (menuID + 0)*FREEGLUT_MENU_HEIGHT + 1 );
280         glVertex2i( menu->Width-2, (menuID + 1)*FREEGLUT_MENU_HEIGHT + 2 );
281         glVertex2i( 2            , (menuID + 1)*FREEGLUT_MENU_HEIGHT + 2 );
282       glEnd();
283     }
284   }
285
286   /*
287    * Print the menu entries now...
288    */
289   glColor4f( 1, 1, 1, 1 );
290
291   for( menuEntry = (SFG_MenuEntry *)menu->Entries.First, i=0; menuEntry;
292        menuEntry = (SFG_MenuEntry *)menuEntry->Node.Next, ++i )
293   {
294     /*
295      * Move the raster into position...
296      */
297     glRasterPos2i(
298         FREEGLUT_MENU_BORDER,
299         (i + 1)*FREEGLUT_MENU_HEIGHT-(int)(FREEGLUT_MENU_HEIGHT*0.3) /* Try to center the text - JCJ 31 July 2003*/
300     );
301
302     /*
303      * Have the label drawn, character after character:
304      */
305     glutBitmapString( FREEGLUT_MENU_FONT, menuEntry->Text);
306
307     /*
308      * If it's a submenu, draw a right arrow
309      */
310     if ( menuEntry->SubMenu != NULL )
311     {
312       GLubyte arrow_char [] = { 0, 0, 32, 48, 56, 60, 62, 63, 62, 60, 56, 48, 32, 0, 0 } ;
313       int width = glutBitmapWidth ( FREEGLUT_MENU_FONT, ' ' ) ;
314
315       glPushClientAttrib( GL_CLIENT_PIXEL_STORE_BIT );
316
317       /*
318        * Set up the pixel unpacking ways
319        */
320       glPixelStorei( GL_UNPACK_SWAP_BYTES,  GL_FALSE );
321       glPixelStorei( GL_UNPACK_LSB_FIRST,   GL_FALSE );
322       glPixelStorei( GL_UNPACK_ROW_LENGTH,  0        );
323       glPixelStorei( GL_UNPACK_SKIP_ROWS,   0        );
324       glPixelStorei( GL_UNPACK_SKIP_PIXELS, 0        );
325       glPixelStorei( GL_UNPACK_ALIGNMENT,   1        );
326
327       glRasterPos2i ( menu->Width - 2 - width,
328                       (i + 1)*FREEGLUT_MENU_HEIGHT ) ;
329       glBitmap ( width, FREEGLUT_MENU_HEIGHT, 0, 0, 0.0, 0.0, arrow_char ) ;
330       glPopClientAttrib();
331     }
332   }
333
334   /*
335    * Now we are ready to check if any of our children needs to be redrawn:
336    */
337   for( menuEntry = (SFG_MenuEntry *)menu->Entries.First; menuEntry;
338        menuEntry = (SFG_MenuEntry *)menuEntry->Node.Next )
339   {
340     /*
341      * Is that an active sub menu by any case?
342      */
343     if( menuEntry->SubMenu != NULL && menuEntry->IsActive == TRUE )
344     {
345       /*
346        * Yeah, indeed. Have it redrawn now:
347        */
348       fgSetWindow ( menuEntry->SubMenu->Window ) ;
349       fghDisplayMenuBox( menuEntry->SubMenu );
350       fgSetWindow ( menu->Window ) ;
351     }
352   }
353 }
354
355 /*
356  * Private static function to set the parent window of a submenu and all of its submenus
357  */
358 static void fghSetSubmenuParentWindow ( SFG_Window *window, SFG_Menu *menu )
359 {
360   SFG_MenuEntry *menuEntry ;
361
362   menu->ParentWindow = window ;
363
364   for ( menuEntry = (SFG_MenuEntry *)menu->Entries.First; menuEntry; menuEntry = (SFG_MenuEntry *)menuEntry->Node.Next )
365   {
366     if ( menuEntry->SubMenu != NULL )
367       fghSetSubmenuParentWindow ( window, menuEntry->SubMenu ) ;
368   }
369 }
370
371
372 /*
373  * Displays the currently active menu for the current window
374  */
375 void fgDisplayMenu( void )
376 {
377     SFG_Window* window = fgStructure.Window;
378     SFG_Menu* menu = NULL;
379
380     /*
381      * Make sure there is a current window available
382      */
383     freeglut_assert_window;
384
385     /*
386      * Check if there is an active menu attached to this window...
387      */
388     menu = window->ActiveMenu;
389
390     /*
391      * Did we find an active menu?
392      */
393     freeglut_return_if_fail( menu != NULL );
394
395     fgSetWindow ( menu->Window ) ;
396
397     /*
398      * Prepare the OpenGL state to do the rendering first:
399      */
400     glPushAttrib( GL_DEPTH_BUFFER_BIT | GL_TEXTURE_BIT | GL_LIGHTING_BIT | GL_POLYGON_BIT );
401
402     glDisable( GL_DEPTH_TEST );
403     glDisable( GL_TEXTURE_2D );
404     glDisable( GL_LIGHTING   );
405     glDisable( GL_CULL_FACE  );
406
407     /*
408      * We'll use an orthogonal projection matrix to draw the menu:
409      */
410     glMatrixMode( GL_PROJECTION );
411     glPushMatrix();
412     glLoadIdentity();
413     glOrtho(
414          0, glutGet( GLUT_WINDOW_WIDTH  ),
415          glutGet( GLUT_WINDOW_HEIGHT ), 0,
416         -1, 1
417     );
418
419     /*
420      * Model-view matix gets reset to identity:
421      */
422     glMatrixMode( GL_MODELVIEW );
423     glPushMatrix();
424     glLoadIdentity();
425
426     /*
427      * First of all, have the exact menu status check:
428      */
429     fghCheckMenuStatus( window, menu );
430
431     /*
432      * The status has been updated and we're ready to have the menu drawn now:
433      */
434     fghDisplayMenuBox( menu );
435
436     /*
437      * Restore the old OpenGL settings now
438      */
439     glPopAttrib();
440
441     glMatrixMode( GL_PROJECTION );
442     glPopMatrix();
443     glMatrixMode( GL_MODELVIEW );
444     glPopMatrix();
445
446     glutSwapBuffers () ;
447
448     /*
449      * Restore the current window
450      */
451     fgSetWindow ( window ) ;
452 }
453
454 /*
455  * Activates a menu pointed by the function argument
456  */
457 void fgActivateMenu( SFG_Window* window, int button )
458 {
459   /*
460    * We'll be referencing this menu a lot, so remember its address:
461    */
462   SFG_Menu* menu = window->Menu[ button ];
463
464   /*
465    * Mark the menu as active, so that it gets displayed:
466    */
467   window->ActiveMenu = menu;
468   menu->IsActive = TRUE ;
469   fgState.ActiveMenus ++ ;
470
471   /*
472    * Set up the initial menu position now:
473    */
474
475   menu->X = window->State.MouseX + glutGet ( GLUT_WINDOW_X ) ;
476   menu->Y = window->State.MouseY + glutGet ( GLUT_WINDOW_Y ) ;
477
478   fgSetWindow ( menu->Window ) ;
479   glutPositionWindow ( menu->X, menu->Y ) ;
480   glutReshapeWindow ( menu->Width, menu->Height ) ;
481   glutPopWindow () ;
482   glutShowWindow () ;
483   menu->Window->ActiveMenu = menu ;
484
485 /*  if( x > ( glutGet( GLUT_WINDOW_WIDTH ) - menu->Width ) )
486     menu->X = glutGet( GLUT_WINDOW_WIDTH ) - menu->Width;
487   if( y > ( glutGet( GLUT_WINDOW_HEIGHT ) - menu->Height) )
488     menu->Y = glutGet( GLUT_WINDOW_HEIGHT ) - menu->Height; */
489 }
490
491 /*
492  * Check whether an active menu absorbs a mouse click
493  */
494 GLboolean fgCheckActiveMenu ( SFG_Window *window, SFG_Menu *menu )
495 {
496   /*
497    * Near as I can tell, this is the active menu behaviour:
498    *  - Down-click any button outside the menu, menu active:  deactivate the menu
499    *  - Down-click any button inside the menu, menu active:  select the menu entry and deactivate the menu
500    *  - Up-click the menu button outside the menu, menu active:  nothing happens
501    *  - Up-click the menu button inside the menu, menu active:  select the menu entry and deactivate the menu
502    * Since menus can have submenus, we need to check this recursively.
503    */
504   return fghCheckMenuStatus ( window, menu ) ;
505 }
506
507 /*
508  * Function to check for menu entry selection on menu deactivation
509  */
510 void fgExecuteMenuCallback( SFG_Menu* menu )
511 {
512   SFG_MenuEntry *menuEntry;
513
514   /*
515    * First of all check any of the active sub menus...
516    */
517   for( menuEntry = (SFG_MenuEntry *)menu->Entries.First; menuEntry; menuEntry = (SFG_MenuEntry *)menuEntry->Node.Next)
518   {
519     /*
520      * Is this menu entry active?
521      */
522     if( menuEntry->IsActive == TRUE )
523     {
524       /*
525        * If there is not a sub menu, execute the menu callback and return...
526        */
527       if( menuEntry->SubMenu == NULL )
528       {
529         /*
530          * ...certainly given that there is one...
531          */
532         if( menu->Callback != NULL )
533           menu->Callback( menuEntry->ID );
534
535         return;
536       }
537
538       /*
539        * Otherwise recurse into the submenu.
540        */
541       fgExecuteMenuCallback( menuEntry->SubMenu );
542
543       /*
544        * There is little sense in dwelling the search on
545        */
546       return;
547     }
548   }
549 }
550
551 /*
552  * Deactivates a menu pointed by the function argument.
553  */
554 void fgDeactivateMenu( SFG_Window *window )
555 {
556   SFG_Window *current_window = fgStructure.Window ;
557
558     /*
559      * Check if there is an active menu attached to this window...
560      */
561     SFG_Menu* menu = window->ActiveMenu;
562     SFG_MenuEntry *menuEntry ;
563
564     /*
565      * Did we find an active window?
566      */
567     freeglut_return_if_fail( menu != NULL );
568
569     /*
570      * Hide the present menu's window
571      */
572     fgSetWindow ( menu->Window ) ;
573     glutHideWindow () ;
574
575     /*
576      * Forget about having that menu active anymore, now:
577      */
578     menu->Window->ActiveMenu = NULL ;
579     menu->ParentWindow->ActiveMenu = NULL ;
580     menu->IsActive = FALSE ;
581
582     fgState.ActiveMenus -- ;
583
584     /*
585      * Hide all submenu windows, and the root menu's window.
586      */
587     for ( menuEntry = (SFG_MenuEntry *)menu->Entries.First; menuEntry;
588           menuEntry = (SFG_MenuEntry *)menuEntry->Node.Next )
589     {
590       /*
591        * Is that an active submenu by any case?
592        */
593       if ( ( menuEntry->SubMenu != NULL ) && menuEntry->SubMenu->IsActive )
594         fgDeactivateSubMenu ( menuEntry ) ;
595     }
596
597     fgSetWindow ( current_window ) ;
598 }
599
600 /*
601  * Deactivates a menu pointed by the function argument.
602  */
603 void fgDeactivateSubMenu( SFG_MenuEntry *menuEntry )
604 {
605   SFG_Window *current_window = fgStructure.Window ;
606   SFG_MenuEntry *subMenuIter ;
607     /*
608      * Hide the present menu's window
609      */
610     fgSetWindow ( menuEntry->SubMenu->Window ) ;
611     glutHideWindow () ;
612
613     /*
614      * Forget about having that menu active anymore, now:
615      */
616     menuEntry->SubMenu->Window->ActiveMenu = NULL ;
617     menuEntry->SubMenu->IsActive = FALSE ;
618
619     /*
620      * Hide all submenu windows, and the root menu's window.
621      */
622     for ( subMenuIter = (SFG_MenuEntry *)menuEntry->SubMenu->Entries.First; subMenuIter;
623           subMenuIter = (SFG_MenuEntry *)subMenuIter->Node.Next )
624     {
625       /*
626        * Is that an active submenu by any case?
627        */
628       if ( ( subMenuIter->SubMenu != NULL ) && subMenuIter->SubMenu->IsActive )
629         fgDeactivateSubMenu ( subMenuIter ) ;
630     }
631
632     fgSetWindow ( current_window ) ;
633 }
634
635 /*
636  * Recalculates current menu's box size
637  */
638 void fghCalculateMenuBoxSize( void )
639 {
640   SFG_MenuEntry* menuEntry;
641   int width = 0, height = 0;
642
643   /*
644    * Make sure there is a current menu set
645    */
646   freeglut_assert_ready; freeglut_return_if_fail( fgStructure.Menu != NULL );
647
648   /*
649    * The menu's box size depends on the menu entries:
650    */
651   for( menuEntry = (SFG_MenuEntry *)fgStructure.Menu->Entries.First; menuEntry;
652        menuEntry = (SFG_MenuEntry *)menuEntry->Node.Next)
653   {
654     /*
655      * Update the menu entry's width value
656      */
657     menuEntry->Width = glutBitmapLength( FREEGLUT_MENU_FONT, menuEntry->Text );
658
659     /*
660      * If the entry is a submenu, then it needs to be wider to accomodate the arrow. JCJ 31 July 2003
661      */
662
663     if (menuEntry->SubMenu != NULL)
664        menuEntry->Width += glutBitmapLength( FREEGLUT_MENU_FONT, " " );
665
666     /*
667      * Check if it's the biggest we've found
668      */
669     if( menuEntry->Width > width )
670       width = menuEntry->Width;
671
672     height += FREEGLUT_MENU_HEIGHT;
673   }
674
675   /*
676    * Store the menu's box size now:
677    */
678   fgStructure.Menu->Height = height; 
679   fgStructure.Menu->Width  = width + 2 * FREEGLUT_MENU_BORDER ;
680 }
681
682
683 /* -- INTERFACE FUNCTIONS -------------------------------------------------- */
684
685 /*
686  * Creates a new menu object, adding it to the freeglut structure
687  */
688 int FGAPIENTRY glutCreateMenu( void (* callback)( int ) )
689 {
690     /*
691      * The menu object creation code resides in freeglut_structure.c
692      */
693     return( fgCreateMenu( callback )->ID );
694 }
695
696 /*
697  * Destroys a menu object, removing all references to it
698  */
699 void FGAPIENTRY glutDestroyMenu( int menuID )
700 {
701     SFG_Menu* menu = fgMenuByID( menuID );
702
703     freeglut_assert_ready; freeglut_return_if_fail( menu != NULL );
704
705     /*
706      * The menu object destruction code resides in freeglut_structure.c
707      */
708     fgDestroyMenu( menu );
709 }
710
711 /*
712  * Returns the ID number of the currently active menu
713  */
714 int FGAPIENTRY glutGetMenu( void )
715 {
716     freeglut_assert_ready;
717
718     /*
719      * Is there a current menu set?
720      */
721     if( fgStructure.Menu != NULL )
722     {
723         /*
724          * Yes, there is indeed...
725          */
726         return( fgStructure.Menu->ID );
727     }
728
729     /*
730      * No, there is no current menu at all
731      */
732     return( 0 );
733 }
734
735 /*
736  * Sets the current menu given its menu ID
737  */
738 void FGAPIENTRY glutSetMenu( int menuID )
739 {
740     SFG_Menu* menu = fgMenuByID( menuID );
741
742     freeglut_assert_ready; freeglut_return_if_fail( menu != NULL );
743
744     /*
745      * The current menu pointer is stored in fgStructure.Menu
746      */
747     fgStructure.Menu = menu;
748 }
749
750 /*
751  * Adds a menu entry to the bottom of the current menu
752  */
753 void FGAPIENTRY glutAddMenuEntry( const char* label, int value )
754 {
755     SFG_MenuEntry* menuEntry = (SFG_MenuEntry *)calloc( sizeof(SFG_MenuEntry), 1 );
756
757     /*
758      * Make sure there is a current menu set
759      */
760     freeglut_assert_ready; freeglut_return_if_fail( fgStructure.Menu != NULL );
761
762     /*
763      * Fill in the appropriate values...
764      */
765     menuEntry->Text = strdup( label );
766     menuEntry->ID   = value;
767
768     /*
769      * Have the new menu entry attached to the current menu
770      */
771     fgListAppend( &fgStructure.Menu->Entries, &menuEntry->Node );
772
773     /*
774      * Update the menu's dimensions now
775      */
776     fghCalculateMenuBoxSize();
777 }
778
779 /*
780  * Add a sub menu to the bottom of the current menu
781  */
782 void FGAPIENTRY glutAddSubMenu( const char* label, int subMenuID )
783 {
784   SFG_MenuEntry* menuEntry = (SFG_MenuEntry *)calloc( sizeof(SFG_MenuEntry), 1 );
785   SFG_Menu*      subMenu = fgMenuByID( subMenuID );
786
787   /*
788    * Make sure there is a current menu and the sub menu
789    * we want to attach actually exists...
790    */
791   freeglut_assert_ready; freeglut_return_if_fail( fgStructure.Menu != NULL );
792   freeglut_return_if_fail( subMenu != NULL );
793
794   /*
795    * Fill in the appropriate values
796    */
797   menuEntry->Text = strdup( label );
798   menuEntry->SubMenu = subMenu;
799   menuEntry->ID      = -1;
800
801   /*
802    * Make the submenu's parent window be the menu's parent window
803    */
804   fghSetSubmenuParentWindow ( fgStructure.Menu->ParentWindow, subMenu ) ;
805
806   /*
807    * Have the new menu entry attached to the current menu
808    */
809   fgListAppend( &fgStructure.Menu->Entries, &menuEntry->Node );
810
811   /*
812    * Update the menu's dimensions now
813    */
814   fghCalculateMenuBoxSize();
815 }
816
817 /*
818  * Changes the specified menu item in the current menu into a menu entry
819  */
820 void FGAPIENTRY glutChangeToMenuEntry( int item, const char* label, int value )
821 {
822     SFG_MenuEntry* menuEntry = NULL;
823
824     /*
825      * Make sure there is a current menu set...
826      */
827     freeglut_assert_ready; freeglut_return_if_fail( fgStructure.Menu != NULL );
828
829     /*
830      * Get n-th menu entry in the current menu, starting from one:
831      */
832     menuEntry = fghFindMenuEntry( fgStructure.Menu, item );
833
834     /*
835      * Make sure the menu entry exists
836      */
837     freeglut_return_if_fail( menuEntry != NULL );
838
839     /*
840      * We want it to become a normal menu entry, so:
841      */
842     if( menuEntry->Text != NULL )
843         free( menuEntry->Text );
844
845     menuEntry->Text = strdup( label );
846     menuEntry->ID      = value;
847     menuEntry->SubMenu = NULL;
848
849     /*
850      * Update the menu's dimensions now
851      */
852     fghCalculateMenuBoxSize();
853 }
854
855 /*
856  * Changes the specified menu item in the current menu into a sub-menu trigger.
857  */
858 void FGAPIENTRY glutChangeToSubMenu( int item, const char* label, int subMenuID )
859 {
860     SFG_Menu*      subMenu = fgMenuByID( subMenuID );
861     SFG_MenuEntry* menuEntry = NULL;
862
863     /*
864      * Make sure there is a current menu set and the sub menu exists...
865      */
866     freeglut_assert_ready; freeglut_return_if_fail( fgStructure.Menu != NULL );
867     freeglut_return_if_fail( subMenu != NULL );
868
869     /*
870      * Get n-th menu entry in the current menu, starting from one:
871      */
872     menuEntry = fghFindMenuEntry( fgStructure.Menu, item );
873
874     /*
875      * Make sure the menu entry exists
876      */
877     freeglut_return_if_fail( menuEntry != NULL );
878
879     /*
880      * We want it to become a sub menu entry, so:
881      */
882     if( menuEntry->Text != NULL )
883         free( menuEntry->Text );
884
885     menuEntry->Text = strdup( label );
886     menuEntry->SubMenu = subMenu;
887     menuEntry->ID      = -1;
888
889     /*
890      * Update the menu's dimensions now
891      */
892     fghCalculateMenuBoxSize();
893 }
894
895 /*
896  * Removes the specified menu item from the current menu
897  */
898 void FGAPIENTRY glutRemoveMenuItem( int item )
899 {
900     SFG_MenuEntry* menuEntry;
901
902     /*
903      * Make sure there is a current menu set
904      */
905     freeglut_assert_ready; freeglut_return_if_fail( fgStructure.Menu != NULL );
906
907     /*
908      * Get n-th menu entry in the current menu, starting from one:
909      */
910     menuEntry = fghFindMenuEntry( fgStructure.Menu, item );
911
912     /*
913      * Make sure the menu entry exists
914      */
915     freeglut_return_if_fail( menuEntry != NULL );
916
917     /*
918      * Removing a menu entry is quite simple...
919      */
920     fgListRemove( &fgStructure.Menu->Entries, &menuEntry->Node );
921
922     /*
923      * Free the entry label string, too
924      */
925     free( menuEntry->Text );
926
927     free( menuEntry );
928
929     /*
930      * Update the menu's dimensions now
931      */
932     fghCalculateMenuBoxSize();
933 }
934
935 /*
936  * Attaches a menu to the current window
937  */
938 void FGAPIENTRY glutAttachMenu( int button )
939 {
940     freeglut_assert_ready;
941
942     /*
943      * There must be a current window and a current menu set:
944      */
945     freeglut_return_if_fail( fgStructure.Window != NULL || fgStructure.Menu != NULL );
946
947     /*
948      * Make sure the button value is valid (0, 1 or 2, see freeglut.h)
949      */
950     freeglut_return_if_fail( button == GLUT_LEFT_BUTTON || button == GLUT_MIDDLE_BUTTON || button == GLUT_RIGHT_BUTTON );
951
952     /*
953      * It is safe now to attach the menu
954      */
955     fgStructure.Window->Menu[ button ] = fgStructure.Menu;
956
957     /*
958      * Make the parent window of the menu (and all submenus) the current window
959      */
960     fghSetSubmenuParentWindow ( fgStructure.Window, fgStructure.Menu ) ;
961 }
962
963 /*
964  * Detaches a menu from the current window
965  */
966 void FGAPIENTRY glutDetachMenu( int button )
967 {
968     freeglut_assert_ready;
969
970     /*
971      * There must be a current window set:
972      */
973     freeglut_return_if_fail( fgStructure.Window != NULL );
974
975     /*
976      * Make sure the button value is valid (0, 1 or 2, see freeglut.h)
977      */
978     freeglut_return_if_fail( button != 0 && button != 1 && button != 2 );
979
980     /*
981      * It is safe now to detach the menu
982      */
983     fgStructure.Window->Menu[ button ] = NULL;
984 }
985
986 /*
987  * A.Donev: Set and retrieve the menu's user data
988  */
989 void* FGAPIENTRY glutGetMenuData( void )
990 {
991    return(fgStructure.Menu->UserData);
992 }
993
994 void FGAPIENTRY glutSetMenuData(void* data)
995 {
996   fgStructure.Menu->UserData=data;
997 }
998
999 /*** END OF FILE ***/