-/*\r
- * freeglut_main.c\r
- *\r
- * The windows message processing methods.\r
- *\r
- * Copyright (c) 1999-2000 Pawel W. Olszta. All Rights Reserved.\r
- * Written by Pawel W. Olszta, <olszta@sourceforge.net>\r
- * Creation date: Fri Dec 3 1999\r
- *\r
- * Permission is hereby granted, free of charge, to any person obtaining a\r
- * copy of this software and associated documentation files (the "Software"),\r
- * to deal in the Software without restriction, including without limitation\r
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,\r
- * and/or sell copies of the Software, and to permit persons to whom the\r
- * Software is furnished to do so, subject to the following conditions:\r
- *\r
- * The above copyright notice and this permission notice shall be included\r
- * in all copies or substantial portions of the Software.\r
- *\r
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS\r
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL\r
- * PAWEL W. OLSZTA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\r
- * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
- */\r
-\r
-#include <GL/freeglut.h>\r
-#include "freeglut_internal.h"\r
-#ifdef HAVE_ERRNO_H\r
-# include <errno.h>\r
-#endif\r
-#include <stdarg.h>\r
-#ifdef HAVE_VFPRINTF\r
-# define VFPRINTF(s,f,a) vfprintf((s),(f),(a))\r
-#elif defined(HAVE__DOPRNT)\r
-# define VFPRINTF(s,f,a) _doprnt((f),(a),(s))\r
-#else\r
-# define VFPRINTF(s,f,a)\r
-#endif\r
-\r
-#ifdef _WIN32_WCE\r
-\r
-typedef struct GXDisplayProperties GXDisplayProperties;\r
-typedef struct GXKeyList GXKeyList;\r
-#include <gx.h>\r
-\r
-typedef struct GXKeyList (*GXGETDEFAULTKEYS)(int);\r
-typedef int (*GXOPENINPUT)();\r
-\r
-GXGETDEFAULTKEYS GXGetDefaultKeys_ = NULL;\r
-GXOPENINPUT GXOpenInput_ = NULL;\r
-\r
-struct GXKeyList gxKeyList;\r
-\r
-#endif /* _WIN32_WCE */\r
-\r
-/*\r
- * Try to get the maximum value allowed for ints, falling back to the minimum\r
- * guaranteed by ISO C99 if there is no suitable header.\r
- */\r
-#ifdef HAVE_LIMITS_H\r
-# include <limits.h>\r
-#endif\r
-#ifndef INT_MAX\r
-# define INT_MAX 32767\r
-#endif\r
-\r
-#ifndef MIN\r
-# define MIN(a,b) (((a)<(b)) ? (a) : (b))\r
-#endif\r
-\r
-extern void fgPlatformReshapeWindow ( SFG_Window *window, int width, int height );\r
-extern void fgPlatformDisplayWindow ( SFG_Window *window );\r
-extern unsigned long fgPlatformSystemTime ( void );\r
-extern void fgPlatformSleepForEvents( long msec );\r
-extern void fgPlatformProcessSingleEvent ( void );\r
-extern void fgPlatformMainLoopPreliminaryWork ( void );\r
-\r
-\r
-\r
-\r
-/* -- PRIVATE FUNCTIONS ---------------------------------------------------- */\r
-\r
-static void fghReshapeWindow ( SFG_Window *window, int width, int height )\r
-{\r
- SFG_Window *current_window = fgStructure.CurrentWindow;\r
-\r
- freeglut_return_if_fail( window != NULL );\r
-\r
- fgPlatformReshapeWindow ( window, width, height );\r
-\r
- if( FETCH_WCB( *window, Reshape ) )\r
- INVOKE_WCB( *window, Reshape, ( width, height ) );\r
- else\r
- {\r
- fgSetWindow( window );\r
- glViewport( 0, 0, width, height );\r
- }\r
-\r
- /*\r
- * Force a window redraw. In Windows at least this is only a partial\r
- * solution: if the window is increasing in size in either dimension,\r
- * the already-drawn part does not get drawn again and things look funny.\r
- * But without this we get this bad behaviour whenever we resize the\r
- * window.\r
- */\r
- window->State.Redisplay = GL_TRUE;\r
-\r
- if( window->IsMenu )\r
- fgSetWindow( current_window );\r
-}\r
-\r
-/*\r
- * Calls a window's redraw method. This is used when\r
- * a redraw is forced by the incoming window messages.\r
- */\r
-void fghRedrawWindow ( SFG_Window *window )\r
-{\r
- SFG_Window *current_window = fgStructure.CurrentWindow;\r
-\r
- freeglut_return_if_fail( window );\r
- freeglut_return_if_fail( FETCH_WCB ( *window, Display ) );\r
-\r
- window->State.Redisplay = GL_FALSE;\r
-\r
- freeglut_return_if_fail( window->State.Visible );\r
-\r
- fgSetWindow( window );\r
-\r
- if( window->State.NeedToResize )\r
- {\r
- fghReshapeWindow(\r
- window,\r
- window->State.Width,\r
- window->State.Height\r
- );\r
-\r
- window->State.NeedToResize = GL_FALSE;\r
- }\r
-\r
- INVOKE_WCB( *window, Display, ( ) );\r
-\r
- fgSetWindow( current_window );\r
-}\r
-\r
-\r
-static void fghcbDisplayWindow( SFG_Window *window,\r
- SFG_Enumerator *enumerator )\r
-{\r
- if( window->State.Redisplay &&\r
- window->State.Visible )\r
- {\r
- window->State.Redisplay = GL_FALSE;\r
- fgPlatformDisplayWindow ( window );\r
- }\r
-\r
- fgEnumSubWindows( window, fghcbDisplayWindow, enumerator );\r
-}\r
-\r
-/*\r
- * Make all windows perform a display call\r
- */\r
-static void fghDisplayAll( void )\r
-{\r
- SFG_Enumerator enumerator;\r
-\r
- enumerator.found = GL_FALSE;\r
- enumerator.data = NULL;\r
-\r
- fgEnumWindows( fghcbDisplayWindow, &enumerator );\r
-}\r
-\r
-/*\r
- * Window enumerator callback to check for the joystick polling code\r
- */\r
-static void fghcbCheckJoystickPolls( SFG_Window *window,\r
- SFG_Enumerator *enumerator )\r
-{\r
- long int checkTime = fgElapsedTime( );\r
-\r
- if( window->State.JoystickLastPoll + window->State.JoystickPollRate <=\r
- checkTime )\r
- {\r
-#if !defined(_WIN32_WCE)\r
- fgJoystickPollWindow( window );\r
-#endif /* !defined(_WIN32_WCE) */\r
- window->State.JoystickLastPoll = checkTime;\r
- }\r
-\r
- fgEnumSubWindows( window, fghcbCheckJoystickPolls, enumerator );\r
-}\r
-\r
-/*\r
- * Check all windows for joystick polling\r
- */\r
-static void fghCheckJoystickPolls( void )\r
-{\r
- SFG_Enumerator enumerator;\r
-\r
- enumerator.found = GL_FALSE;\r
- enumerator.data = NULL;\r
-\r
- fgEnumWindows( fghcbCheckJoystickPolls, &enumerator );\r
-}\r
-\r
-/*\r
- * Check the global timers\r
- */\r
-static void fghCheckTimers( void )\r
-{\r
- long checkTime = fgElapsedTime( );\r
-\r
- while( fgState.Timers.First )\r
- {\r
- SFG_Timer *timer = fgState.Timers.First;\r
-\r
- if( timer->TriggerTime > checkTime )\r
- break;\r
-\r
- fgListRemove( &fgState.Timers, &timer->Node );\r
- fgListAppend( &fgState.FreeTimers, &timer->Node );\r
-\r
- timer->Callback( timer->ID );\r
- }\r
-}\r
-\r
- \r
-/* Platform-dependent time in milliseconds, as an unsigned 32-bit integer.\r
- * This value wraps every 49.7 days, but integer overflows cancel\r
- * when subtracting an initial start time, unless the total time exceeds\r
- * 32-bit, where the GLUT API return value is also overflowed.\r
- */ \r
-unsigned long fgSystemTime(void)\r
-{\r
- return fgPlatformSystemTime ();\r
-}\r
- \r
-/*\r
- * Elapsed Time\r
- */\r
-long fgElapsedTime( void )\r
-{\r
- return (long) (fgSystemTime() - fgState.Time);\r
-}\r
-\r
-/*\r
- * Error Messages.\r
- */\r
-void fgError( const char *fmt, ... )\r
-{\r
- va_list ap;\r
-\r
- if (fgState.ErrorFunc) {\r
-\r
- va_start( ap, fmt );\r
-\r
- /* call user set error handler here */\r
- fgState.ErrorFunc(fmt, ap);\r
-\r
- va_end( ap );\r
-\r
- } else {\r
-\r
- va_start( ap, fmt );\r
-\r
- fprintf( stderr, "freeglut ");\r
- if( fgState.ProgramName )\r
- fprintf( stderr, "(%s): ", fgState.ProgramName );\r
- VFPRINTF( stderr, fmt, ap );\r
- fprintf( stderr, "\n" );\r
-\r
- va_end( ap );\r
-\r
- if ( fgState.Initialised )\r
- fgDeinitialize ();\r
-\r
- exit( 1 );\r
- }\r
-}\r
-\r
-void fgWarning( const char *fmt, ... )\r
-{\r
- va_list ap;\r
-\r
- if (fgState.WarningFunc) {\r
-\r
- va_start( ap, fmt );\r
-\r
- /* call user set warning handler here */\r
- fgState.WarningFunc(fmt, ap);\r
-\r
- va_end( ap );\r
-\r
- } else {\r
-\r
- va_start( ap, fmt );\r
-\r
- fprintf( stderr, "freeglut ");\r
- if( fgState.ProgramName )\r
- fprintf( stderr, "(%s): ", fgState.ProgramName );\r
- VFPRINTF( stderr, fmt, ap );\r
- fprintf( stderr, "\n" );\r
-\r
- va_end( ap );\r
- }\r
-}\r
-\r
-\r
-/*\r
- * Indicates whether Joystick events are being used by ANY window.\r
- *\r
- * The current mechanism is to walk all of the windows and ask if\r
- * there is a joystick callback. We have a short-circuit early\r
- * return if we find any joystick handler registered.\r
- *\r
- * The real way to do this is to make use of the glutTimer() API\r
- * to more cleanly re-implement the joystick API. Then, this code\r
- * and all other "joystick timer" code can be yanked.\r
- *\r
- */\r
-static void fghCheckJoystickCallback( SFG_Window* w, SFG_Enumerator* e)\r
-{\r
- if( FETCH_WCB( *w, Joystick ) )\r
- {\r
- e->found = GL_TRUE;\r
- e->data = w;\r
- }\r
- fgEnumSubWindows( w, fghCheckJoystickCallback, e );\r
-}\r
-static int fghHaveJoystick( void )\r
-{\r
- SFG_Enumerator enumerator;\r
-\r
- enumerator.found = GL_FALSE;\r
- enumerator.data = NULL;\r
- fgEnumWindows( fghCheckJoystickCallback, &enumerator );\r
- return !!enumerator.data;\r
-}\r
-static void fghHavePendingRedisplaysCallback( SFG_Window* w, SFG_Enumerator* e)\r
-{\r
- if( w->State.Redisplay && w->State.Visible )\r
- {\r
- e->found = GL_TRUE;\r
- e->data = w;\r
- }\r
- fgEnumSubWindows( w, fghHavePendingRedisplaysCallback, e );\r
-}\r
-static int fghHavePendingRedisplays (void)\r
-{\r
- SFG_Enumerator enumerator;\r
-\r
- enumerator.found = GL_FALSE;\r
- enumerator.data = NULL;\r
- fgEnumWindows( fghHavePendingRedisplaysCallback, &enumerator );\r
- return !!enumerator.data;\r
-}\r
-/*\r
- * Returns the number of GLUT ticks (milliseconds) till the next timer event.\r
- */\r
-static long fghNextTimer( void )\r
-{\r
- long ret = INT_MAX;\r
- SFG_Timer *timer = fgState.Timers.First;\r
-\r
- if( timer )\r
- ret = timer->TriggerTime - fgElapsedTime();\r
- if( ret < 0 )\r
- ret = 0;\r
-\r
- return ret;\r
-}\r
-\r
-static void fghSleepForEvents( void )\r
-{\r
- long msec;\r
-\r
- if( fgState.IdleCallback || fghHavePendingRedisplays( ) )\r
- return;\r
-\r
- msec = fghNextTimer( );\r
- /* XXX Use GLUT timers for joysticks... */\r
- /* XXX Dumb; forces granularity to .01sec */\r
- if( fghHaveJoystick( ) && ( msec > 10 ) ) \r
- msec = 10;\r
-\r
- fgPlatformSleepForEvents ( msec );\r
-}\r
-\r
-\r
-/* -- INTERFACE FUNCTIONS -------------------------------------------------- */\r
-\r
-/*\r
- * Executes a single iteration in the freeglut processing loop.\r
- */\r
-void FGAPIENTRY glutMainLoopEvent( void )\r
-{\r
- fgPlatformProcessSingleEvent ();\r
-\r
- if( fgState.Timers.First )\r
- fghCheckTimers( );\r
- fghCheckJoystickPolls( );\r
- fghDisplayAll( );\r
-\r
- fgCloseWindows( );\r
-}\r
-\r
-/*\r
- * Enters the freeglut processing loop.\r
- * Stays until the "ExecState" changes to "GLUT_EXEC_STATE_STOP".\r
- */\r
-void FGAPIENTRY glutMainLoop( void )\r
-{\r
- int action;\r
-\r
- FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutMainLoop" );\r
-\r
- fgPlatformMainLoopPreliminaryWork ();\r
-\r
- fgState.ExecState = GLUT_EXEC_STATE_RUNNING ;\r
- while( fgState.ExecState == GLUT_EXEC_STATE_RUNNING )\r
- {\r
- SFG_Window *window;\r
-\r
- glutMainLoopEvent( );\r
- /*\r
- * Step through the list of windows, seeing if there are any\r
- * that are not menus\r
- */\r
- for( window = ( SFG_Window * )fgStructure.Windows.First;\r
- window;\r
- window = ( SFG_Window * )window->Node.Next )\r
- if ( ! ( window->IsMenu ) )\r
- break;\r
-\r
- if( ! window )\r
- fgState.ExecState = GLUT_EXEC_STATE_STOP;\r
- else\r
- {\r
- if( fgState.IdleCallback )\r
- {\r
- if( fgStructure.CurrentWindow &&\r
- fgStructure.CurrentWindow->IsMenu )\r
- /* fail safe */\r
- fgSetWindow( window );\r
- fgState.IdleCallback( );\r
- }\r
-\r
- fghSleepForEvents( );\r
- }\r
- }\r
-\r
- /*\r
- * When this loop terminates, destroy the display, state and structure\r
- * of a freeglut session, so that another glutInit() call can happen\r
- *\r
- * Save the "ActionOnWindowClose" because "fgDeinitialize" resets it.\r
- */\r
- action = fgState.ActionOnWindowClose;\r
- fgDeinitialize( );\r
- if( action == GLUT_ACTION_EXIT )\r
- exit( 0 );\r
-}\r
-\r
-/*\r
- * Leaves the freeglut processing loop.\r
- */\r
-void FGAPIENTRY glutLeaveMainLoop( void )\r
-{\r
- FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutLeaveMainLoop" );\r
- fgState.ExecState = GLUT_EXEC_STATE_STOP ;\r
-}\r
-\r
-\r
-\r
-/*** END OF FILE ***/\r
+/*
+ * freeglut_main.c
+ *
+ * The windows message processing methods.
+ *
+ * Copyright (c) 1999-2000 Pawel W. Olszta. All Rights Reserved.
+ * Written by Pawel W. Olszta, <olszta@sourceforge.net>
+ * Creation date: Fri Dec 3 1999
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * PAWEL W. OLSZTA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <GL/freeglut.h>
+#include "freeglut_internal.h"
+#ifdef HAVE_ERRNO_H
+# include <errno.h>
+#endif
+#include <stdarg.h>
+#ifdef HAVE_VFPRINTF
+# define VFPRINTF(s,f,a) vfprintf((s),(f),(a))
+#elif defined(HAVE__DOPRNT)
+# define VFPRINTF(s,f,a) _doprnt((f),(a),(s))
+#else
+# define VFPRINTF(s,f,a)
+#endif
+
+/*
+ * Try to get the maximum value allowed for ints, falling back to the minimum
+ * guaranteed by ISO C99 if there is no suitable header.
+ */
+#ifdef HAVE_LIMITS_H
+# include <limits.h>
+#endif
+#ifndef INT_MAX
+# define INT_MAX 32767
+#endif
+
+#ifndef MIN
+# define MIN(a,b) (((a)<(b)) ? (a) : (b))
+#endif
+
+extern void fgPlatformReshapeWindow ( SFG_Window *window, int width, int height );
+extern void fgPlatformDisplayWindow ( SFG_Window *window );
+extern fg_time_t fgPlatformSystemTime ( void );
+extern void fgPlatformSleepForEvents( fg_time_t msec );
+extern void fgPlatformProcessSingleEvent ( void );
+extern void fgPlatformMainLoopPreliminaryWork ( void );
+
+
+
+
+/* -- PRIVATE FUNCTIONS ---------------------------------------------------- */
+
+static void fghReshapeWindow ( SFG_Window *window, int width, int height )
+{
+ SFG_Window *current_window = fgStructure.CurrentWindow;
+
+ freeglut_return_if_fail( window != NULL );
+
+ fgPlatformReshapeWindow ( window, width, height );
+
+ if( FETCH_WCB( *window, Reshape ) )
+ INVOKE_WCB( *window, Reshape, ( width, height ) );
+ else
+ {
+ fgSetWindow( window );
+ glViewport( 0, 0, width, height );
+ }
+
+ /*
+ * Force a window redraw. In Windows at least this is only a partial
+ * solution: if the window is increasing in size in either dimension,
+ * the already-drawn part does not get drawn again and things look funny.
+ * But without this we get this bad behaviour whenever we resize the
+ * window.
+ */
+ window->State.Redisplay = GL_TRUE;
+
+ if( window->IsMenu )
+ fgSetWindow( current_window );
+}
+
+/*
+ * Calls a window's redraw method. This is used when
+ * a redraw is forced by the incoming window messages.
+ */
+void fghRedrawWindow ( SFG_Window *window )
+{
+ SFG_Window *current_window = fgStructure.CurrentWindow;
+
+ freeglut_return_if_fail( window );
+ freeglut_return_if_fail( FETCH_WCB ( *window, Display ) );
+
+ window->State.Redisplay = GL_FALSE;
+
+ freeglut_return_if_fail( window->State.Visible );
+
+ fgSetWindow( window );
+
+ if( window->State.NeedToResize )
+ {
+ fghReshapeWindow(
+ window,
+ window->State.Width,
+ window->State.Height
+ );
+
+ window->State.NeedToResize = GL_FALSE;
+ }
+
+ INVOKE_WCB( *window, Display, ( ) );
+
+ fgSetWindow( current_window );
+}
+
+
+static void fghcbDisplayWindow( SFG_Window *window,
+ SFG_Enumerator *enumerator )
+{
+ if( window->State.Redisplay &&
+ window->State.Visible )
+ {
+ window->State.Redisplay = GL_FALSE;
+ fgPlatformDisplayWindow ( window );
+ }
+
+ fgEnumSubWindows( window, fghcbDisplayWindow, enumerator );
+}
+
+/*
+ * Make all windows perform a display call
+ */
+static void fghDisplayAll( void )
+{
+ SFG_Enumerator enumerator;
+
+ enumerator.found = GL_FALSE;
+ enumerator.data = NULL;
+
+ fgEnumWindows( fghcbDisplayWindow, &enumerator );
+}
+
+/*
+ * Window enumerator callback to check for the joystick polling code
+ */
+static void fghcbCheckJoystickPolls( SFG_Window *window,
+ SFG_Enumerator *enumerator )
+{
+ fg_time_t checkTime = fgElapsedTime( );
+
+ if( window->State.JoystickLastPoll + window->State.JoystickPollRate <=
+ checkTime )
+ {
+#if !defined(_WIN32_WCE)
+ fgJoystickPollWindow( window );
+#endif /* !defined(_WIN32_WCE) */
+ window->State.JoystickLastPoll = checkTime;
+ }
+
+ fgEnumSubWindows( window, fghcbCheckJoystickPolls, enumerator );
+}
+
+/*
+ * Check all windows for joystick polling
+ */
+static void fghCheckJoystickPolls( void )
+{
+ SFG_Enumerator enumerator;
+
+ enumerator.found = GL_FALSE;
+ enumerator.data = NULL;
+
+ fgEnumWindows( fghcbCheckJoystickPolls, &enumerator );
+}
+
+/*
+ * Check the global timers
+ */
+static void fghCheckTimers( void )
+{
+ fg_time_t checkTime = fgElapsedTime( );
+
+ while( fgState.Timers.First )
+ {
+ SFG_Timer *timer = fgState.Timers.First;
+
+ if( timer->TriggerTime > checkTime )
+ break;
+
+ fgListRemove( &fgState.Timers, &timer->Node );
+ fgListAppend( &fgState.FreeTimers, &timer->Node );
+
+ timer->Callback( timer->ID );
+ }
+}
+
+
+/* Platform-dependent time in milliseconds, as an unsigned 64-bit integer.
+ * This doesn't overflow in any reasonable time, so no need to worry about
+ * that. The GLUT API return value will however overflow after 49.7 days,
+ * and on Windows we (currently) do not have access to a 64-bit timestamp,
+ * which means internal time will still get in trouble when running the
+ * application for more than 49.7 days.
+ * This value wraps every 49.7 days, but integer overflows cancel
+ * when subtracting an initial start time, unless the total time exceeds
+ * 32-bit, where the GLUT API return value is also overflowed.
+ */
+fg_time_t fgSystemTime(void)
+{
+ return fgPlatformSystemTime();
+}
+
+/*
+ * Elapsed Time
+ */
+fg_time_t fgElapsedTime( void )
+{
+ return fgSystemTime() - fgState.Time;
+}
+
+/*
+ * Error Messages.
+ */
+void fgError( const char *fmt, ... )
+{
+ va_list ap;
+
+ if (fgState.ErrorFunc) {
+
+ va_start( ap, fmt );
+
+ /* call user set error handler here */
+ fgState.ErrorFunc(fmt, ap);
+
+ va_end( ap );
+
+ } else {
+
+ va_start( ap, fmt );
+
+ fprintf( stderr, "freeglut ");
+ if( fgState.ProgramName )
+ fprintf( stderr, "(%s): ", fgState.ProgramName );
+ VFPRINTF( stderr, fmt, ap );
+ fprintf( stderr, "\n" );
+
+ va_end( ap );
+
+ if ( fgState.Initialised )
+ fgDeinitialize ();
+
+ exit( 1 );
+ }
+}
+
+void fgWarning( const char *fmt, ... )
+{
+ va_list ap;
+
+ if (fgState.WarningFunc) {
+
+ va_start( ap, fmt );
+
+ /* call user set warning handler here */
+ fgState.WarningFunc(fmt, ap);
+
+ va_end( ap );
+
+ } else {
+
+ va_start( ap, fmt );
+
+ fprintf( stderr, "freeglut ");
+ if( fgState.ProgramName )
+ fprintf( stderr, "(%s): ", fgState.ProgramName );
+ VFPRINTF( stderr, fmt, ap );
+ fprintf( stderr, "\n" );
+
+ va_end( ap );
+ }
+}
+
+
+/*
+ * 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. We have a short-circuit early
+ * return if we find any joystick handler registered.
+ *
+ * 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 fghCheckJoystickCallback( SFG_Window* w, SFG_Enumerator* e)
+{
+ if( FETCH_WCB( *w, Joystick ) )
+ {
+ e->found = GL_TRUE;
+ e->data = w;
+ }
+ fgEnumSubWindows( w, fghCheckJoystickCallback, e );
+}
+static int fghHaveJoystick( void )
+{
+ SFG_Enumerator enumerator;
+
+ enumerator.found = GL_FALSE;
+ enumerator.data = NULL;
+ fgEnumWindows( fghCheckJoystickCallback, &enumerator );
+ return !!enumerator.data;
+}
+static void fghHavePendingRedisplaysCallback( SFG_Window* w, SFG_Enumerator* e)
+{
+ if( w->State.Redisplay && w->State.Visible )
+ {
+ e->found = GL_TRUE;
+ e->data = w;
+ }
+ fgEnumSubWindows( w, fghHavePendingRedisplaysCallback, e );
+}
+static int fghHavePendingRedisplays (void)
+{
+ SFG_Enumerator enumerator;
+
+ enumerator.found = GL_FALSE;
+ enumerator.data = NULL;
+ fgEnumWindows( fghHavePendingRedisplaysCallback, &enumerator );
+ return !!enumerator.data;
+}
+/*
+ * Returns the number of GLUT ticks (milliseconds) till the next timer event.
+ */
+static fg_time_t fghNextTimer( void )
+{
+ fg_time_t currentTime = fgElapsedTime();
+ SFG_Timer *timer = fgState.Timers.First;
+
+ if( !timer )
+ return INT_MAX;
+
+ if( timer->TriggerTime < currentTime )
+ return 0;
+ else
+ return timer->TriggerTime - currentTime;
+}
+
+static void fghSleepForEvents( void )
+{
+ fg_time_t msec;
+
+ if( fgState.IdleCallback || fghHavePendingRedisplays( ) )
+ return;
+
+ msec = fghNextTimer( );
+ /* XXX Use GLUT timers for joysticks... */
+ /* XXX Dumb; forces granularity to .01sec */
+ if( fghHaveJoystick( ) && ( msec > 10 ) )
+ msec = 10;
+
+ fgPlatformSleepForEvents ( msec );
+}
+
+
+/* -- INTERFACE FUNCTIONS -------------------------------------------------- */
+
+/*
+ * Executes a single iteration in the freeglut processing loop.
+ */
+void FGAPIENTRY glutMainLoopEvent( void )
+{
+ fgPlatformProcessSingleEvent ();
+
+ if( fgState.Timers.First )
+ fghCheckTimers( );
+ fghCheckJoystickPolls( );
+ fghDisplayAll( );
+
+ fgCloseWindows( );
+}
+
+/*
+ * Enters the freeglut processing loop.
+ * Stays until the "ExecState" changes to "GLUT_EXEC_STATE_STOP".
+ */
+void FGAPIENTRY glutMainLoop( void )
+{
+ int action;
+
+ FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutMainLoop" );
+
+ fgPlatformMainLoopPreliminaryWork ();
+
+ 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( ! window )
+ fgState.ExecState = GLUT_EXEC_STATE_STOP;
+ else
+ {
+ if( fgState.IdleCallback )
+ {
+ if( fgStructure.CurrentWindow &&
+ fgStructure.CurrentWindow->IsMenu )
+ /* fail safe */
+ fgSetWindow( window );
+ fgState.IdleCallback( );
+ }
+
+ fghSleepForEvents( );
+ }
+ }
+
+ /*
+ * 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 );
+}
+
+/*
+ * Leaves the freeglut processing loop.
+ */
+void FGAPIENTRY glutLeaveMainLoop( void )
+{
+ FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutLeaveMainLoop" );
+ fgState.ExecState = GLUT_EXEC_STATE_STOP ;
+}
+
+
+
+/*** END OF FILE ***/
projects / freeglut / blobdiff