X-Git-Url: http://git.mutantstargoat.com/user/nuclear/?a=blobdiff_plain;f=src%2Ffreeglut_window.c;h=9ede7456d7805eb9e43b8cf54b4024ca75fe225b;hb=c4ffff1de4b14af7f0efb231f476961c21f3f552;hp=0c65fc415f964cbb711a61689508df54bf436705;hpb=9338532e9e7986bb018825c869ddeaaa535da8e2;p=freeglut

diff --git a/src/freeglut_window.c b/src/freeglut_window.c
index 0c65fc4..9ede745 100644
--- a/src/freeglut_window.c
+++ b/src/freeglut_window.c
@@ -29,11 +29,26 @@
 #include "config.h"
 #endif
 
-#define  G_LOG_DOMAIN  "freeglut-window"
-
-#include "../include/GL/freeglut.h"
+#include <GL/freeglut.h>
 #include "freeglut_internal.h"
 
+#if TARGET_HOST_WINCE
+#include <aygshell.h>
+#pragma comment( lib, "Aygshell.lib" )
+
+wchar_t* wstr_from_str(const char* str)
+{
+    int i,len=strlen(str);
+    wchar_t* wstr = (wchar_t*)malloc(2*len+2);
+    for(i=0; i<len; i++)
+        wstr[i] = str[i];
+    wstr[len] = 0;
+    return wstr;
+}
+
+
+#endif //TARGET_HOST_WINCE
+
 /*
  * TODO BEFORE THE STABLE RELEASE:
  *
@@ -41,8 +56,8 @@
  *  fgSetupPixelFormat      -- ignores the display mode settings
  *  fgOpenWindow()          -- check the Win32 version, -iconic handling!
  *  fgCloseWindow()         -- check the Win32 version
- *  glutCreateWindow()      -- see what happens when default position and size is {-1,-1}
- *  glutCreateSubWindow()   -- see what happens when default position and size is {-1,-1}
+ *  glutCreateWindow()      -- Check when default position and size is {-1,-1}
+ *  glutCreateSubWindow()   -- Check when default position and size is {-1,-1}
  *  glutDestroyWindow()     -- check the Win32 version
  *  glutSetWindow()         -- check the Win32 version
  *  glutGetWindow()         -- OK
@@ -66,98 +81,56 @@
 
 XVisualInfo* fgChooseVisual( void )
 {
-    int bufferSize[] = { 16, 12, 8, 4, 2, 1 };
-    GLboolean wantIndexedMode = FALSE;
+#define BUFFER_SIZES 6
+    int bufferSize[BUFFER_SIZES] = { 16, 12, 8, 4, 2, 1 };
+    GLboolean wantIndexedMode = GL_FALSE;
     int attributes[ 32 ];
     int where = 0;
 
     /*
      * First we have to process the display mode settings...
      */
-#   define ATTRIB(a) attributes[where++]=a;
+/*
+ * Why is there a semi-colon in this #define?  The code
+ * that uses the macro seems to always add more semicolons...
+ */
+#define ATTRIB(a) attributes[where++]=a;
+#define ATTRIB_VAL(a,v) {ATTRIB(a); ATTRIB(v);}
 
-    /*
-     * Decide if we want a true or indexed color visual:
-     */
-    if( !(fgState.DisplayMode & GLUT_INDEX) )
+    if( fgState.DisplayMode & GLUT_INDEX )
     {
-        /*
-         * We are sure that there will be R, B and B components requested:
-         */
-        ATTRIB( GLX_RGBA       );
-        ATTRIB( GLX_RED_SIZE   ); ATTRIB( 1 );
-        ATTRIB( GLX_GREEN_SIZE ); ATTRIB( 1 );
-        ATTRIB( GLX_BLUE_SIZE  ); ATTRIB( 1 );
-
-        /*
-         * Check if the A component is required, too:
-         */
-        if( fgState.DisplayMode & GLUT_ALPHA )
-        {
-            ATTRIB( GLX_ALPHA_SIZE ); ATTRIB( 1 );
-        }
+        ATTRIB_VAL( GLX_BUFFER_SIZE, 8 );
+        wantIndexedMode = GL_TRUE;
     }
     else
     {
-        /*
-         * We've got an indexed color request
-         */
-        ATTRIB( GLX_BUFFER_SIZE ); ATTRIB( 8 );
-
-        /*
-         * Set the 'I want indexed mode' switch
-         */
-        wantIndexedMode = TRUE;
+        ATTRIB( GLX_RGBA );
+        ATTRIB_VAL( GLX_RED_SIZE,   1 );
+        ATTRIB_VAL( GLX_GREEN_SIZE, 1 );
+        ATTRIB_VAL( GLX_BLUE_SIZE,  1 );
+        if( fgState.DisplayMode & GLUT_ALPHA )
+            ATTRIB_VAL( GLX_ALPHA_SIZE, 1 );
     }
 
-    /*
-     * We can have double or single buffered contexts created
-     */
     if( fgState.DisplayMode & GLUT_DOUBLE )
-    {
         ATTRIB( GLX_DOUBLEBUFFER );
-    }
 
-    /*
-     * Stereoscopy seems a nice thing to have
-     */
     if( fgState.DisplayMode & GLUT_STEREO )
-    {
         ATTRIB( GLX_STEREO );
-    }
 
-    /*
-     * Depth buffer is almost always required
-     */
     if( fgState.DisplayMode & GLUT_DEPTH )
-    {
-        ATTRIB( GLX_DEPTH_SIZE ); ATTRIB( 1 );
-    }
+        ATTRIB_VAL( GLX_DEPTH_SIZE, 1 );
 
-    /*
-     * Stenciling support
-     */
     if( fgState.DisplayMode & GLUT_STENCIL )
-    {
-        ATTRIB( GLX_STENCIL_SIZE ); ATTRIB( 1 );
-    }
+        ATTRIB_VAL( GLX_STENCIL_SIZE, 1 );
 
-    /*
-     * And finally the accumulation buffers
-     */
     if( fgState.DisplayMode & GLUT_ACCUM )
     {
-        ATTRIB( GLX_ACCUM_RED_SIZE );   ATTRIB( 1 );
-        ATTRIB( GLX_ACCUM_GREEN_SIZE ); ATTRIB( 1 );
-        ATTRIB( GLX_ACCUM_BLUE_SIZE );  ATTRIB( 1 );
-
-        /*
-         * Check if the A component is required, too:
-         */
+        ATTRIB_VAL( GLX_ACCUM_RED_SIZE,   1 );
+        ATTRIB_VAL( GLX_ACCUM_GREEN_SIZE, 1 );
+        ATTRIB_VAL( GLX_ACCUM_BLUE_SIZE,  1 );
         if( fgState.DisplayMode & GLUT_ALPHA )
-        {
-            ATTRIB( GLX_ACCUM_ALPHA_SIZE ); ATTRIB( 1 );
-        }
+            ATTRIB_VAL( GLX_ACCUM_ALPHA_SIZE, 1 );
     }
 
     /*
@@ -165,48 +138,28 @@ XVisualInfo* fgChooseVisual( void )
      */
     ATTRIB( None );
 
-    /*
-     * OKi now, we've got two cases -- RGB(A) and index mode visuals
-     */
-    if( wantIndexedMode == FALSE )
-    {
-        /*
-         * The easier one. And more common, too.
-         */
-        return( glXChooseVisual( fgDisplay.Display, fgDisplay.Screen, attributes ) );
-    }
+    if( ! wantIndexedMode )
+        return glXChooseVisual( fgDisplay.Display, fgDisplay.Screen,
+                                attributes );
     else
     {
         XVisualInfo* visualInfo;
         int i;
 
         /*
-         * In indexed mode, we need to check how many bits of depth can we achieve
+         * In indexed mode, we need to check how many bits of depth can we
+         * achieve.  We do this by trying each possibility from the list
+         * given in the {bufferSize} array.  If we match, we return to caller.
          */
-        for( i=0; i<6; i++ )
+        for( i=0; i<BUFFER_SIZES; i++ )
         {
-
-            /*
-             * The GLX_BUFFER_SIZE value comes always first, so:
-             */
             attributes[ 1 ] = bufferSize[ i ];
-
-            /*
-             * Check if such visual is possible
-             */
-            visualInfo = glXChooseVisual( fgDisplay.Display, fgDisplay.Screen, attributes );
-
-            /*
-             * The buffer size are sorted in descendant order, so choose the first:
-             */
+            visualInfo = glXChooseVisual( fgDisplay.Display, fgDisplay.Screen,
+                                          attributes );
             if( visualInfo != NULL )
-                return( visualInfo );
+                return visualInfo;
         }
-
-        /*
-         * If we are still here, it means that the visual info was not found
-         */
-        return( NULL );
+        return NULL;
     }
 }
 #endif
@@ -215,135 +168,100 @@ XVisualInfo* fgChooseVisual( void )
  * Setup the pixel format for a Win32 window
  */
 #if TARGET_HOST_WIN32
-GLboolean fgSetupPixelFormat( SFG_Window* window, GLboolean checkOnly, unsigned char layer_type )
+GLboolean fgSetupPixelFormat( SFG_Window* window, GLboolean checkOnly,
+                              unsigned char layer_type )
 {
-	PIXELFORMATDESCRIPTOR* ppfd, pfd;
-	int flags, pixelformat;
-
-	/*
-	 * Check if the window seems valid
-	 */
-	freeglut_return_val_if_fail( window != NULL, 0 );
-
-	/*
-	 * The pixel format should allow us to draw to the window using OpenGL
-	 */
-	flags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL;
-	
-	/*
-	 * It might be the case for us to use double buffering
-	 */
-  if( fgState.DisplayMode & GLUT_DOUBLE )
-    flags |= PFD_DOUBLEBUFFER;
-
-  /*
-   * Specify which pixel format do we opt for...
-   */
-#	pragma message( "fgSetupPixelFormat(): there is still some work to do here!" )
-
-  pfd.nSize				= sizeof(PIXELFORMATDESCRIPTOR);
-  pfd.nVersion			= 1;
-  pfd.dwFlags				= flags;
-  pfd.iPixelType			= PFD_TYPE_RGBA;
-  pfd.cColorBits			= 24;
-  pfd.cRedBits			= 0;
-  pfd.cRedShift			= 0;
-  pfd.cGreenBits			= 0;
-  pfd.cGreenShift			= 0;
-  pfd.cBlueBits			= 0;
-  pfd.cBlueShift			= 0;
-  pfd.cAlphaBits			= 0;
-  pfd.cAlphaShift			= 0;
-  pfd.cAccumBits			= 0;
-  pfd.cAccumRedBits		= 0;
-  pfd.cAccumGreenBits		= 0;
-  pfd.cAccumBlueBits		= 0;
-  pfd.cAccumAlphaBits		= 0;
+#if TARGET_HOST_WINCE
+    return GL_TRUE;
+#else
+    PIXELFORMATDESCRIPTOR* ppfd, pfd;
+    int flags, pixelformat;
+
+    freeglut_return_val_if_fail( window != NULL, 0 );
+    flags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL;
+    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...
+     */
+    pfd.nSize           = sizeof(PIXELFORMATDESCRIPTOR);
+    pfd.nVersion        = 1;
+    pfd.dwFlags         = flags;
+    pfd.iPixelType      = PFD_TYPE_RGBA;
+    pfd.cColorBits      = 24;
+    pfd.cRedBits        = 0;
+    pfd.cRedShift       = 0;
+    pfd.cGreenBits      = 0;
+    pfd.cGreenShift     = 0;
+    pfd.cBlueBits       = 0;
+    pfd.cBlueShift      = 0;
+    pfd.cAlphaBits      = 0;
+    pfd.cAlphaShift     = 0;
+    pfd.cAccumBits      = 0;
+    pfd.cAccumRedBits   = 0;
+    pfd.cAccumGreenBits = 0;
+    pfd.cAccumBlueBits  = 0;
+    pfd.cAccumAlphaBits = 0;
 #if 0
-  pfd.cDepthBits			= 32;
-  pfd.cStencilBits		= 0;
+    pfd.cDepthBits      = 32;
+    pfd.cStencilBits    = 0;
 #else
-  pfd.cDepthBits			= 24;
-  pfd.cStencilBits		= 8;
+    pfd.cDepthBits      = 24;
+    pfd.cStencilBits    = 8;
 #endif
-  pfd.cAuxBuffers			= 0;
-  pfd.iLayerType			= layer_type;
-  pfd.bReserved			= 0;
-  pfd.dwLayerMask			= 0;
-  pfd.dwVisibleMask		= 0;
-  pfd.dwDamageMask		= 0;
-
-  /*
-   * Fill in the color bits...
-   */
-  pfd.cColorBits = (BYTE) GetDeviceCaps( window->Window.Device, BITSPIXEL );
-  ppfd = &pfd;
-
-	/*
-	 * Choose the pixel format that matches our demand
-	 */
-  pixelformat = ChoosePixelFormat( window->Window.Device, ppfd );
-	if( pixelformat == 0 )
-		return( FALSE );
-
-	/*
-	 * We might have been called to check if the pixel format exists only
-	 */
-	if( checkOnly )
-		return( TRUE );
-
-	/*
-	 * Finally, set the window's pixel format
-	 */
-	return ( SetPixelFormat( window->Window.Device, pixelformat, ppfd ) ) ;
+    pfd.cAuxBuffers     = 0;
+    pfd.iLayerType      = layer_type;
+    pfd.bReserved       = 0;
+    pfd.dwLayerMask     = 0;
+    pfd.dwVisibleMask   = 0;
+    pfd.dwDamageMask    = 0;
+
+    pfd.cColorBits = (BYTE) GetDeviceCaps( window->Window.Device, BITSPIXEL );
+    ppfd = &pfd;
+
+    pixelformat = ChoosePixelFormat( window->Window.Device, ppfd );
+    if( pixelformat == 0 )
+        return GL_FALSE;
+
+    if( checkOnly )
+        return GL_TRUE;
+    return SetPixelFormat( window->Window.Device, pixelformat, ppfd );
+#endif //TARGET_HOST_WINCE
 }
 #endif
 
 /*
- * Sets the OpenGL context and the fgStructure "Current Window" pointer to the window
- * structure passed in.
+ * Sets the OpenGL context and the fgStructure "Current Window" pointer to
+ * the window structure passed in.
  */
 void fgSetWindow ( SFG_Window *window )
 {
 #if TARGET_HOST_UNIX_X11
-  if ( window )
-  {
-    /*
-	 * Make the selected window's GLX context the current one
-     */
-    glXMakeCurrent(
-        fgDisplay.Display,
-        window->Window.Handle,
-        window->Window.Context
-    );
-  }
-#elif TARGET_HOST_WIN32
-	/*
-	 * Release the previous' context's device context
-	 */
-	if( fgStructure.Window != NULL )
-		ReleaseDC( fgStructure.Window->Window.Handle, fgStructure.Window->Window.Device );
-
-  if ( window )
-  {
-  	/*
-	   * We will care about releasing the device context later
-	   */
-  	window->Window.Device = GetDC( window->Window.Handle );
-
-  	/*
-	   * Set the new current context:
-	   */
-  	wglMakeCurrent( 
-	  	window->Window.Device, 
-		  window->Window.Context 
-  	);
-  }
-#endif
+    if ( window )
+        glXMakeCurrent(
+            fgDisplay.Display,
+            window->Window.Handle,
+            window->Window.Context
+        );
+#elif TARGET_HOST_WIN32 || TARGET_HOST_WINCE
+    if( fgStructure.Window )
+        ReleaseDC( fgStructure.Window->Window.Handle,
+                   fgStructure.Window->Window.Device );
 
-    /*
-     * Remember that we have changed the current window state
-     */
+    if ( window )
+    {
+        window->Window.Device = GetDC( window->Window.Handle );
+        wglMakeCurrent(
+            window->Window.Device,
+            window->Window.Context
+        );
+    }
+#endif
     fgStructure.Window = window;
 }
 
@@ -352,7 +270,9 @@ void fgSetWindow ( SFG_Window *window )
  * Opens a window. Requires a SFG_Window object created and attached
  * to the freeglut structure. OpenGL context is created here.
  */
-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, GLboolean isSubWindow )
 {
 #if TARGET_HOST_UNIX_X11
     XSetWindowAttributes winAttr;
@@ -364,95 +284,88 @@ void fgOpenWindow( SFG_Window* window, const char* title, int x, int y, int w, i
     freeglut_assert_ready;
 
     /*
-     * Here we are upon the stage. Have the visual selected.
+     * XXX fgChooseVisual() is a common part of all three.
+     * XXX With a little thought, we should be able to greatly
+     * XXX simplify this.
      */
-    if ( fgState.BuildingAMenu )
+    if( !window->IsMenu )
+        window->Window.VisualInfo = fgChooseVisual( );
+    else if( fgStructure.MenuContext )
+        window->Window.VisualInfo = fgChooseVisual( );
+    else
     {
-      /*
-       * If there isn't already an OpenGL rendering context for menu windows, make one
-       */
-      if ( !fgStructure.MenuContext )
-      {
+        /* 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 ;
-      }
-      else
-        window->Window.VisualInfo = fgChooseVisual();
     }
-    else
-      window->Window.VisualInfo = fgChooseVisual();
 
-    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 ) )
-      {
         /*
-         * Single buffering--try it doubled
+         * 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 ) )
+        {
+            fgState.DisplayMode |= GLUT_DOUBLE ;
+            window->Window.VisualInfo = fgChooseVisual( );
+            fgState.DisplayMode &= ~GLUT_DOUBLE;
+        }
+
+        /*
+         * GLUT also checks for multi-sampling, but I don't see that
+         * anywhere else in FREEGLUT so I won't bother with it for the moment.
          */
-        fgState.DisplayMode |= GLUT_DOUBLE ;
-        window->Window.VisualInfo = fgChooseVisual();
-	/* OK, we got a double-buffered window, but we only wanted
-	 * single-buffered.  Clear the double-buffer flag now.
-	 */
-	fgState.DisplayMode &= ~GLUT_DOUBLE ;
-      }
-
-      /*
-       * GLUT also checks for multi-sampling, but I don't see that anywhere else in FREEGLUT
-       * so I won't bother with it for the moment.
-       */
     }
 
+    /*
+     * 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.
+     */
     assert( window->Window.VisualInfo != NULL );
 
+
     /*
-     * Have the windows attributes set
-     *
-     * HINT: the masks should be updated when adding/removing callbacks.
-     *       This might speed up message processing. Is that true?
+     * 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.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;
 
-    /*
-     * The color map is required, too
-     */
     winAttr.colormap = XCreateColormap(
         fgDisplay.Display, fgDisplay.RootWindow,
         window->Window.VisualInfo->visual, AllocNone
     );
 
-    /*
-     * This tells the XCreateWindow() what attributes are we supplying it with
-     */
     mask = CWBackPixmap | CWBorderPixel | CWColormap | CWEventMask;
 
-    /*
-     * If this is a menu window we want the window manager to ignore it.
-     */
-    if ( fgState.BuildingAMenu )
+    if( window->IsMenu )
     {
         winAttr.override_redirect = True;
-	mask |= CWOverrideRedirect;
+        mask |= CWOverrideRedirect;
     }
 
-    /*
-     * Have the window created now
-     */
     window->Window.Handle = XCreateWindow(
         fgDisplay.Display,
-        window->Parent == NULL ? fgDisplay.RootWindow : window->Parent->Window.Handle,
+        window->Parent == NULL ? fgDisplay.RootWindow :
+        window->Parent->Window.Handle,
         x, y, w, h, 0,
         window->Window.VisualInfo->depth, InputOutput,
         window->Window.VisualInfo->visual, mask,
@@ -463,52 +376,50 @@ void fgOpenWindow( SFG_Window* window, const char* title, int x, int y, int w, i
      * 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 )
-      {
-        fgStructure.MenuContext = (SFG_MenuContext *)malloc ( sizeof(SFG_MenuContext) ) ;
-        fgStructure.MenuContext->VisualInfo = window->Window.VisualInfo ;
-        fgStructure.MenuContext->Context = glXCreateContext(
-            fgDisplay.Display, fgStructure.MenuContext->VisualInfo,
-            NULL, fgState.ForceDirectContext | fgState.TryDirectContext
-        );
-      }
+        /*
+         * If there isn't already an OpenGL rendering context for menu
+         * windows, make one
+         */
+        if( !fgStructure.MenuContext )
+        {
+            fgStructure.MenuContext =
+                (SFG_MenuContext *)malloc( sizeof(SFG_MenuContext) );
+            fgStructure.MenuContext->VisualInfo = window->Window.VisualInfo;
+            fgStructure.MenuContext->Context = glXCreateContext(
+                fgDisplay.Display, fgStructure.MenuContext->VisualInfo,
+                NULL, fgState.ForceDirectContext | fgState.TryDirectContext
+            );
+        }
 
-/*      window->Window.Context = fgStructure.MenuContext->Context ; */
-      window->Window.Context = glXCreateContext(
+        /* 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 )
+        if( ! window->Window.Context )
+            window->Window.Context = glXCreateContext(
+                fgDisplay.Display, window->Window.VisualInfo,
+                NULL, fgState.ForceDirectContext | fgState.TryDirectContext
+            );
+    }
+    else
         window->Window.Context = glXCreateContext(
             fgDisplay.Display, window->Window.VisualInfo,
             NULL, fgState.ForceDirectContext | fgState.TryDirectContext
         );
-    }
-    else
-      window->Window.Context = glXCreateContext(
-          fgDisplay.Display, window->Window.VisualInfo,
-          NULL, fgState.ForceDirectContext | fgState.TryDirectContext
-      );
 
-    /*
-     * Make sure the context is direct when the user wants it forced
-     */
-    if( fgState.ForceDirectContext && !glXIsDirect( fgDisplay.Display, window->Window.Context ) )
-        fgError( "unable to force direct context rendering for window '%s'", title );
+    if( fgState.ForceDirectContext &&
+        !glXIsDirect( fgDisplay.Display, window->Window.Context ) )
+        fgError( "unable to force direct context rendering for window '%s'",
+                 title );
 
-    /*
-     * Set the new context as the current one. That's all about the window creation.
-     */
     glXMakeCurrent(
         fgDisplay.Display,
         window->Window.Handle,
@@ -516,39 +427,44 @@ void fgOpenWindow( SFG_Window* window, const char* title, int x, int y, int w, i
     );
 
     /*
-     * Assume the new window is visible by default
+     * XXX Assume the new window is visible by default
+     * XXX Is this a  safe assumption?
      */
-    window->State.Visible = TRUE;
+    window->State.Visible = GL_TRUE;
 
-    /*
-     * For the position and size hints -- make sure we are passing valid values
-     */
     sizeHints.flags = 0;
-
-    if (fgState.Position.Use == TRUE) sizeHints.flags |= USPosition;
-    if (fgState.Size.Use     == TRUE) sizeHints.flags |= USSize;
+    if ( fgState.Position.Use )
+        sizeHints.flags |= USPosition;
+    if ( fgState.Size.Use )
+        sizeHints.flags |= USSize;
 
     /*
      * Fill in the size hints values now (the x, y, width and height
      * settings are obsolote, are there any more WMs that support them?)
+     * Unless the X servers actually stop supporting these, we should
+     * continue to fill them in.  It is *not* our place to tell the user
+     * that they should replace a window manager that they like, and which
+     * works, just because *we* think that it's not "modern" enough.
      */
-    sizeHints.x      = x; sizeHints.y      = y;
-    sizeHints.width  = w; sizeHints.height = h;
+#if TARGET_HOST_WINCE
+    sizeHints.x      = 0;
+    sizeHints.y      = 0;
+    sizeHints.width  = 320;
+    sizeHints.height = 240;
+#else
+    sizeHints.x      = x;
+    sizeHints.y      = y;
+    sizeHints.width  = w;
+    sizeHints.height = h;
+#endif //TARGET_HOST_WINCE
 
-    /*
-     * We can have forced all new windows start in iconified state:
-     */
     wmHints.flags = StateHint;
-    wmHints.initial_state = (fgState.ForceIconic == FALSE) ? NormalState : IconicState;
-
+    wmHints.initial_state = fgState.ForceIconic ? IconicState : NormalState;
     /*
      * Prepare the window and iconified window names...
      */
     XStringListToTextProperty( (char **) &title, 1, &textProperty );
 
-    /*
-     * Set the window's properties now
-     */
     XSetWMProperties(
         fgDisplay.Display,
         window->Window.Handle,
@@ -561,123 +477,145 @@ void fgOpenWindow( SFG_Window* window, const char* title, int x, int y, int w, i
         NULL
     );
 
-    /*
-     * Make sure we are informed about the window deletion commands
-     */
-    XSetWMProtocols( fgDisplay.Display, window->Window.Handle, &fgDisplay.DeleteWindow, 1 );
+    XSetWMProtocols( fgDisplay.Display, window->Window.Handle,
+                     &fgDisplay.DeleteWindow, 1 );
 
-    /*
-     * Finally, have the window mapped to our display
-     */
     XMapWindow( fgDisplay.Display, window->Window.Handle );
 
-#elif TARGET_HOST_WIN32
+#elif TARGET_HOST_WIN32 || TARGET_HOST_WINCE
 
-	WNDCLASS wc;
-	int flags;
-	ATOM atom;
+    WNDCLASS wc;
+    DWORD flags;
+    DWORD exFlags = 0;
+    ATOM atom;
 
     freeglut_assert_ready;
 
-	/*
-	 * Grab the window class we have registered on glutInit():
-	 */
-	atom = GetClassInfo( fgDisplay.Instance, "FREEGLUT", &wc );
-	assert( atom != 0 );
+    /*
+     * Grab the window class we have registered on glutInit():
+     */
+    atom = GetClassInfo( fgDisplay.Instance, _T("FREEGLUT"), &wc );
+    assert( atom != 0 );
 
-    if( gameMode == FALSE )
+    if( gameMode )
     {
-      if ( ( !isSubWindow ) && ( ! window->IsMenu ) )
-      {
+        assert( window->Parent == NULL );
+
         /*
-         * Update the window dimensions, taking account of window decorations.
-         * "freeglut" is to create the window with the outside of its border at (x,y)
-         * and with dimensions (w,h).
+         * Set the window creation flags appropriately to make the window
+         * entirely visible:
          */
-	    	w += (GetSystemMetrics( SM_CXSIZEFRAME ) )*2;
-	    	h += (GetSystemMetrics( SM_CYSIZEFRAME ) )*2 + GetSystemMetrics( SM_CYCAPTION );
-      }
-
-      /*
-	     * Check if the user wants us to use the default position/size
-	     */
-	    if( fgState.Position.Use == FALSE ) { x = CW_USEDEFAULT; y = CW_USEDEFAULT; }
-	    if( fgState.Size    .Use == FALSE ) { w = CW_USEDEFAULT; h = CW_USEDEFAULT; }
-
-	    /*
-	     * There's a small difference between creating the top, child and game mode windows
-	     */
-	    flags = WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_VISIBLE;
-
-      /*
-       * If we're a menu, set our flags to include WS_POPUP to remove decorations
-       */
-      if ( window->IsMenu )
-        flags |= WS_POPUP ;
-	    else if( window->Parent == NULL )
-		    flags |= WS_OVERLAPPEDWINDOW;
-	    else
-		    flags |= WS_CHILD;
+        flags = WS_POPUP | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_VISIBLE;
     }
     else
     {
-        /*
-         * In game mode, the story is a little bit different...
-         */
-        assert( window->Parent == NULL );
+#if !TARGET_HOST_WINCE
+        if ( ( ! isSubWindow ) && ( ! window->IsMenu ) )
+        {
+            /*
+             * Update the window dimensions, taking account of window
+             * decorations.  "freeglut" is to create the window with the
+             * outside of its border at (x,y) and with dimensions (w,h).
+             */
+            w += (GetSystemMetrics( SM_CXSIZEFRAME ) )*2;
+            h += (GetSystemMetrics( SM_CYSIZEFRAME ) )*2 +
+                GetSystemMetrics( SM_CYCAPTION );
+        }
+#endif //TARGET_HOST_WINCE
+
+        if( ! fgState.Position.Use )
+        {
+            x = CW_USEDEFAULT;
+            y = CW_USEDEFAULT;
+        }
+        if( ! fgState.Size.Use )
+        {
+            w = CW_USEDEFAULT;
+            h = CW_USEDEFAULT;
+        }
 
         /*
-         * Set the window creation flags appropriately to make the window entirely visible:
+         * There's a small difference between creating the top, child and
+         * game mode windows
          */
-        flags = WS_POPUP | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_VISIBLE;
+        flags = WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_VISIBLE;
+
+        if ( window->IsMenu )
+        {
+            flags |= WS_POPUP;
+            exFlags |= WS_EX_TOOLWINDOW;
+        }
+#if !TARGET_HOST_WINCE
+        else if( window->Parent == NULL )
+            flags |= WS_OVERLAPPEDWINDOW;
+#endif
+        else
+            flags |= WS_CHILD;
     }
 
-    /*
-     * Create the window now, passing the freeglut window structure as the parameter
-     */
-	window->Window.Handle = CreateWindow( 
-		"FREEGLUT",
+#if TARGET_HOST_WINCE
+    {
+        wchar_t* wstr = wstr_from_str(title);
+
+        window->Window.Handle = CreateWindow(
+            _T("FREEGLUT"),
+            wstr,
+            WS_VISIBLE | WS_POPUP,
+            0,0, 240,320,
+            NULL,
+            NULL,
+            fgDisplay.Instance,
+            (LPVOID) window
+        );
+
+        free(wstr);
+
+        SHFullScreen(window->Window.Handle, SHFS_HIDESTARTICON);
+        SHFullScreen(window->Window.Handle, SHFS_HIDESIPBUTTON);
+        SHFullScreen(window->Window.Handle, SHFS_HIDETASKBAR);
+        MoveWindow(window->Window.Handle, 0, 0, 240, 320, TRUE);
+        ShowWindow(window->Window.Handle, SW_SHOW);
+        UpdateWindow(window->Window.Handle);
+    }
+#else
+    window->Window.Handle = CreateWindowEx(
+        exFlags,
+        "FREEGLUT",
         title,
-		flags,
+        flags,
         x, y, w, h,
-		(HWND) window->Parent == NULL ? NULL : window->Parent->Window.Handle,
-		(HMENU) NULL,
-		fgDisplay.Instance,
-		(LPVOID) window
-	);
-
-	/*
-     * Make sure window was created
-     */
-	assert( window->Window.Handle != NULL );
+        (HWND) window->Parent == NULL ? NULL : window->Parent->Window.Handle,
+        (HMENU) NULL,
+        fgDisplay.Instance,
+        (LPVOID) window
+    );
+#endif TARGET_HOST_WINCE
+
+    if( !( window->Window.Handle ) )
+        fgError( "Failed to create a window (%s)!", title );
+
+#if TARGET_HOST_WINCE
+    ShowWindow( window->Window.Handle, SW_SHOW );
+#else
+    ShowWindow( window->Window.Handle,
+                fgState.ForceIconic ? SW_SHOWMINIMIZED : SW_SHOW );
+#endif //TARGET_HOST_WINCE
 
-    /*
-     * 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
 
-    /*
-     * Save the window's single- or double-buffering state
-     */
-    window->Window.DoubleBuffered = ( fgState.DisplayMode & GLUT_DOUBLE ) ? 1 : 0 ;
+    fgSetWindow( window );
+
+    window->Window.DoubleBuffered =
+        ( 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 );
 }
 
 /*
@@ -688,32 +626,41 @@ 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 );
+    XDestroyWindow( fgDisplay.Display, window->Window.Handle );
+    XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */
+
+#elif TARGET_HOST_WIN32 || TARGET_HOST_WINCE
 
     /*
-     * 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
 }
 
@@ -725,11 +672,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;
 }
 
 /*
@@ -737,30 +682,18 @@ int FGAPIENTRY glutCreateWindow( const char* title )
  */
 int FGAPIENTRY glutCreateSubWindow( int parentID, int x, int y, int w, int h )
 {
+    int ret = 0;
+
     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 );
+    window = fgCreateWindow( parent, "", x, y, w, h, GL_FALSE, GL_FALSE );
+    ret = window->ID;
 
-    /*
-     * Create the new window
-     */
-    window = fgCreateWindow( parent, "", x, y, w, h, FALSE );
-
-    /*
-     * Return the new window's ID
-     */
-    return( window->ID );
+    return ret;
 }
 
 /*
@@ -768,25 +701,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;
+    }
 }
 
 /*
@@ -796,36 +717,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 );
 }
 
 /*
@@ -834,22 +738,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;
 }
 
 /*
@@ -857,28 +748,21 @@ int FGAPIENTRY glutGetWindow( void )
  */
 void FGAPIENTRY glutShowWindow( void )
 {
-    freeglut_assert_ready; freeglut_assert_window;
+    freeglut_assert_ready;
+    freeglut_assert_window;
 
 #if TARGET_HOST_UNIX_X11
-    /*
-     * Showing the window is done via mapping under X
-     */
+
     XMapWindow( fgDisplay.Display, fgStructure.Window->Window.Handle );
-    XFlush( fgDisplay.Display );
+    XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */
 
-#elif TARGET_HOST_WIN32
-	/*
-	 * Restore the window's originial position and size
-	 */
-	ShowWindow( fgStructure.Window->Window.Handle, SW_SHOW );
+#elif TARGET_HOST_WIN32 || TARGET_HOST_WINCE
 
-#endif
+    ShowWindow( fgStructure.Window->Window.Handle, SW_SHOW );
 
-  /*
-   * Since the window is visible, we need to redisplay it ...
-   */
-  fgStructure.Window->State.Redisplay = TRUE;
+#endif
 
+    fgStructure.Window->State.Redisplay = GL_TRUE;
 }
 
 /*
@@ -886,45 +770,27 @@ 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 );
-    }
+        XWithdrawWindow( fgDisplay.Display,
+                         fgStructure.Window->Window.Handle,
+                         fgDisplay.Screen );
     else
-    {
-        /*
-         * Nope, it's a child window
-         */
-        XUnmapWindow( fgDisplay.Display, fgStructure.Window->Window.Handle );
-    }
+        XUnmapWindow( fgDisplay.Display,
+                      fgStructure.Window->Window.Handle );
+    XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */
 
-    /*
-     * Flush the X state now
-     */
-    XFlush( fgDisplay.Display );
+#elif TARGET_HOST_WIN32 || TARGET_HOST_WINCE
 
-#elif TARGET_HOST_WIN32
-	/*
-	 * Hide the window
-	 */
-	ShowWindow( fgStructure.Window->Window.Handle, SW_HIDE );
+    ShowWindow( fgStructure.Window->Window.Handle, SW_HIDE );
 
 #endif
 
-  /*
-   * Since the window is hidden, we don't need to redisplay it ...
-   */
-  fgStructure.Window->State.Redisplay = FALSE;
+    fgStructure.Window->State.Redisplay = GL_FALSE;
 }
 
 /*
@@ -932,28 +798,23 @@ 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 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 || TARGET_HOST_WINCE
 
-  /*
-   * 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;
 }
 
 /*
@@ -961,48 +822,41 @@ void FGAPIENTRY glutIconifyWindow( void )
  */
 void FGAPIENTRY glutSetWindowTitle( const char* title )
 {
-	freeglut_assert_ready; freeglut_assert_window;
+    freeglut_assert_ready;
+    freeglut_assert_window;
+    if( ! fgStructure.Window->Parent )
+    {
+#if TARGET_HOST_UNIX_X11
 
-    /*
-     * Works only for top-level windows
-     */
-    if( fgStructure.Window->Parent != NULL )
-        return;
+        XTextProperty text;
 
-#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 );
-	}
+        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 );
+
+#elif TARGET_HOST_WINCE
+        {
+            wchar_t* wstr = wstr_from_str(title);
+
+            SetWindowText( fgStructure.Window->Window.Handle, wstr );
+
+            free(wstr);
+        }
 #endif
+    }
 }
 
 /*
@@ -1010,48 +864,42 @@ 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 )
+    {
 #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 );
+
+#elif TARGET_HOST_WINCE
+        {
+            wchar_t* wstr = wstr_from_str(title);
+
+            SetWindowText( fgStructure.Window->Window.Handle, wstr );
+
+            free(wstr);
+        }
 #endif
+    }
 }
 
 /*
@@ -1059,58 +907,12 @@ 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 );
-
-#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 ... */
-    {
-      /*
-       * 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 );
-      }
-    }
-    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 ) ;
-    }
+    freeglut_assert_ready;
+    freeglut_assert_window;
 
-		/*
-		 * Resize the window, forcing a redraw to happen
-		 */
-		MoveWindow(
-			fgStructure.Window->Window.Handle,
-			x,
-			y,
-			width,
-			height,
-			TRUE
-		);
-	}
-#endif
+    fgStructure.Window->State.NeedToResize = GL_TRUE;
+    fgStructure.Window->State.Width  = width ;
+    fgStructure.Window->State.Height = height;
 }
 
 /*
@@ -1118,36 +920,30 @@ 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 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 || TARGET_HOST_WINCE
 
-    /*
-		 * 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
 }
@@ -1157,24 +953,21 @@ void FGAPIENTRY glutPositionWindow( int x, int y )
  */
 void FGAPIENTRY glutPushWindow( void )
 {
-    freeglut_assert_ready; freeglut_assert_window;
+    freeglut_assert_ready;
+    freeglut_assert_window;
 
 #if TARGET_HOST_UNIX_X11
-    /*
-     * Lower the current window
-     */
+
     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
-	);
+#elif TARGET_HOST_WIN32 || TARGET_HOST_WINCE
+
+    SetWindowPos(
+        fgStructure.Window->Window.Handle,
+        HWND_BOTTOM,
+        0, 0, 0, 0,
+        SWP_NOSIZE | SWP_NOMOVE
+    );
 
 #endif
 }
@@ -1184,24 +977,21 @@ void FGAPIENTRY glutPushWindow( void )
  */
 void FGAPIENTRY glutPopWindow( void )
 {
-    freeglut_assert_ready; freeglut_assert_window;
+    freeglut_assert_ready;
+    freeglut_assert_window;
 
 #if TARGET_HOST_UNIX_X11
-    /*
-     * Raise the current window
-     */
+
     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
-	);
+#elif TARGET_HOST_WIN32 || TARGET_HOST_WINCE
+
+    SetWindowPos(
+        fgStructure.Window->Window.Handle,
+        HWND_TOP,
+        0, 0, 0, 0,
+        SWP_NOSIZE | SWP_NOMOVE
+    );
 
 #endif
 }
@@ -1211,13 +1001,24 @@ 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 TARGET_HOST_UNIX_X11
         int x, y;
         Window w;
 
+        XMoveResizeWindow(
+            fgDisplay.Display,
+            fgStructure.Window->Window.Handle,
+            0, 0,
+            fgDisplay.ScreenWidth,
+            fgDisplay.ScreenHeight
+        );
+
+        XFlush( fgDisplay.Display ); /* This is needed */
+
         XTranslateCoordinates(
             fgDisplay.Display,
             fgStructure.Window->Window.Handle,
@@ -1225,40 +1026,49 @@ void FGAPIENTRY glutFullScreen( void )
             0, 0, &x, &y, &w
         );
 
-        if (w)
+        if (x || y)
         {
-            XTranslateCoordinates(
+            XMoveWindow(
                 fgDisplay.Display,
                 fgStructure.Window->Window.Handle,
-                w, 0, 0, &x, &y, &w
+                -x, -y
             );
-
-            x = -x;
-            y = -y;
-        }
-        else
-        {
-            x = y = 0;
+            XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */
         }
-
-        XMoveResizeWindow(
-            fgDisplay.Display,
-            fgStructure.Window->Window.Handle,
-            x, y,
-            fgDisplay.ScreenWidth,
-            fgDisplay.ScreenHeight
-        );
-        XFlush( fgDisplay.Display );
-    }
 #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
+    }
 }
 
 /*
@@ -1266,12 +1076,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 ***/