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