X-Git-Url: http://git.mutantstargoat.com/user/nuclear/?a=blobdiff_plain;f=src%2Ffreeglut_window.c;h=af294254ce7f0ae41fd7a28b0c5d762bd4bd88f7;hb=fe6b05020a6274423643f766f6d7b651a6264cbb;hp=17a95e222a4d41c60212eb9e47e79c040dc8016f;hpb=ef4947e0c438b9e91ef39bdc962c8add6db6d1a7;p=freeglut diff --git a/src/freeglut_window.c b/src/freeglut_window.c index 17a95e2..af29425 100644 --- a/src/freeglut_window.c +++ b/src/freeglut_window.c @@ -25,14 +25,25 @@ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -#ifdef HAVE_CONFIG_H -#include "config.h" -#endif +#include +#include "freeglut_internal.h" -#define G_LOG_DOMAIN "freeglut-window" +#if TARGET_HOST_WINCE +#include +#pragma comment( lib, "Aygshell.lib" ) + +static wchar_t* fghWstrFromStr(const char* str) +{ + int i,len=strlen(str); + wchar_t* wstr = (wchar_t*)malloc(2*len+2); + for(i=0; iWindow.Device, BITSPIXEL ); ppfd = &pfd; - + pixelformat = ChoosePixelFormat( window->Window.Device, ppfd ); if( pixelformat == 0 ) - return FALSE; + return GL_FALSE; if( checkOnly ) - return TRUE; + return GL_TRUE; return SetPixelFormat( window->Window.Device, pixelformat, ppfd ); +#endif /* TARGET_HOST_WINCE */ } #endif @@ -227,21 +261,21 @@ void fgSetWindow ( SFG_Window *window ) window->Window.Handle, window->Window.Context ); -#elif TARGET_HOST_WIN32 - if( fgStructure.Window ) - ReleaseDC( fgStructure.Window->Window.Handle, - fgStructure.Window->Window.Device ); +#elif TARGET_HOST_WIN32 || TARGET_HOST_WINCE + if( fgStructure.CurrentWindow ) + ReleaseDC( fgStructure.CurrentWindow->Window.Handle, + fgStructure.CurrentWindow->Window.Device ); if ( window ) { window->Window.Device = GetDC( window->Window.Handle ); - wglMakeCurrent( - window->Window.Device, - window->Window.Context - ); + wglMakeCurrent( + window->Window.Device, + window->Window.Context + ); } #endif - fgStructure.Window = window; + fgStructure.CurrentWindow = window; } @@ -251,7 +285,7 @@ void fgSetWindow ( SFG_Window *window ) */ void fgOpenWindow( SFG_Window* window, const char* title, int x, int y, int w, int h, - GLboolean gameMode, int isSubWindow ) + GLboolean gameMode, GLboolean isSubWindow ) { #if TARGET_HOST_UNIX_X11 XSetWindowAttributes winAttr; @@ -259,47 +293,39 @@ void fgOpenWindow( SFG_Window* window, const char* title, XSizeHints sizeHints; XWMHints wmHints; unsigned long mask; + unsigned int current_DisplayMode = fgState.DisplayMode ; - freeglut_assert_ready; + /* Save the display mode if we are creating a menu window */ + if( window->IsMenu && ( ! fgStructure.MenuContext ) ) + fgState.DisplayMode = GLUT_DOUBLE | GLUT_RGB ; - /* - * 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 ) - window->Window.VisualInfo = fgChooseVisual(); - else if ( fgStructure.MenuContext ) - window->Window.VisualInfo = fgChooseVisual(); - else - { - unsigned int current_DisplayMode = fgState.DisplayMode ; - fgState.DisplayMode = GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH ; - window->Window.VisualInfo = fgChooseVisual(); + window->Window.VisualInfo = fgChooseVisual( ); + + if( window->IsMenu && ( ! fgStructure.MenuContext ) ) fgState.DisplayMode = current_DisplayMode ; - } - 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 ) ) + if( !( fgState.DisplayMode & GLUT_DOUBLE ) ) { fgState.DisplayMode |= GLUT_DOUBLE ; - window->Window.VisualInfo = fgChooseVisual(); - 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. */ } - assert( window->Window.VisualInfo != NULL ); + FREEGLUT_INTERNAL_ERROR_EXIT( window->Window.VisualInfo != NULL, + "Visual with necessary capabilities not found", "fgOpenWindow" ); /* * XXX HINT: the masks should be updated when adding/removing callbacks. @@ -308,15 +334,13 @@ void fgOpenWindow( SFG_Window* window, const char* title, * 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. (Hint: Think mouse-motion!) - * XXX - * XXX It may make a difference in networked environments or on - * XXX some very slow systems, but I think that that is secondary - * XXX to making debugging easier. + * 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 | + winAttr.event_mask = + StructureNotifyMask | SubstructureNotifyMask | ExposureMask | + ButtonPressMask | ButtonReleaseMask | KeyPressMask | KeyReleaseMask | + VisibilityChangeMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask | ButtonMotionMask; winAttr.background_pixmap = None; winAttr.background_pixel = 0; @@ -329,7 +353,7 @@ void fgOpenWindow( SFG_Window* window, const char* title, mask = CWBackPixmap | CWBorderPixel | CWColormap | CWEventMask; - if ( fgState.BuildingAMenu ) + if( window->IsMenu || ( gameMode == GL_TRUE ) ) { winAttr.override_redirect = True; mask |= CWOverrideRedirect; @@ -338,7 +362,7 @@ void fgOpenWindow( SFG_Window* window, const char* title, window->Window.Handle = XCreateWindow( fgDisplay.Display, window->Parent == NULL ? fgDisplay.RootWindow : - window->Parent->Window.Handle, + window->Parent->Window.Handle, x, y, w, h, 0, window->Window.VisualInfo->depth, InputOutput, window->Window.VisualInfo->visual, mask, @@ -349,71 +373,72 @@ 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 ( fgState.BuildingAMenu ) + if( window->IsMenu ) { /* * If there isn't already an OpenGL rendering context for menu * windows, make one */ - if ( !fgStructure.MenuContext ) + 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 + (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 ) ); } -/* window->Window.Context = fgStructure.MenuContext->Context ; */ + /* window->Window.Context = fgStructure.MenuContext->MContext; */ window->Window.Context = glXCreateContext( fgDisplay.Display, window->Window.VisualInfo, - NULL, fgState.ForceDirectContext | fgState.TryDirectContext + NULL, ( fgState.DirectContext != GLUT_FORCE_INDIRECT_CONTEXT ) ); } - else if ( fgState.UseCurrentContext == TRUE ) + else if( fgState.UseCurrentContext ) { - window->Window.Context = glXGetCurrentContext(); + window->Window.Context = glXGetCurrentContext( ); - if ( ! window->Window.Context ) - window->Window.Context = glXCreateContext( - fgDisplay.Display, window->Window.VisualInfo, - NULL, fgState.ForceDirectContext | fgState.TryDirectContext - ); + if( ! window->Window.Context ) + window->Window.Context = glXCreateContext( + fgDisplay.Display, window->Window.VisualInfo, + NULL, ( fgState.DirectContext != GLUT_FORCE_INDIRECT_CONTEXT ) + ); } else window->Window.Context = glXCreateContext( fgDisplay.Display, window->Window.VisualInfo, - NULL, fgState.ForceDirectContext | fgState.TryDirectContext + NULL, ( fgState.DirectContext != GLUT_FORCE_INDIRECT_CONTEXT ) ); - if( fgState.ForceDirectContext && - !glXIsDirect( fgDisplay.Display, window->Window.Context ) ) - fgError( "unable to force direct context rendering for window '%s'", +#if !defined( __FreeBSD__ ) && !defined( __NetBSD__ ) + if( !glXIsDirect( fgDisplay.Display, window->Window.Context ) ) + { + if( fgState.DirectContext == GLUT_FORCE_DIRECT_CONTEXT ) + fgError( "Unable to force direct context rendering for window '%s'", title ); - - glXMakeCurrent( - fgDisplay.Display, - window->Window.Handle, - window->Window.Context - ); + else if( fgState.DirectContext == GLUT_TRY_DIRECT_CONTEXT ) + fgWarning( "Unable to create direct context rendering for window '%s'\nThis may hurt performance.", + title ); + } +#endif /* * XXX Assume the new window is visible by default * XXX Is this a safe assumption? */ - window->State.Visible = TRUE; + window->State.Visible = GL_TRUE; sizeHints.flags = 0; - if (fgState.Position.Use == TRUE) + if ( fgState.Position.Use ) sizeHints.flags |= USPosition; - if (fgState.Size.Use == TRUE) + 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?) + * settings are obsolete, 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 @@ -425,12 +450,8 @@ void fgOpenWindow( SFG_Window* window, const char* title, sizeHints.height = h; wmHints.flags = StateHint; - wmHints.initial_state = - (fgState.ForceIconic == FALSE) ? NormalState : IconicState; - - /* - * Prepare the window and iconified window names... - */ + wmHints.initial_state = fgState.ForceIconic ? IconicState : NormalState; + /* Prepare the window and iconified window names... */ XStringListToTextProperty( (char **) &title, 1, &textProperty ); XSetWMProperties( @@ -444,27 +465,36 @@ void fgOpenWindow( SFG_Window* window, const char* title, &wmHints, NULL ); + XFree( textProperty.value ); + XSetWMProtocols( fgDisplay.Display, window->Window.Handle, &fgDisplay.DeleteWindow, 1 ); + + glXMakeCurrent( + fgDisplay.Display, + window->Window.Handle, + window->Window.Context + ); + XMapWindow( fgDisplay.Display, window->Window.Handle ); -#elif TARGET_HOST_WIN32 +#elif TARGET_HOST_WIN32 || TARGET_HOST_WINCE WNDCLASS wc; - int flags; + 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, _T("FREEGLUT"), &wc ); + FREEGLUT_INTERNAL_ERROR_EXIT ( atom, "Window Class Info Not Found", + "fgOpenWindow" ); + + if( gameMode ) { - assert( window->Parent == NULL ); + FREEGLUT_INTERNAL_ERROR_EXIT ( window->Parent == NULL, + "Game mode being invoked on a subwindow", + "fgOpenWindow" ); /* * Set the window creation flags appropriately to make the window @@ -474,7 +504,8 @@ void fgOpenWindow( SFG_Window* window, const char* title, } else { - if ( ( !isSubWindow ) && ( ! window->IsMenu ) ) +#if !TARGET_HOST_WINCE + if ( ( ! isSubWindow ) && ( ! window->IsMenu ) ) { /* * Update the window dimensions, taking account of window @@ -485,13 +516,14 @@ void fgOpenWindow( SFG_Window* window, const char* title, h += (GetSystemMetrics( SM_CYSIZEFRAME ) )*2 + GetSystemMetrics( SM_CYCAPTION ); } +#endif /* TARGET_HOST_WINCE */ - if( fgState.Position.Use == FALSE ) + if( ! fgState.Position.Use ) { x = CW_USEDEFAULT; y = CW_USEDEFAULT; } - if( fgState.Size.Use == FALSE ) + if( ! fgState.Size.Use ) { w = CW_USEDEFAULT; h = CW_USEDEFAULT; @@ -504,14 +536,45 @@ void fgOpenWindow( SFG_Window* window, const char* title, flags = WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_VISIBLE; if ( window->IsMenu ) - flags |= WS_POPUP ; + { + flags |= WS_POPUP; + exFlags |= WS_EX_TOOLWINDOW; + } +#if !TARGET_HOST_WINCE else if( window->Parent == NULL ) flags |= WS_OVERLAPPEDWINDOW; +#endif else flags |= WS_CHILD; } - window->Window.Handle = CreateWindow( +#if TARGET_HOST_WINCE + { + wchar_t* wstr = fghWstrFromStr(title); + + window->Window.Handle = CreateWindow( + _T("FREEGLUT"), + wstr, + WS_VISIBLE | WS_POPUP, + 0,0, 240,320, + NULL, + NULL, + fgDisplay.Instance, + (LPVOID) window + ); + + free(wstr); + + SHFullScreen(window->Window.Handle, SHFS_HIDESTARTICON); + SHFullScreen(window->Window.Handle, SHFS_HIDESIPBUTTON); + SHFullScreen(window->Window.Handle, SHFS_HIDETASKBAR); + MoveWindow(window->Window.Handle, 0, 0, 240, 320, TRUE); + ShowWindow(window->Window.Handle, SW_SHOW); + UpdateWindow(window->Window.Handle); + } +#else + window->Window.Handle = CreateWindowEx( + exFlags, "FREEGLUT", title, flags, @@ -521,25 +584,33 @@ void fgOpenWindow( SFG_Window* window, const char* title, fgDisplay.Instance, (LPVOID) window ); +#endif /* TARGET_HOST_WINCE */ + if( !( window->Window.Handle ) ) fgError( "Failed to create a window (%s)!", title ); +#if TARGET_HOST_WINCE + ShowWindow( window->Window.Handle, SW_SHOW ); +#else ShowWindow( window->Window.Handle, fgState.ForceIconic ? SW_SHOWMINIMIZED : SW_SHOW ); +#endif /* TARGET_HOST_WINCE */ + UpdateWindow( window->Window.Handle ); - ShowCursor( TRUE ); /* XXX Old comments say "hide cusror"! */ + ShowCursor( TRUE ); /* XXX Old comments say "hide cursor"! */ #endif + fgSetWindow( window ); + window->Window.DoubleBuffered = - ( fgState.DisplayMode & GLUT_DOUBLE ) ? 1 : 0 ; + ( fgState.DisplayMode & GLUT_DOUBLE ) ? 1 : 0; if ( ! window->Window.DoubleBuffered ) { - glDrawBuffer ( GL_FRONT ) ; - glReadBuffer ( GL_FRONT ) ; + glDrawBuffer ( GL_FRONT ); + glReadBuffer ( GL_FRONT ); } - fgSetWindow( window ); } /* @@ -547,23 +618,41 @@ void fgOpenWindow( SFG_Window* window, const char* title, */ void fgCloseWindow( SFG_Window* window ) { - freeglut_assert_ready; - #if TARGET_HOST_UNIX_X11 glXDestroyContext( fgDisplay.Display, window->Window.Context ); + XFree( window->Window.VisualInfo ); XDestroyWindow( fgDisplay.Display, window->Window.Handle ); - XFlush( fgDisplay.Display ); + XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */ -#elif TARGET_HOST_WIN32 +#elif TARGET_HOST_WIN32 || TARGET_HOST_WINCE - SendMessage( - window->Window.Handle, - WM_CLOSE, - 0, - 0 - ); + /* Make sure we don't close a window with current context active */ + if( fgStructure.CurrentWindow == window ) + wglMakeCurrent( NULL, NULL ); + + /* + * Step through the list of windows. If the rendering context + * is not being used by another window, then we delete it. + */ + { + int used = FALSE ; + SFG_Window *iter ; + + 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 } @@ -575,11 +664,17 @@ void fgCloseWindow( SFG_Window* window ) */ int FGAPIENTRY glutCreateWindow( const char* title ) { - /* - * Create a new window and return its unique ID number + /* 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" */ - return( fgCreateWindow( NULL, title, fgState.Position.X, fgState.Position.Y, - fgState.Size.X, fgState.Size.Y, FALSE )->ID ); + FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutCreateWindow" ); + + return fgCreateWindow( NULL, title, fgState.Position.X, fgState.Position.Y, + fgState.Size.X, fgState.Size.Y, GL_FALSE, + GL_FALSE )->ID; } /* @@ -587,30 +682,43 @@ int FGAPIENTRY glutCreateWindow( const char* title ) */ 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_assert_ready; - - /* - * Find a parent to the newly created window... - */ + FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutCreateSubWindow" ); parent = fgWindowByID( parentID ); - - /* - * Fail if the parent has not been found - */ freeglut_return_val_if_fail( parent != NULL, 0 ); + if ( x < 0 ) + { + x = parent->State.Width + x ; + if ( w >= 0 ) x -= w ; + } - /* - * Create the new window - */ - window = fgCreateWindow( parent, "", x, y, w, h, FALSE ); + if ( w < 0 ) w = parent->State.Width - x + w ; + if ( w < 0 ) + { + x += w ; + w = -w ; + } - /* - * Return the new window's ID - */ - return( window->ID ); + 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, "", x, y, w, h, GL_FALSE, GL_FALSE ); + ret = window->ID; + + return ret; } /* @@ -618,25 +726,15 @@ 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; + FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutDestroyWindow" ); + window = fgWindowByID( windowID ); + freeglut_return_if_fail( window != NULL ); + { + fgExecutionState ExecState = fgState.ExecState; + fgAddToWindowDestroyList( window ); + fgState.ExecState = ExecState; + } } /* @@ -646,36 +744,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 ) + FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSetWindow" ); + if( fgStructure.CurrentWindow != NULL ) + if( fgStructure.CurrentWindow->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 ); + fgWarning( "glutSetWindow(): window ID %d not found!", ID ); return; } - fgSetWindow ( window ) ; + fgSetWindow( window ); } /* @@ -683,23 +764,10 @@ 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 ); + FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutGetWindow" ); + if( fgStructure.CurrentWindow == NULL ) + return 0; + return fgStructure.CurrentWindow->ID; } /* @@ -707,28 +775,21 @@ int FGAPIENTRY glutGetWindow( void ) */ void FGAPIENTRY glutShowWindow( void ) { - freeglut_assert_ready; freeglut_assert_window; + FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutShowWindow" ); + FREEGLUT_EXIT_IF_NO_WINDOW ( "glutShowWindow" ); #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.CurrentWindow->Window.Handle ); + XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */ -#endif +#elif TARGET_HOST_WIN32 || TARGET_HOST_WINCE - /* - * Since the window is visible, we need to redisplay it ... - */ - fgStructure.Window->State.Redisplay = TRUE; + ShowWindow( fgStructure.CurrentWindow->Window.Handle, SW_SHOW ); + +#endif + fgStructure.CurrentWindow->State.Redisplay = GL_TRUE; } /* @@ -736,45 +797,27 @@ void FGAPIENTRY glutShowWindow( void ) */ void FGAPIENTRY glutHideWindow( void ) { - freeglut_assert_ready; freeglut_assert_window; + FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutHideWindow" ); + FREEGLUT_EXIT_IF_NO_WINDOW ( "glutHideWindow" ); #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 ) - { - /* - * This is a top-level window - */ - XWithdrawWindow( fgDisplay.Display, fgStructure.Window->Window.Handle, fgDisplay.Screen ); - } + + if( fgStructure.CurrentWindow->Parent == NULL ) + XWithdrawWindow( fgDisplay.Display, + fgStructure.CurrentWindow->Window.Handle, + fgDisplay.Screen ); else - { - /* - * Nope, it's a child window - */ - XUnmapWindow( fgDisplay.Display, fgStructure.Window->Window.Handle ); - } + XUnmapWindow( fgDisplay.Display, + fgStructure.CurrentWindow->Window.Handle ); + XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */ - /* - * Flush the X state now - */ - XFlush( fgDisplay.Display ); +#elif TARGET_HOST_WIN32 || TARGET_HOST_WINCE -#elif TARGET_HOST_WIN32 - /* - * Hide the window - */ - ShowWindow( fgStructure.Window->Window.Handle, SW_HIDE ); + ShowWindow( fgStructure.CurrentWindow->Window.Handle, SW_HIDE ); #endif - /* - * Since the window is hidden, we don't need to redisplay it ... - */ - fgStructure.Window->State.Redisplay = FALSE; + fgStructure.CurrentWindow->State.Redisplay = GL_FALSE; } /* @@ -782,28 +825,23 @@ void FGAPIENTRY glutHideWindow( void ) */ void FGAPIENTRY glutIconifyWindow( void ) { - freeglut_assert_ready; freeglut_assert_window; + FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutIconifyWindow" ); + FREEGLUT_EXIT_IF_NO_WINDOW ( "glutIconifyWindow" ); + fgStructure.CurrentWindow->State.Visible = GL_FALSE; #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.CurrentWindow->Window.Handle, + fgDisplay.Screen ); + XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */ -#endif +#elif TARGET_HOST_WIN32 || TARGET_HOST_WINCE - /* - * Since the window is just an icon, we don't need to redisplay it ... - */ - fgStructure.Window->State.Redisplay = FALSE; + ShowWindow( fgStructure.CurrentWindow->Window.Handle, SW_MINIMIZE ); +#endif + + fgStructure.CurrentWindow->State.Redisplay = GL_FALSE; } /* @@ -811,48 +849,41 @@ void FGAPIENTRY glutIconifyWindow( void ) */ void FGAPIENTRY glutSetWindowTitle( const char* title ) { - freeglut_assert_ready; freeglut_assert_window; + FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSetWindowTitle" ); + FREEGLUT_EXIT_IF_NO_WINDOW ( "glutSetWindowTitle" ); + if( ! fgStructure.CurrentWindow->Parent ) + { +#if TARGET_HOST_UNIX_X11 - /* - * Works only for top-level windows - */ - if( fgStructure.Window->Parent != NULL ) - return; + XTextProperty text; -#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 ); - } + text.value = (unsigned char *) title; + text.encoding = XA_STRING; + text.format = 8; + text.nitems = strlen( title ); + + XSetWMName( + fgDisplay.Display, + fgStructure.CurrentWindow->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.CurrentWindow->Window.Handle, title ); + +#elif TARGET_HOST_WINCE + { + wchar_t* wstr = fghWstrFromStr(title); + + SetWindowText( fgStructure.CurrentWindow->Window.Handle, wstr ); + + free(wstr); + } #endif + } } /* @@ -860,48 +891,42 @@ 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_EXIT_IF_NOT_INITIALISED ( "glutSetIconTitle" ); + FREEGLUT_EXIT_IF_NO_WINDOW ( "glutSetIconTitle" ); + if( ! fgStructure.CurrentWindow->Parent ) + { #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.CurrentWindow->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.CurrentWindow->Window.Handle, title ); + +#elif TARGET_HOST_WINCE + { + wchar_t* wstr = fghWstrFromStr(title); + + SetWindowText( fgStructure.CurrentWindow->Window.Handle, wstr ); + + free(wstr); + } #endif + } } /* @@ -909,58 +934,12 @@ 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_EXIT_IF_NOT_INITIALISED ( "glutReshapeWindow" ); + FREEGLUT_EXIT_IF_NO_WINDOW ( "glutReshapeWindow" ); -#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 ... */ - { - /* - * 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 ); - } - } - 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 + fgStructure.CurrentWindow->State.NeedToResize = GL_TRUE; + fgStructure.CurrentWindow->State.Width = width ; + fgStructure.CurrentWindow->State.Height = height; } /* @@ -968,36 +947,31 @@ void FGAPIENTRY glutReshapeWindow( int width, int height ) */ void FGAPIENTRY glutPositionWindow( int x, int y ) { - freeglut_assert_ready; freeglut_assert_window; + FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutPositionWindow" ); + FREEGLUT_EXIT_IF_NO_WINDOW ( "glutPositionWindow" ); #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.CurrentWindow->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 || TARGET_HOST_WINCE - /* - * 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" returns the pixel coordinates of the outside of the window */ + GetWindowRect( fgStructure.CurrentWindow->Window.Handle, &winRect ); + MoveWindow( + fgStructure.CurrentWindow->Window.Handle, + x, + y, + winRect.right - winRect.left, + winRect.bottom - winRect.top, + TRUE + ); + } #endif } @@ -1007,24 +981,21 @@ void FGAPIENTRY glutPositionWindow( int x, int y ) */ void FGAPIENTRY glutPushWindow( void ) { - freeglut_assert_ready; freeglut_assert_window; + FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutPushWindow" ); + FREEGLUT_EXIT_IF_NO_WINDOW ( "glutPushWindow" ); #if TARGET_HOST_UNIX_X11 - /* - * Lower the current window - */ - 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 - ); + XLowerWindow( fgDisplay.Display, fgStructure.CurrentWindow->Window.Handle ); + +#elif TARGET_HOST_WIN32 || TARGET_HOST_WINCE + + SetWindowPos( + fgStructure.CurrentWindow->Window.Handle, + HWND_BOTTOM, + 0, 0, 0, 0, + SWP_NOSIZE | SWP_NOMOVE + ); #endif } @@ -1034,24 +1005,21 @@ void FGAPIENTRY glutPushWindow( void ) */ void FGAPIENTRY glutPopWindow( void ) { - freeglut_assert_ready; freeglut_assert_window; + FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutPopWindow" ); + FREEGLUT_EXIT_IF_NO_WINDOW ( "glutPopWindow" ); #if TARGET_HOST_UNIX_X11 - /* - * Raise the current window - */ - 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 - ); + XRaiseWindow( fgDisplay.Display, fgStructure.CurrentWindow->Window.Handle ); + +#elif TARGET_HOST_WIN32 || TARGET_HOST_WINCE + + SetWindowPos( + fgStructure.CurrentWindow->Window.Handle, + HWND_TOP, + 0, 0, 0, 0, + SWP_NOSIZE | SWP_NOMOVE + ); #endif } @@ -1061,25 +1029,27 @@ void FGAPIENTRY glutPopWindow( void ) */ void FGAPIENTRY glutFullScreen( void ) { - freeglut_assert_ready; freeglut_assert_window; + FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutFullScreen" ); + FREEGLUT_EXIT_IF_NO_WINDOW ( "glutFullScreen" ); -#if TARGET_HOST_UNIX_X11 { +#if TARGET_HOST_UNIX_X11 int x, y; Window w; XMoveResizeWindow( fgDisplay.Display, - fgStructure.Window->Window.Handle, + fgStructure.CurrentWindow->Window.Handle, 0, 0, fgDisplay.ScreenWidth, fgDisplay.ScreenHeight ); - XFlush( fgDisplay.Display ); + + XFlush( fgDisplay.Display ); /* This is needed */ XTranslateCoordinates( fgDisplay.Display, - fgStructure.Window->Window.Handle, + fgStructure.CurrentWindow->Window.Handle, fgDisplay.RootWindow, 0, 0, &x, &y, &w ); @@ -1088,21 +1058,45 @@ void FGAPIENTRY glutFullScreen( void ) { XMoveWindow( fgDisplay.Display, - fgStructure.Window->Window.Handle, + fgStructure.CurrentWindow->Window.Handle, -x, -y ); - XFlush( fgDisplay.Display ); + XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */ } - } #elif TARGET_HOST_WIN32 - MoveWindow( - fgStructure.Window->Window.Handle, - 0, 0, - fgDisplay.ScreenWidth, - fgDisplay.ScreenHeight, - TRUE - ); + 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.CurrentWindow->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 + } } /* @@ -1110,12 +1104,16 @@ void FGAPIENTRY glutFullScreen( void ) */ void* FGAPIENTRY glutGetWindowData( void ) { - return(fgStructure.Window->UserData); + FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutGetWindowData" ); + FREEGLUT_EXIT_IF_NO_WINDOW ( "glutGetWindowData" ); + return fgStructure.CurrentWindow->UserData; } void FGAPIENTRY glutSetWindowData(void* data) { - fgStructure.Window->UserData=data; + FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSetWindowData" ); + FREEGLUT_EXIT_IF_NO_WINDOW ( "glutSetWindowData" ); + fgStructure.CurrentWindow->UserData = data; } /*** END OF FILE ***/