X-Git-Url: http://git.mutantstargoat.com/user/nuclear/?a=blobdiff_plain;f=src%2Ffreeglut_window.c;h=04e4b0b11542c8eca30b7a90cb4027a4ac22faf2;hb=fc6f0b39d73b3d9f6ee900f23015fac4f692c644;hp=91d4a7195e49be54c394e56a45f78c214f74d3ec;hpb=36523acd8b1d64e878996fef239bb5618ceb03a5;p=freeglut diff --git a/src/freeglut_window.c b/src/freeglut_window.c index 91d4a71..04e4b0b 100644 --- a/src/freeglut_window.c +++ b/src/freeglut_window.c @@ -25,9 +25,14 @@ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +#define FREEGLUT_BUILDING_LIB #include #include "freeglut_internal.h" +#if TARGET_HOST_POSIX_X11 +#include /* LONG_MAX */ +#endif + #if defined(_WIN32_WCE) # include # ifdef FREEGLUT_LIB_PRAGMAS @@ -49,7 +54,7 @@ static wchar_t* fghWstrFromStr(const char* str) /* * TODO BEFORE THE STABLE RELEASE: * - * fgChooseVisual() -- OK, but what about glutInitDisplayString()? + * fgChooseFBConfig() -- OK, but what about glutInitDisplayString()? * fgSetupPixelFormat -- ignores the display mode settings * fgOpenWindow() -- check the Win32 version, -iconic handling! * fgCloseWindow() -- check the Win32 version @@ -76,10 +81,8 @@ static wchar_t* fghWstrFromStr(const char* str) */ #if TARGET_HOST_POSIX_X11 -XVisualInfo* fgChooseVisual( void ) +GLXFBConfig* fgChooseFBConfig( void ) { -#define BUFFER_SIZES 6 - int bufferSize[BUFFER_SIZES] = { 16, 12, 8, 4, 2, 1 }; GLboolean wantIndexedMode = GL_FALSE; int attributes[ 32 ]; int where = 0; @@ -95,11 +98,13 @@ XVisualInfo* fgChooseVisual( void ) if( fgState.DisplayMode & GLUT_INDEX ) { ATTRIB_VAL( GLX_BUFFER_SIZE, 8 ); + /* Buffer size is selected later. */ + + ATTRIB_VAL( GLX_RENDER_TYPE, GLX_COLOR_INDEX_BIT ); wantIndexedMode = GL_TRUE; } else { - ATTRIB( GLX_RGBA ); ATTRIB_VAL( GLX_RED_SIZE, 1 ); ATTRIB_VAL( GLX_GREEN_SIZE, 1 ); ATTRIB_VAL( GLX_BLUE_SIZE, 1 ); @@ -108,10 +113,10 @@ XVisualInfo* fgChooseVisual( void ) } if( fgState.DisplayMode & GLUT_DOUBLE ) - ATTRIB( GLX_DOUBLEBUFFER ); + ATTRIB_VAL( GLX_DOUBLEBUFFER, True ); if( fgState.DisplayMode & GLUT_STEREO ) - ATTRIB( GLX_STEREO ); + ATTRIB_VAL( GLX_STEREO, True ); if( fgState.DisplayMode & GLUT_DEPTH ) ATTRIB_VAL( GLX_DEPTH_SIZE, 1 ); @@ -128,46 +133,137 @@ XVisualInfo* fgChooseVisual( void ) ATTRIB_VAL( GLX_ACCUM_ALPHA_SIZE, 1 ); } - if( fgState.DisplayMode & GLUT_AUX1 ) - ATTRIB_VAL( GLX_AUX_BUFFERS, 1 ); - if( fgState.DisplayMode & GLUT_AUX2 ) - ATTRIB_VAL( GLX_AUX_BUFFERS, 2 ); - if( fgState.DisplayMode & GLUT_AUX3 ) - ATTRIB_VAL( GLX_AUX_BUFFERS, 3 ); if( fgState.DisplayMode & GLUT_AUX4 ) - ATTRIB_VAL( GLX_AUX_BUFFERS, 4 ); - if ( fgState.DisplayMode & GLUT_MULTISAMPLE ) - ATTRIB_VAL( GLX_SAMPLES_SGIS, 4 ); + { + ATTRIB_VAL(GLX_AUX_BUFFERS, 4); + } + else if( fgState.DisplayMode & GLUT_AUX3 ) + { + ATTRIB_VAL(GLX_AUX_BUFFERS, 3); + } + else if( fgState.DisplayMode & GLUT_AUX2 ) + { + ATTRIB_VAL(GLX_AUX_BUFFERS, 2); + } + else if( fgState.DisplayMode & GLUT_AUX1 ) /* NOTE: Same as GLUT_AUX! */ + { + ATTRIB_VAL(GLX_AUX_BUFFERS, fgState.AuxiliaryBufferNumber); + } + if (fgState.DisplayMode & GLUT_MULTISAMPLE) + { + ATTRIB_VAL(GLX_SAMPLE_BUFFERS, 1) + ATTRIB_VAL(GLX_SAMPLES, fgState.SampleNumber) + } /* Push a null at the end of the list */ ATTRIB( None ); - if( ! wantIndexedMode ) - return glXChooseVisual( fgDisplay.Display, fgDisplay.Screen, - attributes ); - else { - XVisualInfo* visualInfo; - int i; + GLXFBConfig * fbconfigArray; /* Array of FBConfigs */ + GLXFBConfig * fbconfig; /* The FBConfig we want */ + int fbconfigArraySize; /* Number of FBConfigs in the array */ - /* - * In indexed mode, we need to check how many bits of depth can we - * achieve. We do this by trying each possibility from the list - * given in the {bufferSize} array. If we match, we return to caller. - */ - for( i=0; i bufferSizeMin) + { + /* + * Free and reallocate fbconfigArray, keeping only FBConfigs + * with the largest buffer size. + */ + XFree(fbconfigArray); + + /* Add buffer size token at the end of the list. */ + where--; + ATTRIB_VAL( GLX_BUFFER_SIZE, bufferSizeMax ); + ATTRIB( None ); + + fbconfigArray = glXChooseFBConfig( fgDisplay.Display, + fgDisplay.Screen, + attributes, + &fbconfigArraySize ); + } + } + + /* + * We now have an array of FBConfigs, the first one being the "best" + * one. So we should return only this FBConfig: + * + * int fbconfigXID; + * + * - pick the XID of the FBConfig we want + * result = glXGetFBConfigAttrib( fgDisplay.Display, + * fbconfigArray[0], + * GLX_FBCONFIG_ID, + * &fbconfigXID ); + * + * - free the array + * XFree(fbconfigArray); + * + * - reset "attributes" with the XID + * where = 0; + * ATTRIB_VAL( GLX_FBCONFIG_ID, fbconfigXID ); + * ATTRIB( None ); + * + * - get our FBConfig only + * fbconfig = glXChooseFBConfig( fgDisplay.Display, + * fgDisplay.Screen, + * attributes, + * &fbconfigArraySize ); + * + * However, for some configurations (for instance multisampling with + * Mesa 6.5.2 and ATI drivers), this does not work: + * glXChooseFBConfig returns NULL, whereas fbconfigXID is a valid + * XID. Further investigation is needed. + * + * So, for now, we return the whole array of FBConfigs. This should + * not produce any side effects elsewhere. + */ + fbconfig = fbconfigArray; + } + else + { + fbconfig = NULL; } - return NULL; + + return fbconfig; } } -#endif +#endif /* TARGET_HOST_POSIX_X11 */ /* * Setup the pixel format for a Win32 window @@ -196,6 +292,81 @@ typedef BOOL (WINAPI * PFNWGLCHOOSEPIXELFORMATARBPROC) (HDC hdc, const int *piAt #define WGL_SAMPLES_ARB 0x2042 +#ifndef WGL_ARB_create_context +#define WGL_ARB_create_context 1 +#ifdef WGL_WGLEXT_PROTOTYPES +extern HGLRC WINAPI wglCreateContextAttribsARB (HDC, HGLRC, const int *); +#endif /* WGL_WGLEXT_PROTOTYPES */ +typedef HGLRC (WINAPI * PFNWGLCREATECONTEXTATTRIBSARBPROC) (HDC hDC, HGLRC hShareContext, const int *attribList); + +#define WGL_CONTEXT_DEBUG_BIT_ARB 0x0001 +#define WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB 0x0002 +#define WGL_CONTEXT_MAJOR_VERSION_ARB 0x2091 +#define WGL_CONTEXT_MINOR_VERSION_ARB 0x2092 +#define WGL_CONTEXT_LAYER_PLANE_ARB 0x2093 +#define WGL_CONTEXT_FLAGS_ARB 0x2094 +#define ERROR_INVALID_VERSION_ARB 0x2095 +#endif + + +void fgNewWGLCreateContext( SFG_Window* window ) +{ + PFNWGLGETEXTENSIONSSTRINGARBPROC wglGetEntensionsStringARB; + HGLRC context; + int attribs[7]; + PFNWGLCREATECONTEXTATTRIBSARBPROC wglCreateContextAttribsARB; + const char * pWglExtString; + + /* If nothing fancy has been required, leave the context as it is */ + if ( fgState.MajorVersion == 1 && fgState.MinorVersion == 0 && fgState.ContextFlags == 0 ) + { + return; + } + + wglMakeCurrent( window->Window.Device, + window->Window.Context ); + + wglGetEntensionsStringARB=(PFNWGLGETEXTENSIONSSTRINGARBPROC)wglGetProcAddress("wglGetExtensionsStringARB"); + if ( wglGetEntensionsStringARB == NULL ) + { + return; + } + + pWglExtString=wglGetEntensionsStringARB(window->Window.Device); + if (( pWglExtString == NULL ) || ( strstr(pWglExtString, "WGL_ARB_create_context") == NULL )) + { + return; + } + + /* new context creation */ + attribs[0] = WGL_CONTEXT_MAJOR_VERSION_ARB; + attribs[1] = fgState.MajorVersion; + attribs[2] = WGL_CONTEXT_MINOR_VERSION_ARB; + attribs[3] = fgState.MinorVersion; + attribs[4] = WGL_CONTEXT_FLAGS_ARB; + attribs[5] = ((fgState.ContextFlags & GLUT_DEBUG) ? WGL_CONTEXT_DEBUG_BIT_ARB : 0) | + ((fgState.ContextFlags & GLUT_FORWARD_COMPATIBLE) ? WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB : 0); + attribs[6] = 0; + + wglCreateContextAttribsARB = (PFNWGLCREATECONTEXTATTRIBSARBPROC) wglGetProcAddress( "wglCreateContextAttribsARB" ); + if ( wglCreateContextAttribsARB == NULL ) + { + fgError( "wglCreateContextAttribsARB not found" ); + } + + context = wglCreateContextAttribsARB( window->Window.Device, 0, attribs ); + if ( context == NULL ) + { + fgError( "Unable to create OpenGL %d.%d context (flags %x)", + fgState.MajorVersion, fgState.MinorVersion, fgState.ContextFlags ); + } + + wglMakeCurrent( NULL, NULL ); + wglDeleteContext( window->Window.Context ); + window->Window.Context = context; +} + + GLboolean fgSetupPixelFormat( SFG_Window* window, GLboolean checkOnly, unsigned char layer_type ) { @@ -265,8 +436,8 @@ GLboolean fgSetupPixelFormat( SFG_Window* window, GLboolean checkOnly, pfd.cAuxBuffers = 3; else if( fgState.DisplayMode & GLUT_AUX2 ) pfd.cAuxBuffers = 2; - else if( fgState.DisplayMode & GLUT_AUX1 ) - pfd.cAuxBuffers = 1; + else if( fgState.DisplayMode & GLUT_AUX1 ) /* NOTE: Same as GLUT_AUX! */ + pfd.cAuxBuffers = fgState.AuxiliaryBufferNumber; else pfd.cAuxBuffers = 0; @@ -289,17 +460,16 @@ GLboolean fgSetupPixelFormat( SFG_Window* window, GLboolean checkOnly, HWND hWnd; HDC hDC, hDC_before=wglGetCurrentDC(); WNDCLASS wndCls; - ATOM atom; /* create a dummy window */ ZeroMemory(&wndCls, sizeof(wndCls)); - wndCls.lpfnWndProc = DefWindowProc; - wndCls.hInstance = fgDisplay.Instance; - wndCls.style = CS_OWNDC | CS_HREDRAW | CS_VREDRAW; - wndCls.lpszClassName = _T("FREEGLUT_dummy"); - atom = RegisterClass( &wndCls ); + wndCls.lpfnWndProc = DefWindowProc; + wndCls.hInstance = fgDisplay.Instance; + wndCls.style = CS_OWNDC | CS_HREDRAW | CS_VREDRAW; + wndCls.lpszClassName = _T("FREEGLUT_dummy"); + RegisterClass( &wndCls ); - hWnd=CreateWindow((LPCSTR)atom, _T(""), WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_OVERLAPPEDWINDOW , 0,0,0,0, 0, 0, fgDisplay.Instance, 0 ); + hWnd=CreateWindow(_T("FREEGLUT_dummy"), _T(""), WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_OVERLAPPEDWINDOW , 0,0,0,0, 0, 0, fgDisplay.Instance, 0 ); hDC=GetDC(hWnd); SetPixelFormat( hDC, pixelformat, ppfd ); @@ -336,7 +506,7 @@ GLboolean fgSetupPixelFormat( SFG_Window* window, GLboolean checkOnly, pAttributes[iCounter++]=WGL_DOUBLE_BUFFER_ARB; pAttributes[iCounter++]=(fgState.DisplayMode & GLUT_DOUBLE)!=0; pAttributes[iCounter++]=WGL_SAMPLE_BUFFERS_ARB; pAttributes[iCounter++]=GL_TRUE; - pAttributes[iCounter++]=WGL_SAMPLES_ARB; pAttributes[iCounter++]=4; + pAttributes[iCounter++]=WGL_SAMPLES_ARB; pAttributes[iCounter++]=fgState.SampleNumber; pAttributes[iCounter++]=0; pAttributes[iCounter++]=0; /* terminator */ bValid = wglChoosePixelFormatARBProc(window->Window.Device,pAttributes,fAttributes,1,&iPixelFormat,&numFormats); @@ -372,9 +542,10 @@ void fgSetWindow ( SFG_Window *window ) { #if TARGET_HOST_POSIX_X11 if ( window ) - glXMakeCurrent( + glXMakeContextCurrent( fgDisplay.Display, window->Window.Handle, + window->Window.Handle, window->Window.Context ); #elif TARGET_HOST_MS_WINDOWS @@ -395,6 +566,90 @@ void fgSetWindow ( SFG_Window *window ) } + +#if TARGET_HOST_POSIX_X11 + +#ifndef GLX_CONTEXT_MAJOR_VERSION_ARB +#define GLX_CONTEXT_MAJOR_VERSION_ARB 0x2091 +#endif + +#ifndef GLX_CONTEXT_MINOR_VERSION_ARB +#define GLX_CONTEXT_MINOR_VERSION_ARB 0x2092 +#endif + +#ifndef GLX_CONTEXT_FLAGS_ARB +#define GLX_CONTEXT_FLAGS_ARB 0x2094 +#endif + +#ifndef GLX_CONTEXT_DEBUG_BIT_ARB +#define GLX_CONTEXT_DEBUG_BIT_ARB 0x0001 +#endif + +#ifndef GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB +#define GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB 0x0002 +#endif + +typedef GLXContext (*CreateContextAttribsProc)(Display *dpy, GLXFBConfig config, + GLXContext share_list, Bool direct, + const int *attrib_list); + +static GLXContext fghCreateNewContext( SFG_Window* window ) +{ + /* for color model calculation */ + int menu = ( window->IsMenu && !fgStructure.MenuContext ); + int index_mode = ( fgState.DisplayMode & GLUT_INDEX ); + + /* "classic" context creation */ + Display *dpy = fgDisplay.Display; + GLXFBConfig config = *(window->Window.FBConfig); + int render_type = ( !menu && index_mode ) ? GLX_COLOR_INDEX_TYPE : GLX_RGBA_TYPE; + GLXContext share_list = NULL; + Bool direct = ( fgState.DirectContext != GLUT_FORCE_INDIRECT_CONTEXT ); + GLXContext context; + + /* new context creation */ + int attribs[7]; + CreateContextAttribsProc createContextAttribs; + + /* If nothing fancy has been required, simply use the old context creation GLX API entry */ + if ( fgState.MajorVersion == 1 && fgState.MinorVersion == 0 && fgState.ContextFlags == 0) + { + context = glXCreateNewContext( dpy, config, render_type, share_list, direct ); + if ( context == NULL ) { + fgError( "could not create new OpenGL context" ); + } + return context; + } + + /* color index mode is not available anymore with OpenGL 3.0 */ + if ( render_type == GLX_COLOR_INDEX_TYPE ) { + fgWarning( "color index mode is deprecated, using RGBA mode" ); + } + + attribs[0] = GLX_CONTEXT_MAJOR_VERSION_ARB; + attribs[1] = fgState.MajorVersion; + attribs[2] = GLX_CONTEXT_MINOR_VERSION_ARB; + attribs[3] = fgState.MinorVersion; + attribs[4] = GLX_CONTEXT_FLAGS_ARB; + attribs[5] = ((fgState.ContextFlags & GLUT_DEBUG) ? GLX_CONTEXT_DEBUG_BIT_ARB : 0) | + ((fgState.ContextFlags & GLUT_FORWARD_COMPATIBLE) ? GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB : 0); + attribs[6] = 0; + + createContextAttribs = (CreateContextAttribsProc) fghGetProcAddress( "glXCreateContextAttribsARB" ); + if ( createContextAttribs == NULL ) { + fgError( "glXCreateContextAttribsARB not found" ); + } + + context = createContextAttribs( dpy, config, share_list, direct, attribs ); + if ( context == NULL ) { + fgError( "could not create new OpenGL %d.%d context (flags %x)", + fgState.MajorVersion, fgState.MinorVersion, fgState.ContextFlags ); + } + return context; +} +#endif + + /* * Opens a window. Requires a SFG_Window object created and attached * to the freeglut structure. OpenGL context is created here. @@ -405,6 +660,7 @@ void fgOpenWindow( SFG_Window* window, const char* title, GLboolean gameMode, GLboolean isSubWindow ) { #if TARGET_HOST_POSIX_X11 + XVisualInfo * visualInfo; XSetWindowAttributes winAttr; XTextProperty textProperty; XSizeHints sizeHints; @@ -416,35 +672,39 @@ void fgOpenWindow( SFG_Window* window, const char* title, if( window->IsMenu && ( ! fgStructure.MenuContext ) ) fgState.DisplayMode = GLUT_DOUBLE | GLUT_RGB ; - window->Window.VisualInfo = fgChooseVisual( ); + window->Window.FBConfig = fgChooseFBConfig( ); if( window->IsMenu && ( ! fgStructure.MenuContext ) ) fgState.DisplayMode = current_DisplayMode ; - if( ! window->Window.VisualInfo ) + if( ! window->Window.FBConfig ) { /* - * The "fgChooseVisual" returned a null meaning that the visual + * The "fgChooseFBConfig" returned a null meaning that the visual * context is not available. * Try a couple of variations to see if they will work. */ if( !( fgState.DisplayMode & GLUT_DOUBLE ) ) { fgState.DisplayMode |= GLUT_DOUBLE ; - window->Window.VisualInfo = fgChooseVisual( ); + window->Window.FBConfig = fgChooseFBConfig( ); fgState.DisplayMode &= ~GLUT_DOUBLE; } if( fgState.DisplayMode & GLUT_MULTISAMPLE ) { fgState.DisplayMode &= ~GLUT_MULTISAMPLE ; - window->Window.VisualInfo = fgChooseVisual( ); + window->Window.FBConfig = fgChooseFBConfig( ); fgState.DisplayMode |= GLUT_MULTISAMPLE; } } - FREEGLUT_INTERNAL_ERROR_EXIT( window->Window.VisualInfo != NULL, - "Visual with necessary capabilities not found", "fgOpenWindow" ); + FREEGLUT_INTERNAL_ERROR_EXIT( window->Window.FBConfig != NULL, + "FBConfig with necessary capabilities not found", "fgOpenWindow" ); + + /* Get the X visual. */ + visualInfo = glXGetVisualFromFBConfig( fgDisplay.Display, + *(window->Window.FBConfig) ); /* * XXX HINT: the masks should be updated when adding/removing callbacks. @@ -467,7 +727,7 @@ void fgOpenWindow( SFG_Window* window, const char* title, winAttr.colormap = XCreateColormap( fgDisplay.Display, fgDisplay.RootWindow, - window->Window.VisualInfo->visual, AllocNone + visualInfo->visual, AllocNone ); mask = CWBackPixmap | CWBorderPixel | CWColormap | CWEventMask; @@ -488,8 +748,8 @@ void fgOpenWindow( SFG_Window* window, const char* title, window->Parent == NULL ? fgDisplay.RootWindow : window->Parent->Window.Handle, x, y, w, h, 0, - window->Window.VisualInfo->depth, InputOutput, - window->Window.VisualInfo->visual, mask, + visualInfo->depth, InputOutput, + visualInfo->visual, mask, &winAttr ); @@ -497,6 +757,7 @@ void fgOpenWindow( SFG_Window* window, const char* title, * The GLX context creation, possibly trying the direct context rendering * or else use the current context if the user has so specified */ + if( window->IsMenu ) { /* @@ -507,34 +768,21 @@ void fgOpenWindow( SFG_Window* window, const char* title, { fgStructure.MenuContext = (SFG_MenuContext *)malloc( sizeof(SFG_MenuContext) ); - fgStructure.MenuContext->MVisualInfo = window->Window.VisualInfo; - fgStructure.MenuContext->MContext = glXCreateContext( - fgDisplay.Display, fgStructure.MenuContext->MVisualInfo, - NULL, ( fgState.DirectContext != GLUT_FORCE_INDIRECT_CONTEXT ) - ); + fgStructure.MenuContext->MContext = fghCreateNewContext( window ); } /* window->Window.Context = fgStructure.MenuContext->MContext; */ - window->Window.Context = glXCreateContext( - fgDisplay.Display, window->Window.VisualInfo, - NULL, ( fgState.DirectContext != GLUT_FORCE_INDIRECT_CONTEXT ) - ); + window->Window.Context = fghCreateNewContext( window ); } else if( fgState.UseCurrentContext ) { window->Window.Context = glXGetCurrentContext( ); if( ! window->Window.Context ) - window->Window.Context = glXCreateContext( - fgDisplay.Display, window->Window.VisualInfo, - NULL, ( fgState.DirectContext != GLUT_FORCE_INDIRECT_CONTEXT ) - ); + window->Window.Context = fghCreateNewContext( window ); } else - window->Window.Context = glXCreateContext( - fgDisplay.Display, window->Window.VisualInfo, - NULL, ( fgState.DirectContext != GLUT_FORCE_INDIRECT_CONTEXT ) - ); + window->Window.Context = fghCreateNewContext( window ); #if !defined( __FreeBSD__ ) && !defined( __NetBSD__ ) if( !glXIsDirect( fgDisplay.Display, window->Window.Context ) ) @@ -542,9 +790,6 @@ void fgOpenWindow( SFG_Window* window, const char* title, if( fgState.DirectContext == GLUT_FORCE_DIRECT_CONTEXT ) fgError( "Unable to force direct context rendering for window '%s'", title ); - else if( fgState.DirectContext == GLUT_TRY_DIRECT_CONTEXT ) - fgWarning( "Unable to create direct context rendering for window '%s'\nThis may hurt performance.", - title ); } #endif @@ -594,20 +839,24 @@ void fgOpenWindow( SFG_Window* window, const char* title, XSetWMProtocols( fgDisplay.Display, window->Window.Handle, &fgDisplay.DeleteWindow, 1 ); - glXMakeCurrent( + glXMakeContextCurrent( fgDisplay.Display, window->Window.Handle, + window->Window.Handle, window->Window.Context ); XMapWindow( fgDisplay.Display, window->Window.Handle ); + XFree(visualInfo); + #elif TARGET_HOST_MS_WINDOWS WNDCLASS wc; DWORD flags; DWORD exFlags = 0; ATOM atom; + int WindowStyle = 0; /* Grab the window class we have registered on glutInit(): */ atom = GetClassInfo( fgDisplay.Instance, _T("FREEGLUT"), &wc ); @@ -735,6 +984,25 @@ void fgOpenWindow( SFG_Window* window, const char* title, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE ); + + /* Hack to remove the caption (title bar) and/or border + * and all the system menu controls. + */ + WindowStyle = GetWindowLong(window->Window.Handle, GWL_STYLE); + if ( fgState.DisplayMode & GLUT_CAPTIONLESS ) + { + SetWindowLong ( window->Window.Handle, GWL_STYLE, + WindowStyle & ~(WS_DLGFRAME | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX)); + } + else if ( fgState.DisplayMode & GLUT_BORDERLESS ) + { + SetWindowLong ( window->Window.Handle, GWL_STYLE, + WindowStyle & ~(WS_BORDER | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX)); + } +/* SetWindowPos(window->Window.Handle, NULL, 0, 0, 0, 0, + SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED); */ + + #if defined(_WIN32_WCE) ShowWindow( window->Window.Handle, SW_SHOW ); #else @@ -766,10 +1034,11 @@ void fgCloseWindow( SFG_Window* window ) { #if TARGET_HOST_POSIX_X11 - glXDestroyContext( fgDisplay.Display, window->Window.Context ); - XFree( window->Window.VisualInfo ); + if( window->Window.Context ) + glXDestroyContext( fgDisplay.Display, window->Window.Context ); + XFree( window->Window.FBConfig ); XDestroyWindow( fgDisplay.Display, window->Window.Handle ); - XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */ + /* XFlush( fgDisplay.Display ); */ /* XXX Shouldn't need this */ #elif TARGET_HOST_MS_WINDOWS @@ -824,6 +1093,14 @@ int FGAPIENTRY glutCreateWindow( const char* title ) GL_FALSE, GL_FALSE )->ID; } +#if TARGET_HOST_MS_WINDOWS +int FGAPIENTRY __glutCreateWindowWithExit( const char *title, void (__cdecl *exit_function)(int) ) +{ + __glutExitFunc = exit_function; + return glutCreateWindow( title ); +} +#endif + /* * This function creates a sub window. */ @@ -1090,6 +1367,12 @@ 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. */ + glutFullScreenToggle(); + } + fgStructure.CurrentWindow->State.NeedToResize = GL_TRUE; fgStructure.CurrentWindow->State.Width = width ; fgStructure.CurrentWindow->State.Height = height; @@ -1103,6 +1386,12 @@ 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. */ + glutFullScreenToggle(); + } + #if TARGET_HOST_POSIX_X11 XMoveWindow( fgDisplay.Display, fgStructure.CurrentWindow->Window.Handle, @@ -1185,37 +1474,32 @@ void FGAPIENTRY glutFullScreen( void ) FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutFullScreen" ); FREEGLUT_EXIT_IF_NO_WINDOW ( "glutFullScreen" ); + if (glutGet(GLUT_FULL_SCREEN)) { -#if TARGET_HOST_POSIX_X11 - int x, y; - Window w; + /* Leave full screen state before resizing. */ + glutFullScreenToggle(); + } - XMoveResizeWindow( - fgDisplay.Display, - fgStructure.CurrentWindow->Window.Handle, - 0, 0, - fgDisplay.ScreenWidth, - fgDisplay.ScreenHeight - ); + { +#if TARGET_HOST_POSIX_X11 - XFlush( fgDisplay.Display ); /* This is needed */ + Status status; /* Returned by XGetWindowAttributes(), not checked. */ + XWindowAttributes attributes; - XTranslateCoordinates( - fgDisplay.Display, - fgStructure.CurrentWindow->Window.Handle, - fgDisplay.RootWindow, - 0, 0, &x, &y, &w - ); + status = XGetWindowAttributes(fgDisplay.Display, + fgStructure.CurrentWindow->Window.Handle, + &attributes); + /* + * The "x" and "y" members of "attributes" are the window's coordinates + * relative to its parent, i.e. to the decoration window. + */ + XMoveResizeWindow(fgDisplay.Display, + fgStructure.CurrentWindow->Window.Handle, + -attributes.x, + -attributes.y, + fgDisplay.ScreenWidth, + fgDisplay.ScreenHeight); - if (x || y) - { - XMoveWindow( - fgDisplay.Display, - fgStructure.CurrentWindow->Window.Handle, - -x, -y - ); - XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */ - } #elif TARGET_HOST_MS_WINDOWS && !defined(_WIN32_WCE) /* FIXME: what about WinCE */ RECT rect; @@ -1253,6 +1537,61 @@ void FGAPIENTRY glutFullScreen( void ) } /* + * Toggle the window's full screen state. + */ +void FGAPIENTRY glutFullScreenToggle( void ) +{ + FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutFullScreenToggle" ); + FREEGLUT_EXIT_IF_NO_WINDOW ( "glutFullScreenToggle" ); + + { +#if TARGET_HOST_POSIX_X11 + + if (fgDisplay.StateFullScreen != None) + { + XEvent xevent; + long event_mask; + int status; + + xevent.type = ClientMessage; + xevent.xclient.type = ClientMessage; + xevent.xclient.serial = 0; + xevent.xclient.send_event = True; + xevent.xclient.display = fgDisplay.Display; + xevent.xclient.window = fgStructure.CurrentWindow->Window.Handle; + xevent.xclient.message_type = fgDisplay.State; + xevent.xclient.format = 32; + xevent.xclient.data.l[0] = 2; /* _NET_WM_STATE_TOGGLE */ + xevent.xclient.data.l[1] = fgDisplay.StateFullScreen; + xevent.xclient.data.l[2] = 0; + xevent.xclient.data.l[3] = 0; + xevent.xclient.data.l[4] = 0; + + /*** Don't really understand how event masks work... ***/ + event_mask = SubstructureRedirectMask | SubstructureNotifyMask; + + status = XSendEvent(fgDisplay.Display, + fgDisplay.RootWindow, + False, + event_mask, + &xevent); + FREEGLUT_INTERNAL_ERROR_EXIT(status != 0, + "XSendEvent failed", + "glutFullScreenToggle"); + } + else +#endif + { + /* + * If the window manager is not Net WM compliant, fall back to legacy + * behaviour. + */ + glutFullScreen(); + } + } +} + +/* * A.Donev: Set and retrieve the window's user data */ void* FGAPIENTRY glutGetWindowData( void )