2 * freeglut_window_mswin.c
\r
4 * The Windows-specific mouse cursor related stuff.
\r
6 * Copyright (c) 2012 Stephen J. Baker. All Rights Reserved.
\r
7 * Written by John F. Fay, <fayjf@sourceforge.net>
\r
8 * Creation date: Sun Jan 22, 2012
\r
10 * Permission is hereby granted, free of charge, to any person obtaining a
\r
11 * copy of this software and associated documentation files (the "Software"),
\r
12 * to deal in the Software without restriction, including without limitation
\r
13 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
\r
14 * and/or sell copies of the Software, and to permit persons to whom the
\r
15 * Software is furnished to do so, subject to the following conditions:
\r
17 * The above copyright notice and this permission notice shall be included
\r
18 * in all copies or substantial portions of the Software.
\r
20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
\r
21 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
\r
22 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
\r
23 * PAWEL W. OLSZTA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
\r
24 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
\r
25 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
\r
28 #define FREEGLUT_BUILDING_LIB
\r
29 #include <GL/freeglut.h>
\r
30 #include "../Common/freeglut_internal.h"
\r
33 /* The following include file is available from SGI but is not standard:
\r
34 * #include <GL/wglext.h>
\r
35 * So we copy the necessary parts out of it.
\r
36 * XXX: should local definitions for extensions be put in a separate include file?
\r
38 typedef const char * (WINAPI * PFNWGLGETEXTENSIONSSTRINGARBPROC) (HDC hdc);
\r
40 typedef BOOL (WINAPI * PFNWGLCHOOSEPIXELFORMATARBPROC) (HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats);
\r
42 #define WGL_DRAW_TO_WINDOW_ARB 0x2001
\r
43 #define WGL_ACCELERATION_ARB 0x2003
\r
44 #define WGL_SUPPORT_OPENGL_ARB 0x2010
\r
45 #define WGL_DOUBLE_BUFFER_ARB 0x2011
\r
46 #define WGL_COLOR_BITS_ARB 0x2014
\r
47 #define WGL_ALPHA_BITS_ARB 0x201B
\r
48 #define WGL_DEPTH_BITS_ARB 0x2022
\r
49 #define WGL_STENCIL_BITS_ARB 0x2023
\r
50 #define WGL_FULL_ACCELERATION_ARB 0x2027
\r
52 #define WGL_SAMPLE_BUFFERS_ARB 0x2041
\r
53 #define WGL_SAMPLES_ARB 0x2042
\r
55 #define WGL_TYPE_RGBA_FLOAT_ARB 0x21A0
\r
57 #define WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB 0x20A9
\r
59 #ifndef WGL_ARB_create_context
\r
60 #define WGL_ARB_create_context 1
\r
61 #ifdef WGL_WGLEXT_PROTOTYPES
\r
62 extern HGLRC WINAPI wglCreateContextAttribsARB (HDC, HGLRC, const int *);
\r
63 #endif /* WGL_WGLEXT_PROTOTYPES */
\r
64 typedef HGLRC (WINAPI * PFNWGLCREATECONTEXTATTRIBSARBPROC) (HDC hDC, HGLRC hShareContext, const int *attribList);
\r
66 #define WGL_CONTEXT_MAJOR_VERSION_ARB 0x2091
\r
67 #define WGL_CONTEXT_MINOR_VERSION_ARB 0x2092
\r
68 #define WGL_CONTEXT_LAYER_PLANE_ARB 0x2093
\r
69 #define WGL_CONTEXT_FLAGS_ARB 0x2094
\r
70 #define WGL_CONTEXT_PROFILE_MASK_ARB 0x9126
\r
72 #define WGL_CONTEXT_DEBUG_BIT_ARB 0x0001
\r
73 #define WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB 0x0002
\r
75 #define WGL_CONTEXT_CORE_PROFILE_BIT_ARB 0x00000001
\r
76 #define WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002
\r
78 #define ERROR_INVALID_VERSION_ARB 0x2095
\r
79 #define ERROR_INVALID_PROFILE_ARB 0x2096
\r
81 /* End of copying the necessary parts out of it. */
\r
83 /* pushing attribute/value pairs into an array */
\r
84 #define ATTRIB(a) attributes[where++]=(a)
\r
85 #define ATTRIB_VAL(a,v) {ATTRIB(a); ATTRIB(v);}
\r
88 extern int fghIsLegacyContextVersionRequested( void );
\r
89 extern int fghMapBit( int mask, int from, int to );
\r
90 extern int fghIsLegacyContextRequested( void );
\r
91 extern void fghContextCreationError( void );
\r
92 extern int fghNumberOfAuxBuffersRequested( void );
\r
95 typedef BOOL (WINAPI *pRegisterTouchWindow)(HWND,ULONG);
\r
96 static pRegisterTouchWindow fghRegisterTouchWindow = (pRegisterTouchWindow)0xDEADBEEF;
\r
100 * Helper functions for getting client area from the window rect
\r
101 * and the window rect from the client area given the style of the window
\r
102 * (or a valid window pointer from which the style can be queried).
\r
104 extern void fghGetBorderWidth(const DWORD windowStyle, int* xBorderWidth, int* yBorderWidth);
\r
108 * Setup the pixel format for a Win32 window
\r
111 #if defined(_WIN32_WCE)
\r
112 static wchar_t* fghWstrFromStr(const char* str)
\r
114 int i,len=strlen(str);
\r
115 wchar_t* wstr = (wchar_t*)malloc(2*len+2);
\r
116 for(i=0; i<len; i++)
\r
121 #endif /* defined(_WIN32_WCE) */
\r
124 static void fghFillContextAttributes( int *attributes ) {
\r
125 int where = 0, contextFlags, contextProfile;
\r
127 if ( !fghIsLegacyContextVersionRequested() ) {
\r
128 ATTRIB_VAL( WGL_CONTEXT_MAJOR_VERSION_ARB, fgState.MajorVersion );
\r
129 ATTRIB_VAL( WGL_CONTEXT_MINOR_VERSION_ARB, fgState.MinorVersion );
\r
133 fghMapBit( fgState.ContextFlags, GLUT_DEBUG, WGL_CONTEXT_DEBUG_BIT_ARB ) |
\r
134 fghMapBit( fgState.ContextFlags, GLUT_FORWARD_COMPATIBLE, WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB );
\r
135 if ( contextFlags != 0 ) {
\r
136 ATTRIB_VAL( WGL_CONTEXT_FLAGS_ARB, contextFlags );
\r
140 fghMapBit( fgState.ContextProfile, GLUT_CORE_PROFILE, WGL_CONTEXT_CORE_PROFILE_BIT_ARB ) |
\r
141 fghMapBit( fgState.ContextProfile, GLUT_COMPATIBILITY_PROFILE, WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB );
\r
142 if ( contextProfile != 0 ) {
\r
143 ATTRIB_VAL( WGL_CONTEXT_PROFILE_MASK_ARB, contextProfile );
\r
149 static int fghIsExtensionSupported( HDC hdc, const char *extension ) {
\r
150 const char *pWglExtString;
\r
151 PFNWGLGETEXTENSIONSSTRINGARBPROC wglGetEntensionsStringARB =
\r
152 (PFNWGLGETEXTENSIONSSTRINGARBPROC) wglGetProcAddress("wglGetExtensionsStringARB");
\r
153 if ( wglGetEntensionsStringARB == NULL )
\r
157 pWglExtString = wglGetEntensionsStringARB( hdc );
\r
158 return ( pWglExtString != NULL ) && ( strstr(pWglExtString, extension) != NULL );
\r
161 void fgNewWGLCreateContext( SFG_Window* window )
\r
165 PFNWGLCREATECONTEXTATTRIBSARBPROC wglCreateContextAttribsARB;
\r
167 /* If nothing fancy has been required, leave the context as it is */
\r
168 if ( fghIsLegacyContextRequested() )
\r
173 wglMakeCurrent( window->Window.pContext.Device, window->Window.Context );
\r
175 if ( !fghIsExtensionSupported( window->Window.pContext.Device, "WGL_ARB_create_context" ) )
\r
180 /* new context creation */
\r
181 fghFillContextAttributes( attributes );
\r
183 wglCreateContextAttribsARB = (PFNWGLCREATECONTEXTATTRIBSARBPROC) wglGetProcAddress( "wglCreateContextAttribsARB" );
\r
184 if ( wglCreateContextAttribsARB == NULL )
\r
186 fgError( "wglCreateContextAttribsARB not found" );
\r
189 context = wglCreateContextAttribsARB( window->Window.pContext.Device, 0, attributes );
\r
190 if ( context == NULL )
\r
192 fghContextCreationError();
\r
195 wglMakeCurrent( NULL, NULL );
\r
196 wglDeleteContext( window->Window.Context );
\r
197 window->Window.Context = context;
\r
200 #if !defined(_WIN32_WCE)
\r
202 static void fghFillPFD( PIXELFORMATDESCRIPTOR *ppfd, HDC hdc, unsigned char layer_type )
\r
204 int flags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL;
\r
205 if ( fgState.DisplayMode & GLUT_DOUBLE ) {
\r
206 flags |= PFD_DOUBLEBUFFER;
\r
208 if ( fgState.DisplayMode & GLUT_STEREO ) {
\r
209 flags |= PFD_STEREO;
\r
212 #if defined(_MSC_VER)
\r
213 #pragma message( "fgSetupPixelFormat(): there is still some work to do here!" )
\r
216 /* Specify which pixel format do we opt for... */
\r
217 ppfd->nSize = sizeof(PIXELFORMATDESCRIPTOR);
\r
218 ppfd->nVersion = 1;
\r
219 ppfd->dwFlags = flags;
\r
221 if( fgState.DisplayMode & GLUT_INDEX ) {
\r
222 ppfd->iPixelType = PFD_TYPE_COLORINDEX;
\r
223 ppfd->cRedBits = 0;
\r
224 ppfd->cGreenBits = 0;
\r
225 ppfd->cBlueBits = 0;
\r
226 ppfd->cAlphaBits = 0;
\r
228 ppfd->iPixelType = PFD_TYPE_RGBA;
\r
229 ppfd->cRedBits = 8;
\r
230 ppfd->cGreenBits = 8;
\r
231 ppfd->cBlueBits = 8;
\r
232 ppfd->cAlphaBits = ( fgState.DisplayMode & GLUT_ALPHA ) ? 8 : 0;
\r
235 ppfd->cColorBits = 24;
\r
236 ppfd->cRedShift = 0;
\r
237 ppfd->cGreenShift = 0;
\r
238 ppfd->cBlueShift = 0;
\r
239 ppfd->cAlphaShift = 0;
\r
240 ppfd->cAccumBits = ( fgState.DisplayMode & GLUT_ACCUM ) ? 1 : 0;
\r
241 ppfd->cAccumRedBits = 0;
\r
242 ppfd->cAccumGreenBits = 0;
\r
243 ppfd->cAccumBlueBits = 0;
\r
244 ppfd->cAccumAlphaBits = 0;
\r
246 /* Hmmm, or 32/0 instead of 24/8? */
\r
247 ppfd->cDepthBits = 24;
\r
248 ppfd->cStencilBits = 8;
\r
250 ppfd->cAuxBuffers = fghNumberOfAuxBuffersRequested();
\r
251 ppfd->iLayerType = layer_type;
\r
252 ppfd->bReserved = 0;
\r
253 ppfd->dwLayerMask = 0;
\r
254 ppfd->dwVisibleMask = 0;
\r
255 ppfd->dwDamageMask = 0;
\r
257 ppfd->cColorBits = (BYTE) GetDeviceCaps( hdc, BITSPIXEL );
\r
260 static void fghFillPixelFormatAttributes( int *attributes, const PIXELFORMATDESCRIPTOR *ppfd )
\r
264 ATTRIB_VAL( WGL_DRAW_TO_WINDOW_ARB, GL_TRUE );
\r
265 ATTRIB_VAL( WGL_SUPPORT_OPENGL_ARB, GL_TRUE );
\r
266 ATTRIB_VAL( WGL_ACCELERATION_ARB, WGL_FULL_ACCELERATION_ARB );
\r
268 ATTRIB_VAL( WGL_COLOR_BITS_ARB, ppfd->cColorBits );
\r
269 ATTRIB_VAL( WGL_ALPHA_BITS_ARB, ppfd->cAlphaBits );
\r
270 ATTRIB_VAL( WGL_DEPTH_BITS_ARB, ppfd->cDepthBits );
\r
271 ATTRIB_VAL( WGL_STENCIL_BITS_ARB, ppfd->cStencilBits );
\r
273 ATTRIB_VAL( WGL_DOUBLE_BUFFER_ARB, ( fgState.DisplayMode & GLUT_DOUBLE ) != 0 );
\r
275 if ( fgState.DisplayMode & GLUT_SRGB ) {
\r
276 ATTRIB_VAL( WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB, TRUE );
\r
279 ATTRIB_VAL( WGL_SAMPLE_BUFFERS_ARB, GL_TRUE );
\r
280 ATTRIB_VAL( WGL_SAMPLES_ARB, fgState.SampleNumber );
\r
285 GLboolean fgSetupPixelFormat( SFG_Window* window, GLboolean checkOnly,
\r
286 unsigned char layer_type )
\r
288 #if defined(_WIN32_WCE)
\r
291 PIXELFORMATDESCRIPTOR pfd;
\r
292 PIXELFORMATDESCRIPTOR* ppfd = &pfd;
\r
298 current_hDC = CreateDC(TEXT("DISPLAY"), NULL ,NULL ,NULL);
\r
300 current_hDC = window->Window.pContext.Device;
\r
302 fghFillPFD( ppfd, current_hDC, layer_type );
\r
303 pixelformat = ChoosePixelFormat( current_hDC, ppfd );
\r
305 /* windows hack for multismapling/sRGB */
\r
306 if ( ( fgState.DisplayMode & GLUT_MULTISAMPLE ) ||
\r
307 ( fgState.DisplayMode & GLUT_SRGB ) )
\r
309 HGLRC rc, rc_before=wglGetCurrentContext();
\r
311 HDC hDC, hDC_before=wglGetCurrentDC();
\r
314 /* create a dummy window */
\r
315 ZeroMemory(&wndCls, sizeof(wndCls));
\r
316 wndCls.lpfnWndProc = DefWindowProc;
\r
317 wndCls.hInstance = fgDisplay.pDisplay.Instance;
\r
318 wndCls.style = CS_OWNDC | CS_HREDRAW | CS_VREDRAW;
\r
319 wndCls.lpszClassName = _T("FREEGLUT_dummy");
\r
320 RegisterClass( &wndCls );
\r
322 hWnd=CreateWindow(_T("FREEGLUT_dummy"), _T(""), WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_OVERLAPPEDWINDOW , 0,0,0,0, 0, 0, fgDisplay.pDisplay.Instance, 0 );
\r
324 SetPixelFormat( hDC, pixelformat, ppfd );
\r
326 rc = wglCreateContext( hDC );
\r
327 wglMakeCurrent(hDC, rc);
\r
329 if ( fghIsExtensionSupported( hDC, "WGL_ARB_multisample" ) )
\r
331 PFNWGLCHOOSEPIXELFORMATARBPROC wglChoosePixelFormatARBProc =
\r
332 (PFNWGLCHOOSEPIXELFORMATARBPROC) wglGetProcAddress("wglChoosePixelFormatARB");
\r
333 if ( wglChoosePixelFormatARBProc )
\r
335 int attributes[100];
\r
338 float fAttributes[] = { 0, 0 };
\r
340 fghFillPixelFormatAttributes( attributes, ppfd );
\r
341 bValid = wglChoosePixelFormatARBProc(hDC, attributes, fAttributes, 1, &iPixelFormat, &numFormats);
\r
343 if ( bValid && numFormats > 0 )
\r
345 pixelformat = iPixelFormat;
\r
350 wglMakeCurrent( hDC_before, rc_before);
\r
351 wglDeleteContext(rc);
\r
352 ReleaseDC(hWnd, hDC);
\r
353 DestroyWindow(hWnd);
\r
354 UnregisterClass(_T("FREEGLUT_dummy"), fgDisplay.pDisplay.Instance);
\r
357 success = ( pixelformat != 0 ) && ( checkOnly || SetPixelFormat( current_hDC, pixelformat, ppfd ) );
\r
360 DeleteDC(current_hDC);
\r
363 #endif /* defined(_WIN32_WCE) */
\r
368 void fgPlatformSetWindow ( SFG_Window *window )
\r
370 if ( window != fgStructure.CurrentWindow )
\r
372 if( fgStructure.CurrentWindow )
\r
373 ReleaseDC( fgStructure.CurrentWindow->Window.Handle,
\r
374 fgStructure.CurrentWindow->Window.pContext.Device );
\r
378 window->Window.pContext.Device = GetDC( window->Window.Handle );
\r
380 window->Window.pContext.Device,
\r
381 window->Window.Context
\r
389 /* Computes position of corners of window Rect (outer position including
\r
390 * decorations) based on the provided client rect and based on the style
\r
391 * of the window in question.
\r
392 * If posIsOutside is set to true, the input client Rect is taken to follow
\r
393 * freeGLUT's window specification convention in which the top-left corner
\r
394 * is at the outside of the window, while the size
\r
395 * (rect.right-rect.left,rect.bottom-rect.top) is the size of the drawable
\r
398 void fghComputeWindowRectFromClientArea_UseStyle( const DWORD windowStyle, RECT *clientRect, BOOL posIsOutside )
\r
400 int xBorderWidth = 0, yBorderWidth = 0;
\r
402 /* If window has title bar, correct rect for it */
\r
403 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... */
\r
405 clientRect->bottom += GetSystemMetrics( SM_CYCAPTION );
\r
407 clientRect->top -= GetSystemMetrics( SM_CYCAPTION );
\r
409 /* get width of window's borders (frame), correct rect for it.
\r
410 * Note, borders can be of zero width if style does not specify borders
\r
412 fghGetBorderWidth(windowStyle, &xBorderWidth, &yBorderWidth);
\r
415 clientRect->right += xBorderWidth * 2;
\r
416 clientRect->bottom += yBorderWidth * 2;
\r
420 clientRect->left -= xBorderWidth;
\r
421 clientRect->right += xBorderWidth;
\r
422 clientRect->top -= yBorderWidth;
\r
423 clientRect->bottom += yBorderWidth;
\r
427 /* Computes position of corners of window Rect (outer position including
\r
428 * decorations) based on the provided client rect and based on the style
\r
429 * of the window in question. If the window pointer or the window handle
\r
430 * is NULL, a fully decorated window (caption and border) is assumed.
\r
431 * Furthermore, if posIsOutside is set to true, the input client Rect is
\r
432 * taken to follow freeGLUT's window specification convention in which the
\r
433 * top-left corner is at the outside of the window, while the size
\r
434 * (rect.right-rect.left,rect.bottom-rect.top) is the size of the drawable
\r
437 void fghComputeWindowRectFromClientArea_QueryWindow( const SFG_Window *window, RECT *clientRect, BOOL posIsOutside )
\r
439 DWORD windowStyle = 0;
\r
441 if (window && window->Window.Handle)
\r
442 windowStyle = GetWindowLong(window->Window.Handle, GWL_STYLE);
\r
444 windowStyle = WS_OVERLAPPEDWINDOW;
\r
446 fghComputeWindowRectFromClientArea_UseStyle(windowStyle, clientRect, posIsOutside);
\r
449 /* Computes position of corners of client area (drawable area) of a window
\r
450 * based on the provided window Rect (outer position including decorations)
\r
451 * and based on the style of the window in question. If the window pointer
\r
452 * or the window handle is NULL, a fully decorated window (caption and
\r
453 * border) is assumed.
\r
454 * Furthermore, if wantPosOutside is set to true, the output client Rect
\r
455 * will follow freeGLUT's window specification convention in which the
\r
456 * top-left corner is at the outside of the window, the size
\r
457 * (rect.right-rect.left,rect.bottom-rect.top) is the size of the drawable
\r
460 void fghComputeClientAreaFromWindowRect( const SFG_Window *window, RECT *windowRect, BOOL wantPosOutside )
\r
462 DWORD windowStyle = 0;
\r
463 int xBorderWidth = 0, yBorderWidth = 0;
\r
465 if (window && window->Window.Handle)
\r
466 windowStyle = GetWindowLong(window->Window.Handle, GWL_STYLE);
\r
468 windowStyle = WS_OVERLAPPEDWINDOW;
\r
470 /* If window has title bar, correct rect for it */
\r
471 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... */
\r
472 if (wantPosOutside)
\r
473 windowRect->bottom -= GetSystemMetrics( SM_CYCAPTION );
\r
475 windowRect->top += GetSystemMetrics( SM_CYCAPTION );
\r
477 /* get width of window's borders (frame), correct rect for it.
\r
478 * Note, borders can be of zero width if style does not specify borders
\r
480 fghGetBorderWidth(windowStyle, &xBorderWidth, &yBorderWidth);
\r
481 if (wantPosOutside)
\r
483 windowRect->right -= xBorderWidth * 2;
\r
484 windowRect->bottom -= yBorderWidth * 2;
\r
488 windowRect->left += xBorderWidth;
\r
489 windowRect->right -= xBorderWidth;
\r
490 windowRect->top += yBorderWidth;
\r
491 windowRect->bottom -= yBorderWidth;
\r
495 /* Gets the rect describing the client area (drawable area) of the
\r
496 * specified window.
\r
497 * Returns an empty rect if window pointer or window handle is NULL.
\r
498 * If wantPosOutside is set to true, the output client Rect
\r
499 * will follow freeGLUT's window specification convention in which the
\r
500 * top-left corner is at the outside of the window, while the size
\r
501 * (rect.right-rect.left,rect.bottom-rect.top) is the size of the drawable
\r
504 RECT fghGetClientArea( const SFG_Window *window, BOOL wantPosOutside )
\r
506 RECT windowRect = {0,0,0,0};
\r
508 freeglut_return_val_if_fail((window && window->Window.Handle),windowRect);
\r
511 * call GetWindowRect()
\r
512 * (this returns the pixel coordinates of the outside of the window)
\r
514 GetWindowRect( window->Window.Handle, &windowRect );
\r
516 /* Then correct the results */
\r
517 fghComputeClientAreaFromWindowRect(window, &windowRect, wantPosOutside);
\r
522 /* Returns the width of the window borders based on the window's style.
\r
524 void fghGetBorderWidth(const DWORD windowStyle, int* xBorderWidth, int* yBorderWidth)
\r
526 if (windowStyle & WS_THICKFRAME)
\r
528 *xBorderWidth = GetSystemMetrics(SM_CXSIZEFRAME);
\r
529 *yBorderWidth = GetSystemMetrics(SM_CYSIZEFRAME);
\r
531 else if (windowStyle & WS_DLGFRAME)
\r
533 *xBorderWidth = GetSystemMetrics(SM_CXFIXEDFRAME);
\r
534 *yBorderWidth = GetSystemMetrics(SM_CYFIXEDFRAME);
\r
543 #if(WINVER >= 0x500)
\r
551 static BOOL CALLBACK m_proc(HMONITOR mon,
\r
556 m_proc_t *dp=(m_proc_t *)data;
\r
557 MONITORINFOEX info;
\r
559 info.cbSize=sizeof(info);
\r
560 res=GetMonitorInfo(mon,(LPMONITORINFO)&info);
\r
563 if( strcmp(dp->name,info.szDevice)==0 )
\r
565 *(dp->x)=info.rcMonitor.left;
\r
566 *(dp->y)=info.rcMonitor.top;
\r
574 * this function returns the origin of the screen identified by
\r
575 * fgDisplay.pDisplay.DisplayName, and 0 otherwise.
\r
576 * This is used in fgOpenWindow to open the gamemode window on the screen
\r
577 * identified by the -display command line argument. The function should
\r
578 * not be called otherwise.
\r
581 static void get_display_origin(int *xp,int *yp)
\r
586 if( fgDisplay.pDisplay.DisplayName )
\r
591 st.name=fgDisplay.pDisplay.DisplayName;
\r
592 EnumDisplayMonitors(0,0,m_proc,(LPARAM)&st);
\r
596 #pragma message( "-display parameter only works if compiled with WINVER >= 0x0500")
\r
598 static void get_display_origin(int *xp,int *yp)
\r
603 if( fgDisplay.pDisplay.DisplayName )
\r
605 fgWarning( "for working -display support FreeGLUT must be compiled with WINVER >= 0x0500");
\r
613 * Opens a window. Requires a SFG_Window object created and attached
\r
614 * to the freeglut structure. OpenGL context is created here.
\r
616 void fgPlatformOpenWindow( SFG_Window* window, const char* title,
\r
617 GLboolean positionUse, int x, int y,
\r
618 GLboolean sizeUse, int w, int h,
\r
619 GLboolean gameMode, GLboolean isSubWindow )
\r
627 /* Grab the window class we have registered on glutInit(): */
\r
628 atom = GetClassInfo( fgDisplay.pDisplay.Instance, _T("FREEGLUT"), &wc );
\r
629 FREEGLUT_INTERNAL_ERROR_EXIT ( atom, "Window Class Info Not Found",
\r
632 /* Determine window style flags*/
\r
635 FREEGLUT_INTERNAL_ERROR_EXIT ( window->Parent == NULL,
\r
636 "Game mode being invoked on a subwindow",
\r
640 * Set the window creation flags appropriately to make the window
\r
641 * entirely visible:
\r
643 flags = WS_POPUP | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_VISIBLE;
\r
647 flags = WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
\r
650 * There's a small difference between creating the top, child and
\r
653 if ( window->IsMenu )
\r
656 exFlags |= WS_EX_TOOLWINDOW;
\r
658 #if defined(_WIN32_WCE)
\r
659 /* no decorations for windows CE */
\r
661 /* if this is not a subwindow (child), set its style based on the requested display mode */
\r
662 else if( window->Parent == NULL )
\r
663 if ( fgState.DisplayMode & GLUT_BORDERLESS )
\r
665 /* no window decorations needed */
\r
667 else if ( fgState.DisplayMode & GLUT_CAPTIONLESS )
\r
668 /* only window decoration is a border, no title bar or buttons */
\r
669 flags |= WS_DLGFRAME;
\r
671 /* window decoration are a border, title bar and buttons.
\r
672 * NB: we later query whether the window has a title bar or
\r
673 * not by testing for the maximize button, as the test for
\r
674 * WS_CAPTION can be true without the window having a title
\r
675 * bar. This style WS_OVERLAPPEDWINDOW gives you a maximize
\r
677 flags |= WS_OVERLAPPEDWINDOW;
\r
680 /* subwindows always have no decoration, but are marked as a child window to the OS */
\r
684 /* determine window size and position */
\r
687 /* if in gamemode, query the origin of specified by the -display
\r
688 * command line parameter (if any) and offset the upper-left corner
\r
689 * of the window so we create the window on that screen.
\r
690 * The -display argument doesn't do anything if not trying to enter
\r
693 int xoff=0, yoff=0;
\r
694 get_display_origin(&xoff,&yoff);
\r
705 if( ! window->IsMenu )
\r
710 else /* fail safe - Windows can make a window of size (0, 0) */
\r
711 w = h = 300; /* default window size */
\r
713 /* store requested client area width and height */
\r
714 window->State.Width = w;
\r
715 window->State.Height = h;
\r
717 #if !defined(_WIN32_WCE) /* no decorations for windows CE */
\r
722 * Update the window dimensions, taking the window decorations
\r
723 * into account. FreeGLUT is to create the window with the
\r
724 * topleft outside corner at (x,y) and with client area
\r
725 * dimensions (w,h).
\r
726 * note: don't need to do this when w=h=CW_USEDEFAULT, so in the
\r
727 * if( sizeUse ) here is convenient.
\r
729 windowRect.left = x;
\r
730 windowRect.top = y;
\r
731 windowRect.right = x+w;
\r
732 windowRect.bottom = y+h;
\r
734 fghComputeWindowRectFromClientArea_UseStyle(flags,&windowRect,TRUE);
\r
736 w = windowRect.right - windowRect.left;
\r
737 h = windowRect.bottom- windowRect.top;
\r
739 #endif /* !defined(_WIN32_WCE) */
\r
741 #if defined(_WIN32_WCE)
\r
743 wchar_t* wstr = fghWstrFromStr(title);
\r
745 window->Window.Handle = CreateWindow(
\r
748 WS_VISIBLE | WS_POPUP,
\r
752 fgDisplay.pDisplay.Instance,
\r
758 SHFullScreen(window->Window.Handle, SHFS_HIDESTARTICON);
\r
759 SHFullScreen(window->Window.Handle, SHFS_HIDESIPBUTTON);
\r
760 SHFullScreen(window->Window.Handle, SHFS_HIDETASKBAR);
\r
761 MoveWindow(window->Window.Handle, 0, 0, 240, 320, TRUE);
\r
762 ShowWindow(window->Window.Handle, SW_SHOW);
\r
763 UpdateWindow(window->Window.Handle);
\r
766 window->Window.Handle = CreateWindowEx(
\r
772 (HWND) window->Parent == NULL ? NULL : window->Parent->Window.Handle,
\r
774 fgDisplay.pDisplay.Instance,
\r
777 #endif /* defined(_WIN32_WCE) */
\r
779 if( !( window->Window.Handle ) )
\r
780 fgError( "Failed to create a window (%s)!", title );
\r
782 #if !defined(_WIN32_WCE)
\r
783 /* Need to set requested style again, apparently Windows doesn't listen when requesting windows without title bar or borders */
\r
784 SetWindowLong(window->Window.Handle, GWL_STYLE, flags);
\r
785 SetWindowPos(window->Window.Handle, HWND_TOP, 0,0,0,0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);
\r
786 #endif /* defined(_WIN32_WCE) */
\r
788 /* Make a menu window always on top - fix Feature Request 947118 */
\r
789 if( window->IsMenu || gameMode )
\r
791 window->Window.Handle,
\r
794 SWP_NOMOVE | SWP_NOSIZE
\r
797 /* Enable multitouch: additional flag TWF_FINETOUCH, TWF_WANTPALM */
\r
799 if (fghRegisterTouchWindow == (pRegisterTouchWindow)0xDEADBEEF)
\r
800 fghRegisterTouchWindow = (pRegisterTouchWindow)GetProcAddress(GetModuleHandle("user32"),"RegisterTouchWindow");
\r
801 if (fghRegisterTouchWindow)
\r
802 fghRegisterTouchWindow( window->Window.Handle, TWF_FINETOUCH | TWF_WANTPALM );
\r
805 #if defined(_WIN32_WCE)
\r
806 ShowWindow( window->Window.Handle, SW_SHOW );
\r
808 ShowWindow( window->Window.Handle,
\r
809 fgState.ForceIconic ? SW_SHOWMINIMIZED : SW_SHOW );
\r
810 #endif /* defined(_WIN32_WCE) */
\r
812 UpdateWindow( window->Window.Handle );
\r
813 ShowCursor( TRUE ); /* XXX Old comments say "hide cursor"! */
\r
819 * Closes a window, destroying the frame and OpenGL context
\r
821 void fgPlatformCloseWindow( SFG_Window* window )
\r
823 /* Make sure we don't close a window with current context active */
\r
824 if( fgStructure.CurrentWindow == window )
\r
825 wglMakeCurrent( NULL, NULL );
\r
828 * Step through the list of windows. If the rendering context
\r
829 * is not being used by another window, then we delete it.
\r
835 for( iter = (SFG_Window *)fgStructure.Windows.First;
\r
837 iter = (SFG_Window *)iter->Node.Next )
\r
839 if( ( iter->Window.Context == window->Window.Context ) &&
\r
840 ( iter != window ) )
\r
845 wglDeleteContext( window->Window.Context );
\r
848 DestroyWindow( window->Window.Handle );
\r
854 * This function makes the current window visible
\r
856 void fgPlatformGlutShowWindow( void )
\r
858 ShowWindow( fgStructure.CurrentWindow->Window.Handle, SW_SHOW );
\r
862 * This function hides the current window
\r
864 void fgPlatformGlutHideWindow( void )
\r
866 ShowWindow( fgStructure.CurrentWindow->Window.Handle, SW_HIDE );
\r
870 * Iconify the current window (top-level windows only)
\r
872 void fgPlatformGlutIconifyWindow( void )
\r
874 ShowWindow( fgStructure.CurrentWindow->Window.Handle, SW_MINIMIZE );
\r
878 * Set the current window's title
\r
880 void fgPlatformGlutSetWindowTitle( const char* title )
\r
884 wchar_t* wstr = fghWstrFromStr(title);
\r
885 SetWindowText( fgStructure.CurrentWindow->Window.Handle, wstr );
\r
889 SetWindowText( fgStructure.CurrentWindow->Window.Handle, title );
\r
894 * Set the current window's iconified title
\r
896 void fgPlatformGlutSetIconTitle( const char* title )
\r
900 wchar_t* wstr = fghWstrFromStr(title);
\r
901 SetWindowText( fgStructure.CurrentWindow->Window.Handle, wstr );
\r
905 SetWindowText( fgStructure.CurrentWindow->Window.Handle, title );
\r
910 * Change the current window's position
\r
912 void fgPlatformGlutPositionWindow( int x, int y )
\r
916 /* "GetWindowRect" returns the pixel coordinates of the outside of the window */
\r
917 GetWindowRect( fgStructure.CurrentWindow->Window.Handle, &winRect );
\r
919 fgStructure.CurrentWindow->Window.Handle,
\r
922 winRect.right - winRect.left,
\r
923 winRect.bottom - winRect.top,
\r
929 * Lowers the current window (by Z order change)
\r
931 void fgPlatformGlutPushWindow( void )
\r
934 fgStructure.CurrentWindow->Window.Handle,
\r
937 SWP_NOSIZE | SWP_NOMOVE
\r
942 * Raises the current window (by Z order change)
\r
944 void fgPlatformGlutPopWindow( void )
\r
947 fgStructure.CurrentWindow->Window.Handle,
\r
950 SWP_NOSIZE | SWP_NOMOVE
\r
955 * Resize the current window so that it fits the whole screen
\r
957 void fgPlatformGlutFullScreen( SFG_Window *win )
\r
959 #if !defined(_WIN32_WCE) /* FIXME: what about WinCE */
\r
961 if (glutGet(GLUT_FULL_SCREEN))
\r
963 /* Leave full screen state before entering fullscreen again (resizing?) */
\r
964 glutLeaveFullScreen();
\r
968 #if(WINVER >= 0x0500) /* Windows 2000 or later */
\r
974 /* For fullscreen mode, first remove all window decoration
\r
975 * and set style to popup so it will overlap the taskbar
\r
976 * then force to maximize on the screen on which it has the most
\r
981 /* store current window rect */
\r
982 GetWindowRect( win->Window.Handle, &win->State.pWState.OldRect );
\r
984 /* store current window style */
\r
985 win->State.pWState.OldStyle = s = GetWindowLong(win->Window.Handle, GWL_STYLE);
\r
987 /* remove decorations from style and add popup style*/
\r
988 s &= ~WS_OVERLAPPEDWINDOW;
\r
990 SetWindowLong(win->Window.Handle, GWL_STYLE, s);
\r
991 SetWindowPos(win->Window.Handle, HWND_TOP, 0,0,0,0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);
\r
993 /* For fullscreen mode, find the monitor that is covered the most
\r
994 * by the window and get its rect as the resize target.
\r
996 hMonitor= MonitorFromRect(&win->State.pWState.OldRect, MONITOR_DEFAULTTONEAREST);
\r
997 mi.cbSize = sizeof(mi);
\r
998 GetMonitorInfo(hMonitor, &mi);
\r
999 rect = mi.rcMonitor;
\r
1000 #else /* if (WINVER >= 0x0500) */
\r
1003 /* For fullscreen mode, force the top-left corner to 0,0
\r
1004 * and adjust the window rectangle so that the client area
\r
1005 * covers the whole screen.
\r
1010 rect.right = fgDisplay.ScreenWidth;
\r
1011 rect.bottom = fgDisplay.ScreenHeight;
\r
1013 AdjustWindowRect ( &rect, WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS |
\r
1014 WS_CLIPCHILDREN, FALSE );
\r
1015 #endif /* (WINVER >= 0x0500) */
\r
1018 * then resize window
\r
1019 * SWP_NOACTIVATE Do not activate the window
\r
1020 * SWP_NOOWNERZORDER Do not change position in z-order
\r
1021 * SWP_NOSENDCHANGING Suppress WM_WINDOWPOSCHANGING message
\r
1022 * SWP_NOZORDER Retains the current Z order (ignore 2nd param)
\r
1024 SetWindowPos( fgStructure.CurrentWindow->Window.Handle,
\r
1028 rect.right - rect.left,
\r
1029 rect.bottom - rect.top,
\r
1030 SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOSENDCHANGING |
\r
1034 win->State.IsFullscreen = GL_TRUE;
\r
1040 * If we are fullscreen, resize the current window back to its original size
\r
1042 void fgPlatformGlutLeaveFullScreen( SFG_Window *win )
\r
1044 #if !defined(_WIN32_WCE) /* FIXME: what about WinCE */
\r
1045 if (!glutGet(GLUT_FULL_SCREEN))
\r
1047 /* nothing to do */
\r
1051 /* restore style of window before making it fullscreen */
\r
1052 SetWindowLong(win->Window.Handle, GWL_STYLE, win->State.pWState.OldStyle);
\r
1053 SetWindowPos(win->Window.Handle, HWND_TOP, 0,0,0,0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);
\r
1056 SetWindowPos(win->Window.Handle,
\r
1058 win->State.pWState.OldRect.left,
\r
1059 win->State.pWState.OldRect.top,
\r
1060 win->State.pWState.OldRect.right - win->State.pWState.OldRect.left,
\r
1061 win->State.pWState.OldRect.bottom - win->State.pWState.OldRect.top,
\r
1062 SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOSENDCHANGING |
\r
1066 win->State.IsFullscreen = GL_FALSE;
\r
1071 * Toggle the window's full screen state.
\r
1073 void fgPlatformGlutFullScreenToggle( SFG_Window *win )
\r
1075 if (!win->State.IsFullscreen)
\r
1078 glutLeaveFullScreen();
\r
1082 /* -- PLATFORM-SPECIFIC INTERFACE FUNCTION -------------------------------------------------- */
\r
1084 int FGAPIENTRY __glutCreateWindowWithExit( const char *title, void (__cdecl *exit_function)(int) )
\r
1086 __glutExitFunc = exit_function;
\r
1087 return glutCreateWindow( title );
\r