When receiving WM_SETFOCUS, check if its child window that should
[freeglut] / 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     {
398         if (posIsOutside)
399             clientRect->bottom += GetSystemMetrics( SM_CYCAPTION );
400         else
401             clientRect->top -= GetSystemMetrics( SM_CYCAPTION );
402     }
403
404     /* get width of window's borders (frame), correct rect for it.
405      * Note, borders can be of zero width if style does not specify borders
406      */
407     fghGetBorderWidth(windowStyle, &xBorderWidth, &yBorderWidth);
408     if (posIsOutside)
409     {
410         clientRect->right  += xBorderWidth * 2;
411         clientRect->bottom += yBorderWidth * 2;
412     }
413     else
414     {
415         clientRect->left   -= xBorderWidth;
416         clientRect->right  += xBorderWidth;
417         clientRect->top    -= yBorderWidth;
418         clientRect->bottom += yBorderWidth;
419     }
420 }
421
422 /* Computes position of corners of window Rect (outer position including
423  * decorations) based on the provided client rect and based on the style
424  * of the window in question. If the window pointer or the window handle
425  * is NULL, a fully decorated window (caption and border) is assumed.
426  * Furthermore, if posIsOutside is set to true, the input client Rect is
427  * taken to follow freeGLUT's window specification convention in which the
428  * top-left corner is at the outside of the window, while the size
429  * (rect.right-rect.left,rect.bottom-rect.top) is the size of the drawable
430  * area.
431 */
432 void fghComputeWindowRectFromClientArea_QueryWindow( const SFG_Window *window, RECT *clientRect, BOOL posIsOutside )
433 {
434     DWORD windowStyle = 0;
435
436     if (window && window->Window.Handle)
437         windowStyle = GetWindowLong(window->Window.Handle, GWL_STYLE);
438     else
439         windowStyle = WS_OVERLAPPEDWINDOW;
440
441     fghComputeWindowRectFromClientArea_UseStyle(windowStyle, clientRect, posIsOutside);
442 }
443
444 /* Computes position of corners of client area (drawable area) of a window
445  * based on the provided window Rect (outer position including decorations)
446  * and based on the style of the window in question. If the window pointer
447  * or the window handle is NULL, a fully decorated window (caption and
448  * border) is assumed.
449  * Furthermore, if wantPosOutside is set to true, the output client Rect
450  * will follow freeGLUT's window specification convention in which the
451  * top-left corner is at the outside of the window, the size
452  * (rect.right-rect.left,rect.bottom-rect.top) is the size of the drawable
453  * area.
454  */
455 void fghComputeClientAreaFromWindowRect( const SFG_Window *window, RECT *windowRect, BOOL wantPosOutside )
456 {
457     DWORD windowStyle = 0;
458     int xBorderWidth = 0, yBorderWidth = 0;
459
460     if (window && window->Window.Handle)
461         windowStyle = GetWindowLong(window->Window.Handle, GWL_STYLE);
462     else
463         windowStyle = WS_OVERLAPPEDWINDOW;
464
465     /* If window has title bar, correct rect for it */
466     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... */
467     {
468         if (wantPosOutside)
469             windowRect->bottom -= GetSystemMetrics( SM_CYCAPTION );
470         else
471             windowRect->top    += GetSystemMetrics( SM_CYCAPTION );
472     }
473
474     /* get width of window's borders (frame), correct rect for it.
475      * Note, borders can be of zero width if style does not specify borders
476      */
477     fghGetBorderWidth(windowStyle, &xBorderWidth, &yBorderWidth);
478     if (wantPosOutside)
479     {
480         windowRect->right  -= xBorderWidth * 2;
481         windowRect->bottom -= yBorderWidth * 2;
482     }
483     else
484     {
485         windowRect->left   += xBorderWidth;
486         windowRect->right  -= xBorderWidth;
487         windowRect->top    += yBorderWidth;
488         windowRect->bottom -= yBorderWidth;
489     }
490 }
491
492 /* Gets the rect describing the client area (drawable area) of the
493  * specified window.
494  * Returns an empty rect if window pointer or window handle is NULL.
495  * If wantPosOutside is set to true, the output client Rect
496  * will follow freeGLUT's window specification convention in which the
497  * top-left corner is at the outside of the window, while the size
498  * (rect.right-rect.left,rect.bottom-rect.top) is the size of the drawable
499  * area.
500  */
501 RECT fghGetClientArea( const SFG_Window *window, BOOL wantPosOutside )
502 {
503     RECT windowRect = {0,0,0,0};
504
505     freeglut_return_val_if_fail((window && window->Window.Handle),windowRect);
506     
507     /*
508      * call GetWindowRect()
509      * (this returns the pixel coordinates of the outside of the window)
510      */
511     GetWindowRect( window->Window.Handle, &windowRect );
512
513     /* Then correct the results */
514     fghComputeClientAreaFromWindowRect(window, &windowRect, wantPosOutside);
515
516     return windowRect;
517 }
518
519 /* Returns the width of the window borders based on the window's style.
520  */
521 void fghGetBorderWidth(const DWORD windowStyle, int* xBorderWidth, int* yBorderWidth)
522 {
523     if (windowStyle & WS_THICKFRAME)
524     {
525         *xBorderWidth = GetSystemMetrics(SM_CXSIZEFRAME);
526         *yBorderWidth = GetSystemMetrics(SM_CYSIZEFRAME);
527     }
528     else if (windowStyle & WS_DLGFRAME)
529     {
530         *xBorderWidth = GetSystemMetrics(SM_CXFIXEDFRAME);
531         *yBorderWidth = GetSystemMetrics(SM_CYFIXEDFRAME);
532     }
533     else
534     {
535         *xBorderWidth = 0;
536         *yBorderWidth = 0;
537     }
538 }
539
540 #if(WINVER >= 0x500)
541 typedef struct
542 {
543       int *x;
544       int *y;
545       const char *name;
546 } m_proc_t;
547
548 static BOOL CALLBACK m_proc(HMONITOR mon,
549                             HDC hdc,
550                             LPRECT rect,
551                             LPARAM data)
552 {
553       m_proc_t *dp=(m_proc_t *)data;
554       MONITORINFOEX info;
555       BOOL res;
556       info.cbSize=sizeof(info);
557       res=GetMonitorInfo(mon,(LPMONITORINFO)&info);
558       if( res )
559       {
560           if( strcmp(dp->name,info.szDevice)==0 )
561           {
562               *(dp->x)=info.rcMonitor.left;
563               *(dp->y)=info.rcMonitor.top;
564               return FALSE;
565           }
566       }
567       return TRUE;
568 }
569
570 /* 
571  * this function returns the origin of the screen identified by
572  * fgDisplay.pDisplay.DisplayName, and 0 otherwise.
573  * This is used in fgOpenWindow to open the gamemode window on the screen
574  * identified by the -display command line argument. The function should
575  * not be called otherwise.
576  */
577
578 static void get_display_origin(int *xp,int *yp)
579 {
580     *xp = 0;
581     *yp = 0;
582
583     if( fgDisplay.pDisplay.DisplayName )
584     {
585         m_proc_t st;
586         st.x=xp;
587         st.y=yp;
588         st.name=fgDisplay.pDisplay.DisplayName;
589         EnumDisplayMonitors(0,0,m_proc,(LPARAM)&st);
590     }
591 }
592 #else
593 #pragma message( "-display parameter only works if compiled with WINVER >= 0x0500")
594
595 static void get_display_origin(int *xp,int *yp)
596 {
597     *xp = 0;
598     *yp = 0;
599
600     if( fgDisplay.pDisplay.DisplayName )
601     {
602         fgWarning( "for working -display support FreeGLUT must be compiled with WINVER >= 0x0500");
603     }
604 }
605 #endif
606
607
608
609 /*
610  * Opens a window. Requires a SFG_Window object created and attached
611  * to the freeglut structure. OpenGL context is created here.
612  */
613 void fgPlatformOpenWindow( SFG_Window* window, const char* title,
614                            GLboolean positionUse, int x, int y,
615                            GLboolean sizeUse, int w, int h,
616                            GLboolean gameMode, GLboolean isSubWindow )
617 {
618
619     WNDCLASS wc;
620     DWORD flags   = 0;
621     DWORD exFlags = 0;
622     ATOM atom;
623
624     /* Grab the window class we have registered on glutInit(): */
625     atom = GetClassInfo( fgDisplay.pDisplay.Instance, _T("FREEGLUT"), &wc );
626     FREEGLUT_INTERNAL_ERROR_EXIT ( atom, "Window Class Info Not Found",
627                                    "fgOpenWindow" );
628
629     /* Determine window style flags*/
630     if( gameMode )
631     {
632         FREEGLUT_INTERNAL_ERROR_EXIT ( window->Parent == NULL,
633                                        "Game mode being invoked on a subwindow",
634                                        "fgOpenWindow" );
635
636         /*
637          * Set the window creation flags appropriately to make the window
638          * entirely visible:
639          */
640         flags = WS_POPUP | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_VISIBLE;
641     }
642     else
643     {
644         flags = WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
645
646         /*
647          * There's a small difference between creating the top, child and
648          * menu windows
649          */
650         if ( window->IsMenu )
651         {
652             flags |= WS_POPUP;
653             exFlags |= WS_EX_TOOLWINDOW;
654         }
655 #if defined(_WIN32_WCE)
656         /* no decorations for windows CE */
657 #else
658         /* if this is not a subwindow (child), set its style based on the requested display mode */
659         else if( window->Parent == NULL )
660             if ( fgState.DisplayMode & GLUT_BORDERLESS )
661             {
662                 /* no window decorations needed */
663             }
664             else if ( fgState.DisplayMode & GLUT_CAPTIONLESS )
665                 /* only window decoration is a border, no title bar or buttons */
666                 flags |= WS_DLGFRAME;
667             else
668                 /* window decoration are a border, title bar and buttons.
669                  * NB: we later query whether the window has a title bar or
670                  * not by testing for the maximize button, as the test for
671                  * WS_CAPTION can be true without the window having a title
672                  * bar. This style WS_OVERLAPPEDWINDOW gives you a maximize
673                  * button. */
674                 flags |= WS_OVERLAPPEDWINDOW;
675 #endif
676         else
677             /* subwindows always have no decoration, but are marked as a child window to the OS */
678             flags |= WS_CHILD;
679     }
680
681     /* determine window size and position */
682     if( gameMode )
683     {
684         /* if in gamemode, query the origin of specified by the -display
685          * command line parameter (if any) and offset the upper-left corner
686          * of the window so we create the window on that screen.
687          * The -display argument doesn't do anything if not trying to enter
688          * gamemode.
689          */
690         int xoff=0, yoff=0;
691         get_display_origin(&xoff,&yoff);
692         x += xoff;
693         y += yoff;
694     }
695     if( !positionUse )
696     {
697         x = CW_USEDEFAULT;
698         y = CW_USEDEFAULT;
699     }
700     if( !sizeUse )
701     {
702         if( ! window->IsMenu )
703         {
704             w = CW_USEDEFAULT;
705             h = CW_USEDEFAULT;
706         }
707         else /* fail safe - Windows can make a window of size (0, 0) */
708             w = h = 300; /* default window size */
709     }
710     /* store requested client area width and height */
711     window->State.Width = w;
712     window->State.Height = h;
713
714 #if !defined(_WIN32_WCE)    /* no decorations for windows CE */
715     if( sizeUse )
716     {
717         RECT windowRect;
718         /*
719          * Update the window dimensions, taking the window decorations
720          * into account.  FreeGLUT is to create the window with the
721          * topleft outside corner at (x,y) and with client area
722          * dimensions (w,h).
723          * note: don't need to do this when w=h=CW_USEDEFAULT, so in the
724          * if( sizeUse ) here is convenient.
725          */
726         windowRect.left     = x;
727         windowRect.top      = y;
728         windowRect.right    = x+w;
729         windowRect.bottom   = y+h;
730
731         fghComputeWindowRectFromClientArea_UseStyle(flags,&windowRect,TRUE);
732
733         w = windowRect.right - windowRect.left;
734         h = windowRect.bottom- windowRect.top;
735     }
736 #endif /* !defined(_WIN32_WCE) */
737
738 #if defined(_WIN32_WCE)
739     {
740         wchar_t* wstr = fghWstrFromStr(title);
741
742         window->Window.Handle = CreateWindow(
743             _T("FREEGLUT"),
744             wstr,
745             WS_VISIBLE | WS_POPUP,
746             0,0, 240,320,
747             NULL,
748             NULL,
749             fgDisplay.pDisplay.Instance,
750             (LPVOID) window
751         );
752
753         free(wstr);
754
755         SHFullScreen(window->Window.Handle, SHFS_HIDESTARTICON);
756         SHFullScreen(window->Window.Handle, SHFS_HIDESIPBUTTON);
757         SHFullScreen(window->Window.Handle, SHFS_HIDETASKBAR);
758         MoveWindow(window->Window.Handle, 0, 0, 240, 320, TRUE);
759         ShowWindow(window->Window.Handle, SW_SHOW);
760         UpdateWindow(window->Window.Handle);
761     }
762 #else
763     window->Window.Handle = CreateWindowEx(
764         exFlags,
765         _T("FREEGLUT"),
766         title,
767         flags,
768         x, y, w, h,
769         (HWND) window->Parent == NULL ? NULL : window->Parent->Window.Handle,
770         (HMENU) NULL,
771         fgDisplay.pDisplay.Instance,
772         (LPVOID) window
773     );
774 #endif /* defined(_WIN32_WCE) */
775
776     if( !( window->Window.Handle ) )
777         fgError( "Failed to create a window (%s)!", title );
778
779 #if !defined(_WIN32_WCE)
780     /* Need to set requested style again, apparently Windows doesn't listen when requesting windows without title bar or borders */
781     SetWindowLong(window->Window.Handle, GWL_STYLE, flags);
782     SetWindowPos(window->Window.Handle, HWND_TOP, 0,0,0,0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);
783 #endif /* defined(_WIN32_WCE) */
784
785     /* Make a menu window always on top - fix Feature Request 947118 */
786     if( window->IsMenu || gameMode )
787         SetWindowPos(
788                         window->Window.Handle,
789                         HWND_TOPMOST,
790                         0, 0, 0, 0,
791                         SWP_NOMOVE | SWP_NOSIZE
792                     );
793
794     /* Enable multitouch: additional flag TWF_FINETOUCH, TWF_WANTPALM */
795     #ifdef WM_TOUCH
796         if (fghRegisterTouchWindow == (pRegisterTouchWindow)0xDEADBEEF) 
797                         fghRegisterTouchWindow = (pRegisterTouchWindow)GetProcAddress(GetModuleHandle("user32"),"RegisterTouchWindow");
798                 if (fghRegisterTouchWindow)
799              fghRegisterTouchWindow( window->Window.Handle, TWF_FINETOUCH | TWF_WANTPALM );
800     #endif
801
802 #if defined(_WIN32_WCE)
803     ShowWindow( window->Window.Handle, SW_SHOW );
804 #else
805     ShowWindow( window->Window.Handle,
806                 fgState.ForceIconic ? SW_SHOWMINIMIZED : SW_SHOW );
807 #endif /* defined(_WIN32_WCE) */
808
809     UpdateWindow( window->Window.Handle );
810     ShowCursor( TRUE );  /* XXX Old comments say "hide cursor"! */
811 }
812
813
814 /*
815  * Closes a window, destroying the frame and OpenGL context
816  */
817 void fgPlatformCloseWindow( SFG_Window* window )
818 {
819     /* Make sure we don't close a window with current context active */
820     if( fgStructure.CurrentWindow == window )
821         wglMakeCurrent( NULL, NULL );
822
823     /*
824      * Step through the list of windows.  If the rendering context
825      * is not being used by another window, then we delete it.
826      */
827     {
828         int used = FALSE ;
829         SFG_Window *iter ;
830
831         for( iter = (SFG_Window *)fgStructure.Windows.First;
832              iter;
833              iter = (SFG_Window *)iter->Node.Next )
834         {
835             if( ( iter->Window.Context == window->Window.Context ) &&
836                 ( iter != window ) )
837                 used = TRUE;
838         }
839
840         if( ! used )
841             wglDeleteContext( window->Window.Context );
842     }
843
844     DestroyWindow( window->Window.Handle );
845 }
846
847
848
849 /*
850  * This function makes the current window visible
851  */
852 void fgPlatformGlutShowWindow( void )
853 {
854     ShowWindow( fgStructure.CurrentWindow->Window.Handle, SW_SHOW );
855 }
856
857 /*
858  * This function hides the current window
859  */
860 void fgPlatformGlutHideWindow( void )
861 {
862     ShowWindow( fgStructure.CurrentWindow->Window.Handle, SW_HIDE );
863 }
864
865 /*
866  * Iconify the current window (top-level windows only)
867  */
868 void fgPlatformGlutIconifyWindow( void )
869 {
870     ShowWindow( fgStructure.CurrentWindow->Window.Handle, SW_MINIMIZE );
871 }
872
873 /*
874  * Set the current window's title
875  */
876 void fgPlatformGlutSetWindowTitle( const char* title )
877 {
878 #ifdef _WIN32_WCE
879     {
880         wchar_t* wstr = fghWstrFromStr(title);
881         SetWindowText( fgStructure.CurrentWindow->Window.Handle, wstr );
882         free(wstr);
883     }
884 #else
885     SetWindowText( fgStructure.CurrentWindow->Window.Handle, title );
886 #endif
887 }
888
889 /*
890  * Set the current window's iconified title
891  */
892 void fgPlatformGlutSetIconTitle( const char* title )
893 {
894 #ifdef _WIN32_WCE
895     {
896         wchar_t* wstr = fghWstrFromStr(title);
897         SetWindowText( fgStructure.CurrentWindow->Window.Handle, wstr );
898         free(wstr);
899     }
900 #else
901     SetWindowText( fgStructure.CurrentWindow->Window.Handle, title );
902 #endif
903 }
904
905 /*
906  * Change the current window's position
907  */
908 void fgPlatformGlutPositionWindow( int x, int y )
909 {
910     RECT winRect;
911
912     /* "GetWindowRect" returns the pixel coordinates of the outside of the window */
913     GetWindowRect( fgStructure.CurrentWindow->Window.Handle, &winRect );
914     MoveWindow(
915         fgStructure.CurrentWindow->Window.Handle,
916         x,
917         y,
918         winRect.right - winRect.left,
919         winRect.bottom - winRect.top,
920         TRUE
921     );
922 }
923
924 /*
925  * Lowers the current window (by Z order change)
926  */
927 void fgPlatformGlutPushWindow( void )
928 {
929     SetWindowPos(
930         fgStructure.CurrentWindow->Window.Handle,
931         HWND_BOTTOM,
932         0, 0, 0, 0,
933         SWP_NOSIZE | SWP_NOMOVE
934     );
935 }
936
937 /*
938  * Raises the current window (by Z order change)
939  */
940 void fgPlatformGlutPopWindow( void )
941 {
942     SetWindowPos(
943         fgStructure.CurrentWindow->Window.Handle,
944         HWND_TOP,
945         0, 0, 0, 0,
946         SWP_NOSIZE | SWP_NOMOVE
947     );
948 }
949
950 /*
951  * Resize the current window so that it fits the whole screen
952  */
953 void fgPlatformGlutFullScreen( SFG_Window *win )
954 {
955 #if !defined(_WIN32_WCE) /* FIXME: what about WinCE */
956
957     if (glutGet(GLUT_FULL_SCREEN))
958     {
959         /*  Leave full screen state before entering fullscreen again (resizing?) */
960         glutLeaveFullScreen();
961     }
962
963     {
964 #if(WINVER >= 0x0500) /* Windows 2000 or later */
965         DWORD s;
966         RECT rect;
967         HMONITOR hMonitor;
968         MONITORINFO mi;
969
970         /* For fullscreen mode, first remove all window decoration
971          * and set style to popup so it will overlap the taskbar
972          * then force to maximize on the screen on which it has the most
973          * overlap.
974          */
975
976         
977         /* store current window rect */
978         GetWindowRect( win->Window.Handle, &win->State.pWState.OldRect );
979
980         /* store current window style */
981         win->State.pWState.OldStyle = s = GetWindowLong(win->Window.Handle, GWL_STYLE);
982
983         /* remove decorations from style and add popup style*/
984         s &= ~WS_OVERLAPPEDWINDOW;
985         s |= WS_POPUP;
986         SetWindowLong(win->Window.Handle, GWL_STYLE, s);
987         SetWindowPos(win->Window.Handle, HWND_TOP, 0,0,0,0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);
988
989         /* For fullscreen mode, find the monitor that is covered the most
990          * by the window and get its rect as the resize target.
991              */
992         hMonitor= MonitorFromRect(&win->State.pWState.OldRect, MONITOR_DEFAULTTONEAREST);
993         mi.cbSize = sizeof(mi);
994         GetMonitorInfo(hMonitor, &mi);
995         rect = mi.rcMonitor;
996 #else   /* if (WINVER >= 0x0500) */
997         RECT rect;
998
999         /* For fullscreen mode, force the top-left corner to 0,0
1000          * and adjust the window rectangle so that the client area
1001          * covers the whole screen.
1002          */
1003
1004         rect.left   = 0;
1005         rect.top    = 0;
1006         rect.right  = fgDisplay.ScreenWidth;
1007         rect.bottom = fgDisplay.ScreenHeight;
1008
1009         AdjustWindowRect ( &rect, WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS |
1010                                   WS_CLIPCHILDREN, FALSE );
1011 #endif  /* (WINVER >= 0x0500) */
1012
1013         /*
1014          * then resize window
1015          * SWP_NOACTIVATE     Do not activate the window
1016          * SWP_NOOWNERZORDER  Do not change position in z-order
1017          * SWP_NOSENDCHANGING Suppress WM_WINDOWPOSCHANGING message
1018          * SWP_NOZORDER       Retains the current Z order (ignore 2nd param)
1019          */
1020         SetWindowPos( fgStructure.CurrentWindow->Window.Handle,
1021                       HWND_TOP,
1022                       rect.left,
1023                       rect.top,
1024                       rect.right  - rect.left,
1025                       rect.bottom - rect.top,
1026                       SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOSENDCHANGING |
1027                       SWP_NOZORDER
1028                     );
1029
1030         win->State.IsFullscreen = GL_TRUE;
1031     }
1032 #endif
1033 }
1034
1035 /*
1036  * If we are fullscreen, resize the current window back to its original size
1037  */
1038 void fgPlatformGlutLeaveFullScreen( SFG_Window *win )
1039 {
1040 #if !defined(_WIN32_WCE) /* FIXME: what about WinCE */
1041     if (!glutGet(GLUT_FULL_SCREEN))
1042     {
1043         /* nothing to do */
1044         return;
1045     }
1046
1047     /* restore style of window before making it fullscreen */
1048     SetWindowLong(win->Window.Handle, GWL_STYLE, win->State.pWState.OldStyle);
1049     SetWindowPos(win->Window.Handle, HWND_TOP, 0,0,0,0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);
1050
1051     /* Then resize */
1052     SetWindowPos(win->Window.Handle,
1053         HWND_TOP,
1054         win->State.pWState.OldRect.left,
1055         win->State.pWState.OldRect.top,
1056         win->State.pWState.OldRect.right  - win->State.pWState.OldRect.left,
1057         win->State.pWState.OldRect.bottom - win->State.pWState.OldRect.top,
1058         SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOSENDCHANGING |
1059         SWP_NOZORDER
1060         );
1061
1062     win->State.IsFullscreen = GL_FALSE;
1063 #endif
1064 }
1065
1066 /*
1067  * Toggle the window's full screen state.
1068  */
1069 void fgPlatformGlutFullScreenToggle( SFG_Window *win )
1070 {
1071     if (!win->State.IsFullscreen)
1072         glutFullScreen();
1073     else
1074         glutLeaveFullScreen();
1075 }
1076
1077
1078 /* -- PLATFORM-SPECIFIC INTERFACE FUNCTION -------------------------------------------------- */
1079
1080 int FGAPIENTRY __glutCreateWindowWithExit( const char *title, void (__cdecl *exit_function)(int) )
1081 {
1082   __glutExitFunc = exit_function;
1083   return glutCreateWindow( title );
1084 }
1085