X-Git-Url: http://git.mutantstargoat.com/user/nuclear/?a=blobdiff_plain;f=src%2Ffreeglut_main.c;h=722f075a7a449383afd5b269a8ce8ce6631ae7d6;hb=65e03872c287ab34ae76bd1831a3786d5e986b72;hp=55e033a2788c0ede42f15819854a7915975e282c;hpb=fffd18193541999b2b5c00905dea0f1effa0ec07;p=freeglut diff --git a/src/freeglut_main.c b/src/freeglut_main.c index 55e033a..722f075 100644 --- a/src/freeglut_main.c +++ b/src/freeglut_main.c @@ -29,7 +29,7 @@ #include "config.h" #endif -#include "../include/GL/freeglut.h" +#include #include "freeglut_internal.h" #include @@ -87,54 +87,65 @@ static void fghReshapeWindowByHandle ( SFG_WindowHandleType handle, #elif TARGET_HOST_WIN32 { - RECT winRect; - int x, y; + RECT rect; - GetWindowRect( window->Window.Handle, &winRect ); - x = winRect.left; - y = winRect.top; + /* + * For windowed mode, get the current position of the + * window and resize taking the size of the frame + * decorations into account. + */ + + GetWindowRect( window->Window.Handle, &rect ); + rect.right = rect.left + width; + rect.bottom = rect.top + height; if ( window->Parent == NULL ) { - /* - * Adjust the size of the window to allow for the size of the - * frame, if we are not a menu - */ - if ( ! window->IsMenu ) + if ( ! window->IsMenu && !window->State.IsGameMode ) { - width += GetSystemMetrics( SM_CXSIZEFRAME ) * 2; - height += GetSystemMetrics( SM_CYSIZEFRAME ) * 2 + - GetSystemMetrics( SM_CYCAPTION ); + rect.right += GetSystemMetrics( SM_CXSIZEFRAME ) * 2; + rect.bottom += GetSystemMetrics( SM_CYSIZEFRAME ) * 2 + + GetSystemMetrics( SM_CYCAPTION ); } } else { - GetWindowRect( window->Parent->Window.Handle, - &winRect ); - x -= winRect.left + GetSystemMetrics( SM_CXSIZEFRAME ); - y -= winRect.top + GetSystemMetrics( SM_CYSIZEFRAME ) + - GetSystemMetrics( SM_CYCAPTION ); + GetWindowRect( window->Parent->Window.Handle, &rect ); + AdjustWindowRect ( &rect, WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS | + WS_CLIPCHILDREN, FALSE ); } - MoveWindow( - window->Window.Handle, - x, - y, - width, - height, - TRUE + /* + * 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( 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 - - if( !( FETCH_WCB( *window, Reshape ) ) ) + /* + * XXX Should update {window->State.OldWidth, window->State.OldHeight} + * XXX to keep in lockstep with UNIX_X11 code. + */ + if( FETCH_WCB( *window, Reshape ) ) + INVOKE_WCB( *window, Reshape, ( width, height ) ); + else { fgSetWindow( window ); glViewport( 0, 0, width, height ); } - else - INVOKE_WCB( *window, Reshape, ( width, height ) ); + +#endif /* * Force a window redraw. In Windows at least this is only a partial @@ -176,7 +187,7 @@ static void fghRedrawWindowByHandle ( SFG_WindowHandleType handle ) ); window->State.NeedToResize = GL_FALSE; - fgSetWindow ( current_window ); + fgSetWindow( current_window ); } INVOKE_WCB( *window, Display, ( ) ); @@ -188,25 +199,25 @@ static void fghRedrawWindowByHandle ( SFG_WindowHandleType handle ) static void fghcbDisplayWindow( SFG_Window *window, SFG_Enumerator *enumerator ) { - if( window->State.Redisplay && - window->State.Visible ) + if( window->State.NeedToResize ) { - if( window->State.NeedToResize ) - { - SFG_Window *current_window = fgStructure.Window; + SFG_Window *current_window = fgStructure.Window; - fgSetWindow( window ); + fgSetWindow( window ); - fghReshapeWindowByHandle( - window->Window.Handle, - window->State.Width, - window->State.Height - ); + fghReshapeWindowByHandle( + window->Window.Handle, + window->State.Width, + window->State.Height + ); - window->State.NeedToResize = GL_FALSE; - fgSetWindow ( current_window ); - } + window->State.NeedToResize = GL_FALSE; + fgSetWindow ( current_window ); + } + if( window->State.Redisplay && + window->State.Visible ) + { window->State.Redisplay = GL_FALSE; #if TARGET_HOST_UNIX_X11 @@ -277,10 +288,11 @@ static void fghCheckJoystickPolls( void ) static void fghCheckTimers( void ) { long checkTime = fgElapsedTime( ); - SFG_Timer *timer; - while( timer = fgState.Timers.First ) + while( fgState.Timers.First ) { + SFG_Timer *timer = fgState.Timers.First; + if( timer->TriggerTime > checkTime ) break; @@ -367,20 +379,12 @@ void fgWarning( const char *fmt, ... ) * Indicates whether Joystick events are being used by ANY window. * * The current mechanism is to walk all of the windows and ask if - * there is a joystick callback. Certainly in some cases, maybe - * in all cases, the joystick is attached to the system and accessed - * from ONE point by GLUT/freeglut, so this is not the right way, - * in general, to do this. However, the Joystick code is segregated - * in its own little world, so we can't access the information that - * we need in order to do that nicely. - * - * Some alternatives: - * * Store Joystick data into freeglut global state. - * * Provide NON-static functions or data from Joystick *.c file. + * there is a joystick callback. We have a short-circuit early + * return if we find any joystick handler registered. * - * Basically, the RIGHT way to do this requires knowing something - * about the Joystick. Right now, the Joystick code is behind - * an opaque wall. + * The real way to do this is to make use of the glutTimer() API + * to more cleanly re-implement the joystick API. Then, this code + * and all other "joystick timer" code can be yanked. * */ static void fgCheckJoystickCallback( SFG_Window* w, SFG_Enumerator* e) @@ -423,10 +427,12 @@ static int fgHavePendingRedisplays (void) static long fgNextTimer( void ) { long ret = INT_MAX; - SFG_Timer *timer; + SFG_Timer *timer = fgState.Timers.First; - if( (timer = fgState.Timers.First) ) + if( timer ) ret = timer->TriggerTime - fgElapsedTime(); + if( ret < 0 ) + ret = 0; return ret; } @@ -436,31 +442,44 @@ static long fgNextTimer( void ) */ static void fgSleepForEvents( void ) { -#if TARGET_HOST_UNIX_X11 - fd_set fdset; - int err; - int socket; - struct timeval wait; - long msec; - + long msec; + if( fgState.IdleCallback || fgHavePendingRedisplays( ) ) return; - socket = ConnectionNumber( fgDisplay.Display ); - FD_ZERO( &fdset ); - FD_SET( socket, &fdset ); - + msec = fgNextTimer( ); - if( fgHaveJoystick( ) ) - msec = MIN( msec, 10 ); - - wait.tv_sec = msec / 1000; - wait.tv_usec = (msec % 1000) * 1000; - err = select( socket+1, &fdset, NULL, NULL, &wait ); + if( fgHaveJoystick( ) ) /* XXX Use GLUT timers for joysticks... */ + msec = MIN( msec, 10 ); /* XXX Dumb; forces granularity to .01sec */ - if( -1 == err ) - fgWarning ( "freeglut select() error: %d\n", errno ); - +#if TARGET_HOST_UNIX_X11 + /* + * Possibly due to aggressive use of XFlush() and friends, + * it is possible to have our socket drained but still have + * unprocessed events. (Or, this may just be normal with + * X, anyway?) We do non-trivial processing of X events + * after tham in event-reading loop, in any case, so we + * need to allow that we may have an empty socket but non- + * empty event queue. + */ + if( ! XPending( fgDisplay.Display ) ) + { + fd_set fdset; + int err; + int socket; + struct timeval wait; + + socket = ConnectionNumber( fgDisplay.Display ); + FD_ZERO( &fdset ); + FD_SET( socket, &fdset ); + wait.tv_sec = msec / 1000; + wait.tv_usec = (msec % 1000) * 1000; + err = select( socket+1, &fdset, NULL, NULL, &wait ); + + if( -1 == err ) + fgWarning ( "freeglut select() error: %d\n", errno ); + } #elif TARGET_HOST_WIN32 + MsgWaitForMultipleObjects( 0, NULL, FALSE, msec, QS_ALLEVENTS ); #endif } @@ -542,24 +561,44 @@ void FGAPIENTRY glutMainLoopEvent( void ) * (in freeglut only) will not get an initial reshape event, * which can break things. * - * XXX NOTE that it is possible that you will more than one Reshape - * XXX event for your top-level window, but something like this - * XXX appears to be required for compatbility. - * * GLUT presumably does this because it generally tries to treat * sub-windows the same as windows. + * + * XXX Technically, GETWINDOW( xconfigure ) and + * XXX {event.xconfigure} may not be legit ways to get at + * XXX data for CreateNotify events. In practice, the data + * XXX is in a union which is laid out much the same either + * XXX way. But if you want to split hairs, this isn't legit, + * XXX and we should instead duplicate some code. */ case CreateNotify: case ConfigureNotify: GETWINDOW( xconfigure ); - window->State.NeedToResize = GL_TRUE ; - window->State.Width = event.xconfigure.width ; - window->State.Height = event.xconfigure.height; + { + int width = event.xconfigure.width; + int height = event.xconfigure.height; + + if( ( width != window->State.OldWidth ) || + ( height != window->State.OldHeight ) ) + { + window->State.OldWidth = width; + window->State.OldHeight = height; + if( FETCH_WCB( *window, Reshape ) ) + INVOKE_WCB( *window, Reshape, ( width, height ) ); + else + { + fgSetWindow( window ); + glViewport( 0, 0, width, height ); + } + glutPostRedisplay( ); + } + } break; case DestroyNotify: /* * This is sent to confirm the XDestroyWindow call. + * * XXX WHY is this commented out? Should we re-enable it? */ /* fgAddToWindowDestroyList ( window ); */ @@ -568,13 +607,19 @@ void FGAPIENTRY glutMainLoopEvent( void ) case Expose: /* * We are too dumb to process partial exposes... + * * XXX Well, we could do it. However, it seems to only * XXX be potentially useful for single-buffered (since * XXX double-buffered does not respect viewport when we * XXX do a buffer-swap). + * */ if( event.xexpose.count == 0 ) - fghRedrawWindowByHandle( event.xexpose.window ); + { + GETWINDOW( xexpose ); + fgSetWindow( window ); + glutPostRedisplay( ); + } break; case MapNotify: @@ -596,6 +641,9 @@ void FGAPIENTRY glutMainLoopEvent( void ) case VisibilityNotify: { GETWINDOW( xvisibility ); + /* + * XXX INVOKE_WCB() does this check for us. + */ if( ! FETCH_WCB( *window, WindowStatus ) ) break; fgSetWindow( window ); @@ -663,7 +711,9 @@ void FGAPIENTRY glutMainLoopEvent( void ) /* * XXX For more than 5 buttons, just check {event.xmotion.state}, - * XXX rather than a host of bit-masks? + * XXX rather than a host of bit-masks? Or maybe we need to + * XXX track ButtonPress/ButtonRelease events in our own + * XXX bit-mask? */ #define BUTTON_MASK \ ( Button1Mask | Button2Mask | Button3Mask | Button4Mask | Button5Mask ) @@ -733,7 +783,7 @@ void FGAPIENTRY glutMainLoopEvent( void ) window->ActiveMenu->Window->State.MouseY = event.xbutton.y_root - window->ActiveMenu->Y; } - + /* In the menu, invoke the callback and deactivate the menu*/ if( fgCheckActiveMenu( window->ActiveMenu->Window, window->ActiveMenu ) ) @@ -760,12 +810,19 @@ void FGAPIENTRY glutMainLoopEvent( void ) else if( pressed ) /* * Outside the menu, deactivate if it's a downclick + * * XXX This isn't enough. A downclick outside of * XXX the interior of our freeglut windows should also * XXX deactivate the menu. This is more complicated. */ fgDeactivateMenu( window->ActiveMenu->ParentWindow ); - + + /* + * XXX Why does an active menu require a redisplay at + * XXX this point? If this can come out cleanly, then + * XXX it probably should do so; if not, a comment should + * XXX explain it. + */ window->State.Redisplay = GL_TRUE; break; } @@ -778,6 +835,9 @@ void FGAPIENTRY glutMainLoopEvent( void ) ( window->Menu[ button ] ) && pressed ) { + /* + * XXX Posting a requisite Redisplay seems bogus. + */ window->State.Redisplay = GL_TRUE; fgSetWindow( window ); fgActivateMenu( window, button ); @@ -797,7 +857,7 @@ void FGAPIENTRY glutMainLoopEvent( void ) /* * Finally execute the mouse or mouse wheel callback * - * XXX Use a symbolic constant, *not* "4"! + * XXX Use a symbolic constant, *not* "4"! ("3, sire!") */ if( ( button < 3 ) || ( ! FETCH_WCB( *window, MouseWheel ) ) ) INVOKE_WCB( *window, Mouse, ( button, @@ -995,6 +1055,8 @@ void FGAPIENTRY glutMainLoopEvent( void ) */ void FGAPIENTRY glutMainLoop( void ) { + int action; + #if TARGET_HOST_WIN32 SFG_Window *window = (SFG_Window *)fgStructure.Windows.First ; #endif @@ -1028,24 +1090,40 @@ void FGAPIENTRY glutMainLoop( void ) fgState.ExecState = GLUT_EXEC_STATE_RUNNING ; while( fgState.ExecState == GLUT_EXEC_STATE_RUNNING ) { - glutMainLoopEvent( ); + SFG_Window *window; - if( fgStructure.Windows.First == NULL ) + glutMainLoopEvent( ); + /* + * Step through the list of windows, seeing if there are any + * that are not menus + */ + for( window = ( SFG_Window * )fgStructure.Windows.First; + window; + window = ( SFG_Window * )window->Node.Next ) + if ( ! ( window->IsMenu ) ) + break; + + if( ! window ) fgState.ExecState = GLUT_EXEC_STATE_STOP; else { if( fgState.IdleCallback ) fgState.IdleCallback( ); - fgSleepForEvents(); + fgSleepForEvents( ); } } /* * When this loop terminates, destroy the display, state and structure * of a freeglut session, so that another glutInit() call can happen + * + * Save the "ActionOnWindowClose" because "fgDeinitialize" resets it. */ + action = fgState.ActionOnWindowClose; fgDeinitialize( ); + if( action == GLUT_ACTION_EXIT ) + exit( 0 ); } /* @@ -1145,11 +1223,17 @@ LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam, case WM_SIZE: /* - * We got resized... But check if the window has been already added... + * If the window is visible, then it is the user manually resizing it. + * If it is not, then it is the system sending us a dummy resize with + * zero dimensions on a "glutIconifyWindow" call. */ - window->State.NeedToResize = GL_TRUE; - window->State.Width = LOWORD(lParam); - window->State.Height = HIWORD(lParam); + if( window->State.Visible ) + { + window->State.NeedToResize = GL_TRUE; + window->State.Width = LOWORD(lParam); + window->State.Height = HIWORD(lParam); + } + break; #if 0 case WM_SETFOCUS: @@ -1312,10 +1396,13 @@ LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam, } if( GetSystemMetrics( SM_SWAPBUTTON ) ) + { if( button == GLUT_LEFT_BUTTON ) button = GLUT_RIGHT_BUTTON; - else if( button == GLUT_RIGHT_BUTTON ) - button = GLUT_LEFT_BUTTON; + else + if( button == GLUT_RIGHT_BUTTON ) + button = GLUT_LEFT_BUTTON; + } if( button == -1 ) return DefWindowProc( hWnd, uMsg, lParam, wParam ); @@ -1380,7 +1467,7 @@ LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam, break; } - if ( window->Menu[ button ] && pressed ) + if( window->Menu[ button ] && pressed ) { window->State.Redisplay = GL_TRUE; fgSetWindow( window );