#include "config.h"
#endif
-#include "../include/GL/freeglut.h"
+#include <GL/freeglut.h>
#include "freeglut_internal.h"
#include <limits.h>
fgSetWindow( window );
- fghReshapeWindowByHandle(
+ fghReshapeWindowByHandle(
window->Window.Handle,
window->State.Width,
window->State.Height
);
window->State.NeedToResize = GL_FALSE;
- fgSetWindow ( current_window );
+ fgSetWindow( current_window );
}
INVOKE_WCB( *window, Display, ( ) );
if( window->State.NeedToResize )
{
SFG_Window *current_window = fgStructure.Window;
-
+
fgSetWindow( window );
-
- fghReshapeWindowByHandle(
+
+ fghReshapeWindowByHandle(
window->Window.Handle,
window->State.Width,
window->State.Height
);
-
+
window->State.NeedToResize = GL_FALSE;
- fgSetWindow( current_window );
+ fgSetWindow ( current_window );
}
if( window->State.Redisplay &&
}
#elif TARGET_HOST_WIN32
RedrawWindow(
- window->Window.Handle, NULL, NULL,
+ window->Window.Handle, NULL, NULL,
RDW_NOERASE | RDW_INTERNALPAINT | RDW_INVALIDATE | RDW_UPDATENOW
);
#endif
* 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)
e->data = w;
}
fgEnumSubWindows( w, fgHavePendingRedisplaysCallback, e );
-}
+}
static int fgHavePendingRedisplays (void)
{
SFG_Enumerator enumerator;
if( fgState.IdleCallback || fgHavePendingRedisplays( ) )
return;
-
+
msec = fgNextTimer( );
if( fgHaveJoystick( ) ) /* 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 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;
ret |= GLUT_ACTIVE_CTRL;
if( event->xkey.state & Mod1Mask )
ret |= GLUT_ACTIVE_ALT;
-
+
return ret;
}
#endif
*/
if( (Atom) event.xclient.data.l[ 0 ] == fgDisplay.DeleteWindow )
{
- GETWINDOW( xclient );
+ GETWINDOW( xclient );
fgDestroyWindow ( window );
case DestroyNotify:
/*
* This is sent to confirm the XDestroyWindow call.
+ *
* XXX WHY is this commented out? Should we re-enable it?
*/
/* fgAddToWindowDestroyList ( window ); */
* XXX double-buffered does not respect viewport when we
* XXX do a buffer-swap).
*
- * XXX GETWINDOW( xexpose );
- * XXX fgSetWindow( window );
- * XXX glutPostRedisplay( );
*/
if( event.xexpose.count == 0 )
- fghRedrawWindowByHandle( event.xexpose.window );
+ {
+ GETWINDOW( xexpose );
+ fgSetWindow( window );
+ glutPostRedisplay( );
+ }
break;
case MapNotify:
case VisibilityNotify:
{
- GETWINDOW( xvisibility );
+ GETWINDOW( xvisibility );
/*
* XXX INVOKE_WCB() does this check for us.
*/
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;
*/
GETWINDOW( xbutton );
GETMOUSE( xbutton );
-
+
/*
* An X button (at least in XFree86) is numbered from 1.
* A GLUT button is numbered from 0.
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 ) )
int direction = -1;
if( button % 2 )
direction = 1;
-
+
if( pressed )
INVOKE_WCB( *window, MouseWheel, ( wheel_number,
direction,
*/
void FGAPIENTRY glutMainLoop( void )
{
+ int action;
+
#if TARGET_HOST_WIN32
SFG_Window *window = (SFG_Window *)fgStructure.Windows.First ;
#endif
INVOKE_WCB( *window, Visibility, ( window->State.Visible ) );
fgSetWindow( current_window );
}
-
+
window = (SFG_Window *)window->Node.Next ;
}
#endif
/*
* 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
/*
* 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( fgState.ActionOnWindowClose == GLUT_ACTION_EXIT )
+ if( action == GLUT_ACTION_EXIT )
exit( 0 );
}
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:
+ 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 ); */
* 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: \
{
window->State.MouseX = LOWORD( lParam );
window->State.MouseY = HIWORD( lParam );
-
+
if ( window->ActiveMenu )
{
window->State.Redisplay = GL_TRUE;
int keypress = -1;
POINT mouse_pos ;
- if( fgState.IgnoreKeyRepeat && (lParam & KF_REPEAT) )
+ if( fgState.IgnoreKeyRepeat && (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( );
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( );
{
BYTE state[ 256 ];
WORD code[ 2 ];
-
+
GetKeyboardState( state );
-
+
if( ToAscii( wParam, 0, state, code, 0 ) == 1 )
wParam=code[ 0 ];
case WM_SYSCHAR:
case WM_CHAR:
{
- if( fgState.IgnoreKeyRepeat && (lParam & KF_REPEAT) )
+ if( fgState.IgnoreKeyRepeat && (HIWORD(lParam) & KF_REPEAT) )
break;
fgState.Modifiers = fgGetWin32Modifiers( );