FMudanyali/FreeGLUT-Vita
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Hm. I thought that I already hit this file for style normalization.

Browse Source 
Oh well...  Should be no functional changes.  Should be pretty
close to in-line with the style of changes that I've been making else-
where.


git-svn-id: https://svn.code.sf.net/p/freeglut/code/trunk@331 7f0cb862-5218-0410-a997-914c9d46530a
This commit is contained in:
rkrolib 2003-11-10 10:00:21 +00:00
parent 1023b7eb84
commit 9623350767
1 changed files with 133 additions and 130 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

261
freeglut/freeglut/src/freeglut_structure.c
View File

@ -120,8 +120,8 @@ SFG_Window* fgCreateWindow( SFG_Window* parent, const char* title,
*/ */
SFG_Menu* fgCreateMenu( FGCBMenu menuCallback ) SFG_Menu* fgCreateMenu( FGCBMenu menuCallback )
{ {
int x = 100, y = 100, w = 100, h = 100 ; int x = 100, y = 100, w = 100, h = 100;
SFG_Window *current_window = fgStructure.Window ; SFG_Window *current_window = fgStructure.Window;
/* /*
* Have the menu object created * Have the menu object created
@ -136,34 +136,34 @@ SFG_Menu* fgCreateMenu( FGCBMenu menuCallback )
if( !fgState.Time.Set ) if( !fgState.Time.Set )
glutInit( &fakeArgc, NULL ); glutInit( &fakeArgc, NULL );
menu->ParentWindow = fgStructure.Window ; menu->ParentWindow = fgStructure.Window;
/* /*
* Create a window for the menu to reside in. Set the * Create a window for the menu to reside in. Set the
* global variable BuildingAMenu to true so we can ensure * global variable BuildingAMenu to true so we can ensure
* it is created without decorations. * it is created without decorations.
*/ */
fgState.BuildingAMenu = TRUE ; fgState.BuildingAMenu = TRUE;
fgCreateWindow ( NULL, NULL, x, y, w, h, FALSE ) ; fgCreateWindow( NULL, NULL, x, y, w, h, FALSE );
menu->Window = fgStructure.Window ; menu->Window = fgStructure.Window;
glutDisplayFunc ( fgDisplayMenu ) ; glutDisplayFunc( fgDisplayMenu );
/* /*
* While BuildingAMenu is true, all windows built have no decorations. * While BuildingAMenu is true, all windows built have no decorations.
* That's not a good default behavior, so let's set it false again. * That's not a good default behavior, so let's set it false again.
*/ */
fgState.BuildingAMenu = FALSE ; fgState.BuildingAMenu = FALSE;
glutHideWindow () ; /* Hide the window for now */ glutHideWindow( ); /* Hide the window for now */
fgSetWindow ( current_window ) ; fgSetWindow( current_window );
/* /*
* Initialize the object properties: * Initialize the object properties:
*/ */
menu->ID = ++fgStructure.MenuID; menu->ID = ++fgStructure.MenuID;
menu->Callback = menuCallback; menu->Callback = menuCallback;
menu->ActiveEntry = NULL ; menu->ActiveEntry = NULL;
fgListInit( &menu->Entries ); fgListInit( &menu->Entries );
fgListAppend( &fgStructure.Menus, &menu->Node ); fgListAppend( &fgStructure.Menus, &menu->Node );
@ -182,14 +182,14 @@ SFG_Menu* fgCreateMenu( FGCBMenu menuCallback )
* extremely dim view of this. * 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. * Function to add a window to the linked list of windows to destroy.
* Subwindows are automatically added because they hang from the window * Subwindows are automatically added because they hang from the window
* structure. * structure.
*/ */
void fgAddToWindowDestroyList ( SFG_Window* window, GLboolean needToClose ) void fgAddToWindowDestroyList( SFG_Window* window, GLboolean needToClose )
{ {
SFG_WindowList *new_list_entry = SFG_WindowList *new_list_entry =
( SFG_WindowList* )malloc( sizeof(SFG_WindowList ) ); ( SFG_WindowList* )malloc( sizeof(SFG_WindowList ) );
@ -282,10 +282,10 @@ void fgDestroyWindow( SFG_Window* window, GLboolean needToClose )
SFG_Window* subWindow; SFG_Window* subWindow;
int menu_index ; int menu_index ;
assert( window != NULL ); assert( window );
freeglut_assert_ready; freeglut_assert_ready;
while ( (subWindow = (SFG_Window *)window->Children.First) != NULL ) while( subWindow = ( SFG_Window * )window->Children.First )
fgDestroyWindow( subWindow, needToClose ); fgDestroyWindow( subWindow, needToClose );
/* /*
@ -293,20 +293,20 @@ void fgDestroyWindow( SFG_Window* window, GLboolean needToClose )
* XXX this unconditional? Overhead is close to nil, and it would * XXX this unconditional? Overhead is close to nil, and it would
* XXX clarify the code by omitting a conditional test. * XXX clarify the code by omitting a conditional test.
*/ */
if ( FETCH_WCB( *window, Destroy ) ) if( FETCH_WCB( *window, Destroy ) )
{ {
SFG_Window *activeWindow = fgStructure.Window ; SFG_Window *activeWindow = fgStructure.Window ;
INVOKE_WCB( *window, Destroy, ( ) ); INVOKE_WCB( *window, Destroy, ( ) );
fgSetWindow ( activeWindow ) ; fgSetWindow ( activeWindow ) ;
} }
if ( window->Parent != NULL ) if( window->Parent )
fgListRemove( &window->Parent->Children, &window->Node ); fgListRemove( &window->Parent->Children, &window->Node );
else else
fgListRemove( &fgStructure.Windows, &window->Node ); fgListRemove( &fgStructure.Windows, &window->Node );
if ( window->ActiveMenu != NULL ) if( window->ActiveMenu )
fgDeactivateMenu ( window ) ; fgDeactivateMenu( window );
for ( menu_index = 0; menu_index < 3; menu_index ++ ) for ( menu_index = 0; menu_index < 3; menu_index ++ )
{ {
@ -317,8 +317,8 @@ void fgDestroyWindow( SFG_Window* window, GLboolean needToClose )
if( needToClose == TRUE ) if( needToClose == TRUE )
fgCloseWindow( window ); fgCloseWindow( window );
free( window ); free( window );
if ( fgStructure.Window == window ) if( fgStructure.Window == window )
fgStructure.Window = NULL ; fgStructure.Window = NULL;
fgClearCallBacks( window ); fgClearCallBacks( window );
} }
@ -335,14 +335,15 @@ static void fghRemoveMenuFromWindow( SFG_Window* window, SFG_Menu* menu )
* Check if the menu is attached to the current window, * Check if the menu is attached to the current window,
* if so, have it detached (by overwriting with a NULL): * 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 ) if( window->Menu[ i ] == menu )
window->Menu[ i ] = NULL; window->Menu[ i ] = NULL;
/* /*
* Call this function for all of the window's children recursively: * 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) subWindow = (SFG_Window *)subWindow->Node.Next)
fghRemoveMenuFromWindow( subWindow, menu ); fghRemoveMenuFromWindow( subWindow, menu );
} }
@ -353,13 +354,13 @@ static void fghRemoveMenuFromWindow( SFG_Window* window, SFG_Menu* menu )
*/ */
static void fghRemoveMenuFromMenu( SFG_Menu* from, 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; for( entry = (SFG_MenuEntry *)from->Entries.First;
entry; entry;
entry = (SFG_MenuEntry *)entry->Node.Next ) entry = ( SFG_MenuEntry * )entry->Node.Next )
if (entry->SubMenu == menu) if( entry->SubMenu == menu )
entry->SubMenu = NULL; entry->SubMenu = NULL;
} }
/* /*
@ -368,65 +369,65 @@ static void fghRemoveMenuFromMenu( SFG_Menu* from, SFG_Menu* menu )
*/ */
void fgDestroyMenu( SFG_Menu* menu ) void fgDestroyMenu( SFG_Menu* menu )
{ {
SFG_Window *window; SFG_Window *window;
SFG_Menu *from; SFG_Menu *from;
SFG_MenuEntry *entry; SFG_MenuEntry *entry;
assert( menu != NULL ); assert( menu );
freeglut_assert_ready; freeglut_assert_ready;
/* /*
* First of all, have all references to this menu removed from all windows: * First of all, have all references to this menu removed from all windows:
*/ */
for( window = (SFG_Window *)fgStructure.Windows.First; for( window = (SFG_Window *)fgStructure.Windows.First;
window; window;
window = (SFG_Window *)window->Node.Next ) window = (SFG_Window *)window->Node.Next )
fghRemoveMenuFromWindow( window, menu ); fghRemoveMenuFromWindow( window, menu );
/* /*
* Now proceed with removing menu entries that lead to this menu * Now proceed with removing menu entries that lead to this menu
*/ */
for( from = (SFG_Menu *)fgStructure.Menus.First; for( from = ( SFG_Menu * )fgStructure.Menus.First;
from; from;
from = (SFG_Menu *)from->Node.Next ) from = ( SFG_Menu * )from->Node.Next )
fghRemoveMenuFromMenu( from, menu ); fghRemoveMenuFromMenu( from, menu );
/* /*
* If the programmer defined a destroy callback, call it * If the programmer defined a destroy callback, call it
* A. Donev: But first make this the active menu * A. Donev: But first make this the active menu
*/ */
if ( menu->Destroy != NULL ) if( menu->Destroy )
{ {
SFG_Menu *activeMenu=fgStructure.Menu; SFG_Menu *activeMenu=fgStructure.Menu;
fgStructure.Menu = menu; fgStructure.Menu = menu;
menu->Destroy () ; menu->Destroy( );
fgStructure.Menu = activeMenu; fgStructure.Menu = activeMenu;
} }
/* /*
* Now we are pretty sure the menu is not used anywhere * Now we are pretty sure the menu is not used anywhere
* and that we can remove all of its entries * and that we can remove all of its entries
*/ */
while( (entry = (SFG_MenuEntry *)menu->Entries.First) != NULL ) while( entry = ( SFG_MenuEntry * )menu->Entries.First )
{ {
fgListRemove(&menu->Entries, &entry->Node); fgListRemove( &menu->Entries, &entry->Node );
if( entry->Text ) if( entry->Text )
free( entry->Text ); free( entry->Text );
entry->Text = NULL; entry->Text = NULL;
free( entry ); free( entry );
entry = NULL; entry = NULL;
} }
if ( fgStructure.Window == menu->Window ) if( fgStructure.Window == menu->Window )
fgSetWindow ( menu->ParentWindow ) ; fgSetWindow( menu->ParentWindow );
fgDestroyWindow ( menu->Window, TRUE ) ; fgDestroyWindow( menu->Window, TRUE );
fgListRemove( &fgStructure.Menus, &menu->Node ); fgListRemove( &fgStructure.Menus, &menu->Node );
if( fgStructure.Menu == menu ) if( fgStructure.Menu == menu )
fgStructure.Menu = NULL; fgStructure.Menu = NULL;
free( menu ); free( menu );
} }
/* /*
@ -437,14 +438,14 @@ void fgDestroyMenu( SFG_Menu* menu )
*/ */
void fgCreateStructure( void ) void fgCreateStructure( void )
{ {
/* /*
* We will be needing two lists: the first containing windows, * We will be needing two lists: the first containing windows,
* and the second containing the user-defined menus. * and the second containing the user-defined menus.
* Also, no current window/menu is set, as none has been created yet. * Also, no current window/menu is set, as none has been created yet.
*/ */
fgListInit(&fgStructure.Windows); fgListInit(&fgStructure.Windows);
fgListInit(&fgStructure.Menus); fgListInit(&fgStructure.Menus);
} }
/* /*
@ -454,19 +455,19 @@ void fgCreateStructure( void )
*/ */
void fgDestroyStructure( void ) void fgDestroyStructure( void )
{ {
SFG_Window *window; SFG_Window *window;
SFG_Menu *menu; SFG_Menu *menu;
freeglut_assert_ready; freeglut_assert_ready;
/* /*
* Make sure all windows and menus have been deallocated * Make sure all windows and menus have been deallocated
*/ */
while( (menu = (SFG_Menu *)fgStructure.Menus.First) != NULL ) while( menu = ( SFG_Menu * )fgStructure.Menus.First )
fgDestroyMenu( menu ); fgDestroyMenu( menu );
while( (window = (SFG_Window *)fgStructure.Windows.First) != NULL ) while( window = ( SFG_Window * )fgStructure.Windows.First )
fgDestroyWindow( window, TRUE ); fgDestroyWindow( window, TRUE );
} }
/* /*
@ -474,22 +475,22 @@ void fgDestroyStructure( void )
*/ */
void fgEnumWindows( FGCBenumerator enumCallback, SFG_Enumerator* enumerator ) void fgEnumWindows( FGCBenumerator enumCallback, SFG_Enumerator* enumerator )
{ {
SFG_Window *window; SFG_Window *window;
assert( (enumCallback != NULL) && (enumerator != NULL) ); assert( enumCallback && enumerator );
freeglut_assert_ready; freeglut_assert_ready;
/* /*
* Check every of the top-level windows * Check every of the top-level windows
*/ */
for( window = (SFG_Window *)fgStructure.Windows.First; for( window = ( SFG_Window * )fgStructure.Windows.First;
window; window;
window = (SFG_Window *)window->Node.Next ) window = ( SFG_Window * )window->Node.Next )
{ {
enumCallback( window, enumerator ); enumCallback( window, enumerator );
if( enumerator->found == TRUE ) if( enumerator->found == TRUE )
return; return;
} }
} }
/* /*
@ -499,19 +500,19 @@ void fgEnumWindows( FGCBenumerator enumCallback, SFG_Enumerator* enumerator )
void fgEnumSubWindows( SFG_Window* window, FGCBenumerator enumCallback, void fgEnumSubWindows( SFG_Window* window, FGCBenumerator enumCallback,
SFG_Enumerator* enumerator ) SFG_Enumerator* enumerator )
{ {
SFG_Window *child; SFG_Window *child;
assert( (enumCallback != NULL) && (enumerator != NULL) ); assert( enumCallback && enumerator );
freeglut_assert_ready; freeglut_assert_ready;
for( child = (SFG_Window *)window->Children.First; for( child = ( SFG_Window * )window->Children.First;
child; child;
child = (SFG_Window *)child->Node.Next ) child = ( SFG_Window * )child->Node.Next )
{ {
enumCallback( child, enumerator ); enumCallback( child, enumerator );
if( enumerator->found == TRUE ) if( enumerator->found == TRUE )
return; return;
} }
} }
/* /*
@ -673,13 +674,13 @@ void fgListRemove(SFG_List *list, SFG_Node *node)
{ {
SFG_Node *ln; SFG_Node *ln;
if ( (ln = (SFG_Node *)node->Next) != NULL ) if( ln = (SFG_Node *)node->Next )
ln->Prev = node->Prev; ln->Prev = node->Prev;
if ( (ln = (SFG_Node *)node->Prev) != NULL ) if( ln = (SFG_Node *)node->Prev )
ln->Next = node->Next; ln->Next = node->Next;
if ( (ln = (SFG_Node *)list->First) == node ) if( ( ln = (SFG_Node *)list->First ) == node )
list->First = node->Next; list->First = node->Next;
if ( (ln = (SFG_Node *)list->Last) == node ) if( ( ln = (SFG_Node *)list->Last ) == node )
list->Last = node->Prev; list->Last = node->Prev;
} }
@ -688,7 +689,9 @@ int fgListLength(SFG_List *list)
SFG_Node *node; SFG_Node *node;
int length = 0; 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; ++length;
return length; return length;