Cleanup pass after committing callback conversion (from structure to

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

freeglut/freeglut/src/freeglut_callbacks.c

@@ -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 ) )

freeglut/freeglut/src/freeglut_internal.h

@@ -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        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        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 */
+    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      */
     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 */
+    fgExecutionState ExecState;           /* Used for GLUT termination       */
-    char            *ProgramName ;         /* Name of the program invoking the "freeglut" library" */
+    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         *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
 {
@@ -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_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
@@ -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 );
+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
 
 /*
  * 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
 

freeglut/freeglut/src/freeglut_main.c

@@ -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 ) ; */

freeglut/freeglut/src/freeglut_structure.c

@@ -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 ) ;
     }