X-Git-Url: http://git.mutantstargoat.com/user/nuclear/?a=blobdiff_plain;f=src%2Ffreeglut_state.c;h=2b683e1327243cf488b99008e896af5ab3568ec6;hb=fe573d6af98de430357a7321cd50f5e92e9a2aab;hp=70d7eafec67bc9428c4f46efb957b18888a3be9b;hpb=19ec40fe17e7f60ce3548d986249381014807c35;p=freeglut

diff --git a/src/freeglut_state.c b/src/freeglut_state.c
index 70d7eaf..2b683e1 100644
--- a/src/freeglut_state.c
+++ b/src/freeglut_state.c
@@ -25,13 +25,7 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#define  G_LOG_DOMAIN  "freeglut-state"
-
-#include "../include/GL/freeglut.h"
+#include <GL/freeglut.h>
 #include "freeglut_internal.h"
 
 /*
@@ -51,7 +45,7 @@
 
 /* -- PRIVATE FUNCTIONS ---------------------------------------------------- */
 
-#if TARGET_HOST_UNIX_X11
+#if TARGET_HOST_POSIX_X11
 /*
  * Queries the GL context about some attributes
  */
@@ -59,8 +53,8 @@ static int fghGetConfig( int attribute )
 {
   int returnValue = 0;
 
-  if( fgStructure.Window )
-      glXGetConfig( fgDisplay.Display, fgStructure.Window->Window.VisualInfo,
+  if( fgStructure.CurrentWindow )
+      glXGetConfig( fgDisplay.Display, fgStructure.CurrentWindow->Window.VisualInfo,
                     attribute, &returnValue );
 
   return returnValue;
@@ -74,103 +68,123 @@ static int fghGetConfig( int attribute )
  */
 void FGAPIENTRY glutSetOption( GLenum eWhat, int value )
 {
-  freeglut_assert_ready;
-
-  /*
-   * XXX In chronological code add order.  (WHY in that order?)
-   */
-  switch( eWhat )
-  {
-  case GLUT_INIT_WINDOW_X:
-      fgState.Position.X = (GLint)value;
-      break;
-
-  case GLUT_INIT_WINDOW_Y:
-      fgState.Position.Y = (GLint)value;
-      break;
-
-  case GLUT_INIT_WINDOW_WIDTH:
-      fgState.Size.X = (GLint)value;
-      break;
-
-  case GLUT_INIT_WINDOW_HEIGHT:
-      fgState.Size.Y = (GLint)value;
-      break;
-
-  case GLUT_INIT_DISPLAY_MODE:
-      fgState.DisplayMode = (unsigned int)value;
-      break;
-
-  case GLUT_ACTION_ON_WINDOW_CLOSE:
-      fgState.ActionOnWindowClose = value;
-      break;
-
-  case GLUT_RENDERING_CONTEXT:
-      fgState.UseCurrentContext =
-          ( value == GLUT_USE_CURRENT_CONTEXT ) ? TRUE : FALSE;
-      break;
-
-  case GLUT_WINDOW_CURSOR:
-      if( fgStructure.Window != NULL )
-          fgStructure.Window->State.Cursor = value;
-      break;
-
-  default:
-      fgWarning( "glutSetOption(): missing enum handle %i\n", eWhat );
-      break;
-  }
+    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSetOption" );
+
+    /*
+     * XXX In chronological code add order.  (WHY in that order?)
+     */
+    switch( eWhat )
+    {
+    case GLUT_INIT_WINDOW_X:
+        fgState.Position.X = (GLint)value;
+        break;
+
+    case GLUT_INIT_WINDOW_Y:
+        fgState.Position.Y = (GLint)value;
+        break;
+
+    case GLUT_INIT_WINDOW_WIDTH:
+        fgState.Size.X = (GLint)value;
+        break;
+
+    case GLUT_INIT_WINDOW_HEIGHT:
+        fgState.Size.Y = (GLint)value;
+        break;
+
+    case GLUT_INIT_DISPLAY_MODE:
+        fgState.DisplayMode = (unsigned int)value;
+        break;
+
+    case GLUT_ACTION_ON_WINDOW_CLOSE:
+        fgState.ActionOnWindowClose = value;
+        break;
+
+    case GLUT_RENDERING_CONTEXT:
+        fgState.UseCurrentContext =
+            ( value == GLUT_USE_CURRENT_CONTEXT ) ? GL_TRUE : GL_FALSE;
+        break;
+
+    case GLUT_DIRECT_RENDERING:
+        fgState.DirectContext = value;
+        break;
+
+    case GLUT_WINDOW_CURSOR:
+        if( fgStructure.CurrentWindow != NULL )
+            fgStructure.CurrentWindow->State.Cursor = value;
+        break;
+
+    default:
+        fgWarning( "glutSetOption(): missing enum handle %d", eWhat );
+        break;
+    }
 }
 
+#if TARGET_HOST_MS_WINDOWS
+/* The following include file is available from SGI but is not standard:
+ *   #include <GL/wglext.h>
+ * So we copy the necessary parts out of it to support the multisampling query
+ */
+#define WGL_SAMPLES_ARB                0x2042
+#endif
+
+
 /*
  * General settings query method
  */
 int FGAPIENTRY glutGet( GLenum eWhat )
 {
+#if TARGET_HOST_MS_WINDOWS
     int returnValue ;
     GLboolean boolValue ;
+#endif
 
-    if ( eWhat == GLUT_INIT_STATE )
-        return ( fgState.Time.Set ) ;
-
-    freeglut_assert_ready;
+    int nsamples = 0;
 
-    /*
-     * XXX In chronological code add order.  (WHY in that order?)
-     */
-    switch( eWhat )
+    switch (eWhat)
     {
+    case GLUT_INIT_STATE:
+        return fgState.Initialised;
+
     case GLUT_ELAPSED_TIME:
-        return( fgElapsedTime() );
+        return fgElapsedTime();
+    }
 
-    /*
-     * Following values are stored in fgState and fgDisplay global structures
-     */
-    case GLUT_SCREEN_WIDTH:         return( fgDisplay.ScreenWidth    );
-    case GLUT_SCREEN_HEIGHT:        return( fgDisplay.ScreenHeight   );
-    case GLUT_SCREEN_WIDTH_MM:      return( fgDisplay.ScreenWidthMM  );
-    case GLUT_SCREEN_HEIGHT_MM:     return( fgDisplay.ScreenHeightMM );
-    case GLUT_INIT_WINDOW_X:        return( fgState.Position.X       );
-    case GLUT_INIT_WINDOW_Y:        return( fgState.Position.Y       );
-    case GLUT_INIT_WINDOW_WIDTH:    return( fgState.Size.X           );
-    case GLUT_INIT_WINDOW_HEIGHT:   return( fgState.Size.Y           );
-    case GLUT_INIT_DISPLAY_MODE:    return( fgState.DisplayMode      );
+    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutGet" );
 
+    /* XXX In chronological code add order.  (WHY in that order?) */
+    switch( eWhat )
+    {
+    /* Following values are stored in fgState and fgDisplay global structures */
+    case GLUT_SCREEN_WIDTH:         return fgDisplay.ScreenWidth   ;
+    case GLUT_SCREEN_HEIGHT:        return fgDisplay.ScreenHeight  ;
+    case GLUT_SCREEN_WIDTH_MM:      return fgDisplay.ScreenWidthMM ;
+    case GLUT_SCREEN_HEIGHT_MM:     return fgDisplay.ScreenHeightMM;
+    case GLUT_INIT_WINDOW_X:        return fgState.Position.Use ?
+                                           fgState.Position.X : -1 ;
+    case GLUT_INIT_WINDOW_Y:        return fgState.Position.Use ?
+                                           fgState.Position.Y : -1 ;
+    case GLUT_INIT_WINDOW_WIDTH:    return fgState.Size.Use ?
+                                           fgState.Size.X : -1     ;
+    case GLUT_INIT_WINDOW_HEIGHT:   return fgState.Size.Use ?
+                                           fgState.Size.Y : -1     ;
+    case GLUT_INIT_DISPLAY_MODE:    return fgState.DisplayMode     ;
+
+#if TARGET_HOST_POSIX_X11
     /*
      * The window/context specific queries are handled mostly by
      * fghGetConfig().
      */
     case GLUT_WINDOW_NUM_SAMPLES:
-        /*
-         * XXX Multisampling. Return what I know about multisampling.
-         */
-        return( 0 );
+#ifdef GLX_VERSION_1_3
+        glGetIntegerv(GL_SAMPLES, &nsamples);
+#endif
+        return nsamples;
 
-#if TARGET_HOST_UNIX_X11
     /*
      * The rest of GLX queries under X are general enough to use a macro to
      * check them
      */
-#   define GLX_QUERY(a,b) case a: return( fghGetConfig( b ) );
+#   define GLX_QUERY(a,b) case a: return fghGetConfig( b );
 
     GLX_QUERY( GLUT_WINDOW_RGBA,                GLX_RGBA                );
     GLX_QUERY( GLUT_WINDOW_DOUBLEBUFFER,        GLX_DOUBLEBUFFER        );
@@ -189,19 +203,17 @@ int FGAPIENTRY glutGet( GLenum eWhat )
 
 #   undef GLX_QUERY
 
-    /*
-     * Colormap size is handled in a bit different way than all the rest
-     */
+    /* Colormap size is handled in a bit different way than all the rest */
     case GLUT_WINDOW_COLORMAP_SIZE:
-        if( (fghGetConfig( GLX_RGBA )) || (fgStructure.Window == NULL) )
+        if( (fghGetConfig( GLX_RGBA )) || (fgStructure.CurrentWindow == NULL) )
         {
             /*
              * We've got a RGBA visual, so there is no colormap at all.
              * The other possibility is that we have no current window set.
              */
-            return( 0 );
+            return 0;
         }
-        return( fgStructure.Window->Window.VisualInfo->visual->map_entries );
+        return fgStructure.CurrentWindow->Window.VisualInfo->visual->map_entries;
 
     /*
      * Those calls are somewhat similiar, as they use XGetWindowAttributes()
@@ -215,12 +227,12 @@ int FGAPIENTRY glutGet( GLenum eWhat )
         int x, y;
         Window w;
 
-        if( fgStructure.Window == NULL )
-            return( 0 );
+        if( fgStructure.CurrentWindow == NULL )
+            return 0;
 
         XTranslateCoordinates(
             fgDisplay.Display,
-            fgStructure.Window->Window.Handle,
+            fgStructure.CurrentWindow->Window.Handle,
             fgDisplay.RootWindow,
             0, 0, &x, &y, &w);
 
@@ -231,10 +243,10 @@ int FGAPIENTRY glutGet( GLenum eWhat )
         }
 
         if ( w == 0 )
-            return( 0 );
+            return 0;
         XTranslateCoordinates(
             fgDisplay.Display,
-            fgStructure.Window->Window.Handle,
+            fgStructure.CurrentWindow->Window.Handle,
             w, 0, 0, &x, &y, &w);
 
         switch ( eWhat )
@@ -249,11 +261,11 @@ int FGAPIENTRY glutGet( GLenum eWhat )
     {
         XWindowAttributes winAttributes;
 
-        if( fgStructure.Window == NULL )
-            return( 0 );
+        if( fgStructure.CurrentWindow == NULL )
+            return 0;
         XGetWindowAttributes(
             fgDisplay.Display,
-            fgStructure.Window->Window.Handle,
+            fgStructure.CurrentWindow->Window.Handle,
             &winAttributes
         );
         switch ( eWhat )
@@ -263,73 +275,79 @@ int FGAPIENTRY glutGet( GLenum eWhat )
         }
     }
 
-    /*
-     * I do not know yet if there will be a fgChooseVisual() function for Win32
-     */
+    /* I do not know yet if there will be a fgChooseVisual() function for Win32 */
     case GLUT_DISPLAY_MODE_POSSIBLE:
-        return( fgChooseVisual() == NULL ? 0 : 1 );
+    {
+        XVisualInfo* visualInfo = fgChooseVisual();
+        if ( visualInfo == NULL ) {
+            return 0;
+        } else {
+            XFree( visualInfo );
+            return 1;
+        }
+    }
 
-    /*
-     * This is system-dependant
-     */
+    /* This is system-dependant */
     case GLUT_WINDOW_FORMAT_ID:
-        if( fgStructure.Window == NULL )
-            return( 0 );
+        if( fgStructure.CurrentWindow == NULL )
+            return 0;
 
-        return( fgStructure.Window->Window.VisualInfo->visualid );
+        return fgStructure.CurrentWindow->Window.VisualInfo->visualid;
 
-#elif TARGET_HOST_WIN32
+#elif TARGET_HOST_MS_WINDOWS
 
-    /*
-     * Handle the OpenGL inquiries
-     */
+    case GLUT_WINDOW_NUM_SAMPLES:
+      glGetIntegerv(WGL_SAMPLES_ARB, &nsamples);
+      return nsamples;
+
+    /* Handle the OpenGL inquiries */
     case GLUT_WINDOW_RGBA:
-      glGetBooleanv ( GL_RGBA_MODE, &boolValue ) ;
-      returnValue = boolValue ? 1 : 0 ;
-      return ( returnValue ) ;
+      glGetBooleanv ( GL_RGBA_MODE, &boolValue );
+      returnValue = boolValue ? 1 : 0;
+      return returnValue;
     case GLUT_WINDOW_DOUBLEBUFFER:
-      glGetBooleanv ( GL_DOUBLEBUFFER, &boolValue ) ;
-      returnValue = boolValue ? 1 : 0 ;
-      return ( returnValue ) ;
+      glGetBooleanv ( GL_DOUBLEBUFFER, &boolValue );
+      returnValue = boolValue ? 1 : 0;
+      return returnValue;
     case GLUT_WINDOW_STEREO:
-      glGetBooleanv ( GL_STEREO, &boolValue ) ;
-      returnValue = boolValue ? 1 : 0 ;
-      return ( returnValue ) ;
+      glGetBooleanv ( GL_STEREO, &boolValue );
+      returnValue = boolValue ? 1 : 0;
+      return returnValue;
 
     case GLUT_WINDOW_RED_SIZE:
-      glGetIntegerv ( GL_RED_BITS, &returnValue ) ;
-      return ( returnValue ) ;
+      glGetIntegerv ( GL_RED_BITS, &returnValue );
+      return returnValue;
     case GLUT_WINDOW_GREEN_SIZE:
-      glGetIntegerv ( GL_GREEN_BITS, &returnValue ) ;
-      return ( returnValue ) ;
+      glGetIntegerv ( GL_GREEN_BITS, &returnValue );
+      return returnValue;
     case GLUT_WINDOW_BLUE_SIZE:
-      glGetIntegerv ( GL_BLUE_BITS, &returnValue ) ;
-      return ( returnValue ) ;
+      glGetIntegerv ( GL_BLUE_BITS, &returnValue );
+      return returnValue;
     case GLUT_WINDOW_ALPHA_SIZE:
-      glGetIntegerv ( GL_ALPHA_BITS, &returnValue ) ;
-      return ( returnValue ) ;
+      glGetIntegerv ( GL_ALPHA_BITS, &returnValue );
+      return returnValue;
     case GLUT_WINDOW_ACCUM_RED_SIZE:
-      glGetIntegerv ( GL_ACCUM_RED_BITS, &returnValue ) ;
-      return ( returnValue ) ;
+      glGetIntegerv ( GL_ACCUM_RED_BITS, &returnValue );
+      return returnValue;
     case GLUT_WINDOW_ACCUM_GREEN_SIZE:
-      glGetIntegerv ( GL_ACCUM_GREEN_BITS, &returnValue ) ;
-      return ( returnValue ) ;
+      glGetIntegerv ( GL_ACCUM_GREEN_BITS, &returnValue );
+      return returnValue;
     case GLUT_WINDOW_ACCUM_BLUE_SIZE:
-      glGetIntegerv ( GL_ACCUM_BLUE_BITS, &returnValue ) ;
-      return ( returnValue ) ;
+      glGetIntegerv ( GL_ACCUM_BLUE_BITS, &returnValue );
+      return returnValue;
     case GLUT_WINDOW_ACCUM_ALPHA_SIZE:
-      glGetIntegerv ( GL_ACCUM_ALPHA_BITS, &returnValue ) ;
-      return ( returnValue ) ;
+      glGetIntegerv ( GL_ACCUM_ALPHA_BITS, &returnValue );
+      return returnValue;
     case GLUT_WINDOW_DEPTH_SIZE:
-      glGetIntegerv ( GL_DEPTH_BITS, &returnValue ) ;
-      return ( returnValue ) ;
+      glGetIntegerv ( GL_DEPTH_BITS, &returnValue );
+      return returnValue;
 
     case GLUT_WINDOW_BUFFER_SIZE:
       returnValue = 1 ;                                      /* ????? */
-      return ( returnValue ) ;
+      return returnValue;
     case GLUT_WINDOW_STENCIL_SIZE:
       returnValue = 0 ;                                      /* ????? */
-      return ( returnValue ) ;
+      return returnValue;
 
     case GLUT_WINDOW_X:
     case GLUT_WINDOW_Y:
@@ -362,89 +380,109 @@ int FGAPIENTRY glutGet( GLenum eWhat )
 
         RECT winRect;
 
-        freeglut_return_val_if_fail( fgStructure.Window != NULL, 0 );
+        freeglut_return_val_if_fail( fgStructure.CurrentWindow != NULL, 0 );
 
         /*
          * We need to call GetWindowRect() first...
          *  (this returns the pixel coordinates of the outside of the window)
          */
-        GetWindowRect( fgStructure.Window->Window.Handle, &winRect );
+        GetWindowRect( fgStructure.CurrentWindow->Window.Handle, &winRect );
 
-        /*
-         * ...then we've got to correct the results we've just received...
-         */
-        if ( ( fgStructure.GameMode != fgStructure.Window ) && ( fgStructure.Window->Parent == NULL ) &&
-             ( ! fgStructure.Window->IsMenu ) )
+        /* ...then we've got to correct the results we've just received... */
+
+#if !defined(_WIN32_WCE)
+        if ( ( fgStructure.GameModeWindow != fgStructure.CurrentWindow ) && ( fgStructure.CurrentWindow->Parent == NULL ) &&
+             ( ! fgStructure.CurrentWindow->IsMenu ) )
         {
           winRect.left   += GetSystemMetrics( SM_CXSIZEFRAME );
           winRect.right  -= GetSystemMetrics( SM_CXSIZEFRAME );
           winRect.top    += GetSystemMetrics( SM_CYSIZEFRAME ) + GetSystemMetrics( SM_CYCAPTION );
           winRect.bottom -= GetSystemMetrics( SM_CYSIZEFRAME );
         }
+#endif /* !defined(_WIN32_WCE) */
 
         switch( eWhat )
         {
-        case GLUT_WINDOW_X:      return( winRect.left                 );
-        case GLUT_WINDOW_Y:      return( winRect.top                  );
-        case GLUT_WINDOW_WIDTH:  return( winRect.right - winRect.left );
-        case GLUT_WINDOW_HEIGHT: return( winRect.bottom - winRect.top );
+        case GLUT_WINDOW_X:      return winRect.left                ;
+        case GLUT_WINDOW_Y:      return winRect.top                 ;
+        case GLUT_WINDOW_WIDTH:  return winRect.right - winRect.left;
+        case GLUT_WINDOW_HEIGHT: return winRect.bottom - winRect.top;
         }
     }
     break;
 
     case GLUT_WINDOW_BORDER_WIDTH :
-        return ( GetSystemMetrics( SM_CXSIZEFRAME ) ) ;
+#if defined(_WIN32_WCE)
+        return 0;
+#else
+        return GetSystemMetrics( SM_CXSIZEFRAME );
+#endif /* !defined(_WIN32_WCE) */
 
     case GLUT_WINDOW_HEADER_HEIGHT :
-        return ( GetSystemMetrics( SM_CYCAPTION ) ) ;
+#if defined(_WIN32_WCE)
+        return 0;
+#else
+        return GetSystemMetrics( SM_CYCAPTION );
+#endif /* defined(_WIN32_WCE) */
 
     case GLUT_DISPLAY_MODE_POSSIBLE:
-        return( fgSetupPixelFormat( fgStructure.Window, TRUE, PFD_MAIN_PLANE ) );
+#if defined(_WIN32_WCE)
+        return 0;
+#else
+        return fgSetupPixelFormat( fgStructure.CurrentWindow, GL_TRUE,
+                                    PFD_MAIN_PLANE );
+#endif /* defined(_WIN32_WCE) */
+
 
     case GLUT_WINDOW_FORMAT_ID:
-        if( fgStructure.Window != NULL )
-            return( GetPixelFormat( fgStructure.Window->Window.Device ) );
-        return( 0 );
+#if !defined(_WIN32_WCE)
+        if( fgStructure.CurrentWindow != NULL )
+            return GetPixelFormat( fgStructure.CurrentWindow->Window.Device );
+#endif /* defined(_WIN32_WCE) */
+        return 0;
 
 #endif
 
-    /*
-     * The window structure queries
-     */
+    /* The window structure queries */
     case GLUT_WINDOW_PARENT:
-        if( fgStructure.Window         == NULL ) return( 0 );
-        if( fgStructure.Window->Parent == NULL ) return( 0 );
-        return( fgStructure.Window->Parent->ID );
+        if( fgStructure.CurrentWindow         == NULL ) return 0;
+        if( fgStructure.CurrentWindow->Parent == NULL ) return 0;
+        return fgStructure.CurrentWindow->Parent->ID;
 
     case GLUT_WINDOW_NUM_CHILDREN:
-        if( fgStructure.Window == NULL )
-            return( 0 );
-        return( fgListLength( &fgStructure.Window->Children ) );
+        if( fgStructure.CurrentWindow == NULL )
+            return 0;
+        return fgListLength( &fgStructure.CurrentWindow->Children );
 
     case GLUT_WINDOW_CURSOR:
-        if( fgStructure.Window == NULL )
-            return( 0 );
-        return( fgStructure.Window->State.Cursor );
+        if( fgStructure.CurrentWindow == NULL )
+            return 0;
+        return fgStructure.CurrentWindow->State.Cursor;
 
     case GLUT_MENU_NUM_ITEMS:
-        if( fgStructure.Menu == NULL )
-            return( 0 );
-        return( fgListLength( &fgStructure.Menu->Entries ) );
+        if( fgStructure.CurrentMenu == NULL )
+            return 0;
+        return fgListLength( &fgStructure.CurrentMenu->Entries );
 
     case GLUT_ACTION_ON_WINDOW_CLOSE:
-        return fgState.ActionOnWindowClose ;
+        return fgState.ActionOnWindowClose;
 
     case GLUT_VERSION :
-        return VERSION_MAJOR * 10000 + VERSION_MINOR * 100 + VERSION_PATCH ;
+        return VERSION_MAJOR * 10000 + VERSION_MINOR * 100 + VERSION_PATCH;
 
     case GLUT_RENDERING_CONTEXT:
-        return ( fgState.UseCurrentContext ? GLUT_USE_CURRENT_CONTEXT : GLUT_CREATE_NEW_CONTEXT ) ;
+        return fgState.UseCurrentContext ? GLUT_USE_CURRENT_CONTEXT
+                                         : GLUT_CREATE_NEW_CONTEXT;
+
+    case GLUT_DIRECT_RENDERING:
+        return fgState.DirectContext;
+        break;
 
     default:
-        fgWarning( "glutGet(): missing enum handle %i\n", eWhat );
+        fgWarning( "glutGet(): missing enum handle %d", eWhat );
         break;
     }
-    return( -1 );
+    return -1;
 }
 
 /*
@@ -452,107 +490,113 @@ int FGAPIENTRY glutGet( GLenum eWhat )
  */
 int FGAPIENTRY glutDeviceGet( GLenum eWhat )
 {
-    freeglut_assert_ready;
+    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutDeviceGet" );
 
-    /*
-     * XXX WARNING: we are mostly lying in this function.
-     */
+    /* XXX WARNING: we are mostly lying in this function. */
     switch( eWhat )
     {
     case GLUT_HAS_KEYBOARD:
         /*
-         * We always have a keyboard present on PC machines...
+         * Win32 is assumed a keyboard, and this cannot be queried,
+         * except for WindowsCE.
          *
-         * XXX I think that some of my PCs will boot without a keyboard.
-         * XXX Also, who says that we are running on a PC?  UNIX/X11
-         * XXX is much more generic, and X11 can go over a network.
-         * XXX Though in actuality, we can probably assume BOTH a
-         * XXX mouse and keyboard for most/all of our users.
+         * X11 has a core keyboard by definition, although it can
+         * be present as a virtual/dummy keyboard. For now, there
+         * is no reliable way to tell if a real keyboard is present.
          */
-        return( TRUE );
+#if defined(_WIN32_CE)
+        return ( GetKeyboardStatus() & KBDI_KEYBOARD_PRESENT ) ? 1 : 0;
+#   if FREEGLUT_LIB_PRAGMAS
+#       pragma comment (lib,"Kbdui.lib")
+#   endif
+
+#else
+        return 1;
+#endif
 
-#if TARGET_HOST_UNIX_X11
+#if TARGET_HOST_POSIX_X11
 
+    /* X11 has a mouse by definition */
     case GLUT_HAS_MOUSE:
-        return( TRUE );
+        return 1 ;
 
     case GLUT_NUM_MOUSE_BUTTONS:
-        /*
-         * Return the number of mouse buttons available. This is a big guess.
+        /* We should be able to pass NULL when the last argument is zero,
+         * but at least one X server has a bug where this causes a segfault.
          *
-         * XXX We can probe /var/run/dmesg.boot which is world-readable.
-         * XXX This would be somewhat system-dependant, but is doable.
-         * XXX E.g., on NetBSD, my USB mouse registers:
-         * XXX   ums0 at uhidev0: 3 buttons and Z dir.
-         * XXX We can also probe /var/log/XFree86\..*\.log to get
-         * XXX lines such as:
-         * XXX   (**) Option "Buttons" "5"
-         * XXX   (**) Option "ZAxisMapping" "4 5"
-         * XXX   (**) Mouse0: ZAxisMapping: buttons 4 and 5
-         * XXX   (**) Mouse0: Buttons: 5
-         * XXX ...which tells us even more, and is a bit less
-         * XXX system-dependant.  (Other than MS-WINDOWS, all
-         * XXX target hosts with actual users are probably running
-         * XXX XFree86...)  It is at least worth taking a look at
-         * XXX this file.
+         * In XFree86/Xorg servers, a mouse wheel is seen as two buttons
+         * rather than an Axis; "freeglut_main.c" expects this when
+         * checking for a wheel event.
          */
-        return( 3 );
+        {
+            unsigned char map;
+            int nbuttons = XGetPointerMapping(fgDisplay.Display, &map,0);
+            return nbuttons;
+        }
 
-#elif TARGET_HOST_WIN32
+#elif TARGET_HOST_MS_WINDOWS
 
     case GLUT_HAS_MOUSE:
         /*
-         * The Windows can be booted without a mouse. 
-         * It would be nice to have this reported.
+         * MS Windows can be booted without a mouse.
          */
-        return( GetSystemMetrics( SM_MOUSEPRESENT ) );
+        return GetSystemMetrics( SM_MOUSEPRESENT );
 
     case GLUT_NUM_MOUSE_BUTTONS:
-        /*
-         * We are much more fortunate under Win32 about this...
-         */
-        return( GetSystemMetrics( SM_CMOUSEBUTTONS ) );
-
+#  if defined(_WIN32_WCE)
+        return 1;
+#  else
+        return GetSystemMetrics( SM_CMOUSEBUTTONS );
+#  endif
 #endif
 
-    case GLUT_JOYSTICK_POLL_RATE:
     case GLUT_HAS_JOYSTICK:
+        return fgJoystickDetect ();
+
+    case GLUT_OWNS_JOYSTICK:
+        return fgState.JoysticksInitialised;
+
+    case GLUT_JOYSTICK_POLL_RATE:
+        return fgStructure.CurrentWindow ? fgStructure.CurrentWindow->State.JoystickPollRate : 0;
+
+    /* XXX The following two are only for Joystick 0 but this is an improvement */
     case GLUT_JOYSTICK_BUTTONS:
+        return glutJoystickGetNumButtons ( 0 );
+
     case GLUT_JOYSTICK_AXES:
-        /*
-         * XXX WARNING: THIS IS A BIG LIE!
-         */
-        return( 0 );
+        return glutJoystickGetNumAxes ( 0 );
 
-    case GLUT_HAS_SPACEBALL:
     case GLUT_HAS_DIAL_AND_BUTTON_BOX:
+        return fgInputDeviceDetect ();
+
+    case GLUT_NUM_DIALS:
+        if ( fgState.InputDevsInitialised ) return 8;
+        return 0;
+ 
+    case GLUT_NUM_BUTTON_BOX_BUTTONS:
+        return 0;
+
+    case GLUT_HAS_SPACEBALL:
     case GLUT_HAS_TABLET:
-        return( FALSE );
+        return 0;
 
     case GLUT_NUM_SPACEBALL_BUTTONS:
-    case GLUT_NUM_BUTTON_BOX_BUTTONS:
-    case GLUT_NUM_DIALS:
     case GLUT_NUM_TABLET_BUTTONS:
-        return( 0 );
+        return 0;
 
     case GLUT_DEVICE_IGNORE_KEY_REPEAT:
-        return( fgState.IgnoreKeyRepeat );
+        return fgStructure.CurrentWindow ? fgStructure.CurrentWindow->State.IgnoreKeyRepeat : 0;
 
     case GLUT_DEVICE_KEY_REPEAT:
-        /*
-         * XXX WARNING: THIS IS A BIG LIE!
-         */
-        return( GLUT_KEY_REPEAT_DEFAULT );
+        return fgState.KeyRepeat;
 
     default:
-        fgWarning( "glutDeviceGet(): missing enum handle %i\n", eWhat );
+        fgWarning( "glutDeviceGet(): missing enum handle %d", eWhat );
         break;
     }
 
-    /*
-     * And now -- the failure.
-     */
-    return( -1 );
+    /* And now -- the failure. */
+    return -1;
 }
 
 /*
@@ -560,16 +604,14 @@ int FGAPIENTRY glutDeviceGet( GLenum eWhat )
  */
 int FGAPIENTRY glutGetModifiers( void )
 {
-    if( fgStructure.Window == NULL )
-        return( 0 );
-
-    if( fgStructure.Window->State.Modifiers == 0xffffffff )
+    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutGetModifiers" );
+    if( fgState.Modifiers == INVALID_MODIFIERS )
     {
         fgWarning( "glutGetModifiers() called outside an input callback" );
-        return( 0 );
+        return 0;
     }
 
-    return( fgStructure.Window->State.Modifiers );
+    return fgState.Modifiers;
 }
 
 /*
@@ -577,7 +619,7 @@ int FGAPIENTRY glutGetModifiers( void )
  */
 int FGAPIENTRY glutLayerGet( GLenum eWhat )
 {
-    freeglut_assert_ready;
+    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutLayerGet" );
 
     /*
      * This is easy as layers are not implemented ;-)
@@ -588,16 +630,16 @@ int FGAPIENTRY glutLayerGet( GLenum eWhat )
     switch( eWhat )
     {
 
-#if TARGET_HOST_UNIX_X11
+#if TARGET_HOST_POSIX_X11
 
     case GLUT_OVERLAY_POSSIBLE:
-        return( FALSE );
+        return 0;
 
     case GLUT_LAYER_IN_USE:
-        return( GLUT_NORMAL );
+        return GLUT_NORMAL;
 
     case GLUT_HAS_OVERLAY:
-        return( FALSE );
+        return 0;
 
     case GLUT_TRANSPARENT_INDEX:
         /*
@@ -605,28 +647,27 @@ int FGAPIENTRY glutLayerGet( GLenum eWhat )
          *
          * XXX HUH?
          */
-        return( 0 );
+        return 0;
 
     case GLUT_NORMAL_DAMAGED:
-        /*
-         * XXX Actually I do not know. Maybe.
-         */
-        return( FALSE );
+        /* XXX Actually I do not know. Maybe. */
+        return 0;
 
     case GLUT_OVERLAY_DAMAGED:
-        return( -1 );
+        return -1;
 
-#elif TARGET_HOST_WIN32
+#elif TARGET_HOST_MS_WINDOWS
 
     case GLUT_OVERLAY_POSSIBLE:
-/*        return( fgSetupPixelFormat( fgStructure.Window, TRUE, PFD_OVERLAY_PLANE ) ); */
-      return FALSE ;
+/*      return fgSetupPixelFormat( fgStructure.CurrentWindow, GL_TRUE,
+                                   PFD_OVERLAY_PLANE ); */
+      return 0 ;
 
     case GLUT_LAYER_IN_USE:
-        return( GLUT_NORMAL );
+        return GLUT_NORMAL;
 
     case GLUT_HAS_OVERLAY:
-        return( FALSE );
+        return 0;
 
     case GLUT_TRANSPARENT_INDEX:
         /*
@@ -634,27 +675,23 @@ int FGAPIENTRY glutLayerGet( GLenum eWhat )
          *
          * XXX HUH?
          */
-        return( 0 );
+        return 0;
 
     case GLUT_NORMAL_DAMAGED:
-        /*
-         * XXX Actually I do not know. Maybe.
-         */
-        return( FALSE );
+        /* XXX Actually I do not know. Maybe. */
+        return 0;
 
     case GLUT_OVERLAY_DAMAGED:
-        return( -1 );
+        return -1;
 #endif
 
     default:
-        fgWarning( "glutLayerGet(): missing enum handle %i\n", eWhat );
+        fgWarning( "glutLayerGet(): missing enum handle %d", eWhat );
         break;
     }
 
-    /*
-     * And fail. That's good. Programs do love failing.
-     */
-    return( -1 );
+    /* And fail. That's good. Programs do love failing. */
+    return -1;
 }
 
 /*** END OF FILE ***/