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

Cleanup pass after committing callback conversion (from structure to

Browse Source 
array-of-pointers).  Mostly deleted commented-out struct-based code.
Also added some XXX comments that I though should be pondered.  (My
own pair of eyes, and one brain cell, were not sufficient at this time
to decide what to do for those ponderables.  (^&)


git-svn-id: https://svn.code.sf.net/p/freeglut/code/trunk@304 7f0cb862-5218-0410-a997-914c9d46530a
This commit is contained in:
rkrolib 2003-11-06 23:29:55 +00:00
parent 80a523394c
commit 65dde7f632
4 changed files with 168 additions and 293 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
freeglut/freeglut/src/freeglut_callbacks.c
View File

@ -42,7 +42,6 @@
if( fgStructure.Window == NULL ) \
return; \
FETCH_WCB( ( *( fgStructure.Window ) ), a ) = callback;
/* fgStructure.Window->Callbacks.a = callback; */
/*
* Sets the Display callback for the current window
@ -123,18 +122,12 @@ static void fghVisibility( int status )
freeglut_return_if_fail( fgStructure.Window );
vis = FETCH_WCB( ( *( fgStructure.Window ) ), Visibility );
freeglut_return_if_fail( vis );
/* Callbacks.Visibility ); */
if( status == GLUT_HIDDEN || status == GLUT_FULLY_COVERED )
glut_status = GLUT_NOT_VISIBLE;
else
glut_status = GLUT_VISIBLE;
vis( glut_status );
/*
fgStructure.Window->Callbacks.Visibility( GLUT_NOT_VISIBLE );
else
fgStructure.Window->Callbacks.Visibility( GLUT_VISIBLE );
*/
}
void FGAPIENTRY glutVisibilityFunc( void (* callback)( int ) )

131
freeglut/freeglut/src/freeglut_internal.h
View File

@ -214,41 +214,41 @@ struct tagSFG_State
{
SFG_XYUse Position; /* The default windows' position */
SFG_XYUse Size; /* The default windows' size */
unsigned int DisplayMode; /* The display mode for new windows */
unsigned int DisplayMode; /* Display mode for new windows */
GLboolean ForceDirectContext; /* Should we force direct contexts? */
GLboolean ForceDirectContext; /* Force direct rendering? */
GLboolean TryDirectContext; /* What about giving a try to? */
GLboolean ForceIconic; /* All new top windows are iconified */
GLboolean UseCurrentContext; /* New windows use current window's rendering context */
GLboolean ForceIconic; /* New top windows are iconified */
GLboolean UseCurrentContext; /* New windows share with current */
GLboolean GLDebugSwitch; /* OpenGL state debugging switch */
GLboolean XSyncSwitch; /* X11 sync protocol switch */
GLboolean IgnoreKeyRepeat; /* Whether to ignore key repeat... */
GLboolean IgnoreKeyRepeat; /* Whether to ignore key repeat. */
GLuint FPSInterval; /* Interval between FPS printfs */
GLuint SwapCount; /* Count of glutSwapBuffer calls */
GLuint SwapTime; /* Time of last SwapBuffers */
SFG_Time Time; /* The time that glutInit was called */
SFG_Time Time; /* Time that glutInit was called */
SFG_List Timers; /* The freeglut timer hooks */
FGCBIdle IdleCallback; /* The global idle callback */
GLboolean BuildingAMenu; /* True if we are presently making a menu */
int ActiveMenus; /* Number of currently active menus */
GLboolean BuildingAMenu; /* Are we presently making a menu */
int ActiveMenus; /* Num. of currently active menus */
FGCBMenuState MenuStateCallback; /* Menu callbacks are global */
FGCBMenuStatus MenuStatusCallback;
SFG_XYUse GameModeSize; /* The game mode screen's dimensions */
SFG_XYUse GameModeSize; /* Game mode screen's dimensions */
int GameModeDepth; /* The pixel depth for game mode */
int GameModeRefresh; /* The refresh rate for game mode */
int ActionOnWindowClose ; /* Action when user clicks "x" on window header bar */
int ActionOnWindowClose; /* Action when user closes window */
fgExecutionState ExecState ; /* Current state of the GLUT execution */
char *ProgramName ; /* Name of the program invoking the "freeglut" library" */
fgExecutionState ExecState; /* Used for GLUT termination */
char *ProgramName; /* Name of the invoking program */
};
/*
@ -353,45 +353,19 @@ struct tagSFG_WindowState
#endif
};
/*
* The window callbacks the user can supply us with. Should be kept portable.
*/
typedef struct tagSFG_WindowCallbacks SFG_WindowCallbacks;
struct tagSFG_WindowCallbacks
{
/*
* Following callbacks are fully supported right now
* and are ready to be tested for GLUT conformance:
*/
FGCBDisplay Display;
FGCBReshape Reshape;
FGCBKeyboard Keyboard;
FGCBKeyboardUp KeyboardUp;
FGCBSpecial Special;
FGCBSpecialUp SpecialUp;
FGCBMouse Mouse;
FGCBMouseWheel MouseWheel;
FGCBMotion Motion;
FGCBPassive Passive;
FGCBEntry Entry;
FGCBVisibility Visibility;
FGCBWindowStatus WindowStatus;
FGCBJoystick Joystick;
FGCBDestroy Destroy;
/*
* Those callbacks are being ignored for the moment
* FETCH_WCB() is used as:
*
* FETCH_WCB( window, Visibility );
*
* ...where {window} is the freeglut window to fetch the callback from,
* {Visibility} is the window-specific callback to fetch.
*
* The result is correctly type-cast to the callback function pointer
* type. (This is accomlished by abutting the callback name to a
* common prefix, using ANSI C token-pasting.)
*/
FGCBSelect Select;
FGCBOverlayDisplay OverlayDisplay;
FGCBSpaceMotion SpaceMotion;
FGCBSpaceRotation SpaceRotation;
FGCBSpaceButton SpaceButton;
FGCBDials Dials;
FGCBButtonBox ButtonBox;
FGCBTabletMotion TabletMotion;
FGCBTabletButton TabletButton;
};
#define FETCH_WCB(window,cbname) \
((FGCB ## cbname)((window).CallBacks[CB_ ## cbname]))
@ -422,6 +396,23 @@ struct tagSFG_WindowCallbacks
FETCH_WCB( window, cbname ) arg_list; \
} \
}
/*
* The window callbacks the user can supply us with. Should be kept portable.
*
* This enumeration provides the freeglut CallBack numbers.
* The symbolic constants are indices into a window's array of
* function callbacks. The names are formed by splicing a common
* prefix onto the callback's base name. (This was originally
* done so that an early stage of development could live side-by-
* side with the old callback code. The old callback code used
* the bare callback's name as a structure member, so I used a
* prefix for the array index name.)
*
* XXX For consistancy, perhaps the prefix should match the
* XXX FETCH* and INVOKE* macro suffices. I.e., WCB_, rather than
* XXX CB_.
*/
enum
{
CB_Display,
@ -480,19 +471,19 @@ typedef struct tagSFG_Menu SFG_Menu;
struct tagSFG_Menu
{
SFG_Node Node;
void *UserData ; /* A. Donev: User data passed back at callback */
void *UserData; /* User data passed back at callback */
int ID; /* The global menu ID */
SFG_List Entries; /* The menu entries list */
FGCBMenu Callback; /* The menu callback */
FGCBDestroy Destroy; /* A. Donev: Destruction callback */
FGCBDestroy Destroy; /* Destruction callback */
GLboolean IsActive; /* Is the menu selected? */
int Width; /* Menu box width in pixels */
int Height; /* Menu box height in pixels */
int X, Y; /* Menu box raster position */
SFG_MenuEntry *ActiveEntry; /* Currently active entry in the menu */
SFG_Window *Window ; /* OpenGL window for menu */
SFG_Window *ParentWindow ; /* OpenGL window in which the menu is defined */
SFG_Window *Window; /* Window for menu */
SFG_Window *ParentWindow; /* Window in which the menu is defined */
};
/*
@ -510,7 +501,8 @@ struct tagSFG_MenuEntry
};
/*
* A window, making part of freeglut windows hierarchy. Should be kept portable.
* A window, making part of freeglut windows hierarchy.
* Should be kept portable.
*/
struct tagSFG_Window
{
@ -519,9 +511,8 @@ struct tagSFG_Window
SFG_Context Window; /* Window and OpenGL context */
SFG_WindowState State; /* The window state */
/* SFG_WindowCallbacks Callbacks; /* The window callbacks */
void *CallBacks[ TOTAL_CALLBACKS ]; /* Array of window callbacks */
void *UserData ; /* A. Donev: A pointer to user data used in rendering */
void *UserData ; /* For use by user */
SFG_Menu* Menu[ FREEGLUT_MAX_MENUS ]; /* Menus appended to window */
SFG_Menu* ActiveMenu; /* The window's active menu */
@ -589,7 +580,7 @@ struct tagSFG_Font
int Height; /* Height of the characters */
const GLubyte** Characters; /* The characters mapping */
float xorig, yorig ; /* The origin of the character relative to the draw location */
float xorig, yorig; /* Relative origin of the character */
};
/*
@ -656,8 +647,12 @@ extern SFG_State fgState;
* Following definitions are somewhat similiar to GLib's,
* but do not generate any log messages:
*/
#define freeglut_return_if_fail( expr ) if( !(expr) ) return;
#define freeglut_return_val_if_fail( expr, val ) if( !(expr) ) return( val );
#define freeglut_return_if_fail( expr ) \
if( !(expr) ) \
return;
#define freeglut_return_val_if_fail( expr, val ) \
if( !(expr) ) \
return( val );
/*
* A call to those macros assures us that there is a current
@ -694,19 +689,25 @@ XVisualInfo* fgChooseVisual( void );
* The window procedure for Win32 events handling
*/
#if TARGET_HOST_WIN32
LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam );
GLboolean fgSetupPixelFormat( SFG_Window* window, GLboolean checkOnly, unsigned char layer_type );
LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg,
WPARAM wParam, LPARAM lParam );
GLboolean fgSetupPixelFormat( SFG_Window* window, GLboolean checkOnly,
unsigned char layer_type );
#endif
/*
* Window creation, opening, closing and destruction.
* Defined in freeglut_structure.c, freeglut_window.c.
*/
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 );
void fgSetWindow ( SFG_Window *window ) ;
void fgOpenWindow( SFG_Window* window, const char* title, int x, int y, int w, int h, GLboolean gameMode, int isSubWindow );
void fgOpenWindow( SFG_Window* window, const char* title,
int x, int y, int w, int h, GLboolean gameMode,
int isSubWindow );
void fgCloseWindow( SFG_Window* window );
void fgAddToWindowDestroyList ( SFG_Window* window, GLboolean needToClose ) ;
void fgAddToWindowDestroyList ( SFG_Window* window,
GLboolean needToClose ) ;
void fgCloseWindows ();
void fgDestroyWindow( SFG_Window* window, GLboolean needToClose );
@ -736,7 +737,8 @@ void fgJoystickPollWindow( SFG_Window* window );
* are defined and exported from freeglut_structure.c file.
*/
void fgEnumWindows( FGCBenumerator enumCallback, SFG_Enumerator* enumerator );
void fgEnumSubWindows( SFG_Window* window, FGCBenumerator enumCallback, SFG_Enumerator* enumerator );
void fgEnumSubWindows( SFG_Window* window, FGCBenumerator enumCallback,
SFG_Enumerator* enumerator );
/*
* fgWindowByHandle returns a (SFG_Window *) value pointing to the
@ -746,7 +748,6 @@ void fgEnumSubWindows( SFG_Window* window, FGCBenumerator enumCallback, SFG_Enum
#if TARGET_HOST_UNIX_X11
SFG_Window* fgWindowByHandle( Window hWindow );
#elif TARGET_HOST_WIN32
SFG_Window* fgWindowByHandle( HWND hWindow );
#endif

204
freeglut/freeglut/src/freeglut_main.c
View File

@ -83,12 +83,27 @@ static void fghRedrawWindowByHandle
{
SFG_Window* window = fgWindowByHandle( handle );
freeglut_return_if_fail( window != NULL );
/*
* XXX Other than clearing the Redisplay flag or not,
* XXX we may as well rely on the INVOK_WCB() doing this
* XXX pointer-check.
* XXX
* XXX If we do not invoke the display because the pointer
* XXX is not defined (should never happen, really), then
* XXX we may enter an infinite busy-loop trying to update
* XXX the window. Similarly, if we skip because the window
* XXX is not visible. However, if the window becomes visible
* XXX at a later time, the window should get its callback
* XXX invoked. I would recommend removing the first check,
* XXX and making the second check only affect whether the
* XXX callback is invoked---but always clear the flag, if
* XXX the {window} pointer is defined.
*/
freeglut_return_if_fail( FETCH_WCB( *window, Display ) );
freeglut_return_if_fail( window->State.Visible == TRUE );
/* fgSetWindow( window ); */
window->State.Redisplay = FALSE;
/* window->Callbacks.Display( ); */
INVOKE_WCB( *window, Display, ( ) );
}
@ -109,13 +124,6 @@ static void fghReshapeWindowByHandle
SFG_Window* window = fgWindowByHandle( handle );
freeglut_return_if_fail( window != NULL );
/*
* fgSetWindow( window );
* if( window->Callbacks.Reshape != NULL )
* window->Callbacks.Reshape( width, height );
* else
* glViewport( 0, 0, width, height );
*/
if( !( FETCH_WCB( *window, Reshape ) ) )
{
fgSetWindow( window );
@ -143,15 +151,22 @@ static void fghReshapeWindowByHandle
static void fghcbDisplayWindow( SFG_Window *window, SFG_Enumerator *enumerator )
{
#if TARGET_HOST_UNIX_X11
/*
* XXX Do we need/want to check the callback pointer here?
* XXX INVOKE_WCB() will check for us. Arguably, the
* XXX Redisplay status flag should be cleared regardless
* XXX of any concern but that {window} is a valid pointer
* XXX (which this function is assuming anyway).
* XXX Especially since old GLUT wouldn't even enter its main
* XXX loop if you didn't have a display callback defined...
*/
if( ( FETCH_WCB( *window, Display ) ) &&
( window->State.Redisplay == TRUE ) &&
( window->State.Visible == TRUE ) )
{
SFG_Window *current_window = fgStructure.Window ;
/* fgSetWindow( window ); */
window->State.Redisplay = FALSE;
/* window->Callbacks.Display( ); */
INVOKE_WCB( *window, Display, ( ) );
fgSetWindow( current_window );
}
@ -174,6 +189,9 @@ static void fghcbDisplayWindow( SFG_Window *window, SFG_Enumerator *enumerator )
fgSetWindow ( current_window );
}
/*
* XXX See above comment about the Redisplay flag...
*/
if( ( FETCH_WCB( *window, Display ) ) &&
( window->State.Redisplay == TRUE ) &&
( window->State.Visible == TRUE ) )
@ -604,13 +622,6 @@ void FGAPIENTRY glutMainLoopEvent( void )
{
GETWINDOW( xcrossing );
GETMOUSE( xcrossing );
/*
* if( window->Callbacks.Entry )
* {
* fgSetWindow( window ) ;
* window->Callbacks.Entry( GLUT_ENTERED );
* }
*/
INVOKE_WCB( *window, Entry, ( GLUT_ENTERED ) );
}
break;
@ -619,13 +630,6 @@ void FGAPIENTRY glutMainLoopEvent( void )
{
GETWINDOW( xcrossing );
GETMOUSE( xcrossing );
/*
* if( window->Callbacks.Entry )
* {
* fgSetWindow( window ) ;
* window->Callbacks.Entry( GLUT_LEFT );
* }
*/
INVOKE_WCB( *window, Entry, ( GLUT_LEFT ) );
}
break;
@ -660,31 +664,11 @@ void FGAPIENTRY glutMainLoopEvent( void )
(event.xmotion.state & Button4Mask) ||
(event.xmotion.state & Button5Mask) )
{
/*
* A mouse button was pressed during the movement...
* Is there a motion callback hooked to the window?
*/
/*
* if( window->Callbacks.Motion )
* {
* fgSetWindow ( window ) ;
* window->Callbacks.Motion( event.xmotion.x,
* event.xmotion.y );
* }
*/
INVOKE_WCB( *window, Motion, ( event.xmotion.x,
event.xmotion.y ) );
}
else
{
/*
* if( window->Callbacks.Passive )
* {
* fgSetWindow( window );
* window->Callbacks.Passive( event.xmotion.x,
* event.xmotion.y );
* }
*/
INVOKE_WCB( *window, Passive, ( event.xmotion.x,
event.xmotion.y ) );
}
@ -717,6 +701,10 @@ void FGAPIENTRY glutMainLoopEvent( void )
button = event.xbutton.button - 1;
/*
* XXX This comment is replicated in the WIN32 section and
* XXX maybe also in the menu code. Can we move the info
* XXX to one central place and *reference* it from here?
*
* Do not execute the application's mouse callback if a menu
* is hooked to this button. In that case an appropriate
* private call should be generated.
@ -803,8 +791,6 @@ void FGAPIENTRY glutMainLoopEvent( void )
! FETCH_WCB( *window, MouseWheel ) )
break;
/* fgSetWindow( window ); */
/*
* XXX Why don't we use {window}? Other code here does...
*/
@ -817,15 +803,6 @@ void FGAPIENTRY glutMainLoopEvent( void )
*/
if( ( button < 4 ) || ( ! FETCH_WCB( *window, MouseWheel ) ) )
{
/*
* if( window->Callbacks.Mouse )
* fgStructure.Window->Callbacks.Mouse(
* button,
* pressed ? GLUT_DOWN : GLUT_UP,
* event.xbutton.x,
* event.xbutton.y
* );
*/
INVOKE_WCB( *window, Mouse, ( button,
pressed ? GLUT_DOWN : GLUT_UP,
event.xbutton.x,
@ -846,15 +823,6 @@ void FGAPIENTRY glutMainLoopEvent( void )
int wheel_number = (button - 4) / 2;
int direction = (button & 1)*2 - 1;
/*
* if( pressed )
* fgStructure.Window->Callbacks.MouseWheel(
* wheel_number,
* direction,
* event.xbutton.x,
* event.xbutton.y
* );
*/
if( pressed )
INVOKE_WCB( *window, MouseWheel, ( wheel_number,
direction,
@ -1034,10 +1002,6 @@ void FGAPIENTRY glutMainLoop( void )
{
SFG_Window *current_window = fgStructure.Window ;
/*
* fgSetWindow( window );
* window->Callbacks.Visibility ( window->State.Visible ) ;
*/
INVOKE_WCB( *window, Visibility, ( window->State.Visible ) );
fgSetWindow( current_window );
}
@ -1308,27 +1272,11 @@ LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam,
( wParam & MK_MBUTTON ) ||
( wParam & MK_RBUTTON ) )
{
/*
* if( window->Callbacks.Motion )
* {
* fgSetWindow( window );
* window->Callbacks.Motion( window->State.MouseX,
* window->State.MouseY );
* }
*/
INVOKE_WCB( *window, Motion, ( window->State.MouseX,
window->State.MouseY ) );
}
else
{
/*
* if( window->Callbacks.Passive )
* {
* fgSetWindow( window );
* window->Callbacks.Passive( window->State.MouseX,
* window->State.MouseY );
* }
*/
INVOKE_WCB( *window, Passive, ( window->State.MouseX,
window->State.MouseY ) );
}
@ -1457,14 +1405,6 @@ LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam,
window->State.MouseY
)
);
/*
* window->Callbacks.Mouse(
* button,
* pressed == TRUE ? GLUT_DOWN : GLUT_UP,
* window->State.MouseX,
* window->State.MouseY
* );
*/
fgStructure.Window->State.Modifiers = 0xffffffff;
}
@ -1511,15 +1451,6 @@ LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam,
)
);
}
/*
* if( window->Callbacks.MouseWheel )
* window->Callbacks.MouseWheel(
* wheel_number,
* direction,
* window->State.MouseX,
* window->State.MouseY
* );
*/
else /* No mouse wheel, call the mouse button callback twice */
{
/*
@ -1537,17 +1468,6 @@ LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam,
( button, GLUT_UP,
window->State.MouseX, window->State.MouseX )
);
/*
* window->Callbacks.Mouse( button, GLUT_DOWN,
* window->State.MouseX,
* window->State.MouseY
* );
* window->Callbacks.Mouse( button, GLUT_UP,
* window->State.MouseX,
* window->State.MouseY
* );
*/
}
fgStructure.Window->State.Modifiers = 0xffffffff;
@ -1608,29 +1528,15 @@ LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam,
/*
* The delete key should be treated as an ASCII keypress:
*/
/*
* if( window->Callbacks.Keyboard )
* {
* fgSetWindow( window );
* window->Callbacks.Keyboard( 127, window->State.MouseX,
* window->State.MouseY );
* }
*/
INVOKE_WCB( *window, Keyboard,
( 127, window->State.MouseX, window->State.MouseY )
);
}
/* if( ( keypress != -1 ) && window->Callbacks.Special )
* {
* fgSetWindow( window );
* window->Callbacks.Special( keypress, window->State.MouseX,
* window->State.MouseY );
* }
*/
if( keypress != -1 )
INVOKE_WCB( *window, Special,
( keypress, window->State.MouseX, window->State.MouseY )
( keypress,
window->State.MouseX, window->State.MouseY )
);
window->State.Modifiers = 0xffffffff;
@ -1688,13 +1594,6 @@ LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam,
/*
* The delete key should be treated as an ASCII keypress:
*/
/* if( window->Callbacks.KeyboardUp )
* {
* fgSetWindow( window );
* window->Callbacks.KeyboardUp( 127, window->State.MouseX,
* window->State.MouseY );
* }
*/
INVOKE_WCB( *window, KeyboardUp,
( 127, window->State.MouseX, window->State.MouseY )
);
@ -1710,15 +1609,6 @@ LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam,
if( ToAscii( wParam, 0, state, code, 0 ) == 1 )
wParam=code[ 0 ];
/*
* if( window->Callbacks.KeyboardUp )
* {
* fgSetWindow( window );
* window->Callbacks.KeyboardUp( (char)wParam,
* window->State.MouseX,
* window->State.MouseY );
* }
*/
INVOKE_WCB( *window, KeyboardUp,
( (char)wParam,
window->State.MouseX, window->State.MouseY )
@ -1726,14 +1616,6 @@ LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam,
}
}
/*
* if( (keypress != -1) && window->Callbacks.SpecialUp )
* {
* fgSetWindow( window );
* window->Callbacks.SpecialUp( keypress, window->State.MouseX,
* window->State.MouseY );
* }
*/
if( keypress != -1 )
INVOKE_WCB( *window, SpecialUp,
( keypress,
@ -1750,12 +1632,15 @@ LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam,
if( fgState.IgnoreKeyRepeat && (lParam & KF_REPEAT) )
break;
/*
* XXX INVOKE_WCB() takes care of the callback-pointer check.
* XXX We could just uncoditionally find/trash the Modifiers
* XXX and get rid of the "if( ... ) {" and "}". Unconditinal
* XXX code is simpler code. (^&
*/
if( FETCH_WCB( *window, Keyboard ) )
{
/* fgSetWindow( window ); */
window->State.Modifiers = fgGetWin32Modifiers( );
/* window->Callbacks.Keyboard( (char)wParam, window->State.MouseX,
window->State.MouseY ); */
INVOKE_WCB( *window, Keyboard,
( (char)wParam,
window->State.MouseX, window->State.MouseY )
@ -1767,13 +1652,6 @@ LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam,
case WM_CAPTURECHANGED:
/* User has finished resizing the window, force a redraw */
/*
* if( window->Callbacks.Display )
* {
* fgSetWindow( window );
* window->Callbacks.Display( );
* }
*/
INVOKE_WCB( *window, Display, ( ) );
/*lRet = DefWindowProc( hWnd, uMsg, wParam, lParam ) ; */

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

@ -266,11 +266,14 @@ void fgDestroyWindow( SFG_Window* window, GLboolean needToClose )
while ( (subWindow = (SFG_Window *)window->Children.First) != NULL )
fgDestroyWindow( subWindow, needToClose );
/*
* 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 ;
/* fgSetWindow ( window ) ; */
/* window->Callbacks.Destroy () ; */
INVOKE_WCB( *window, Destroy, ( ) );
fgSetWindow ( activeWindow ) ;
}