Made all the "glutJoystickXXX" functions part of the freeglut extensions.
[freeglut] / src / freeglut_structure.c
1 /*
2  * freeglut_structure.c
3  *
4  * Windows and menus need tree structure
5  *
6  * Copyright (c) 1999-2000 Pawel W. Olszta. All Rights Reserved.
7  * Written by Pawel W. Olszta, <olszta@sourceforge.net>
8  * Creation date: Sat Dec 18 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 #include <GL/freeglut.h>
29 #include "freeglut_internal.h"
30
31 /* -- GLOBAL EXPORTS ------------------------------------------------------- */
32
33 /*
34  * The SFG_Structure container holds information about windows and menus
35  * created between glutInit() and glutMainLoop() return.
36  */
37
38 SFG_Structure fgStructure = { { NULL, NULL },  /* The list of windows       */
39                               { NULL, NULL },  /* The list of menus         */
40                               { NULL, NULL },  /* Windows to Destroy list   */
41                               NULL,            /* The current window        */
42                               NULL,            /* The current menu          */
43                               NULL,            /* The menu OpenGL context   */
44                               NULL,            /* The game mode window      */
45                               0,               /* The current new window ID */
46                               0 };             /* The current new menu ID   */
47
48
49 /* -- PRIVATE FUNCTIONS ---------------------------------------------------- */
50
51 static void fghClearCallBacks( SFG_Window *window )
52 {
53     if( window )
54     {
55         int i;
56         for( i = 0; i < TOTAL_CALLBACKS; ++i )
57             window->CallBacks[ i ] = NULL;
58     }
59 }
60
61 /*
62  * This private function creates, opens and adds to the hierarchy
63  * a freeglut window complete with OpenGL context and stuff...
64  *
65  * If parent is set to NULL, the window created will be a topmost one.
66  */
67 SFG_Window* fgCreateWindow( SFG_Window* parent, const char* title,
68                             int x, int y, int w, int h,
69                             GLboolean gameMode, GLboolean isMenu )
70 {
71     /* Have the window object created */
72     SFG_Window *window = (SFG_Window *)calloc( sizeof(SFG_Window), 1 );
73
74     fghClearCallBacks( window );
75
76     /* Initialize the object properties */
77     window->ID = ++fgStructure.WindowID;
78     window->State.OldHeight = window->State.OldWidth = -1;
79
80     fgListInit( &window->Children );
81     if( parent )
82     {
83         fgListAppend( &parent->Children, &window->Node );
84         window->Parent = parent;
85     }
86     else
87         fgListAppend( &fgStructure.Windows, &window->Node );
88
89     /* Set the default mouse cursor and reset the modifiers value */
90     window->State.Cursor    = GLUT_CURSOR_INHERIT;
91
92     window->IsMenu = isMenu;
93
94     window->State.IgnoreKeyRepeat = GL_FALSE;
95     window->State.KeyRepeating    = GL_FALSE;
96
97     /*
98      * Open the window now. The fgOpenWindow() function is system
99      * dependant, and resides in freeglut_window.c. Uses fgState.
100      */
101     fgOpenWindow( window, title, x, y, w, h, gameMode,
102                   (GLboolean)(parent ? GL_TRUE : GL_FALSE) );
103
104     return window;
105 }
106
107 /*
108  * This private function creates a menu and adds it to the menus list
109  */
110 SFG_Menu* fgCreateMenu( FGCBMenu menuCallback )
111 {
112     int x = 100, y = 100, w = 100, h = 100;
113     SFG_Window *current_window = fgStructure.CurrentWindow;
114
115     /* Have the menu object created */
116     SFG_Menu* menu = (SFG_Menu *)calloc( sizeof(SFG_Menu), 1 );
117
118     menu->ParentWindow = NULL;
119
120     /* Create a window for the menu to reside in. */
121
122     fgCreateWindow( NULL, "freeglut menu", x, y, w, h, GL_FALSE, GL_TRUE );
123     menu->Window = fgStructure.CurrentWindow;
124     glutDisplayFunc( fgDisplayMenu );
125
126     glutHideWindow( );  /* Hide the window for now */
127     fgSetWindow( current_window );
128
129     /* Initialize the object properties: */
130     menu->ID       = ++fgStructure.MenuID;
131     menu->Callback = menuCallback;
132     menu->ActiveEntry = NULL;
133
134     fgListInit( &menu->Entries );
135     fgListAppend( &fgStructure.Menus, &menu->Node );
136
137     /* Newly created menus implicitly become current ones */
138     fgStructure.CurrentMenu = menu;
139
140     return menu;
141 }
142
143 /*
144  * Function to add a window to the linked list of windows to destroy.
145  * Subwindows are automatically added because they hang from the window
146  * structure.
147  */
148 void fgAddToWindowDestroyList( SFG_Window* window )
149 {
150     SFG_WindowList *new_list_entry =
151         ( SFG_WindowList* )malloc( sizeof(SFG_WindowList ) );
152     new_list_entry->window = window;
153     fgListAppend( &fgStructure.WindowsToDestroy, &new_list_entry->node );
154
155     /* Check if the window is the current one... */
156     if( fgStructure.CurrentWindow == window )
157         fgStructure.CurrentWindow = NULL;
158
159     /*
160      * Clear all window callbacks except Destroy, which will
161      * be invoked later.  Right now, we are potentially carrying
162      * out a freeglut operation at the behest of a client callback,
163      * so we are reluctant to re-enter the client with the Destroy
164      * callback, right now.  The others are all wiped out, however,
165      * to ensure that they are no longer called after this point.
166      */
167     {
168         FGCBDestroy destroy = (FGCBDestroy)FETCH_WCB( *window, Destroy );
169         fghClearCallBacks( window );
170         SET_WCB( *window, Destroy, destroy );
171     }
172 }
173
174 /*
175  * Function to close down all the windows in the "WindowsToDestroy" list
176  */
177 void fgCloseWindows( )
178 {
179     while( fgStructure.WindowsToDestroy.First )
180     {
181         SFG_WindowList *window_ptr = fgStructure.WindowsToDestroy.First;
182         fgDestroyWindow( window_ptr->window );
183         fgListRemove( &fgStructure.WindowsToDestroy, &window_ptr->node );
184         free( window_ptr );
185     }
186 }
187
188 /*
189  * This function destroys a window and all of its subwindows. Actually,
190  * another function, defined in freeglut_window.c is called, but this is
191  * a whole different story...
192  */
193 void fgDestroyWindow( SFG_Window* window )
194 {
195     FREEGLUT_INTERNAL_ERROR_EXIT ( window, "Window destroy function called with null window",
196                                    "fgDestroyWindow" );
197
198     while( window->Children.First )
199         fgDestroyWindow( ( SFG_Window * )window->Children.First );
200
201     {
202         SFG_Window *activeWindow = fgStructure.CurrentWindow;
203         INVOKE_WCB( *window, Destroy, ( ) );
204         fgSetWindow( activeWindow );
205     }
206
207     if( window->Parent )
208         fgListRemove( &window->Parent->Children, &window->Node );
209     else
210         fgListRemove( &fgStructure.Windows, &window->Node );
211
212     if( window->ActiveMenu )
213       fgDeactivateMenu( window );
214
215     fghClearCallBacks( window );
216     fgCloseWindow( window );
217     free( window );
218     if( fgStructure.CurrentWindow == window )
219         fgStructure.CurrentWindow = NULL;
220 }
221
222 /*
223  * This is a helper static function that removes a menu (given its pointer)
224  * from any windows that can be accessed from a given parent...
225  */
226 static void fghRemoveMenuFromWindow( SFG_Window* window, SFG_Menu* menu )
227 {
228     SFG_Window *subWindow;
229     int i;
230
231     /* Check whether this is the active menu in the window */
232     if ( menu == window->ActiveMenu )
233         window->ActiveMenu = NULL ;
234
235     /*
236      * Check if the menu is attached to the current window,
237      * if so, have it detached (by overwriting with a NULL):
238      */
239     for( i = 0; i < FREEGLUT_MAX_MENUS; i++ )
240         if( window->Menu[ i ] == menu )
241             window->Menu[ i ] = NULL;
242
243     /* Call this function for all of the window's children recursively: */
244     for( subWindow = (SFG_Window *)window->Children.First;
245          subWindow;
246          subWindow = (SFG_Window *)subWindow->Node.Next)
247         fghRemoveMenuFromWindow( subWindow, menu );
248 }
249
250 /*
251  * This is a static helper function that removes menu references
252  * from another menu, given two pointers to them...
253  */
254 static void fghRemoveMenuFromMenu( SFG_Menu* from, SFG_Menu* menu )
255 {
256     SFG_MenuEntry *entry;
257
258     for( entry = (SFG_MenuEntry *)from->Entries.First;
259          entry;
260          entry = ( SFG_MenuEntry * )entry->Node.Next )
261         if( entry->SubMenu == menu )
262             entry->SubMenu = NULL;
263 }
264
265 /*
266  * This function destroys a menu specified by the parameter. All menus
267  * and windows are updated to make sure no ill pointers hang around.
268  */
269 void fgDestroyMenu( SFG_Menu* menu )
270 {
271     SFG_Window *window;
272     SFG_Menu *from;
273
274     FREEGLUT_INTERNAL_ERROR_EXIT ( menu, "Menu destroy function called with null menu",
275                                    "fgDestroyMenu" );
276
277     /* First of all, have all references to this menu removed from all windows: */
278     for( window = (SFG_Window *)fgStructure.Windows.First;
279          window;
280          window = (SFG_Window *)window->Node.Next )
281         fghRemoveMenuFromWindow( window, menu );
282
283     /* Now proceed with removing menu entries that lead to this menu */
284     for( from = ( SFG_Menu * )fgStructure.Menus.First;
285          from;
286          from = ( SFG_Menu * )from->Node.Next )
287         fghRemoveMenuFromMenu( from, menu );
288
289     /*
290      * If the programmer defined a destroy callback, call it
291      * A. Donev: But first make this the active menu
292      */
293     if( menu->Destroy )
294     {
295         SFG_Menu *activeMenu=fgStructure.CurrentMenu;
296         fgStructure.CurrentMenu = menu;
297         menu->Destroy( );
298         fgStructure.CurrentMenu = activeMenu;
299     }
300
301     /*
302      * Now we are pretty sure the menu is not used anywhere
303      * and that we can remove all of its entries
304      */
305     while( menu->Entries.First )
306     {
307         SFG_MenuEntry *entry = ( SFG_MenuEntry * ) menu->Entries.First;
308
309         fgListRemove( &menu->Entries, &entry->Node );
310
311         if( entry->Text )
312             free( entry->Text );
313         entry->Text = NULL;
314
315         free( entry );
316     }
317
318     if( fgStructure.CurrentWindow == menu->Window )
319         fgSetWindow( NULL );
320     fgDestroyWindow( menu->Window );
321     fgListRemove( &fgStructure.Menus, &menu->Node );
322     if( fgStructure.CurrentMenu == menu )
323         fgStructure.CurrentMenu = NULL;
324
325     free( menu );
326 }
327
328 /*
329  * This function should be called on glutInit(). It will prepare the internal
330  * structure of freeglut to be used in the application. The structure will be
331  * destroyed using fgDestroyStructure() on glutMainLoop() return. In that
332  * case further use of freeglut should be preceeded with a glutInit() call.
333  */
334 void fgCreateStructure( void )
335 {
336     /*
337      * We will be needing two lists: the first containing windows,
338      * and the second containing the user-defined menus.
339      * Also, no current window/menu is set, as none has been created yet.
340      */
341
342     fgListInit(&fgStructure.Windows);
343     fgListInit(&fgStructure.Menus);
344     fgListInit(&fgStructure.WindowsToDestroy);
345
346     fgStructure.CurrentWindow = NULL;
347     fgStructure.CurrentMenu = NULL;
348     fgStructure.MenuContext = NULL;
349     fgStructure.GameMode = NULL;
350     fgStructure.WindowID = 0;
351     fgStructure.MenuID = 0;
352 }
353
354 /*
355  * This function is automatically called on glutMainLoop() return.
356  * It should deallocate and destroy all remnants of previous
357  * glutInit()-enforced structure initialization...
358  */
359 void fgDestroyStructure( void )
360 {
361     /* Clean up the WindowsToDestroy list. */
362     fgCloseWindows( );
363
364     /* Make sure all windows and menus have been deallocated */
365     while( fgStructure.Menus.First )
366         fgDestroyMenu( ( SFG_Menu * )fgStructure.Menus.First );
367
368     while( fgStructure.Windows.First )
369         fgDestroyWindow( ( SFG_Window * )fgStructure.Windows.First );
370 }
371
372 /*
373  * Helper function to enumerate through all registered top-level windows
374  */
375 void fgEnumWindows( FGCBenumerator enumCallback, SFG_Enumerator* enumerator )
376 {
377     SFG_Window *window;
378
379     FREEGLUT_INTERNAL_ERROR_EXIT ( enumCallback && enumerator,
380                                    "Enumerator or callback missing from window enumerator call",
381                                    "fgEnumWindows" );
382
383     /* Check every of the top-level windows */
384     for( window = ( SFG_Window * )fgStructure.Windows.First;
385          window;
386          window = ( SFG_Window * )window->Node.Next )
387     {
388         enumCallback( window, enumerator );
389         if( enumerator->found )
390             return;
391     }
392 }
393
394 /*
395  * Helper function to enumerate through all a window's subwindows
396  * (single level descent)
397  */
398 void fgEnumSubWindows( SFG_Window* window, FGCBenumerator enumCallback,
399                        SFG_Enumerator* enumerator )
400 {
401     SFG_Window *child;
402
403     FREEGLUT_INTERNAL_ERROR_EXIT ( enumCallback && enumerator,
404                                    "Enumerator or callback missing from subwindow enumerator call",
405                                    "fgEnumSubWindows" );
406     FREEGLUT_INTERNAL_ERROR_EXIT_IF_NOT_INITIALISED ( "Window Enumeration" );
407
408     for( child = ( SFG_Window * )window->Children.First;
409          child;
410          child = ( SFG_Window * )child->Node.Next )
411     {
412         enumCallback( child, enumerator );
413         if( enumerator->found )
414             return;
415     }
416 }
417
418 /*
419  * A static helper function to look for a window given its handle
420  */
421 static void fghcbWindowByHandle( SFG_Window *window,
422                                  SFG_Enumerator *enumerator )
423 {
424     if ( enumerator->found )
425         return;
426
427     /* Check the window's handle. Hope this works. Looks ugly. That's for sure. */
428     if( window->Window.Handle == (SFG_WindowHandleType) (enumerator->data) )
429     {
430         enumerator->found = GL_TRUE;
431         enumerator->data = window;
432
433         return;
434     }
435
436     /* Otherwise, check this window's children */
437     fgEnumSubWindows( window, fghcbWindowByHandle, enumerator );
438 }
439
440 /*
441  * fgWindowByHandle returns a (SFG_Window *) value pointing to the
442  * first window in the queue matching the specified window handle.
443  * The function is defined in freeglut_structure.c file.
444  */
445 SFG_Window* fgWindowByHandle ( SFG_WindowHandleType hWindow )
446 {
447     SFG_Enumerator enumerator;
448
449     /* This is easy and makes use of the windows enumeration defined above */
450     enumerator.found = GL_FALSE;
451     enumerator.data = (void *)hWindow;
452     fgEnumWindows( fghcbWindowByHandle, &enumerator );
453
454     if( enumerator.found )
455         return( SFG_Window *) enumerator.data;
456     return NULL;
457 }
458
459 /*
460  * A static helper function to look for a window given its ID
461  */
462 static void fghcbWindowByID( SFG_Window *window, SFG_Enumerator *enumerator )
463 {
464     /* Make sure we do not overwrite our precious results... */
465     if( enumerator->found )
466         return;
467
468     /* Check the window's handle. Hope this works. Looks ugly. That's for sure. */
469     if( window->ID == *( int *)(enumerator->data) )
470     {
471         enumerator->found = GL_TRUE;
472         enumerator->data = window;
473
474         return;
475     }
476
477     /* Otherwise, check this window's children */
478     fgEnumSubWindows( window, fghcbWindowByID, enumerator );
479 }
480
481 /*
482  * This function is similiar to the previous one, except it is
483  * looking for a specified (sub)window identifier. The function
484  * is defined in freeglut_structure.c file.
485  */
486 SFG_Window* fgWindowByID( int windowID )
487 {
488     SFG_Enumerator enumerator;
489
490     /* Uses a method very similiar for fgWindowByHandle... */
491     enumerator.found = GL_FALSE;
492     enumerator.data = ( void * )&windowID;
493     fgEnumWindows( fghcbWindowByID, &enumerator );
494     if( enumerator.found )
495         return ( SFG_Window * )enumerator.data;
496     return NULL;
497 }
498
499 /*
500  * Looks up a menu given its ID. This is easier that fgWindowByXXX
501  * as all menus are placed in one doubly linked list...
502  */
503 SFG_Menu* fgMenuByID( int menuID )
504 {
505     SFG_Menu *menu = NULL;
506
507     /* It's enough to check all entries in fgStructure.Menus... */
508     for( menu = (SFG_Menu *)fgStructure.Menus.First;
509          menu;
510          menu = (SFG_Menu *)menu->Node.Next )
511         if( menu->ID == menuID )
512             return menu;
513     return NULL;
514 }
515
516 /*
517  * List functions...
518  */
519 void fgListInit(SFG_List *list)
520 {
521     list->First = NULL;
522     list->Last = NULL;
523 }
524
525 void fgListAppend(SFG_List *list, SFG_Node *node)
526 {
527     if ( list->Last )
528     {
529         SFG_Node *ln = (SFG_Node *) list->Last;
530         ln->Next = node;
531         node->Prev = ln;
532     }
533     else
534     {
535         node->Prev = NULL;
536         list->First = node;
537     }
538
539     node->Next = NULL;
540     list->Last = node;
541 }
542
543 void fgListRemove(SFG_List *list, SFG_Node *node)
544 {
545     if( node->Next )
546         ( ( SFG_Node * )node->Next )->Prev = node->Prev;
547     if( node->Prev )
548         ( ( SFG_Node * )node->Prev )->Next = node->Next;
549     if( ( ( SFG_Node * )list->First ) == node )
550         list->First = node->Next;
551     if( ( ( SFG_Node * )list->Last ) == node )
552         list->Last = node->Prev;
553 }
554
555 int fgListLength(SFG_List *list)
556 {
557     SFG_Node *node;
558     int length = 0;
559
560     for( node =( SFG_Node * )list->First;
561          node;
562          node = ( SFG_Node * )node->Next )
563         ++length;
564
565     return length;
566 }
567
568
569 void fgListInsert(SFG_List *list, SFG_Node *next, SFG_Node *node)
570 {
571     SFG_Node *prev;
572
573     if( (node->Next = next) )
574     {
575         prev = next->Prev;
576         next->Prev = node;
577     }
578     else
579     {
580         prev = list->Last;
581         list->Last = node;
582     }
583
584     if( (node->Prev = prev) )
585         prev->Next = node;
586     else
587         list->First = node;
588 }
589
590 /*** END OF FILE ***/