-/*\r
- * freeglut_window.c\r
- *\r
- * Window management methods.\r
- *\r
- * Copyright (c) 1999-2000 Pawel W. Olszta. All Rights Reserved.\r
- * Written by Pawel W. Olszta, <olszta@sourceforge.net>\r
- * Creation date: Fri Dec 3 1999\r
- *\r
- * Permission is hereby granted, free of charge, to any person obtaining a\r
- * copy of this software and associated documentation files (the "Software"),\r
- * to deal in the Software without restriction, including without limitation\r
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,\r
- * and/or sell copies of the Software, and to permit persons to whom the\r
- * Software is furnished to do so, subject to the following conditions:\r
- *\r
- * The above copyright notice and this permission notice shall be included\r
- * in all copies or substantial portions of the Software.\r
- *\r
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS\r
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL\r
- * PAWEL W. OLSZTA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\r
- * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
- */\r
-\r
-#define FREEGLUT_BUILDING_LIB\r
-#include <GL/freeglut.h>\r
-#include "freeglut_internal.h"\r
-\r
-#if TARGET_HOST_POSIX_X11\r
-#include <limits.h> /* LONG_MAX */\r
-#include <unistd.h> /* usleep */\r
-#endif\r
-\r
-#if defined(_WIN32_WCE)\r
-# include <Aygshell.h>\r
-# ifdef FREEGLUT_LIB_PRAGMAS\r
-# pragma comment( lib, "Aygshell.lib" )\r
-# endif\r
-#endif /* defined(_WIN32_WCE) */\r
-\r
-\r
-#if TARGET_HOST_POSIX_X11\r
-#ifndef GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB\r
-#define GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB 0x20B2\r
-#endif\r
-\r
-#ifndef GLX_CONTEXT_MAJOR_VERSION_ARB\r
-#define GLX_CONTEXT_MAJOR_VERSION_ARB 0x2091\r
-#endif\r
-\r
-#ifndef GLX_CONTEXT_MINOR_VERSION_ARB\r
-#define GLX_CONTEXT_MINOR_VERSION_ARB 0x2092\r
-#endif\r
-\r
-#ifndef GLX_CONTEXT_FLAGS_ARB\r
-#define GLX_CONTEXT_FLAGS_ARB 0x2094\r
-#endif\r
-\r
-#ifndef GLX_CONTEXT_PROFILE_MASK_ARB\r
-#define GLX_CONTEXT_PROFILE_MASK_ARB 0x9126\r
-#endif\r
-\r
-#ifndef GLX_CONTEXT_DEBUG_BIT_ARB\r
-#define GLX_CONTEXT_DEBUG_BIT_ARB 0x0001\r
-#endif\r
-\r
-#ifndef GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB\r
-#define GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB 0x0002\r
-#endif\r
-\r
-#ifndef GLX_CONTEXT_CORE_PROFILE_BIT_ARB\r
-#define GLX_CONTEXT_CORE_PROFILE_BIT_ARB 0x00000001\r
-#endif\r
-\r
-#ifndef GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB\r
-#define GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002\r
-#endif\r
-\r
-#ifndef GLX_RGBA_FLOAT_TYPE\r
-#define GLX_RGBA_FLOAT_TYPE 0x20B9\r
-#endif\r
-\r
-#ifndef GLX_RGBA_FLOAT_BIT\r
-#define GLX_RGBA_FLOAT_BIT 0x00000004\r
-#endif\r
-#endif /* TARGET_HOST_POSIX_X11 */\r
-\r
-\r
-#if TARGET_HOST_MS_WINDOWS\r
-/* The following include file is available from SGI but is not standard:\r
- * #include <GL/wglext.h>\r
- * So we copy the necessary parts out of it.\r
- * XXX: should local definitions for extensions be put in a separate include file?\r
- */\r
-typedef const char * (WINAPI * PFNWGLGETEXTENSIONSSTRINGARBPROC) (HDC hdc);\r
-\r
-typedef BOOL (WINAPI * PFNWGLCHOOSEPIXELFORMATARBPROC) (HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats);\r
-\r
-#define WGL_DRAW_TO_WINDOW_ARB 0x2001\r
-#define WGL_ACCELERATION_ARB 0x2003\r
-#define WGL_SUPPORT_OPENGL_ARB 0x2010\r
-#define WGL_DOUBLE_BUFFER_ARB 0x2011\r
-#define WGL_COLOR_BITS_ARB 0x2014\r
-#define WGL_ALPHA_BITS_ARB 0x201B\r
-#define WGL_DEPTH_BITS_ARB 0x2022\r
-#define WGL_STENCIL_BITS_ARB 0x2023\r
-#define WGL_FULL_ACCELERATION_ARB 0x2027\r
-\r
-#define WGL_SAMPLE_BUFFERS_ARB 0x2041\r
-#define WGL_SAMPLES_ARB 0x2042\r
-\r
-#define WGL_TYPE_RGBA_FLOAT_ARB 0x21A0\r
-\r
-#define WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB 0x20A9\r
-\r
-#ifndef WGL_ARB_create_context\r
-#define WGL_ARB_create_context 1\r
-#ifdef WGL_WGLEXT_PROTOTYPES\r
-extern HGLRC WINAPI wglCreateContextAttribsARB (HDC, HGLRC, const int *);\r
-#endif /* WGL_WGLEXT_PROTOTYPES */\r
-typedef HGLRC (WINAPI * PFNWGLCREATECONTEXTATTRIBSARBPROC) (HDC hDC, HGLRC hShareContext, const int *attribList);\r
-\r
-#define WGL_CONTEXT_MAJOR_VERSION_ARB 0x2091\r
-#define WGL_CONTEXT_MINOR_VERSION_ARB 0x2092\r
-#define WGL_CONTEXT_LAYER_PLANE_ARB 0x2093\r
-#define WGL_CONTEXT_FLAGS_ARB 0x2094\r
-#define WGL_CONTEXT_PROFILE_MASK_ARB 0x9126\r
-\r
-#define WGL_CONTEXT_DEBUG_BIT_ARB 0x0001\r
-#define WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB 0x0002\r
-\r
-#define WGL_CONTEXT_CORE_PROFILE_BIT_ARB 0x00000001\r
-#define WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002\r
-\r
-#define ERROR_INVALID_VERSION_ARB 0x2095\r
-#define ERROR_INVALID_PROFILE_ARB 0x2096\r
-#endif\r
-\r
-#endif /* TARGET_HOST_MS_WINDOWS */\r
-\r
-#ifdef WM_TOUCH\r
- typedef BOOL (WINAPI *pRegisterTouchWindow)(HWND,ULONG);\r
- static pRegisterTouchWindow fghRegisterTouchWindow = (pRegisterTouchWindow)0xDEADBEEF;\r
-#endif\r
-\r
-/* pushing attribute/value pairs into an array */\r
-#define ATTRIB(a) attributes[where++]=(a)\r
-#define ATTRIB_VAL(a,v) {ATTRIB(a); ATTRIB(v);}\r
-\r
-/*\r
- * TODO BEFORE THE STABLE RELEASE:\r
- *\r
- * fgChooseFBConfig() -- OK, but what about glutInitDisplayString()?\r
- * fgSetupPixelFormat -- ignores the display mode settings\r
- * fgOpenWindow() -- check the Win32 version, -iconic handling!\r
- * fgCloseWindow() -- check the Win32 version\r
- * glutCreateWindow() -- Check when default position and size is {-1,-1}\r
- * glutCreateSubWindow() -- Check when default position and size is {-1,-1}\r
- * glutDestroyWindow() -- check the Win32 version\r
- * glutSetWindow() -- check the Win32 version\r
- * glutGetWindow() -- OK\r
- * glutSetWindowTitle() -- check the Win32 version\r
- * glutSetIconTitle() -- check the Win32 version\r
- * glutShowWindow() -- check the Win32 version\r
- * glutHideWindow() -- check the Win32 version\r
- * glutIconifyWindow() -- check the Win32 version\r
- * glutReshapeWindow() -- check the Win32 version\r
- * glutPositionWindow() -- check the Win32 version\r
- * glutPushWindow() -- check the Win32 version\r
- * glutPopWindow() -- check the Win32 version\r
- */\r
-\r
-/* -- PRIVATE FUNCTIONS ---------------------------------------------------- */\r
-\r
-static int fghIsLegacyContextVersionRequested( void )\r
-{\r
- return fgState.MajorVersion < 2 || (fgState.MajorVersion == 2 && fgState.MinorVersion <= 1);\r
-}\r
-\r
-static int fghIsLegacyContextRequested( void )\r
-{\r
- return fghIsLegacyContextVersionRequested() &&\r
- fgState.ContextFlags == 0 &&\r
- fgState.ContextProfile == 0;\r
-}\r
-\r
-static int fghNumberOfAuxBuffersRequested( void )\r
-{\r
- if ( fgState.DisplayMode & GLUT_AUX4 ) {\r
- return 4;\r
- }\r
- if ( fgState.DisplayMode & GLUT_AUX3 ) {\r
- return 3;\r
- }\r
- if ( fgState.DisplayMode & GLUT_AUX2 ) {\r
- return 2;\r
- }\r
- if ( fgState.DisplayMode & GLUT_AUX1 ) { /* NOTE: Same as GLUT_AUX! */\r
- return fgState.AuxiliaryBufferNumber;\r
- }\r
- return 0;\r
-}\r
-\r
-static int fghMapBit( int mask, int from, int to )\r
-{\r
- return ( mask & from ) ? to : 0;\r
-\r
-}\r
-\r
-static void fghContextCreationError( void )\r
-{\r
- fgError( "Unable to create OpenGL %d.%d context (flags %x, profile %x)",\r
- fgState.MajorVersion, fgState.MinorVersion, fgState.ContextFlags,\r
- fgState.ContextProfile );\r
-}\r
-\r
-\r
-/* -- SYSTEM-DEPENDENT PRIVATE FUNCTIONS ------------------------------------ */\r
-\r
-#if TARGET_HOST_POSIX_X11\r
-/*\r
- * Chooses a visual basing on the current display mode settings\r
- */\r
-\r
-GLXFBConfig* fgChooseFBConfig( int *numcfgs )\r
-{\r
- GLboolean wantIndexedMode = GL_FALSE;\r
- int attributes[ 100 ];\r
- int where = 0, numAuxBuffers;\r
-\r
- /* First we have to process the display mode settings... */\r
- if( fgState.DisplayMode & GLUT_INDEX ) {\r
- ATTRIB_VAL( GLX_BUFFER_SIZE, 8 );\r
- /* Buffer size is selected later. */\r
-\r
- ATTRIB_VAL( GLX_RENDER_TYPE, GLX_COLOR_INDEX_BIT );\r
- wantIndexedMode = GL_TRUE;\r
- } else {\r
- ATTRIB_VAL( GLX_RED_SIZE, 1 );\r
- ATTRIB_VAL( GLX_GREEN_SIZE, 1 );\r
- ATTRIB_VAL( GLX_BLUE_SIZE, 1 );\r
- if( fgState.DisplayMode & GLUT_ALPHA ) {\r
- ATTRIB_VAL( GLX_ALPHA_SIZE, 1 );\r
- }\r
- }\r
-\r
- if( fgState.DisplayMode & GLUT_DOUBLE ) {\r
- ATTRIB_VAL( GLX_DOUBLEBUFFER, True );\r
- }\r
-\r
- if( fgState.DisplayMode & GLUT_STEREO ) {\r
- ATTRIB_VAL( GLX_STEREO, True );\r
- }\r
-\r
- if( fgState.DisplayMode & GLUT_DEPTH ) {\r
- ATTRIB_VAL( GLX_DEPTH_SIZE, 1 );\r
- }\r
-\r
- if( fgState.DisplayMode & GLUT_STENCIL ) {\r
- ATTRIB_VAL( GLX_STENCIL_SIZE, 1 );\r
- }\r
-\r
- if( fgState.DisplayMode & GLUT_ACCUM ) {\r
- ATTRIB_VAL( GLX_ACCUM_RED_SIZE, 1 );\r
- ATTRIB_VAL( GLX_ACCUM_GREEN_SIZE, 1 );\r
- ATTRIB_VAL( GLX_ACCUM_BLUE_SIZE, 1 );\r
- if( fgState.DisplayMode & GLUT_ALPHA ) {\r
- ATTRIB_VAL( GLX_ACCUM_ALPHA_SIZE, 1 );\r
- }\r
- }\r
-\r
- numAuxBuffers = fghNumberOfAuxBuffersRequested();\r
- if ( numAuxBuffers > 0 ) {\r
- ATTRIB_VAL( GLX_AUX_BUFFERS, numAuxBuffers );\r
- }\r
-\r
- if( fgState.DisplayMode & GLUT_SRGB ) {\r
- ATTRIB_VAL( GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB, True );\r
- }\r
-\r
- if (fgState.DisplayMode & GLUT_MULTISAMPLE) {\r
- ATTRIB_VAL(GLX_SAMPLE_BUFFERS, 1);\r
- ATTRIB_VAL(GLX_SAMPLES, fgState.SampleNumber);\r
- }\r
-\r
- /* Push a terminator at the end of the list */\r
- ATTRIB( None );\r
-\r
- {\r
- GLXFBConfig * fbconfigArray; /* Array of FBConfigs */\r
- GLXFBConfig * fbconfig; /* The FBConfig we want */\r
- int fbconfigArraySize; /* Number of FBConfigs in the array */\r
-\r
-\r
- /* Get all FBConfigs that match "attributes". */\r
- fbconfigArray = glXChooseFBConfig( fgDisplay.Display,\r
- fgDisplay.Screen,\r
- attributes,\r
- &fbconfigArraySize );\r
-\r
- if (fbconfigArray != NULL)\r
- {\r
- int result; /* Returned by glXGetFBConfigAttrib, not checked. */\r
-\r
-\r
- if( wantIndexedMode )\r
- {\r
- /*\r
- * In index mode, we want the largest buffer size, i.e. visual\r
- * depth. Here, FBConfigs are sorted by increasing buffer size\r
- * first, so FBConfigs with the largest size come last.\r
- */\r
-\r
- int bufferSizeMin, bufferSizeMax;\r
-\r
- /* Get bufferSizeMin. */\r
- result =\r
- glXGetFBConfigAttrib( fgDisplay.Display,\r
- fbconfigArray[0],\r
- GLX_BUFFER_SIZE,\r
- &bufferSizeMin );\r
- /* Get bufferSizeMax. */\r
- result =\r
- glXGetFBConfigAttrib( fgDisplay.Display,\r
- fbconfigArray[fbconfigArraySize - 1],\r
- GLX_BUFFER_SIZE,\r
- &bufferSizeMax );\r
-\r
- if (bufferSizeMax > bufferSizeMin)\r
- {\r
- /* \r
- * Free and reallocate fbconfigArray, keeping only FBConfigs\r
- * with the largest buffer size.\r
- */\r
- XFree(fbconfigArray);\r
-\r
- /* Add buffer size token at the end of the list. */\r
- where--;\r
- ATTRIB_VAL( GLX_BUFFER_SIZE, bufferSizeMax );\r
- ATTRIB( None );\r
-\r
- fbconfigArray = glXChooseFBConfig( fgDisplay.Display,\r
- fgDisplay.Screen,\r
- attributes,\r
- &fbconfigArraySize );\r
- }\r
- }\r
-\r
- /*\r
- * We now have an array of FBConfigs, the first one being the "best"\r
- * one. So we should return only this FBConfig:\r
- *\r
- * int fbconfigXID;\r
- *\r
- * - pick the XID of the FBConfig we want\r
- * result = glXGetFBConfigAttrib( fgDisplay.Display,\r
- * fbconfigArray[0],\r
- * GLX_FBCONFIG_ID,\r
- * &fbconfigXID );\r
- *\r
- * - free the array\r
- * XFree(fbconfigArray);\r
- *\r
- * - reset "attributes" with the XID\r
- * where = 0;\r
- * ATTRIB_VAL( GLX_FBCONFIG_ID, fbconfigXID );\r
- * ATTRIB( None );\r
- *\r
- * - get our FBConfig only\r
- * fbconfig = glXChooseFBConfig( fgDisplay.Display,\r
- * fgDisplay.Screen,\r
- * attributes,\r
- * &fbconfigArraySize );\r
- *\r
- * However, for some configurations (for instance multisampling with\r
- * Mesa 6.5.2 and ATI drivers), this does not work:\r
- * glXChooseFBConfig returns NULL, whereas fbconfigXID is a valid\r
- * XID. Further investigation is needed.\r
- *\r
- * So, for now, we return the whole array of FBConfigs. This should\r
- * not produce any side effects elsewhere.\r
- */\r
- fbconfig = fbconfigArray;\r
- }\r
- else\r
- {\r
- fbconfig = NULL;\r
- }\r
-\r
- if (numcfgs)\r
- *numcfgs = fbconfigArraySize;\r
-\r
- return fbconfig;\r
- }\r
-}\r
-\r
-\r
-static void fghFillContextAttributes( int *attributes ) {\r
- int where = 0, contextFlags, contextProfile;\r
-\r
- if ( !fghIsLegacyContextVersionRequested() ) {\r
- ATTRIB_VAL( GLX_CONTEXT_MAJOR_VERSION_ARB, fgState.MajorVersion );\r
- ATTRIB_VAL( GLX_CONTEXT_MINOR_VERSION_ARB, fgState.MinorVersion );\r
- }\r
-\r
- contextFlags =\r
- fghMapBit( fgState.ContextFlags, GLUT_DEBUG, GLX_CONTEXT_DEBUG_BIT_ARB ) |\r
- fghMapBit( fgState.ContextFlags, GLUT_FORWARD_COMPATIBLE, GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB );\r
- if ( contextFlags != 0 ) {\r
- ATTRIB_VAL( GLX_CONTEXT_FLAGS_ARB, contextFlags );\r
- }\r
-\r
- contextProfile =\r
- fghMapBit( fgState.ContextProfile, GLUT_CORE_PROFILE, GLX_CONTEXT_CORE_PROFILE_BIT_ARB ) |\r
- fghMapBit( fgState.ContextProfile, GLUT_COMPATIBILITY_PROFILE, GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB );\r
- if ( contextProfile != 0 ) {\r
- ATTRIB_VAL( GLX_CONTEXT_PROFILE_MASK_ARB, contextProfile );\r
- }\r
-\r
- ATTRIB( 0 );\r
-}\r
-\r
-typedef GLXContext (*CreateContextAttribsProc)(Display *dpy, GLXFBConfig config,\r
- GLXContext share_list, Bool direct,\r
- const int *attrib_list);\r
-\r
-static GLXContext fghCreateNewContext( SFG_Window* window )\r
-{\r
- /* for color model calculation */\r
- int menu = ( window->IsMenu && !fgStructure.MenuContext );\r
- int index_mode = ( fgState.DisplayMode & GLUT_INDEX );\r
-\r
- /* "classic" context creation */\r
- Display *dpy = fgDisplay.Display;\r
- GLXFBConfig config = *(window->Window.FBConfig);\r
- int render_type = ( !menu && index_mode ) ? GLX_COLOR_INDEX_TYPE : GLX_RGBA_TYPE;\r
- GLXContext share_list = NULL;\r
- Bool direct = ( fgState.DirectContext != GLUT_FORCE_INDIRECT_CONTEXT );\r
- GLXContext context;\r
-\r
- /* new context creation */\r
- int attributes[9];\r
- CreateContextAttribsProc createContextAttribs = (CreateContextAttribsProc) fghGetProcAddress( "glXCreateContextAttribsARB" );\r
- \r
- /* glXCreateContextAttribsARB not found, yet the user has requested the new context creation */\r
- if ( !createContextAttribs && !fghIsLegacyContextRequested() ) {\r
- fgWarning( "OpenGL >2.1 context requested but glXCreateContextAttribsARB is not available! Falling back to legacy context creation" );\r
- fgState.MajorVersion = 2;\r
- fgState.MinorVersion = 1;\r
- }\r
-\r
- /* If nothing fancy has been required, simply use the old context creation GLX API entry */\r
- if ( fghIsLegacyContextRequested() || !createContextAttribs )\r
- {\r
- context = glXCreateNewContext( dpy, config, render_type, share_list, direct );\r
- if ( context == NULL ) {\r
- fghContextCreationError();\r
- }\r
- return context;\r
- }\r
-\r
- /* color index mode is not available anymore with OpenGL 3.0 */\r
- if ( render_type == GLX_COLOR_INDEX_TYPE ) {\r
- fgWarning( "color index mode is deprecated, using RGBA mode" );\r
- }\r
-\r
- fghFillContextAttributes( attributes );\r
-\r
- context = createContextAttribs( dpy, config, share_list, direct, attributes );\r
- if ( context == NULL ) {\r
- fghContextCreationError();\r
- }\r
- return context;\r
-}\r
-\r
-\r
-#define _NET_WM_STATE_TOGGLE 2\r
-static int fghResizeFullscrToggle(void)\r
-{\r
- XWindowAttributes attributes;\r
-\r
- if(glutGet(GLUT_FULL_SCREEN)) {\r
- /* restore original window size */\r
- SFG_Window *win = fgStructure.CurrentWindow;\r
- fgStructure.CurrentWindow->State.NeedToResize = GL_TRUE;\r
- fgStructure.CurrentWindow->State.Width = win->State.OldWidth;\r
- fgStructure.CurrentWindow->State.Height = win->State.OldHeight;\r
-\r
- } else {\r
- /* resize the window to cover the entire screen */\r
- XGetWindowAttributes(fgDisplay.Display,\r
- fgStructure.CurrentWindow->Window.Handle,\r
- &attributes);\r
- \r
- /*\r
- * The "x" and "y" members of "attributes" are the window's coordinates\r
- * relative to its parent, i.e. to the decoration window.\r
- */\r
- XMoveResizeWindow(fgDisplay.Display,\r
- fgStructure.CurrentWindow->Window.Handle,\r
- -attributes.x,\r
- -attributes.y,\r
- fgDisplay.ScreenWidth,\r
- fgDisplay.ScreenHeight);\r
- }\r
- return 0;\r
-}\r
-\r
-static int fghEwmhFullscrToggle(void)\r
-{\r
- XEvent xev;\r
- long evmask = SubstructureRedirectMask | SubstructureNotifyMask;\r
-\r
- if(!fgDisplay.State || !fgDisplay.StateFullScreen) {\r
- return -1;\r
- }\r
-\r
- xev.type = ClientMessage;\r
- xev.xclient.window = fgStructure.CurrentWindow->Window.Handle;\r
- xev.xclient.message_type = fgDisplay.State;\r
- xev.xclient.format = 32;\r
- xev.xclient.data.l[0] = _NET_WM_STATE_TOGGLE;\r
- xev.xclient.data.l[1] = fgDisplay.StateFullScreen;\r
- xev.xclient.data.l[2] = 0; /* no second property to toggle */\r
- xev.xclient.data.l[3] = 1; /* source indication: application */\r
- xev.xclient.data.l[4] = 0; /* unused */\r
-\r
- if(!XSendEvent(fgDisplay.Display, fgDisplay.RootWindow, 0, evmask, &xev)) {\r
- return -1;\r
- }\r
- return 0;\r
-}\r
-\r
-static int fghToggleFullscreen(void)\r
-{\r
- /* first try the EWMH (_NET_WM_STATE) method ... */\r
- if(fghEwmhFullscrToggle() != -1) {\r
- return 0;\r
- }\r
-\r
- /* fall back to resizing the window */\r
- if(fghResizeFullscrToggle() != -1) {\r
- return 0;\r
- }\r
- return -1;\r
-}\r
-\r
-\r
-#endif /* TARGET_HOST_POSIX_X11 */\r
-\r
-\r
-#if TARGET_HOST_MS_WINDOWS\r
-/*\r
- * Setup the pixel format for a Win32 window\r
- */\r
-\r
-#if defined(_WIN32_WCE)\r
-static wchar_t* fghWstrFromStr(const char* str)\r
-{\r
- int i,len=strlen(str);\r
- wchar_t* wstr = (wchar_t*)malloc(2*len+2);\r
- for(i=0; i<len; i++)\r
- wstr[i] = str[i];\r
- wstr[len] = 0;\r
- return wstr;\r
-}\r
-#endif /* defined(_WIN32_WCE) */\r
-\r
-\r
-static void fghFillContextAttributes( int *attributes ) {\r
- int where = 0, contextFlags, contextProfile;\r
-\r
- if ( !fghIsLegacyContextVersionRequested() ) {\r
- ATTRIB_VAL( WGL_CONTEXT_MAJOR_VERSION_ARB, fgState.MajorVersion );\r
- ATTRIB_VAL( WGL_CONTEXT_MINOR_VERSION_ARB, fgState.MinorVersion );\r
- }\r
-\r
- contextFlags =\r
- fghMapBit( fgState.ContextFlags, GLUT_DEBUG, WGL_CONTEXT_DEBUG_BIT_ARB ) |\r
- fghMapBit( fgState.ContextFlags, GLUT_FORWARD_COMPATIBLE, WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB );\r
- if ( contextFlags != 0 ) {\r
- ATTRIB_VAL( WGL_CONTEXT_FLAGS_ARB, contextFlags );\r
- }\r
-\r
- contextProfile =\r
- fghMapBit( fgState.ContextProfile, GLUT_CORE_PROFILE, WGL_CONTEXT_CORE_PROFILE_BIT_ARB ) |\r
- fghMapBit( fgState.ContextProfile, GLUT_COMPATIBILITY_PROFILE, WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB );\r
- if ( contextProfile != 0 ) {\r
- ATTRIB_VAL( WGL_CONTEXT_PROFILE_MASK_ARB, contextProfile );\r
- }\r
-\r
- ATTRIB( 0 );\r
-}\r
-\r
-static int fghIsExtensionSupported( HDC hdc, const char *extension ) {\r
- const char *pWglExtString;\r
- PFNWGLGETEXTENSIONSSTRINGARBPROC wglGetEntensionsStringARB =\r
- (PFNWGLGETEXTENSIONSSTRINGARBPROC) wglGetProcAddress("wglGetExtensionsStringARB");\r
- if ( wglGetEntensionsStringARB == NULL )\r
- {\r
- return FALSE;\r
- }\r
- pWglExtString = wglGetEntensionsStringARB( hdc );\r
- return ( pWglExtString != NULL ) && ( strstr(pWglExtString, extension) != NULL );\r
-}\r
-\r
-void fgNewWGLCreateContext( SFG_Window* window )\r
-{\r
- HGLRC context;\r
- int attributes[9];\r
- PFNWGLCREATECONTEXTATTRIBSARBPROC wglCreateContextAttribsARB;\r
-\r
- /* If nothing fancy has been required, leave the context as it is */\r
- if ( fghIsLegacyContextRequested() )\r
- {\r
- return;\r
- }\r
-\r
- wglMakeCurrent( window->Window.Device, window->Window.Context );\r
-\r
- if ( !fghIsExtensionSupported( window->Window.Device, "WGL_ARB_create_context" ) )\r
- {\r
- return;\r
- }\r
-\r
- /* new context creation */\r
- fghFillContextAttributes( attributes );\r
-\r
- wglCreateContextAttribsARB = (PFNWGLCREATECONTEXTATTRIBSARBPROC) wglGetProcAddress( "wglCreateContextAttribsARB" );\r
- if ( wglCreateContextAttribsARB == NULL )\r
- {\r
- fgError( "wglCreateContextAttribsARB not found" );\r
- }\r
-\r
- context = wglCreateContextAttribsARB( window->Window.Device, 0, attributes );\r
- if ( context == NULL )\r
- {\r
- fghContextCreationError();\r
- }\r
-\r
- wglMakeCurrent( NULL, NULL );\r
- wglDeleteContext( window->Window.Context );\r
- window->Window.Context = context;\r
-}\r
-\r
-#if !defined(_WIN32_WCE)\r
-\r
-static void fghFillPFD( PIXELFORMATDESCRIPTOR *ppfd, HDC hdc, unsigned char layer_type )\r
-{\r
- int flags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL;\r
- if ( fgState.DisplayMode & GLUT_DOUBLE ) {\r
- flags |= PFD_DOUBLEBUFFER;\r
- }\r
- if ( fgState.DisplayMode & GLUT_STEREO ) {\r
- flags |= PFD_STEREO;\r
- }\r
-\r
-#if defined(_MSC_VER)\r
-#pragma message( "fgSetupPixelFormat(): there is still some work to do here!" )\r
-#endif\r
-\r
- /* Specify which pixel format do we opt for... */\r
- ppfd->nSize = sizeof(PIXELFORMATDESCRIPTOR);\r
- ppfd->nVersion = 1;\r
- ppfd->dwFlags = flags;\r
-\r
- if( fgState.DisplayMode & GLUT_INDEX ) {\r
- ppfd->iPixelType = PFD_TYPE_COLORINDEX;\r
- ppfd->cRedBits = 0;\r
- ppfd->cGreenBits = 0;\r
- ppfd->cBlueBits = 0;\r
- ppfd->cAlphaBits = 0;\r
- } else {\r
- ppfd->iPixelType = PFD_TYPE_RGBA;\r
- ppfd->cRedBits = 8;\r
- ppfd->cGreenBits = 8;\r
- ppfd->cBlueBits = 8;\r
- ppfd->cAlphaBits = ( fgState.DisplayMode & GLUT_ALPHA ) ? 8 : 0;\r
- }\r
-\r
- ppfd->cColorBits = 24;\r
- ppfd->cRedShift = 0;\r
- ppfd->cGreenShift = 0;\r
- ppfd->cBlueShift = 0;\r
- ppfd->cAlphaShift = 0;\r
- ppfd->cAccumBits = ( fgState.DisplayMode & GLUT_ACCUM ) ? 1 : 0;\r
- ppfd->cAccumRedBits = 0;\r
- ppfd->cAccumGreenBits = 0;\r
- ppfd->cAccumBlueBits = 0;\r
- ppfd->cAccumAlphaBits = 0;\r
-\r
- /* Hmmm, or 32/0 instead of 24/8? */\r
- ppfd->cDepthBits = 24;\r
- ppfd->cStencilBits = 8;\r
-\r
- ppfd->cAuxBuffers = fghNumberOfAuxBuffersRequested();\r
- ppfd->iLayerType = layer_type;\r
- ppfd->bReserved = 0;\r
- ppfd->dwLayerMask = 0;\r
- ppfd->dwVisibleMask = 0;\r
- ppfd->dwDamageMask = 0;\r
- \r
- ppfd->cColorBits = (BYTE) GetDeviceCaps( hdc, BITSPIXEL );\r
-}\r
-\r
-static void fghFillPixelFormatAttributes( int *attributes, const PIXELFORMATDESCRIPTOR *ppfd )\r
-{\r
- int where = 0;\r
-\r
- ATTRIB_VAL( WGL_DRAW_TO_WINDOW_ARB, GL_TRUE );\r
- ATTRIB_VAL( WGL_SUPPORT_OPENGL_ARB, GL_TRUE );\r
- ATTRIB_VAL( WGL_ACCELERATION_ARB, WGL_FULL_ACCELERATION_ARB );\r
-\r
- ATTRIB_VAL( WGL_COLOR_BITS_ARB, ppfd->cColorBits );\r
- ATTRIB_VAL( WGL_ALPHA_BITS_ARB, ppfd->cAlphaBits );\r
- ATTRIB_VAL( WGL_DEPTH_BITS_ARB, ppfd->cDepthBits );\r
- ATTRIB_VAL( WGL_STENCIL_BITS_ARB, ppfd->cStencilBits );\r
-\r
- ATTRIB_VAL( WGL_DOUBLE_BUFFER_ARB, ( fgState.DisplayMode & GLUT_DOUBLE ) != 0 );\r
-\r
- if ( fgState.DisplayMode & GLUT_SRGB ) {\r
- ATTRIB_VAL( WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB, TRUE );\r
- }\r
-\r
- ATTRIB_VAL( WGL_SAMPLE_BUFFERS_ARB, GL_TRUE );\r
- ATTRIB_VAL( WGL_SAMPLES_ARB, fgState.SampleNumber );\r
- ATTRIB( 0 );\r
-}\r
-#endif\r
-\r
-GLboolean fgSetupPixelFormat( SFG_Window* window, GLboolean checkOnly,\r
- unsigned char layer_type )\r
-{\r
-#if defined(_WIN32_WCE)\r
- return GL_TRUE;\r
-#else\r
- PIXELFORMATDESCRIPTOR pfd;\r
- PIXELFORMATDESCRIPTOR* ppfd = &pfd;\r
- int pixelformat;\r
- HDC current_hDC;\r
- GLboolean success;\r
-\r
- if (checkOnly)\r
- current_hDC = CreateDC(TEXT("DISPLAY"), NULL ,NULL ,NULL);\r
- else\r
- current_hDC = window->Window.Device;\r
-\r
- fghFillPFD( ppfd, current_hDC, layer_type );\r
- pixelformat = ChoosePixelFormat( current_hDC, ppfd );\r
-\r
- /* windows hack for multismapling/sRGB */\r
- if ( ( fgState.DisplayMode & GLUT_MULTISAMPLE ) ||\r
- ( fgState.DisplayMode & GLUT_SRGB ) )\r
- { \r
- HGLRC rc, rc_before=wglGetCurrentContext();\r
- HWND hWnd;\r
- HDC hDC, hDC_before=wglGetCurrentDC();\r
- WNDCLASS wndCls;\r
-\r
- /* create a dummy window */\r
- ZeroMemory(&wndCls, sizeof(wndCls));\r
- wndCls.lpfnWndProc = DefWindowProc;\r
- wndCls.hInstance = fgDisplay.Instance;\r
- wndCls.style = CS_OWNDC | CS_HREDRAW | CS_VREDRAW;\r
- wndCls.lpszClassName = _T("FREEGLUT_dummy");\r
- RegisterClass( &wndCls );\r
-\r
- hWnd=CreateWindow(_T("FREEGLUT_dummy"), _T(""), WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_OVERLAPPEDWINDOW , 0,0,0,0, 0, 0, fgDisplay.Instance, 0 );\r
- hDC=GetDC(hWnd);\r
- SetPixelFormat( hDC, pixelformat, ppfd );\r
-\r
- rc = wglCreateContext( hDC );\r
- wglMakeCurrent(hDC, rc);\r
-\r
- if ( fghIsExtensionSupported( hDC, "WGL_ARB_multisample" ) )\r
- {\r
- PFNWGLCHOOSEPIXELFORMATARBPROC wglChoosePixelFormatARBProc =\r
- (PFNWGLCHOOSEPIXELFORMATARBPROC) wglGetProcAddress("wglChoosePixelFormatARB");\r
- if ( wglChoosePixelFormatARBProc )\r
- {\r
- int attributes[100];\r
- int iPixelFormat;\r
- BOOL bValid;\r
- float fAttributes[] = { 0, 0 };\r
- UINT numFormats;\r
- fghFillPixelFormatAttributes( attributes, ppfd );\r
- bValid = wglChoosePixelFormatARBProc(hDC, attributes, fAttributes, 1, &iPixelFormat, &numFormats);\r
-\r
- if ( bValid && numFormats > 0 )\r
- {\r
- pixelformat = iPixelFormat;\r
- }\r
- }\r
- }\r
-\r
- wglMakeCurrent( hDC_before, rc_before);\r
- wglDeleteContext(rc);\r
- ReleaseDC(hWnd, hDC);\r
- DestroyWindow(hWnd);\r
- UnregisterClass(_T("FREEGLUT_dummy"), fgDisplay.Instance);\r
- }\r
-\r
- success = ( pixelformat != 0 ) && ( checkOnly || SetPixelFormat( current_hDC, pixelformat, ppfd ) );\r
-\r
- if (checkOnly)\r
- DeleteDC(current_hDC);\r
-\r
- return success;\r
-#endif /* defined(_WIN32_WCE) */\r
-}\r
-\r
-#endif /* TARGET_HOST_MS_WINDOWS */\r
-\r
-/*\r
- * Sets the OpenGL context and the fgStructure "Current Window" pointer to\r
- * the window structure passed in.\r
- */\r
-void fgSetWindow ( SFG_Window *window )\r
-{\r
-#if TARGET_HOST_POSIX_X11\r
- if ( window )\r
- {\r
- glXMakeContextCurrent(\r
- fgDisplay.Display,\r
- window->Window.Handle,\r
- window->Window.Handle,\r
- window->Window.Context\r
- );\r
- }\r
-#elif TARGET_HOST_MS_WINDOWS\r
- if ( window != fgStructure.CurrentWindow )\r
- {\r
- if( fgStructure.CurrentWindow )\r
- ReleaseDC( fgStructure.CurrentWindow->Window.Handle,\r
- fgStructure.CurrentWindow->Window.Device );\r
-\r
- if ( window )\r
- {\r
- window->Window.Device = GetDC( window->Window.Handle );\r
- wglMakeCurrent(\r
- window->Window.Device,\r
- window->Window.Context\r
- );\r
- }\r
- }\r
-#endif\r
- fgStructure.CurrentWindow = window;\r
-}\r
-\r
-#if TARGET_HOST_MS_WINDOWS\r
-\r
-/* Computes position of corners of window Rect (outer position including\r
- * decorations) based on the provided client rect and based on the style\r
- * of the window in question.\r
- * If posIsOutside is set to true, the input client Rect is taken to follow\r
- * freeGLUT's window specification convention in which the top-left corner\r
- * is at the outside of the window, while the size\r
- * (rect.right-rect.left,rect.bottom-rect.top) is the size of the drawable\r
- * area.\r
- */\r
-void fghComputeWindowRectFromClientArea_UseStyle( const DWORD windowStyle, RECT *clientRect, BOOL posIsOutside )\r
-{\r
- int xBorderWidth = 0, yBorderWidth = 0;\r
-\r
- /* If window has title bar, correct rect for it */\r
- 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
- if (posIsOutside)\r
- clientRect->bottom += GetSystemMetrics( SM_CYCAPTION );\r
- else\r
- clientRect->top -= GetSystemMetrics( SM_CYCAPTION );\r
-\r
- /* get width of window's borders (frame), correct rect for it.\r
- * Note, borders can be of zero width if style does not specify borders\r
- */\r
- fghGetBorderWidth(windowStyle, &xBorderWidth, &yBorderWidth);\r
- if (posIsOutside)\r
- {\r
- clientRect->right += xBorderWidth * 2;\r
- clientRect->bottom += yBorderWidth * 2;\r
- }\r
- else\r
- {\r
- clientRect->left -= xBorderWidth;\r
- clientRect->right += xBorderWidth;\r
- clientRect->top -= yBorderWidth;\r
- clientRect->bottom += yBorderWidth;\r
- }\r
-}\r
-\r
-/* Computes position of corners of window Rect (outer position including\r
- * decorations) based on the provided client rect and based on the style\r
- * of the window in question. If the window pointer or the window handle\r
- * is NULL, a fully decorated window (caption and border) is assumed.\r
- * Furthermore, if posIsOutside is set to true, the input client Rect is\r
- * taken to follow freeGLUT's window specification convention in which the\r
- * top-left corner is at the outside of the window, while the size\r
- * (rect.right-rect.left,rect.bottom-rect.top) is the size of the drawable\r
- * area.\r
-*/\r
-void fghComputeWindowRectFromClientArea_QueryWindow( const SFG_Window *window, RECT *clientRect, BOOL posIsOutside )\r
-{\r
- DWORD windowStyle = 0;\r
-\r
- if (window && window->Window.Handle)\r
- windowStyle = GetWindowLong(window->Window.Handle, GWL_STYLE);\r
- else\r
- windowStyle = WS_OVERLAPPEDWINDOW;\r
-\r
- fghComputeWindowRectFromClientArea_UseStyle(windowStyle, clientRect, posIsOutside);\r
-}\r
-\r
-/* Computes position of corners of client area (drawable area) of a window\r
- * based on the provided window Rect (outer position including decorations)\r
- * and based on the style of the window in question. If the window pointer\r
- * or the window handle is NULL, a fully decorated window (caption and\r
- * border) is assumed.\r
- * Furthermore, if wantPosOutside is set to true, the output client Rect\r
- * will follow freeGLUT's window specification convention in which the\r
- * top-left corner is at the outside of the window, the size\r
- * (rect.right-rect.left,rect.bottom-rect.top) is the size of the drawable\r
- * area.\r
- */\r
-void fghComputeClientAreaFromWindowRect( const SFG_Window *window, RECT *windowRect, BOOL wantPosOutside )\r
-{\r
- DWORD windowStyle = 0;\r
- int xBorderWidth = 0, yBorderWidth = 0;\r
-\r
- if (window && window->Window.Handle)\r
- windowStyle = GetWindowLong(window->Window.Handle, GWL_STYLE);\r
- else\r
- windowStyle = WS_OVERLAPPEDWINDOW;\r
-\r
- /* If window has title bar, correct rect for it */\r
- 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
- if (wantPosOutside)\r
- windowRect->bottom -= GetSystemMetrics( SM_CYCAPTION );\r
- else\r
- windowRect->top += GetSystemMetrics( SM_CYCAPTION );\r
-\r
- /* get width of window's borders (frame), correct rect for it.\r
- * Note, borders can be of zero width if style does not specify borders\r
- */\r
- fghGetBorderWidth(windowStyle, &xBorderWidth, &yBorderWidth);\r
- if (wantPosOutside)\r
- {\r
- windowRect->right -= xBorderWidth * 2;\r
- windowRect->bottom -= yBorderWidth * 2;\r
- }\r
- else\r
- {\r
- windowRect->left += xBorderWidth;\r
- windowRect->right -= xBorderWidth;\r
- windowRect->top += yBorderWidth;\r
- windowRect->bottom -= yBorderWidth;\r
- }\r
-}\r
-\r
-/* Gets the rect describing the client area (drawable area) of the\r
- * specified window.\r
- * Returns an empty rect if window pointer or window handle is NULL.\r
- * If wantPosOutside is set to true, the output client Rect\r
- * will follow freeGLUT's window specification convention in which the\r
- * top-left corner is at the outside of the window, while the size\r
- * (rect.right-rect.left,rect.bottom-rect.top) is the size of the drawable\r
- * area.\r
- */\r
-RECT fghGetClientArea( const SFG_Window *window, BOOL wantPosOutside )\r
-{\r
- RECT windowRect = {0,0,0,0};\r
-\r
- freeglut_return_val_if_fail((window && window->Window.Handle),windowRect);\r
- \r
- /*\r
- * call GetWindowRect()\r
- * (this returns the pixel coordinates of the outside of the window)\r
- */\r
- GetWindowRect( window->Window.Handle, &windowRect );\r
-\r
- /* Then correct the results */\r
- fghComputeClientAreaFromWindowRect(window, &windowRect, wantPosOutside);\r
-\r
- return windowRect;\r
-}\r
-\r
-/* Returns the width of the window borders based on the window's style.\r
- */\r
-void fghGetBorderWidth(const DWORD windowStyle, int* xBorderWidth, int* yBorderWidth)\r
-{\r
- if (windowStyle & WS_THICKFRAME)\r
- {\r
- *xBorderWidth = GetSystemMetrics(SM_CXSIZEFRAME);\r
- *yBorderWidth = GetSystemMetrics(SM_CYSIZEFRAME);\r
- }\r
- else if (windowStyle & WS_DLGFRAME)\r
- {\r
- *xBorderWidth = GetSystemMetrics(SM_CXFIXEDFRAME);\r
- *yBorderWidth = GetSystemMetrics(SM_CYFIXEDFRAME);\r
- }\r
- else\r
- {\r
- *xBorderWidth = 0;\r
- *yBorderWidth = 0;\r
- }\r
-}\r
-\r
-#if(WINVER >= 0x500)\r
-typedef struct\r
-{\r
- int *x;\r
- int *y;\r
- const char *name;\r
-} m_proc_t;\r
-\r
-static BOOL CALLBACK m_proc(HMONITOR mon,\r
- HDC hdc,\r
- LPRECT rect,\r
- LPARAM data)\r
-{\r
- m_proc_t *dp=(m_proc_t *)data;\r
- MONITORINFOEX info;\r
- BOOL res;\r
- info.cbSize=sizeof(info);\r
- res=GetMonitorInfo(mon,(LPMONITORINFO)&info);\r
- if( res )\r
- {\r
- if( strcmp(dp->name,info.szDevice)==0 )\r
- {\r
- *(dp->x)=info.rcMonitor.left;\r
- *(dp->y)=info.rcMonitor.top;\r
- return FALSE;\r
- }\r
- }\r
- return TRUE;\r
-}\r
-\r
-/* \r
- * this function returns the origin of the screen identified by\r
- * fgDisplay.DisplayName, and 0 otherwise.\r
- * This is used in fgOpenWindow to open the gamemode window on the screen\r
- * identified by the -display command line argument. The function should\r
- * not be called otherwise.\r
- */\r
-\r
-static void get_display_origin(int *xp,int *yp)\r
-{\r
- *xp = 0;\r
- *yp = 0;\r
-\r
- if( fgDisplay.DisplayName )\r
- {\r
- m_proc_t st;\r
- st.x=xp;\r
- st.y=yp;\r
- st.name=fgDisplay.DisplayName;\r
- EnumDisplayMonitors(0,0,m_proc,(LPARAM)&st);\r
- }\r
-}\r
-#else\r
-#pragma message( "-display parameter only works if compiled with WINVER >= 0x0500")\r
-\r
-static void get_display_origin(int *xp,int *yp)\r
-{\r
- *xp = 0;\r
- *yp = 0;\r
-\r
- if( fgDisplay.DisplayName )\r
- {\r
- fgWarning( "for working -display support FreeGLUT must be compiled with WINVER >= 0x0500");\r
- }\r
-}\r
-#endif\r
-#endif\r
-\r
-\r
-#if TARGET_HOST_POSIX_X11\r
-static Bool fghWindowIsVisible( Display *display, XEvent *event, XPointer arg)\r
-{\r
- Window window = (Window)arg;\r
- return (event->type == MapNotify) && (event->xmap.window == window);\r
-}\r
-#endif\r
-\r
-\r
-/*\r
- * Opens a window. Requires a SFG_Window object created and attached\r
- * to the freeglut structure. OpenGL context is created here.\r
- */\r
-void fgOpenWindow( SFG_Window* window, const char* title,\r
- GLboolean positionUse, int x, int y,\r
- GLboolean sizeUse, int w, int h,\r
- GLboolean gameMode, GLboolean isSubWindow )\r
-{\r
-#if TARGET_HOST_POSIX_X11\r
- XVisualInfo * visualInfo = NULL;\r
- XSetWindowAttributes winAttr;\r
- XTextProperty textProperty;\r
- XSizeHints sizeHints;\r
- XWMHints wmHints;\r
- XEvent eventReturnBuffer; /* return buffer required for a call */\r
- unsigned long mask;\r
- int num_FBConfigs, i;\r
- unsigned int current_DisplayMode = fgState.DisplayMode ;\r
-\r
- /* Save the display mode if we are creating a menu window */\r
- if( window->IsMenu && ( ! fgStructure.MenuContext ) )\r
- fgState.DisplayMode = GLUT_DOUBLE | GLUT_RGB ;\r
-\r
- window->Window.FBConfig = fgChooseFBConfig( &num_FBConfigs );\r
-\r
- if( window->IsMenu && ( ! fgStructure.MenuContext ) )\r
- fgState.DisplayMode = current_DisplayMode ;\r
-\r
- if( ! window->Window.FBConfig )\r
- {\r
- /*\r
- * The "fgChooseFBConfig" returned a null meaning that the visual\r
- * context is not available.\r
- * Try a couple of variations to see if they will work.\r
- */\r
- if( !( fgState.DisplayMode & GLUT_DOUBLE ) )\r
- {\r
- fgState.DisplayMode |= GLUT_DOUBLE ;\r
- window->Window.FBConfig = fgChooseFBConfig( &num_FBConfigs );\r
- fgState.DisplayMode &= ~GLUT_DOUBLE;\r
- }\r
-\r
- if( fgState.DisplayMode & GLUT_MULTISAMPLE )\r
- {\r
- fgState.DisplayMode &= ~GLUT_MULTISAMPLE ;\r
- window->Window.FBConfig = fgChooseFBConfig( &num_FBConfigs );\r
- fgState.DisplayMode |= GLUT_MULTISAMPLE;\r
- }\r
- }\r
-\r
- FREEGLUT_INTERNAL_ERROR_EXIT( window->Window.FBConfig != NULL,\r
- "FBConfig with necessary capabilities not found", "fgOpenWindow" );\r
-\r
- /* Get the X visual. */\r
- for (i = 0; i < num_FBConfigs; i++) {\r
- visualInfo = glXGetVisualFromFBConfig( fgDisplay.Display,\r
- window->Window.FBConfig[i] );\r
- if (visualInfo)\r
- break;\r
- }\r
-\r
- FREEGLUT_INTERNAL_ERROR_EXIT( visualInfo != NULL,\r
- "visualInfo could not be retrieved from FBConfig", "fgOpenWindow" );\r
-\r
- /*\r
- * XXX HINT: the masks should be updated when adding/removing callbacks.\r
- * XXX This might speed up message processing. Is that true?\r
- * XXX\r
- * XXX A: Not appreciably, but it WILL make it easier to debug.\r
- * XXX Try tracing old GLUT and try tracing freeglut. Old GLUT\r
- * XXX turns off events that it doesn't need and is a whole lot\r
- * XXX more pleasant to trace. (Think mouse-motion! Tons of\r
- * XXX ``bonus'' GUI events stream in.)\r
- */\r
- winAttr.event_mask =\r
- StructureNotifyMask | SubstructureNotifyMask | ExposureMask |\r
- ButtonPressMask | ButtonReleaseMask | KeyPressMask | KeyReleaseMask |\r
- VisibilityChangeMask | EnterWindowMask | LeaveWindowMask |\r
- PointerMotionMask | ButtonMotionMask;\r
- winAttr.background_pixmap = None;\r
- winAttr.background_pixel = 0;\r
- winAttr.border_pixel = 0;\r
-\r
- winAttr.colormap = XCreateColormap(\r
- fgDisplay.Display, fgDisplay.RootWindow,\r
- visualInfo->visual, AllocNone\r
- );\r
-\r
- mask = CWBackPixmap | CWBorderPixel | CWColormap | CWEventMask;\r
-\r
- if( window->IsMenu || ( gameMode == GL_TRUE ) )\r
- {\r
- winAttr.override_redirect = True;\r
- mask |= CWOverrideRedirect;\r
- }\r
-\r
- if( ! positionUse )\r
- x = y = -1; /* default window position */\r
- if( ! sizeUse )\r
- w = h = 300; /* default window size */\r
-\r
- window->Window.Handle = XCreateWindow(\r
- fgDisplay.Display,\r
- window->Parent == NULL ? fgDisplay.RootWindow :\r
- window->Parent->Window.Handle,\r
- x, y, w, h, 0,\r
- visualInfo->depth, InputOutput,\r
- visualInfo->visual, mask,\r
- &winAttr\r
- );\r
-\r
- /*\r
- * The GLX context creation, possibly trying the direct context rendering\r
- * or else use the current context if the user has so specified\r
- */\r
-\r
- if( window->IsMenu )\r
- {\r
- /*\r
- * If there isn't already an OpenGL rendering context for menu\r
- * windows, make one\r
- */\r
- if( !fgStructure.MenuContext )\r
- {\r
- fgStructure.MenuContext =\r
- (SFG_MenuContext *)malloc( sizeof(SFG_MenuContext) );\r
- fgStructure.MenuContext->MContext = fghCreateNewContext( window );\r
- }\r
-\r
- /* window->Window.Context = fgStructure.MenuContext->MContext; */\r
- window->Window.Context = fghCreateNewContext( window );\r
- }\r
- else if( fgState.UseCurrentContext )\r
- {\r
- window->Window.Context = glXGetCurrentContext( );\r
-\r
- if( ! window->Window.Context )\r
- window->Window.Context = fghCreateNewContext( window );\r
- }\r
- else\r
- window->Window.Context = fghCreateNewContext( window );\r
-\r
-#if !defined( __FreeBSD__ ) && !defined( __NetBSD__ )\r
- if( !glXIsDirect( fgDisplay.Display, window->Window.Context ) )\r
- {\r
- if( fgState.DirectContext == GLUT_FORCE_DIRECT_CONTEXT )\r
- fgError( "Unable to force direct context rendering for window '%s'",\r
- title );\r
- }\r
-#endif\r
-\r
- /*\r
- * XXX Assume the new window is visible by default\r
- * XXX Is this a safe assumption?\r
- */\r
- window->State.Visible = GL_TRUE;\r
-\r
- sizeHints.flags = 0;\r
- if ( positionUse )\r
- sizeHints.flags |= USPosition;\r
- if ( sizeUse )\r
- sizeHints.flags |= USSize;\r
-\r
- /*\r
- * Fill in the size hints values now (the x, y, width and height\r
- * settings are obsolete, are there any more WMs that support them?)\r
- * Unless the X servers actually stop supporting these, we should\r
- * continue to fill them in. It is *not* our place to tell the user\r
- * that they should replace a window manager that they like, and which\r
- * works, just because *we* think that it's not "modern" enough.\r
- */\r
- sizeHints.x = x;\r
- sizeHints.y = y;\r
- sizeHints.width = w;\r
- sizeHints.height = h;\r
-\r
- wmHints.flags = StateHint;\r
- wmHints.initial_state = fgState.ForceIconic ? IconicState : NormalState;\r
- /* Prepare the window and iconified window names... */\r
- XStringListToTextProperty( (char **) &title, 1, &textProperty );\r
-\r
- XSetWMProperties(\r
- fgDisplay.Display,\r
- window->Window.Handle,\r
- &textProperty,\r
- &textProperty,\r
- 0,\r
- 0,\r
- &sizeHints,\r
- &wmHints,\r
- NULL\r
- );\r
- XFree( textProperty.value );\r
-\r
- XSetWMProtocols( fgDisplay.Display, window->Window.Handle,\r
- &fgDisplay.DeleteWindow, 1 );\r
-\r
- glXMakeContextCurrent(\r
- fgDisplay.Display,\r
- window->Window.Handle,\r
- window->Window.Handle,\r
- window->Window.Context\r
- );\r
-\r
- /* register extension events _before_ window is mapped */\r
- #ifdef HAVE_X11_EXTENSIONS_XINPUT2_H\r
- fgRegisterDevices( fgDisplay.Display, &(window->Window.Handle) );\r
- #endif\r
-\r
- XMapWindow( fgDisplay.Display, window->Window.Handle );\r
-\r
- XFree(visualInfo);\r
-\r
- if( !isSubWindow)\r
- XPeekIfEvent( fgDisplay.Display, &eventReturnBuffer, &fghWindowIsVisible, (XPointer)(window->Window.Handle) );\r
-\r
-#elif TARGET_HOST_MS_WINDOWS\r
-\r
- WNDCLASS wc;\r
- DWORD flags = 0;\r
- DWORD exFlags = 0;\r
- ATOM atom;\r
-\r
- /* Grab the window class we have registered on glutInit(): */\r
- atom = GetClassInfo( fgDisplay.Instance, _T("FREEGLUT"), &wc );\r
- FREEGLUT_INTERNAL_ERROR_EXIT ( atom, "Window Class Info Not Found",\r
- "fgOpenWindow" );\r
-\r
- /* Determine window style flags*/\r
- if( gameMode )\r
- {\r
- FREEGLUT_INTERNAL_ERROR_EXIT ( window->Parent == NULL,\r
- "Game mode being invoked on a subwindow",\r
- "fgOpenWindow" );\r
-\r
- /*\r
- * Set the window creation flags appropriately to make the window\r
- * entirely visible:\r
- */\r
- flags = WS_POPUP | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_VISIBLE;\r
- }\r
- else\r
- {\r
- flags = WS_CLIPSIBLINGS | WS_CLIPCHILDREN;\r
-\r
- /*\r
- * There's a small difference between creating the top, child and\r
- * menu windows\r
- */\r
- if ( window->IsMenu )\r
- {\r
- flags |= WS_POPUP;\r
- exFlags |= WS_EX_TOOLWINDOW;\r
- }\r
-#if defined(_WIN32_WCE)\r
- /* no decorations for windows CE */\r
-#else\r
- /* if this is not a subwindow (child), set its style based on the requested display mode */\r
- else if( window->Parent == NULL )\r
- if ( fgState.DisplayMode & GLUT_BORDERLESS )\r
- {\r
- /* no window decorations needed */\r
- }\r
- else if ( fgState.DisplayMode & GLUT_CAPTIONLESS )\r
- /* only window decoration is a border, no title bar or buttons */\r
- flags |= WS_DLGFRAME;\r
- else\r
- /* window decoration are a border, title bar and buttons.\r
- * NB: we later query whether the window has a title bar or\r
- * not by testing for the maximize button, as the test for\r
- * WS_CAPTION can be true without the window having a title\r
- * bar. This style WS_OVERLAPPEDWINDOW gives you a maximize\r
- * button. */\r
- flags |= WS_OVERLAPPEDWINDOW;\r
-#endif\r
- else\r
- /* subwindows always have no decoration, but are marked as a child window to the OS */\r
- flags |= WS_CHILD;\r
- }\r
-\r
- /* determine window size and position */\r
- if( gameMode )\r
- {\r
- /* if in gamemode, query the origin of specified by the -display\r
- * command line parameter (if any) and offset the upper-left corner\r
- * of the window so we create the window on that screen.\r
- * The -display argument doesn't do anything if not trying to enter\r
- * gamemode.\r
- */\r
- int xoff=0, yoff=0;\r
- get_display_origin(&xoff,&yoff);\r
- x += xoff;\r
- y += yoff;\r
- }\r
- if( !positionUse )\r
- {\r
- x = CW_USEDEFAULT;\r
- y = CW_USEDEFAULT;\r
- }\r
- if( !sizeUse )\r
- {\r
- if( ! window->IsMenu )\r
- {\r
- w = CW_USEDEFAULT;\r
- h = CW_USEDEFAULT;\r
- }\r
- else /* fail safe - Windows can make a window of size (0, 0) */\r
- w = h = 300; /* default window size */\r
- }\r
- /* store requested client area width and height */\r
- window->State.Width = w;\r
- window->State.Height = h;\r
-\r
-#if !defined(_WIN32_WCE) /* no decorations for windows CE */\r
- if( sizeUse )\r
- {\r
- RECT windowRect;\r
- /*\r
- * Update the window dimensions, taking the window decorations\r
- * into account. FreeGLUT is to create the window with the\r
- * topleft outside corner at (x,y) and with client area\r
- * dimensions (w,h).\r
- * note: don't need to do this when w=h=CW_USEDEFAULT, so in the\r
- * if( sizeUse ) here is convenient.\r
- */\r
- windowRect.left = x;\r
- windowRect.top = y;\r
- windowRect.right = x+w;\r
- windowRect.bottom = y+h;\r
-\r
- fghComputeWindowRectFromClientArea_UseStyle(flags,&windowRect,TRUE);\r
-\r
- w = windowRect.right - windowRect.left;\r
- h = windowRect.bottom- windowRect.top;\r
- }\r
-#endif /* !defined(_WIN32_WCE) */\r
-\r
-#if defined(_WIN32_WCE)\r
- {\r
- wchar_t* wstr = fghWstrFromStr(title);\r
-\r
- window->Window.Handle = CreateWindow(\r
- _T("FREEGLUT"),\r
- wstr,\r
- WS_VISIBLE | WS_POPUP,\r
- 0,0, 240,320,\r
- NULL,\r
- NULL,\r
- fgDisplay.Instance,\r
- (LPVOID) window\r
- );\r
-\r
- free(wstr);\r
-\r
- SHFullScreen(window->Window.Handle, SHFS_HIDESTARTICON);\r
- SHFullScreen(window->Window.Handle, SHFS_HIDESIPBUTTON);\r
- SHFullScreen(window->Window.Handle, SHFS_HIDETASKBAR);\r
- MoveWindow(window->Window.Handle, 0, 0, 240, 320, TRUE);\r
- ShowWindow(window->Window.Handle, SW_SHOW);\r
- UpdateWindow(window->Window.Handle);\r
- }\r
-#else\r
- window->Window.Handle = CreateWindowEx(\r
- exFlags,\r
- _T("FREEGLUT"),\r
- title,\r
- flags,\r
- x, y, w, h,\r
- (HWND) window->Parent == NULL ? NULL : window->Parent->Window.Handle,\r
- (HMENU) NULL,\r
- fgDisplay.Instance,\r
- (LPVOID) window\r
- );\r
-#endif /* defined(_WIN32_WCE) */\r
-\r
- if( !( window->Window.Handle ) )\r
- fgError( "Failed to create a window (%s)!", title );\r
-\r
-#if !defined(_WIN32_WCE)\r
- /* Need to set requested style again, apparently Windows doesn't listen when requesting windows without title bar or borders */\r
- SetWindowLong(window->Window.Handle, GWL_STYLE, flags);\r
- SetWindowPos(window->Window.Handle, HWND_TOP, 0,0,0,0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);\r
-#endif /* defined(_WIN32_WCE) */\r
-\r
- /* Make a menu window always on top - fix Feature Request 947118 */\r
- if( window->IsMenu || gameMode )\r
- SetWindowPos(\r
- window->Window.Handle,\r
- HWND_TOPMOST,\r
- 0, 0, 0, 0,\r
- SWP_NOMOVE | SWP_NOSIZE\r
- );\r
-\r
- /* Enable multitouch: additional flag TWF_FINETOUCH, TWF_WANTPALM */\r
- #ifdef WM_TOUCH\r
- if (fghRegisterTouchWindow == (pRegisterTouchWindow)0xDEADBEEF) \r
- fghRegisterTouchWindow = (pRegisterTouchWindow)GetProcAddress(GetModuleHandle("user32"),"RegisterTouchWindow");\r
- if (fghRegisterTouchWindow)\r
- fghRegisterTouchWindow( window->Window.Handle, TWF_FINETOUCH | TWF_WANTPALM );\r
- #endif\r
-\r
-#if defined(_WIN32_WCE)\r
- ShowWindow( window->Window.Handle, SW_SHOW );\r
-#else\r
- ShowWindow( window->Window.Handle,\r
- fgState.ForceIconic ? SW_SHOWMINIMIZED : SW_SHOW );\r
-#endif /* defined(_WIN32_WCE) */\r
-\r
- UpdateWindow( window->Window.Handle );\r
- ShowCursor( TRUE ); /* XXX Old comments say "hide cursor"! */\r
-\r
-#endif\r
-\r
- fgSetWindow( window );\r
-\r
- window->Window.DoubleBuffered =\r
- ( fgState.DisplayMode & GLUT_DOUBLE ) ? 1 : 0;\r
-\r
- if ( ! window->Window.DoubleBuffered )\r
- {\r
- glDrawBuffer ( GL_FRONT );\r
- glReadBuffer ( GL_FRONT );\r
- }\r
-}\r
-\r
-/*\r
- * Closes a window, destroying the frame and OpenGL context\r
- */\r
-void fgCloseWindow( SFG_Window* window )\r
-{\r
- /* if we're in gamemode and we're closing the gamemode window,\r
- * call glutLeaveGameMode first to make sure the gamemode is\r
- * properly closed before closing the window\r
- */\r
- if (fgStructure.GameModeWindow != NULL && fgStructure.GameModeWindow->ID==window->ID)\r
- glutLeaveGameMode();\r
-\r
-#if TARGET_HOST_POSIX_X11\r
-\r
- if( window->Window.Context )\r
- glXDestroyContext( fgDisplay.Display, window->Window.Context );\r
- XFree( window->Window.FBConfig );\r
-\r
- if( window->Window.Handle ) {\r
- XDestroyWindow( fgDisplay.Display, window->Window.Handle );\r
- }\r
- /* XFlush( fgDisplay.Display ); */ /* XXX Shouldn't need this */\r
-\r
-#elif TARGET_HOST_MS_WINDOWS\r
-\r
- /* Make sure we don't close a window with current context active */\r
- if( fgStructure.CurrentWindow == window )\r
- wglMakeCurrent( NULL, NULL );\r
-\r
- /*\r
- * Step through the list of windows. If the rendering context\r
- * is not being used by another window, then we delete it.\r
- */\r
- {\r
- int used = FALSE ;\r
- SFG_Window *iter ;\r
-\r
- for( iter = (SFG_Window *)fgStructure.Windows.First;\r
- iter;\r
- iter = (SFG_Window *)iter->Node.Next )\r
- {\r
- if( ( iter->Window.Context == window->Window.Context ) &&\r
- ( iter != window ) )\r
- used = TRUE;\r
- }\r
-\r
- if( ! used )\r
- wglDeleteContext( window->Window.Context );\r
- }\r
-\r
- DestroyWindow( window->Window.Handle );\r
-#endif\r
-}\r
-\r
-\r
-/* -- INTERFACE FUNCTIONS -------------------------------------------------- */\r
-\r
-/*\r
- * Creates a new top-level freeglut window\r
- */\r
-int FGAPIENTRY glutCreateWindow( const char* title )\r
-{\r
- /* XXX GLUT does not exit; it simply calls "glutInit" quietly if the\r
- * XXX application has not already done so. The "freeglut" community\r
- * XXX decided not to go this route (freeglut-developer e-mail from\r
- * XXX Steve Baker, 12/16/04, 4:22 PM CST, "Re: [Freeglut-developer]\r
- * XXX Desired 'freeglut' behaviour when there is no current window"\r
- */\r
- FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutCreateWindow" );\r
-\r
- return fgCreateWindow( NULL, title, fgState.Position.Use,\r
- fgState.Position.X, fgState.Position.Y,\r
- fgState.Size.Use, fgState.Size.X, fgState.Size.Y,\r
- GL_FALSE, GL_FALSE )->ID;\r
-}\r
-\r
-#if TARGET_HOST_MS_WINDOWS\r
-int FGAPIENTRY __glutCreateWindowWithExit( const char *title, void (__cdecl *exit_function)(int) )\r
-{\r
- __glutExitFunc = exit_function;\r
- return glutCreateWindow( title );\r
-}\r
-#endif\r
-\r
-/*\r
- * This function creates a sub window.\r
- */\r
-int FGAPIENTRY glutCreateSubWindow( int parentID, int x, int y, int w, int h )\r
-{\r
- int ret = 0;\r
- SFG_Window* window = NULL;\r
- SFG_Window* parent = NULL;\r
-\r
- FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutCreateSubWindow" );\r
- parent = fgWindowByID( parentID );\r
- freeglut_return_val_if_fail( parent != NULL, 0 );\r
- if ( x < 0 )\r
- {\r
- x = parent->State.Width + x ;\r
- if ( w >= 0 ) x -= w ;\r
- }\r
-\r
- if ( w < 0 ) w = parent->State.Width - x + w ;\r
- if ( w < 0 )\r
- {\r
- x += w ;\r
- w = -w ;\r
- }\r
-\r
- if ( y < 0 )\r
- {\r
- y = parent->State.Height + y ;\r
- if ( h >= 0 ) y -= h ;\r
- }\r
-\r
- if ( h < 0 ) h = parent->State.Height - y + h ;\r
- if ( h < 0 )\r
- {\r
- y += h ;\r
- h = -h ;\r
- }\r
-\r
- window = fgCreateWindow( parent, "", GL_TRUE, x, y, GL_TRUE, w, h, GL_FALSE, GL_FALSE );\r
- ret = window->ID;\r
-\r
- return ret;\r
-}\r
-\r
-/*\r
- * Destroys a window and all of its subwindows\r
- */\r
-void FGAPIENTRY glutDestroyWindow( int windowID )\r
-{\r
- SFG_Window* window;\r
- FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutDestroyWindow" );\r
- window = fgWindowByID( windowID );\r
- freeglut_return_if_fail( window != NULL );\r
- {\r
- fgExecutionState ExecState = fgState.ExecState;\r
- fgAddToWindowDestroyList( window );\r
- fgState.ExecState = ExecState;\r
- }\r
-}\r
-\r
-/*\r
- * This function selects the current window\r
- */\r
-void FGAPIENTRY glutSetWindow( int ID )\r
-{\r
- SFG_Window* window = NULL;\r
-\r
- FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSetWindow" );\r
- if( fgStructure.CurrentWindow != NULL )\r
- if( fgStructure.CurrentWindow->ID == ID )\r
- return;\r
-\r
- window = fgWindowByID( ID );\r
- if( window == NULL )\r
- {\r
- fgWarning( "glutSetWindow(): window ID %d not found!", ID );\r
- return;\r
- }\r
-\r
- fgSetWindow( window );\r
-}\r
-\r
-/*\r
- * This function returns the ID number of the current window, 0 if none exists\r
- */\r
-int FGAPIENTRY glutGetWindow( void )\r
-{\r
- SFG_Window *win = fgStructure.CurrentWindow;\r
- /*\r
- * Since GLUT did not throw an error if this function was called without a prior call to\r
- * "glutInit", this function shouldn't do so here. Instead let us return a zero.\r
- * See Feature Request "[ 1307049 ] glutInit check".\r
- */\r
- if ( ! fgState.Initialised )\r
- return 0;\r
-\r
- while ( win && win->IsMenu )\r
- win = win->Parent;\r
- return win ? win->ID : 0;\r
-}\r
-\r
-/*\r
- * This function makes the current window visible\r
- */\r
-void FGAPIENTRY glutShowWindow( void )\r
-{\r
- FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutShowWindow" );\r
- FREEGLUT_EXIT_IF_NO_WINDOW ( "glutShowWindow" );\r
-\r
-#if TARGET_HOST_POSIX_X11\r
-\r
- XMapWindow( fgDisplay.Display, fgStructure.CurrentWindow->Window.Handle );\r
- XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */\r
-\r
-#elif TARGET_HOST_MS_WINDOWS\r
-\r
- ShowWindow( fgStructure.CurrentWindow->Window.Handle, SW_SHOW );\r
-\r
-#endif\r
-\r
- fgStructure.CurrentWindow->State.Redisplay = GL_TRUE;\r
-}\r
-\r
-/*\r
- * This function hides the current window\r
- */\r
-void FGAPIENTRY glutHideWindow( void )\r
-{\r
- FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutHideWindow" );\r
- FREEGLUT_EXIT_IF_NO_WINDOW ( "glutHideWindow" );\r
-\r
-#if TARGET_HOST_POSIX_X11\r
-\r
- if( fgStructure.CurrentWindow->Parent == NULL )\r
- XWithdrawWindow( fgDisplay.Display,\r
- fgStructure.CurrentWindow->Window.Handle,\r
- fgDisplay.Screen );\r
- else\r
- XUnmapWindow( fgDisplay.Display,\r
- fgStructure.CurrentWindow->Window.Handle );\r
- XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */\r
-\r
-#elif TARGET_HOST_MS_WINDOWS\r
-\r
- ShowWindow( fgStructure.CurrentWindow->Window.Handle, SW_HIDE );\r
-\r
-#endif\r
-\r
- fgStructure.CurrentWindow->State.Redisplay = GL_FALSE;\r
-}\r
-\r
-/*\r
- * Iconify the current window (top-level windows only)\r
- */\r
-void FGAPIENTRY glutIconifyWindow( void )\r
-{\r
- FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutIconifyWindow" );\r
- FREEGLUT_EXIT_IF_NO_WINDOW ( "glutIconifyWindow" );\r
-\r
- fgStructure.CurrentWindow->State.Visible = GL_FALSE;\r
-#if TARGET_HOST_POSIX_X11\r
-\r
- XIconifyWindow( fgDisplay.Display, fgStructure.CurrentWindow->Window.Handle,\r
- fgDisplay.Screen );\r
- XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */\r
-\r
-#elif TARGET_HOST_MS_WINDOWS\r
-\r
- ShowWindow( fgStructure.CurrentWindow->Window.Handle, SW_MINIMIZE );\r
-\r
-#endif\r
-\r
- fgStructure.CurrentWindow->State.Redisplay = GL_FALSE;\r
-}\r
-\r
-/*\r
- * Set the current window's title\r
- */\r
-void FGAPIENTRY glutSetWindowTitle( const char* title )\r
-{\r
- FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSetWindowTitle" );\r
- FREEGLUT_EXIT_IF_NO_WINDOW ( "glutSetWindowTitle" );\r
- if( ! fgStructure.CurrentWindow->Parent )\r
- {\r
-#if TARGET_HOST_POSIX_X11\r
-\r
- XTextProperty text;\r
-\r
- text.value = (unsigned char *) title;\r
- text.encoding = XA_STRING;\r
- text.format = 8;\r
- text.nitems = strlen( title );\r
-\r
- XSetWMName(\r
- fgDisplay.Display,\r
- fgStructure.CurrentWindow->Window.Handle,\r
- &text\r
- );\r
-\r
- XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */\r
-\r
-#elif TARGET_HOST_MS_WINDOWS\r
-# ifdef _WIN32_WCE\r
- {\r
- wchar_t* wstr = fghWstrFromStr(title);\r
- SetWindowText( fgStructure.CurrentWindow->Window.Handle, wstr );\r
- free(wstr);\r
- }\r
-# else\r
- SetWindowText( fgStructure.CurrentWindow->Window.Handle, title );\r
-# endif\r
-\r
-#endif\r
- }\r
-}\r
-\r
-/*\r
- * Set the current window's iconified title\r
- */\r
-void FGAPIENTRY glutSetIconTitle( const char* title )\r
-{\r
- FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSetIconTitle" );\r
- FREEGLUT_EXIT_IF_NO_WINDOW ( "glutSetIconTitle" );\r
-\r
- if( ! fgStructure.CurrentWindow->Parent )\r
- {\r
-#if TARGET_HOST_POSIX_X11\r
-\r
- XTextProperty text;\r
-\r
- text.value = (unsigned char *) title;\r
- text.encoding = XA_STRING;\r
- text.format = 8;\r
- text.nitems = strlen( title );\r
-\r
- XSetWMIconName(\r
- fgDisplay.Display,\r
- fgStructure.CurrentWindow->Window.Handle,\r
- &text\r
- );\r
-\r
- XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */\r
-\r
-#elif TARGET_HOST_MS_WINDOWS\r
-# ifdef _WIN32_WCE\r
- {\r
- wchar_t* wstr = fghWstrFromStr(title);\r
- SetWindowText( fgStructure.CurrentWindow->Window.Handle, wstr );\r
- free(wstr);\r
- }\r
-# else\r
- SetWindowText( fgStructure.CurrentWindow->Window.Handle, title );\r
-# endif\r
-\r
-#endif\r
- }\r
-}\r
-\r
-/*\r
- * Change the current window's size\r
- */\r
-void FGAPIENTRY glutReshapeWindow( int width, int height )\r
-{\r
- FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutReshapeWindow" );\r
- FREEGLUT_EXIT_IF_NO_WINDOW ( "glutReshapeWindow" );\r
-\r
- if (glutGet(GLUT_FULL_SCREEN))\r
- {\r
- /* Leave full screen state before resizing. */\r
- glutLeaveFullScreen();\r
- }\r
-\r
- fgStructure.CurrentWindow->State.NeedToResize = GL_TRUE;\r
- fgStructure.CurrentWindow->State.Width = width ;\r
- fgStructure.CurrentWindow->State.Height = height;\r
-}\r
-\r
-/*\r
- * Change the current window's position\r
- */\r
-void FGAPIENTRY glutPositionWindow( int x, int y )\r
-{\r
- FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutPositionWindow" );\r
- FREEGLUT_EXIT_IF_NO_WINDOW ( "glutPositionWindow" );\r
-\r
- if (glutGet(GLUT_FULL_SCREEN))\r
- {\r
- /* Leave full screen state before moving. */\r
- glutLeaveFullScreen();\r
- }\r
-\r
-#if TARGET_HOST_POSIX_X11\r
-\r
- XMoveWindow( fgDisplay.Display, fgStructure.CurrentWindow->Window.Handle,\r
- x, y );\r
- XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */\r
-\r
-#elif TARGET_HOST_MS_WINDOWS\r
-\r
- {\r
- RECT winRect;\r
-\r
- /* "GetWindowRect" returns the pixel coordinates of the outside of the window */\r
- GetWindowRect( fgStructure.CurrentWindow->Window.Handle, &winRect );\r
- MoveWindow(\r
- fgStructure.CurrentWindow->Window.Handle,\r
- x,\r
- y,\r
- winRect.right - winRect.left,\r
- winRect.bottom - winRect.top,\r
- TRUE\r
- );\r
- }\r
-\r
-#endif\r
-}\r
-\r
-/*\r
- * Lowers the current window (by Z order change)\r
- */\r
-void FGAPIENTRY glutPushWindow( void )\r
-{\r
- FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutPushWindow" );\r
- FREEGLUT_EXIT_IF_NO_WINDOW ( "glutPushWindow" );\r
-\r
-#if TARGET_HOST_POSIX_X11\r
-\r
- XLowerWindow( fgDisplay.Display, fgStructure.CurrentWindow->Window.Handle );\r
-\r
-#elif TARGET_HOST_MS_WINDOWS\r
-\r
- SetWindowPos(\r
- fgStructure.CurrentWindow->Window.Handle,\r
- HWND_BOTTOM,\r
- 0, 0, 0, 0,\r
- SWP_NOSIZE | SWP_NOMOVE\r
- );\r
-\r
-#endif\r
-}\r
-\r
-/*\r
- * Raises the current window (by Z order change)\r
- */\r
-void FGAPIENTRY glutPopWindow( void )\r
-{\r
- FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutPopWindow" );\r
- FREEGLUT_EXIT_IF_NO_WINDOW ( "glutPopWindow" );\r
-\r
-#if TARGET_HOST_POSIX_X11\r
-\r
- XRaiseWindow( fgDisplay.Display, fgStructure.CurrentWindow->Window.Handle );\r
-\r
-#elif TARGET_HOST_MS_WINDOWS\r
-\r
- SetWindowPos(\r
- fgStructure.CurrentWindow->Window.Handle,\r
- HWND_TOP,\r
- 0, 0, 0, 0,\r
- SWP_NOSIZE | SWP_NOMOVE\r
- );\r
-\r
-#endif\r
-}\r
-\r
-/*\r
- * Resize the current window so that it fits the whole screen\r
- */\r
-void FGAPIENTRY glutFullScreen( void )\r
-{\r
- SFG_Window *win;\r
-\r
- FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutFullScreen" );\r
- FREEGLUT_EXIT_IF_NO_WINDOW ( "glutFullScreen" );\r
-\r
- win = fgStructure.CurrentWindow;\r
-\r
- if (win->Parent)\r
- {\r
- /* Child windows cannot be made fullscreen, consistent with GLUT's behavior\r
- * Also, what would it mean for a child window to be fullscreen, given that it\r
- * is confined to its parent?\r
- */\r
- fgWarning("glutFullScreen called on a child window, ignoring...");\r
- return;\r
- }\r
- else if (fgStructure.GameModeWindow != NULL && fgStructure.GameModeWindow->ID==win->ID)\r
- {\r
- /* Ignore fullscreen call on GameMode window, those are always fullscreen already */\r
- return;\r
- }\r
-\r
-#if TARGET_HOST_POSIX_X11\r
- if(!glutGet(GLUT_FULL_SCREEN)) {\r
- if(fghToggleFullscreen() != -1) {\r
- win->State.IsFullscreen = GL_TRUE;\r
- }\r
- }\r
-\r
-#elif TARGET_HOST_MS_WINDOWS && !defined(_WIN32_WCE) /* FIXME: what about WinCE */\r
-\r
- if (glutGet(GLUT_FULL_SCREEN))\r
- {\r
- /* Leave full screen state before entering fullscreen again (resizing?) */\r
- glutLeaveFullScreen();\r
- }\r
-\r
- {\r
-#if(WINVER >= 0x0500) /* Windows 2000 or later */\r
- DWORD s;\r
- RECT rect;\r
- HMONITOR hMonitor;\r
- MONITORINFO mi;\r
-\r
- /* For fullscreen mode, first remove all window decoration\r
- * and set style to popup so it will overlap the taskbar\r
- * then force to maximize on the screen on which it has the most\r
- * overlap.\r
- */\r
-\r
- \r
- /* store current window rect */\r
- GetWindowRect( win->Window.Handle, &win->State.OldRect );\r
-\r
- /* store current window style */\r
- win->State.OldStyle = s = GetWindowLong(win->Window.Handle, GWL_STYLE);\r
-\r
- /* remove decorations from style and add popup style*/\r
- s &= ~WS_OVERLAPPEDWINDOW;\r
- s |= WS_POPUP;\r
- SetWindowLong(win->Window.Handle, GWL_STYLE, s);\r
- SetWindowPos(win->Window.Handle, HWND_TOP, 0,0,0,0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);\r
-\r
- /* For fullscreen mode, find the monitor that is covered the most\r
- * by the window and get its rect as the resize target.\r
- */\r
- hMonitor= MonitorFromRect(&win->State.OldRect, MONITOR_DEFAULTTONEAREST);\r
- mi.cbSize = sizeof(mi);\r
- GetMonitorInfo(hMonitor, &mi);\r
- rect = mi.rcMonitor;\r
-#else /* if (WINVER >= 0x0500) */\r
- RECT rect;\r
-\r
- /* For fullscreen mode, force the top-left corner to 0,0\r
- * and adjust the window rectangle so that the client area\r
- * covers the whole screen.\r
- */\r
-\r
- rect.left = 0;\r
- rect.top = 0;\r
- rect.right = fgDisplay.ScreenWidth;\r
- rect.bottom = fgDisplay.ScreenHeight;\r
-\r
- AdjustWindowRect ( &rect, WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS |\r
- WS_CLIPCHILDREN, FALSE );\r
-#endif /* (WINVER >= 0x0500) */\r
-\r
- /*\r
- * then resize window\r
- * SWP_NOACTIVATE Do not activate the window\r
- * SWP_NOOWNERZORDER Do not change position in z-order\r
- * SWP_NOSENDCHANGING Suppress WM_WINDOWPOSCHANGING message\r
- * SWP_NOZORDER Retains the current Z order (ignore 2nd param)\r
- */\r
- SetWindowPos( fgStructure.CurrentWindow->Window.Handle,\r
- HWND_TOP,\r
- rect.left,\r
- rect.top,\r
- rect.right - rect.left,\r
- rect.bottom - rect.top,\r
- SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOSENDCHANGING |\r
- SWP_NOZORDER\r
- );\r
-\r
- win->State.IsFullscreen = GL_TRUE;\r
- }\r
-#endif\r
-}\r
-\r
-/*\r
- * If we are fullscreen, resize the current window back to its original size\r
- */\r
-void FGAPIENTRY glutLeaveFullScreen( void )\r
-{\r
- SFG_Window *win;\r
-\r
- FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutFullScreen" );\r
- FREEGLUT_EXIT_IF_NO_WINDOW ( "glutFullScreen" );\r
-\r
- win = fgStructure.CurrentWindow;\r
-\r
-#if TARGET_HOST_POSIX_X11\r
- if(glutGet(GLUT_FULL_SCREEN)) {\r
- if(fghToggleFullscreen() != -1) {\r
- win->State.IsFullscreen = GL_FALSE;\r
- }\r
- }\r
-\r
-#elif TARGET_HOST_MS_WINDOWS && !defined(_WIN32_WCE) /* FIXME: what about WinCE */\r
- if (!glutGet(GLUT_FULL_SCREEN))\r
- {\r
- /* nothing to do */\r
- return;\r
- }\r
-\r
- /* restore style of window before making it fullscreen */\r
- SetWindowLong(win->Window.Handle, GWL_STYLE, win->State.OldStyle);\r
- SetWindowPos(win->Window.Handle, HWND_TOP, 0,0,0,0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);\r
-\r
- /* Then resize */\r
- SetWindowPos(win->Window.Handle,\r
- HWND_TOP,\r
- win->State.OldRect.left,\r
- win->State.OldRect.top,\r
- win->State.OldRect.right - win->State.OldRect.left,\r
- win->State.OldRect.bottom - win->State.OldRect.top,\r
- SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOSENDCHANGING |\r
- SWP_NOZORDER\r
- );\r
-\r
- win->State.IsFullscreen = GL_FALSE;\r
-#endif\r
-}\r
-\r
-/*\r
- * Toggle the window's full screen state.\r
- */\r
-void FGAPIENTRY glutFullScreenToggle( void )\r
-{\r
- SFG_Window *win;\r
-\r
- FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutFullScreenToggle" );\r
- FREEGLUT_EXIT_IF_NO_WINDOW ( "glutFullScreenToggle" );\r
-\r
- win = fgStructure.CurrentWindow;\r
-\r
-#if TARGET_HOST_POSIX_X11\r
- if(fghToggleFullscreen() != -1) {\r
- win->State.IsFullscreen = !win->State.IsFullscreen;\r
- }\r
-#elif TARGET_HOST_MS_WINDOWS\r
- if (!win->State.IsFullscreen)\r
- glutFullScreen();\r
- else\r
- glutLeaveFullScreen();\r
-#endif\r
-}\r
-\r
-/*\r
- * A.Donev: Set and retrieve the window's user data\r
- */\r
-void* FGAPIENTRY glutGetWindowData( void )\r
-{\r
- FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutGetWindowData" );\r
- FREEGLUT_EXIT_IF_NO_WINDOW ( "glutGetWindowData" );\r
- return fgStructure.CurrentWindow->UserData;\r
-}\r
-\r
-void FGAPIENTRY glutSetWindowData(void* data)\r
-{\r
- FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSetWindowData" );\r
- FREEGLUT_EXIT_IF_NO_WINDOW ( "glutSetWindowData" );\r
- fgStructure.CurrentWindow->UserData = data;\r
-}\r
-\r
-/*** END OF FILE ***/\r
+/*
+ * freeglut_window.c
+ *
+ * Window management methods.
+ *
+ * Copyright (c) 1999-2000 Pawel W. Olszta. All Rights Reserved.
+ * Written by Pawel W. Olszta, <olszta@sourceforge.net>
+ * Creation date: Fri Dec 3 1999
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * PAWEL W. OLSZTA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#define FREEGLUT_BUILDING_LIB
+#include <GL/freeglut.h>
+#include "freeglut_internal.h"
+
+#if defined(_WIN32_WCE)
+# include <Aygshell.h>
+# ifdef FREEGLUT_LIB_PRAGMAS
+# pragma comment( lib, "Aygshell.lib" )
+# endif
+#endif /* defined(_WIN32_WCE) */
+
+
+/*
+ * TODO BEFORE THE STABLE RELEASE:
+ *
+ * fgSetupPixelFormat -- ignores the display mode settings
+ * fgOpenWindow() -- check the Win32 version, -iconic handling!
+ * fgCloseWindow() -- check the Win32 version
+ * glutCreateWindow() -- Check when default position and size is {-1,-1}
+ * glutCreateSubWindow() -- Check when default position and size is {-1,-1}
+ * glutDestroyWindow() -- check the Win32 version
+ * glutSetWindow() -- check the Win32 version
+ * glutSetWindowTitle() -- check the Win32 version
+ * glutSetIconTitle() -- check the Win32 version
+ * glutShowWindow() -- check the Win32 version
+ * glutHideWindow() -- check the Win32 version
+ * glutIconifyWindow() -- check the Win32 version
+ * glutPushWindow() -- check the Win32 version
+ * glutPopWindow() -- check the Win32 version
+ */
+
+
+extern void fgPlatformSetWindow ( SFG_Window *window );
+extern void fgPlatformOpenWindow( SFG_Window* window, const char* title,
+ GLboolean positionUse, int x, int y,
+ GLboolean sizeUse, int w, int h,
+ GLboolean gameMode, GLboolean isSubWindow );
+extern void fgPlatformCloseWindow( SFG_Window* window );
+extern void fgPlatformGlutShowWindow( void );
+extern void fgPlatformGlutHideWindow( void );
+extern void fgPlatformGlutIconifyWindow( void );
+extern void fgPlatformGlutSetWindowTitle( const char* title );
+extern void fgPlatformGlutSetIconTitle( const char* title );
+extern void fgPlatformGlutPositionWindow( int x, int y );
+extern void fgPlatformGlutPushWindow( void );
+extern void fgPlatformGlutPopWindow( void );
+extern void fgPlatformGlutFullScreen( SFG_Window *win );
+extern void fgPlatformGlutLeaveFullScreen( SFG_Window *win );
+extern void fgPlatformGlutFullScreenToggle( SFG_Window *win );
+
+
+/* -- PRIVATE FUNCTIONS ---------------------------------------------------- */
+
+int fghIsLegacyContextVersionRequested( void )
+{
+ return fgState.MajorVersion < 2 || (fgState.MajorVersion == 2 && fgState.MinorVersion <= 1);
+}
+
+int fghIsLegacyContextRequested( void )
+{
+ return fghIsLegacyContextVersionRequested() &&
+ fgState.ContextFlags == 0 &&
+ fgState.ContextProfile == 0;
+}
+
+int fghNumberOfAuxBuffersRequested( void )
+{
+ if ( fgState.DisplayMode & GLUT_AUX4 ) {
+ return 4;
+ }
+ if ( fgState.DisplayMode & GLUT_AUX3 ) {
+ return 3;
+ }
+ if ( fgState.DisplayMode & GLUT_AUX2 ) {
+ return 2;
+ }
+ if ( fgState.DisplayMode & GLUT_AUX1 ) { /* NOTE: Same as GLUT_AUX! */
+ return fgState.AuxiliaryBufferNumber;
+ }
+ return 0;
+}
+
+int fghMapBit( int mask, int from, int to )
+{
+ return ( mask & from ) ? to : 0;
+
+}
+
+void fghContextCreationError( void )
+{
+ fgError( "Unable to create OpenGL %d.%d context (flags %x, profile %x)",
+ fgState.MajorVersion, fgState.MinorVersion, fgState.ContextFlags,
+ fgState.ContextProfile );
+}
+
+
+/* -- SYSTEM-DEPENDENT PRIVATE FUNCTIONS ------------------------------------ */
+
+/*
+ * Sets the OpenGL context and the fgStructure "Current Window" pointer to
+ * the window structure passed in.
+ */
+void fgSetWindow ( SFG_Window *window )
+{
+ fgPlatformSetWindow ( window );
+
+ fgStructure.CurrentWindow = window;
+}
+
+/*
+ * Opens a window. Requires a SFG_Window object created and attached
+ * to the freeglut structure. OpenGL context is created here.
+ */
+void fgOpenWindow( SFG_Window* window, const char* title,
+ GLboolean positionUse, int x, int y,
+ GLboolean sizeUse, int w, int h,
+ GLboolean gameMode, GLboolean isSubWindow )
+{
+ fgPlatformOpenWindow( window, title,
+ positionUse, x, y,
+ sizeUse, w, h,
+ gameMode, isSubWindow );
+
+ fgSetWindow( window );
+
+ window->Window.DoubleBuffered =
+ ( fgState.DisplayMode & GLUT_DOUBLE ) ? 1 : 0;
+
+ if ( ! window->Window.DoubleBuffered )
+ {
+ glDrawBuffer ( GL_FRONT );
+ glReadBuffer ( GL_FRONT );
+ }
+}
+
+/*
+ * Closes a window, destroying the frame and OpenGL context
+ */
+void fgCloseWindow( SFG_Window* window )
+{
+ /* if we're in gamemode and we're closing the gamemode window,
+ * call glutLeaveGameMode first to make sure the gamemode is
+ * properly closed before closing the window
+ */
+ if (fgStructure.GameModeWindow != NULL && fgStructure.GameModeWindow->ID==window->ID)
+ glutLeaveGameMode();
+
+ fgPlatformCloseWindow ( window );
+}
+
+
+/* -- INTERFACE FUNCTIONS -------------------------------------------------- */
+
+/*
+ * Creates a new top-level freeglut window
+ */
+int FGAPIENTRY glutCreateWindow( const char* title )
+{
+ /* XXX GLUT does not exit; it simply calls "glutInit" quietly if the
+ * XXX application has not already done so. The "freeglut" community
+ * XXX decided not to go this route (freeglut-developer e-mail from
+ * XXX Steve Baker, 12/16/04, 4:22 PM CST, "Re: [Freeglut-developer]
+ * XXX Desired 'freeglut' behaviour when there is no current window"
+ */
+ FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutCreateWindow" );
+
+ return fgCreateWindow( NULL, title, fgState.Position.Use,
+ fgState.Position.X, fgState.Position.Y,
+ fgState.Size.Use, fgState.Size.X, fgState.Size.Y,
+ GL_FALSE, GL_FALSE )->ID;
+}
+
+/*
+ * This function creates a sub window.
+ */
+int FGAPIENTRY glutCreateSubWindow( int parentID, int x, int y, int w, int h )
+{
+ int ret = 0;
+ SFG_Window* window = NULL;
+ SFG_Window* parent = NULL;
+
+ FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutCreateSubWindow" );
+ parent = fgWindowByID( parentID );
+ freeglut_return_val_if_fail( parent != NULL, 0 );
+ if ( x < 0 )
+ {
+ x = parent->State.Width + x ;
+ if ( w >= 0 ) x -= w ;
+ }
+
+ if ( w < 0 ) w = parent->State.Width - x + w ;
+ if ( w < 0 )
+ {
+ x += w ;
+ w = -w ;
+ }
+
+ if ( y < 0 )
+ {
+ y = parent->State.Height + y ;
+ if ( h >= 0 ) y -= h ;
+ }
+
+ if ( h < 0 ) h = parent->State.Height - y + h ;
+ if ( h < 0 )
+ {
+ y += h ;
+ h = -h ;
+ }
+
+ window = fgCreateWindow( parent, "", GL_TRUE, x, y, GL_TRUE, w, h, GL_FALSE, GL_FALSE );
+ ret = window->ID;
+
+ return ret;
+}
+
+/*
+ * Destroys a window and all of its subwindows
+ */
+void FGAPIENTRY glutDestroyWindow( int windowID )
+{
+ SFG_Window* window;
+ FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutDestroyWindow" );
+ window = fgWindowByID( windowID );
+ freeglut_return_if_fail( window != NULL );
+ {
+ fgExecutionState ExecState = fgState.ExecState;
+ fgAddToWindowDestroyList( window );
+ fgState.ExecState = ExecState;
+ }
+}
+
+/*
+ * This function selects the specified window as the current window
+ */
+void FGAPIENTRY glutSetWindow( int ID )
+{
+ SFG_Window* window = NULL;
+
+ FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSetWindow" );
+ if( fgStructure.CurrentWindow != NULL )
+ if( fgStructure.CurrentWindow->ID == ID )
+ return;
+
+ window = fgWindowByID( ID );
+ if( window == NULL )
+ {
+ fgWarning( "glutSetWindow(): window ID %d not found!", ID );
+ return;
+ }
+
+ fgSetWindow( window );
+}
+
+/*
+ * This function returns the ID number of the current window, 0 if none exists
+ */
+int FGAPIENTRY glutGetWindow( void )
+{
+ SFG_Window *win = fgStructure.CurrentWindow;
+ /*
+ * Since GLUT did not throw an error if this function was called without a prior call to
+ * "glutInit", this function shouldn't do so here. Instead let us return a zero.
+ * See Feature Request "[ 1307049 ] glutInit check".
+ */
+ if ( ! fgState.Initialised )
+ return 0;
+
+ while ( win && win->IsMenu )
+ win = win->Parent;
+ return win ? win->ID : 0;
+}
+
+/*
+ * This function makes the current window visible
+ */
+void FGAPIENTRY glutShowWindow( void )
+{
+ FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutShowWindow" );
+ FREEGLUT_EXIT_IF_NO_WINDOW ( "glutShowWindow" );
+
+ fgPlatformGlutShowWindow ();
+
+ fgStructure.CurrentWindow->State.Redisplay = GL_TRUE;
+}
+
+/*
+ * This function hides the current window
+ */
+void FGAPIENTRY glutHideWindow( void )
+{
+ FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutHideWindow" );
+ FREEGLUT_EXIT_IF_NO_WINDOW ( "glutHideWindow" );
+
+ fgPlatformGlutHideWindow ();
+
+ fgStructure.CurrentWindow->State.Redisplay = GL_FALSE;
+}
+
+/*
+ * Iconify the current window (top-level windows only)
+ */
+void FGAPIENTRY glutIconifyWindow( void )
+{
+ FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutIconifyWindow" );
+ FREEGLUT_EXIT_IF_NO_WINDOW ( "glutIconifyWindow" );
+
+ fgStructure.CurrentWindow->State.Visible = GL_FALSE;
+
+ fgPlatformGlutIconifyWindow ();
+
+ fgStructure.CurrentWindow->State.Redisplay = GL_FALSE;
+}
+
+/*
+ * Set the current window's title
+ */
+void FGAPIENTRY glutSetWindowTitle( const char* title )
+{
+ FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSetWindowTitle" );
+ FREEGLUT_EXIT_IF_NO_WINDOW ( "glutSetWindowTitle" );
+ if( ! fgStructure.CurrentWindow->Parent )
+ {
+ fgPlatformGlutSetWindowTitle ( title );
+ }
+}
+
+/*
+ * Set the current window's iconified title
+ */
+void FGAPIENTRY glutSetIconTitle( const char* title )
+{
+ FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSetIconTitle" );
+ FREEGLUT_EXIT_IF_NO_WINDOW ( "glutSetIconTitle" );
+
+ if( ! fgStructure.CurrentWindow->Parent )
+ {
+ fgPlatformGlutSetIconTitle ( title );
+ }
+}
+
+/*
+ * Change the current window's size
+ */
+void FGAPIENTRY glutReshapeWindow( int width, int height )
+{
+ FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutReshapeWindow" );
+ FREEGLUT_EXIT_IF_NO_WINDOW ( "glutReshapeWindow" );
+
+ if (glutGet(GLUT_FULL_SCREEN))
+ {
+ /* Leave full screen state before resizing. */
+ glutLeaveFullScreen();
+ }
+
+ fgStructure.CurrentWindow->State.NeedToResize = GL_TRUE;
+ fgStructure.CurrentWindow->State.Width = width ;
+ fgStructure.CurrentWindow->State.Height = height;
+}
+
+/*
+ * Change the current window's position
+ */
+void FGAPIENTRY glutPositionWindow( int x, int y )
+{
+ FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutPositionWindow" );
+ FREEGLUT_EXIT_IF_NO_WINDOW ( "glutPositionWindow" );
+
+ if (glutGet(GLUT_FULL_SCREEN))
+ {
+ /* Leave full screen state before moving. */
+ glutLeaveFullScreen();
+ }
+
+ fgPlatformGlutPositionWindow ( x, y );
+}
+
+/*
+ * Lowers the current window (by Z order change)
+ */
+void FGAPIENTRY glutPushWindow( void )
+{
+ FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutPushWindow" );
+ FREEGLUT_EXIT_IF_NO_WINDOW ( "glutPushWindow" );
+
+ fgPlatformGlutPushWindow ();
+}
+
+/*
+ * Raises the current window (by Z order change)
+ */
+void FGAPIENTRY glutPopWindow( void )
+{
+ FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutPopWindow" );
+ FREEGLUT_EXIT_IF_NO_WINDOW ( "glutPopWindow" );
+
+ fgPlatformGlutPopWindow ();
+}
+
+/*
+ * Resize the current window so that it fits the whole screen
+ */
+void FGAPIENTRY glutFullScreen( void )
+{
+ SFG_Window *win;
+
+ FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutFullScreen" );
+ FREEGLUT_EXIT_IF_NO_WINDOW ( "glutFullScreen" );
+
+ win = fgStructure.CurrentWindow;
+
+ if (win->Parent)
+ {
+ /* Child windows cannot be made fullscreen, consistent with GLUT's behavior
+ * Also, what would it mean for a child window to be fullscreen, given that it
+ * is confined to its parent?
+ */
+ fgWarning("glutFullScreen called on a child window, ignoring...");
+ return;
+ }
+ else if (fgStructure.GameModeWindow != NULL && fgStructure.GameModeWindow->ID==win->ID)
+ {
+ /* Ignore fullscreen call on GameMode window, those are always fullscreen already */
+ return;
+ }
+
+ fgPlatformGlutFullScreen ( win );
+}
+
+/*
+ * If we are fullscreen, resize the current window back to its original size
+ */
+void FGAPIENTRY glutLeaveFullScreen( void )
+{
+ SFG_Window *win;
+
+ FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutFullScreen" );
+ FREEGLUT_EXIT_IF_NO_WINDOW ( "glutFullScreen" );
+
+ win = fgStructure.CurrentWindow;
+
+ fgPlatformGlutLeaveFullScreen ( win );
+}
+
+/*
+ * Toggle the window's full screen state.
+ */
+void FGAPIENTRY glutFullScreenToggle( void )
+{
+ SFG_Window *win;
+
+ FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutFullScreenToggle" );
+ FREEGLUT_EXIT_IF_NO_WINDOW ( "glutFullScreenToggle" );
+
+ win = fgStructure.CurrentWindow;
+
+ fgPlatformGlutFullScreenToggle ( win );
+}
+
+/*
+ * A.Donev: Set and retrieve the window's user data
+ */
+void* FGAPIENTRY glutGetWindowData( void )
+{
+ FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutGetWindowData" );
+ FREEGLUT_EXIT_IF_NO_WINDOW ( "glutGetWindowData" );
+ return fgStructure.CurrentWindow->UserData;
+}
+
+void FGAPIENTRY glutSetWindowData(void* data)
+{
+ FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSetWindowData" );
+ FREEGLUT_EXIT_IF_NO_WINDOW ( "glutSetWindowData" );
+ fgStructure.CurrentWindow->UserData = data;
+}
+
+/*** END OF FILE ***/
projects / freeglut / blobdiff