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

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

@ -212,43 +212,43 @@ typedef enum {
typedef struct tagSFG_State SFG_State; typedef struct tagSFG_State SFG_State;
struct tagSFG_State struct tagSFG_State
{ {
SFG_XYUse Position; /* The default windows' position */ SFG_XYUse Position; /* The default windows' position */
SFG_XYUse Size; /* The default windows' size */ 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 TryDirectContext; /* What about giving a try to? */
GLboolean ForceIconic; /* All new top windows are iconified */ GLboolean ForceIconic; /* New top windows are iconified */
GLboolean UseCurrentContext; /* New windows use current window's rendering context */ GLboolean UseCurrentContext; /* New windows share with current */
GLboolean GLDebugSwitch; /* OpenGL state debugging switch */ GLboolean GLDebugSwitch; /* OpenGL state debugging switch */
GLboolean XSyncSwitch; /* X11 sync protocol 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 FPSInterval; /* Interval between FPS printfs */
GLuint SwapCount; /* Count of glutSwapBuffer calls */ GLuint SwapCount; /* Count of glutSwapBuffer calls */
GLuint SwapTime; /* Time of last SwapBuffers */ 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 */ SFG_List Timers; /* The freeglut timer hooks */
FGCBIdle IdleCallback; /* The global idle callback */ FGCBIdle IdleCallback; /* The global idle callback */
GLboolean BuildingAMenu; /* True if we are presently making a menu */ GLboolean BuildingAMenu; /* Are we presently making a menu */
int ActiveMenus; /* Number of currently active menus */ int ActiveMenus; /* Num. of currently active menus */
FGCBMenuState MenuStateCallback; /* Menu callbacks are global */ FGCBMenuState MenuStateCallback; /* Menu callbacks are global */
FGCBMenuStatus MenuStatusCallback; 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 GameModeDepth; /* The pixel depth for game mode */
int GameModeRefresh; /* The refresh rate 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 */ fgExecutionState ExecState; /* Used for GLUT termination */
char *ProgramName ; /* Name of the program invoking the "freeglut" library" */ char *ProgramName; /* Name of the invoking program */
}; };
/* /*
@ -312,18 +312,18 @@ typedef struct tagSFG_Context SFG_Context;
struct tagSFG_Context struct tagSFG_Context
{ {
#if TARGET_HOST_UNIX_X11 #if TARGET_HOST_UNIX_X11
Window Handle; /* The window's handle */ Window Handle; /* The window's handle */
GLXContext Context; /* The OpenGL context */ GLXContext Context; /* The OpenGL context */
XVisualInfo* VisualInfo; /* The window's visual information */ XVisualInfo* VisualInfo; /* The window's visual information */
#elif TARGET_HOST_WIN32 #elif TARGET_HOST_WIN32
HWND Handle; /* The window's handle */ HWND Handle; /* The window's handle */
HDC Device; /* The window's device context */ HDC Device; /* The window's device context */
HGLRC Context; /* The window's WGL context */ HGLRC Context; /* The window's WGL context */
#endif #endif
int DoubleBuffered; /* Treat the window as double-buffered */ int DoubleBuffered; /* Treat the window as double-buffered */
}; };
/* /*
@ -353,45 +353,19 @@ struct tagSFG_WindowState
#endif #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:
*/ *
FGCBSelect Select; * FETCH_WCB( window, Visibility );
FGCBOverlayDisplay OverlayDisplay; *
FGCBSpaceMotion SpaceMotion; * ...where {window} is the freeglut window to fetch the callback from,
FGCBSpaceRotation SpaceRotation; * {Visibility} is the window-specific callback to fetch.
FGCBSpaceButton SpaceButton; *
FGCBDials Dials; * The result is correctly type-cast to the callback function pointer
FGCBButtonBox ButtonBox; * type. (This is accomlished by abutting the callback name to a
FGCBTabletMotion TabletMotion; * common prefix, using ANSI C token-pasting.)
FGCBTabletButton TabletButton; */
};
#define FETCH_WCB(window,cbname) \ #define FETCH_WCB(window,cbname) \
((FGCB ## cbname)((window).CallBacks[CB_ ## cbname])) ((FGCB ## cbname)((window).CallBacks[CB_ ## cbname]))
@ -422,6 +396,23 @@ struct tagSFG_WindowCallbacks
FETCH_WCB( window, cbname ) arg_list; \ 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 enum
{ {
CB_Display, CB_Display,
@ -463,10 +454,10 @@ typedef struct tagSFG_MenuContext SFG_MenuContext;
struct tagSFG_MenuContext struct tagSFG_MenuContext
{ {
#if TARGET_HOST_UNIX_X11 #if TARGET_HOST_UNIX_X11
GLXContext Context; /* The menu OpenGL context */ GLXContext Context; /* The menu OpenGL context */
XVisualInfo* VisualInfo; /* The window's visual information */ XVisualInfo* VisualInfo; /* The window's visual information */
#elif TARGET_HOST_WIN32 #elif TARGET_HOST_WIN32
HGLRC Context; /* The menu window's WGL context */ HGLRC Context; /* The menu window's WGL context */
#endif #endif
}; };
@ -480,19 +471,19 @@ typedef struct tagSFG_Menu SFG_Menu;
struct tagSFG_Menu struct tagSFG_Menu
{ {
SFG_Node Node; 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 */ int ID; /* The global menu ID */
SFG_List Entries; /* The menu entries list */ SFG_List Entries; /* The menu entries list */
FGCBMenu Callback; /* The menu callback */ FGCBMenu Callback; /* The menu callback */
FGCBDestroy Destroy; /* A. Donev: Destruction callback */ FGCBDestroy Destroy; /* Destruction callback */
GLboolean IsActive; /* Is the menu selected? */ GLboolean IsActive; /* Is the menu selected? */
int Width; /* Menu box width in pixels */ int Width; /* Menu box width in pixels */
int Height; /* Menu box height in pixels */ int Height; /* Menu box height in pixels */
int X, Y; /* Menu box raster position */ int X, Y; /* Menu box raster position */
SFG_MenuEntry *ActiveEntry ; /* Currently active entry in the menu */ SFG_MenuEntry *ActiveEntry; /* Currently active entry in the menu */
SFG_Window *Window ; /* OpenGL window for menu */ SFG_Window *Window; /* Window for menu */
SFG_Window *ParentWindow ; /* OpenGL window in which the menu is defined */ 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 struct tagSFG_Window
{ {
@ -519,9 +511,8 @@ struct tagSFG_Window
SFG_Context Window; /* Window and OpenGL context */ SFG_Context Window; /* Window and OpenGL context */
SFG_WindowState State; /* The window state */ SFG_WindowState State; /* The window state */
/* SFG_WindowCallbacks Callbacks; /* The window callbacks */
void *CallBacks[ TOTAL_CALLBACKS ]; /* Array of 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* Menu[ FREEGLUT_MAX_MENUS ]; /* Menus appended to window */
SFG_Menu* ActiveMenu; /* The window's active menu */ SFG_Menu* ActiveMenu; /* The window's active menu */
@ -539,10 +530,10 @@ struct tagSFG_Window
typedef struct tagSFG_WindowList SFG_WindowList ; typedef struct tagSFG_WindowList SFG_WindowList ;
struct tagSFG_WindowList struct tagSFG_WindowList
{ {
SFG_Window *window ; SFG_Window *window ;
GLboolean needToClose ; GLboolean needToClose ;
SFG_WindowList *next ; SFG_WindowList *next ;
} ; };
/* /*
* This holds information about all the windows, menus etc. * This holds information about all the windows, menus etc.
@ -550,18 +541,18 @@ struct tagSFG_WindowList
typedef struct tagSFG_Structure SFG_Structure; typedef struct tagSFG_Structure SFG_Structure;
struct tagSFG_Structure struct tagSFG_Structure
{ {
SFG_List Windows; /* The global windows list */ SFG_List Windows; /* The global windows list */
SFG_List Menus; /* The global menus list */ SFG_List Menus; /* The global menus list */
SFG_Window* Window; /* The currently active win. */ SFG_Window* Window; /* The currently active win. */
SFG_Menu* Menu; /* Same, but menu... */ SFG_Menu* Menu; /* Same, but menu... */
SFG_MenuContext* MenuContext; /* OpenGL rendering context for menus */ SFG_MenuContext* MenuContext; /* OpenGL rendering context for menus */
SFG_Window* GameMode; /* The game mode window */ SFG_Window* GameMode; /* The game mode window */
int WindowID; /* The new current window ID */ int WindowID; /* The new current window ID */
int MenuID; /* The new current menu ID */ int MenuID; /* The new current menu ID */
}; };
/* /*
@ -584,12 +575,12 @@ typedef void (* FGCBenumerator )( SFG_Window *, SFG_Enumerator * );
typedef struct tagSFG_Font SFG_Font; typedef struct tagSFG_Font SFG_Font;
struct tagSFG_Font struct tagSFG_Font
{ {
char* Name; /* The source font name */ char* Name; /* The source font name */
int Quantity; /* Number of chars in font */ int Quantity; /* Number of chars in font */
int Height; /* Height of the characters */ int Height; /* Height of the characters */
const GLubyte** Characters; /* The characters mapping */ 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,15 +647,19 @@ extern SFG_State fgState;
* Following definitions are somewhat similiar to GLib's, * Following definitions are somewhat similiar to GLib's,
* but do not generate any log messages: * but do not generate any log messages:
*/ */
#define freeglut_return_if_fail( expr ) if( !(expr) ) return; #define freeglut_return_if_fail( expr ) \
#define freeglut_return_val_if_fail( expr, val ) if( !(expr) ) return( val ); 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 * A call to those macros assures us that there is a current
* window and menu set, respectively: * window and menu set, respectively:
*/ */
#define freeglut_assert_window assert( fgStructure.Window != NULL ); #define freeglut_assert_window assert( fgStructure.Window != NULL );
#define freeglut_assert_menu assert( fgStructure.Menu != NULL ); #define freeglut_assert_menu assert( fgStructure.Menu != NULL );
/* /*
* The initialize and deinitialize functions get called on glutInit() * The initialize and deinitialize functions get called on glutInit()
@ -694,20 +689,26 @@ XVisualInfo* fgChooseVisual( void );
* The window procedure for Win32 events handling * The window procedure for Win32 events handling
*/ */
#if TARGET_HOST_WIN32 #if TARGET_HOST_WIN32
LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam ); LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg,
GLboolean fgSetupPixelFormat( SFG_Window* window, GLboolean checkOnly, unsigned char layer_type ); WPARAM wParam, LPARAM lParam );
GLboolean fgSetupPixelFormat( SFG_Window* window, GLboolean checkOnly,
unsigned char layer_type );
#endif #endif
/* /*
* Window creation, opening, closing and destruction. * Window creation, opening, closing and destruction.
* Defined in freeglut_structure.c, freeglut_window.c. * 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 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 fgCloseWindow( SFG_Window* window );
void fgAddToWindowDestroyList ( SFG_Window* window, GLboolean needToClose ) ; void fgAddToWindowDestroyList ( SFG_Window* window,
void fgCloseWindows () ; GLboolean needToClose ) ;
void fgCloseWindows ();
void fgDestroyWindow( SFG_Window* window, GLboolean needToClose ); 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. * are defined and exported from freeglut_structure.c file.
*/ */
void fgEnumWindows( FGCBenumerator enumCallback, SFG_Enumerator* enumerator ); 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 * 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 #if TARGET_HOST_UNIX_X11
SFG_Window* fgWindowByHandle( Window hWindow ); SFG_Window* fgWindowByHandle( Window hWindow );
#elif TARGET_HOST_WIN32 #elif TARGET_HOST_WIN32
SFG_Window* fgWindowByHandle( HWND hWindow ); SFG_Window* fgWindowByHandle( HWND hWindow );
#endif #endif
@ -768,8 +769,8 @@ SFG_Menu* fgMenuByID( int menuID );
* of the menu user interface handling code... * of the menu user interface handling code...
*/ */
void fgActivateMenu( SFG_Window* window, int button ); void fgActivateMenu( SFG_Window* window, int button );
void fgExecuteMenuCallback( SFG_Menu* menu ) ; void fgExecuteMenuCallback( SFG_Menu* menu );
GLboolean fgCheckActiveMenu ( SFG_Window *window, SFG_Menu *menu ) ; GLboolean fgCheckActiveMenu ( SFG_Window *window, SFG_Menu *menu );
void fgDeactivateMenu( SFG_Window *window ); void fgDeactivateMenu( SFG_Window *window );
void fgDeactivateSubMenu( SFG_MenuEntry *menuEntry ); void fgDeactivateSubMenu( SFG_MenuEntry *menuEntry );

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

@ -83,12 +83,27 @@ static void fghRedrawWindowByHandle
{ {
SFG_Window* window = fgWindowByHandle( handle ); SFG_Window* window = fgWindowByHandle( handle );
freeglut_return_if_fail( window != NULL ); 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( FETCH_WCB( *window, Display ) );
freeglut_return_if_fail( window->State.Visible == TRUE ); freeglut_return_if_fail( window->State.Visible == TRUE );
/* fgSetWindow( window ); */
window->State.Redisplay = FALSE; window->State.Redisplay = FALSE;
/* window->Callbacks.Display( ); */
INVOKE_WCB( *window, Display, ( ) ); INVOKE_WCB( *window, Display, ( ) );
} }
@ -109,13 +124,6 @@ static void fghReshapeWindowByHandle
SFG_Window* window = fgWindowByHandle( handle ); SFG_Window* window = fgWindowByHandle( handle );
freeglut_return_if_fail( window != NULL ); 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 ) ) ) if( !( FETCH_WCB( *window, Reshape ) ) )
{ {
fgSetWindow( window ); fgSetWindow( window );
@ -143,15 +151,22 @@ static void fghReshapeWindowByHandle
static void fghcbDisplayWindow( SFG_Window *window, SFG_Enumerator *enumerator ) static void fghcbDisplayWindow( SFG_Window *window, SFG_Enumerator *enumerator )
{ {
#if TARGET_HOST_UNIX_X11 #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 ) ) && if( ( FETCH_WCB( *window, Display ) ) &&
( window->State.Redisplay == TRUE ) && ( window->State.Redisplay == TRUE ) &&
( window->State.Visible == TRUE ) ) ( window->State.Visible == TRUE ) )
{ {
SFG_Window *current_window = fgStructure.Window ; SFG_Window *current_window = fgStructure.Window ;
/* fgSetWindow( window ); */
window->State.Redisplay = FALSE; window->State.Redisplay = FALSE;
/* window->Callbacks.Display( ); */
INVOKE_WCB( *window, Display, ( ) ); INVOKE_WCB( *window, Display, ( ) );
fgSetWindow( current_window ); fgSetWindow( current_window );
} }
@ -174,6 +189,9 @@ static void fghcbDisplayWindow( SFG_Window *window, SFG_Enumerator *enumerator )
fgSetWindow ( current_window ); fgSetWindow ( current_window );
} }
/*
* XXX See above comment about the Redisplay flag...
*/
if( ( FETCH_WCB( *window, Display ) ) && if( ( FETCH_WCB( *window, Display ) ) &&
( window->State.Redisplay == TRUE ) && ( window->State.Redisplay == TRUE ) &&
( window->State.Visible == TRUE ) ) ( window->State.Visible == TRUE ) )
@ -604,13 +622,6 @@ void FGAPIENTRY glutMainLoopEvent( void )
{ {
GETWINDOW( xcrossing ); GETWINDOW( xcrossing );
GETMOUSE( xcrossing ); GETMOUSE( xcrossing );
/*
* if( window->Callbacks.Entry )
* {
* fgSetWindow( window ) ;
* window->Callbacks.Entry( GLUT_ENTERED );
* }
*/
INVOKE_WCB( *window, Entry, ( GLUT_ENTERED ) ); INVOKE_WCB( *window, Entry, ( GLUT_ENTERED ) );
} }
break; break;
@ -619,13 +630,6 @@ void FGAPIENTRY glutMainLoopEvent( void )
{ {
GETWINDOW( xcrossing ); GETWINDOW( xcrossing );
GETMOUSE( xcrossing ); GETMOUSE( xcrossing );
/*
* if( window->Callbacks.Entry )
* {
* fgSetWindow( window ) ;
* window->Callbacks.Entry( GLUT_LEFT );
* }
*/
INVOKE_WCB( *window, Entry, ( GLUT_LEFT ) ); INVOKE_WCB( *window, Entry, ( GLUT_LEFT ) );
} }
break; break;
@ -660,33 +664,13 @@ void FGAPIENTRY glutMainLoopEvent( void )
(event.xmotion.state & Button4Mask) || (event.xmotion.state & Button4Mask) ||
(event.xmotion.state & Button5Mask) ) (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, INVOKE_WCB( *window, Motion, ( event.xmotion.x,
event.xmotion.y ) ); event.xmotion.y ) );
} }
else else
{ {
/*
* if( window->Callbacks.Passive )
* {
* fgSetWindow( window );
* window->Callbacks.Passive( event.xmotion.x,
* event.xmotion.y );
* }
*/
INVOKE_WCB( *window, Passive, ( event.xmotion.x, INVOKE_WCB( *window, Passive, ( event.xmotion.x,
event.xmotion.y ) ); event.xmotion.y ) );
} }
} }
break; break;
@ -717,6 +701,10 @@ void FGAPIENTRY glutMainLoopEvent( void )
button = event.xbutton.button - 1; 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 * Do not execute the application's mouse callback if a menu
* is hooked to this button. In that case an appropriate * is hooked to this button. In that case an appropriate
* private call should be generated. * private call should be generated.
@ -803,8 +791,6 @@ void FGAPIENTRY glutMainLoopEvent( void )
! FETCH_WCB( *window, MouseWheel ) ) ! FETCH_WCB( *window, MouseWheel ) )
break; break;
/* fgSetWindow( window ); */
/* /*
* XXX Why don't we use {window}? Other code here does... * 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( ( 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, INVOKE_WCB( *window, Mouse, ( button,
pressed ? GLUT_DOWN : GLUT_UP, pressed ? GLUT_DOWN : GLUT_UP,
event.xbutton.x, event.xbutton.x,
@ -846,15 +823,6 @@ void FGAPIENTRY glutMainLoopEvent( void )
int wheel_number = (button - 4) / 2; int wheel_number = (button - 4) / 2;
int direction = (button & 1)*2 - 1; int direction = (button & 1)*2 - 1;
/*
* if( pressed )
* fgStructure.Window->Callbacks.MouseWheel(
* wheel_number,
* direction,
* event.xbutton.x,
* event.xbutton.y
* );
*/
if( pressed ) if( pressed )
INVOKE_WCB( *window, MouseWheel, ( wheel_number, INVOKE_WCB( *window, MouseWheel, ( wheel_number,
direction, direction,
@ -1034,10 +1002,6 @@ void FGAPIENTRY glutMainLoop( void )
{ {
SFG_Window *current_window = fgStructure.Window ; SFG_Window *current_window = fgStructure.Window ;
/*
* fgSetWindow( window );
* window->Callbacks.Visibility ( window->State.Visible ) ;
*/
INVOKE_WCB( *window, Visibility, ( window->State.Visible ) ); INVOKE_WCB( *window, Visibility, ( window->State.Visible ) );
fgSetWindow( current_window ); fgSetWindow( current_window );
} }
@ -1308,27 +1272,11 @@ LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam,
( wParam & MK_MBUTTON ) || ( wParam & MK_MBUTTON ) ||
( wParam & MK_RBUTTON ) ) ( 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, INVOKE_WCB( *window, Motion, ( window->State.MouseX,
window->State.MouseY ) ); window->State.MouseY ) );
} }
else else
{ {
/*
* if( window->Callbacks.Passive )
* {
* fgSetWindow( window );
* window->Callbacks.Passive( window->State.MouseX,
* window->State.MouseY );
* }
*/
INVOKE_WCB( *window, Passive, ( window->State.MouseX, INVOKE_WCB( *window, Passive, ( window->State.MouseX,
window->State.MouseY ) ); window->State.MouseY ) );
} }
@ -1457,14 +1405,6 @@ LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam,
window->State.MouseY window->State.MouseY
) )
); );
/*
* window->Callbacks.Mouse(
* button,
* pressed == TRUE ? GLUT_DOWN : GLUT_UP,
* window->State.MouseX,
* window->State.MouseY
* );
*/
fgStructure.Window->State.Modifiers = 0xffffffff; 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 */ 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, ( button, GLUT_UP,
window->State.MouseX, window->State.MouseX ) 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; 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: * 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, INVOKE_WCB( *window, Keyboard,
( 127, window->State.MouseX, window->State.MouseY ) ( 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 ) if( keypress != -1 )
INVOKE_WCB( *window, Special, INVOKE_WCB( *window, Special,
( keypress, window->State.MouseX, window->State.MouseY ) ( keypress,
window->State.MouseX, window->State.MouseY )
); );
window->State.Modifiers = 0xffffffff; 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: * 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, INVOKE_WCB( *window, KeyboardUp,
( 127, window->State.MouseX, window->State.MouseY ) ( 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 ) if( ToAscii( wParam, 0, state, code, 0 ) == 1 )
wParam=code[ 0 ]; wParam=code[ 0 ];
/*
* if( window->Callbacks.KeyboardUp )
* {
* fgSetWindow( window );
* window->Callbacks.KeyboardUp( (char)wParam,
* window->State.MouseX,
* window->State.MouseY );
* }
*/
INVOKE_WCB( *window, KeyboardUp, INVOKE_WCB( *window, KeyboardUp,
( (char)wParam, ( (char)wParam,
window->State.MouseX, window->State.MouseY ) 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 ) if( keypress != -1 )
INVOKE_WCB( *window, SpecialUp, INVOKE_WCB( *window, SpecialUp,
( keypress, ( keypress,
@ -1750,12 +1632,15 @@ LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam,
if( fgState.IgnoreKeyRepeat && (lParam & KF_REPEAT) ) if( fgState.IgnoreKeyRepeat && (lParam & KF_REPEAT) )
break; 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 ) ) if( FETCH_WCB( *window, Keyboard ) )
{ {
/* fgSetWindow( window ); */
window->State.Modifiers = fgGetWin32Modifiers( ); window->State.Modifiers = fgGetWin32Modifiers( );
/* window->Callbacks.Keyboard( (char)wParam, window->State.MouseX,
window->State.MouseY ); */
INVOKE_WCB( *window, Keyboard, INVOKE_WCB( *window, Keyboard,
( (char)wParam, ( (char)wParam,
window->State.MouseX, window->State.MouseY ) window->State.MouseX, window->State.MouseY )
@ -1767,13 +1652,6 @@ LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam,
case WM_CAPTURECHANGED: case WM_CAPTURECHANGED:
/* User has finished resizing the window, force a redraw */ /* User has finished resizing the window, force a redraw */
/*
* if( window->Callbacks.Display )
* {
* fgSetWindow( window );
* window->Callbacks.Display( );
* }
*/
INVOKE_WCB( *window, Display, ( ) ); INVOKE_WCB( *window, Display, ( ) );
/*lRet = DefWindowProc( hWnd, uMsg, wParam, lParam ) ; */ /*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 ) while ( (subWindow = (SFG_Window *)window->Children.First) != NULL )
fgDestroyWindow( subWindow, needToClose ); 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 ) ) if ( FETCH_WCB( *window, Destroy ) )
{ {
SFG_Window *activeWindow = fgStructure.Window ; SFG_Window *activeWindow = fgStructure.Window ;
/* fgSetWindow ( window ) ; */
/* window->Callbacks.Destroy () ; */
INVOKE_WCB( *window, Destroy, ( ) ); INVOKE_WCB( *window, Destroy, ( ) );
fgSetWindow ( activeWindow ) ; fgSetWindow ( activeWindow ) ;
} }