SFG_Structure fgStructure = { { NULL, NULL }, /* The list of windows */
{ NULL, NULL }, /* The list of menus */
+ { NULL, NULL }, /* Windows to Destroy list */
NULL, /* The current window */
NULL, /* The current menu */
NULL, /* The menu OpenGL context */
* 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 )
+ int x, int y, int w, int h,
+ GLboolean gameMode, GLboolean isMenu )
{
/*
* Have the window object created
* 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.Initialised )
glutInit( &fakeArgc, NULL );
/*
* Initialize the object properties
*/
window->ID = ++fgStructure.WindowID;
+ window->State.OldHeight = window->State.OldWidth = -1;
fgListInit( &window->Children );
- if( parent != NULL )
+ if( parent )
{
fgListAppend( &parent->Children, &window->Node );
window->Parent = parent;
* Set the default mouse cursor and reset the modifiers value
*/
window->State.Cursor = GLUT_CURSOR_INHERIT;
- window->State.Modifiers = 0xffffffff;
- 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 );
+ parent ? GL_TRUE : GL_FALSE );
return 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.Initialised )
glutInit( &fakeArgc, NULL );
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 );
+ 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 */
fgSetWindow( current_window );
}
/*
- * 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;
-
-/*
* 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 )
{
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;
+ fgListAppend( &fgStructure.WindowsToDestroy, &new_list_entry->node );
/*
* Check if the window is the current one...
{
void *destroy = FETCH_WCB( *window, Destroy );
fgClearCallBacks( window );
- FETCH_WCB( *window, Destroy ) = destroy;
+ SET_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;
}
/*
*/
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 )
+ while( fgStructure.WindowsToDestroy.First )
{
- SFG_WindowList *next = window_ptr->next;
- fgDestroyWindow( window_ptr->window, window_ptr->needToClose );
+ SFG_WindowList *window_ptr = fgStructure.WindowsToDestroy.First;
+ fgDestroyWindow( window_ptr->window );
+ fgListRemove( &fgStructure.WindowsToDestroy, &window_ptr->node );
free( window_ptr );
- window_ptr = next;
-
- if( !window_ptr )
- {
- window_ptr = WindowsToDestroy;
- WindowsToDestroy = ( SFG_WindowList* )NULL;
- }
}
}
* another function, defined in freeglut_window.c is called, but this is
* a whole different story...
*/
-void fgDestroyWindow( SFG_Window* window, GLboolean needToClose )
+void fgDestroyWindow( SFG_Window* window )
{
- SFG_Window* subWindow;
- int menu_index ;
+ int menu_index;
assert( window );
freeglut_assert_ready;
- while( subWindow = ( SFG_Window * )window->Children.First )
- fgDestroyWindow( subWindow, needToClose );
+ while( window->Children.First )
+ fgDestroyWindow( ( SFG_Window * )window->Children.First );
- /*
- * 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( FETCH_WCB( *window, Destroy ) )
{
- SFG_Window *activeWindow = fgStructure.Window ;
+ SFG_Window *activeWindow = fgStructure.Window;
INVOKE_WCB( *window, Destroy, ( ) );
- fgSetWindow ( activeWindow ) ;
+ fgSetWindow( activeWindow );
}
if( window->Parent )
if( window->ActiveMenu )
fgDeactivateMenu( window );
- for ( menu_index = 0; menu_index < 3; menu_index ++ )
- {
- if ( window->Menu[menu_index] != NULL )
- window->Menu[menu_index]->ParentWindow = NULL ;
- }
+ for( menu_index = 0; menu_index < 3; menu_index ++ )
+ if( window->Menu[ menu_index ] )
+ window->Menu[ menu_index ]->ParentWindow = NULL;
fgClearCallBacks( window );
- if( needToClose == TRUE )
- fgCloseWindow( window );
+ fgCloseWindow( window );
free( window );
if( fgStructure.Window == window )
fgStructure.Window = NULL;
if( fgStructure.Window == menu->Window )
fgSetWindow( menu->ParentWindow );
- fgDestroyWindow( menu->Window, TRUE );
+ fgDestroyWindow( menu->Window );
fgListRemove( &fgStructure.Menus, &menu->Node );
if( fgStructure.Menu == menu )
fgStructure.Menu = NULL;
fgListInit(&fgStructure.Windows);
fgListInit(&fgStructure.Menus);
+ fgListInit(&fgStructure.WindowsToDestroy);
}
/*
*/
void fgDestroyStructure( void )
{
- SFG_Window *window;
- SFG_Menu *menu;
-
freeglut_assert_ready;
/*
- * Make sure all windows and menus have been deallocated
+ * Clean up the WindowsToDestroy list.
*/
- while( menu = ( SFG_Menu * )fgStructure.Menus.First )
- fgDestroyMenu( menu );
+ fgCloseWindows( );
- while( window = ( SFG_Window * )fgStructure.Windows.First )
- fgDestroyWindow( window, TRUE );
+ /*
+ * Make sure all windows and menus have been deallocated
+ */
+ while( fgStructure.Menus.First )
+ fgDestroyMenu( ( SFG_Menu * )fgStructure.Menus.First );
+
+ while( fgStructure.Windows.First )
+ fgDestroyWindow( ( SFG_Window * )fgStructure.Windows.First );
}
/*
window = ( SFG_Window * )window->Node.Next )
{
enumCallback( window, enumerator );
- if( enumerator->found == TRUE )
+ if( enumerator->found )
return;
}
}
child = ( SFG_Window * )child->Node.Next )
{
enumCallback( child, enumerator );
- if( enumerator->found == TRUE )
+ if( enumerator->found )
return;
}
}
static void fghcbWindowByHandle( SFG_Window *window,
SFG_Enumerator *enumerator )
{
- freeglut_return_if_fail( enumerator->found == FALSE );
-
-#if TARGET_HOST_UNIX_X11
- #define WBHANDLE (Window)
-#elif TARGET_HOST_WIN32
- #define WBHANDLE (HWND)
-#endif
+ if ( enumerator->found )
+ return;
/*
* Check the window's handle. Hope this works. Looks ugly. That's for sure.
*/
- if( window->Window.Handle == WBHANDLE (enumerator->data) )
+ if( window->Window.Handle == (SFG_WindowHandleType) (enumerator->data) )
{
- enumerator->found = TRUE;
+ enumerator->found = GL_TRUE;
enumerator->data = window;
return;
* Otherwise, check this window's children
*/
fgEnumSubWindows( window, fghcbWindowByHandle, enumerator );
-
-#undef WBHANDLE
}
/*
* first window in the queue matching the specified window handle.
* The function is defined in freeglut_structure.c file.
*/
-SFG_Window* fgWindowByHandle
-#if TARGET_HOST_UNIX_X11
-( Window hWindow )
-#elif TARGET_HOST_WIN32
-( HWND hWindow )
-#endif
+SFG_Window* fgWindowByHandle ( SFG_WindowHandleType hWindow )
{
SFG_Enumerator enumerator;
/*
* This is easy and makes use of the windows enumeration defined above
*/
- enumerator.found = FALSE;
+ enumerator.found = GL_FALSE;
enumerator.data = (void *)hWindow;
fgEnumWindows( fghcbWindowByHandle, &enumerator );
- if( enumerator.found == TRUE )
+ if( enumerator.found )
return( SFG_Window *) enumerator.data;
return NULL;
}
/*
* 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) ) /* XXX int/ptr conversion! */
+ if( window->ID == *( int *)(enumerator->data) )
{
- enumerator->found = TRUE;
+ enumerator->found = GL_TRUE;
enumerator->data = window;
return;
/*
* Uses a method very similiar for fgWindowByHandle...
*/
- enumerator.found = FALSE;
- enumerator.data = (void *) windowID; /* XXX int/pointer conversion! */
+ enumerator.found = GL_FALSE;
+ enumerator.data = ( void * )&windowID;
fgEnumWindows( fghcbWindowByID, &enumerator );
- if( enumerator.found == TRUE )
- return( SFG_Window *) enumerator.data;
+ if( enumerator.found )
+ return ( SFG_Window * )enumerator.data;
return NULL;
}
{
SFG_Node *ln;
- if ( (ln = (SFG_Node *)list->Last) != NULL )
+ if ( ln = (SFG_Node *)list->Last )
{
ln->Next = node;
node->Prev = ln;
ln->Prev = node->Prev;
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;
}
return length;
}
+
+void fgListInsert(SFG_List *list, SFG_Node *next, SFG_Node *node)
+{
+ SFG_Node *prev;
+
+ if( (node->Next = next) )
+ {
+ prev = next->Prev;
+ next->Prev = node;
+ }
+ else
+ {
+ prev = list->Last;
+ list->Last = node;
+ }
+
+ if( (node->Prev = prev) )
+ prev->Next = node;
+ else
+ list->First = node;
+}
+
/*** END OF FILE ***/
projects / freeglut / blobdiff