git.mutantstargoat.com Git - freeglut/blob - src/fg_main.c

   1 /*
   2  * fg_main.c
   3  *
   4  * The windows message processing methods.
   5  *
   6  * Copyright (c) 1999-2000 Pawel W. Olszta. All Rights Reserved.
   7  * Written by Pawel W. Olszta, <olszta@sourceforge.net>
   8  * Creation date: Fri Dec 3 1999
   9  *
  10  * Permission is hereby granted, free of charge, to any person obtaining a
  11  * copy of this software and associated documentation files (the "Software"),
  12  * to deal in the Software without restriction, including without limitation
  13  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  14  * and/or sell copies of the Software, and to permit persons to whom the
  15  * Software is furnished to do so, subject to the following conditions:
  16  *
  17  * The above copyright notice and this permission notice shall be included
  18  * in all copies or substantial portions of the Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  21  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  23  * PAWEL W. OLSZTA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
  24  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  25  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  26  */
  27
  28 #include <GL/freeglut.h>
  29 #include "fg_internal.h"
  30 #include <errno.h>
  31 #include <stdarg.h>
  32
  33 /*
  34  * Try to get the maximum value allowed for ints, falling back to the minimum
  35  * guaranteed by ISO C99 if there is no suitable header.
  36  */
  37 #ifdef HAVE_LIMITS_H
  38 #    include <limits.h>
  39 #endif
  40 #ifndef INT_MAX
  41 #    define INT_MAX 32767
  42 #endif
  43
  44 #ifndef MIN
  45 #    define MIN(a,b) (((a)<(b)) ? (a) : (b))
  46 #endif
  47
  48 extern void fgProcessWork   ( SFG_Window *window );
  49 extern fg_time_t fgPlatformSystemTime ( void );
  50 extern void fgPlatformSleepForEvents( fg_time_t msec );
  51 extern void fgPlatformProcessSingleEvent ( void );
  52 extern void fgPlatformMainLoopPreliminaryWork ( void );
  53
  54 extern void fgPlatformInitWork(SFG_Window* window);
  55 extern void fgPlatformPosResZordWork(SFG_Window* window, unsigned int workMask);
  56 extern void fgPlatformVisibilityWork(SFG_Window* window);
  57
  58
  59 /* -- PRIVATE FUNCTIONS ---------------------------------------------------- */
  60
  61 void fghOnReshapeNotify(SFG_Window *window, int width, int height, GLboolean forceNotify)
  62 {
  63     GLboolean notify = GL_FALSE;
  64
  65     if( width  != window->State.Width ||
  66         height != window->State.Height )
  67     {
  68         window->State.Width = width;
  69         window->State.Height = height;
  70
  71         notify = GL_TRUE;
  72     }
  73
  74     if (notify || forceNotify)
  75     {
  76         SFG_Window *saved_window = fgStructure.CurrentWindow;
  77
  78         INVOKE_WCB( *window, Reshape, ( width, height ) );
  79
  80         /*
  81          * Force a window redraw.  In Windows at least this is only a partial
  82          * solution:  if the window is increasing in size in either dimension,
  83          * the already-drawn part does not get drawn again and things look funny.
  84          * But without this we get this bad behaviour whenever we resize the
  85          * window.
  86          * DN: Hmm.. the above sounds like a concern only in single buffered mode...
  87          */
  88         window->State.WorkMask |= GLUT_DISPLAY_WORK;
  89         if( window->IsMenu )
  90             fgSetWindow( saved_window );
  91     }
  92 }
  93
  94 void fghOnPositionNotify(SFG_Window *window, int x, int y, GLboolean forceNotify)
  95 {
  96     GLboolean notify = GL_FALSE;
  97
  98     if( x  != window->State.Xpos ||
  99         y != window->State.Ypos )
 100     {
 101         window->State.Xpos = x;
 102         window->State.Ypos = y;
 103
 104         notify = GL_TRUE;
 105     }
 106
 107     if (notify || forceNotify)
 108     {
 109         SFG_Window *saved_window = fgStructure.CurrentWindow;
 110         INVOKE_WCB( *window, Position, ( x, y ) );
 111         fgSetWindow( saved_window );
 112     }
 113 }
 114
 115 /*
 116  * Calls a window's redraw method. This is used when
 117  * a redraw is forced by the incoming window messages,
 118  * or if a redisplay is otherwise pending.
 119  * this is lean and mean without checks as it is
 120  * currently only called from fghcbDisplayWindow which
 121  * only calls this if the window is visible and needs
 122  * a redisplay.
 123  * Note that the fgSetWindow call on Windows makes the
 124  * right device context current on windows, allowing
 125  * direct drawing without BeginPaint/EndPaint in the
 126  * WM_PAINT handler.
 127  */
 128 void fghRedrawWindow ( SFG_Window *window )
 129 {
 130     SFG_Window *current_window = fgStructure.CurrentWindow;
 131
 132     fgSetWindow( window );
 133     INVOKE_WCB( *window, Display, ( ) );
 134
 135     fgSetWindow( current_window );
 136 }
 137
 138 void fghRedrawWindowAndChildren ( SFG_Window *window )
 139 {
 140     SFG_Window* child;
 141
 142     fghRedrawWindow(window);
 143
 144     for( child = ( SFG_Window * )window->Children.First;
 145          child;
 146          child = ( SFG_Window * )child->Node.Next )
 147     {
 148         fghRedrawWindowAndChildren(child);
 149     }
 150 }
 151
 152
 153 static void fghcbProcessWork( SFG_Window *window,
 154                               SFG_Enumerator *enumerator )
 155 {
 156     if( window->State.WorkMask )
 157         fgProcessWork ( window );
 158
 159     fgEnumSubWindows( window, fghcbProcessWork, enumerator );
 160 }
 161
 162 /*
 163  * Make all windows process their work list
 164  */
 165 static void fghProcessWork( void )
 166 {
 167     SFG_Enumerator enumerator;
 168
 169     enumerator.found = GL_FALSE;
 170     enumerator.data  =  NULL;
 171
 172     fgEnumWindows( fghcbProcessWork, &enumerator );
 173 }
 174
 175 /*
 176  * Window enumerator callback to check for the joystick polling code
 177  */
 178 static void fghcbCheckJoystickPolls( SFG_Window *window,
 179                                      SFG_Enumerator *enumerator )
 180 {
 181     fg_time_t checkTime;
 182
 183     if (window->State.JoystickPollRate > 0 && FETCH_WCB( *window, Joystick ))
 184     {
 185         /* This window has a joystick to be polled (if pollrate <= 0, user needs to poll manually with glutForceJoystickFunc */
 186         checkTime= fgElapsedTime( );
 187
 188         if( window->State.JoystickLastPoll + window->State.JoystickPollRate <=
 189             checkTime )
 190         {
 191 #if !defined(_WIN32_WCE)
 192             fgJoystickPollWindow( window );
 193 #endif /* !defined(_WIN32_WCE) */
 194             window->State.JoystickLastPoll = checkTime;
 195         }
 196     }
 197
 198     fgEnumSubWindows( window, fghcbCheckJoystickPolls, enumerator );
 199 }
 200
 201 /*
 202  * Check all windows for joystick polling
 203  *
 204  * The real way to do this is to make use of the glutTimer() API
 205  * to more cleanly re-implement the joystick API.  Then, this code
 206  * and all other "joystick timer" code can be yanked.
 207  */
 208 static void fghCheckJoystickPolls( void )
 209 {
 210     SFG_Enumerator enumerator;
 211
 212     enumerator.found = GL_FALSE;
 213     enumerator.data  =  NULL;
 214
 215     fgEnumWindows( fghcbCheckJoystickPolls, &enumerator );
 216 }
 217
 218 /*
 219  * Check the global timers
 220  */
 221 static void fghCheckTimers( void )
 222 {
 223     fg_time_t checkTime = fgElapsedTime( );
 224
 225     while( fgState.Timers.First )
 226     {
 227         SFG_Timer *timer = fgState.Timers.First;
 228
 229         if( timer->TriggerTime > checkTime )
 230             /* Timers are sorted by triggerTime */
 231             break;
 232
 233         fgListRemove( &fgState.Timers, &timer->Node );
 234         fgListAppend( &fgState.FreeTimers, &timer->Node );
 235
 236         timer->Callback( timer->ID, timer->CallbackData );
 237     }
 238 }
 239
 240
 241 /* Platform-dependent time in milliseconds, as an unsigned 64-bit integer.
 242  * This doesn't overflow in any reasonable time, so no need to worry about
 243  * that. The GLUT API return value will however overflow after 49.7 days,
 244  * which means you will still get in trouble when running the
 245  * application for more than 49.7 days.
 246  */
 247 fg_time_t fgSystemTime(void)
 248 {
 249         return fgPlatformSystemTime();
 250 }
 251
 252 /*
 253  * Elapsed Time
 254  */
 255 fg_time_t fgElapsedTime( void )
 256 {
 257     return fgSystemTime() - fgState.Time;
 258 }
 259
 260 /*
 261  * Error Messages.
 262  */
 263 void fgError( const char *fmt, ... )
 264 {
 265     va_list ap;
 266
 267     if (fgState.ErrorFunc) {
 268
 269         va_start( ap, fmt );
 270
 271         /* call user set error handler here */
 272         fgState.ErrorFunc(fmt, ap, fgState.ErrorFuncData);
 273
 274         va_end( ap );
 275
 276     } else {
 277 #ifdef FREEGLUT_PRINT_ERRORS
 278         va_start( ap, fmt );
 279
 280         fprintf( stderr, "freeglut ");
 281         if( fgState.ProgramName )
 282             fprintf( stderr, "(%s): ", fgState.ProgramName );
 283         vfprintf( stderr, fmt, ap );
 284         fprintf( stderr, "\n" );
 285
 286         va_end( ap );
 287 #endif
 288
 289         if ( fgState.Initialised )
 290             fgDeinitialize ();
 291
 292         exit( 1 );
 293     }
 294 }
 295
 296 void fgWarning( const char *fmt, ... )
 297 {
 298     va_list ap;
 299
 300     if (fgState.WarningFunc) {
 301
 302         va_start( ap, fmt );
 303
 304         /* call user set warning handler here */
 305         fgState.WarningFunc(fmt, ap, fgState.WarningFuncData);
 306
 307         va_end( ap );
 308
 309     } else {
 310 #ifdef FREEGLUT_PRINT_WARNINGS
 311         va_start( ap, fmt );
 312
 313         fprintf( stderr, "freeglut ");
 314         if( fgState.ProgramName )
 315             fprintf( stderr, "(%s): ", fgState.ProgramName );
 316         vfprintf( stderr, fmt, ap );
 317         fprintf( stderr, "\n" );
 318
 319         va_end( ap );
 320 #endif
 321     }
 322 }
 323
 324
 325 /*
 326  * Indicates whether work is pending for ANY window.
 327  *
 328  * The current mechanism is to walk all of the windows and ask if
 329  * work is pending. We have a short-circuit early return if we find any.
 330  */
 331 static void fghHavePendingWorkCallback( SFG_Window* w, SFG_Enumerator* e)
 332 {
 333     if( w->State.WorkMask )
 334     {
 335         e->found = GL_TRUE;
 336         e->data = w;
 337         return;
 338     }
 339     fgEnumSubWindows( w, fghHavePendingWorkCallback, e );
 340 }
 341 static int fghHavePendingWork (void)
 342 {
 343     SFG_Enumerator enumerator;
 344
 345     enumerator.found = GL_FALSE;
 346     enumerator.data = NULL;
 347     fgEnumWindows( fghHavePendingWorkCallback, &enumerator );
 348     return !!enumerator.data;
 349 }
 350
 351 /*
 352  * Returns the number of GLUT ticks (milliseconds) till the next timer event.
 353  */
 354 static fg_time_t fghNextTimer( void )
 355 {
 356     fg_time_t currentTime;
 357     SFG_Timer *timer = fgState.Timers.First;    /* timers are sorted by trigger time, so only have to check the first */
 358
 359     if( !timer )
 360         return INT_MAX;
 361
 362     currentTime = fgElapsedTime();
 363     if( timer->TriggerTime < currentTime )
 364         return 0;
 365     else
 366         return timer->TriggerTime - currentTime;
 367 }
 368
 369 static void fghSleepForEvents( void )
 370 {
 371     fg_time_t msec;
 372
 373     if( fghHavePendingWork( ) )
 374         return;
 375
 376     msec = fghNextTimer( );
 377     /* XXX Should use GLUT timers for joysticks... */
 378     /* XXX Dumb; forces granularity to .01sec */
 379     if( fgState.NumActiveJoysticks>0 && ( msec > 10 ) )
 380         msec = 10;
 381
 382     fgPlatformSleepForEvents ( msec );
 383 }
 384
 385
 386 /* Step through the work list */
 387 void fgProcessWork(SFG_Window *window)
 388 {
 389     unsigned int workMask = window->State.WorkMask;
 390     /* Now clear it so that any callback generated by the actions below can set work again */
 391     window->State.WorkMask = 0;
 392
 393     if (workMask&~GLUT_DISPLAY_WORK)    /* Display work is the common case, skip all the below at once */
 394     {
 395         if (workMask & GLUT_INIT_WORK)
 396         {
 397             /* This is before the first display callback: if needed for the platform,
 398              * call a few callbacks to inform user of window size, position, etc
 399              */
 400             fgPlatformInitWork(window);
 401
 402             /* Call init context callback */
 403             INVOKE_WCB( *window, InitContext, ( ) );
 404
 405             /* Lastly, check if we have a display callback, error out if not
 406              * This is the right place to do it, as the redisplay will be
 407              * next right after we exit this function, so there is no more
 408              * opportunity for the user to register a callback for this window.
 409              */
 410             if (!FETCH_WCB(*window, Display))
 411                 fgError ( "ERROR:  No display callback registered for window %d\n", window->ID );
 412         }
 413
 414         /* On windows we can position, resize and change z order at the same time */
 415         if (workMask & (GLUT_POSITION_WORK|GLUT_SIZE_WORK|GLUT_ZORDER_WORK|GLUT_FULL_SCREEN_WORK))
 416         {
 417             fgPlatformPosResZordWork(window,workMask);
 418         }
 419
 420         if (workMask & GLUT_VISIBILITY_WORK)
 421         {
 422             fgPlatformVisibilityWork(window);
 423         }
 424     }
 425
 426     /* check window state's workmask as well as some of the above callbacks might have generated redisplay requests. We can deal with those right now instead of wait for the next mainloop iteration. */
 427     if (workMask & GLUT_DISPLAY_WORK || window->State.WorkMask & GLUT_DISPLAY_WORK)
 428     {
 429         if( window->State.Visible )
 430         {
 431             /* Strip out display work from the work list */
 432             /* NB: do this before the display callback is called as user might call postredisplay in his display callback */
 433             window->State.WorkMask &= ~GLUT_DISPLAY_WORK;
 434
 435             fghRedrawWindow ( window );
 436         }
 437     }
 438 }
 439
 440
 441 /* -- INTERFACE FUNCTIONS -------------------------------------------------- */
 442
 443 /*
 444  * Executes a single iteration in the freeglut processing loop.
 445  */
 446 void FGAPIENTRY glutMainLoopEvent( void )
 447 {
 448     /* Process input */
 449         fgPlatformProcessSingleEvent ();
 450
 451     if( fgState.Timers.First )
 452         fghCheckTimers( );
 453     if (fgState.NumActiveJoysticks>0)   /* If zero, don't poll joysticks */
 454         fghCheckJoystickPolls( );
 455
 456     /* Perform work on the window (position, reshape, display, etc) */
 457     fghProcessWork( );
 458
 459     /* Check OpenGL error state if requested.
 460      * Don't call if no more open windows (can happen if user closes window from
 461      * title bar), would lead to infinite error loop in glutReportErrors
 462      */
 463     if (fgState.GLDebugSwitch && fgStructure.CurrentWindow)
 464         glutReportErrors( );
 465
 466     fgCloseWindows( );
 467 }
 468
 469 /*
 470  * Enters the freeglut processing loop.
 471  * Stays until the "ExecState" changes to "GLUT_EXEC_STATE_STOP".
 472  */
 473 void FGAPIENTRY glutMainLoop( void )
 474 {
 475     int action;
 476
 477     FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutMainLoop" );
 478
 479     if (!fgStructure.Windows.First)
 480         fgError(" ERROR:  glutMainLoop called with no windows created.");
 481
 482     fgPlatformMainLoopPreliminaryWork ();
 483
 484     fgState.ExecState = GLUT_EXEC_STATE_RUNNING ;
 485     for(;;)
 486     {
 487         SFG_Window *window;
 488
 489         glutMainLoopEvent( );
 490         if( fgState.ExecState != GLUT_EXEC_STATE_RUNNING )
 491             break;
 492         /*
 493          * Step through the list of windows, seeing if there are any
 494          * that are not menus
 495          */
 496         for( window = ( SFG_Window * )fgStructure.Windows.First;
 497              window;
 498              window = ( SFG_Window * )window->Node.Next )
 499             if ( ! ( window->IsMenu ) )
 500                 break;
 501
 502         if( ! window )
 503             fgState.ExecState = GLUT_EXEC_STATE_STOP;
 504         else
 505         {
 506             if( fgState.IdleCallback )
 507             {
 508                 if( fgStructure.CurrentWindow &&
 509                     fgStructure.CurrentWindow->IsMenu )
 510                     /* fail safe */
 511                     fgSetWindow( window );
 512                 fgState.IdleCallback( fgState.IdleCallbackData );
 513             }
 514             else
 515                 fghSleepForEvents( );
 516         }
 517     }
 518
 519     /*
 520      * When this loop terminates, destroy the display, state and structure
 521      * of a freeglut session, so that another glutInit() call can happen
 522      *
 523      * Save the "ActionOnWindowClose" because "fgDeinitialize" resets it.
 524      */
 525     action = fgState.ActionOnWindowClose;
 526     fgDeinitialize( );
 527     if( action == GLUT_ACTION_EXIT )
 528         exit( 0 );
 529 }
 530
 531 /*
 532  * Leaves the freeglut processing loop.
 533  */
 534 void FGAPIENTRY glutLeaveMainLoop( void )
 535 {
 536     FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutLeaveMainLoop" );
 537     fgState.ExecState = GLUT_EXEC_STATE_STOP ;
 538 }
 539
 540
 541
 542 /*** END OF FILE ***/