2 * freeglut_window_mswin.c
4 * The Windows-specific mouse cursor related stuff.
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
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:
17 * The above copyright notice and this permission notice shall be included
18 * in all copies or substantial portions of the Software.
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.
28 #define FREEGLUT_BUILDING_LIB
29 #include <GL/freeglut.h>
30 #include "../fg_internal.h"
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?
38 typedef const char * (WINAPI * PFNWGLGETEXTENSIONSSTRINGARBPROC) (HDC hdc);
40 typedef BOOL (WINAPI * PFNWGLCHOOSEPIXELFORMATARBPROC) (HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats);
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
52 #define WGL_SAMPLE_BUFFERS_ARB 0x2041
53 #define WGL_SAMPLES_ARB 0x2042
55 #define WGL_TYPE_RGBA_FLOAT_ARB 0x21A0
57 #define WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB 0x20A9
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);
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
72 #define WGL_CONTEXT_DEBUG_BIT_ARB 0x0001
73 #define WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB 0x0002
75 #define WGL_CONTEXT_CORE_PROFILE_BIT_ARB 0x00000001
76 #define WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002
78 #define ERROR_INVALID_VERSION_ARB 0x2095
79 #define ERROR_INVALID_PROFILE_ARB 0x2096
81 /* End of copying the necessary parts out of it. */
84 typedef BOOL (WINAPI *pRegisterTouchWindow)(HWND,ULONG);
85 static pRegisterTouchWindow fghRegisterTouchWindow = (pRegisterTouchWindow)0xDEADBEEF;
90 * Setup the pixel format for a Win32 window
93 #if defined(_WIN32_WCE)
94 static wchar_t* fghWstrFromStr(const char* str)
96 int i,len=strlen(str);
97 wchar_t* wstr = (wchar_t*)malloc(2*len+2);
103 #endif /* defined(_WIN32_WCE) */
106 static void fghFillContextAttributes( int *attributes ) {
107 int where = 0, contextFlags, contextProfile;
109 ATTRIB_VAL( WGL_CONTEXT_MAJOR_VERSION_ARB, fgState.MajorVersion );
110 ATTRIB_VAL( WGL_CONTEXT_MINOR_VERSION_ARB, fgState.MinorVersion );
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 );
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 );
129 static int fghIsExtensionSupported( HDC hdc, const char *extension ) {
130 const char *pWglExtString;
131 PFNWGLGETEXTENSIONSSTRINGARBPROC wglGetEntensionsStringARB =
132 (PFNWGLGETEXTENSIONSSTRINGARBPROC) wglGetProcAddress("wglGetExtensionsStringARB");
133 if ( wglGetEntensionsStringARB == NULL )
137 pWglExtString = wglGetEntensionsStringARB( hdc );
138 return ( pWglExtString != NULL ) && ( strstr(pWglExtString, extension) != NULL );
141 void fgNewWGLCreateContext( SFG_Window* window )
145 PFNWGLCREATECONTEXTATTRIBSARBPROC wglCreateContextAttribsARB;
147 /* If nothing fancy has been required, leave the context as it is */
148 if ( fghIsLegacyContextRequested() )
153 wglMakeCurrent( window->Window.pContext.Device, window->Window.Context );
155 if ( !fghIsExtensionSupported( window->Window.pContext.Device, "WGL_ARB_create_context" ) )
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 */
163 /* new context creation */
164 fghFillContextAttributes( attributes );
166 wglCreateContextAttribsARB = (PFNWGLCREATECONTEXTATTRIBSARBPROC) wglGetProcAddress( "wglCreateContextAttribsARB" );
167 if ( wglCreateContextAttribsARB == NULL )
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 */
175 context = wglCreateContextAttribsARB( window->Window.pContext.Device, 0, attributes );
176 if ( context == NULL )
178 fghContextCreationError();
181 wglMakeCurrent( NULL, NULL );
182 wglDeleteContext( window->Window.Context );
183 window->Window.Context = context;
186 #if !defined(_WIN32_WCE)
188 static void fghFillPFD( PIXELFORMATDESCRIPTOR *ppfd, HDC hdc, unsigned char layer_type )
190 int flags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL;
191 if ( fgState.DisplayMode & GLUT_DOUBLE ) {
192 flags |= PFD_DOUBLEBUFFER;
194 if ( fgState.DisplayMode & GLUT_STEREO ) {
198 #if defined(_MSC_VER)
199 #pragma message( "fgSetupPixelFormat(): there is still some work to do here!" )
202 /* Specify which pixel format do we opt for... */
203 ppfd->nSize = sizeof(PIXELFORMATDESCRIPTOR);
205 ppfd->dwFlags = flags;
207 if( fgState.DisplayMode & GLUT_INDEX ) {
208 ppfd->iPixelType = PFD_TYPE_COLORINDEX;
210 ppfd->cGreenBits = 0;
212 ppfd->cAlphaBits = 0;
214 ppfd->iPixelType = PFD_TYPE_RGBA;
216 ppfd->cGreenBits = 8;
218 ppfd->cAlphaBits = ( fgState.DisplayMode & GLUT_ALPHA ) ? 8 : 0;
221 ppfd->cColorBits = 24;
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;
232 /* Hmmm, or 32/0 instead of 24/8? */
233 ppfd->cDepthBits = 24;
234 ppfd->cStencilBits = 8;
236 ppfd->cAuxBuffers = fghNumberOfAuxBuffersRequested();
237 ppfd->iLayerType = layer_type;
239 ppfd->dwLayerMask = 0;
240 ppfd->dwVisibleMask = 0;
241 ppfd->dwDamageMask = 0;
243 ppfd->cColorBits = (BYTE) GetDeviceCaps( hdc, BITSPIXEL );
246 static void fghFillPixelFormatAttributes( int *attributes, const PIXELFORMATDESCRIPTOR *ppfd )
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 );
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 );
259 ATTRIB_VAL( WGL_DOUBLE_BUFFER_ARB, ( fgState.DisplayMode & GLUT_DOUBLE ) != 0 );
261 if ( fgState.DisplayMode & GLUT_SRGB ) {
262 ATTRIB_VAL( WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB, TRUE );
265 ATTRIB_VAL( WGL_SAMPLE_BUFFERS_ARB, GL_TRUE );
266 ATTRIB_VAL( WGL_SAMPLES_ARB, fgState.SampleNumber );
271 GLboolean fgSetupPixelFormat( SFG_Window* window, GLboolean checkOnly,
272 unsigned char layer_type )
274 #if defined(_WIN32_WCE)
277 PIXELFORMATDESCRIPTOR pfd;
278 PIXELFORMATDESCRIPTOR* ppfd = &pfd;
284 current_hDC = CreateDC(TEXT("DISPLAY"), NULL ,NULL ,NULL);
286 current_hDC = window->Window.pContext.Device;
288 fghFillPFD( ppfd, current_hDC, layer_type );
289 pixelformat = ChoosePixelFormat( current_hDC, ppfd );
291 /* windows hack for multismapling/sRGB */
292 if ( ( fgState.DisplayMode & GLUT_MULTISAMPLE ) ||
293 ( fgState.DisplayMode & GLUT_SRGB ) )
295 HGLRC rc, rc_before=wglGetCurrentContext();
297 HDC hDC, hDC_before=wglGetCurrentDC();
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 );
308 hWnd=CreateWindow(_T("FREEGLUT_dummy"), _T(""), WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_OVERLAPPEDWINDOW , 0,0,0,0, 0, 0, fgDisplay.pDisplay.Instance, 0 );
310 SetPixelFormat( hDC, pixelformat, ppfd );
312 rc = wglCreateContext( hDC );
313 wglMakeCurrent(hDC, rc);
315 if ( fghIsExtensionSupported( hDC, "WGL_ARB_multisample" ) )
317 PFNWGLCHOOSEPIXELFORMATARBPROC wglChoosePixelFormatARBProc =
318 (PFNWGLCHOOSEPIXELFORMATARBPROC) wglGetProcAddress("wglChoosePixelFormatARB");
319 if ( wglChoosePixelFormatARBProc )
324 float fAttributes[] = { 0, 0 };
326 fghFillPixelFormatAttributes( attributes, ppfd );
327 bValid = wglChoosePixelFormatARBProc(hDC, attributes, fAttributes, 1, &iPixelFormat, &numFormats);
329 if ( bValid && numFormats > 0 )
331 pixelformat = iPixelFormat;
336 wglMakeCurrent( hDC_before, rc_before);
337 wglDeleteContext(rc);
338 ReleaseDC(hWnd, hDC);
340 UnregisterClass(_T("FREEGLUT_dummy"), fgDisplay.pDisplay.Instance);
343 success = ( pixelformat != 0 ) && ( checkOnly || SetPixelFormat( current_hDC, pixelformat, ppfd ) );
346 DeleteDC(current_hDC);
349 #endif /* defined(_WIN32_WCE) */
354 void fgPlatformSetWindow ( SFG_Window *window )
356 if ( window != fgStructure.CurrentWindow )
358 if( fgStructure.CurrentWindow )
359 ReleaseDC( fgStructure.CurrentWindow->Window.Handle,
360 fgStructure.CurrentWindow->Window.pContext.Device );
364 window->Window.pContext.Device = GetDC( window->Window.Handle );
366 window->Window.pContext.Device,
367 window->Window.Context
374 void fghGetDefaultWindowStyle(DWORD *flags)
376 if ( fgState.DisplayMode & GLUT_BORDERLESS )
378 /* no window decorations needed, no-op */
380 else if ( fgState.DisplayMode & GLUT_CAPTIONLESS )
381 /* only window decoration is a border, no title bar or buttons */
382 (*flags) |= WS_DLGFRAME;
384 /* window decoration are a border, title bar and buttons. */
385 (*flags) |= WS_OVERLAPPEDWINDOW;
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.
392 void fghGetStyleFromWindow( const SFG_Window *window, DWORD *windowStyle, DWORD *windowExStyle )
394 if (window && window->Window.Handle)
396 *windowStyle = GetWindowLong(window->Window.Handle, GWL_STYLE);
397 *windowExStyle = GetWindowLong(window->Window.Handle, GWL_EXSTYLE);
402 fghGetDefaultWindowStyle(windowStyle);
403 /* WindowExStyle==0 is fine/default, exStyle is currently only used for menu windows */
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
418 void fghComputeWindowRectFromClientArea_UseStyle( RECT *clientRect, const DWORD windowStyle, const DWORD windowExStyle, BOOL posIsOutside )
420 RECT windowRect = {0,0,0,0};
421 CopyRect(&windowRect,clientRect);
423 /* Get rect including non-client area */
424 AdjustWindowRectEx(&windowRect,windowStyle,FALSE,windowExStyle);
426 /* Move window right and down by non-client area extent on left and top, if wanted */
429 windowRect.right += clientRect->left-windowRect.left;
430 windowRect.bottom += clientRect->top -windowRect.top;
431 windowRect.left = clientRect->left;
432 windowRect.top = clientRect->top;
435 /* done, copy windowRect to output */
436 CopyRect(clientRect,&windowRect);
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
449 void fghComputeWindowRectFromClientArea_QueryWindow( RECT *clientRect, const SFG_Window *window, BOOL posIsOutside )
451 DWORD windowStyle = 0, windowExStyle = 0;
452 fghGetStyleFromWindow(window,&windowStyle,&windowExStyle);
454 fghComputeWindowRectFromClientArea_UseStyle(clientRect, windowStyle, windowExStyle, posIsOutside);
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 * Does not touch clientRect if window pointer or window handle is NULL.
461 * (rect.right-rect.left,rect.bottom-rect.top) is the size of the drawable area.
463 void fghGetClientArea( RECT *clientRect, const SFG_Window *window )
465 POINT topLeftClient = {0,0};
466 POINT topLeftWindow = {0,0};
468 freeglut_return_if_fail((window && window->Window.Handle));
470 /* Get size of client rect */
471 GetClientRect(window->Window.Handle, clientRect);
472 /* Get position of top-left of client area on the screen */
473 ClientToScreen(window->Window.Handle,&topLeftClient);
474 /* Add top-left offset */
475 OffsetRect(clientRect,topLeftClient.x,topLeftClient.y);
486 static BOOL CALLBACK m_proc(HMONITOR mon,
491 m_proc_t *dp=(m_proc_t *)data;
494 info.cbSize=sizeof(info);
495 res=GetMonitorInfo(mon,(LPMONITORINFO)&info);
498 if( strcmp(dp->name,info.szDevice)==0 )
500 *(dp->x)=info.rcMonitor.left;
501 *(dp->y)=info.rcMonitor.top;
509 * this function returns the origin of the screen identified by
510 * fgDisplay.pDisplay.DisplayName, and 0 otherwise.
511 * This is used in fgOpenWindow to open the gamemode window on the screen
512 * identified by the -display command line argument. The function should
513 * not be called otherwise.
516 static void get_display_origin(int *xp,int *yp)
521 if( fgDisplay.pDisplay.DisplayName )
526 st.name=fgDisplay.pDisplay.DisplayName;
527 EnumDisplayMonitors(0,0,m_proc,(LPARAM)&st);
531 #pragma message( "-display parameter only works if compiled with WINVER >= 0x0500")
533 static void get_display_origin(int *xp,int *yp)
538 if( fgDisplay.pDisplay.DisplayName )
540 fgWarning( "for working -display support FreeGLUT must be compiled with WINVER >= 0x0500");
548 * Opens a window. Requires a SFG_Window object created and attached
549 * to the freeglut structure. OpenGL context is created here.
551 void fgPlatformOpenWindow( SFG_Window* window, const char* title,
552 GLboolean positionUse, int x, int y,
553 GLboolean sizeUse, int w, int h,
554 GLboolean gameMode, GLboolean isSubWindow )
562 /* Grab the window class we have registered on glutInit(): */
563 atom = GetClassInfo( fgDisplay.pDisplay.Instance, _T("FREEGLUT"), &wc );
564 FREEGLUT_INTERNAL_ERROR_EXIT ( atom, "Window Class Info Not Found",
567 /* Determine window style flags*/
570 FREEGLUT_INTERNAL_ERROR_EXIT ( window->Parent == NULL,
571 "Game mode being invoked on a subwindow",
575 * Set the window creation flags appropriately to make the window
578 flags = WS_POPUP | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_VISIBLE;
582 flags = WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
585 * There's a small difference between creating the top, child and
588 if ( window->IsMenu )
591 exFlags |= WS_EX_TOOLWINDOW;
593 #if defined(_WIN32_WCE)
594 /* no decorations for windows CE */
596 /* if this is not a subwindow (child), set its style based on the requested window decorations */
597 else if( window->Parent == NULL )
598 fghGetDefaultWindowStyle(&flags);
601 /* subwindows always have no decoration, but are marked as a child window to the OS */
605 /* determine window size and position */
608 /* if in gamemode, query the origin of specified by the -display
609 * command line parameter (if any) and offset the upper-left corner
610 * of the window so we create the window on that screen.
611 * The -display argument doesn't do anything if not trying to enter
615 get_display_origin(&xoff,&yoff);
626 if( ! window->IsMenu )
631 else /* fail safe - Windows can make a window of size (0, 0) */
632 w = h = 300; /* default window size */
634 /* store requested client area width and height */
635 window->State.Width = w;
636 window->State.Height = h;
638 #if !defined(_WIN32_WCE) /* no decorations for windows CE */
643 * Update the window dimensions, taking the window decorations
644 * into account. FreeGLUT is to create the window with the
645 * topleft outside corner at (x,y) and with client area
647 * note: don't need to do this when w=h=CW_USEDEFAULT, so in the
648 * if( sizeUse ) here is convenient.
652 windowRect.right = x+w;
653 windowRect.bottom = y+h;
655 fghComputeWindowRectFromClientArea_UseStyle(&windowRect,flags,exFlags,TRUE);
657 /* NB: w and h are now width and height of window including non-client area! */
658 w = windowRect.right - windowRect.left;
659 h = windowRect.bottom- windowRect.top;
661 #endif /* !defined(_WIN32_WCE) */
663 #if defined(_WIN32_WCE)
665 wchar_t* wstr = fghWstrFromStr(title);
667 window->Window.Handle = CreateWindow(
670 WS_VISIBLE | WS_POPUP,
674 fgDisplay.pDisplay.Instance,
680 SHFullScreen(window->Window.Handle, SHFS_HIDESTARTICON);
681 SHFullScreen(window->Window.Handle, SHFS_HIDESIPBUTTON);
682 SHFullScreen(window->Window.Handle, SHFS_HIDETASKBAR);
683 MoveWindow(window->Window.Handle, 0, 0, 240, 320, TRUE);
684 ShowWindow(window->Window.Handle, SW_SHOW);
685 UpdateWindow(window->Window.Handle);
688 window->Window.Handle = CreateWindowEx(
694 (HWND) window->Parent == NULL ? NULL : window->Parent->Window.Handle,
696 fgDisplay.pDisplay.Instance,
699 #endif /* defined(_WIN32_WCE) */
701 if( !( window->Window.Handle ) )
702 fgError( "Failed to create a window (%s)!", title );
704 #if !defined(_WIN32_WCE)
705 /* Need to set requested style again, apparently Windows doesn't listen when requesting windows without title bar or borders */
706 SetWindowLong(window->Window.Handle, GWL_STYLE, flags);
707 SetWindowPos(window->Window.Handle, HWND_TOP, 0,0,0,0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);
708 #endif /* defined(_WIN32_WCE) */
710 /* Make a menu window always on top - fix Feature Request 947118 */
711 if( window->IsMenu || gameMode )
713 window->Window.Handle,
716 SWP_NOMOVE | SWP_NOSIZE
719 /* Enable multitouch: additional flag TWF_FINETOUCH, TWF_WANTPALM */
721 if (fghRegisterTouchWindow == (pRegisterTouchWindow)0xDEADBEEF)
722 fghRegisterTouchWindow = (pRegisterTouchWindow)GetProcAddress(GetModuleHandle("user32"),"RegisterTouchWindow");
723 if (fghRegisterTouchWindow)
724 fghRegisterTouchWindow( window->Window.Handle, TWF_FINETOUCH | TWF_WANTPALM );
727 #if defined(_WIN32_WCE)
728 ShowWindow( window->Window.Handle, SW_SHOW );
730 ShowWindow( window->Window.Handle,
731 fgState.ForceIconic ? SW_SHOWMINIMIZED : SW_SHOWNORMAL );
732 #endif /* defined(_WIN32_WCE) */
734 UpdateWindow( window->Window.Handle );
735 ShowCursor( TRUE ); /* XXX Old comments say "hide cursor"! */
739 void fgPlatformDisplayWindow ( SFG_Window *window )
742 window->Window.Handle, NULL, NULL,
743 RDW_NOERASE | RDW_INTERNALPAINT | RDW_INVALIDATE | RDW_UPDATENOW
748 void fgPlatformReshapeWindow ( SFG_Window *window, int width, int height )
753 * For windowed mode, get the current position of the
754 * window and resize taking the size of the frame
755 * decorations into account.
757 * Note on maximizing behavior of Windows: the resize borders are off
758 * the screen such that the client area extends all the way from the
759 * leftmost corner to the rightmost corner to maximize screen real
760 * estate. A caption is still shown however to allow interaction with
761 * the window controls. This is default behavior of Windows that
762 * FreeGLUT sticks with. To alter, one would have to check if
763 * WS_MAXIMIZE style is set when a resize event is triggered, and
764 * then manually correct the windowRect to put the borders back on
768 /* "GetWindowRect" returns the pixel coordinates of the outside of the window */
769 GetWindowRect( window->Window.Handle, &windowRect );
771 /* Create rect in FreeGLUT format, (X,Y) topleft outside window, WxH of client area */
772 windowRect.right = windowRect.left+width;
773 windowRect.bottom = windowRect.top+height;
775 if (window->Parent == NULL)
776 /* get the window rect from this to feed to SetWindowPos, correct for window decorations */
777 fghComputeWindowRectFromClientArea_QueryWindow(&windowRect,window,TRUE);
780 /* correct rect for position client area of parent window
781 * (SetWindowPos input for child windows is in coordinates
782 * relative to the parent's client area).
783 * Child windows don't have decoration, so no need to correct
787 fghGetClientArea( &parentRect, window->Parent );
788 OffsetRect(&windowRect,-parentRect.left,-parentRect.top);
791 /* Do the actual resizing */
792 SetWindowPos( window->Window.Handle,
794 windowRect.left, windowRect.top,
795 windowRect.right - windowRect.left,
796 windowRect.bottom- windowRect.top,
797 SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOSENDCHANGING |
801 /* Set new width and height so we can test for that in WM_SIZE message handler and don't do anything if not needed */
802 window->State.Width = width;
803 window->State.Height = height;
808 * Closes a window, destroying the frame and OpenGL context
810 void fgPlatformCloseWindow( SFG_Window* window )
812 /* Make sure we don't close a window with current context active */
813 if( fgStructure.CurrentWindow == window )
814 wglMakeCurrent( NULL, NULL );
817 * Step through the list of windows. If the rendering context
818 * is not being used by another window, then we delete it.
824 for( iter = (SFG_Window *)fgStructure.Windows.First;
826 iter = (SFG_Window *)iter->Node.Next )
828 if( ( iter->Window.Context == window->Window.Context ) &&
834 wglDeleteContext( window->Window.Context );
837 DestroyWindow( window->Window.Handle );
843 * This function makes the current window visible
845 void fgPlatformGlutShowWindow( void )
847 ShowWindow( fgStructure.CurrentWindow->Window.Handle, SW_SHOW );
851 * This function hides the current window
853 void fgPlatformGlutHideWindow( void )
855 ShowWindow( fgStructure.CurrentWindow->Window.Handle, SW_HIDE );
859 * Iconify the current window (top-level windows only)
861 void fgPlatformGlutIconifyWindow( void )
863 ShowWindow( fgStructure.CurrentWindow->Window.Handle, SW_MINIMIZE );
867 * Set the current window's title
869 void fgPlatformGlutSetWindowTitle( const char* title )
873 wchar_t* wstr = fghWstrFromStr(title);
874 SetWindowText( fgStructure.CurrentWindow->Window.Handle, wstr );
878 SetWindowText( fgStructure.CurrentWindow->Window.Handle, title );
883 * Set the current window's iconified title
884 * There really isn't a way to set the icon name separate from the
885 * windows name in Win32, so, just set the windows name.
887 void fgPlatformGlutSetIconTitle( const char* title )
891 wchar_t* wstr = fghWstrFromStr(title);
892 SetWindowText( fgStructure.CurrentWindow->Window.Handle, wstr );
896 SetWindowText( fgStructure.CurrentWindow->Window.Handle, title );
901 * Change the current window's position
903 void fgPlatformGlutPositionWindow( int x, int y )
907 /* "GetWindowRect" returns the pixel coordinates of the outside of the window */
908 GetWindowRect( fgStructure.CurrentWindow->Window.Handle, &winRect );
910 fgStructure.CurrentWindow->Window.Handle,
913 winRect.right - winRect.left,
914 winRect.bottom - winRect.top,
920 * Lowers the current window (by Z order change)
922 void fgPlatformGlutPushWindow( void )
925 fgStructure.CurrentWindow->Window.Handle,
928 SWP_NOSIZE | SWP_NOMOVE
933 * Raises the current window (by Z order change)
935 void fgPlatformGlutPopWindow( void )
938 fgStructure.CurrentWindow->Window.Handle,
941 SWP_NOSIZE | SWP_NOMOVE
946 * Resize the current window so that it fits the whole screen
948 void fgPlatformGlutFullScreen( SFG_Window *win )
950 #if !defined(_WIN32_WCE) /* FIXME: what about WinCE */
952 if (glutGet(GLUT_FULL_SCREEN))
954 /* Leave full screen state before entering fullscreen again (resizing?) */
955 glutLeaveFullScreen();
959 #if(WINVER >= 0x0500) /* Windows 2000 or later */
964 /* For fullscreen mode, first remove all window decoration
965 * and set style to popup so it will overlap the taskbar
966 * then force to maximize on the screen on which it has the most
971 /* save current window rect, style, exstyle and maximized state */
972 win->State.pWState.OldMaximized = !!IsZoomed(win->Window.Handle);
973 if (win->State.pWState.OldMaximized)
974 /* We force the window into restored mode before going
975 * fullscreen because Windows doesn't seem to hide the
976 * taskbar if the window is in the maximized state.
978 SendMessage(win->Window.Handle, WM_SYSCOMMAND, SC_RESTORE, 0);
980 GetWindowRect( win->Window.Handle, &win->State.pWState.OldRect );
981 win->State.pWState.OldStyle = GetWindowLong(win->Window.Handle, GWL_STYLE);
982 win->State.pWState.OldStyleEx = GetWindowLong(win->Window.Handle, GWL_EXSTYLE);
984 /* remove decorations from style */
985 SetWindowLong(win->Window.Handle, GWL_STYLE,
986 win->State.pWState.OldStyle & ~(WS_CAPTION | WS_THICKFRAME));
987 SetWindowLong(win->Window.Handle, GWL_EXSTYLE,
988 win->State.pWState.OldStyleEx & ~(WS_EX_DLGMODALFRAME |
989 WS_EX_WINDOWEDGE | WS_EX_CLIENTEDGE | WS_EX_STATICEDGE));
991 /* For fullscreen mode, find the monitor that is covered the most
992 * by the window and get its rect as the resize target.
994 hMonitor= MonitorFromRect(&win->State.pWState.OldRect, MONITOR_DEFAULTTONEAREST);
995 mi.cbSize = sizeof(mi);
996 GetMonitorInfo(hMonitor, &mi);
998 #else /* if (WINVER >= 0x0500) */
1001 /* For fullscreen mode, force the top-left corner to 0,0
1002 * and adjust the window rectangle so that the client area
1003 * covers the whole screen.
1008 rect.right = fgDisplay.ScreenWidth;
1009 rect.bottom = fgDisplay.ScreenHeight;
1011 AdjustWindowRect ( &rect, WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS |
1012 WS_CLIPCHILDREN, FALSE );
1013 #endif /* (WINVER >= 0x0500) */
1016 * then resize window
1017 * SWP_NOACTIVATE Do not activate the window
1018 * SWP_NOOWNERZORDER Do not change position in z-order
1019 * SWP_NOSENDCHANGING Suppress WM_WINDOWPOSCHANGING message
1020 * SWP_NOZORDER Retains the current Z order (ignore 2nd param)
1022 SetWindowPos( fgStructure.CurrentWindow->Window.Handle,
1026 rect.right - rect.left,
1027 rect.bottom - rect.top,
1028 SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOSENDCHANGING |
1032 win->State.IsFullscreen = GL_TRUE;
1038 * If we are fullscreen, resize the current window back to its original size
1040 void fgPlatformGlutLeaveFullScreen( SFG_Window *win )
1042 #if !defined(_WIN32_WCE) /* FIXME: what about WinCE */
1043 if (!glutGet(GLUT_FULL_SCREEN))
1049 /* restore style of window before making it fullscreen */
1050 SetWindowLong(win->Window.Handle, GWL_STYLE, win->State.pWState.OldStyle);
1051 SetWindowLong(win->Window.Handle, GWL_EXSTYLE, win->State.pWState.OldStyleEx);
1054 SetWindowPos(win->Window.Handle,
1056 win->State.pWState.OldRect.left,
1057 win->State.pWState.OldRect.top,
1058 win->State.pWState.OldRect.right - win->State.pWState.OldRect.left,
1059 win->State.pWState.OldRect.bottom - win->State.pWState.OldRect.top,
1060 SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOSENDCHANGING |
1064 if (win->State.pWState.OldMaximized)
1065 SendMessage(win->Window.Handle, WM_SYSCOMMAND, SC_MAXIMIZE, 0);
1067 win->State.IsFullscreen = GL_FALSE;
1072 * Toggle the window's full screen state.
1074 void fgPlatformGlutFullScreenToggle( SFG_Window *win )
1076 if (!win->State.IsFullscreen)
1079 glutLeaveFullScreen();
1083 /* -- PLATFORM-SPECIFIC INTERFACE FUNCTION -------------------------------------------------- */
1085 int FGAPIENTRY __glutCreateWindowWithExit( const char *title, void (__cdecl *exit_function)(int) )
1087 __glutExitFunc = exit_function;
1088 return glutCreateWindow( title );