X-Git-Url: http://git.mutantstargoat.com/user/nuclear/?a=blobdiff_plain;f=src%2Ffreeglut_window.c;h=6217627dad6fb4695a4f8235419804e8655f3cc5;hb=65e03872c287ab34ae76bd1831a3786d5e986b72;hp=6fc6ade4a6eccb021b4df599bcc5e256f7dc49cd;hpb=2cf5907afe7e631b9112031f30ed84c5fc527d5f;p=freeglut

diff --git a/src/freeglut_window.c b/src/freeglut_window.c
index 6fc6ade..6217627 100644
--- a/src/freeglut_window.c
+++ b/src/freeglut_window.c
@@ -29,9 +29,7 @@
 #include "config.h"
 #endif
 
-#define  G_LOG_DOMAIN  "freeglut-window"
-
-#include "../include/GL/freeglut.h"
+#include <GL/freeglut.h>
 #include "freeglut_internal.h"
 
 /*
@@ -68,7 +66,7 @@ XVisualInfo* fgChooseVisual( void )
 {
 #define BUFFER_SIZES 6
     int bufferSize[BUFFER_SIZES] = { 16, 12, 8, 4, 2, 1 };
-    GLboolean wantIndexedMode = FALSE;
+    GLboolean wantIndexedMode = GL_FALSE;
     int attributes[ 32 ];
     int where = 0;
 
@@ -85,7 +83,7 @@ XVisualInfo* fgChooseVisual( void )
     if( fgState.DisplayMode & GLUT_INDEX )
     {
         ATTRIB_VAL( GLX_BUFFER_SIZE, 8 );
-        wantIndexedMode = TRUE;
+        wantIndexedMode = GL_TRUE;
     }
     else
     {
@@ -123,7 +121,7 @@ XVisualInfo* fgChooseVisual( void )
      */
     ATTRIB( None );
 
-    if( wantIndexedMode == FALSE )
+    if( ! wantIndexedMode )
         return glXChooseVisual( fgDisplay.Display, fgDisplay.Screen,
                                 attributes );
     else
@@ -164,7 +162,9 @@ GLboolean fgSetupPixelFormat( SFG_Window* window, GLboolean checkOnly,
     if( fgState.DisplayMode & GLUT_DOUBLE )
         flags |= PFD_DOUBLEBUFFER;
 
+#if defined(_MSC_VER)
 #pragma message( "fgSetupPixelFormat(): there is still some work to do here!" )
+#endif
 
     /*
      * Specify which pixel format do we opt for...
@@ -206,10 +206,10 @@ GLboolean fgSetupPixelFormat( SFG_Window* window, GLboolean checkOnly,
     
     pixelformat = ChoosePixelFormat( window->Window.Device, ppfd );
     if( pixelformat == 0 )
-        return FALSE;
+        return GL_FALSE;
 
     if( checkOnly )
-        return TRUE;
+        return GL_TRUE;
     return SetPixelFormat( window->Window.Device, pixelformat, ppfd );
 }
 #endif
@@ -237,8 +237,8 @@ void fgSetWindow ( SFG_Window *window )
         window->Window.Device = GetDC( window->Window.Handle );
         wglMakeCurrent( 
             window->Window.Device, 
-            window->Window.Context 
-  	);
+            window->Window.Context
+        );
     }
 #endif
     fgStructure.Window = window;
@@ -251,7 +251,7 @@ 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 )
+                   GLboolean gameMode, GLboolean isSubWindow )
 {
 #if TARGET_HOST_UNIX_X11
     XSetWindowAttributes winAttr;
@@ -267,30 +267,31 @@ void fgOpenWindow( SFG_Window* window, const char* title,
      * XXX With a little thought, we should be able to greatly
      * XXX simplify this.
      */
-    if ( !fgState.BuildingAMenu )
-      window->Window.VisualInfo = fgChooseVisual();
-    else if ( fgStructure.MenuContext )
-        window->Window.VisualInfo = fgChooseVisual();
+    if( !window->IsMenu )
+        window->Window.VisualInfo = fgChooseVisual( );
+    else if( fgStructure.MenuContext )
+        window->Window.VisualInfo = fgChooseVisual( );
     else
     {
+        /* XXX Why are menus double- and depth-buffered? */
         unsigned int current_DisplayMode = fgState.DisplayMode ;
         fgState.DisplayMode = GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH ;
-        window->Window.VisualInfo = fgChooseVisual();
+        window->Window.VisualInfo = fgChooseVisual( );
         fgState.DisplayMode = current_DisplayMode ;
     }
 
-    if ( ! window->Window.VisualInfo )
+    if( ! window->Window.VisualInfo )
     {
         /*
          * The "fgChooseVisual" returned a null meaning that the visual
          * context is not available.
          * Try a couple of variations to see if they will work.
          */
-        if ( ! ( fgState.DisplayMode & GLUT_DOUBLE ) )
+        if( !( fgState.DisplayMode & GLUT_DOUBLE ) )
         {
             fgState.DisplayMode |= GLUT_DOUBLE ;
-            window->Window.VisualInfo = fgChooseVisual();
-            fgState.DisplayMode &= ~GLUT_DOUBLE ;
+            window->Window.VisualInfo = fgChooseVisual( );
+            fgState.DisplayMode &= ~GLUT_DOUBLE;
         }
         
         /*
@@ -299,66 +300,92 @@ void fgOpenWindow( SFG_Window* window, const char* title,
          */
     }
 
-    assert( window->Window.VisualInfo != NULL );
-
     /*
-     * XXX HINT: the masks should be updated when adding/removing callbacks.
-     * XXX       This might speed up message processing. Is that true?
-     * XXX
-     * XXX A: Not appreciably, but it WILL make it easier to debug.
-     * XXX    Try tracing old GLUT and try tracing freeglut.  Old GLUT
-     * XXX    turns off events that it doesn't need and is a whole lot
-     * XXX    more pleasant to trace.  (Hint: Think mouse-motion!)
-     * XXX
-     * XXX    It may make a difference in networked environments or on
-     * XXX    some very slow systems, but I think that that is secondary
-     * XXX    to making debugging easier.
+     * XXX This seems to be abusing an assert() for error-checking.
+     * XXX It is possible that the visual simply can't be found,
+     * XXX in which case we should print an error and return a 0
+     * XXX for the window id, I think.
      */
-    winAttr.event_mask        = StructureNotifyMask | SubstructureNotifyMask |
-        ExposureMask | ButtonPressMask | ButtonReleaseMask | KeyPressMask |
-        KeyRelease | VisibilityChangeMask | EnterWindowMask | LeaveWindowMask |
-        PointerMotionMask | ButtonMotionMask;
-    winAttr.background_pixmap = None;
-    winAttr.background_pixel  = 0;
-    winAttr.border_pixel      = 0;
-
-    winAttr.colormap = XCreateColormap(
-        fgDisplay.Display, fgDisplay.RootWindow,
-        window->Window.VisualInfo->visual, AllocNone
-    );
-
-    mask = CWBackPixmap | CWBorderPixel | CWColormap | CWEventMask;
+    assert( window->Window.VisualInfo != NULL );
 
-    if ( fgState.BuildingAMenu )
+    window->State.IsOffscreen = GL_FALSE;
+    if( fgState.DisplayMode & GLUT_OFFSCREEN )
     {
-        winAttr.override_redirect = True;
-        mask |= CWOverrideRedirect;
+        window->State.IsOffscreen = GL_TRUE;
+        window->Window.Pixmap = XCreatePixmap(
+            fgDisplay.Display, fgDisplay.RootWindow,
+            w, h,
+            window->Window.VisualInfo->depth
+        );
+        if( False != window->Window.Pixmap )
+        {
+            window->Window.Handle = glXCreateGLXPixmap(
+                fgDisplay.Display,
+                window->Window.VisualInfo,
+                window->Window.Pixmap
+            );
+            if( False == window->Window.Handle )
+                XFreePixmap( fgDisplay.Display, window->Window.Pixmap );
+        }
     }
+    else
+    {
+        /*
+         * XXX HINT: the masks should be updated when adding/removing callbacks.
+         * XXX       This might speed up message processing. Is that true?
+         * XXX
+         * XXX A: Not appreciably, but it WILL make it easier to debug.
+         * XXX    Try tracing old GLUT and try tracing freeglut.  Old GLUT
+         * XXX    turns off events that it doesn't need and is a whole lot
+         * XXX    more pleasant to trace.  (Think mouse-motion!  Tons of
+         * XXX    ``bonus'' GUI events stream in.)
+         */
+        winAttr.event_mask        =
+            StructureNotifyMask | SubstructureNotifyMask | ExposureMask |
+            ButtonPressMask | ButtonReleaseMask | KeyPressMask | KeyRelease |
+            VisibilityChangeMask | EnterWindowMask | LeaveWindowMask |
+            PointerMotionMask | ButtonMotionMask;
+        winAttr.background_pixmap = None;
+        winAttr.background_pixel  = 0;
+        winAttr.border_pixel      = 0;
+
+        winAttr.colormap = XCreateColormap(
+            fgDisplay.Display, fgDisplay.RootWindow,
+            window->Window.VisualInfo->visual, AllocNone
+        );
 
-    window->Window.Handle = XCreateWindow(
-        fgDisplay.Display,
-        window->Parent == NULL ? fgDisplay.RootWindow :
-                                 window->Parent->Window.Handle,
-        x, y, w, h, 0,
-        window->Window.VisualInfo->depth, InputOutput,
-        window->Window.VisualInfo->visual, mask,
-        &winAttr
-    );
+        mask = CWBackPixmap | CWBorderPixel | CWColormap | CWEventMask;
 
+        if ( window->IsMenu )
+        {
+            winAttr.override_redirect = True;
+            mask |= CWOverrideRedirect;
+        }
+
+        window->Window.Handle = XCreateWindow(
+            fgDisplay.Display,
+            window->Parent == NULL ? fgDisplay.RootWindow :
+                                     window->Parent->Window.Handle,
+            x, y, w, h, 0,
+            window->Window.VisualInfo->depth, InputOutput,
+            window->Window.VisualInfo->visual, mask,
+            &winAttr
+        );
+    }
     /*
      * The GLX context creation, possibly trying the direct context rendering
      *  or else use the current context if the user has so specified
      */
-    if ( fgState.BuildingAMenu )
+    if( window->IsMenu )
     {
         /*
          * If there isn't already an OpenGL rendering context for menu
          * windows, make one
          */
-        if ( !fgStructure.MenuContext )
+        if( !fgStructure.MenuContext )
         {
             fgStructure.MenuContext =
-                (SFG_MenuContext *)malloc ( sizeof(SFG_MenuContext) );
+                (SFG_MenuContext *)malloc( sizeof(SFG_MenuContext) );
             fgStructure.MenuContext->VisualInfo = window->Window.VisualInfo;
             fgStructure.MenuContext->Context = glXCreateContext(
                 fgDisplay.Display, fgStructure.MenuContext->VisualInfo,
@@ -366,21 +393,21 @@ void fgOpenWindow( SFG_Window* window, const char* title,
             );
         }
 
-/*      window->Window.Context = fgStructure.MenuContext->Context ; */
+        /* window->Window.Context = fgStructure.MenuContext->Context; */
         window->Window.Context = glXCreateContext(
             fgDisplay.Display, window->Window.VisualInfo,
             NULL, fgState.ForceDirectContext | fgState.TryDirectContext
         );
     }
-    else if ( fgState.UseCurrentContext == TRUE )
+    else if( fgState.UseCurrentContext )
     {
-      window->Window.Context = glXGetCurrentContext();
+        window->Window.Context = glXGetCurrentContext( );
 
-      if ( ! window->Window.Context )
-        window->Window.Context = glXCreateContext(
-            fgDisplay.Display, window->Window.VisualInfo,
-            NULL, fgState.ForceDirectContext | fgState.TryDirectContext
-        );
+        if( ! window->Window.Context )
+            window->Window.Context = glXCreateContext(
+                fgDisplay.Display, window->Window.VisualInfo,
+                NULL, fgState.ForceDirectContext | fgState.TryDirectContext
+            );
     }
     else
         window->Window.Context = glXCreateContext(
@@ -403,12 +430,12 @@ void fgOpenWindow( SFG_Window* window, const char* title,
      * XXX Assume the new window is visible by default
      * XXX Is this a  safe assumption?
      */
-    window->State.Visible = TRUE;
+    window->State.Visible = GL_TRUE;
 
     sizeHints.flags = 0;
-    if (fgState.Position.Use == TRUE)
+    if ( fgState.Position.Use )
         sizeHints.flags |= USPosition;
-    if (fgState.Size.Use     == TRUE)
+    if ( fgState.Size.Use )
         sizeHints.flags |= USSize;
 
     /*
@@ -425,29 +452,32 @@ void fgOpenWindow( SFG_Window* window, const char* title,
     sizeHints.height = h;
 
     wmHints.flags = StateHint;
-    wmHints.initial_state =
-        (fgState.ForceIconic == FALSE) ? NormalState : IconicState;
-
-    /*
-     * Prepare the window and iconified window names...
-     */
-    XStringListToTextProperty( (char **) &title, 1, &textProperty );
-
-    XSetWMProperties(
-        fgDisplay.Display,
-        window->Window.Handle,
-        &textProperty,
-        &textProperty,
-        0,
-        0,
-        &sizeHints,
-        &wmHints,
-        NULL
-    );
-    XSetWMProtocols( fgDisplay.Display, window->Window.Handle,
-                     &fgDisplay.DeleteWindow, 1 );
-    XMapWindow( fgDisplay.Display, window->Window.Handle );
+    wmHints.initial_state = fgState.ForceIconic ? IconicState : NormalState;
+    if( GL_FALSE == window->State.IsOffscreen )
+    {
+        /*
+         * Prepare the window and iconified window names...
+         */
+        XStringListToTextProperty( (char **) &title, 1, &textProperty );
 
+        XSetWMProperties(
+            fgDisplay.Display,
+            window->Window.Handle,
+            &textProperty,
+            &textProperty,
+            0,
+            0,
+            &sizeHints,
+            &wmHints,
+            NULL
+        );
+    
+        XSetWMProtocols( fgDisplay.Display, window->Window.Handle,
+                         &fgDisplay.DeleteWindow, 1 );
+    
+        XMapWindow( fgDisplay.Display, window->Window.Handle );
+    }
+    
 #elif TARGET_HOST_WIN32
 
     WNDCLASS wc;
@@ -462,7 +492,7 @@ void fgOpenWindow( SFG_Window* window, const char* title,
     atom = GetClassInfo( fgDisplay.Instance, "FREEGLUT", &wc );
     assert( atom != 0 );
     
-    if( gameMode != FALSE )
+    if( gameMode )
     {
         assert( window->Parent == NULL );
 
@@ -474,7 +504,7 @@ void fgOpenWindow( SFG_Window* window, const char* title,
     }
     else
     {
-        if ( ( !isSubWindow ) && ( ! window->IsMenu ) )
+        if ( ( ! isSubWindow ) && ( ! window->IsMenu ) )
         {
             /*
              * Update the window dimensions, taking account of window
@@ -486,12 +516,12 @@ void fgOpenWindow( SFG_Window* window, const char* title,
                 GetSystemMetrics( SM_CYCAPTION );
         }
 
-        if( fgState.Position.Use == FALSE )
+        if( ! fgState.Position.Use )
         {
             x = CW_USEDEFAULT;
             y = CW_USEDEFAULT;
         }
-        if( fgState.Size.Use == FALSE )
+        if( ! fgState.Size.Use )
         {
             w = CW_USEDEFAULT;
             h = CW_USEDEFAULT;
@@ -524,33 +554,23 @@ void fgOpenWindow( SFG_Window* window, const char* title,
     if( !( window->Window.Handle ) )
         fgError( "Failed to create a window (%s)!", title );
 
-    /*
-     * Show and update the main window. Hide(???) the mouse cursor.
-     */
     ShowWindow( window->Window.Handle,
                 fgState.ForceIconic ? SW_SHOWMINIMIZED : SW_SHOW );
     UpdateWindow( window->Window.Handle );
-    ShowCursor( TRUE );
+    ShowCursor( TRUE );  /* XXX Old comments say "hide cusror"! */
 
 #endif
 
+    fgSetWindow( window );
+
     window->Window.DoubleBuffered =
-        ( fgState.DisplayMode & GLUT_DOUBLE ) ? 1 : 0 ;
+        ( fgState.DisplayMode & GLUT_DOUBLE ) ? 1 : 0;
 
-    /*
-     * If it's not double-buffered, make sure the rendering is done to the
-     * front buffer.
-     */
     if ( ! window->Window.DoubleBuffered )
     {
-        glDrawBuffer ( GL_FRONT ) ;
-        glReadBuffer ( GL_FRONT ) ;
+        glDrawBuffer ( GL_FRONT );
+        glReadBuffer ( GL_FRONT );
     }
-
-    /*
-     * Set the newly created window as the current one
-     */
-    fgSetWindow( window );
 }
 
 /*
@@ -561,32 +581,47 @@ void fgCloseWindow( SFG_Window* window )
     freeglut_assert_ready;
 
 #if TARGET_HOST_UNIX_X11
-    /*
-     * As easy as kill bunnies with axes. Destroy the context first:
-     */
+
     glXDestroyContext( fgDisplay.Display, window->Window.Context );
+    if( GL_FALSE == window->State.IsOffscreen )
+        XDestroyWindow( fgDisplay.Display, window->Window.Handle );
+    else
+    {
+        glXDestroyGLXPixmap( fgDisplay.Display, window->Window.Handle );
+        XFreePixmap( fgDisplay.Display, window->Window.Pixmap );
+    }
+    XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */
+
+#elif TARGET_HOST_WIN32
 
     /*
-     * Then have the window killed:
+     * Make sure we don't close a window with current context active
      */
-    XDestroyWindow( fgDisplay.Display, window->Window.Handle );
+    if( fgStructure.Window == window )
+        wglMakeCurrent( NULL, NULL );
 
     /*
-     * Finally, flush the rests down the stream
+     * Step through the list of windows.  If the rendering context
+     * is not being used by another window, then we delete it.
      */
-    XFlush( fgDisplay.Display );
+    {
+        int used = FALSE ;
+        SFG_Window *iter ;
 
-#elif TARGET_HOST_WIN32
-	/*
-	 * Send the WM_CLOSE message to the window now
-	 */
-	SendMessage( 
-		window->Window.Handle,
-		WM_CLOSE,
-		0,
-		0
-	);
+        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 );
+    }
+
+    DestroyWindow( window->Window.Handle );
 #endif
 }
 
@@ -598,11 +633,9 @@ void fgCloseWindow( SFG_Window* window )
  */
 int FGAPIENTRY glutCreateWindow( const char* title )
 {
-    /*
-     * Create a new window and return its unique ID number
-     */
-    return( fgCreateWindow( NULL, title, fgState.Position.X, fgState.Position.Y,
-                            fgState.Size.X, fgState.Size.Y, FALSE )->ID );
+    return fgCreateWindow( NULL, title, fgState.Position.X, fgState.Position.Y,
+                           fgState.Size.X, fgState.Size.Y, GL_FALSE,
+                           GL_FALSE )->ID;
 }
 
 /*
@@ -610,30 +643,20 @@ int FGAPIENTRY glutCreateWindow( const char* title )
  */
 int FGAPIENTRY glutCreateSubWindow( int parentID, int x, int y, int w, int h )
 {
-    SFG_Window* window = NULL;
-    SFG_Window* parent = NULL;
-
-    freeglut_assert_ready;
-
-    /*
-     * Find a parent to the newly created window...
-     */
-    parent = fgWindowByID( parentID );
-
-    /*
-     * Fail if the parent has not been found
-     */
-    freeglut_return_val_if_fail( parent != NULL, 0 );
-
-    /*
-     * Create the new window
-     */
-    window = fgCreateWindow( parent, "", x, y, w, h, FALSE );
-
-    /*
-     * Return the new window's ID
-     */
-    return( window->ID );
+    int ret = 0;
+    
+    if( GL_FALSE == fgStructure.Window->State.IsOffscreen )
+    {
+        SFG_Window* window = NULL;
+        SFG_Window* parent = NULL;
+
+        freeglut_assert_ready;
+        parent = fgWindowByID( parentID );
+        freeglut_return_val_if_fail( parent != NULL, 0 );
+        window = fgCreateWindow( parent, "", x, y, w, h, GL_FALSE, GL_FALSE );
+        ret = window->ID;
+    }
+    return ret;
 }
 
 /*
@@ -641,25 +664,13 @@ int FGAPIENTRY glutCreateSubWindow( int parentID, int x, int y, int w, int h )
  */
 void FGAPIENTRY glutDestroyWindow( int windowID )
 {
-  fgExecutionState ExecState = fgState.ExecState ;
-
-  /*
-   * Grab the freeglut window pointer from the structure
-   */
-  SFG_Window* window = fgWindowByID( windowID );
-  freeglut_return_if_fail( window != NULL );
-
-  /*
-   * There is a function that performs all needed steps
-   * defined in freeglut_structure.c. Let's use it:
-   */
-  fgAddToWindowDestroyList( window, TRUE );
-
-  /*
-   * Since the "fgAddToWindowDestroyList" function could easily have set the "ExecState"
-   * to stop, let's set it back to what it was.
-   */
-  fgState.ExecState = ExecState ;
+    SFG_Window* window = fgWindowByID( windowID );
+    freeglut_return_if_fail( window != NULL );
+    {
+        fgExecutionState ExecState = fgState.ExecState;
+        fgAddToWindowDestroyList( window );
+        fgState.ExecState = ExecState;
+    }
 }
 
 /*
@@ -669,36 +680,19 @@ void FGAPIENTRY glutSetWindow( int ID )
 {
     SFG_Window* window = NULL;
 
-    /*
-     * Make sure we don't get called too early
-     */
     freeglut_assert_ready;
-
-    /*
-     * Be wise. Be wise. Be wise. Be quick.
-     */
     if( fgStructure.Window != NULL )
         if( fgStructure.Window->ID == ID )
             return;
 
-    /*
-     * Now we are sure there is sense in looking for the window
-     */
     window = fgWindowByID( ID );
-
-    /*
-     * In the case of an utter failure...
-     */
     if( window == NULL )
     {
-        /*
-         * ...issue a warning message and keep rolling on
-         */
         fgWarning( "glutSetWindow(): window ID %i not found!", ID );
         return;
     }
 
-    fgSetWindow ( window ) ;
+    fgSetWindow( window );
 }
 
 /*
@@ -707,22 +701,9 @@ void FGAPIENTRY glutSetWindow( int ID )
 int FGAPIENTRY glutGetWindow( void )
 {
     freeglut_assert_ready;
-
-    /*
-     * Do we have a current window selected?
-     */
     if( fgStructure.Window == NULL )
-    {
-        /*
-         * Nope. Return zero to mark the state.
-         */
-        return( 0 );
-    }
-
-    /*
-     * Otherwise, return the ID of the current window
-     */
-    return( fgStructure.Window->ID );
+        return 0;
+    return fgStructure.Window->ID;
 }
 
 /*
@@ -730,28 +711,23 @@ int FGAPIENTRY glutGetWindow( void )
  */
 void FGAPIENTRY glutShowWindow( void )
 {
-    freeglut_assert_ready; freeglut_assert_window;
+    freeglut_assert_ready;
+    freeglut_assert_window;
 
+    if( GL_FALSE == fgStructure.Window->State.IsOffscreen )
+    {
 #if TARGET_HOST_UNIX_X11
-    /*
-     * Showing the window is done via mapping under X
-     */
-    XMapWindow( fgDisplay.Display, fgStructure.Window->Window.Handle );
-    XFlush( fgDisplay.Display );
 
-#elif TARGET_HOST_WIN32
-	/*
-	 * Restore the window's originial position and size
-	 */
-	ShowWindow( fgStructure.Window->Window.Handle, SW_SHOW );
+        XMapWindow( fgDisplay.Display, fgStructure.Window->Window.Handle );
+        XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */
 
-#endif
+#elif TARGET_HOST_WIN32
 
-  /*
-   * Since the window is visible, we need to redisplay it ...
-   */
-  fgStructure.Window->State.Redisplay = TRUE;
+        ShowWindow( fgStructure.Window->Window.Handle, SW_SHOW );
 
+#endif
+    }
+    fgStructure.Window->State.Redisplay = GL_TRUE;
 }
 
 /*
@@ -759,45 +735,29 @@ void FGAPIENTRY glutShowWindow( void )
  */
 void FGAPIENTRY glutHideWindow( void )
 {
-    freeglut_assert_ready; freeglut_assert_window;
+    freeglut_assert_ready;
+    freeglut_assert_window;
 
-#if TARGET_HOST_UNIX_X11
-    /*
-     * The way we hide a window depends on if we're dealing
-     * with a top-level or children one...
-     */
-    if( fgStructure.Window->Parent == NULL )
-    {
-        /*
-         * This is a top-level window
-         */
-        XWithdrawWindow( fgDisplay.Display, fgStructure.Window->Window.Handle, fgDisplay.Screen );
-    }
-    else
+    if( GL_FALSE == fgStructure.Window->State.IsOffscreen )
     {
-        /*
-         * Nope, it's a child window
-         */
-        XUnmapWindow( fgDisplay.Display, fgStructure.Window->Window.Handle );
-    }
+#if TARGET_HOST_UNIX_X11
 
-    /*
-     * Flush the X state now
-     */
-    XFlush( fgDisplay.Display );
+        if( fgStructure.Window->Parent == NULL )
+            XWithdrawWindow( fgDisplay.Display,
+                             fgStructure.Window->Window.Handle,
+                             fgDisplay.Screen );
+        else
+            XUnmapWindow( fgDisplay.Display,
+                          fgStructure.Window->Window.Handle );
+        XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */
 
 #elif TARGET_HOST_WIN32
-	/*
-	 * Hide the window
-	 */
-	ShowWindow( fgStructure.Window->Window.Handle, SW_HIDE );
 
-#endif
+        ShowWindow( fgStructure.Window->Window.Handle, SW_HIDE );
 
-  /*
-   * Since the window is hidden, we don't need to redisplay it ...
-   */
-  fgStructure.Window->State.Redisplay = FALSE;
+#endif
+    }
+    fgStructure.Window->State.Redisplay = GL_FALSE;
 }
 
 /*
@@ -805,28 +765,25 @@ void FGAPIENTRY glutHideWindow( void )
  */
 void FGAPIENTRY glutIconifyWindow( void )
 {
-    freeglut_assert_ready; freeglut_assert_window;
+    freeglut_assert_ready;
+    freeglut_assert_window;
 
+    fgStructure.Window->State.Visible   = GL_FALSE;
+    if( GL_FALSE == fgStructure.Window->State.IsOffscreen )
+    {
 #if TARGET_HOST_UNIX_X11
-    /*
-     * Iconify the window and flush the X state
-     */
-    XIconifyWindow( fgDisplay.Display, fgStructure.Window->Window.Handle, fgDisplay.Screen );
-    XFlush( fgDisplay.Display );
 
-#elif TARGET_HOST_WIN32
-	/*
-	 * Minimize the current window (this should be the same as X window iconifying)
-	 */
-	ShowWindow( fgStructure.Window->Window.Handle, SW_MINIMIZE );
+        XIconifyWindow( fgDisplay.Display, fgStructure.Window->Window.Handle,
+                        fgDisplay.Screen );
+        XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */
 
-#endif
+#elif TARGET_HOST_WIN32
 
-  /*
-   * Since the window is just an icon, we don't need to redisplay it ...
-   */
-  fgStructure.Window->State.Redisplay = FALSE;
+        ShowWindow( fgStructure.Window->Window.Handle, SW_MINIMIZE );
 
+#endif
+    }
+    fgStructure.Window->State.Redisplay = GL_FALSE;
 }
 
 /*
@@ -834,48 +791,34 @@ void FGAPIENTRY glutIconifyWindow( void )
  */
 void FGAPIENTRY glutSetWindowTitle( const char* title )
 {
-	freeglut_assert_ready; freeglut_assert_window;
-
-    /*
-     * Works only for top-level windows
-     */
-    if( fgStructure.Window->Parent != NULL )
-        return;
-
+    freeglut_assert_ready;
+    freeglut_assert_window;
+    if( ! fgStructure.Window->Parent &&
+        ( GL_FALSE == fgStructure.Window->State.IsOffscreen ) )
+    {
 #if TARGET_HOST_UNIX_X11
-	{
-		XTextProperty text;
-
-		/*
-		 * Prepare the text properties
-		 */
-		text.value = (unsigned char *) title;
-		text.encoding = XA_STRING;
-		text.format = 8;
-		text.nitems = strlen( title );
-
-		/*
-		 * Set the title now
-		 */
-		XSetWMName(
-			fgDisplay.Display,
-			fgStructure.Window->Window.Handle,
-			&text
-		);
-
-		/*
-		 * Have the X display state flushed
-		 */
-		XFlush( fgDisplay.Display );
-	}
+
+        XTextProperty text;
+        
+        text.value = (unsigned char *) title;
+        text.encoding = XA_STRING;
+        text.format = 8;
+        text.nitems = strlen( title );
+        
+        XSetWMName(
+            fgDisplay.Display,
+            fgStructure.Window->Window.Handle,
+            &text
+        );
+        
+        XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */
 
 #elif TARGET_HOST_WIN32
-	/*
-	 * This seems to be a bit easier under Win32
-	 */
-	SetWindowText( fgStructure.Window->Window.Handle, title );
+
+        SetWindowText( fgStructure.Window->Window.Handle, title );
 
 #endif
+    }
 }
 
 /*
@@ -883,48 +826,35 @@ void FGAPIENTRY glutSetWindowTitle( const char* title )
  */
 void FGAPIENTRY glutSetIconTitle( const char* title )
 {
-    freeglut_assert_ready; freeglut_assert_window;
-
-    /*
-     * Works only for top-level windows
-     */
-    if( fgStructure.Window->Parent != NULL )
-        return;
+    freeglut_assert_ready;
+    freeglut_assert_window;
 
+    if( ! fgStructure.Window->Parent &&
+        GL_FALSE == fgStructure.Window->State.IsOffscreen )
+    {
 #if TARGET_HOST_UNIX_X11
-	{
-		XTextProperty text;
-
-		/*
-		 * Prepare the text properties
-		 */
-		text.value = (unsigned char *) title;
-		text.encoding = XA_STRING;
-		text.format = 8;
-		text.nitems = strlen( title );
-
-		/*
-		 * Set the title now
-		 */
-		XSetWMIconName(
-			fgDisplay.Display,
-			fgStructure.Window->Window.Handle,
-			&text
-		);
-
-		/*
-		 * Have the X display state flushed
-		 */
-		XFlush( fgDisplay.Display );
-	}
+
+        XTextProperty text;
+        
+        text.value = (unsigned char *) title;
+        text.encoding = XA_STRING;
+        text.format = 8;
+        text.nitems = strlen( title );
+
+        XSetWMIconName(
+            fgDisplay.Display,
+            fgStructure.Window->Window.Handle,
+            &text
+        );
+
+        XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */
 
 #elif TARGET_HOST_WIN32
-	/*
-	 * This seems to be a bit easier under Win32
-	 */
-	SetWindowText( fgStructure.Window->Window.Handle, title );
+
+        SetWindowText( fgStructure.Window->Window.Handle, title );
 
 #endif
+    }
 }
 
 /*
@@ -932,58 +862,16 @@ void FGAPIENTRY glutSetIconTitle( const char* title )
  */
 void FGAPIENTRY glutReshapeWindow( int width, int height )
 {
-    freeglut_assert_ready; freeglut_assert_window;
-
-#if TARGET_HOST_UNIX_X11
-    /*
-     * Resize the window and flush the X state
-     */
-    XResizeWindow( fgDisplay.Display, fgStructure.Window->Window.Handle, width, height );
-    XFlush( fgDisplay.Display );
+    freeglut_assert_ready;
+    freeglut_assert_window;
 
-#elif TARGET_HOST_WIN32
-	{
-		RECT winRect;
-    int x, y ;
-
-		/*
-		 * First off, grab the current window's position
-		 */
-		GetWindowRect( fgStructure.Window->Window.Handle, &winRect );
-    x = winRect.left ;
-    y = winRect.top ;
-
-    if ( fgStructure.Window->Parent == NULL )  /* If this is not a subwindow ... */
+    /* XXX Could delete/create/set-window-id for offscreen. */
+    if( GL_FALSE == fgStructure.Window->State.IsOffscreen )
     {
-      /*
-       * Adjust the size of the window to allow for the size of the frame, if we are not a menu
-       */
-      if ( ! fgStructure.Window->IsMenu )
-      {
-    		width += GetSystemMetrics( SM_CXSIZEFRAME ) * 2;
-	    	height += GetSystemMetrics( SM_CYSIZEFRAME ) * 2 + GetSystemMetrics( SM_CYCAPTION );
-      }
+        fgStructure.Window->State.NeedToResize = GL_TRUE;
+        fgStructure.Window->State.Width  = width ;
+        fgStructure.Window->State.Height = height;
     }
-    else  /* This is a subwindow, get the parent window's position and subtract it off */
-    {
-      GetWindowRect ( fgStructure.Window->Parent->Window.Handle, &winRect ) ;
-      x -= winRect.left + GetSystemMetrics( SM_CXSIZEFRAME ) ;
-      y -= winRect.top + GetSystemMetrics( SM_CYSIZEFRAME ) + GetSystemMetrics( SM_CYCAPTION ) ;
-    }
-
-		/*
-		 * Resize the window, forcing a redraw to happen
-		 */
-		MoveWindow(
-			fgStructure.Window->Window.Handle,
-			x,
-			y,
-			width,
-			height,
-			TRUE
-		);
-	}
-#endif
 }
 
 /*
@@ -991,38 +879,33 @@ void FGAPIENTRY glutReshapeWindow( int width, int height )
  */
 void FGAPIENTRY glutPositionWindow( int x, int y )
 {
-    freeglut_assert_ready; freeglut_assert_window;
+    freeglut_assert_ready;
+    freeglut_assert_window;
 
+    if( GL_FALSE == fgStructure.Window->State.IsOffscreen )
+    {
 #if TARGET_HOST_UNIX_X11
-    /*
-     * Reposition the window and flush the X state
-     */
-    XMoveWindow( fgDisplay.Display, fgStructure.Window->Window.Handle, x, y );
-    XFlush( fgDisplay.Display );
 
-#elif TARGET_HOST_WIN32
-	{
-		RECT winRect;
+        XMoveWindow( fgDisplay.Display, fgStructure.Window->Window.Handle,
+                     x, y );
+        XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */
 
-		/*
-		 * First off, grab the current window's position
-		 */
-		GetWindowRect( fgStructure.Window->Window.Handle, &winRect );
+#elif TARGET_HOST_WIN32
 
-    /*
-		 * Reposition the window, forcing a redraw to happen
-		 */
-		MoveWindow(
-			fgStructure.Window->Window.Handle,
-			x,
-			y,
-			winRect.right - winRect.left,
-			winRect.bottom - winRect.top,
-			TRUE
-		);
-	}
+        RECT winRect;
+        
+        GetWindowRect( fgStructure.Window->Window.Handle, &winRect );
+        MoveWindow(
+            fgStructure.Window->Window.Handle,
+            x,
+            y,
+            winRect.right - winRect.left,
+            winRect.bottom - winRect.top,
+            TRUE
+        );
 
 #endif
+    }
 }
 
 /*
@@ -1030,26 +913,26 @@ void FGAPIENTRY glutPositionWindow( int x, int y )
  */
 void FGAPIENTRY glutPushWindow( void )
 {
-    freeglut_assert_ready; freeglut_assert_window;
+    freeglut_assert_ready;
+    freeglut_assert_window;
 
+    if( GL_FALSE == fgStructure.Window->State.IsOffscreen )
+    {
 #if TARGET_HOST_UNIX_X11
-    /*
-     * Lower the current window
-     */
-    XLowerWindow( fgDisplay.Display, fgStructure.Window->Window.Handle );
+
+        XLowerWindow( fgDisplay.Display, fgStructure.Window->Window.Handle );
 
 #elif TARGET_HOST_WIN32
-	/*
-	 * Set the new window's Z position, not affecting the rest of the settings:
-	 */
-	SetWindowPos(
-		fgStructure.Window->Window.Handle,
-		HWND_BOTTOM,
-		0, 0, 0, 0,
-		SWP_NOSIZE | SWP_NOMOVE
-	);
+
+        SetWindowPos(
+            fgStructure.Window->Window.Handle,
+            HWND_BOTTOM,
+            0, 0, 0, 0,
+            SWP_NOSIZE | SWP_NOMOVE
+        );
 
 #endif
+    }
 }
 
 /*
@@ -1057,26 +940,26 @@ void FGAPIENTRY glutPushWindow( void )
  */
 void FGAPIENTRY glutPopWindow( void )
 {
-    freeglut_assert_ready; freeglut_assert_window;
+    freeglut_assert_ready;
+    freeglut_assert_window;
 
+    if( GL_FALSE == fgStructure.Window->State.IsOffscreen )
+    {
 #if TARGET_HOST_UNIX_X11
-    /*
-     * Raise the current window
-     */
-    XRaiseWindow( fgDisplay.Display, fgStructure.Window->Window.Handle );
+
+        XRaiseWindow( fgDisplay.Display, fgStructure.Window->Window.Handle );
 
 #elif TARGET_HOST_WIN32
-	/*
-	 * Set the new window's Z position, not affecting the rest of the settings:
-	 */
-	SetWindowPos(
-		fgStructure.Window->Window.Handle,
-		HWND_TOP,
-		0, 0, 0, 0,
-		SWP_NOSIZE | SWP_NOMOVE
-	);
+
+        SetWindowPos(
+            fgStructure.Window->Window.Handle,
+            HWND_TOP,
+            0, 0, 0, 0,
+            SWP_NOSIZE | SWP_NOMOVE
+        );
 
 #endif
+    }
 }
 
 /*
@@ -1084,10 +967,12 @@ void FGAPIENTRY glutPopWindow( void )
  */
 void FGAPIENTRY glutFullScreen( void )
 {
-    freeglut_assert_ready; freeglut_assert_window;
+    freeglut_assert_ready;
+    freeglut_assert_window;
 
-#if TARGET_HOST_UNIX_X11
+    if( GL_FALSE == fgStructure.Window->State.IsOffscreen )
     {
+#if TARGET_HOST_UNIX_X11
         int x, y;
         Window w;
 
@@ -1098,7 +983,8 @@ void FGAPIENTRY glutFullScreen( void )
             fgDisplay.ScreenWidth,
             fgDisplay.ScreenHeight
         );
-        XFlush( fgDisplay.Display );
+
+        XFlush( fgDisplay.Display ); /* This is needed */
 
         XTranslateCoordinates(
             fgDisplay.Display,
@@ -1114,18 +1000,42 @@ void FGAPIENTRY glutFullScreen( void )
                 fgStructure.Window->Window.Handle,
                 -x, -y
             );
-            XFlush( fgDisplay.Display );
+            XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */
         }
-    }
 #elif TARGET_HOST_WIN32
-    MoveWindow(
-        fgStructure.Window->Window.Handle,
-        0, 0,
-        fgDisplay.ScreenWidth,
-        fgDisplay.ScreenHeight,
-        TRUE
-    );
+        RECT rect;
+
+        /* For fullscreen mode, force the top-left corner to 0,0
+         * and adjust the window rectangle so that the client area
+         * covers the whole screen.
+         */
+
+        rect.left   = 0;
+        rect.top    = 0;
+        rect.right  = fgDisplay.ScreenWidth;
+        rect.bottom = fgDisplay.ScreenHeight;
+
+        AdjustWindowRect ( &rect, WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS |
+                                  WS_CLIPCHILDREN, FALSE );
+
+        /*
+         * 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( fgStructure.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
+    }
 }
 
 /*
@@ -1133,12 +1043,12 @@ void FGAPIENTRY glutFullScreen( void )
  */
 void* FGAPIENTRY glutGetWindowData( void )
 {
-   return(fgStructure.Window->UserData);
+    return fgStructure.Window->UserData;
 }
 
 void FGAPIENTRY glutSetWindowData(void* data)
 {
-  fgStructure.Window->UserData=data;
+    fgStructure.Window->UserData = data;
 }
 
 /*** END OF FILE ***/