X-Git-Url: http://git.mutantstargoat.com/user/nuclear/?a=blobdiff_plain;f=src%2Ffreeglut_main.c;h=1fae543b98a81bc5182d31c1492a7787ca685f36;hb=9dac5d0710b760ba04ebb6bbe9ee61041232c700;hp=1e313c46e569854c494b407f538ca41d7ab23143;hpb=98ea79ef777bea593a87aef9600ee3d4fda6e110;p=freeglut diff --git a/src/freeglut_main.c b/src/freeglut_main.c index 1e313c4..1fae543 100644 --- a/src/freeglut_main.c +++ b/src/freeglut_main.c @@ -25,11 +25,12 @@ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ + #ifdef HAVE_CONFIG_H #include "config.h" #endif -#include "../include/GL/freeglut.h" +#include #include "freeglut_internal.h" #include @@ -40,6 +41,20 @@ #include #include #elif TARGET_HOST_WIN32 +#elif TARGET_HOST_WINCE + +typedef struct GXDisplayProperties GXDisplayProperties; +typedef struct GXKeyList GXKeyList; +#include + +typedef struct GXKeyList (*GXGETDEFAULTKEYS)(int); +typedef int (*GXOPENINPUT)(); + +GXGETDEFAULTKEYS GXGetDefaultKeys_ = NULL; +GXOPENINPUT GXOpenInput_ = NULL; + +struct GXKeyList gxKeyList; + #endif #ifndef MAX @@ -68,23 +83,11 @@ * Handle a window configuration change. When no reshape * callback is hooked, the viewport size is updated to * match the new window size. - * - * XXX We can/should make a "unified" window handle type so that - * XXX the function headers don't need this silly #ifdef junk. - * XXX Make the type, say, {fgWindow}. On UNIX_X11, this is - * XXX {Window}. On WIN32, it is {HWND}. Then do the #ifdef - * XXX junk *once* in "freeglut_internal.h". */ -static void fghReshapeWindowByHandle -#if TARGET_HOST_UNIX_X11 - ( Window handle, int width, int height ) -#elif TARGET_HOST_WIN32 - ( HWND handle, int width, int height ) -#endif +static void fghReshapeWindow ( SFG_Window *window, int width, int height ) { SFG_Window *current_window = fgStructure.Window; - SFG_Window* window = fgWindowByHandle( handle ); freeglut_return_if_fail( window != NULL ); @@ -93,70 +96,74 @@ static void fghReshapeWindowByHandle XResizeWindow( fgDisplay.Display, window->Window.Handle, width, height ); XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */ - /* - * XXX REALLY shouldn't be done. GLUT docs state that this - * XXX isn't even processed immediately, but rather waits - * XXX for return to the mainloop. "This allows multiple - * XXX glutReshapeWindow, glutPositionWindow, and glutFullScreen - * XXX requests to the same window to be coalesced." (This is - * XXX having some deleterious effect on a sample program of mine.) - * XXX Not only does GLUT not flush at this point, GLUT doesn't even - * XXX *do* the reshape at this point! We should probably rip this - * XXX out and do what GLUT promises. It would be more efficient, and - * XXX might be more compatible. - */ -#elif TARGET_HOST_WIN32 +#elif TARGET_HOST_WIN32 || TARGET_HOST_WINCE +#if !TARGET_HOST_WINCE { RECT winRect; - int x, y; + int x, y, w, h; + /* + * For windowed mode, get the current position of the + * window and resize taking the size of the frame + * decorations into account. + */ + + /* "GetWindowRect" returns the pixel coordinates of the outside of the window */ GetWindowRect( window->Window.Handle, &winRect ); x = winRect.left; y = winRect.top; + w = width; + h = 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 ); + w += GetSystemMetrics( SM_CXSIZEFRAME ) * 2; + h += 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 ); + RECT parentRect; + GetWindowRect( window->Parent->Window.Handle, &parentRect ); + x -= parentRect.left + GetSystemMetrics( SM_CXSIZEFRAME ) * 2; + y -= parentRect.top + GetSystemMetrics( SM_CYSIZEFRAME ) * 2 + + GetSystemMetrics( SM_CYCAPTION ); } - 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, + x, y, w, h, + SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOSENDCHANGING | + SWP_NOZORDER ); } +#endif /* TARGET_HOST_WINCE */ -#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 @@ -175,53 +182,33 @@ static void fghReshapeWindowByHandle * Calls a window's redraw method. This is used when * a redraw is forced by the incoming window messages. */ -static void fghRedrawWindowByHandle -#if TARGET_HOST_UNIX_X11 - ( Window handle ) -#elif TARGET_HOST_WIN32 - ( HWND handle ) -#endif +static void fghRedrawWindow ( SFG_Window *window ) { - SFG_Window* window = fgWindowByHandle( handle ); - freeglut_return_if_fail( window != NULL ); + SFG_Window *current_window = fgStructure.Window; + + freeglut_return_if_fail( window ); + freeglut_return_if_fail( FETCH_WCB ( *window, Display ) ); + + window->State.Redisplay = GL_FALSE; - /* - * XXX Other than clearing the Redisplay flag or not, - * XXX we may as well rely on the INVOK_WCB() doing this - * XXX pointer-check. - * XXX - * XXX If we do not invoke the display because the pointer - * XXX is not defined (should never happen, really), then - * XXX we may enter an infinite busy-loop trying to update - * XXX the window. Similarly, if we skip because the window - * XXX is not visible. However, if the window becomes visible - * XXX at a later time, the window should get its callback - * XXX invoked. I would recommend removing the first check, - * XXX and making the second check only affect whether the - * XXX callback is invoked---but always clear the flag, if - * XXX the {window} pointer is defined. - */ - freeglut_return_if_fail( FETCH_WCB( *window, Display ) ); freeglut_return_if_fail( window->State.Visible ); + fgSetWindow( window ); + if( window->State.NeedToResize ) { - SFG_Window *current_window = fgStructure.Window; - - fgSetWindow( window ); - - fghReshapeWindowByHandle( - window->Window.Handle, + fghReshapeWindow( + window, window->State.Width, window->State.Height ); window->State.NeedToResize = GL_FALSE; - fgSetWindow ( current_window ); } - window->State.Redisplay = GL_FALSE; INVOKE_WCB( *window, Display, ( ) ); + + fgSetWindow( current_window ); } /* @@ -230,47 +217,16 @@ static void fghRedrawWindowByHandle static void fghcbDisplayWindow( SFG_Window *window, SFG_Enumerator *enumerator ) { - /* - * XXX Do we need/want to check the callback pointer here? - * XXX INVOKE_WCB() will check for us. Arguably, the - * XXX Redisplay status flag should be cleared regardless - * XXX of any concern but that {window} is a valid pointer - * XXX (which this function is assuming anyway). - * XXX Especially since old GLUT wouldn't even enter its main - * XXX loop if you didn't have a display callback defined... - */ - if( ( FETCH_WCB( *window, Display ) ) && - window->State.Redisplay && + if( window->State.Redisplay && window->State.Visible ) { - if( window->State.NeedToResize ) - { - SFG_Window *current_window = fgStructure.Window; - - fgSetWindow( window ); - - fghReshapeWindowByHandle( - window->Window.Handle, - window->State.Width, - window->State.Height - ); - - window->State.NeedToResize = GL_FALSE; - fgSetWindow ( current_window ); - } - window->State.Redisplay = GL_FALSE; #if TARGET_HOST_UNIX_X11 - { - SFG_Window *current_window = fgStructure.Window; - - INVOKE_WCB( *window, Display, ( ) ); - fgSetWindow( current_window ); - } -#elif TARGET_HOST_WIN32 + fghRedrawWindow ( window ) ; +#elif TARGET_HOST_WIN32 || TARGET_HOST_WINCE RedrawWindow( - window->Window.Handle, NULL, NULL, + window->Window.Handle, NULL, NULL, RDW_NOERASE | RDW_INTERNALPAINT | RDW_INVALIDATE | RDW_UPDATENOW ); #endif @@ -303,7 +259,9 @@ static void fghcbCheckJoystickPolls( SFG_Window *window, if( window->State.JoystickLastPoll + window->State.JoystickPollRate <= checkTime ) { +#if !TARGET_HOST_WINCE fgJoystickPollWindow( window ); +#endif /* !TARGET_HOST_WINCE */ window->State.JoystickLastPoll = checkTime; } @@ -329,38 +287,21 @@ static void fghCheckJoystickPolls( void ) static void fghCheckTimers( void ) { long checkTime = fgElapsedTime( ); - SFG_Timer *timer, *next; - SFG_List timedOut; - - fgListInit(&timedOut); - for( timer = (SFG_Timer *)fgState.Timers.First; - timer; - timer = (SFG_Timer *)next ) + while( fgState.Timers.First ) { - next = (SFG_Timer *)timer->Node.Next; + SFG_Timer *timer = fgState.Timers.First; - if( timer->TriggerTime <= checkTime ) - { - fgListRemove( &fgState.Timers, &timer->Node ); - fgListAppend( &timedOut, &timer->Node ); - } - } + if( timer->TriggerTime > checkTime ) + break; - /* - * Now feel free to execute all the hooked and timed out timer callbacks - * And delete the timed out timers... - */ - while ( (timer = (SFG_Timer *)timedOut.First) ) - { - if( timer->Callback != NULL ) - timer->Callback( timer->ID ); - fgListRemove( &timedOut, &timer->Node ); - free( timer ); + fgListRemove( &fgState.Timers, &timer->Node ); + fgListAppend( &fgState.FreeTimers, &timer->Node ); + + timer->Callback( timer->ID ); } } - /* * Elapsed Time */ @@ -371,15 +312,17 @@ long fgElapsedTime( void ) #if TARGET_HOST_UNIX_X11 struct timeval now; long elapsed; - + gettimeofday( &now, NULL ); - + elapsed = (now.tv_usec - fgState.Time.Value.tv_usec) / 1000; elapsed += (now.tv_sec - fgState.Time.Value.tv_sec) * 1000; - + return elapsed; #elif TARGET_HOST_WIN32 return timeGetTime() - fgState.Time.Value; +#elif TARGET_HOST_WINCE + return GetTickCount() - fgState.Time.Value; #endif } else @@ -388,6 +331,8 @@ long fgElapsedTime( void ) gettimeofday( &fgState.Time.Value, NULL ); #elif TARGET_HOST_WIN32 fgState.Time.Value = timeGetTime (); +#elif TARGET_HOST_WINCE + fgState.Time.Value = GetTickCount(); #endif fgState.Time.Set = GL_TRUE ; @@ -437,78 +382,60 @@ 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. + * there is a joystick callback. We have a short-circuit early + * return if we find any joystick handler registered. * - * Some alternatives: - * * Store Joystick data into freeglut global state. - * * Provide NON-static functions or data from Joystick *.c file. - * - * 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) +static void fghCheckJoystickCallback( SFG_Window* w, SFG_Enumerator* e) { if( FETCH_WCB( *w, Joystick ) ) { e->found = GL_TRUE; e->data = w; } - fgEnumSubWindows( w, fgCheckJoystickCallback, e ); + fgEnumSubWindows( w, fghCheckJoystickCallback, e ); } -static int fgHaveJoystick( void ) +static int fghHaveJoystick( void ) { SFG_Enumerator enumerator; enumerator.found = GL_FALSE; enumerator.data = NULL; - fgEnumWindows( fgCheckJoystickCallback, &enumerator ); + fgEnumWindows( fghCheckJoystickCallback, &enumerator ); return !!enumerator.data; } -static void fgHavePendingRedisplaysCallback( SFG_Window* w, SFG_Enumerator* e) +static void fghHavePendingRedisplaysCallback( SFG_Window* w, SFG_Enumerator* e) { if( w->State.Redisplay ) { e->found = GL_TRUE; e->data = w; } - fgEnumSubWindows( w, fgHavePendingRedisplaysCallback, e ); -} -static int fgHavePendingRedisplays (void) + fgEnumSubWindows( w, fghHavePendingRedisplaysCallback, e ); +} +static int fghHavePendingRedisplays (void) { SFG_Enumerator enumerator; enumerator.found = GL_FALSE; enumerator.data = NULL; - fgEnumWindows( fgHavePendingRedisplaysCallback, &enumerator ); + fgEnumWindows( fghHavePendingRedisplaysCallback, &enumerator ); return !!enumerator.data; } /* - * Indicates whether there are any outstanding timers. - */ -#if 0 /* Not used */ -static int fgHaveTimers( void ) -{ - return !!fgState.Timers.First; -} -#endif -/* * Returns the number of GLUT ticks (milliseconds) till the next timer event. */ -static long fgNextTimer( void ) +static long fghNextTimer( void ) { - long now = fgElapsedTime(); long ret = INT_MAX; - SFG_Timer *timer; + SFG_Timer *timer = fgState.Timers.First; - for( timer = (SFG_Timer *)fgState.Timers.First; - timer; - timer = (SFG_Timer *)timer->Node.Next ) - ret = MIN( ret, MAX( 0, timer->TriggerTime - now ) ); + if( timer ) + ret = timer->TriggerTime - fgElapsedTime(); + if( ret < 0 ) + ret = 0; return ret; } @@ -516,33 +443,46 @@ static long fgNextTimer( void ) * Does the magic required to relinquish the CPU until something interesting * happens. */ -static void fgSleepForEvents( void ) +static void fghSleepForEvents( void ) { -#if TARGET_HOST_UNIX_X11 - fd_set fdset; - int err; - int socket; - struct timeval wait; - long msec; - - if( fgState.IdleCallback || fgHavePendingRedisplays( ) ) + long msec; + + if( fgState.IdleCallback || fghHavePendingRedisplays( ) ) 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( -1 == err ) - fgWarning ( "freeglut select() error: %d\n", errno ); - -#elif TARGET_HOST_WIN32 + + msec = fghNextTimer( ); + if( fghHaveJoystick( ) ) /* XXX Use GLUT timers for joysticks... */ + msec = MIN( msec, 10 ); /* XXX Dumb; forces granularity to .01sec */ + +#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 the 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", errno ); + } +#elif TARGET_HOST_WIN32 || TARGET_HOST_WINCE + MsgWaitForMultipleObjects( 0, NULL, FALSE, msec, QS_ALLEVENTS ); #endif } @@ -550,7 +490,7 @@ static void fgSleepForEvents( void ) /* * Returns GLUT modifier mask for an XEvent. */ -int fgGetXModifiers( XEvent *event ) +static int fghGetXModifiers( XEvent *event ) { int ret = 0; @@ -560,7 +500,7 @@ int fgGetXModifiers( XEvent *event ) ret |= GLUT_ACTIVE_CTRL; if( event->xkey.state & Mod1Mask ) ret |= GLUT_ACTIVE_ALT; - + return ret; } #endif @@ -577,9 +517,7 @@ void FGAPIENTRY glutMainLoopEvent( void ) SFG_Window* window; XEvent event; - /* - * This code was repeated constantly, so here it goes into a definition: - */ + /* This code was repeated constantly, so here it goes into a definition: */ #define GETWINDOW(a) \ window = fgWindowByHandle( event.a.window ); \ if( window == NULL ) \ @@ -598,15 +536,22 @@ void FGAPIENTRY glutMainLoopEvent( void ) switch( event.type ) { case ClientMessage: - /* - * Destroy the window when the WM_DELETE_WINDOW message arrives - */ + /* Destroy the window when the WM_DELETE_WINDOW message arrives */ if( (Atom) event.xclient.data.l[ 0 ] == fgDisplay.DeleteWindow ) { - GETWINDOW( xclient ); + GETWINDOW( xclient ); + + fgDestroyWindow ( window ); + + if( fgState.ActionOnWindowClose == GLUT_ACTION_EXIT ) + { + fgDeinitialize( ); + exit( 0 ); + } + else if( fgState.ActionOnWindowClose == GLUT_ACTION_GLUTMAINLOOP_RETURNS ) + fgState.ExecState = GLUT_EXEC_STATE_STOP; - fgCloseWindow ( window ); - fgAddToWindowDestroyList ( window, GL_FALSE ); + return; } break; @@ -616,39 +561,65 @@ 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, GL_FALSE ); */ + /* fgAddToWindowDestroyList ( window ); */ break; 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: @@ -669,7 +640,10 @@ void FGAPIENTRY glutMainLoopEvent( void ) case VisibilityNotify: { - GETWINDOW( xvisibility ); + GETWINDOW( xvisibility ); + /* + * XXX INVOKE_WCB() does this check for us. + */ if( ! FETCH_WCB( *window, WindowStatus ) ) break; fgSetWindow( window ); @@ -686,20 +660,20 @@ void FGAPIENTRY glutMainLoopEvent( void ) INVOKE_WCB( *window, WindowStatus, ( GLUT_FULLY_RETAINED ) ); window->State.Visible = GL_TRUE; break; - + case VisibilityPartiallyObscured: INVOKE_WCB( *window, WindowStatus, ( GLUT_PARTIALLY_RETAINED ) ); window->State.Visible = GL_TRUE; break; - + case VisibilityFullyObscured: INVOKE_WCB( *window, WindowStatus, ( GLUT_FULLY_COVERED ) ); window->State.Visible = GL_FALSE; break; default: - fgWarning( "Uknown X visibility state: %d", + fgWarning( "Unknown X visibility state: %d", event.xvisibility.state ); break; } @@ -737,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 ) @@ -765,7 +741,7 @@ void FGAPIENTRY glutMainLoopEvent( void ) */ GETWINDOW( xbutton ); GETMOUSE( xbutton ); - + /* * An X button (at least in XFree86) is numbered from 1. * A GLUT button is numbered from 0. @@ -807,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 ) ) @@ -834,24 +810,30 @@ 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; } - /* - * No active menu, let's check whether we need to activate one. - */ + /* No active menu, let's check whether we need to activate one. */ if( ( 0 <= button ) && ( FREEGLUT_MAX_MENUS > button ) && ( window->Menu[ button ] ) && pressed ) { + /* XXX Posting a requisite Redisplay seems bogus. */ window->State.Redisplay = GL_TRUE; fgSetWindow( window ); fgActivateMenu( window, button ); @@ -866,15 +848,12 @@ void FGAPIENTRY glutMainLoopEvent( void ) ! FETCH_WCB( *window, MouseWheel ) ) break; - /* - * XXX Why don't we use {window}? Other code here does... - */ - fgState.Modifiers = fgGetXModifiers( &event ); + fgState.Modifiers = fghGetXModifiers( &event ); /* * 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, @@ -900,7 +879,7 @@ void FGAPIENTRY glutMainLoopEvent( void ) int direction = -1; if( button % 2 ) direction = 1; - + if( pressed ) INVOKE_WCB( *window, MouseWheel, ( wheel_number, direction, @@ -909,9 +888,7 @@ void FGAPIENTRY glutMainLoopEvent( void ) ); } - /* - * Trash the modifiers state - */ + /* Trash the modifiers state */ fgState.Modifiers = 0xffffffff; } break; @@ -925,6 +902,37 @@ void FGAPIENTRY glutMainLoopEvent( void ) GETWINDOW( xkey ); GETMOUSE( xkey ); + /* Detect auto repeated keys, if configured globally or per-window */ + + if ( fgState.KeyRepeat==GLUT_KEY_REPEAT_OFF || window->State.IgnoreKeyRepeat==GL_TRUE ) + { + if (event.type==KeyRelease) + { + /* + * Look at X11 keystate to detect repeat mode. + * While X11 says the key is actually held down, we'll ignore KeyRelease/KeyPress pairs. + */ + + char keys[32]; + XQueryKeymap( fgDisplay.Display, keys ); /* Look at X11 keystate to detect repeat mode */ + + if ( event.xkey.keycode<256 ) /* XQueryKeymap is limited to 256 keycodes */ + { + if ( keys[event.xkey.keycode>>3] & (1<<(event.xkey.keycode%8)) ) + window->State.KeyRepeating = GL_TRUE; + else + window->State.KeyRepeating = GL_FALSE; + } + } + } + else + window->State.KeyRepeating = GL_FALSE; + + /* Cease processing this event if it is auto repeated */ + + if (window->State.KeyRepeating) + break; + if( event.type == KeyPress ) { keyboard_cb = FETCH_WCB( *window, Keyboard ); @@ -964,7 +972,7 @@ void FGAPIENTRY glutMainLoopEvent( void ) if( keyboard_cb ) { fgSetWindow( window ); - fgState.Modifiers = fgGetXModifiers( &event ); + fgState.Modifiers = fghGetXModifiers( &event ); keyboard_cb( asciiCode[ 0 ], event.xkey.x, event.xkey.y ); @@ -1018,7 +1026,7 @@ void FGAPIENTRY glutMainLoopEvent( void ) if( special_cb && (special != -1) ) { fgSetWindow( window ); - fgState.Modifiers = fgGetXModifiers( &event ); + fgState.Modifiers = fghGetXModifiers( &event ); special_cb( special, event.xkey.x, event.xkey.y ); fgState.Modifiers = 0xffffffff; } @@ -1036,21 +1044,32 @@ void FGAPIENTRY glutMainLoopEvent( void ) } } -#elif TARGET_HOST_WIN32 +#elif TARGET_HOST_WIN32 || TARGET_HOST_WINCE MSG stMsg; while( PeekMessage( &stMsg, NULL, 0, 0, PM_NOREMOVE ) ) { if( GetMessage( &stMsg, NULL, 0, 0 ) == 0 ) - fgState.ExecState = GLUT_EXEC_STATE_STOP ; + { + if( fgState.ActionOnWindowClose == GLUT_ACTION_EXIT ) + { + fgDeinitialize( ); + exit( 0 ); + } + else if( fgState.ActionOnWindowClose == GLUT_ACTION_GLUTMAINLOOP_RETURNS ) + fgState.ExecState = GLUT_EXEC_STATE_STOP; + + return; + } TranslateMessage( &stMsg ); DispatchMessage( &stMsg ); } #endif - fghCheckTimers( ); + if( fgState.Timers.First ) + fghCheckTimers( ); fghCheckJoystickPolls( ); fghDisplayAll( ); @@ -1063,13 +1082,15 @@ void FGAPIENTRY glutMainLoopEvent( void ) */ void FGAPIENTRY glutMainLoop( void ) { -#if TARGET_HOST_WIN32 + int action; + +#if TARGET_HOST_WIN32 || TARGET_HOST_WINCE SFG_Window *window = (SFG_Window *)fgStructure.Windows.First ; #endif freeglut_assert_ready; -#if TARGET_HOST_WIN32 +#if TARGET_HOST_WIN32 || TARGET_HOST_WINCE /* * Processing before the main loop: If there is a window which is open and * which has a visibility callback, call it. I know this is an ugly hack, @@ -1088,7 +1109,7 @@ void FGAPIENTRY glutMainLoop( void ) INVOKE_WCB( *window, Visibility, ( window->State.Visible ) ); fgSetWindow( current_window ); } - + window = (SFG_Window *)window->Node.Next ; } #endif @@ -1096,31 +1117,40 @@ void FGAPIENTRY glutMainLoop( void ) fgState.ExecState = GLUT_EXEC_STATE_RUNNING ; while( fgState.ExecState == GLUT_EXEC_STATE_RUNNING ) { + SFG_Window *window; + 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( fgStructure.Windows.First == NULL ) + if( ! window ) fgState.ExecState = GLUT_EXEC_STATE_STOP; else { if( fgState.IdleCallback ) fgState.IdleCallback( ); - fgSleepForEvents(); + fghSleepForEvents( ); } } - { - fgExecutionState execState = fgState.ExecState; - - /* - * When this loop terminates, destroy the display, state and structure - * of a freeglut session, so that another glutInit() call can happen - */ - fgDeinitialize( ); - - if( execState == GLUT_ACTION_EXIT ) - exit( 0 ); - } + /* + * 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 ); } /* @@ -1132,11 +1162,11 @@ void FGAPIENTRY glutLeaveMainLoop( void ) } -#if TARGET_HOST_WIN32 +#if TARGET_HOST_WIN32 || TARGET_HOST_WINCE /* * Determine a GLUT modifer mask based on MS-WINDOWS system info. */ -int fgGetWin32Modifiers (void) +static int fghGetWin32Modifiers (void) { return ( ( ( GetKeyState( VK_LSHIFT ) < 0 ) || @@ -1165,9 +1195,7 @@ LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam, switch( uMsg ) { case WM_CREATE: - /* - * The window structure is passed as the creation structure paramter... - */ + /* The window structure is passed as the creation structure paramter... */ window = (SFG_Window *) (((LPCREATESTRUCT) lParam)->lpCreateParams); assert( window != NULL ); @@ -1177,7 +1205,9 @@ LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam, { unsigned int current_DisplayMode = fgState.DisplayMode; fgState.DisplayMode = GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH; +#if !TARGET_HOST_WINCE fgSetupPixelFormat( window, GL_FALSE, PFD_MAIN_PLANE ); +#endif fgState.DisplayMode = current_DisplayMode; if( fgStructure.MenuContext ) @@ -1197,7 +1227,9 @@ LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam, } else { +#if !TARGET_HOST_WINCE fgSetupPixelFormat( window, GL_FALSE, PFD_MAIN_PLANE ); +#endif if( ! fgState.UseCurrentContext ) window->Window.Context = @@ -1216,28 +1248,57 @@ LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam, window->State.Height = fgState.Size.Y; ReleaseDC( window->Window.Handle, window->Window.Device ); + +#if TARGET_HOST_WINCE + /* Take over button handling */ + { + HINSTANCE dxDllLib=LoadLibrary(_T("gx.dll")); + if (dxDllLib) + { + GXGetDefaultKeys_=(GXGETDEFAULTKEYS)GetProcAddress(dxDllLib, _T("?GXGetDefaultKeys@@YA?AUGXKeyList@@H@Z")); + GXOpenInput_=(GXOPENINPUT)GetProcAddress(dxDllLib, _T("?GXOpenInput@@YAHXZ")); + } + + if(GXOpenInput_) + (*GXOpenInput_)(); + if(GXGetDefaultKeys_) + gxKeyList = (*GXGetDefaultKeys_)(GX_LANDSCAPEKEYS); + } + +#endif /* TARGET_HOST_WINCE */ break; 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; +#if TARGET_HOST_WINCE + window->State.Width = HIWORD(lParam); + window->State.Height = LOWORD(lParam); +#else + window->State.Width = LOWORD(lParam); + window->State.Height = HIWORD(lParam); +#endif /* TARGET_HOST_WINCE */ + } + break; #if 0 - case WM_SETFOCUS: - printf("WM_SETFOCUS: %p\n", window ); + case WM_SETFOCUS: +/* printf("WM_SETFOCUS: %p\n", window ); */ lRet = DefWindowProc( hWnd, uMsg, wParam, lParam ); break; - case WM_ACTIVATE: + case WM_ACTIVATE: if (LOWORD(wParam) != WA_INACTIVE) { /* glutSetCursor( fgStructure.Window->State.Cursor ); */ - printf("WM_ACTIVATE: glutSetCursor( %p, %d)\n", window, - window->State.Cursor ); +/* printf("WM_ACTIVATE: glutSetCursor( %p, %d)\n", window, + window->State.Cursor ); */ glutSetCursor( window->State.Cursor ); } @@ -1253,7 +1314,7 @@ LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam, * XXX call glutSetCurdsor() instead of defining two macros * XXX and implementing a nested case in-line. */ - case WM_SETCURSOR: + case WM_SETCURSOR: /* Set the cursor AND change it for this window class. */ #define MAP_CURSOR(a,b) \ case a: \ @@ -1298,43 +1359,14 @@ LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam, /* Turn on the visibility in case it was turned off somehow */ window->State.Visible = GL_TRUE; BeginPaint( hWnd, &ps ); - fghRedrawWindowByHandle( hWnd ); + fghRedrawWindow( window ); EndPaint( hWnd, &ps ); break; case WM_CLOSE: - /* - * Make sure we don't close a window with current context active - */ - if( fgStructure.Window == window ) - { - int used = FALSE ; - SFG_Window *iter ; - - wglMakeCurrent( NULL, NULL ); - /* - * Step through the list of windows. If the rendering context - * is not being used by another window, then we delete it. - */ - 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 ); - } - - /* - * Put on a linked list of windows to be removed after all the - * callbacks have returned - */ - fgAddToWindowDestroyList( window, GL_FALSE ); - DestroyWindow( hWnd ); + fgDestroyWindow ( window ); + if ( fgState.ActionOnWindowClose != GLUT_ACTION_CONTINUE_EXECUTION ) + PostQuitMessage(0); break; case WM_DESTROY: @@ -1345,9 +1377,18 @@ LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam, case WM_MOUSEMOVE: { +#if TARGET_HOST_WINCE + window->State.MouseX = 320-HIWORD( lParam ); + window->State.MouseY = LOWORD( lParam ); +#else window->State.MouseX = LOWORD( lParam ); window->State.MouseY = HIWORD( lParam ); - +#endif /* TARGET_HOST_WINCE */ + /* Restrict to [-32768, 32767] to match X11 behaviour */ + /* See comment in "freeglut_developer" mailing list 10/4/04 */ + if ( window->State.MouseX > 32767 ) window->State.MouseX -= 65536; + if ( window->State.MouseY > 32767 ) window->State.MouseY -= 65536; + if ( window->ActiveMenu ) { window->State.Redisplay = GL_TRUE; @@ -1355,7 +1396,7 @@ LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam, break; } - fgState.Modifiers = fgGetWin32Modifiers( ); + fgState.Modifiers = fghGetWin32Modifiers( ); if( ( wParam & MK_LBUTTON ) || ( wParam & MK_MBUTTON ) || @@ -1380,8 +1421,18 @@ LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam, GLboolean pressed = GL_TRUE; int button; +#if TARGET_HOST_WINCE + window->State.MouseX = 320-HIWORD( lParam ); + window->State.MouseY = LOWORD( lParam ); +#else window->State.MouseX = LOWORD( lParam ); window->State.MouseY = HIWORD( lParam ); +#endif /* TARGET_HOST_WINCE */ + + /* Restrict to [-32768, 32767] to match X11 behaviour */ + /* See comment in "freeglut_developer" mailing list 10/4/04 */ + if ( window->State.MouseX > 32767 ) window->State.MouseX -= 65536; + if ( window->State.MouseY > 32767 ) window->State.MouseY -= 65536; switch( uMsg ) { @@ -1415,11 +1466,16 @@ LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam, break; } +#if !TARGET_HOST_WINCE 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; + } +#endif /* !TARGET_HOST_WINCE */ if( button == -1 ) return DefWindowProc( hWnd, uMsg, lParam, wParam ); @@ -1484,7 +1540,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 ); @@ -1493,11 +1549,24 @@ LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam, break; } + /* Set capture so that the window captures all the mouse messages */ + /* + * XXX - Multiple button support: Under X11, the mouse is not released + * XXX - from the window until all buttons have been released, even if the + * XXX - user presses a button in another window. This will take more + * XXX - code changes than I am up to at the moment (10/5/04). The present + * XXX - is a 90 percent solution. + */ + if ( pressed == GL_TRUE ) + SetCapture ( window->Window.Handle ) ; + else + ReleaseCapture () ; + if( ! FETCH_WCB( *window, Mouse ) ) break; fgSetWindow( window ); - fgState.Modifiers = fgGetWin32Modifiers( ); + fgState.Modifiers = fghGetWin32Modifiers( ); INVOKE_WCB( *window, Mouse, @@ -1542,7 +1611,7 @@ LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam, break; fgSetWindow( window ); - fgState.Modifiers = fgGetWin32Modifiers( ); + fgState.Modifiers = fghGetWin32Modifiers( ); while( ticks-- ) if( FETCH_WCB( *window, MouseWheel ) ) @@ -1582,14 +1651,14 @@ LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam, int keypress = -1; POINT mouse_pos ; - if( fgState.IgnoreKeyRepeat && (lParam & KF_REPEAT) ) + if( ( fgState.KeyRepeat==GLUT_KEY_REPEAT_OFF || window->State.IgnoreKeyRepeat==GL_TRUE ) && (HIWORD(lParam) & KF_REPEAT) ) break; /* - * Remember the current modifiers state. This is done here in order + * Remember the current modifiers state. This is done here in order * to make sure the VK_DELETE keyboard callback is executed properly. */ - fgState.Modifiers = fgGetWin32Modifiers( ); + fgState.Modifiers = fghGetWin32Modifiers( ); GetCursorPos( &mouse_pos ); ScreenToClient( window->Window.Handle, &mouse_pos ); @@ -1635,6 +1704,28 @@ LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam, ); } +#if TARGET_HOST_WINCE + if(!(lParam & 0x40000000)) /* Prevent auto-repeat */ + { + if(wParam==(unsigned)gxKeyList.vkRight) + keypress = GLUT_KEY_RIGHT; + else if(wParam==(unsigned)gxKeyList.vkLeft) + keypress = GLUT_KEY_LEFT; + else if(wParam==(unsigned)gxKeyList.vkUp) + keypress = GLUT_KEY_UP; + else if(wParam==(unsigned)gxKeyList.vkDown) + keypress = GLUT_KEY_DOWN; + else if(wParam==(unsigned)gxKeyList.vkA) + keypress = GLUT_KEY_F1; + else if(wParam==(unsigned)gxKeyList.vkB) + keypress = GLUT_KEY_F2; + else if(wParam==(unsigned)gxKeyList.vkC) + keypress = GLUT_KEY_F3; + else if(wParam==(unsigned)gxKeyList.vkStart) + keypress = GLUT_KEY_F4; + } +#endif + if( keypress != -1 ) INVOKE_WCB( *window, Special, ( keypress, @@ -1652,10 +1743,10 @@ LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam, POINT mouse_pos; /* - * Remember the current modifiers state. This is done here in order + * Remember the current modifiers state. This is done here in order * to make sure the VK_DELETE keyboard callback is executed properly. */ - fgState.Modifiers = fgGetWin32Modifiers( ); + fgState.Modifiers = fghGetWin32Modifiers( ); GetCursorPos( &mouse_pos ); ScreenToClient( window->Window.Handle, &mouse_pos ); @@ -1703,11 +1794,12 @@ LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam, default: { +#if !TARGET_HOST_WINCE BYTE state[ 256 ]; WORD code[ 2 ]; - + GetKeyboardState( state ); - + if( ToAscii( wParam, 0, state, code, 0 ) == 1 ) wParam=code[ 0 ]; @@ -1715,6 +1807,7 @@ LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam, ( (char)wParam, window->State.MouseX, window->State.MouseY ) ); +#endif /* !TARGET_HOST_WINCE */ } } @@ -1731,24 +1824,15 @@ LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam, case WM_SYSCHAR: case WM_CHAR: { - if( fgState.IgnoreKeyRepeat && (lParam & KF_REPEAT) ) + if( (fgState.KeyRepeat==GLUT_KEY_REPEAT_OFF || window->State.IgnoreKeyRepeat==GL_TRUE) && (HIWORD(lParam) & KF_REPEAT) ) break; - /* - * XXX INVOKE_WCB() takes care of the callback-pointer check. - * XXX We could just uncoditionally find/trash the Modifiers - * XXX and get rid of the "if( ... ) {" and "}". Unconditinal - * XXX code is simpler code. (^& - */ - if( FETCH_WCB( *window, Keyboard ) ) - { - fgState.Modifiers = fgGetWin32Modifiers( ); - INVOKE_WCB( *window, Keyboard, - ( (char)wParam, - window->State.MouseX, window->State.MouseY ) - ); - fgState.Modifiers = 0xffffffff; - } + fgState.Modifiers = fghGetWin32Modifiers( ); + INVOKE_WCB( *window, Keyboard, + ( (char)wParam, + window->State.MouseX, window->State.MouseY ) + ); + fgState.Modifiers = 0xffffffff; } break; @@ -1785,6 +1869,7 @@ LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam, lRet = DefWindowProc( hWnd, uMsg, wParam, lParam ); break; +#if !TARGET_HOST_WINCE case WM_SYNCPAINT: /* 0x0088 */ /* Another window has moved, need to update this one */ window->State.Redisplay = GL_TRUE; @@ -1802,11 +1887,15 @@ LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam, { /* * We have received a system command message. Try to act on it. - * The commands are passed in through the "lParam" parameter: - * Clicking on a corner to resize the window gives a "F004" message - * but this is not defined in my header file. + * The commands are passed in through the "wParam" parameter: + * The least significant digit seems to be which edge of the window + * is being used for a resize event: + * 4 3 5 + * 1 2 + * 7 6 8 + * Congratulations and thanks to Richard Rauch for figuring this out.. */ - switch ( lParam ) + switch ( wParam & 0xfff0 ) { case SC_SIZE : break ; @@ -1860,8 +1949,15 @@ LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam, case SC_HOTKEY : break ; + + default: +#if _DEBUG + fgWarning( "Unknown wParam type 0x%x", wParam ); +#endif + break; } } +#endif /* !TARGET_HOST_WINCE */ /* We need to pass the message on to the operating system as well */ lRet = DefWindowProc( hWnd, uMsg, wParam, lParam );