X-Git-Url: http://git.mutantstargoat.com/user/nuclear/?a=blobdiff_plain;f=src%2Ffreeglut_structure.c;h=0824a3402fc5941371c8b2d27deacf9cb7024741;hb=2e8c8e1910a0f5a18c6108174bad31f13af38165;hp=da29757323d421c8637da7bfb658acd222807024;hpb=9b5ed2940eac112c894bb43f802fbda5b1c8b27a;p=freeglut

diff --git a/src/freeglut_structure.c b/src/freeglut_structure.c
index da29757..0824a34 100644
--- a/src/freeglut_structure.c
+++ b/src/freeglut_structure.c
@@ -29,8 +29,6 @@
 #include "config.h"
 #endif
 
-#define  G_LOG_DOMAIN  "freeglut-structure"
-
 #include "../include/GL/freeglut.h"
 #include "freeglut_internal.h"
 
@@ -54,13 +52,25 @@ SFG_Structure fgStructure = { { NULL, NULL },  /* The list of windows       */
 
 /* -- PRIVATE FUNCTIONS ---------------------------------------------------- */
 
+void fgClearCallBacks( SFG_Window *window )
+{
+    if( window )
+    {
+        int i;
+        for( i = 0; i < TOTAL_CALLBACKS; ++i )
+            window->CallBacks[ i ] = NULL;
+    }
+}
+
 /*
  * This private function creates, opens and adds to the hierarchy
  * a freeglut window complete with OpenGL context and stuff...
  *
  * If parent is set to NULL, the window created will be a topmost one.
  */
-SFG_Window* fgCreateWindow( SFG_Window* parent, const char* title, int x, int y, int w, int h, GLboolean gameMode )
+SFG_Window* fgCreateWindow( SFG_Window* parent, const char* title,
+                            int x, int y, int w, int h,
+                            GLboolean gameMode, GLboolean isMenu )
 {
     /*
      * Have the window object created
@@ -68,11 +78,13 @@ SFG_Window* fgCreateWindow( SFG_Window* parent, const char* title, int x, int y,
     SFG_Window *window = (SFG_Window *)calloc( sizeof(SFG_Window), 1 );
     int fakeArgc = 0;
 
+    fgClearCallBacks( window );
+
     /*
      * If the freeglut internals haven't been initialized yet,
      * do it now. Hack's idea courtesy of Chris Purnell...
      */
-    if( !fgState.Time.Set )
+    if( !fgState.Initalized )
         glutInit( &fakeArgc, NULL );
 
     /*
@@ -80,60 +92,39 @@ SFG_Window* fgCreateWindow( SFG_Window* parent, const char* title, int x, int y,
      */
     window->ID = ++fgStructure.WindowID;
 
-    /*
-     * Initialize the children list
-     */
     fgListInit( &window->Children );
-
-    /*
-     * Does this window have a parent?
-     */
     if( parent != NULL )
     {
-        /*
-         * That's quite right, attach this windows as a child window
-         */
-	fgListAppend( &parent->Children, &window->Node );
+        fgListAppend( &parent->Children, &window->Node );
         window->Parent = parent;
     }
     else
-    {
-        /*
-         * Otherwise add the newly created window to the topmost windows list
-         */
-	fgListAppend( &fgStructure.Windows, &window->Node );
-    }
+        fgListAppend( &fgStructure.Windows, &window->Node );
 
     /*
      * Set the default mouse cursor and reset the modifiers value
      */
     window->State.Cursor    = GLUT_CURSOR_INHERIT;
-    window->State.Modifiers = 0xffffffff;
 
-    /*
-     * If this window is a menu, set IsMenu in the structure
-     */
-    window->IsMenu = fgState.BuildingAMenu ;
+    window->IsMenu = isMenu;
 
     /*
      * Open the window now. The fgOpenWindow() function is system
      * dependant, and resides in freeglut_window.c. Uses fgState.
      */
-    fgOpenWindow( window, title, x, y, w, h, gameMode, (parent != NULL) ? TRUE : FALSE );
+    fgOpenWindow( window, title, x, y, w, h, gameMode,
+                  parent ? GL_TRUE : GL_FALSE );
 
-    /*
-     * Return a pointer to the newly created window
-     */
-    return( window );
+    return window;
 }
 
 /*
  * This private function creates a menu and adds it to the menus list
  */
-SFG_Menu* fgCreateMenu( FGCBmenu menuCallback )
+SFG_Menu* fgCreateMenu( FGCBMenu menuCallback )
 {
-  int x = 100, y = 100, w = 100, h = 100 ;
-  SFG_Window *current_window = fgStructure.Window ;
+    int x = 100, y = 100, w = 100, h = 100;
+    SFG_Window *current_window = fgStructure.Window;
 
     /*
      * Have the menu object created
@@ -145,46 +136,30 @@ SFG_Menu* fgCreateMenu( FGCBmenu menuCallback )
      * If the freeglut internals haven't been initialized yet,
      * do it now. Hack's idea courtesy of Chris Purnell...
      */
-    if( !fgState.Time.Set )
+    if( !fgState.Initalized )
         glutInit( &fakeArgc, NULL );
 
-    menu->ParentWindow = fgStructure.Window ;
+    menu->ParentWindow = fgStructure.Window;
 
     /*
-     * Create a window for the menu to reside in.  Set the
-     * global variable BuildingAMenu to true so we can ensure
-     * it is created without decorations.
+     * Create a window for the menu to reside in.
      */
-    fgState.BuildingAMenu = TRUE ;
 
-    fgCreateWindow ( NULL, NULL, x, y, w, h, FALSE ) ;
-    menu->Window = fgStructure.Window ;
-    glutDisplayFunc ( fgDisplayMenu ) ;
+    fgCreateWindow( NULL, NULL, x, y, w, h, GL_FALSE, GL_TRUE );
+    menu->Window = fgStructure.Window;
+    glutDisplayFunc( fgDisplayMenu );
 
-    /*
-     * While BuildingAMenu is true, all windows built have no decorations.  That's
-     * not a good default behavior, so let's set it false again.
-     */
-    fgState.BuildingAMenu = FALSE ;
-
-    glutHideWindow () ;  /* Hide the window for now */
-    fgStructure.Window = current_window ;
+    glutHideWindow( );  /* Hide the window for now */
+    fgSetWindow( current_window );
 
     /*
      * Initialize the object properties:
      */
     menu->ID       = ++fgStructure.MenuID;
     menu->Callback = menuCallback;
-    menu->ActiveEntry = NULL ;
+    menu->ActiveEntry = NULL;
 
-    /*
-     * Initialize the entries list
-     */
     fgListInit( &menu->Entries );
-
-    /*
-     * Add it to the menu structure hierarchy
-     */
     fgListAppend( &fgStructure.Menus, &menu->Node );
 
     /*
@@ -192,77 +167,103 @@ SFG_Menu* fgCreateMenu( FGCBmenu menuCallback )
      */
     fgStructure.Menu = menu;
 
-    /*
-     * Return the result to the caller
-     */
-    return( menu );
+    return menu;
 }
 
 /*
- * Linked list of windows to destroy ... this is so we don't destroy a window from the middle of
- * its callback.  Some C compilers take an extremely dim view of this.
+ * Linked list of windows to destroy ... this is so we don't destroy a
+ * window from the middle of its callback.  Some C compilers take an
+ * extremely dim view of this.
  */
 
-static SFG_WindowList* WindowsToDestroy = (SFG_WindowList*)NULL ;
+static SFG_WindowList* WindowsToDestroy = ( SFG_WindowList* )NULL;
 
 /*
- * Function to add a window to the linked list of windows to destroy.  Subwindows are automatically
- * added because they hang from the window structure.
+ * Function to add a window to the linked list of windows to destroy.
+ * Subwindows are automatically added because they hang from the window
+ * structure.
  */
-void fgAddToWindowDestroyList ( SFG_Window* window, GLboolean needToClose )
+void fgAddToWindowDestroyList( SFG_Window* window, GLboolean needToClose )
 {
-  SFG_WindowList *new_list_entry = (SFG_WindowList*)malloc ( sizeof(SFG_WindowList) ) ;
-  new_list_entry->window = window ;
-  new_list_entry->needToClose = needToClose ;
-  new_list_entry->next = WindowsToDestroy ;
-  WindowsToDestroy = new_list_entry ;
-
-  /*
-   * Check if the window is the current one...
-   */
-  if ( fgStructure.Window == window )
-    fgStructure.Window = NULL;
-
-  /*
-   * If the destroyed window has the highest window ID number, decrement the window ID number
-   */
-  if ( window->ID == fgStructure.WindowID ) fgStructure.WindowID-- ;
-
-  /*
-   * Check the execution state.  If this has been called from "glutDestroyWindow",
-   * a statement in that function will reset the "ExecState" after this function returns.
-   */
-  if ( fgState.ActionOnWindowClose != GLUT_ACTION_CONTINUE_EXECUTION )
-  {
-    /*
-     * Set the execution state flag to drop out of the main loop.
-     */
-    if ( fgState.ActionOnWindowClose == GLUT_ACTION_EXIT )
-      fgState.ExecState = GLUT_EXEC_STATE_STOP ;
-  }
+    SFG_WindowList *new_list_entry =
+        ( SFG_WindowList* )malloc( sizeof(SFG_WindowList ) );
+    new_list_entry->window = window;
+    new_list_entry->needToClose = needToClose;
+    new_list_entry->next = WindowsToDestroy;
+    WindowsToDestroy = new_list_entry;
+
+    /*
+     * Check if the window is the current one...
+     */
+    if( fgStructure.Window == window )
+        fgStructure.Window = NULL;
+
+    /*
+     * Clear all window callbacks except Destroy, which will
+     * be invoked later.  Right now, we are potentially carrying
+     * out a freeglut operation at the behest of a client callback,
+     * so we are reluctant to re-enter the client with the Destroy
+     * callback, right now.  The others are all wiped out, however,
+     * to ensure that they are no longer called after this point.
+     */
+    {
+        void *destroy = FETCH_WCB( *window, Destroy );
+        fgClearCallBacks( window );
+        FETCH_WCB( *window, Destroy ) = destroy;
+    }
+    
+
+    /*
+     * If the destroyed window has the highest window ID number, decrement
+     * the window ID number.
+     *
+     * XXX Do we REALLY want to *ever* recycle window IDs?  Integers are
+     * XXX plentiful, and clients may rely upon the implied promise in
+     * XXX the GLUT docs to not recycle these.  (I can't remember if it
+     * XXX is explicit.)
+     *
+     * XXX If we *do* want to do this, we should actually recompute the
+     * XXX highest window-ID; the new highest may not in fact be one less
+     * XXX than what we have just deleted.
+     */
+    if ( window->ID == fgStructure.WindowID )
+        fgStructure.WindowID--;
+
+    /*
+     * Check the execution state.  If this has been called from
+     * "glutDestroyWindow", a statement in that function will reset the
+     * "ExecState" after this function returns.
+     */
+    if( fgState.ActionOnWindowClose != GLUT_ACTION_CONTINUE_EXECUTION )
+        /*
+         * Set the execution state flag to drop out of the main loop.
+         */
+        if( fgState.ActionOnWindowClose == GLUT_ACTION_EXIT )
+            fgState.ExecState = GLUT_EXEC_STATE_STOP;
 }
 
 /*
  * Function to close down all the windows in the "WindowsToDestroy" list
  */
-void fgCloseWindows ()
+void fgCloseWindows( )
 {
-  SFG_WindowList *window_ptr = WindowsToDestroy ;
-  WindowsToDestroy = (SFG_WindowList*)NULL ;  /* In case the destroy callbacks cause more windows to be closed */
-
-  while ( window_ptr )
-  {
-    SFG_WindowList *next = window_ptr->next ;
-    fgDestroyWindow ( window_ptr->window, window_ptr->needToClose ) ;
-    free ( window_ptr ) ;
-    window_ptr = next ;
+    SFG_WindowList *window_ptr = WindowsToDestroy;
+    WindowsToDestroy = ( SFG_WindowList* )NULL;
+    /* In case the destroy callbacks cause more windows to be closed */
 
-    if ( !window_ptr )
+    while( window_ptr )
     {
-      window_ptr = WindowsToDestroy ;
-      WindowsToDestroy = (SFG_WindowList*)NULL ;
+        SFG_WindowList *next = window_ptr->next;
+        fgDestroyWindow( window_ptr->window, window_ptr->needToClose );
+        free( window_ptr );
+        window_ptr = next;
+
+        if( !window_ptr )
+        {
+            window_ptr = WindowsToDestroy;
+            WindowsToDestroy = ( SFG_WindowList* )NULL;
+        }
     }
-  }
 }
 
 /*
@@ -273,54 +274,46 @@ void fgCloseWindows ()
 void fgDestroyWindow( SFG_Window* window, GLboolean needToClose )
 {
     SFG_Window* subWindow;
+    int menu_index ;
 
-    assert( window != NULL );
+    assert( window );
     freeglut_assert_ready;
 
-    /*
-     * Does this window have any subwindows?
-     */
-    while ( (subWindow = (SFG_Window *)window->Children.First) != NULL )
-    {
-        /*
-         * Destroy the first window in the list (possibly destroying
-         * its subwindows too). This is not very effective, but works
-         */
+    while( subWindow = ( SFG_Window * )window->Children.First )
         fgDestroyWindow( subWindow, needToClose );
-    }
 
     /*
-     * If the programmer defined a destroy callback, call it
-     * A. Donev: But first make this the active window
+     * XXX Since INVOKE_WCB() tests the function pointer, why not make
+     * XXX this unconditional?  Overhead is close to nil, and it would
+     * XXX clarify the code by omitting a conditional test.
      */
-    if ( window->Callbacks.Destroy != NULL )
+    if( FETCH_WCB( *window, Destroy ) )
     {
-      SFG_Window *activeWindow = fgStructure.Window ;
-      fgStructure.Window = window ;
-      window->Callbacks.Destroy () ;
-      fgStructure.Window = activeWindow ;
+        SFG_Window *activeWindow = fgStructure.Window ;
+        INVOKE_WCB( *window, Destroy, ( ) );
+        fgSetWindow ( activeWindow ) ;
     }
 
-    /*
-     * Now we should remove the reference to this window from its parent
-     */
-    if ( window->Parent != NULL )
+    if( window->Parent )
         fgListRemove( &window->Parent->Children, &window->Node );
     else
         fgListRemove( &fgStructure.Windows, &window->Node );
 
-    /*
-     * OK, this window seems disconnected from the structure enough
-     * in order to be closed without any bigger risks...
-     */
-    if( needToClose == TRUE )
-        fgCloseWindow( window );
+    if( window->ActiveMenu )
+      fgDeactivateMenu( window );
 
-    /*
-     * Finally, we can delete the window's object. It hopefully does
-     * have everything inside it freed and we do not have to care...
-     */
+    for ( menu_index = 0; menu_index < 3; menu_index ++ )
+    {
+      if ( window->Menu[menu_index] != NULL )
+        window->Menu[menu_index]->ParentWindow = NULL ;
+    }
+
+    fgClearCallBacks( window );
+    if( needToClose )
+        fgCloseWindow( window );
     free( window );
+    if( fgStructure.Window == window )
+        fgStructure.Window = NULL;
 }
 
 /*
@@ -336,20 +329,17 @@ static void fghRemoveMenuFromWindow( SFG_Window* window, SFG_Menu* menu )
      * Check if the menu is attached to the current window,
      * if so, have it detached (by overwriting with a NULL):
      */
-    for( i=0; i<3; i++ )
-    {
+    for( i = 0; i < 3; i++ )
         if( window->Menu[ i ] == menu )
             window->Menu[ i ] = NULL;
-    }
 
     /*
      * Call this function for all of the window's children recursively:
      */
-    for( subWindow = (SFG_Window *)window->Children.First; subWindow;
+    for( subWindow = (SFG_Window *)window->Children.First;
+         subWindow;
          subWindow = (SFG_Window *)subWindow->Node.Next)
-    {
         fghRemoveMenuFromWindow( subWindow, menu );
-    }
 }
 
 /*
@@ -358,15 +348,13 @@ static void fghRemoveMenuFromWindow( SFG_Window* window, SFG_Menu* menu )
  */
 static void fghRemoveMenuFromMenu( SFG_Menu* from, SFG_Menu* menu )
 {
-  SFG_MenuEntry *entry;
+    SFG_MenuEntry *entry;
 
-  for( entry = (SFG_MenuEntry *)from->Entries.First; entry; entry = (SFG_MenuEntry *)entry->Node.Next )
-  {
-    if (entry->SubMenu == menu)
-    {
-      entry->SubMenu = NULL;
-    }
-  }
+    for( entry = (SFG_MenuEntry *)from->Entries.First;
+         entry;
+         entry = ( SFG_MenuEntry * )entry->Node.Next )
+        if( entry->SubMenu == menu )
+            entry->SubMenu = NULL;
 }
 
 /*
@@ -375,80 +363,65 @@ static void fghRemoveMenuFromMenu( SFG_Menu* from, SFG_Menu* menu )
  */
 void fgDestroyMenu( SFG_Menu* menu )
 {
-  SFG_Window *window;
-  SFG_Menu *from;
-  SFG_MenuEntry *entry;
-
-  assert( menu != NULL );
-  freeglut_assert_ready;
-
-  /*
-   * First of all, have all references to this menu removed from all windows:
-   */
-  for( window = (SFG_Window *)fgStructure.Windows.First; window; window = (SFG_Window *)window->Node.Next )
-  {
-    fghRemoveMenuFromWindow( window, menu );
-  }
-
-  /*
-   * Now proceed with removing menu entries that lead to this menu
-   */
-  for( from = (SFG_Menu *)fgStructure.Menus.First; from; from = (SFG_Menu *)from->Node.Next )
-  {
-    fghRemoveMenuFromMenu( from, menu );
-  }
-
-  /*
-   * If the programmer defined a destroy callback, call it
-   * A. Donev: But first make this the active menu
-   */    
-  if ( menu->Destroy != NULL )
-  {
-    SFG_Menu *activeMenu=fgStructure.Menu;
-    fgStructure.Menu = menu;    
-    menu->Destroy () ;  
-    fgStructure.Menu = activeMenu;     
-  }        
-
-  /*
-   * Now we are pretty sure the menu is not used anywhere
-   * and that we can remove all of its entries
-   */
-  while( (entry = (SFG_MenuEntry *)menu->Entries.First) != NULL )
-  {
-    fgListRemove(&menu->Entries, &entry->Node);
-
-    /*
-     * There might be a string allocated, have it freed:
-     */
-    free( entry->Text );
-
-    /*
-     * Deallocate the entry itself:
-     */
-    free( entry );
-  }
-
-  /*
-   * Destroy the window associated with the menu
-   */
-  fgDestroyWindow ( menu->Window, TRUE ) ;
-
-  /*
-   * Remove the menu from the menus list
-   */
-  fgListRemove( &fgStructure.Menus, &menu->Node );
-
-  /*
-   * If that menu was the current one...
-   */
-  if( fgStructure.Menu == menu )
-    fgStructure.Menu = NULL;
-
-  /*
-   * Have the menu structure freed
-   */
-  free( menu );
+    SFG_Window *window;
+    SFG_Menu *from;
+    SFG_MenuEntry *entry;
+
+    assert( menu );
+    freeglut_assert_ready;
+
+    /*
+     * First of all, have all references to this menu removed from all windows:
+     */
+    for( window = (SFG_Window *)fgStructure.Windows.First;
+         window;
+         window = (SFG_Window *)window->Node.Next )
+        fghRemoveMenuFromWindow( window, menu );
+
+    /*
+     * Now proceed with removing menu entries that lead to this menu
+     */
+    for( from = ( SFG_Menu * )fgStructure.Menus.First;
+         from;
+         from = ( SFG_Menu * )from->Node.Next )
+        fghRemoveMenuFromMenu( from, menu );
+
+    /*
+     * If the programmer defined a destroy callback, call it
+     * A. Donev: But first make this the active menu
+     */
+    if( menu->Destroy )
+    {
+        SFG_Menu *activeMenu=fgStructure.Menu;
+        fgStructure.Menu = menu;
+        menu->Destroy( );
+        fgStructure.Menu = activeMenu;
+    }
+
+    /*
+     * Now we are pretty sure the menu is not used anywhere
+     * and that we can remove all of its entries
+     */
+    while( entry = ( SFG_MenuEntry * )menu->Entries.First )
+    {
+        fgListRemove( &menu->Entries, &entry->Node );
+
+        if( entry->Text )
+            free( entry->Text );
+        entry->Text = NULL;
+
+        free( entry );
+        entry = NULL;
+    }
+
+    if( fgStructure.Window == menu->Window )
+        fgSetWindow( menu->ParentWindow );
+    fgDestroyWindow( menu->Window, GL_TRUE );
+    fgListRemove( &fgStructure.Menus, &menu->Node );
+    if( fgStructure.Menu == menu )
+        fgStructure.Menu = NULL;
+
+    free( menu );
 }
 
 /*
@@ -459,38 +432,36 @@ void fgDestroyMenu( SFG_Menu* menu )
  */
 void fgCreateStructure( void )
 {
-  /*
-   * We will be needing two lists: the first containing windows,
-   * and the second containing the user-defined menus.
-   * Also, no current window/menu is set, as none has been created yet.
-   */
-
-  fgListInit(&fgStructure.Windows);
-  fgListInit(&fgStructure.Menus);
+    /*
+     * We will be needing two lists: the first containing windows,
+     * and the second containing the user-defined menus.
+     * Also, no current window/menu is set, as none has been created yet.
+     */
+
+    fgListInit(&fgStructure.Windows);
+    fgListInit(&fgStructure.Menus);
 }
 
 /*
- * This function is automatically called on glutMainLoop() return. It should deallocate 
- * and destroy all remnants of previous glutInit()-enforced structure initialization...
+ * This function is automatically called on glutMainLoop() return.
+ * It should deallocate and destroy all remnants of previous
+ * glutInit()-enforced structure initialization...
  */
 void fgDestroyStructure( void )
 {
-  SFG_Window *window;
-  SFG_Menu *menu;
-
-  /*
-   * Just make sure we are not called in vain...
-   */
-  freeglut_assert_ready;
-
-  /*
-   * Make sure all windows and menus have been deallocated
-   */
-  while( (window = (SFG_Window *)fgStructure.Windows.First) != NULL )
-    fgDestroyWindow( window, TRUE );
-
-  while( (menu = (SFG_Menu *)fgStructure.Menus.First) != NULL )
-    fgDestroyMenu( menu );
+    SFG_Window *window;
+    SFG_Menu *menu;
+
+    freeglut_assert_ready;
+
+    /*
+     * Make sure all windows and menus have been deallocated
+     */
+    while( menu = ( SFG_Menu * )fgStructure.Menus.First )
+        fgDestroyMenu( menu );
+
+    while( window = ( SFG_Window * )fgStructure.Windows.First )
+        fgDestroyWindow( window, GL_TRUE );
 }
 
 /*
@@ -498,67 +469,54 @@ void fgDestroyStructure( void )
  */
 void fgEnumWindows( FGCBenumerator enumCallback, SFG_Enumerator* enumerator )
 {
-  SFG_Window *window;
+    SFG_Window *window;
 
-  assert( (enumCallback != NULL) && (enumerator != NULL) );
-  freeglut_assert_ready;
-
-  /*
-   * Check every of the top-level windows
-   */
-  for( window = (SFG_Window *)fgStructure.Windows.First; window;
-       window = (SFG_Window *)window->Node.Next )
-  {
-    /*
-     * Execute the callback...
-     */
-    enumCallback( window, enumerator );
+    assert( enumCallback && enumerator );
+    freeglut_assert_ready;
 
     /*
-     * If it has been marked as 'found', stop searching
+     * Check every of the top-level windows
      */
-    if( enumerator->found == TRUE )
-      return;
-  }
+    for( window = ( SFG_Window * )fgStructure.Windows.First;
+         window;
+         window = ( SFG_Window * )window->Node.Next )
+    {
+        enumCallback( window, enumerator );
+        if( enumerator->found )
+            return;
+    }
 }
 
 /*
- * Helper function to enumerate through all a window's subwindows (single level descent)
+ * Helper function to enumerate through all a window's subwindows
+ * (single level descent)
  */
-void fgEnumSubWindows( SFG_Window* window, FGCBenumerator enumCallback, SFG_Enumerator* enumerator )
+void fgEnumSubWindows( SFG_Window* window, FGCBenumerator enumCallback,
+                       SFG_Enumerator* enumerator )
 {
-  SFG_Window *child;
+    SFG_Window *child;
 
-  assert( (enumCallback != NULL) && (enumerator != NULL) );
-  freeglut_assert_ready;
-
-  /*
-   * Check every of the window's children:
-   */
-  for( child = (SFG_Window *)window->Children.First; child; child = (SFG_Window *)child->Node.Next )
-  {
-    /*
-     * Execute the callback...
-     */
-    enumCallback( child, enumerator );
+    assert( enumCallback && enumerator );
+    freeglut_assert_ready;
 
-    /*
-     * If it has been marked as 'found', stop searching
-     */
-    if( enumerator->found == TRUE )
-      return;
-  }
+    for( child = ( SFG_Window * )window->Children.First;
+         child;
+         child = ( SFG_Window * )child->Node.Next )
+    {
+        enumCallback( child, enumerator );
+        if( enumerator->found )
+            return;
+    }
 }
 
 /*
  * A static helper function to look for a window given its handle
  */
-static void fghcbWindowByHandle( SFG_Window *window, SFG_Enumerator *enumerator )
+static void fghcbWindowByHandle( SFG_Window *window,
+                                 SFG_Enumerator *enumerator )
 {
-    /*
-     * Make sure we do not overwrite our precious results...
-     */
-    freeglut_return_if_fail( enumerator->found == FALSE );
+    if ( enumerator->found )
+        return;
 
 #if TARGET_HOST_UNIX_X11
     #define WBHANDLE (Window)
@@ -571,7 +529,7 @@ static void fghcbWindowByHandle( SFG_Window *window, SFG_Enumerator *enumerator
      */
     if( window->Window.Handle == WBHANDLE (enumerator->data) )
     {
-        enumerator->found = TRUE;
+        enumerator->found = GL_TRUE;
         enumerator->data = window;
 
         return;
@@ -602,24 +560,13 @@ SFG_Window* fgWindowByHandle
     /*
      * This is easy and makes use of the windows enumeration defined above
      */
-    enumerator.found = FALSE;
+    enumerator.found = GL_FALSE;
     enumerator.data = (void *)hWindow;
-
-    /*
-     * Start the enumeration now:
-     */
     fgEnumWindows( fghcbWindowByHandle, &enumerator );
 
-    /*
-     * Check if the window has been found or not:
-     */
-    if( enumerator.found == TRUE )
-        return( (SFG_Window *) enumerator.data );
-
-    /*
-     * Otherwise return NULL to mark the failure
-     */
-    return( NULL );
+    if( enumerator.found )
+        return( SFG_Window *) enumerator.data;
+    return NULL;
 }
 
 /*
@@ -630,14 +577,15 @@ static void fghcbWindowByID( SFG_Window *window, SFG_Enumerator *enumerator )
     /*
      * Make sure we do not overwrite our precious results...
      */
-    freeglut_return_if_fail( enumerator->found == FALSE );
+    if ( enumerator->found )
+        return;
 
     /*
      * Check the window's handle. Hope this works. Looks ugly. That's for sure.
      */
-    if( window->ID == (int) (enumerator->data) )
+    if( window->ID == (int) (enumerator->data) ) /* XXX int/ptr conversion! */
     {
-        enumerator->found = TRUE;
+        enumerator->found = GL_TRUE;
         enumerator->data = window;
 
         return;
@@ -661,24 +609,12 @@ SFG_Window* fgWindowByID( int windowID )
     /*
      * Uses a method very similiar for fgWindowByHandle...
      */
-    enumerator.found = FALSE;
-    enumerator.data = (void *) windowID;
-
-    /*
-     * Start the enumeration now:
-     */
+    enumerator.found = GL_FALSE;
+    enumerator.data = (void *) windowID; /* XXX int/pointer conversion! */
     fgEnumWindows( fghcbWindowByID, &enumerator );
-
-    /*
-     * Check if the window has been found or not:
-     */
-    if( enumerator.found == TRUE )
-        return( (SFG_Window *) enumerator.data );
-
-    /*
-     * Otherwise return NULL to mark the failure
-     */
-    return( NULL );
+    if( enumerator.found )
+        return( SFG_Window *) enumerator.data;
+    return NULL;
 }
 
 /*
@@ -694,19 +630,12 @@ SFG_Menu* fgMenuByID( int menuID )
     /*
      * It's enough to check all entries in fgStructure.Menus...
      */
-    for( menu = (SFG_Menu *)fgStructure.Menus.First; menu; menu = (SFG_Menu *)menu->Node.Next )
-    {
-        /*
-         * Does the ID number match?
-         */
+    for( menu = (SFG_Menu *)fgStructure.Menus.First;
+         menu;
+         menu = (SFG_Menu *)menu->Node.Next )
         if( menu->ID == menuID )
-            return( menu );
-    }
-
-    /*
-     * We have not found the requested menu ID
-     */
-    return( NULL );
+            return menu;
+    return NULL;
 }
 
 /*
@@ -741,13 +670,13 @@ void fgListRemove(SFG_List *list, SFG_Node *node)
 {
     SFG_Node *ln;
 
-    if ( (ln = (SFG_Node *)node->Next) != NULL )
+    if( ln = (SFG_Node *)node->Next )
         ln->Prev = node->Prev;
-    if ( (ln = (SFG_Node *)node->Prev) != NULL )
+    if( ln = (SFG_Node *)node->Prev )
         ln->Next = node->Next;
-    if ( (ln = (SFG_Node *)list->First) == node )
+    if( ( ln = (SFG_Node *)list->First ) == node )
         list->First = node->Next;
-    if ( (ln = (SFG_Node *)list->Last) == node )
+    if( ( ln = (SFG_Node *)list->Last ) == node )
         list->Last = node->Prev;
 }
 
@@ -756,10 +685,12 @@ int fgListLength(SFG_List *list)
     SFG_Node *node;
     int length = 0;
 
-    for( node = (SFG_Node *)list->First; node; node = (SFG_Node *)node->Next )
+    for( node =( SFG_Node * )list->First;
+         node;
+         node = ( SFG_Node * )node->Next )
         ++length;
 
-    return( length );
+    return length;
 }
 
 /*** END OF FILE ***/