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