X-Git-Url: http://git.mutantstargoat.com/user/nuclear/?a=blobdiff_plain;f=src%2Ffreeglut_main.c;h=fb756545f9e42b5991f3b579373c2aaef8837e97;hb=d6ccf7c81bdad11e6902a258e8e21fdbe6b9f968;hp=e5b7c508c5ca4438ba51e71409a1065716fcee85;hpb=4cba0748bb698d485cdad359b28ae4b2c6acc362;p=freeglut

diff --git a/src/freeglut_main.c b/src/freeglut_main.c
index e5b7c50..fb75654 100644
--- a/src/freeglut_main.c
+++ b/src/freeglut_main.c
@@ -29,7 +29,7 @@
 #include "config.h"
 #endif
 
-#include "../include/GL/freeglut.h"
+#include <GL/freeglut.h>
 #include "freeglut_internal.h"
 
 #include <limits.h>
@@ -87,54 +87,65 @@ static void fghReshapeWindowByHandle ( SFG_WindowHandleType handle,
 #elif TARGET_HOST_WIN32
 
     {
-        RECT winRect;
-        int x, y;
+        RECT rect;
 
-        GetWindowRect( window->Window.Handle, &winRect );
-        x = winRect.left;
-        y = winRect.top;
+        /*
+         * For windowed mode, get the current position of the
+         * window and resize taking the size of the frame
+         * decorations into account.
+         */
+
+        GetWindowRect( window->Window.Handle, &rect );
+        rect.right  = rect.left + width;
+        rect.bottom = rect.top  + height;
 
         if ( window->Parent == NULL )
         {
-            /*
-             * Adjust the size of the window to allow for the size of the
-             * frame, if we are not a menu
-             */
-            if ( ! window->IsMenu )
+            if ( ! window->IsMenu && !window->State.IsGameMode )
             {
-                width += GetSystemMetrics( SM_CXSIZEFRAME ) * 2;
-                height += GetSystemMetrics( SM_CYSIZEFRAME ) * 2 +
-                    GetSystemMetrics( SM_CYCAPTION );
+                rect.right  += GetSystemMetrics( SM_CXSIZEFRAME ) * 2;
+                rect.bottom += GetSystemMetrics( SM_CYSIZEFRAME ) * 2 +
+                               GetSystemMetrics( SM_CYCAPTION );
             }
         }
         else
         {
-            GetWindowRect( window->Parent->Window.Handle,
-                           &winRect );
-            x -= winRect.left + GetSystemMetrics( SM_CXSIZEFRAME );
-            y -= winRect.top + GetSystemMetrics( SM_CYSIZEFRAME ) +
-                GetSystemMetrics( SM_CYCAPTION );
+            GetWindowRect( window->Parent->Window.Handle, &rect );
+            AdjustWindowRect ( &rect, WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS |
+                                      WS_CLIPCHILDREN, FALSE );
         }
 
-        MoveWindow(
-            window->Window.Handle,
-            x,
-            y,
-            width,
-            height,
-            TRUE
+        /*
+         * SWP_NOACTIVATE      Do not activate the window
+         * SWP_NOOWNERZORDER   Do not change position in z-order
+         * SWP_NOSENDCHANGING  Supress WM_WINDOWPOSCHANGING message
+         * SWP_NOZORDER        Retains the current Z order (ignore 2nd param)
+         */
+
+        SetWindowPos( window->Window.Handle,
+                      HWND_TOP,
+                      rect.left,
+                      rect.top,
+                      rect.right  - rect.left,
+                      rect.bottom - rect.top,
+                      SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOSENDCHANGING |
+                      SWP_NOZORDER
         );
     }
 
-#endif
-
-    if( !( FETCH_WCB( *window, Reshape ) ) )
+    /*
+     * XXX Should update {window->State.OldWidth, window->State.OldHeight}
+     * XXX to keep in lockstep with UNIX_X11 code.
+     */
+    if( FETCH_WCB( *window, Reshape ) )
+        INVOKE_WCB( *window, Reshape, ( width, height ) );
+    else
     {
         fgSetWindow( window );
         glViewport( 0, 0, width, height );
     }
-    else
-        INVOKE_WCB( *window, Reshape, ( width, height ) );
+
+#endif
 
     /*
      * Force a window redraw.  In Windows at least this is only a partial
@@ -169,14 +180,14 @@ static void fghRedrawWindowByHandle ( SFG_WindowHandleType handle )
 
         fgSetWindow( window );
 
-        fghReshapeWindowByHandle( 
+        fghReshapeWindowByHandle(
             window->Window.Handle,
             window->State.Width,
             window->State.Height
         );
 
         window->State.NeedToResize = GL_FALSE;
-        fgSetWindow ( current_window );
+        fgSetWindow( current_window );
     }
 
     INVOKE_WCB( *window, Display, ( ) );
@@ -188,25 +199,25 @@ static void fghRedrawWindowByHandle ( SFG_WindowHandleType handle )
 static void fghcbDisplayWindow( SFG_Window *window,
                                 SFG_Enumerator *enumerator )
 {
-    if( window->State.Redisplay &&
-        window->State.Visible )
+    if( window->State.NeedToResize )
     {
-        if( window->State.NeedToResize )
-        {
-            SFG_Window *current_window = fgStructure.Window;
+        SFG_Window *current_window = fgStructure.Window;
 
-            fgSetWindow( window );
+        fgSetWindow( window );
 
-            fghReshapeWindowByHandle( 
-                window->Window.Handle,
-                window->State.Width,
-                window->State.Height
-            );
+        fghReshapeWindowByHandle(
+            window->Window.Handle,
+            window->State.Width,
+            window->State.Height
+        );
 
-            window->State.NeedToResize = GL_FALSE;
-            fgSetWindow ( current_window );
-        }
+        window->State.NeedToResize = GL_FALSE;
+        fgSetWindow ( current_window );
+    }
 
+    if( window->State.Redisplay &&
+        window->State.Visible )
+    {
         window->State.Redisplay = GL_FALSE;
 
 #if TARGET_HOST_UNIX_X11
@@ -218,7 +229,7 @@ static void fghcbDisplayWindow( SFG_Window *window,
         }
 #elif TARGET_HOST_WIN32
         RedrawWindow(
-            window->Window.Handle, NULL, NULL, 
+            window->Window.Handle, NULL, NULL,
             RDW_NOERASE | RDW_INTERNALPAINT | RDW_INVALIDATE | RDW_UPDATENOW
         );
 #endif
@@ -277,38 +288,21 @@ static void fghCheckJoystickPolls( void )
 static void fghCheckTimers( void )
 {
     long checkTime = fgElapsedTime( );
-    SFG_Timer *timer, *next;
-    SFG_List timedOut;
 
-    fgListInit(&timedOut);
-
-    for( timer = (SFG_Timer *)fgState.Timers.First;
-         timer;
-         timer = (SFG_Timer *)next )
+    while( fgState.Timers.First )
     {
-        next = (SFG_Timer *)timer->Node.Next;
+        SFG_Timer *timer = fgState.Timers.First;
 
-        if( timer->TriggerTime <= checkTime )
-        {
-            fgListRemove( &fgState.Timers, &timer->Node );
-            fgListAppend( &timedOut, &timer->Node );
-        }
-    }
+        if( timer->TriggerTime > checkTime )
+            break;
 
-    /*
-     * Now feel free to execute all the hooked and timed out timer callbacks
-     * And delete the timed out timers...
-     */
-    while ( (timer = (SFG_Timer *)timedOut.First) )
-    {
-        if( timer->Callback != NULL )
-            timer->Callback( timer->ID );
-        fgListRemove( &timedOut, &timer->Node );
-        free( timer );
+        fgListRemove( &fgState.Timers, &timer->Node );
+        fgListAppend( &fgState.FreeTimers, &timer->Node );
+
+        timer->Callback( timer->ID );
     }
 }
 
-
 /*
  * Elapsed Time
  */
@@ -319,12 +313,12 @@ long fgElapsedTime( void )
 #if TARGET_HOST_UNIX_X11
         struct timeval now;
         long elapsed;
-        
+
         gettimeofday( &now, NULL );
-        
+
         elapsed = (now.tv_usec - fgState.Time.Value.tv_usec) / 1000;
         elapsed += (now.tv_sec - fgState.Time.Value.tv_sec) * 1000;
-        
+
         return elapsed;
 #elif TARGET_HOST_WIN32
         return timeGetTime() - fgState.Time.Value;
@@ -385,20 +379,12 @@ void fgWarning( const char *fmt, ... )
  * Indicates whether Joystick events are being used by ANY window.
  *
  * The current mechanism is to walk all of the windows and ask if
- * there is a joystick callback.  Certainly in some cases, maybe
- * in all cases, the joystick is attached to the system and accessed
- * from ONE point by GLUT/freeglut, so this is not the right way,
- * in general, to do this.  However, the Joystick code is segregated
- * in its own little world, so we can't access the information that
- * we need in order to do that nicely.
+ * there is a joystick callback.  We have a short-circuit early
+ * return if we find any joystick handler registered.
  *
- * Some alternatives:
- *  * Store Joystick data into freeglut global state.
- *  * Provide NON-static functions or data from Joystick *.c file.
- *
- * Basically, the RIGHT way to do this requires knowing something
- * about the Joystick.  Right now, the Joystick code is behind
- * an opaque wall.
+ * The real way to do this is to make use of the glutTimer() API
+ * to more cleanly re-implement the joystick API.  Then, this code
+ * and all other "joystick timer" code can be yanked.
  *
  */
 static void fgCheckJoystickCallback( SFG_Window* w, SFG_Enumerator* e)
@@ -426,7 +412,7 @@ static void fgHavePendingRedisplaysCallback( SFG_Window* w, SFG_Enumerator* e)
         e->data = w;
     }
     fgEnumSubWindows( w, fgHavePendingRedisplaysCallback, e );
-}        
+}
 static int fgHavePendingRedisplays (void)
 {
     SFG_Enumerator enumerator;
@@ -436,27 +422,17 @@ static int fgHavePendingRedisplays (void)
     return !!enumerator.data;
 }
 /*
- * Indicates whether there are any outstanding timers.
- */
-#if 0 /* Not used */
-static int fgHaveTimers( void )
-{
-    return !!fgState.Timers.First;
-}
-#endif
-/*
  * Returns the number of GLUT ticks (milliseconds) till the next timer event.
  */
 static long fgNextTimer( void )
 {
-    long now = fgElapsedTime();
     long ret = INT_MAX;
-    SFG_Timer *timer;
+    SFG_Timer *timer = fgState.Timers.First;
 
-    for( timer = (SFG_Timer *)fgState.Timers.First;
-         timer;
-         timer = (SFG_Timer *)timer->Node.Next )
-        ret = MIN( ret, MAX( 0, timer->TriggerTime - now ) );
+    if( timer )
+        ret = timer->TriggerTime - fgElapsedTime();
+    if( ret < 0 )
+        ret = 0;
 
     return ret;
 }
@@ -466,31 +442,44 @@ static long fgNextTimer( void )
  */
 static void fgSleepForEvents( void )
 {
-#if TARGET_HOST_UNIX_X11
-    fd_set fdset;
-    int err;
-    int socket;
-    struct timeval wait;
-    long msec;    
-    
+    long msec;
+
     if( fgState.IdleCallback || fgHavePendingRedisplays( ) )
         return;
-    socket = ConnectionNumber( fgDisplay.Display );
-    FD_ZERO( &fdset );
-    FD_SET( socket, &fdset );
-    
+
     msec = fgNextTimer( );
-    if( fgHaveJoystick( ) )
-        msec = MIN( msec, 10 );
-    
-    wait.tv_sec = msec / 1000;
-    wait.tv_usec = (msec % 1000) * 1000;
-    err = select( socket+1, &fdset, NULL, NULL, &wait );
-
-    if( -1 == err )
-        fgWarning ( "freeglut select() error: %d\n", errno );
-    
+    if( fgHaveJoystick( ) )     /* XXX Use GLUT timers for joysticks... */
+        msec = MIN( msec, 10 ); /* XXX Dumb; forces granularity to .01sec */
+
+#if TARGET_HOST_UNIX_X11
+    /*
+     * Possibly due to aggressive use of XFlush() and friends,
+     * it is possible to have our socket drained but still have
+     * unprocessed events.  (Or, this may just be normal with
+     * X, anyway?)  We do non-trivial processing of X events
+     * after tham in event-reading loop, in any case, so we
+     * need to allow that we may have an empty socket but non-
+     * empty event queue.
+     */
+    if( ! XPending( fgDisplay.Display ) )
+    {
+        fd_set fdset;
+        int err;
+        int socket;
+        struct timeval wait;
+
+        socket = ConnectionNumber( fgDisplay.Display );
+        FD_ZERO( &fdset );
+        FD_SET( socket, &fdset );
+        wait.tv_sec = msec / 1000;
+        wait.tv_usec = (msec % 1000) * 1000;
+        err = select( socket+1, &fdset, NULL, NULL, &wait );
+
+        if( -1 == err )
+            fgWarning ( "freeglut select() error: %d\n", errno );
+    }
 #elif TARGET_HOST_WIN32
+    MsgWaitForMultipleObjects( 0, NULL, FALSE, msec, QS_ALLEVENTS );
 #endif
 }
 
@@ -508,7 +497,7 @@ int fgGetXModifiers( XEvent *event )
         ret |= GLUT_ACTIVE_CTRL;
     if( event->xkey.state & Mod1Mask )
         ret |= GLUT_ACTIVE_ALT;
-    
+
     return ret;
 }
 #endif
@@ -551,10 +540,18 @@ void FGAPIENTRY glutMainLoopEvent( void )
              */
             if( (Atom) event.xclient.data.l[ 0 ] == fgDisplay.DeleteWindow )
             {
-                GETWINDOW( xclient ); 
+                GETWINDOW( xclient );
+
+                fgDestroyWindow ( window );
 
-                fgCloseWindow ( window );
-                fgAddToWindowDestroyList ( window, GL_FALSE );
+                if( fgState.ActionOnWindowClose == GLUT_ACTION_EXIT )
+                {
+                    fgDeinitialize( );
+                    exit( 0 );
+                }
+
+                fgState.ExecState = GLUT_EXEC_STATE_STOP;
+                return;
             }
             break;
 
@@ -564,39 +561,65 @@ void FGAPIENTRY glutMainLoopEvent( void )
              * (in freeglut only) will not get an initial reshape event,
              * which can break things.
              *
-             * XXX NOTE that it is possible that you will more than one Reshape
-             * XXX event for your top-level window, but something like this
-             * XXX appears to be required for compatbility.
-             *
              * GLUT presumably does this because it generally tries to treat
              * sub-windows the same as windows.
+             *
+             * XXX Technically, GETWINDOW( xconfigure ) and
+             * XXX {event.xconfigure} may not be legit ways to get at
+             * XXX data for CreateNotify events.  In practice, the data
+             * XXX is in a union which is laid out much the same either
+             * XXX way.  But if you want to split hairs, this isn't legit,
+             * XXX and we should instead duplicate some code.
              */
         case CreateNotify:
         case ConfigureNotify:
             GETWINDOW( xconfigure );
-            window->State.NeedToResize = GL_TRUE ;
-            window->State.Width  = event.xconfigure.width ;
-            window->State.Height = event.xconfigure.height;
+            {
+                int width = event.xconfigure.width;
+                int height = event.xconfigure.height;
+
+                if( ( width != window->State.OldWidth ) ||
+                    ( height != window->State.OldHeight ) )
+                {
+                    window->State.OldWidth = width;
+                    window->State.OldHeight = height;
+                    if( FETCH_WCB( *window, Reshape ) )
+                        INVOKE_WCB( *window, Reshape, ( width, height ) );
+                    else
+                    {
+                        fgSetWindow( window );
+                        glViewport( 0, 0, width, height );
+                    }
+                    glutPostRedisplay( );
+                }
+            }
             break;
 
         case DestroyNotify:
             /*
              * This is sent to confirm the XDestroyWindow call.
+             *
              * XXX WHY is this commented out?  Should we re-enable it?
              */
-            /* fgAddToWindowDestroyList ( window, GL_FALSE ); */
+            /* fgAddToWindowDestroyList ( window ); */
             break;
 
         case Expose:
             /*
              * We are too dumb to process partial exposes...
+             *
              * XXX Well, we could do it.  However, it seems to only
              * XXX be potentially useful for single-buffered (since
              * XXX double-buffered does not respect viewport when we
              * XXX do a buffer-swap).
+             *
              */
             if( event.xexpose.count == 0 )
-                fghRedrawWindowByHandle( event.xexpose.window );
+            {
+                GETWINDOW( xexpose );
+                fgSetWindow( window );
+                glutPostRedisplay( );
+            }
             break;
 
         case MapNotify:
@@ -617,7 +640,10 @@ void FGAPIENTRY glutMainLoopEvent( void )
 
         case VisibilityNotify:
         {
-            GETWINDOW( xvisibility ); 
+            GETWINDOW( xvisibility );
+            /*
+             * XXX INVOKE_WCB() does this check for us.
+             */
             if( ! FETCH_WCB( *window, WindowStatus ) )
                 break;
             fgSetWindow( window );
@@ -634,13 +660,13 @@ void FGAPIENTRY glutMainLoopEvent( void )
                 INVOKE_WCB( *window, WindowStatus, ( GLUT_FULLY_RETAINED ) );
                 window->State.Visible = GL_TRUE;
                 break;
-                
+
             case VisibilityPartiallyObscured:
                 INVOKE_WCB( *window, WindowStatus,
                             ( GLUT_PARTIALLY_RETAINED ) );
                 window->State.Visible = GL_TRUE;
                 break;
-                
+
             case VisibilityFullyObscured:
                 INVOKE_WCB( *window, WindowStatus, ( GLUT_FULLY_COVERED ) );
                 window->State.Visible = GL_FALSE;
@@ -685,7 +711,9 @@ void FGAPIENTRY glutMainLoopEvent( void )
 
             /*
              * XXX For more than 5 buttons, just check {event.xmotion.state},
-             * XXX rather than a host of bit-masks?
+             * XXX rather than a host of bit-masks?  Or maybe we need to
+             * XXX track ButtonPress/ButtonRelease events in our own
+             * XXX bit-mask?
              */
 #define BUTTON_MASK \
   ( Button1Mask | Button2Mask | Button3Mask | Button4Mask | Button5Mask )
@@ -713,7 +741,7 @@ void FGAPIENTRY glutMainLoopEvent( void )
              */
             GETWINDOW( xbutton );
             GETMOUSE( xbutton );
-          
+
             /*
              * An X button (at least in XFree86) is numbered from 1.
              * A GLUT button is numbered from 0.
@@ -755,7 +783,7 @@ void FGAPIENTRY glutMainLoopEvent( void )
                     window->ActiveMenu->Window->State.MouseY =
                         event.xbutton.y_root - window->ActiveMenu->Y;
                 }
-              
+
                 /* In the menu, invoke the callback and deactivate the menu*/
                 if( fgCheckActiveMenu( window->ActiveMenu->Window,
                                        window->ActiveMenu ) )
@@ -782,12 +810,19 @@ void FGAPIENTRY glutMainLoopEvent( void )
                 else if( pressed )
                     /*
                      * Outside the menu, deactivate if it's a downclick
+                     *
                      * XXX This isn't enough.  A downclick outside of
                      * XXX the interior of our freeglut windows should also
                      * XXX deactivate the menu.  This is more complicated.
                      */
                     fgDeactivateMenu( window->ActiveMenu->ParentWindow );
-              
+
+                /*
+                 * XXX Why does an active menu require a redisplay at
+                 * XXX this point?  If this can come out cleanly, then
+                 * XXX it probably should do so; if not, a comment should
+                 * XXX explain it.
+                 */
                 window->State.Redisplay = GL_TRUE;
                 break;
             }
@@ -800,6 +835,9 @@ void FGAPIENTRY glutMainLoopEvent( void )
                 ( window->Menu[ button ] ) &&
                 pressed )
             {
+                /*
+                 * XXX Posting a requisite Redisplay seems bogus.
+                 */
                 window->State.Redisplay = GL_TRUE;
                 fgSetWindow( window );
                 fgActivateMenu( window, button );
@@ -819,7 +857,7 @@ void FGAPIENTRY glutMainLoopEvent( void )
             /*
              * Finally execute the mouse or mouse wheel callback
              *
-             * XXX Use a symbolic constant, *not* "4"!
+             * XXX Use a symbolic constant, *not* "4"!  ("3, sire!")
              */
             if( ( button < 3 ) || ( ! FETCH_WCB( *window, MouseWheel ) ) )
                 INVOKE_WCB( *window, Mouse, ( button,
@@ -845,7 +883,7 @@ void FGAPIENTRY glutMainLoopEvent( void )
                 int direction = -1;
                 if( button % 2 )
                     direction = 1;
-                
+
                 if( pressed )
                     INVOKE_WCB( *window, MouseWheel, ( wheel_number,
                                                        direction,
@@ -988,14 +1026,23 @@ void FGAPIENTRY glutMainLoopEvent( void )
     while( PeekMessage( &stMsg, NULL, 0, 0, PM_NOREMOVE ) )
     {
         if( GetMessage( &stMsg, NULL, 0, 0 ) == 0 )
-            fgState.ExecState = GLUT_EXEC_STATE_STOP ;
+        {
+            if( fgState.ActionOnWindowClose == GLUT_ACTION_EXIT )
+            {
+                fgDeinitialize( );
+                exit( 0 );
+            }
+            fgState.ExecState = GLUT_EXEC_STATE_STOP;
+            return;
+        }
 
         TranslateMessage( &stMsg );
         DispatchMessage( &stMsg );
     }
 #endif
 
-    fghCheckTimers( );
+    if( fgState.Timers.First )
+        fghCheckTimers( );
     fghCheckJoystickPolls( );
     fghDisplayAll( );
 
@@ -1008,6 +1055,8 @@ void FGAPIENTRY glutMainLoopEvent( void )
  */
 void FGAPIENTRY glutMainLoop( void )
 {
+    int action;
+
 #if TARGET_HOST_WIN32
     SFG_Window *window = (SFG_Window *)fgStructure.Windows.First ;
 #endif
@@ -1033,7 +1082,7 @@ void FGAPIENTRY glutMainLoop( void )
             INVOKE_WCB( *window, Visibility, ( window->State.Visible ) );
             fgSetWindow( current_window );
         }
-        
+
         window = (SFG_Window *)window->Node.Next ;
     }
 #endif
@@ -1041,31 +1090,40 @@ void FGAPIENTRY glutMainLoop( void )
     fgState.ExecState = GLUT_EXEC_STATE_RUNNING ;
     while( fgState.ExecState == GLUT_EXEC_STATE_RUNNING )
     {
+        SFG_Window *window;
+
         glutMainLoopEvent( );
+        /*
+         * Step through the list of windows, seeing if there are any
+         * that are not menus
+         */
+        for( window = ( SFG_Window * )fgStructure.Windows.First;
+             window;
+             window = ( SFG_Window * )window->Node.Next )
+            if ( ! ( window->IsMenu ) )
+                break;
 
-        if( fgStructure.Windows.First == NULL )
+        if( ! window )
             fgState.ExecState = GLUT_EXEC_STATE_STOP;
         else
         {
             if( fgState.IdleCallback )
                 fgState.IdleCallback( );
 
-            fgSleepForEvents();
+            fgSleepForEvents( );
         }
     }
 
-    {
-        fgExecutionState execState = fgState.ExecState;
-        
-        /*
-         * When this loop terminates, destroy the display, state and structure
-         * of a freeglut session, so that another glutInit() call can happen
-         */
-        fgDeinitialize( );
-
-        if( execState == GLUT_ACTION_EXIT )
-            exit( 0 );
-    }
+    /*
+     * When this loop terminates, destroy the display, state and structure
+     * of a freeglut session, so that another glutInit() call can happen
+     *
+     * Save the "ActionOnWindowClose" because "fgDeinitialize" resets it.
+     */
+    action = fgState.ActionOnWindowClose;
+    fgDeinitialize( );
+    if( action == GLUT_ACTION_EXIT )
+        exit( 0 );
 }
 
 /*
@@ -1165,19 +1223,25 @@ LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam,
 
     case WM_SIZE:
         /*
-         * We got resized... But check if the window has been already added...
+         * If the window is visible, then it is the user manually resizing it.
+         * If it is not, then it is the system sending us a dummy resize with
+         * zero dimensions on a "glutIconifyWindow" call.
          */
-        window->State.NeedToResize = GL_TRUE;
-        window->State.Width  = LOWORD(lParam);
-        window->State.Height = HIWORD(lParam);
+        if( window->State.Visible )
+        {
+            window->State.NeedToResize = GL_TRUE;
+            window->State.Width  = LOWORD(lParam);
+            window->State.Height = HIWORD(lParam);
+        }
+
         break;
 #if 0
-    case WM_SETFOCUS: 
+    case WM_SETFOCUS:
         printf("WM_SETFOCUS: %p\n", window );
         lRet = DefWindowProc( hWnd, uMsg, wParam, lParam );
         break;
 
-    case WM_ACTIVATE: 
+    case WM_ACTIVATE:
         if (LOWORD(wParam) != WA_INACTIVE)
         {
             /* glutSetCursor( fgStructure.Window->State.Cursor ); */
@@ -1198,7 +1262,7 @@ LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam,
          * XXX call glutSetCurdsor() instead of defining two macros
          * XXX and implementing a nested case in-line.
          */
-    case WM_SETCURSOR: 
+    case WM_SETCURSOR:
         /* Set the cursor AND change it for this window class. */
 #define MAP_CURSOR(a,b)                 \
     case a:                             \
@@ -1248,38 +1312,9 @@ LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam,
         break;
 
     case WM_CLOSE:
-        /*
-         * Make sure we don't close a window with current context active
-         */
-        if( fgStructure.Window == window )
-        {
-            int used = FALSE ;
-            SFG_Window *iter ;
-
-            wglMakeCurrent( NULL, NULL );
-            /*
-             * Step through the list of windows.  If the rendering context
-             * is not being used by another window, then we delete it.
-             */
-            for( iter = (SFG_Window *)fgStructure.Windows.First;
-                 iter;
-                 iter = (SFG_Window *)iter->Node.Next )
-            {
-                if( ( iter->Window.Context == window->Window.Context ) &&
-                    ( iter != window ) )
-                    used = TRUE;
-            }
-
-            if( ! used )
-                wglDeleteContext( window->Window.Context );
-        }
-
-        /*
-         * Put on a linked list of windows to be removed after all the
-         * callbacks have returned
-         */
-        fgAddToWindowDestroyList( window, GL_FALSE );
-        DestroyWindow( hWnd );
+        fgDestroyWindow ( window );
+        if ( fgState.ActionOnWindowClose != GLUT_ACTION_CONTINUE_EXECUTION )
+            PostQuitMessage(0);
         break;
 
     case WM_DESTROY:
@@ -1292,7 +1327,7 @@ LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam,
     {
         window->State.MouseX = LOWORD( lParam );
         window->State.MouseY = HIWORD( lParam );
-        
+
         if ( window->ActiveMenu )
         {
             window->State.Redisplay = GL_TRUE;
@@ -1361,10 +1396,13 @@ LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam,
         }
 
         if( GetSystemMetrics( SM_SWAPBUTTON ) )
+        {
             if( button == GLUT_LEFT_BUTTON )
                 button = GLUT_RIGHT_BUTTON;
-            else if( button == GLUT_RIGHT_BUTTON )
-                button = GLUT_LEFT_BUTTON;
+            else
+                if( button == GLUT_RIGHT_BUTTON )
+                    button = GLUT_LEFT_BUTTON;
+        }
 
         if( button == -1 )
             return DefWindowProc( hWnd, uMsg, lParam, wParam );
@@ -1429,7 +1467,7 @@ LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam,
             break;
         }
 
-        if ( window->Menu[ button ] && pressed )
+        if( window->Menu[ button ] && pressed )
         {
             window->State.Redisplay = GL_TRUE;
             fgSetWindow( window );
@@ -1527,11 +1565,11 @@ LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam,
         int keypress = -1;
         POINT mouse_pos ;
 
-        if( fgState.IgnoreKeyRepeat && (lParam & KF_REPEAT) )
+        if( fgState.IgnoreKeyRepeat && (HIWORD(lParam) & KF_REPEAT) )
             break;
 
         /*
-         * Remember the current modifiers state. This is done here in order 
+         * Remember the current modifiers state. This is done here in order
          * to make sure the VK_DELETE keyboard callback is executed properly.
          */
         fgState.Modifiers = fgGetWin32Modifiers( );
@@ -1597,7 +1635,7 @@ LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam,
         POINT mouse_pos;
 
         /*
-         * Remember the current modifiers state. This is done here in order 
+         * Remember the current modifiers state. This is done here in order
          * to make sure the VK_DELETE keyboard callback is executed properly.
          */
         fgState.Modifiers = fgGetWin32Modifiers( );
@@ -1650,9 +1688,9 @@ LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam,
         {
             BYTE state[ 256 ];
             WORD code[ 2 ];
-            
+
             GetKeyboardState( state );
-            
+
             if( ToAscii( wParam, 0, state, code, 0 ) == 1 )
                 wParam=code[ 0 ];
 
@@ -1676,7 +1714,7 @@ LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam,
     case WM_SYSCHAR:
     case WM_CHAR:
     {
-        if( fgState.IgnoreKeyRepeat && (lParam & KF_REPEAT) )
+        if( fgState.IgnoreKeyRepeat && (HIWORD(lParam) & KF_REPEAT) )
             break;
 
         fgState.Modifiers = fgGetWin32Modifiers( );