X-Git-Url: http://git.mutantstargoat.com/user/nuclear/?a=blobdiff_plain;f=src%2Ffreeglut_window.c;h=eb1842d10fb727256bb45e9a3f6359103de8383c;hb=0c26580b96f8e2f431489049be61077bd24dd21d;hp=21b3006336e0de96447df0cdd9a22945f8d1b233;hpb=1a7b5b7702bcc093a613b02be7af4720f2618c79;p=freeglut diff --git a/src/freeglut_window.c b/src/freeglut_window.c index 21b3006..eb1842d 100644 --- a/src/freeglut_window.c +++ b/src/freeglut_window.c @@ -29,9 +29,7 @@ #include "config.h" #endif -#define G_LOG_DOMAIN "freeglut-window" - -#include "../include/GL/freeglut.h" +#include #include "freeglut_internal.h" /* @@ -41,8 +39,8 @@ * fgSetupPixelFormat -- ignores the display mode settings * fgOpenWindow() -- check the Win32 version, -iconic handling! * fgCloseWindow() -- check the Win32 version - * glutCreateWindow() -- see what happens when default position and size is {-1,-1} - * glutCreateSubWindow() -- see what happens when default position and size is {-1,-1} + * 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 * glutGetWindow() -- OK @@ -66,98 +64,56 @@ XVisualInfo* fgChooseVisual( void ) { - int bufferSize[] = { 16, 12, 8, 4, 2, 1 }; - GLboolean wantIndexedMode = FALSE; +#define BUFFER_SIZES 6 + int bufferSize[BUFFER_SIZES] = { 16, 12, 8, 4, 2, 1 }; + GLboolean wantIndexedMode = GL_FALSE; int attributes[ 32 ]; int where = 0; /* * First we have to process the display mode settings... */ -# define ATTRIB(a) attributes[where++]=a; +/* + * Why is there a semi-colon in this #define? The code + * that uses the macro seems to always add more semicolons... + */ +#define ATTRIB(a) attributes[where++]=a; +#define ATTRIB_VAL(a,v) {ATTRIB(a); ATTRIB(v);} - /* - * Decide if we want a true or indexed color visual: - */ - if( !(fgState.DisplayMode & GLUT_INDEX) ) + if( fgState.DisplayMode & GLUT_INDEX ) { - /* - * We are sure that there will be R, B and B components requested: - */ - ATTRIB( GLX_RGBA ); - ATTRIB( GLX_RED_SIZE ); ATTRIB( 1 ); - ATTRIB( GLX_GREEN_SIZE ); ATTRIB( 1 ); - ATTRIB( GLX_BLUE_SIZE ); ATTRIB( 1 ); - - /* - * Check if the A component is required, too: - */ - if( fgState.DisplayMode & GLUT_ALPHA ) - { - ATTRIB( GLX_ALPHA_SIZE ); ATTRIB( 1 ); - } + ATTRIB_VAL( GLX_BUFFER_SIZE, 8 ); + wantIndexedMode = GL_TRUE; } else { - /* - * We've got an indexed color request - */ - ATTRIB( GLX_BUFFER_SIZE ); ATTRIB( 8 ); - - /* - * Set the 'I want indexed mode' switch - */ - wantIndexedMode = TRUE; + ATTRIB( GLX_RGBA ); + ATTRIB_VAL( GLX_RED_SIZE, 1 ); + ATTRIB_VAL( GLX_GREEN_SIZE, 1 ); + ATTRIB_VAL( GLX_BLUE_SIZE, 1 ); + if( fgState.DisplayMode & GLUT_ALPHA ) + ATTRIB_VAL( GLX_ALPHA_SIZE, 1 ); } - /* - * We can have double or single buffered contexts created - */ if( fgState.DisplayMode & GLUT_DOUBLE ) - { ATTRIB( GLX_DOUBLEBUFFER ); - } - /* - * Stereoscopy seems a nice thing to have - */ if( fgState.DisplayMode & GLUT_STEREO ) - { ATTRIB( GLX_STEREO ); - } - /* - * Depth buffer is almost always required - */ if( fgState.DisplayMode & GLUT_DEPTH ) - { - ATTRIB( GLX_DEPTH_SIZE ); ATTRIB( 1 ); - } + ATTRIB_VAL( GLX_DEPTH_SIZE, 1 ); - /* - * Stenciling support - */ if( fgState.DisplayMode & GLUT_STENCIL ) - { - ATTRIB( GLX_STENCIL_SIZE ); ATTRIB( 1 ); - } + ATTRIB_VAL( GLX_STENCIL_SIZE, 1 ); - /* - * And finally the accumulation buffers - */ if( fgState.DisplayMode & GLUT_ACCUM ) { - ATTRIB( GLX_ACCUM_RED_SIZE ); ATTRIB( 1 ); - ATTRIB( GLX_ACCUM_GREEN_SIZE ); ATTRIB( 1 ); - ATTRIB( GLX_ACCUM_BLUE_SIZE ); ATTRIB( 1 ); - - /* - * Check if the A component is required, too: - */ + ATTRIB_VAL( GLX_ACCUM_RED_SIZE, 1 ); + ATTRIB_VAL( GLX_ACCUM_GREEN_SIZE, 1 ); + ATTRIB_VAL( GLX_ACCUM_BLUE_SIZE, 1 ); if( fgState.DisplayMode & GLUT_ALPHA ) - { - ATTRIB( GLX_ACCUM_ALPHA_SIZE ); ATTRIB( 1 ); - } + ATTRIB_VAL( GLX_ACCUM_ALPHA_SIZE, 1 ); } /* @@ -165,48 +121,28 @@ XVisualInfo* fgChooseVisual( void ) */ ATTRIB( None ); - /* - * OKi now, we've got two cases -- RGB(A) and index mode visuals - */ - if( wantIndexedMode == FALSE ) - { - /* - * The easier one. And more common, too. - */ - return( glXChooseVisual( fgDisplay.Display, fgDisplay.Screen, attributes ) ); - } + if( ! wantIndexedMode ) + return glXChooseVisual( fgDisplay.Display, fgDisplay.Screen, + attributes ); else { XVisualInfo* visualInfo; int i; /* - * In indexed mode, we need to check how many bits of depth can we achieve + * 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<6; i++ ) + for( i=0; iWindow.Device, BITSPIXEL ); - ppfd = &pfd; - - /* - * Choose the pixel format that matches our demand - */ - pixelformat = ChoosePixelFormat( window->Window.Device, ppfd ); - if( pixelformat == 0 ) - return( FALSE ); - - /* - * We might have been called to check if the pixel format exists only - */ - if( checkOnly ) - return( TRUE ); - - /* - * Finally, set the window's pixel format - */ - return ( SetPixelFormat( window->Window.Device, pixelformat, ppfd ) ) ; + pfd.cAuxBuffers = 0; + pfd.iLayerType = layer_type; + pfd.bReserved = 0; + pfd.dwLayerMask = 0; + pfd.dwVisibleMask = 0; + pfd.dwDamageMask = 0; + + pfd.cColorBits = (BYTE) GetDeviceCaps( window->Window.Device, BITSPIXEL ); + ppfd = &pfd; + + pixelformat = ChoosePixelFormat( window->Window.Device, ppfd ); + if( pixelformat == 0 ) + return GL_FALSE; + + if( checkOnly ) + return GL_TRUE; + return SetPixelFormat( window->Window.Device, pixelformat, ppfd ); } #endif /* - * Sets the OpenGL context and the fgStructure "Current Window" pointer to the window - * structure passed in. + * Sets the OpenGL context and the fgStructure "Current Window" pointer to + * the window structure passed in. */ void fgSetWindow ( SFG_Window *window ) { #if TARGET_HOST_UNIX_X11 - /* - * Make the selected window's GLX context the current one - */ - glXMakeCurrent( - fgDisplay.Display, - window->Window.Handle, - window->Window.Context - ); - + if ( window ) + glXMakeCurrent( + fgDisplay.Display, + window->Window.Handle, + window->Window.Context + ); #elif TARGET_HOST_WIN32 - /* - * Release the previous' context's device context - */ - if( fgStructure.Window != NULL ) - ReleaseDC( fgStructure.Window->Window.Handle, fgStructure.Window->Window.Device ); - - if ( window ) - { - /* - * We will care about releasing the device context later - */ - window->Window.Device = GetDC( window->Window.Handle ); - - /* - * Set the new current context: - */ - wglMakeCurrent( - window->Window.Device, - window->Window.Context - ); - } -#endif + if( fgStructure.Window ) + ReleaseDC( fgStructure.Window->Window.Handle, + fgStructure.Window->Window.Device ); - /* - * Remember that we have changed the current window state - */ + if ( window ) + { + window->Window.Device = GetDC( window->Window.Handle ); + wglMakeCurrent( + window->Window.Device, + window->Window.Context + ); + } +#endif fgStructure.Window = window; } @@ -350,7 +249,9 @@ void fgSetWindow ( SFG_Window *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, int x, int y, int w, int h, GLboolean gameMode, int isSubWindow ) +void fgOpenWindow( SFG_Window* window, const char* title, + int x, int y, int w, int h, + GLboolean gameMode, GLboolean isSubWindow ) { #if TARGET_HOST_UNIX_X11 XSetWindowAttributes winAttr; @@ -362,147 +263,163 @@ void fgOpenWindow( SFG_Window* window, const char* title, int x, int y, int w, i freeglut_assert_ready; /* - * Here we are upon the stage. Have the visual selected. + * XXX fgChooseVisual() is a common part of all three. + * XXX With a little thought, we should be able to greatly + * XXX simplify this. */ - if ( fgState.BuildingAMenu ) + if( !window->IsMenu ) + window->Window.VisualInfo = fgChooseVisual( ); + else if( fgStructure.MenuContext ) + window->Window.VisualInfo = fgChooseVisual( ); + else { - /* - * If there isn't already an OpenGL rendering context for menu windows, make one - */ - if ( !fgStructure.MenuContext ) - { + /* XXX Why are menus double- and depth-buffered? */ unsigned int current_DisplayMode = fgState.DisplayMode ; fgState.DisplayMode = GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH ; - window->Window.VisualInfo = fgChooseVisual(); + window->Window.VisualInfo = fgChooseVisual( ); fgState.DisplayMode = current_DisplayMode ; - } - else - window->Window.VisualInfo = fgChooseVisual(); } - else - window->Window.VisualInfo = fgChooseVisual(); - if ( ! window->Window.VisualInfo ) + if( ! window->Window.VisualInfo ) { - /* - * The "fgChooseVisual" 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 ) ) - { /* - * Single buffering--try it doubled + * The "fgChooseVisual" 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( ); + fgState.DisplayMode &= ~GLUT_DOUBLE; + } + + /* + * GLUT also checks for multi-sampling, but I don't see that + * anywhere else in FREEGLUT so I won't bother with it for the moment. */ - fgState.DisplayMode |= GLUT_DOUBLE ; - window->Window.VisualInfo = fgChooseVisual(); - } - - /* - * GLUT also checks for multi-sampling, but I don't see that anywhere else in FREEGLUT - * so I won't bother with it for the moment. - */ } - assert( window->Window.VisualInfo != NULL ); - - /* - * Have the windows attributes set - * - * HINT: the masks should be updated when adding/removing callbacks. - * This might speed up message processing. Is that true? - */ - winAttr.event_mask = StructureNotifyMask | SubstructureNotifyMask | ExposureMask | - ButtonPressMask | ButtonReleaseMask | KeyPressMask | KeyRelease | - VisibilityChangeMask | EnterWindowMask | LeaveWindowMask | - PointerMotionMask | ButtonMotionMask; - winAttr.background_pixmap = None; - winAttr.background_pixel = 0; - winAttr.border_pixel = 0; - /* - * The color map is required, too + * XXX This seems to be abusing an assert() for error-checking. + * XXX It is possible that the visual simply can't be found, + * XXX in which case we should print an error and return a 0 + * XXX for the window id, I think. */ - winAttr.colormap = XCreateColormap( - fgDisplay.Display, fgDisplay.RootWindow, - window->Window.VisualInfo->visual, AllocNone - ); - - /* - * This tells the XCreateWindow() what attributes are we supplying it with - */ - mask = CWBackPixmap | CWBorderPixel | CWColormap | CWEventMask; + assert( window->Window.VisualInfo != NULL ); - /* - * If this is a menu window we want the window manager to ignore it. - */ - if ( fgState.BuildingAMenu ) + window->State.IsOffscreen = GL_FALSE; + if( fgState.DisplayMode & GLUT_OFFSCREEN ) { - winAttr.override_redirect = True; - mask |= CWOverrideRedirect; + window->State.IsOffscreen = GL_TRUE; + window->Window.Pixmap = XCreatePixmap( + fgDisplay.Display, fgDisplay.RootWindow, + w, h, + window->Window.VisualInfo->depth + ); + if( False != window->Window.Pixmap ) + { + window->Window.Handle = glXCreateGLXPixmap( + fgDisplay.Display, + window->Window.VisualInfo, + window->Window.Pixmap + ); + if( False == window->Window.Handle ) + XFreePixmap( fgDisplay.Display, window->Window.Pixmap ); + } } + else + { + /* + * XXX HINT: the masks should be updated when adding/removing callbacks. + * XXX This might speed up message processing. Is that true? + * XXX + * XXX A: Not appreciably, but it WILL make it easier to debug. + * XXX Try tracing old GLUT and try tracing freeglut. Old GLUT + * XXX turns off events that it doesn't need and is a whole lot + * XXX more pleasant to trace. (Think mouse-motion! Tons of + * XXX ``bonus'' GUI events stream in.) + */ + winAttr.event_mask = + StructureNotifyMask | SubstructureNotifyMask | ExposureMask | + ButtonPressMask | ButtonReleaseMask | KeyPressMask | KeyRelease | + VisibilityChangeMask | EnterWindowMask | LeaveWindowMask | + PointerMotionMask | ButtonMotionMask; + winAttr.background_pixmap = None; + winAttr.background_pixel = 0; + winAttr.border_pixel = 0; + + winAttr.colormap = XCreateColormap( + fgDisplay.Display, fgDisplay.RootWindow, + window->Window.VisualInfo->visual, AllocNone + ); - /* - * Have the window created now - */ - window->Window.Handle = XCreateWindow( - fgDisplay.Display, - window->Parent == NULL ? fgDisplay.RootWindow : window->Parent->Window.Handle, - x, y, w, h, 0, - window->Window.VisualInfo->depth, InputOutput, - window->Window.VisualInfo->visual, mask, - &winAttr - ); + mask = CWBackPixmap | CWBorderPixel | CWColormap | CWEventMask; + + if ( window->IsMenu ) + { + winAttr.override_redirect = True; + mask |= CWOverrideRedirect; + } + window->Window.Handle = XCreateWindow( + fgDisplay.Display, + window->Parent == NULL ? fgDisplay.RootWindow : + window->Parent->Window.Handle, + x, y, w, h, 0, + window->Window.VisualInfo->depth, InputOutput, + window->Window.VisualInfo->visual, mask, + &winAttr + ); + } /* * The GLX context creation, possibly trying the direct context rendering * or else use the current context if the user has so specified */ - if ( fgState.BuildingAMenu ) + if( window->IsMenu ) { - /* - * If there isn't already an OpenGL rendering context for menu windows, make one - */ - if ( !fgStructure.MenuContext ) - { - fgStructure.MenuContext = (SFG_MenuContext *)malloc ( sizeof(SFG_MenuContext) ) ; - fgStructure.MenuContext->VisualInfo = window->Window.VisualInfo ; - fgStructure.MenuContext->Context = glXCreateContext( - fgDisplay.Display, fgStructure.MenuContext->VisualInfo, - NULL, fgState.ForceDirectContext | fgState.TryDirectContext - ); - } + /* + * If there isn't already an OpenGL rendering context for menu + * windows, make one + */ + if( !fgStructure.MenuContext ) + { + fgStructure.MenuContext = + (SFG_MenuContext *)malloc( sizeof(SFG_MenuContext) ); + fgStructure.MenuContext->VisualInfo = window->Window.VisualInfo; + fgStructure.MenuContext->Context = glXCreateContext( + fgDisplay.Display, fgStructure.MenuContext->VisualInfo, + NULL, fgState.ForceDirectContext | fgState.TryDirectContext + ); + } -/* window->Window.Context = fgStructure.MenuContext->Context ; */ - window->Window.Context = glXCreateContext( + /* window->Window.Context = fgStructure.MenuContext->Context; */ + window->Window.Context = glXCreateContext( fgDisplay.Display, window->Window.VisualInfo, NULL, fgState.ForceDirectContext | fgState.TryDirectContext ); } - else if ( fgState.UseCurrentContext == TRUE ) + else if( fgState.UseCurrentContext ) { - window->Window.Context = glXGetCurrentContext(); + window->Window.Context = glXGetCurrentContext( ); - if ( ! window->Window.Context ) + if( ! window->Window.Context ) + window->Window.Context = glXCreateContext( + fgDisplay.Display, window->Window.VisualInfo, + NULL, fgState.ForceDirectContext | fgState.TryDirectContext + ); + } + else window->Window.Context = glXCreateContext( fgDisplay.Display, window->Window.VisualInfo, NULL, fgState.ForceDirectContext | fgState.TryDirectContext ); - } - else - window->Window.Context = glXCreateContext( - fgDisplay.Display, window->Window.VisualInfo, - NULL, fgState.ForceDirectContext | fgState.TryDirectContext - ); - /* - * Make sure the context is direct when the user wants it forced - */ - if( fgState.ForceDirectContext && !glXIsDirect( fgDisplay.Display, window->Window.Context ) ) - fgError( "unable to force direct context rendering for window '%s'", title ); + if( fgState.ForceDirectContext && + !glXIsDirect( fgDisplay.Display, window->Window.Context ) ) + fgError( "unable to force direct context rendering for window '%s'", + title ); - /* - * Set the new context as the current one. That's all about the window creation. - */ glXMakeCurrent( fgDisplay.Display, window->Window.Handle, @@ -510,168 +427,155 @@ void fgOpenWindow( SFG_Window* window, const char* title, int x, int y, int w, i ); /* - * Assume the new window is visible by default + * XXX Assume the new window is visible by default + * XXX Is this a safe assumption? */ - window->State.Visible = TRUE; + window->State.Visible = GL_TRUE; - /* - * For the position and size hints -- make sure we are passing valid values - */ sizeHints.flags = 0; - - if (fgState.Position.Use == TRUE) sizeHints.flags |= USPosition; - if (fgState.Size.Use == TRUE) sizeHints.flags |= USSize; + if ( fgState.Position.Use ) + sizeHints.flags |= USPosition; + if ( fgState.Size.Use ) + sizeHints.flags |= USSize; /* * Fill in the size hints values now (the x, y, width and height * settings are obsolote, are there any more WMs that support them?) + * Unless the X servers actually stop supporting these, we should + * continue to fill them in. It is *not* our place to tell the user + * that they should replace a window manager that they like, and which + * works, just because *we* think that it's not "modern" enough. */ - sizeHints.x = x; sizeHints.y = y; - sizeHints.width = w; sizeHints.height = h; + sizeHints.x = x; + sizeHints.y = y; + sizeHints.width = w; + sizeHints.height = h; - /* - * We can have forced all new windows start in iconified state: - */ wmHints.flags = StateHint; - wmHints.initial_state = (fgState.ForceIconic == FALSE) ? NormalState : IconicState; - - /* - * Prepare the window and iconified window names... - */ - XStringListToTextProperty( (char **) &title, 1, &textProperty ); - - /* - * Set the window's properties now - */ - XSetWMProperties( - fgDisplay.Display, - window->Window.Handle, - &textProperty, - &textProperty, - 0, - 0, - &sizeHints, - &wmHints, - NULL - ); - - /* - * Make sure we are informed about the window deletion commands - */ - XSetWMProtocols( fgDisplay.Display, window->Window.Handle, &fgDisplay.DeleteWindow, 1 ); - - /* - * Finally, have the window mapped to our display - */ - XMapWindow( fgDisplay.Display, window->Window.Handle ); - + wmHints.initial_state = fgState.ForceIconic ? IconicState : NormalState; + if( GL_FALSE == window->State.IsOffscreen ) + { + /* + * Prepare the window and iconified window names... + */ + XStringListToTextProperty( (char **) &title, 1, &textProperty ); + + XSetWMProperties( + fgDisplay.Display, + window->Window.Handle, + &textProperty, + &textProperty, + 0, + 0, + &sizeHints, + &wmHints, + NULL + ); + + XSetWMProtocols( fgDisplay.Display, window->Window.Handle, + &fgDisplay.DeleteWindow, 1 ); + + XMapWindow( fgDisplay.Display, window->Window.Handle ); + } + #elif TARGET_HOST_WIN32 - WNDCLASS wc; - int flags; - ATOM atom; + WNDCLASS wc; + DWORD flags; + DWORD exFlags = 0; + ATOM atom; freeglut_assert_ready; - - /* - * Grab the window class we have registered on glutInit(): - */ - atom = GetClassInfo( fgDisplay.Instance, "FREEGLUT", &wc ); - assert( atom != 0 ); - - if( gameMode == FALSE ) + + /* + * Grab the window class we have registered on glutInit(): + */ + atom = GetClassInfo( fgDisplay.Instance, "FREEGLUT", &wc ); + assert( atom != 0 ); + + if( gameMode ) { - if ( ( !isSubWindow ) && ( ! window->IsMenu ) ) - { + assert( window->Parent == NULL ); + /* - * Update the window dimensions, taking account of window decorations. - * "freeglut" is to create the window with the outside of its border at (x,y) - * and with dimensions (w,h). + * Set the window creation flags appropriately to make the window + * entirely visible: */ - w += (GetSystemMetrics( SM_CXSIZEFRAME ) )*2; - h += (GetSystemMetrics( SM_CYSIZEFRAME ) )*2 + GetSystemMetrics( SM_CYCAPTION ); - } - - /* - * Check if the user wants us to use the default position/size - */ - if( fgState.Position.Use == FALSE ) { x = CW_USEDEFAULT; y = CW_USEDEFAULT; } - if( fgState.Size .Use == FALSE ) { w = CW_USEDEFAULT; h = CW_USEDEFAULT; } - - /* - * There's a small difference between creating the top, child and game mode windows - */ - flags = WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_VISIBLE; - - /* - * If we're a menu, set our flags to include WS_POPUP to remove decorations - */ - if ( window->IsMenu ) - flags |= WS_POPUP ; - else if( window->Parent == NULL ) - flags |= WS_OVERLAPPEDWINDOW; - else - flags |= WS_CHILD; + flags = WS_POPUP | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_VISIBLE; } else { - /* - * In game mode, the story is a little bit different... - */ - assert( window->Parent == NULL ); + if ( ( ! isSubWindow ) && ( ! window->IsMenu ) ) + { + /* + * Update the window dimensions, taking account of window + * decorations. "freeglut" is to create the window with the + * outside of its border at (x,y) and with dimensions (w,h). + */ + w += (GetSystemMetrics( SM_CXSIZEFRAME ) )*2; + h += (GetSystemMetrics( SM_CYSIZEFRAME ) )*2 + + GetSystemMetrics( SM_CYCAPTION ); + } + + if( ! fgState.Position.Use ) + { + x = CW_USEDEFAULT; + y = CW_USEDEFAULT; + } + if( ! fgState.Size.Use ) + { + w = CW_USEDEFAULT; + h = CW_USEDEFAULT; + } /* - * Set the window creation flags appropriately to make the window entirely visible: + * There's a small difference between creating the top, child and + * game mode windows */ - flags = WS_POPUP | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_VISIBLE; + flags = WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_VISIBLE; + + if ( window->IsMenu ) + { + flags |= WS_POPUP; + exFlags |= WS_EX_TOOLWINDOW; + } + else if( window->Parent == NULL ) + flags |= WS_OVERLAPPEDWINDOW; + else + flags |= WS_CHILD; } - /* - * Create the window now, passing the freeglut window structure as the parameter - */ - window->Window.Handle = CreateWindow( - "FREEGLUT", + window->Window.Handle = CreateWindowEx( + exFlags, + "FREEGLUT", title, - flags, + flags, x, y, w, h, - (HWND) window->Parent == NULL ? NULL : window->Parent->Window.Handle, - (HMENU) NULL, - fgDisplay.Instance, - (LPVOID) window - ); - - /* - * Make sure window was created - */ - assert( window->Window.Handle != NULL ); + (HWND) window->Parent == NULL ? NULL : window->Parent->Window.Handle, + (HMENU) NULL, + fgDisplay.Instance, + (LPVOID) window + ); + if( !( window->Window.Handle ) ) + fgError( "Failed to create a window (%s)!", title ); - /* - * Show and update the main window. Hide the mouse cursor. - */ - ShowWindow( window->Window.Handle, fgState.ForceIconic ? SW_SHOWMINIMIZED : SW_SHOW ); + ShowWindow( window->Window.Handle, + fgState.ForceIconic ? SW_SHOWMINIMIZED : SW_SHOW ); UpdateWindow( window->Window.Handle ); - ShowCursor( TRUE ); + ShowCursor( TRUE ); /* XXX Old comments say "hide cusror"! */ #endif - /* - * Save the window's single- or double-buffering state - */ - window->Window.DoubleBuffered = ( fgState.DisplayMode & GLUT_DOUBLE ) ? 1 : 0 ; + fgSetWindow( window ); + + window->Window.DoubleBuffered = + ( fgState.DisplayMode & GLUT_DOUBLE ) ? 1 : 0; - /* - * If it's not double-buffered, make sure the rendering is done to the front buffer. - */ if ( ! window->Window.DoubleBuffered ) { - glDrawBuffer ( GL_FRONT ) ; - glReadBuffer ( GL_FRONT ) ; + glDrawBuffer ( GL_FRONT ); + glReadBuffer ( GL_FRONT ); } - - /* - * Set the newly created window as the current one - */ - fgSetWindow( window ); } /* @@ -682,32 +586,47 @@ void fgCloseWindow( SFG_Window* window ) freeglut_assert_ready; #if TARGET_HOST_UNIX_X11 - /* - * As easy as kill bunnies with axes. Destroy the context first: - */ + glXDestroyContext( fgDisplay.Display, window->Window.Context ); + if( GL_FALSE == window->State.IsOffscreen ) + XDestroyWindow( fgDisplay.Display, window->Window.Handle ); + else + { + glXDestroyGLXPixmap( fgDisplay.Display, window->Window.Handle ); + XFreePixmap( fgDisplay.Display, window->Window.Pixmap ); + } + XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */ + +#elif TARGET_HOST_WIN32 /* - * Then have the window killed: + * Make sure we don't close a window with current context active */ - XDestroyWindow( fgDisplay.Display, window->Window.Handle ); + if( fgStructure.Window == window ) + wglMakeCurrent( NULL, NULL ); /* - * Finally, flush the rests down the stream + * Step through the list of windows. If the rendering context + * is not being used by another window, then we delete it. */ - XFlush( fgDisplay.Display ); + { + int used = FALSE ; + SFG_Window *iter ; -#elif TARGET_HOST_WIN32 - /* - * Send the WM_CLOSE message to the window now - */ - SendMessage( - window->Window.Handle, - WM_CLOSE, - 0, - 0 - ); + for( iter = (SFG_Window *)fgStructure.Windows.First; + iter; + iter = (SFG_Window *)iter->Node.Next ) + { + if( ( iter->Window.Context == window->Window.Context ) && + ( iter != window ) ) + used = TRUE; + } + + if( ! used ) + wglDeleteContext( window->Window.Context ); + } + DestroyWindow( window->Window.Handle ); #endif } @@ -719,11 +638,9 @@ void fgCloseWindow( SFG_Window* window ) */ int FGAPIENTRY glutCreateWindow( const char* title ) { - /* - * Create a new window and return its unique ID number - */ - return( fgCreateWindow( NULL, title, fgState.Position.X, fgState.Position.Y, - fgState.Size.X, fgState.Size.Y, FALSE )->ID ); + return fgCreateWindow( NULL, title, fgState.Position.X, fgState.Position.Y, + fgState.Size.X, fgState.Size.Y, GL_FALSE, + GL_FALSE )->ID; } /* @@ -731,30 +648,20 @@ int FGAPIENTRY glutCreateWindow( const char* title ) */ int FGAPIENTRY glutCreateSubWindow( int parentID, int x, int y, int w, int h ) { - SFG_Window* window = NULL; - SFG_Window* parent = NULL; - - freeglut_assert_ready; - - /* - * Find a parent to the newly created window... - */ - parent = fgWindowByID( parentID ); - - /* - * Fail if the parent has not been found - */ - freeglut_return_val_if_fail( parent != NULL, 0 ); - - /* - * Create the new window - */ - window = fgCreateWindow( parent, "", x, y, w, h, FALSE ); - - /* - * Return the new window's ID - */ - return( window->ID ); + int ret = 0; + + if( GL_FALSE == fgStructure.Window->State.IsOffscreen ) + { + SFG_Window* window = NULL; + SFG_Window* parent = NULL; + + freeglut_assert_ready; + parent = fgWindowByID( parentID ); + freeglut_return_val_if_fail( parent != NULL, 0 ); + window = fgCreateWindow( parent, "", x, y, w, h, GL_FALSE, GL_FALSE ); + ret = window->ID; + } + return ret; } /* @@ -762,25 +669,13 @@ int FGAPIENTRY glutCreateSubWindow( int parentID, int x, int y, int w, int h ) */ void FGAPIENTRY glutDestroyWindow( int windowID ) { - fgExecutionState ExecState = fgState.ExecState ; - - /* - * Grab the freeglut window pointer from the structure - */ - SFG_Window* window = fgWindowByID( windowID ); - freeglut_return_if_fail( window != NULL ); - - /* - * There is a function that performs all needed steps - * defined in freeglut_structure.c. Let's use it: - */ - fgAddToWindowDestroyList( window, TRUE ); - - /* - * Since the "fgAddToWindowDestroyList" function could easily have set the "ExecState" - * to stop, let's set it back to what it was. - */ - fgState.ExecState = ExecState ; + SFG_Window* window = fgWindowByID( windowID ); + freeglut_return_if_fail( window != NULL ); + { + fgExecutionState ExecState = fgState.ExecState; + fgAddToWindowDestroyList( window ); + fgState.ExecState = ExecState; + } } /* @@ -790,36 +685,19 @@ void FGAPIENTRY glutSetWindow( int ID ) { SFG_Window* window = NULL; - /* - * Make sure we don't get called too early - */ freeglut_assert_ready; - - /* - * Be wise. Be wise. Be wise. Be quick. - */ if( fgStructure.Window != NULL ) if( fgStructure.Window->ID == ID ) return; - /* - * Now we are sure there is sense in looking for the window - */ window = fgWindowByID( ID ); - - /* - * In the case of an utter failure... - */ if( window == NULL ) { - /* - * ...issue a warning message and keep rolling on - */ fgWarning( "glutSetWindow(): window ID %i not found!", ID ); return; } - fgSetWindow ( window ) ; + fgSetWindow( window ); } /* @@ -828,22 +706,9 @@ void FGAPIENTRY glutSetWindow( int ID ) int FGAPIENTRY glutGetWindow( void ) { freeglut_assert_ready; - - /* - * Do we have a current window selected? - */ if( fgStructure.Window == NULL ) - { - /* - * Nope. Return zero to mark the state. - */ - return( 0 ); - } - - /* - * Otherwise, return the ID of the current window - */ - return( fgStructure.Window->ID ); + return 0; + return fgStructure.Window->ID; } /* @@ -851,28 +716,23 @@ int FGAPIENTRY glutGetWindow( void ) */ void FGAPIENTRY glutShowWindow( void ) { - freeglut_assert_ready; freeglut_assert_window; + freeglut_assert_ready; + freeglut_assert_window; + if( GL_FALSE == fgStructure.Window->State.IsOffscreen ) + { #if TARGET_HOST_UNIX_X11 - /* - * Showing the window is done via mapping under X - */ - XMapWindow( fgDisplay.Display, fgStructure.Window->Window.Handle ); - XFlush( fgDisplay.Display ); -#elif TARGET_HOST_WIN32 - /* - * Restore the window's originial position and size - */ - ShowWindow( fgStructure.Window->Window.Handle, SW_SHOW ); + XMapWindow( fgDisplay.Display, fgStructure.Window->Window.Handle ); + XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */ -#endif +#elif TARGET_HOST_WIN32 - /* - * Since the window is visible, we need to redisplay it ... - */ - fgStructure.Window->State.Redisplay = TRUE; + ShowWindow( fgStructure.Window->Window.Handle, SW_SHOW ); +#endif + } + fgStructure.Window->State.Redisplay = GL_TRUE; } /* @@ -880,45 +740,29 @@ void FGAPIENTRY glutShowWindow( void ) */ void FGAPIENTRY glutHideWindow( void ) { - freeglut_assert_ready; freeglut_assert_window; + freeglut_assert_ready; + freeglut_assert_window; -#if TARGET_HOST_UNIX_X11 - /* - * The way we hide a window depends on if we're dealing - * with a top-level or children one... - */ - if( fgStructure.Window->Parent == NULL ) + if( GL_FALSE == fgStructure.Window->State.IsOffscreen ) { - /* - * This is a top-level window - */ - XWithdrawWindow( fgDisplay.Display, fgStructure.Window->Window.Handle, fgDisplay.Screen ); - } - else - { - /* - * Nope, it's a child window - */ - XUnmapWindow( fgDisplay.Display, fgStructure.Window->Window.Handle ); - } +#if TARGET_HOST_UNIX_X11 - /* - * Flush the X state now - */ - XFlush( fgDisplay.Display ); + if( fgStructure.Window->Parent == NULL ) + XWithdrawWindow( fgDisplay.Display, + fgStructure.Window->Window.Handle, + fgDisplay.Screen ); + else + XUnmapWindow( fgDisplay.Display, + fgStructure.Window->Window.Handle ); + XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */ #elif TARGET_HOST_WIN32 - /* - * Hide the window - */ - ShowWindow( fgStructure.Window->Window.Handle, SW_HIDE ); -#endif + ShowWindow( fgStructure.Window->Window.Handle, SW_HIDE ); - /* - * Since the window is hidden, we don't need to redisplay it ... - */ - fgStructure.Window->State.Redisplay = FALSE; +#endif + } + fgStructure.Window->State.Redisplay = GL_FALSE; } /* @@ -926,28 +770,25 @@ void FGAPIENTRY glutHideWindow( void ) */ void FGAPIENTRY glutIconifyWindow( void ) { - freeglut_assert_ready; freeglut_assert_window; + freeglut_assert_ready; + freeglut_assert_window; + fgStructure.Window->State.Visible = GL_FALSE; + if( GL_FALSE == fgStructure.Window->State.IsOffscreen ) + { #if TARGET_HOST_UNIX_X11 - /* - * Iconify the window and flush the X state - */ - XIconifyWindow( fgDisplay.Display, fgStructure.Window->Window.Handle, fgDisplay.Screen ); - XFlush( fgDisplay.Display ); -#elif TARGET_HOST_WIN32 - /* - * Minimize the current window (this should be the same as X window iconifying) - */ - ShowWindow( fgStructure.Window->Window.Handle, SW_MINIMIZE ); + XIconifyWindow( fgDisplay.Display, fgStructure.Window->Window.Handle, + fgDisplay.Screen ); + XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */ -#endif +#elif TARGET_HOST_WIN32 - /* - * Since the window is just an icon, we don't need to redisplay it ... - */ - fgStructure.Window->State.Redisplay = FALSE; + ShowWindow( fgStructure.Window->Window.Handle, SW_MINIMIZE ); +#endif + } + fgStructure.Window->State.Redisplay = GL_FALSE; } /* @@ -955,48 +796,34 @@ void FGAPIENTRY glutIconifyWindow( void ) */ void FGAPIENTRY glutSetWindowTitle( const char* title ) { - freeglut_assert_ready; freeglut_assert_window; - - /* - * Works only for top-level windows - */ - if( fgStructure.Window->Parent != NULL ) - return; - + freeglut_assert_ready; + freeglut_assert_window; + if( ! fgStructure.Window->Parent && + ( GL_FALSE == fgStructure.Window->State.IsOffscreen ) ) + { #if TARGET_HOST_UNIX_X11 - { - XTextProperty text; - - /* - * Prepare the text properties - */ - text.value = (unsigned char *) title; - text.encoding = XA_STRING; - text.format = 8; - text.nitems = strlen( title ); - - /* - * Set the title now - */ - XSetWMName( - fgDisplay.Display, - fgStructure.Window->Window.Handle, - &text - ); - - /* - * Have the X display state flushed - */ - XFlush( fgDisplay.Display ); - } + + XTextProperty text; + + text.value = (unsigned char *) title; + text.encoding = XA_STRING; + text.format = 8; + text.nitems = strlen( title ); + + XSetWMName( + fgDisplay.Display, + fgStructure.Window->Window.Handle, + &text + ); + + XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */ #elif TARGET_HOST_WIN32 - /* - * This seems to be a bit easier under Win32 - */ - SetWindowText( fgStructure.Window->Window.Handle, title ); + + SetWindowText( fgStructure.Window->Window.Handle, title ); #endif + } } /* @@ -1004,48 +831,35 @@ void FGAPIENTRY glutSetWindowTitle( const char* title ) */ void FGAPIENTRY glutSetIconTitle( const char* title ) { - freeglut_assert_ready; freeglut_assert_window; - - /* - * Works only for top-level windows - */ - if( fgStructure.Window->Parent != NULL ) - return; + freeglut_assert_ready; + freeglut_assert_window; + if( ! fgStructure.Window->Parent && + GL_FALSE == fgStructure.Window->State.IsOffscreen ) + { #if TARGET_HOST_UNIX_X11 - { - XTextProperty text; - - /* - * Prepare the text properties - */ - text.value = (unsigned char *) title; - text.encoding = XA_STRING; - text.format = 8; - text.nitems = strlen( title ); - - /* - * Set the title now - */ - XSetWMIconName( - fgDisplay.Display, - fgStructure.Window->Window.Handle, - &text - ); - - /* - * Have the X display state flushed - */ - XFlush( fgDisplay.Display ); - } + + XTextProperty text; + + text.value = (unsigned char *) title; + text.encoding = XA_STRING; + text.format = 8; + text.nitems = strlen( title ); + + XSetWMIconName( + fgDisplay.Display, + fgStructure.Window->Window.Handle, + &text + ); + + XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */ #elif TARGET_HOST_WIN32 - /* - * This seems to be a bit easier under Win32 - */ - SetWindowText( fgStructure.Window->Window.Handle, title ); + + SetWindowText( fgStructure.Window->Window.Handle, title ); #endif + } } /* @@ -1053,58 +867,16 @@ void FGAPIENTRY glutSetIconTitle( const char* title ) */ void FGAPIENTRY glutReshapeWindow( int width, int height ) { - freeglut_assert_ready; freeglut_assert_window; - -#if TARGET_HOST_UNIX_X11 - /* - * Resize the window and flush the X state - */ - XResizeWindow( fgDisplay.Display, fgStructure.Window->Window.Handle, width, height ); - XFlush( fgDisplay.Display ); + freeglut_assert_ready; + freeglut_assert_window; -#elif TARGET_HOST_WIN32 - { - RECT winRect; - int x, y ; - - /* - * First off, grab the current window's position - */ - GetWindowRect( fgStructure.Window->Window.Handle, &winRect ); - x = winRect.left ; - y = winRect.top ; - - if ( fgStructure.Window->Parent == NULL ) /* If this is not a subwindow ... */ + /* XXX Could delete/create/set-window-id for offscreen. */ + if( GL_FALSE == fgStructure.Window->State.IsOffscreen ) { - /* - * Adjust the size of the window to allow for the size of the frame, if we are not a menu - */ - if ( ! fgStructure.Window->IsMenu ) - { - width += GetSystemMetrics( SM_CXSIZEFRAME ) * 2; - height += GetSystemMetrics( SM_CYSIZEFRAME ) * 2 + GetSystemMetrics( SM_CYCAPTION ); - } + fgStructure.Window->State.NeedToResize = GL_TRUE; + fgStructure.Window->State.Width = width ; + fgStructure.Window->State.Height = height; } - else /* This is a subwindow, get the parent window's position and subtract it off */ - { - GetWindowRect ( fgStructure.Window->Parent->Window.Handle, &winRect ) ; - x -= winRect.left + GetSystemMetrics( SM_CXSIZEFRAME ) ; - y -= winRect.top + GetSystemMetrics( SM_CYSIZEFRAME ) + GetSystemMetrics( SM_CYCAPTION ) ; - } - - /* - * Resize the window, forcing a redraw to happen - */ - MoveWindow( - fgStructure.Window->Window.Handle, - x, - y, - width, - height, - TRUE - ); - } -#endif } /* @@ -1112,38 +884,33 @@ void FGAPIENTRY glutReshapeWindow( int width, int height ) */ void FGAPIENTRY glutPositionWindow( int x, int y ) { - freeglut_assert_ready; freeglut_assert_window; + freeglut_assert_ready; + freeglut_assert_window; + if( GL_FALSE == fgStructure.Window->State.IsOffscreen ) + { #if TARGET_HOST_UNIX_X11 - /* - * Reposition the window and flush the X state - */ - XMoveWindow( fgDisplay.Display, fgStructure.Window->Window.Handle, x, y ); - XFlush( fgDisplay.Display ); -#elif TARGET_HOST_WIN32 - { - RECT winRect; + XMoveWindow( fgDisplay.Display, fgStructure.Window->Window.Handle, + x, y ); + XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */ - /* - * First off, grab the current window's position - */ - GetWindowRect( fgStructure.Window->Window.Handle, &winRect ); +#elif TARGET_HOST_WIN32 - /* - * Reposition the window, forcing a redraw to happen - */ - MoveWindow( - fgStructure.Window->Window.Handle, - x, - y, - winRect.right - winRect.left, - winRect.bottom - winRect.top, - TRUE - ); - } + RECT winRect; + + GetWindowRect( fgStructure.Window->Window.Handle, &winRect ); + MoveWindow( + fgStructure.Window->Window.Handle, + x, + y, + winRect.right - winRect.left, + winRect.bottom - winRect.top, + TRUE + ); #endif + } } /* @@ -1151,26 +918,26 @@ void FGAPIENTRY glutPositionWindow( int x, int y ) */ void FGAPIENTRY glutPushWindow( void ) { - freeglut_assert_ready; freeglut_assert_window; + freeglut_assert_ready; + freeglut_assert_window; + if( GL_FALSE == fgStructure.Window->State.IsOffscreen ) + { #if TARGET_HOST_UNIX_X11 - /* - * Lower the current window - */ - XLowerWindow( fgDisplay.Display, fgStructure.Window->Window.Handle ); + + XLowerWindow( fgDisplay.Display, fgStructure.Window->Window.Handle ); #elif TARGET_HOST_WIN32 - /* - * Set the new window's Z position, not affecting the rest of the settings: - */ - SetWindowPos( - fgStructure.Window->Window.Handle, - HWND_BOTTOM, - 0, 0, 0, 0, - SWP_NOSIZE | SWP_NOMOVE - ); + + SetWindowPos( + fgStructure.Window->Window.Handle, + HWND_BOTTOM, + 0, 0, 0, 0, + SWP_NOSIZE | SWP_NOMOVE + ); #endif + } } /* @@ -1178,26 +945,26 @@ void FGAPIENTRY glutPushWindow( void ) */ void FGAPIENTRY glutPopWindow( void ) { - freeglut_assert_ready; freeglut_assert_window; + freeglut_assert_ready; + freeglut_assert_window; + if( GL_FALSE == fgStructure.Window->State.IsOffscreen ) + { #if TARGET_HOST_UNIX_X11 - /* - * Raise the current window - */ - XRaiseWindow( fgDisplay.Display, fgStructure.Window->Window.Handle ); + + XRaiseWindow( fgDisplay.Display, fgStructure.Window->Window.Handle ); #elif TARGET_HOST_WIN32 - /* - * Set the new window's Z position, not affecting the rest of the settings: - */ - SetWindowPos( - fgStructure.Window->Window.Handle, - HWND_TOP, - 0, 0, 0, 0, - SWP_NOSIZE | SWP_NOMOVE - ); + + SetWindowPos( + fgStructure.Window->Window.Handle, + HWND_TOP, + 0, 0, 0, 0, + SWP_NOSIZE | SWP_NOMOVE + ); #endif + } } /* @@ -1205,17 +972,75 @@ void FGAPIENTRY glutPopWindow( void ) */ void FGAPIENTRY glutFullScreen( void ) { - freeglut_assert_ready; freeglut_assert_window; + freeglut_assert_ready; + freeglut_assert_window; - /* - * Just have the window repositioned and resized - */ - glutPositionWindow( 0, 0 ); + if( GL_FALSE == fgStructure.Window->State.IsOffscreen ) + { +#if TARGET_HOST_UNIX_X11 + int x, y; + Window w; + + XMoveResizeWindow( + fgDisplay.Display, + fgStructure.Window->Window.Handle, + 0, 0, + fgDisplay.ScreenWidth, + fgDisplay.ScreenHeight + ); - glutReshapeWindow( - fgDisplay.ScreenWidth, - fgDisplay.ScreenHeight - ); + XFlush( fgDisplay.Display ); /* This is needed */ + + XTranslateCoordinates( + fgDisplay.Display, + fgStructure.Window->Window.Handle, + fgDisplay.RootWindow, + 0, 0, &x, &y, &w + ); + + if (x || y) + { + XMoveWindow( + fgDisplay.Display, + fgStructure.Window->Window.Handle, + -x, -y + ); + XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */ + } +#elif TARGET_HOST_WIN32 + RECT rect; + + /* For fullscreen mode, force the top-left corner to 0,0 + * and adjust the window rectangle so that the client area + * covers the whole screen. + */ + + rect.left = 0; + rect.top = 0; + rect.right = fgDisplay.ScreenWidth; + rect.bottom = fgDisplay.ScreenHeight; + + AdjustWindowRect ( &rect, WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS | + WS_CLIPCHILDREN, FALSE ); + + /* + * SWP_NOACTIVATE Do not activate the window + * SWP_NOOWNERZORDER Do not change position in z-order + * SWP_NOSENDCHANGING Supress WM_WINDOWPOSCHANGING message + * SWP_NOZORDER Retains the current Z order (ignore 2nd param) + */ + + SetWindowPos( fgStructure.Window->Window.Handle, + HWND_TOP, + rect.left, + rect.top, + rect.right - rect.left, + rect.bottom - rect.top, + SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOSENDCHANGING | + SWP_NOZORDER + ); +#endif + } } /* @@ -1223,21 +1048,12 @@ void FGAPIENTRY glutFullScreen( void ) */ void* FGAPIENTRY glutGetWindowData( void ) { - return(fgStructure.Window->UserData); + return fgStructure.Window->UserData; } void FGAPIENTRY glutSetWindowData(void* data) { - fgStructure.Window->UserData=data; + fgStructure.Window->UserData = data; } /*** END OF FILE ***/ - - - - - - - - -