Removed extra comment on FETCH_USER_DATA_WCB
Renamed helper callbacks from glutXXXCalback to fghXXXCallback
git-svn-id: svn+ssh://svn.code.sf.net/p/freeglut/code/trunk/freeglut/freeglut@1816
7f0cb862-5218-0410-a997-
914c9d46530a
fgState.IdleCallbackData = userData;
}
fgState.IdleCallbackData = userData;
}
-static void glutIdleFuncCallback( FGCBUserData userData )
+static void fghIdleFuncCallback( FGCBUserData userData )
{
FGCBIdle callback = (FGCBIdle)userData;
callback();
{
FGCBIdle callback = (FGCBIdle)userData;
callback();
{
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutIdleFunc" );
if( callback )
{
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutIdleFunc" );
if( callback )
- glutIdleFuncUcall( glutIdleFuncCallback, (FGCBUserData)callback );
+ glutIdleFuncUcall( fghIdleFuncCallback, (FGCBUserData)callback );
else
glutIdleFuncUcall( NULL, NULL );
}
else
glutIdleFuncUcall( NULL, NULL );
}
fgListInsert( &fgState.Timers, &node->Node, &timer->Node );
}
fgListInsert( &fgState.Timers, &node->Node, &timer->Node );
}
-static void glutTimerFuncCallback( int ID, FGCBUserData userData )
+static void fghTimerFuncCallback( int ID, FGCBUserData userData )
{
FGCBTimer callback = (FGCBTimer)userData;
callback( ID );
{
FGCBTimer callback = (FGCBTimer)userData;
callback( ID );
{
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutTimerFunc" );
if( callback )
{
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutTimerFunc" );
if( callback )
- glutTimerFuncUcall( timeOut, glutTimerFuncCallback, timerID, (FGCBUserData)callback );
+ glutTimerFuncUcall( timeOut, fghTimerFuncCallback, timerID, (FGCBUserData)callback );
else
glutTimerFuncUcall( timeOut, NULL, timerID, NULL );
}
else
glutTimerFuncUcall( timeOut, NULL, timerID, NULL );
}
fgState.MenuStatusCallbackData = userData;
}
fgState.MenuStatusCallbackData = userData;
}
-static void glutMenuStatusFuncCallback( int menuState, int mouseX, int mouseY, FGCBUserData userData )
+static void fghMenuStatusFuncCallback( int menuState, int mouseX, int mouseY, FGCBUserData userData )
{
FGCBMenuStatus callback = (FGCBMenuStatus)userData;
callback( menuState, mouseX, mouseY );
{
FGCBMenuStatus callback = (FGCBMenuStatus)userData;
callback( menuState, mouseX, mouseY );
{
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutMenuStatusFunc" );
if( callback )
{
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutMenuStatusFunc" );
if( callback )
- glutMenuStatusFuncUcall( glutMenuStatusFuncCallback, (FGCBUserData)callback );
+ glutMenuStatusFuncUcall( fghMenuStatusFuncCallback, (FGCBUserData)callback );
else
glutMenuStatusFuncUcall( NULL, NULL );
}
else
glutMenuStatusFuncUcall( NULL, NULL );
}
-static void glutMenuDestroyFuncCallback( FGCBUserData userData )
+static void fghMenuDestroyFuncCallback( FGCBUserData userData )
{
FGCBDestroy callback = (FGCBDestroy)userData;
callback();
{
FGCBDestroy callback = (FGCBDestroy)userData;
callback();
{
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutMenuDestroyFunc" );
if( callback )
{
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutMenuDestroyFunc" );
if( callback )
- glutMenuDestroyFuncUcall( glutMenuDestroyFuncCallback, (FGCBUserData)callback );
+ glutMenuDestroyFuncUcall( fghMenuDestroyFuncCallback, (FGCBUserData)callback );
else
glutMenuDestroyFuncUcall( NULL, NULL );
}
else
glutMenuDestroyFuncUcall( NULL, NULL );
}
* Types need to be defined for callbacks. It's not ideal, but it works for this.
*/
#define IMPLEMENT_CALLBACK_FUNC_CB_ARG0(a,b) \
* Types need to be defined for callbacks. It's not ideal, but it works for this.
*/
#define IMPLEMENT_CALLBACK_FUNC_CB_ARG0(a,b) \
-static void glut##a##FuncCallback( FGCBUserData userData ) \
+static void fgh##a##FuncCallback( FGCBUserData userData ) \
{ \
FGCB##b callback = (FGCB##b)userData; \
callback(); \
}
#define IMPLEMENT_CALLBACK_FUNC_CB_ARG1(a,b) \
{ \
FGCB##b callback = (FGCB##b)userData; \
callback(); \
}
#define IMPLEMENT_CALLBACK_FUNC_CB_ARG1(a,b) \
-static void glut##a##FuncCallback( int arg1val, FGCBUserData userData ) \
+static void fgh##a##FuncCallback( int arg1val, FGCBUserData userData ) \
{ \
FGCB##b callback = (FGCB##b)userData; \
callback( arg1val ); \
}
#define IMPLEMENT_CALLBACK_FUNC_CB_ARG2(a,b) \
{ \
FGCB##b callback = (FGCB##b)userData; \
callback( arg1val ); \
}
#define IMPLEMENT_CALLBACK_FUNC_CB_ARG2(a,b) \
-static void glut##a##FuncCallback( int arg1val, int arg2val, FGCBUserData userData ) \
+static void fgh##a##FuncCallback( int arg1val, int arg2val, FGCBUserData userData ) \
{ \
FGCB##b callback = (FGCB##b)userData; \
callback( arg1val, arg2val ); \
}
#define IMPLEMENT_CALLBACK_FUNC_CB_ARG3_USER(a,b,arg1,arg2,arg3) \
{ \
FGCB##b callback = (FGCB##b)userData; \
callback( arg1val, arg2val ); \
}
#define IMPLEMENT_CALLBACK_FUNC_CB_ARG3_USER(a,b,arg1,arg2,arg3) \
-static void glut##a##FuncCallback( arg1 arg1val, arg2 arg2val, arg3 arg3val, FGCBUserData userData ) \
+static void fgh##a##FuncCallback( arg1 arg1val, arg2 arg2val, arg3 arg3val, FGCBUserData userData ) \
{ \
FGCB##b callback = (FGCB##b)userData; \
callback( arg1val, arg2val, arg3val ); \
}
#define IMPLEMENT_CALLBACK_FUNC_CB_ARG3(a,b) IMPLEMENT_CALLBACK_FUNC_CB_ARG3_USER(a,b,int,int,int)
#define IMPLEMENT_CALLBACK_FUNC_CB_ARG4(a,b) \
{ \
FGCB##b callback = (FGCB##b)userData; \
callback( arg1val, arg2val, arg3val ); \
}
#define IMPLEMENT_CALLBACK_FUNC_CB_ARG3(a,b) IMPLEMENT_CALLBACK_FUNC_CB_ARG3_USER(a,b,int,int,int)
#define IMPLEMENT_CALLBACK_FUNC_CB_ARG4(a,b) \
-static void glut##a##FuncCallback( int arg1val, int arg2val, int arg3val, int arg4val, FGCBUserData userData ) \
+static void fgh##a##FuncCallback( int arg1val, int arg2val, int arg3val, int arg4val, FGCBUserData userData ) \
{ \
FGCB##b callback = (FGCB##b)userData; \
callback( arg1val, arg2val, arg3val, arg4val ); \
}
#define IMPLEMENT_CALLBACK_FUNC_CB_ARG5(a,b) \
{ \
FGCB##b callback = (FGCB##b)userData; \
callback( arg1val, arg2val, arg3val, arg4val ); \
}
#define IMPLEMENT_CALLBACK_FUNC_CB_ARG5(a,b) \
-static void glut##a##FuncCallback( int arg1val, int arg2val, int arg3val, int arg4val, int arg5val, FGCBUserData userData ) \
+static void fgh##a##FuncCallback( int arg1val, int arg2val, int arg3val, int arg4val, int arg5val, FGCBUserData userData ) \
{ \
FGCB##b callback = (FGCB##b)userData; \
callback( arg1val, arg2val, arg3val, arg4val, arg5val ); \
{ \
FGCB##b callback = (FGCB##b)userData; \
callback( arg1val, arg2val, arg3val, arg4val, arg5val ); \
{ \
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glut"#a"Func" ); \
if( callback ) \
{ \
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glut"#a"Func" ); \
if( callback ) \
- glut##a##FuncUcall( glut##a##FuncCallback, (FGCBUserData)callback ); \
+ glut##a##FuncUcall( fgh##a##FuncCallback, (FGCBUserData)callback ); \
else \
glut##a##FuncUcall( NULL, NULL ); \
}
else \
glut##a##FuncUcall( NULL, NULL ); \
}
SET_CALLBACK( Display );
}
SET_CALLBACK( Display );
}
-static void glutDisplayFuncCallback( FGCBUserData userData )
+static void fghDisplayFuncCallback( FGCBUserData userData )
{
FGCBDisplay callback = (FGCBDisplay)userData;
callback();
{
FGCBDisplay callback = (FGCBDisplay)userData;
callback();
{
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutDisplayFunc" );
if( callback )
{
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutDisplayFunc" );
if( callback )
- glutDisplayFuncUcall( glutDisplayFuncCallback, (FGCBUserData)callback );
+ glutDisplayFuncUcall( fghDisplayFuncCallback, (FGCBUserData)callback );
else
glutDisplayFuncUcall( NULL, NULL );
}
else
glutDisplayFuncUcall( NULL, NULL );
}
SET_CALLBACK( Reshape );
}
SET_CALLBACK( Reshape );
}
-static void glutReshapeFuncCallback( int width, int height, FGCBUserData userData )
+static void fghReshapeFuncCallback( int width, int height, FGCBUserData userData )
{
FGCBReshape callback = (FGCBReshape)userData;
callback( width, height );
{
FGCBReshape callback = (FGCBReshape)userData;
callback( width, height );
{
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutReshapeFunc" );
if( callback )
{
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutReshapeFunc" );
if( callback )
- glutReshapeFuncUcall( glutReshapeFuncCallback, (FGCBUserData)callback );
+ glutReshapeFuncUcall( fghReshapeFuncCallback, (FGCBUserData)callback );
else
glutReshapeFuncUcall( NULL, NULL );
}
else
glutReshapeFuncUcall( NULL, NULL );
}
glutWindowStatusFuncUcall( NULL, NULL );
}
glutWindowStatusFuncUcall( NULL, NULL );
}
-static void glutVisibilityFuncCallback( int visibility, FGCBUserData userData )
+static void fghVisibilityFuncCallback( int visibility, FGCBUserData userData )
{
FGCBVisibility callback = (FGCBVisibility)userData;
callback( visibility );
{
FGCBVisibility callback = (FGCBVisibility)userData;
callback( visibility );
{
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutVisibilityFunc" );
if( callback )
{
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutVisibilityFunc" );
if( callback )
- glutVisibilityFuncUcall( glutVisibilityFuncCallback, (FGCBUserData)callback );
+ glutVisibilityFuncUcall( fghVisibilityFuncCallback, (FGCBUserData)callback );
else
glutVisibilityFuncUcall( NULL, NULL );
}
else
glutVisibilityFuncUcall( NULL, NULL );
}
fgStructure.CurrentWindow->State.JoystickLastPoll -= pollInterval;
}
fgStructure.CurrentWindow->State.JoystickLastPoll -= pollInterval;
}
-static void glutJoystickFuncCallback( unsigned int buttons, int axis0, int axis1, int axis2, FGCBUserData userData )
+static void fghJoystickFuncCallback( unsigned int buttons, int axis0, int axis1, int axis2, FGCBUserData userData )
{
FGCBJoystick callback = (FGCBJoystick)userData;
callback( buttons, axis0, axis1, axis2 );
{
FGCBJoystick callback = (FGCBJoystick)userData;
callback( buttons, axis0, axis1, axis2 );
{
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutJoystickFunc" );
if( callback )
{
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutJoystickFunc" );
if( callback )
- glutJoystickFuncUcall( glutJoystickFuncCallback, pollInterval, (FGCBUserData)callback );
+ glutJoystickFuncUcall( fghJoystickFuncCallback, pollInterval, (FGCBUserData)callback );
else
glutJoystickFuncUcall( NULL, pollInterval, NULL );
}
else
glutJoystickFuncUcall( NULL, pollInterval, NULL );
}
SET_CALLBACK( SpaceMotion );
}
SET_CALLBACK( SpaceMotion );
}
-static void glutSpaceballMotionFuncCallback( int x, int y, int z, FGCBUserData userData )
+static void fghSpaceballMotionFuncCallback( int x, int y, int z, FGCBUserData userData )
{
FGCBSpaceMotion callback = (FGCBSpaceMotion)userData;
callback( x, y, z );
{
FGCBSpaceMotion callback = (FGCBSpaceMotion)userData;
callback( x, y, z );
{
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSpaceballMotionFunc" );
if( callback )
{
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSpaceballMotionFunc" );
if( callback )
- glutSpaceballMotionFuncUcall( glutSpaceballMotionFuncCallback, (FGCBUserData)callback );
+ glutSpaceballMotionFuncUcall( fghSpaceballMotionFuncCallback, (FGCBUserData)callback );
else
glutSpaceballMotionFuncUcall( NULL, NULL );
}
else
glutSpaceballMotionFuncUcall( NULL, NULL );
}
SET_CALLBACK( SpaceRotation );
}
SET_CALLBACK( SpaceRotation );
}
-static void glutSpaceballRotateFuncCallback( int x, int y, int z, FGCBUserData userData )
+static void fghSpaceballRotateFuncCallback( int x, int y, int z, FGCBUserData userData )
{
FGCBSpaceRotation callback = (FGCBSpaceRotation)userData;
callback( x, y, z );
{
FGCBSpaceRotation callback = (FGCBSpaceRotation)userData;
callback( x, y, z );
{
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSpaceballRotateFunc" );
if( callback )
{
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSpaceballRotateFunc" );
if( callback )
- glutSpaceballRotateFuncUcall( glutSpaceballRotateFuncCallback, (FGCBUserData)callback );
+ glutSpaceballRotateFuncUcall( fghSpaceballRotateFuncCallback, (FGCBUserData)callback );
else
glutSpaceballRotateFuncUcall( NULL, NULL );
}
else
glutSpaceballRotateFuncUcall( NULL, NULL );
}
SET_CALLBACK( SpaceButton );
}
SET_CALLBACK( SpaceButton );
}
-static void glutSpaceballButtonFuncCallback( int button, int buttonState, FGCBUserData userData )
+static void fghSpaceballButtonFuncCallback( int button, int buttonState, FGCBUserData userData )
{
FGCBSpaceButton callback = (FGCBSpaceButton)userData;
callback( button, buttonState );
{
FGCBSpaceButton callback = (FGCBSpaceButton)userData;
callback( button, buttonState );
{
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSpaceballButtonFunc" );
if( callback )
{
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSpaceballButtonFunc" );
if( callback )
- glutSpaceballButtonFuncUcall( glutSpaceballButtonFuncCallback, (FGCBUserData)callback );
+ glutSpaceballButtonFuncUcall( fghSpaceballButtonFuncCallback, (FGCBUserData)callback );
else
glutSpaceballButtonFuncUcall( NULL, NULL );
}
else
glutSpaceballButtonFuncUcall( NULL, NULL );
}
fgState.ErrorFuncData = userData;
}
fgState.ErrorFuncData = userData;
}
-static void glutInitErrorFuncCallback( const char *fmt, va_list ap, FGCBUserData userData )
+static void fghInitErrorFuncCallback( const char *fmt, va_list ap, FGCBUserData userData )
{
FGError callback = (FGError)userData;
callback( fmt, ap );
{
FGError callback = (FGError)userData;
callback( fmt, ap );
void FGAPIENTRY glutInitErrorFunc( FGError callback )
{
void FGAPIENTRY glutInitErrorFunc( FGError callback )
{
- if (callback)
- glutInitErrorFuncUcall( glutInitErrorFuncCallback, (FGCBUserData)callback );
- else
- glutInitErrorFuncUcall( NULL, NULL );
+ if (callback)
+ {
+ glutInitErrorFuncUcall( fghInitErrorFuncCallback, (FGCBUserData)callback );
+ }
+ else
+ {
+ glutInitErrorFuncUcall( NULL, NULL );
+ }
fgState.WarningFuncData = userData;
}
fgState.WarningFuncData = userData;
}
-static void glutInitWarningFuncCallback( const char *fmt, va_list ap, FGCBUserData userData )
+static void fghInitWarningFuncCallback( const char *fmt, va_list ap, FGCBUserData userData )
{
FGWarning callback = (FGWarning)userData;
callback( fmt, ap );
{
FGWarning callback = (FGWarning)userData;
callback( fmt, ap );
void FGAPIENTRY glutInitWarningFunc( FGWarning callback )
{
void FGAPIENTRY glutInitWarningFunc( FGWarning callback )
{
- if (callback)
- glutInitWarningFuncUcall( glutInitWarningFuncCallback, (FGCBUserData)callback );
- else
- glutInitWarningFuncUcall( NULL, NULL );
+ if (callback)
+ {
+ glutInitWarningFuncUcall( fghInitWarningFuncCallback, (FGCBUserData)callback );
+ }
+ else
+ {
+ glutInitWarningFuncUcall( NULL, NULL );
+ }
* The {if( FETCH_WCB( ... ) != func )} test is to do type-checking
* and for no other reason. Since it's hidden in the macro, the
* ugliness is felt to be rather benign.
* The {if( FETCH_WCB( ... ) != func )} test is to do type-checking
* and for no other reason. Since it's hidden in the macro, the
* ugliness is felt to be rather benign.
+ *
+ * If the function-pointer is the same, the data will be the only
+ * value updated. If the function-pointer changes, the data will
+ * be changed as well, preventing stail data from being passed in.
+ * Just updating the data does nothing unless a function-pointer
+ * exists, as the data is otherwise already allocated.
*/
#define SET_WCB(window,cbname,func,udata) \
do \
*/
#define SET_WCB(window,cbname,func,udata) \
do \
(((window).CallBacks[WCB_ ## cbname]) = (SFG_Proc)(func)); \
(((window).CallbackDatas[WCB_ ## cbname]) = (udata)); \
} \
(((window).CallBacks[WCB_ ## cbname]) = (SFG_Proc)(func)); \
(((window).CallbackDatas[WCB_ ## cbname]) = (udata)); \
} \
+ else if( FETCH_USER_DATA_WCB( window, cbname ) != udata ) \
+ { \
+ (((window).CallbackDatas[WCB_ ## cbname]) = (udata)); \
+ } \
* {cbname} is the window-specific callback to be invoked,
*
* This expects a variable named "window" of type tagSFG_Window to exist.
* {cbname} is the window-specific callback to be invoked,
*
* This expects a variable named "window" of type tagSFG_Window to exist.
- */
-/*
- * FETCH_USER_DATA_WCB() is used as:
- *
- * FETCH_USER_DATA_WCB( window, cbname );
- *
- * ...where {window} is the freeglut window to fetch the callback data from,
- * {cbname} is the window-specific callback data to fetch.
*
* The result is the callback data pointer.
*/
*
* The result is the callback data pointer.
*/
{
/* The menu object creation code resides in fg_structure.c */
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutCreateMenuUcall" );
{
/* The menu object creation code resides in fg_structure.c */
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutCreateMenuUcall" );
- if (fgState.ActiveMenus)
- fgError("Menu manipulation not allowed while menus in use.");
+ if (fgState.ActiveMenus)
+ {
+ fgError( "Menu manipulation not allowed while menus in use." );
+ }
return fgCreateMenu( callback, userData )->ID;
}
/* Standard glutCreateMenu */
return fgCreateMenu( callback, userData )->ID;
}
/* Standard glutCreateMenu */
-static void glutCreateMenuCallback( int menu, FGCBUserData userData )
+static void fghCreateMenuCallback( int menu, FGCBUserData userData )
{
FGCBMenu callback = (FGCBMenu)userData;
callback( menu );
{
FGCBMenu callback = (FGCBMenu)userData;
callback( menu );
{
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutCreateMenu" );
if (!callback)
{
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutCreateMenu" );
if (!callback)
return glutCreateMenuUcall( NULL, NULL );
return glutCreateMenuUcall( NULL, NULL );
- return glutCreateMenuUcall( glutCreateMenuCallback, (FGCBUserData)callback );
+ }
+ return glutCreateMenuUcall( fghCreateMenuCallback, (FGCBUserData)callback );