git.mutantstargoat.com Git - freeglut/blob - src/mswin/fg_window_mswin.c

   1 /*
   2  * freeglut_window_mswin.c
   3  *
   4  * The Windows-specific mouse cursor related stuff.
   5  *
   6  * Copyright (c) 2012 Stephen J. Baker. All Rights Reserved.
   7  * Written by John F. Fay, <fayjf@sourceforge.net>
   8  * Creation date: Sun Jan 22, 2012
   9  *
  10  * Permission is hereby granted, free of charge, to any person obtaining a
  11  * copy of this software and associated documentation files (the "Software"),
  12  * to deal in the Software without restriction, including without limitation
  13  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  14  * and/or sell copies of the Software, and to permit persons to whom the
  15  * Software is furnished to do so, subject to the following conditions:
  16  *
  17  * The above copyright notice and this permission notice shall be included
  18  * in all copies or substantial portions of the Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  21  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  23  * PAWEL W. OLSZTA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
  24  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  25  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  26  */
  27
  28 #define FREEGLUT_BUILDING_LIB
  29 #include <GL/freeglut.h>
  30 #include "../fg_internal.h"
  31
  32
  33 /* The following include file is available from SGI but is not standard:
  34  *   #include <GL/wglext.h>
  35  * So we copy the necessary parts out of it.
  36  * XXX: should local definitions for extensions be put in a separate include file?
  37  */
  38 typedef const char * (WINAPI * PFNWGLGETEXTENSIONSSTRINGARBPROC) (HDC hdc);
  39
  40 typedef BOOL (WINAPI * PFNWGLCHOOSEPIXELFORMATARBPROC) (HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats);
  41
  42 #define WGL_DRAW_TO_WINDOW_ARB         0x2001
  43 #define WGL_ACCELERATION_ARB           0x2003
  44 #define WGL_SUPPORT_OPENGL_ARB         0x2010
  45 #define WGL_DOUBLE_BUFFER_ARB          0x2011
  46 #define WGL_COLOR_BITS_ARB             0x2014
  47 #define WGL_ALPHA_BITS_ARB             0x201B
  48 #define WGL_DEPTH_BITS_ARB             0x2022
  49 #define WGL_STENCIL_BITS_ARB           0x2023
  50 #define WGL_FULL_ACCELERATION_ARB      0x2027
  51
  52 #define WGL_SAMPLE_BUFFERS_ARB         0x2041
  53 #define WGL_SAMPLES_ARB                0x2042
  54
  55 #define WGL_TYPE_RGBA_FLOAT_ARB        0x21A0
  56
  57 #define WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB 0x20A9
  58
  59 #ifndef WGL_ARB_create_context
  60 #define WGL_ARB_create_context 1
  61 #ifdef WGL_WGLEXT_PROTOTYPES
  62 extern HGLRC WINAPI wglCreateContextAttribsARB (HDC, HGLRC, const int *);
  63 #endif /* WGL_WGLEXT_PROTOTYPES */
  64 typedef HGLRC (WINAPI * PFNWGLCREATECONTEXTATTRIBSARBPROC) (HDC hDC, HGLRC hShareContext, const int *attribList);
  65
  66 #define WGL_CONTEXT_MAJOR_VERSION_ARB  0x2091
  67 #define WGL_CONTEXT_MINOR_VERSION_ARB  0x2092
  68 #define WGL_CONTEXT_LAYER_PLANE_ARB    0x2093
  69 #define WGL_CONTEXT_FLAGS_ARB          0x2094
  70 #define WGL_CONTEXT_PROFILE_MASK_ARB   0x9126
  71
  72 #define WGL_CONTEXT_DEBUG_BIT_ARB      0x0001
  73 #define WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB 0x0002
  74
  75 #define WGL_CONTEXT_CORE_PROFILE_BIT_ARB 0x00000001
  76 #define WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002
  77
  78 #define ERROR_INVALID_VERSION_ARB      0x2095
  79 #define ERROR_INVALID_PROFILE_ARB      0x2096
  80 #endif
  81 /* End of copying the necessary parts out of it. */
  82
  83 #ifdef WM_TOUCH
  84 typedef BOOL (WINAPI *pRegisterTouchWindow)(HWND,ULONG);
  85 static pRegisterTouchWindow fghRegisterTouchWindow = (pRegisterTouchWindow)0xDEADBEEF;
  86 #endif
  87
  88
  89 /*
  90  * Setup the pixel format for a Win32 window
  91  */
  92
  93 #if defined(_WIN32_WCE)
  94 static wchar_t* fghWstrFromStr(const char* str)
  95 {
  96     int i,len=strlen(str);
  97     wchar_t* wstr = (wchar_t*)malloc(2*len+2);
  98     for(i=0; i<len; i++)
  99         wstr[i] = str[i];
 100     wstr[len] = 0;
 101     return wstr;
 102 }
 103 #endif /* defined(_WIN32_WCE) */
 104
 105
 106 static void fghFillContextAttributes( int *attributes ) {
 107   int where = 0, contextFlags, contextProfile;
 108
 109   ATTRIB_VAL( WGL_CONTEXT_MAJOR_VERSION_ARB, fgState.MajorVersion );
 110   ATTRIB_VAL( WGL_CONTEXT_MINOR_VERSION_ARB, fgState.MinorVersion );
 111
 112   contextFlags =
 113     fghMapBit( fgState.ContextFlags, GLUT_DEBUG, WGL_CONTEXT_DEBUG_BIT_ARB ) |
 114     fghMapBit( fgState.ContextFlags, GLUT_FORWARD_COMPATIBLE, WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB );
 115   if ( contextFlags != 0 ) {
 116     ATTRIB_VAL( WGL_CONTEXT_FLAGS_ARB, contextFlags );
 117   }
 118
 119   contextProfile =
 120     fghMapBit( fgState.ContextProfile, GLUT_CORE_PROFILE, WGL_CONTEXT_CORE_PROFILE_BIT_ARB ) |
 121     fghMapBit( fgState.ContextProfile, GLUT_COMPATIBILITY_PROFILE, WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB );
 122   if ( contextProfile != 0 ) {
 123     ATTRIB_VAL( WGL_CONTEXT_PROFILE_MASK_ARB, contextProfile );
 124   }
 125
 126   ATTRIB( 0 );
 127 }
 128
 129 static int fghIsExtensionSupported( HDC hdc, const char *extension ) {
 130     const char *pWglExtString;
 131     PFNWGLGETEXTENSIONSSTRINGARBPROC wglGetEntensionsStringARB =
 132       (PFNWGLGETEXTENSIONSSTRINGARBPROC) wglGetProcAddress("wglGetExtensionsStringARB");
 133     if ( wglGetEntensionsStringARB == NULL )
 134     {
 135       return FALSE;
 136     }
 137     pWglExtString = wglGetEntensionsStringARB( hdc );
 138     return ( pWglExtString != NULL ) && ( strstr(pWglExtString, extension) != NULL );
 139 }
 140
 141 void fgNewWGLCreateContext( SFG_Window* window )
 142 {
 143     HGLRC context;
 144     int attributes[9];
 145     PFNWGLCREATECONTEXTATTRIBSARBPROC wglCreateContextAttribsARB;
 146
 147     /* If nothing fancy has been required, leave the context as it is */
 148     if ( fghIsLegacyContextRequested() )
 149     {
 150         return;
 151     }
 152
 153     wglMakeCurrent( window->Window.pContext.Device, window->Window.Context );
 154
 155     if ( !fghIsExtensionSupported( window->Window.pContext.Device, "WGL_ARB_create_context" ) )
 156     {
 157         /* wglCreateContextAttribsARB not found, yet the user has requested the new context creation */
 158         fgWarning( "OpenGL >2.1 context requested but wglCreateContextAttribsARB is not available! Falling back to legacy context creation" );
 159         /* Legacy context already created at this point in WM_CREATE path of fgPlatformWindowProc, just return */
 160         return;
 161     }
 162
 163     /* new context creation */
 164     fghFillContextAttributes( attributes );
 165
 166     wglCreateContextAttribsARB = (PFNWGLCREATECONTEXTATTRIBSARBPROC) wglGetProcAddress( "wglCreateContextAttribsARB" );
 167     if ( wglCreateContextAttribsARB == NULL )
 168     {
 169         /* wglCreateContextAttribsARB not found, yet the user has requested the new context creation */
 170         fgWarning( "OpenGL >2.1 context requested but wglCreateContextAttribsARB is not available! Falling back to legacy context creation" );
 171         /* Legacy context already created at this point in WM_CREATE path of fgPlatformWindowProc, just return */
 172         return;
 173     }
 174
 175     context = wglCreateContextAttribsARB( window->Window.pContext.Device, 0, attributes );
 176     if ( context == NULL )
 177     {
 178         fghContextCreationError();
 179     }
 180
 181     wglMakeCurrent( NULL, NULL );
 182     wglDeleteContext( window->Window.Context );
 183     window->Window.Context = context;
 184 }
 185
 186 #if !defined(_WIN32_WCE)
 187
 188 static void fghFillPFD( PIXELFORMATDESCRIPTOR *ppfd, HDC hdc, unsigned char layer_type )
 189 {
 190   int flags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL;
 191   if ( fgState.DisplayMode & GLUT_DOUBLE ) {
 192         flags |= PFD_DOUBLEBUFFER;
 193   }
 194   if ( fgState.DisplayMode & GLUT_STEREO ) {
 195     flags |= PFD_STEREO;
 196   }
 197
 198 #if defined(_MSC_VER)
 199 #pragma message( "fgSetupPixelFormat(): there is still some work to do here!" )
 200 #endif
 201
 202   /* Specify which pixel format do we opt for... */
 203   ppfd->nSize = sizeof(PIXELFORMATDESCRIPTOR);
 204   ppfd->nVersion = 1;
 205   ppfd->dwFlags = flags;
 206
 207   if( fgState.DisplayMode & GLUT_INDEX ) {
 208     ppfd->iPixelType = PFD_TYPE_COLORINDEX;
 209     ppfd->cRedBits = 0;
 210     ppfd->cGreenBits = 0;
 211     ppfd->cBlueBits = 0;
 212     ppfd->cAlphaBits = 0;
 213   } else {
 214     ppfd->iPixelType = PFD_TYPE_RGBA;
 215     ppfd->cRedBits = 8;
 216     ppfd->cGreenBits = 8;
 217     ppfd->cBlueBits = 8;
 218     ppfd->cAlphaBits = ( fgState.DisplayMode & GLUT_ALPHA ) ? 8 : 0;
 219   }
 220
 221   ppfd->cColorBits = 24;
 222   ppfd->cRedShift = 0;
 223   ppfd->cGreenShift = 0;
 224   ppfd->cBlueShift = 0;
 225   ppfd->cAlphaShift = 0;
 226   ppfd->cAccumBits = ( fgState.DisplayMode & GLUT_ACCUM ) ? 1 : 0;
 227   ppfd->cAccumRedBits = 0;
 228   ppfd->cAccumGreenBits = 0;
 229   ppfd->cAccumBlueBits = 0;
 230   ppfd->cAccumAlphaBits = 0;
 231
 232   /* Hmmm, or 32/0 instead of 24/8? */
 233   ppfd->cDepthBits = 24;
 234   ppfd->cStencilBits = 8;
 235
 236   ppfd->cAuxBuffers = fghNumberOfAuxBuffersRequested();
 237   ppfd->iLayerType = layer_type;
 238   ppfd->bReserved = 0;
 239   ppfd->dwLayerMask = 0;
 240   ppfd->dwVisibleMask = 0;
 241   ppfd->dwDamageMask = 0;
 242
 243   ppfd->cColorBits = (BYTE) GetDeviceCaps( hdc, BITSPIXEL );
 244 }
 245
 246 static void fghFillPixelFormatAttributes( int *attributes, const PIXELFORMATDESCRIPTOR *ppfd )
 247 {
 248   int where = 0;
 249
 250   ATTRIB_VAL( WGL_DRAW_TO_WINDOW_ARB, GL_TRUE );
 251   ATTRIB_VAL( WGL_SUPPORT_OPENGL_ARB, GL_TRUE );
 252   ATTRIB_VAL( WGL_ACCELERATION_ARB, WGL_FULL_ACCELERATION_ARB );
 253
 254   ATTRIB_VAL( WGL_COLOR_BITS_ARB, ppfd->cColorBits );
 255   ATTRIB_VAL( WGL_ALPHA_BITS_ARB, ppfd->cAlphaBits );
 256   ATTRIB_VAL( WGL_DEPTH_BITS_ARB, ppfd->cDepthBits );
 257   ATTRIB_VAL( WGL_STENCIL_BITS_ARB, ppfd->cStencilBits );
 258
 259   ATTRIB_VAL( WGL_DOUBLE_BUFFER_ARB, ( fgState.DisplayMode & GLUT_DOUBLE ) != 0 );
 260
 261   if ( fgState.DisplayMode & GLUT_SRGB ) {
 262     ATTRIB_VAL( WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB, TRUE );
 263   }
 264
 265   ATTRIB_VAL( WGL_SAMPLE_BUFFERS_ARB, GL_TRUE );
 266   ATTRIB_VAL( WGL_SAMPLES_ARB, fgState.SampleNumber );
 267   ATTRIB( 0 );
 268 }
 269 #endif
 270
 271 GLboolean fgSetupPixelFormat( SFG_Window* window, GLboolean checkOnly,
 272                               unsigned char layer_type )
 273 {
 274 #if defined(_WIN32_WCE)
 275     return GL_TRUE;
 276 #else
 277     PIXELFORMATDESCRIPTOR pfd;
 278     PIXELFORMATDESCRIPTOR* ppfd = &pfd;
 279     int pixelformat;
 280     HDC current_hDC;
 281     GLboolean success;
 282
 283     if (checkOnly)
 284       current_hDC = CreateDC(TEXT("DISPLAY"), NULL ,NULL ,NULL);
 285     else
 286       current_hDC = window->Window.pContext.Device;
 287
 288     fghFillPFD( ppfd, current_hDC, layer_type );
 289     pixelformat = ChoosePixelFormat( current_hDC, ppfd );
 290
 291     /* windows hack for multismapling/sRGB */
 292     if ( ( fgState.DisplayMode & GLUT_MULTISAMPLE ) ||
 293          ( fgState.DisplayMode & GLUT_SRGB ) )
 294     {
 295         HGLRC rc, rc_before=wglGetCurrentContext();
 296         HWND hWnd;
 297         HDC hDC, hDC_before=wglGetCurrentDC();
 298         WNDCLASS wndCls;
 299
 300         /* create a dummy window */
 301         ZeroMemory(&wndCls, sizeof(wndCls));
 302         wndCls.lpfnWndProc = DefWindowProc;
 303         wndCls.hInstance = fgDisplay.pDisplay.Instance;
 304         wndCls.style = CS_OWNDC | CS_HREDRAW | CS_VREDRAW;
 305         wndCls.lpszClassName = _T("FREEGLUT_dummy");
 306         RegisterClass( &wndCls );
 307
 308         hWnd=CreateWindow(_T("FREEGLUT_dummy"), _T(""), WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_OVERLAPPEDWINDOW , 0,0,0,0, 0, 0, fgDisplay.pDisplay.Instance, 0 );
 309         hDC=GetDC(hWnd);
 310         SetPixelFormat( hDC, pixelformat, ppfd );
 311
 312         rc = wglCreateContext( hDC );
 313         wglMakeCurrent(hDC, rc);
 314
 315         if ( fghIsExtensionSupported( hDC, "WGL_ARB_multisample" ) )
 316         {
 317             PFNWGLCHOOSEPIXELFORMATARBPROC wglChoosePixelFormatARBProc =
 318               (PFNWGLCHOOSEPIXELFORMATARBPROC) wglGetProcAddress("wglChoosePixelFormatARB");
 319             if ( wglChoosePixelFormatARBProc )
 320             {
 321                 int attributes[100];
 322                 int iPixelFormat;
 323                 BOOL bValid;
 324                 float fAttributes[] = { 0, 0 };
 325                 UINT numFormats;
 326                 fghFillPixelFormatAttributes( attributes, ppfd );
 327                 bValid = wglChoosePixelFormatARBProc(hDC, attributes, fAttributes, 1, &iPixelFormat, &numFormats);
 328
 329                 if ( bValid && numFormats > 0 )
 330                 {
 331                     pixelformat = iPixelFormat;
 332                 }
 333             }
 334         }
 335
 336         wglMakeCurrent( hDC_before, rc_before);
 337         wglDeleteContext(rc);
 338         ReleaseDC(hWnd, hDC);
 339         DestroyWindow(hWnd);
 340         UnregisterClass(_T("FREEGLUT_dummy"), fgDisplay.pDisplay.Instance);
 341     }
 342
 343     success = ( pixelformat != 0 ) && ( checkOnly || SetPixelFormat( current_hDC, pixelformat, ppfd ) );
 344
 345     if (checkOnly)
 346         DeleteDC(current_hDC);
 347
 348     return success;
 349 #endif /* defined(_WIN32_WCE) */
 350 }
 351
 352
 353
 354 void fgPlatformSetWindow ( SFG_Window *window )
 355 {
 356     if ( window != fgStructure.CurrentWindow )
 357     {
 358         if( fgStructure.CurrentWindow )
 359             ReleaseDC( fgStructure.CurrentWindow->Window.Handle,
 360                        fgStructure.CurrentWindow->Window.pContext.Device );
 361
 362         if ( window )
 363         {
 364             window->Window.pContext.Device = GetDC( window->Window.Handle );
 365             wglMakeCurrent(
 366                 window->Window.pContext.Device,
 367                 window->Window.Context
 368             );
 369         }
 370     }
 371 }
 372
 373
 374 void fghPlatformGetMousePos(SFG_XYUse *mouse_pos)
 375 {
 376     POINT pos;
 377     GetCursorPos(&pos);
 378
 379     mouse_pos->X = pos.x;
 380     mouse_pos->Y = pos.y;
 381     mouse_pos->Use = GL_TRUE;
 382 }
 383
 384 /* Returns the width of the window borders based on the window's style.
 385 */
 386 void fghGetBorderWidth(const DWORD windowStyle, int* xBorderWidth, int* yBorderWidth)
 387 {
 388     if (windowStyle & WS_THICKFRAME)
 389     {
 390         *xBorderWidth = GetSystemMetrics(SM_CXSIZEFRAME);
 391         *yBorderWidth = GetSystemMetrics(SM_CYSIZEFRAME);
 392     }
 393     else if (windowStyle & WS_DLGFRAME)
 394     {
 395         *xBorderWidth = GetSystemMetrics(SM_CXFIXEDFRAME);
 396         *yBorderWidth = GetSystemMetrics(SM_CYFIXEDFRAME);
 397     }
 398     else
 399     {
 400         *xBorderWidth = 0;
 401         *yBorderWidth = 0;
 402     }
 403 }
 404
 405
 406
 407 /* Computes position of corners of window Rect (outer position including
 408  * decorations) based on the provided client rect and based on the style
 409  * of the window in question.
 410  * If posIsOutside is set to true, the input client Rect is taken to follow
 411  * freeGLUT's window specification convention in which the top-left corner
 412  * is at the outside of the window, while the size
 413  * (rect.right-rect.left,rect.bottom-rect.top) is the size of the drawable
 414  * area.
 415  */
 416 void fghComputeWindowRectFromClientArea_UseStyle( const DWORD windowStyle, RECT *clientRect, BOOL posIsOutside )
 417 {
 418     int xBorderWidth = 0, yBorderWidth = 0;
 419
 420     /* If window has title bar, correct rect for it */
 421     if (windowStyle & WS_MAXIMIZEBOX) /* Need to query for WS_MAXIMIZEBOX to see if we have a title bar, the WS_CAPTION query is also true for a WS_DLGFRAME only... */
 422     {
 423         if (posIsOutside)
 424             clientRect->bottom += GetSystemMetrics( SM_CYCAPTION );
 425         else
 426             clientRect->top -= GetSystemMetrics( SM_CYCAPTION );
 427     }
 428
 429     /* get width of window's borders (frame), correct rect for it.
 430      * Note, borders can be of zero width if style does not specify borders
 431      */
 432     fghGetBorderWidth(windowStyle, &xBorderWidth, &yBorderWidth);
 433     if (posIsOutside)
 434     {
 435         clientRect->right  += xBorderWidth * 2;
 436         clientRect->bottom += yBorderWidth * 2;
 437     }
 438     else
 439     {
 440         clientRect->left   -= xBorderWidth;
 441         clientRect->right  += xBorderWidth;
 442         clientRect->top    -= yBorderWidth;
 443         clientRect->bottom += yBorderWidth;
 444     }
 445 }
 446
 447 /* Computes position of corners of window Rect (outer position including
 448  * decorations) based on the provided client rect and based on the style
 449  * of the window in question. If the window pointer or the window handle
 450  * is NULL, a fully decorated window (caption and border) is assumed.
 451  * Furthermore, if posIsOutside is set to true, the input client Rect is
 452  * taken to follow freeGLUT's window specification convention in which the
 453  * top-left corner is at the outside of the window, while the size
 454  * (rect.right-rect.left,rect.bottom-rect.top) is the size of the drawable
 455  * area.
 456 */
 457 void fghComputeWindowRectFromClientArea_QueryWindow( const SFG_Window *window, RECT *clientRect, BOOL posIsOutside )
 458 {
 459     DWORD windowStyle = 0;
 460
 461     if (window && window->Window.Handle)
 462         windowStyle = GetWindowLong(window->Window.Handle, GWL_STYLE);
 463     else
 464         windowStyle = WS_OVERLAPPEDWINDOW;
 465
 466     fghComputeWindowRectFromClientArea_UseStyle(windowStyle, clientRect, posIsOutside);
 467 }
 468
 469 /* Computes position of corners of client area (drawable area) of a window
 470  * based on the provided window Rect (outer position including decorations)
 471  * and based on the style of the window in question. If the window pointer
 472  * or the window handle is NULL, a fully decorated window (caption and
 473  * border) is assumed.
 474  * Furthermore, if wantPosOutside is set to true, the output client Rect
 475  * will follow freeGLUT's window specification convention in which the
 476  * top-left corner is at the outside of the window, the size
 477  * (rect.right-rect.left,rect.bottom-rect.top) is the size of the drawable
 478  * area.
 479  */
 480 void fghComputeClientAreaFromWindowRect( const SFG_Window *window, RECT *windowRect, BOOL wantPosOutside )
 481 {
 482     DWORD windowStyle = 0;
 483     int xBorderWidth = 0, yBorderWidth = 0;
 484
 485     if (window && window->Window.Handle)
 486         windowStyle = GetWindowLong(window->Window.Handle, GWL_STYLE);
 487     else
 488         windowStyle = WS_OVERLAPPEDWINDOW;
 489
 490     /* If window has title bar, correct rect for it */
 491     if (windowStyle & WS_MAXIMIZEBOX) /* Need to query for WS_MAXIMIZEBOX to see if we have a title bar, the WS_CAPTION query is also true for a WS_DLGFRAME only... */
 492     {
 493         if (wantPosOutside)
 494             windowRect->bottom -= GetSystemMetrics( SM_CYCAPTION );
 495         else
 496             windowRect->top    += GetSystemMetrics( SM_CYCAPTION );
 497     }
 498
 499     /* get width of window's borders (frame), correct rect for it.
 500      * Note, borders can be of zero width if style does not specify borders
 501      */
 502     fghGetBorderWidth(windowStyle, &xBorderWidth, &yBorderWidth);
 503     if (wantPosOutside)
 504     {
 505         windowRect->right  -= xBorderWidth * 2;
 506         windowRect->bottom -= yBorderWidth * 2;
 507     }
 508     else
 509     {
 510         windowRect->left   += xBorderWidth;
 511         windowRect->right  -= xBorderWidth;
 512         windowRect->top    += yBorderWidth;
 513         windowRect->bottom -= yBorderWidth;
 514     }
 515 }
 516
 517 /* Gets the rect describing the client area (drawable area) of the
 518  * specified window.
 519  * Returns an empty rect if window pointer or window handle is NULL.
 520  * If wantPosOutside is set to true, the output client Rect
 521  * will follow freeGLUT's window specification convention in which the
 522  * top-left corner is at the outside of the window, while the size
 523  * (rect.right-rect.left,rect.bottom-rect.top) is the size of the drawable
 524  * area.
 525  */
 526 RECT fghGetClientArea( const SFG_Window *window, BOOL wantPosOutside )
 527 {
 528     RECT windowRect = {0,0,0,0};
 529
 530     freeglut_return_val_if_fail((window && window->Window.Handle),windowRect);
 531
 532     /*
 533      * call GetWindowRect()
 534      * (this returns the pixel coordinates of the outside of the window)
 535      */
 536     GetWindowRect( window->Window.Handle, &windowRect );
 537
 538     /* Then correct the results */
 539     fghComputeClientAreaFromWindowRect(window, &windowRect, wantPosOutside);
 540
 541     return windowRect;
 542 }
 543
 544 #if(WINVER >= 0x500)
 545 typedef struct
 546 {
 547       int *x;
 548       int *y;
 549       const char *name;
 550 } m_proc_t;
 551
 552 static BOOL CALLBACK m_proc(HMONITOR mon,
 553                             HDC hdc,
 554                             LPRECT rect,
 555                             LPARAM data)
 556 {
 557       m_proc_t *dp=(m_proc_t *)data;
 558       MONITORINFOEX info;
 559       BOOL res;
 560       info.cbSize=sizeof(info);
 561       res=GetMonitorInfo(mon,(LPMONITORINFO)&info);
 562       if( res )
 563       {
 564           if( strcmp(dp->name,info.szDevice)==0 )
 565           {
 566               *(dp->x)=info.rcMonitor.left;
 567               *(dp->y)=info.rcMonitor.top;
 568               return FALSE;
 569           }
 570       }
 571       return TRUE;
 572 }
 573
 574 /*
 575  * this function returns the origin of the screen identified by
 576  * fgDisplay.pDisplay.DisplayName, and 0 otherwise.
 577  * This is used in fgOpenWindow to open the gamemode window on the screen
 578  * identified by the -display command line argument. The function should
 579  * not be called otherwise.
 580  */
 581
 582 static void get_display_origin(int *xp,int *yp)
 583 {
 584     *xp = 0;
 585     *yp = 0;
 586
 587     if( fgDisplay.pDisplay.DisplayName )
 588     {
 589         m_proc_t st;
 590         st.x=xp;
 591         st.y=yp;
 592         st.name=fgDisplay.pDisplay.DisplayName;
 593         EnumDisplayMonitors(0,0,m_proc,(LPARAM)&st);
 594     }
 595 }
 596 #else
 597 #pragma message( "-display parameter only works if compiled with WINVER >= 0x0500")
 598
 599 static void get_display_origin(int *xp,int *yp)
 600 {
 601     *xp = 0;
 602     *yp = 0;
 603
 604     if( fgDisplay.pDisplay.DisplayName )
 605     {
 606         fgWarning( "for working -display support FreeGLUT must be compiled with WINVER >= 0x0500");
 607     }
 608 }
 609 #endif
 610
 611
 612
 613 /*
 614  * Opens a window. Requires a SFG_Window object created and attached
 615  * to the freeglut structure. OpenGL context is created here.
 616  */
 617 void fgPlatformOpenWindow( SFG_Window* window, const char* title,
 618                            GLboolean positionUse, int x, int y,
 619                            GLboolean sizeUse, int w, int h,
 620                            GLboolean gameMode, GLboolean isSubWindow )
 621 {
 622
 623     WNDCLASS wc;
 624     DWORD flags   = 0;
 625     DWORD exFlags = 0;
 626     ATOM atom;
 627
 628     /* Grab the window class we have registered on glutInit(): */
 629     atom = GetClassInfo( fgDisplay.pDisplay.Instance, _T("FREEGLUT"), &wc );
 630     FREEGLUT_INTERNAL_ERROR_EXIT ( atom, "Window Class Info Not Found",
 631                                    "fgOpenWindow" );
 632
 633     /* Determine window style flags*/
 634     if( gameMode )
 635     {
 636         FREEGLUT_INTERNAL_ERROR_EXIT ( window->Parent == NULL,
 637                                        "Game mode being invoked on a subwindow",
 638                                        "fgOpenWindow" );
 639
 640         /*
 641          * Set the window creation flags appropriately to make the window
 642          * entirely visible:
 643          */
 644         flags = WS_POPUP | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_VISIBLE;
 645     }
 646     else
 647     {
 648         flags = WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
 649
 650         /*
 651          * There's a small difference between creating the top, child and
 652          * menu windows
 653          */
 654         if ( window->IsMenu )
 655         {
 656             flags |= WS_POPUP;
 657             exFlags |= WS_EX_TOOLWINDOW;
 658         }
 659 #if defined(_WIN32_WCE)
 660         /* no decorations for windows CE */
 661 #else
 662         /* if this is not a subwindow (child), set its style based on the requested display mode */
 663         else if( window->Parent == NULL )
 664             if ( fgState.DisplayMode & GLUT_BORDERLESS )
 665             {
 666                 /* no window decorations needed */
 667             }
 668             else if ( fgState.DisplayMode & GLUT_CAPTIONLESS )
 669                 /* only window decoration is a border, no title bar or buttons */
 670                 flags |= WS_DLGFRAME;
 671             else
 672                 /* window decoration are a border, title bar and buttons.
 673                  * NB: we later query whether the window has a title bar or
 674                  * not by testing for the maximize button, as the test for
 675                  * WS_CAPTION can be true without the window having a title
 676                  * bar. This style WS_OVERLAPPEDWINDOW gives you a maximize
 677                  * button. */
 678                 flags |= WS_OVERLAPPEDWINDOW;
 679 #endif
 680         else
 681             /* subwindows always have no decoration, but are marked as a child window to the OS */
 682             flags |= WS_CHILD;
 683     }
 684
 685     /* determine window size and position */
 686     if( gameMode )
 687     {
 688         /* if in gamemode, query the origin of specified by the -display
 689          * command line parameter (if any) and offset the upper-left corner
 690          * of the window so we create the window on that screen.
 691          * The -display argument doesn't do anything if not trying to enter
 692          * gamemode.
 693          */
 694         int xoff=0, yoff=0;
 695         get_display_origin(&xoff,&yoff);
 696         x += xoff;
 697         y += yoff;
 698     }
 699     if( !positionUse )
 700     {
 701         x = CW_USEDEFAULT;
 702         y = CW_USEDEFAULT;
 703     }
 704     if( !sizeUse )
 705     {
 706         if( ! window->IsMenu )
 707         {
 708             w = CW_USEDEFAULT;
 709             h = CW_USEDEFAULT;
 710         }
 711         else /* fail safe - Windows can make a window of size (0, 0) */
 712             w = h = 300; /* default window size */
 713     }
 714     /* store requested client area width and height */
 715     window->State.Width = w;
 716     window->State.Height = h;
 717
 718 #if !defined(_WIN32_WCE)    /* no decorations for windows CE */
 719     if( sizeUse )
 720     {
 721         RECT windowRect;
 722         /*
 723          * Update the window dimensions, taking the window decorations
 724          * into account.  FreeGLUT is to create the window with the
 725          * topleft outside corner at (x,y) and with client area
 726          * dimensions (w,h).
 727          * note: don't need to do this when w=h=CW_USEDEFAULT, so in the
 728          * if( sizeUse ) here is convenient.
 729          */
 730         windowRect.left     = x;
 731         windowRect.top      = y;
 732         windowRect.right    = x+w;
 733         windowRect.bottom   = y+h;
 734
 735         fghComputeWindowRectFromClientArea_UseStyle(flags,&windowRect,TRUE);
 736
 737         w = windowRect.right - windowRect.left;
 738         h = windowRect.bottom- windowRect.top;
 739     }
 740 #endif /* !defined(_WIN32_WCE) */
 741
 742 #if defined(_WIN32_WCE)
 743     {
 744         wchar_t* wstr = fghWstrFromStr(title);
 745
 746         window->Window.Handle = CreateWindow(
 747             _T("FREEGLUT"),
 748             wstr,
 749             WS_VISIBLE | WS_POPUP,
 750             0,0, 240,320,
 751             NULL,
 752             NULL,
 753             fgDisplay.pDisplay.Instance,
 754             (LPVOID) window
 755         );
 756
 757         free(wstr);
 758
 759         SHFullScreen(window->Window.Handle, SHFS_HIDESTARTICON);
 760         SHFullScreen(window->Window.Handle, SHFS_HIDESIPBUTTON);
 761         SHFullScreen(window->Window.Handle, SHFS_HIDETASKBAR);
 762         MoveWindow(window->Window.Handle, 0, 0, 240, 320, TRUE);
 763         ShowWindow(window->Window.Handle, SW_SHOW);
 764         UpdateWindow(window->Window.Handle);
 765     }
 766 #else
 767     window->Window.Handle = CreateWindowEx(
 768         exFlags,
 769         _T("FREEGLUT"),
 770         title,
 771         flags,
 772         x, y, w, h,
 773         (HWND) window->Parent == NULL ? NULL : window->Parent->Window.Handle,
 774         (HMENU) NULL,
 775         fgDisplay.pDisplay.Instance,
 776         (LPVOID) window
 777     );
 778 #endif /* defined(_WIN32_WCE) */
 779
 780     if( !( window->Window.Handle ) )
 781         fgError( "Failed to create a window (%s)!", title );
 782
 783 #if !defined(_WIN32_WCE)
 784     /* Need to set requested style again, apparently Windows doesn't listen when requesting windows without title bar or borders */
 785     SetWindowLong(window->Window.Handle, GWL_STYLE, flags);
 786     SetWindowPos(window->Window.Handle, HWND_TOP, 0,0,0,0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);
 787 #endif /* defined(_WIN32_WCE) */
 788
 789     /* Make a menu window always on top - fix Feature Request 947118 */
 790     if( window->IsMenu || gameMode )
 791         SetWindowPos(
 792                         window->Window.Handle,
 793                         HWND_TOPMOST,
 794                         0, 0, 0, 0,
 795                         SWP_NOMOVE | SWP_NOSIZE
 796                     );
 797
 798     /* Enable multitouch: additional flag TWF_FINETOUCH, TWF_WANTPALM */
 799     #ifdef WM_TOUCH
 800         if (fghRegisterTouchWindow == (pRegisterTouchWindow)0xDEADBEEF)
 801                         fghRegisterTouchWindow = (pRegisterTouchWindow)GetProcAddress(GetModuleHandle("user32"),"RegisterTouchWindow");
 802                 if (fghRegisterTouchWindow)
 803              fghRegisterTouchWindow( window->Window.Handle, TWF_FINETOUCH | TWF_WANTPALM );
 804     #endif
 805
 806 #if defined(_WIN32_WCE)
 807     ShowWindow( window->Window.Handle, SW_SHOW );
 808 #else
 809     ShowWindow( window->Window.Handle,
 810                 fgState.ForceIconic ? SW_SHOWMINIMIZED : SW_SHOW );
 811 #endif /* defined(_WIN32_WCE) */
 812
 813     UpdateWindow( window->Window.Handle );
 814     ShowCursor( TRUE );  /* XXX Old comments say "hide cursor"! */
 815 }
 816
 817
 818 /*
 819  * Closes a window, destroying the frame and OpenGL context
 820  */
 821 void fgPlatformCloseWindow( SFG_Window* window )
 822 {
 823     /* Make sure we don't close a window with current context active */
 824     if( fgStructure.CurrentWindow == window )
 825         wglMakeCurrent( NULL, NULL );
 826
 827     /*
 828      * Step through the list of windows.  If the rendering context
 829      * is not being used by another window, then we delete it.
 830      */
 831     {
 832         int used = FALSE ;
 833         SFG_Window *iter ;
 834
 835         for( iter = (SFG_Window *)fgStructure.Windows.First;
 836              iter;
 837              iter = (SFG_Window *)iter->Node.Next )
 838         {
 839             if( ( iter->Window.Context == window->Window.Context ) &&
 840                 ( iter != window ) )
 841                 used = TRUE;
 842         }
 843
 844         if( ! used )
 845             wglDeleteContext( window->Window.Context );
 846     }
 847
 848     DestroyWindow( window->Window.Handle );
 849 }
 850
 851
 852
 853 /*
 854  * This function makes the current window visible
 855  */
 856 void fgPlatformGlutShowWindow( void )
 857 {
 858     ShowWindow( fgStructure.CurrentWindow->Window.Handle, SW_SHOW );
 859 }
 860
 861 /*
 862  * This function hides the current window
 863  */
 864 void fgPlatformGlutHideWindow( void )
 865 {
 866     ShowWindow( fgStructure.CurrentWindow->Window.Handle, SW_HIDE );
 867 }
 868
 869 /*
 870  * Iconify the current window (top-level windows only)
 871  */
 872 void fgPlatformGlutIconifyWindow( void )
 873 {
 874     ShowWindow( fgStructure.CurrentWindow->Window.Handle, SW_MINIMIZE );
 875 }
 876
 877 /*
 878  * Set the current window's title
 879  */
 880 void fgPlatformGlutSetWindowTitle( const char* title )
 881 {
 882 #ifdef _WIN32_WCE
 883     {
 884         wchar_t* wstr = fghWstrFromStr(title);
 885         SetWindowText( fgStructure.CurrentWindow->Window.Handle, wstr );
 886         free(wstr);
 887     }
 888 #else
 889     SetWindowText( fgStructure.CurrentWindow->Window.Handle, title );
 890 #endif
 891 }
 892
 893 /*
 894  * Set the current window's iconified title
 895  * There really isn't a way to set the icon name separate from the
 896  * windows name in Win32, so, just set the windows name.
 897  */
 898 void fgPlatformGlutSetIconTitle( const char* title )
 899 {
 900 #ifdef _WIN32_WCE
 901     {
 902         wchar_t* wstr = fghWstrFromStr(title);
 903         SetWindowText( fgStructure.CurrentWindow->Window.Handle, wstr );
 904         free(wstr);
 905     }
 906 #else
 907     SetWindowText( fgStructure.CurrentWindow->Window.Handle, title );
 908 #endif
 909 }
 910
 911 /*
 912  * Change the current window's position
 913  */
 914 void fgPlatformGlutPositionWindow( int x, int y )
 915 {
 916     RECT winRect;
 917
 918     /* "GetWindowRect" returns the pixel coordinates of the outside of the window */
 919     GetWindowRect( fgStructure.CurrentWindow->Window.Handle, &winRect );
 920     MoveWindow(
 921         fgStructure.CurrentWindow->Window.Handle,
 922         x,
 923         y,
 924         winRect.right - winRect.left,
 925         winRect.bottom - winRect.top,
 926         TRUE
 927     );
 928 }
 929
 930 /*
 931  * Lowers the current window (by Z order change)
 932  */
 933 void fgPlatformGlutPushWindow( void )
 934 {
 935     SetWindowPos(
 936         fgStructure.CurrentWindow->Window.Handle,
 937         HWND_BOTTOM,
 938         0, 0, 0, 0,
 939         SWP_NOSIZE | SWP_NOMOVE
 940     );
 941 }
 942
 943 /*
 944  * Raises the current window (by Z order change)
 945  */
 946 void fgPlatformGlutPopWindow( void )
 947 {
 948     SetWindowPos(
 949         fgStructure.CurrentWindow->Window.Handle,
 950         HWND_TOP,
 951         0, 0, 0, 0,
 952         SWP_NOSIZE | SWP_NOMOVE
 953     );
 954 }
 955
 956 /*
 957  * Resize the current window so that it fits the whole screen
 958  */
 959 void fgPlatformGlutFullScreen( SFG_Window *win )
 960 {
 961 #if !defined(_WIN32_WCE) /* FIXME: what about WinCE */
 962
 963     if (glutGet(GLUT_FULL_SCREEN))
 964     {
 965         /*  Leave full screen state before entering fullscreen again (resizing?) */
 966         glutLeaveFullScreen();
 967     }
 968
 969     {
 970 #if(WINVER >= 0x0500) /* Windows 2000 or later */
 971         DWORD s;
 972         RECT rect;
 973         HMONITOR hMonitor;
 974         MONITORINFO mi;
 975
 976         /* For fullscreen mode, first remove all window decoration
 977          * and set style to popup so it will overlap the taskbar
 978          * then force to maximize on the screen on which it has the most
 979          * overlap.
 980          */
 981
 982
 983         /* store current window rect */
 984         GetWindowRect( win->Window.Handle, &win->State.pWState.OldRect );
 985
 986         /* store current window style */
 987         win->State.pWState.OldStyle = s = GetWindowLong(win->Window.Handle, GWL_STYLE);
 988
 989         /* remove decorations from style and add popup style*/
 990         s &= ~WS_OVERLAPPEDWINDOW;
 991         s |= WS_POPUP;
 992         SetWindowLong(win->Window.Handle, GWL_STYLE, s);
 993         SetWindowPos(win->Window.Handle, HWND_TOP, 0,0,0,0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);
 994
 995         /* For fullscreen mode, find the monitor that is covered the most
 996          * by the window and get its rect as the resize target.
 997              */
 998         hMonitor= MonitorFromRect(&win->State.pWState.OldRect, MONITOR_DEFAULTTONEAREST);
 999         mi.cbSize = sizeof(mi);
1000         GetMonitorInfo(hMonitor, &mi);
1001         rect = mi.rcMonitor;
1002 #else   /* if (WINVER >= 0x0500) */
1003         RECT rect;
1004
1005         /* For fullscreen mode, force the top-left corner to 0,0
1006          * and adjust the window rectangle so that the client area
1007          * covers the whole screen.
1008          */
1009
1010         rect.left   = 0;
1011         rect.top    = 0;
1012         rect.right  = fgDisplay.ScreenWidth;
1013         rect.bottom = fgDisplay.ScreenHeight;
1014
1015         AdjustWindowRect ( &rect, WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS |
1016                                   WS_CLIPCHILDREN, FALSE );
1017 #endif  /* (WINVER >= 0x0500) */
1018
1019         /*
1020          * then resize window
1021          * SWP_NOACTIVATE     Do not activate the window
1022          * SWP_NOOWNERZORDER  Do not change position in z-order
1023          * SWP_NOSENDCHANGING Suppress WM_WINDOWPOSCHANGING message
1024          * SWP_NOZORDER       Retains the current Z order (ignore 2nd param)
1025          */
1026         SetWindowPos( fgStructure.CurrentWindow->Window.Handle,
1027                       HWND_TOP,
1028                       rect.left,
1029                       rect.top,
1030                       rect.right  - rect.left,
1031                       rect.bottom - rect.top,
1032                       SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOSENDCHANGING |
1033                       SWP_NOZORDER
1034                     );
1035
1036         win->State.IsFullscreen = GL_TRUE;
1037     }
1038 #endif
1039 }
1040
1041 /*
1042  * If we are fullscreen, resize the current window back to its original size
1043  */
1044 void fgPlatformGlutLeaveFullScreen( SFG_Window *win )
1045 {
1046 #if !defined(_WIN32_WCE) /* FIXME: what about WinCE */
1047     if (!glutGet(GLUT_FULL_SCREEN))
1048     {
1049         /* nothing to do */
1050         return;
1051     }
1052
1053     /* restore style of window before making it fullscreen */
1054     SetWindowLong(win->Window.Handle, GWL_STYLE, win->State.pWState.OldStyle);
1055     SetWindowPos(win->Window.Handle, HWND_TOP, 0,0,0,0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);
1056
1057     /* Then resize */
1058     SetWindowPos(win->Window.Handle,
1059         HWND_TOP,
1060         win->State.pWState.OldRect.left,
1061         win->State.pWState.OldRect.top,
1062         win->State.pWState.OldRect.right  - win->State.pWState.OldRect.left,
1063         win->State.pWState.OldRect.bottom - win->State.pWState.OldRect.top,
1064         SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOSENDCHANGING |
1065         SWP_NOZORDER
1066         );
1067
1068     win->State.IsFullscreen = GL_FALSE;
1069 #endif
1070 }
1071
1072 /*
1073  * Toggle the window's full screen state.
1074  */
1075 void fgPlatformGlutFullScreenToggle( SFG_Window *win )
1076 {
1077     if (!win->State.IsFullscreen)
1078         glutFullScreen();
1079     else
1080         glutLeaveFullScreen();
1081 }
1082
1083
1084 /* -- PLATFORM-SPECIFIC INTERFACE FUNCTION -------------------------------------------------- */
1085
1086 int FGAPIENTRY __glutCreateWindowWithExit( const char *title, void (__cdecl *exit_function)(int) )
1087 {
1088   __glutExitFunc = exit_function;
1089   return glutCreateWindow( title );
1090 }
1091