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

   1 /*
   2  * freeglut_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 #ifdef HAVE_CONFIG_H
  29 #include "config.h"
  30 #endif
  31
  32 #include "../include/GL/freeglut.h"
  33 #include "freeglut_internal.h"
  34
  35 #include <limits.h>
  36 #if TARGET_HOST_UNIX_X11
  37 #include <sys/types.h>
  38 #include <sys/time.h>
  39 #include <unistd.h>
  40 #include <errno.h>
  41 #include <sys/stat.h>
  42 #elif TARGET_HOST_WIN32
  43 #endif
  44
  45 #ifndef MAX
  46 #define MAX(a,b) (((a)>(b)) ? (a) : (b))
  47 #endif
  48
  49 #ifndef MIN
  50 #define MIN(a,b) (((a)<(b)) ? (a) : (b))
  51 #endif
  52
  53
  54 /*
  55  * TODO BEFORE THE STABLE RELEASE:
  56  *
  57  * There are some issues concerning window redrawing under X11, and maybe
  58  * some events are not handled. The Win32 version lacks some more features,
  59  * but seems acceptable for not demanding purposes.
  60  *
  61  * Need to investigate why the X11 version breaks out with an error when
  62  * closing a window (using the window manager, not glutDestroyWindow)...
  63  */
  64
  65 /* -- PRIVATE FUNCTIONS ---------------------------------------------------- */
  66
  67 /*
  68  * Handle a window configuration change. When no reshape
  69  * callback is hooked, the viewport size is updated to
  70  * match the new window size.
  71  */
  72 static void fghReshapeWindowByHandle ( SFG_WindowHandleType handle,
  73                                        int width, int height )
  74 {
  75     SFG_Window *current_window = fgStructure.Window;
  76
  77     SFG_Window* window = fgWindowByHandle( handle );
  78     freeglut_return_if_fail( window != NULL );
  79
  80
  81 #if TARGET_HOST_UNIX_X11
  82
  83     XResizeWindow( fgDisplay.Display, window->Window.Handle,
  84                    width, height );
  85     XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */
  86
  87 #elif TARGET_HOST_WIN32
  88
  89     {
  90         RECT winRect;
  91         int x, y;
  92
  93         GetWindowRect( window->Window.Handle, &winRect );
  94         x = winRect.left;
  95         y = winRect.top;
  96
  97         if ( window->Parent == NULL )
  98         {
  99             /*
 100              * Adjust the size of the window to allow for the size of the
 101              * frame, if we are not a menu
 102              */
 103             if ( ! window->IsMenu )
 104             {
 105                 width += GetSystemMetrics( SM_CXSIZEFRAME ) * 2;
 106                 height += GetSystemMetrics( SM_CYSIZEFRAME ) * 2 +
 107                     GetSystemMetrics( SM_CYCAPTION );
 108             }
 109         }
 110         else
 111         {
 112             GetWindowRect( window->Parent->Window.Handle,
 113                            &winRect );
 114             x -= winRect.left + GetSystemMetrics( SM_CXSIZEFRAME );
 115             y -= winRect.top + GetSystemMetrics( SM_CYSIZEFRAME ) +
 116                 GetSystemMetrics( SM_CYCAPTION );
 117         }
 118
 119         MoveWindow(
 120             window->Window.Handle,
 121             x,
 122             y,
 123             width,
 124             height,
 125             TRUE
 126         );
 127     }
 128
 129 #endif
 130
 131     if( !( FETCH_WCB( *window, Reshape ) ) )
 132     {
 133         fgSetWindow( window );
 134         glViewport( 0, 0, width, height );
 135     }
 136     else
 137         INVOKE_WCB( *window, Reshape, ( width, height ) );
 138
 139     /*
 140      * Force a window redraw.  In Windows at least this is only a partial
 141      * solution:  if the window is increasing in size in either dimension,
 142      * the already-drawn part does not get drawn again and things look funny.
 143      * But without this we get this bad behaviour whenever we resize the
 144      * window.
 145      */
 146     window->State.Redisplay = GL_TRUE;
 147
 148     if( window->IsMenu )
 149         fgSetWindow( current_window );
 150 }
 151
 152 /*
 153  * Calls a window's redraw method. This is used when
 154  * a redraw is forced by the incoming window messages.
 155  */
 156 static void fghRedrawWindowByHandle ( SFG_WindowHandleType handle )
 157 {
 158     SFG_Window* window = fgWindowByHandle( handle );
 159     freeglut_return_if_fail( window );
 160     freeglut_return_if_fail( FETCH_WCB ( *window, Display ) );
 161
 162     window->State.Redisplay = GL_FALSE;
 163
 164     freeglut_return_if_fail( window->State.Visible );
 165
 166     if( window->State.NeedToResize )
 167     {
 168         SFG_Window *current_window = fgStructure.Window;
 169
 170         fgSetWindow( window );
 171
 172         fghReshapeWindowByHandle(
 173             window->Window.Handle,
 174             window->State.Width,
 175             window->State.Height
 176         );
 177
 178         window->State.NeedToResize = GL_FALSE;
 179         fgSetWindow ( current_window );
 180     }
 181
 182     INVOKE_WCB( *window, Display, ( ) );
 183 }
 184
 185 /*
 186  * A static helper function to execute display callback for a window
 187  */
 188 static void fghcbDisplayWindow( SFG_Window *window,
 189                                 SFG_Enumerator *enumerator )
 190 {
 191     if( window->State.Redisplay &&
 192         window->State.Visible )
 193     {
 194         if( window->State.NeedToResize )
 195         {
 196             SFG_Window *current_window = fgStructure.Window;
 197
 198             fgSetWindow( window );
 199
 200             fghReshapeWindowByHandle(
 201                 window->Window.Handle,
 202                 window->State.Width,
 203                 window->State.Height
 204             );
 205
 206             window->State.NeedToResize = GL_FALSE;
 207             fgSetWindow ( current_window );
 208         }
 209
 210         window->State.Redisplay = GL_FALSE;
 211
 212 #if TARGET_HOST_UNIX_X11
 213         {
 214             SFG_Window *current_window = fgStructure.Window;
 215
 216             INVOKE_WCB( *window, Display, ( ) );
 217             fgSetWindow( current_window );
 218         }
 219 #elif TARGET_HOST_WIN32
 220         RedrawWindow(
 221             window->Window.Handle, NULL, NULL,
 222             RDW_NOERASE | RDW_INTERNALPAINT | RDW_INVALIDATE | RDW_UPDATENOW
 223         );
 224 #endif
 225     }
 226
 227     fgEnumSubWindows( window, fghcbDisplayWindow, enumerator );
 228 }
 229
 230 /*
 231  * Make all windows perform a display call
 232  */
 233 static void fghDisplayAll( void )
 234 {
 235     SFG_Enumerator enumerator;
 236
 237     enumerator.found = GL_FALSE;
 238     enumerator.data  =  NULL;
 239
 240     fgEnumWindows( fghcbDisplayWindow, &enumerator );
 241 }
 242
 243 /*
 244  * Window enumerator callback to check for the joystick polling code
 245  */
 246 static void fghcbCheckJoystickPolls( SFG_Window *window,
 247                                      SFG_Enumerator *enumerator )
 248 {
 249     long int checkTime = fgElapsedTime( );
 250
 251     if( window->State.JoystickLastPoll + window->State.JoystickPollRate <=
 252         checkTime )
 253     {
 254         fgJoystickPollWindow( window );
 255         window->State.JoystickLastPoll = checkTime;
 256     }
 257
 258     fgEnumSubWindows( window, fghcbCheckJoystickPolls, enumerator );
 259 }
 260
 261 /*
 262  * Check all windows for joystick polling
 263  */
 264 static void fghCheckJoystickPolls( void )
 265 {
 266     SFG_Enumerator enumerator;
 267
 268     enumerator.found = GL_FALSE;
 269     enumerator.data  =  NULL;
 270
 271     fgEnumWindows( fghcbCheckJoystickPolls, &enumerator );
 272 }
 273
 274 /*
 275  * Check the global timers
 276  */
 277 static void fghCheckTimers( void )
 278 {
 279     long checkTime = fgElapsedTime( );
 280     SFG_Timer *timer;
 281
 282     while( timer = fgState.Timers.First )
 283     {
 284         if( timer->TriggerTime > checkTime )
 285             break;
 286
 287         fgListRemove( &fgState.Timers, &timer->Node );
 288         fgListAppend( &fgState.FreeTimers, &timer->Node );
 289
 290         timer->Callback( timer->ID );
 291     }
 292 }
 293
 294 /*
 295  * Elapsed Time
 296  */
 297 long fgElapsedTime( void )
 298 {
 299     if ( fgState.Time.Set )
 300     {
 301 #if TARGET_HOST_UNIX_X11
 302         struct timeval now;
 303         long elapsed;
 304
 305         gettimeofday( &now, NULL );
 306
 307         elapsed = (now.tv_usec - fgState.Time.Value.tv_usec) / 1000;
 308         elapsed += (now.tv_sec - fgState.Time.Value.tv_sec) * 1000;
 309
 310         return elapsed;
 311 #elif TARGET_HOST_WIN32
 312         return timeGetTime() - fgState.Time.Value;
 313 #endif
 314     }
 315     else
 316     {
 317 #if TARGET_HOST_UNIX_X11
 318         gettimeofday( &fgState.Time.Value, NULL );
 319 #elif TARGET_HOST_WIN32
 320         fgState.Time.Value = timeGetTime ();
 321 #endif
 322         fgState.Time.Set = GL_TRUE ;
 323
 324         return 0 ;
 325     }
 326 }
 327
 328 /*
 329  * Error Messages.
 330  */
 331 void fgError( const char *fmt, ... )
 332 {
 333     va_list ap;
 334
 335     va_start( ap, fmt );
 336
 337     fprintf( stderr, "freeglut ");
 338     if( fgState.ProgramName )
 339         fprintf (stderr, "(%s): ", fgState.ProgramName);
 340     vfprintf( stderr, fmt, ap );
 341     fprintf( stderr, "\n" );
 342
 343     va_end( ap );
 344
 345     if ( fgState.Initialised )
 346         fgDeinitialize ();
 347
 348     exit( 1 );
 349 }
 350
 351 void fgWarning( const char *fmt, ... )
 352 {
 353     va_list ap;
 354
 355     va_start( ap, fmt );
 356
 357     fprintf( stderr, "freeglut ");
 358     if( fgState.ProgramName )
 359         fprintf( stderr, "(%s): ", fgState.ProgramName );
 360     vfprintf( stderr, fmt, ap );
 361     fprintf( stderr, "\n" );
 362
 363     va_end( ap );
 364 }
 365
 366 /*
 367  * Indicates whether Joystick events are being used by ANY window.
 368  *
 369  * The current mechanism is to walk all of the windows and ask if
 370  * there is a joystick callback.  Certainly in some cases, maybe
 371  * in all cases, the joystick is attached to the system and accessed
 372  * from ONE point by GLUT/freeglut, so this is not the right way,
 373  * in general, to do this.  However, the Joystick code is segregated
 374  * in its own little world, so we can't access the information that
 375  * we need in order to do that nicely.
 376  *
 377  * Some alternatives:
 378  *  * Store Joystick data into freeglut global state.
 379  *  * Provide NON-static functions or data from Joystick *.c file.
 380  *
 381  * Basically, the RIGHT way to do this requires knowing something
 382  * about the Joystick.  Right now, the Joystick code is behind
 383  * an opaque wall.
 384  *
 385  */
 386 static void fgCheckJoystickCallback( SFG_Window* w, SFG_Enumerator* e)
 387 {
 388     if( FETCH_WCB( *w, Joystick ) )
 389     {
 390         e->found = GL_TRUE;
 391         e->data = w;
 392     }
 393     fgEnumSubWindows( w, fgCheckJoystickCallback, e );
 394 }
 395 static int fgHaveJoystick( void )
 396 {
 397     SFG_Enumerator enumerator;
 398     enumerator.found = GL_FALSE;
 399     enumerator.data = NULL;
 400     fgEnumWindows( fgCheckJoystickCallback, &enumerator );
 401     return !!enumerator.data;
 402 }
 403 static void fgHavePendingRedisplaysCallback( SFG_Window* w, SFG_Enumerator* e)
 404 {
 405     if( w->State.Redisplay )
 406     {
 407         e->found = GL_TRUE;
 408         e->data = w;
 409     }
 410     fgEnumSubWindows( w, fgHavePendingRedisplaysCallback, e );
 411 }
 412 static int fgHavePendingRedisplays (void)
 413 {
 414     SFG_Enumerator enumerator;
 415     enumerator.found = GL_FALSE;
 416     enumerator.data = NULL;
 417     fgEnumWindows( fgHavePendingRedisplaysCallback, &enumerator );
 418     return !!enumerator.data;
 419 }
 420 /*
 421  * Returns the number of GLUT ticks (milliseconds) till the next timer event.
 422  */
 423 static long fgNextTimer( void )
 424 {
 425     long ret = INT_MAX;
 426     SFG_Timer *timer;
 427
 428     if( (timer = fgState.Timers.First) )
 429         ret = timer->TriggerTime - fgElapsedTime();
 430
 431     return ret;
 432 }
 433 /*
 434  * Does the magic required to relinquish the CPU until something interesting
 435  * happens.
 436  */
 437 static void fgSleepForEvents( void )
 438 {
 439 #if TARGET_HOST_UNIX_X11
 440     fd_set fdset;
 441     int err;
 442     int socket;
 443     struct timeval wait;
 444     long msec;
 445
 446     if( fgState.IdleCallback || fgHavePendingRedisplays( ) )
 447         return;
 448     socket = ConnectionNumber( fgDisplay.Display );
 449     FD_ZERO( &fdset );
 450     FD_SET( socket, &fdset );
 451
 452     msec = fgNextTimer( );
 453     if( fgHaveJoystick( ) )
 454         msec = MIN( msec, 10 );
 455
 456     wait.tv_sec = msec / 1000;
 457     wait.tv_usec = (msec % 1000) * 1000;
 458     err = select( socket+1, &fdset, NULL, NULL, &wait );
 459
 460     if( -1 == err )
 461         fgWarning ( "freeglut select() error: %d\n", errno );
 462
 463 #elif TARGET_HOST_WIN32
 464 #endif
 465 }
 466
 467 #if TARGET_HOST_UNIX_X11
 468 /*
 469  * Returns GLUT modifier mask for an XEvent.
 470  */
 471 int fgGetXModifiers( XEvent *event )
 472 {
 473     int ret = 0;
 474
 475     if( event->xkey.state & ( ShiftMask | LockMask ) )
 476         ret |= GLUT_ACTIVE_SHIFT;
 477     if( event->xkey.state & ControlMask )
 478         ret |= GLUT_ACTIVE_CTRL;
 479     if( event->xkey.state & Mod1Mask )
 480         ret |= GLUT_ACTIVE_ALT;
 481
 482     return ret;
 483 }
 484 #endif
 485
 486
 487 /* -- INTERFACE FUNCTIONS -------------------------------------------------- */
 488
 489 /*
 490  * Executes a single iteration in the freeglut processing loop.
 491  */
 492 void FGAPIENTRY glutMainLoopEvent( void )
 493 {
 494 #if TARGET_HOST_UNIX_X11
 495     SFG_Window* window;
 496     XEvent event;
 497
 498     /*
 499      * This code was repeated constantly, so here it goes into a definition:
 500      */
 501 #define GETWINDOW(a)                             \
 502     window = fgWindowByHandle( event.a.window ); \
 503     if( window == NULL )                         \
 504         break;
 505
 506 #define GETMOUSE(a)                              \
 507     window->State.MouseX = event.a.x;            \
 508     window->State.MouseY = event.a.y;
 509
 510     freeglut_assert_ready;
 511
 512     while( XPending( fgDisplay.Display ) )
 513     {
 514         XNextEvent( fgDisplay.Display, &event );
 515
 516         switch( event.type )
 517         {
 518         case ClientMessage:
 519             /*
 520              * Destroy the window when the WM_DELETE_WINDOW message arrives
 521              */
 522             if( (Atom) event.xclient.data.l[ 0 ] == fgDisplay.DeleteWindow )
 523             {
 524                 GETWINDOW( xclient );
 525
 526                 fgDestroyWindow ( window );
 527
 528                 if( fgState.ActionOnWindowClose == GLUT_ACTION_EXIT )
 529                 {
 530                     fgDeinitialize( );
 531                     exit( 0 );
 532                 }
 533
 534                 fgState.ExecState = GLUT_EXEC_STATE_STOP;
 535                 return;
 536             }
 537             break;
 538
 539             /*
 540              * CreateNotify causes a configure-event so that sub-windows are
 541              * handled compatibly with GLUT.  Otherwise, your sub-windows
 542              * (in freeglut only) will not get an initial reshape event,
 543              * which can break things.
 544              *
 545              * XXX NOTE that it is possible that you will more than one Reshape
 546              * XXX event for your top-level window, but something like this
 547              * XXX appears to be required for compatbility.
 548              *
 549              * GLUT presumably does this because it generally tries to treat
 550              * sub-windows the same as windows.
 551              */
 552         case CreateNotify:
 553         case ConfigureNotify:
 554             GETWINDOW( xconfigure );
 555             window->State.NeedToResize = GL_TRUE ;
 556             window->State.Width  = event.xconfigure.width ;
 557             window->State.Height = event.xconfigure.height;
 558             break;
 559
 560         case DestroyNotify:
 561             /*
 562              * This is sent to confirm the XDestroyWindow call.
 563              * XXX WHY is this commented out?  Should we re-enable it?
 564              */
 565             /* fgAddToWindowDestroyList ( window ); */
 566             break;
 567
 568         case Expose:
 569             /*
 570              * We are too dumb to process partial exposes...
 571              * XXX Well, we could do it.  However, it seems to only
 572              * XXX be potentially useful for single-buffered (since
 573              * XXX double-buffered does not respect viewport when we
 574              * XXX do a buffer-swap).
 575              */
 576             if( event.xexpose.count == 0 )
 577                 fghRedrawWindowByHandle( event.xexpose.window );
 578             break;
 579
 580         case MapNotify:
 581         case UnmapNotify:
 582             /*
 583              * If we never do anything with this, can we just not ask to
 584              * get these messages?
 585              */
 586             break;
 587
 588         case MappingNotify:
 589             /*
 590              * Have the client's keyboard knowledge updated (xlib.ps,
 591              * page 206, says that's a good thing to do)
 592              */
 593             XRefreshKeyboardMapping( (XMappingEvent *) &event );
 594             break;
 595
 596         case VisibilityNotify:
 597         {
 598             GETWINDOW( xvisibility );
 599             if( ! FETCH_WCB( *window, WindowStatus ) )
 600                 break;
 601             fgSetWindow( window );
 602
 603             /*
 604              * Sending this event, the X server can notify us that the window
 605              * has just acquired one of the three possible visibility states:
 606              * VisibilityUnobscured, VisibilityPartiallyObscured or
 607              * VisibilityFullyObscured
 608              */
 609             switch( event.xvisibility.state )
 610             {
 611             case VisibilityUnobscured:
 612                 INVOKE_WCB( *window, WindowStatus, ( GLUT_FULLY_RETAINED ) );
 613                 window->State.Visible = GL_TRUE;
 614                 break;
 615
 616             case VisibilityPartiallyObscured:
 617                 INVOKE_WCB( *window, WindowStatus,
 618                             ( GLUT_PARTIALLY_RETAINED ) );
 619                 window->State.Visible = GL_TRUE;
 620                 break;
 621
 622             case VisibilityFullyObscured:
 623                 INVOKE_WCB( *window, WindowStatus, ( GLUT_FULLY_COVERED ) );
 624                 window->State.Visible = GL_FALSE;
 625                 break;
 626
 627             default:
 628                 fgWarning( "Uknown X visibility state: %d",
 629                            event.xvisibility.state );
 630                 break;
 631             }
 632         }
 633         break;
 634
 635         case EnterNotify:
 636         case LeaveNotify:
 637             GETWINDOW( xcrossing );
 638             GETMOUSE( xcrossing );
 639             INVOKE_WCB( *window, Entry, ( ( EnterNotify == event.type ) ?
 640                                           GLUT_ENTERED :
 641                                           GLUT_LEFT ) );
 642             break;
 643
 644         case MotionNotify:
 645         {
 646             GETWINDOW( xmotion );
 647             GETMOUSE( xmotion );
 648
 649             if( window->ActiveMenu )
 650             {
 651                 if( window == window->ActiveMenu->ParentWindow )
 652                 {
 653                     window->ActiveMenu->Window->State.MouseX =
 654                         event.xmotion.x_root - window->ActiveMenu->X;
 655                     window->ActiveMenu->Window->State.MouseY =
 656                         event.xmotion.y_root - window->ActiveMenu->Y;
 657                 }
 658                 window->ActiveMenu->Window->State.Redisplay = GL_TRUE ;
 659                 fgSetWindow( window->ActiveMenu->ParentWindow );
 660
 661                 break;
 662             }
 663
 664             /*
 665              * XXX For more than 5 buttons, just check {event.xmotion.state},
 666              * XXX rather than a host of bit-masks?
 667              */
 668 #define BUTTON_MASK \
 669   ( Button1Mask | Button2Mask | Button3Mask | Button4Mask | Button5Mask )
 670             if ( event.xmotion.state & BUTTON_MASK )
 671                 INVOKE_WCB( *window, Motion, ( event.xmotion.x,
 672                                                event.xmotion.y ) );
 673             else
 674                 INVOKE_WCB( *window, Passive, ( event.xmotion.x,
 675                                                 event.xmotion.y ) );
 676         }
 677         break;
 678
 679         case ButtonRelease:
 680         case ButtonPress:
 681         {
 682             GLboolean pressed = GL_TRUE;
 683             int button;
 684
 685             if( event.type == ButtonRelease )
 686                 pressed = GL_FALSE ;
 687
 688             /*
 689              * A mouse button has been pressed or released. Traditionally,
 690              * break if the window was found within the freeglut structures.
 691              */
 692             GETWINDOW( xbutton );
 693             GETMOUSE( xbutton );
 694
 695             /*
 696              * An X button (at least in XFree86) is numbered from 1.
 697              * A GLUT button is numbered from 0.
 698              * Old GLUT passed through buttons other than just the first
 699              * three, though it only gave symbolic names and official
 700              * support to the first three.
 701              */
 702             button = event.xbutton.button - 1;
 703
 704             /*
 705              * XXX This comment is replicated in the WIN32 section and
 706              * XXX maybe also in the menu code.  Can we move the info
 707              * XXX to one central place and *reference* it from here?
 708              *
 709              * Do not execute the application's mouse callback if a menu
 710              * is hooked to this button.  In that case an appropriate
 711              * private call should be generated.
 712              * Near as I can tell, this is the menu behaviour:
 713              *  - Down-click the menu button, menu not active:  activate
 714              *    the menu with its upper left-hand corner at the mouse
 715              *    location.
 716              *  - Down-click any button outside the menu, menu active:
 717              *    deactivate the menu
 718              *  - Down-click any button inside the menu, menu active:
 719              *    select the menu entry and deactivate the menu
 720              *  - Up-click the menu button, menu not active:  nothing happens
 721              *  - Up-click the menu button outside the menu, menu active:
 722              *    nothing happens
 723              *  - Up-click the menu button inside the menu, menu active:
 724              *    select the menu entry and deactivate the menu
 725              */
 726             /* Window has an active menu, it absorbs any mouse click */
 727             if( window->ActiveMenu )
 728             {
 729                 if( window == window->ActiveMenu->ParentWindow )
 730                 {
 731                     window->ActiveMenu->Window->State.MouseX =
 732                         event.xbutton.x_root - window->ActiveMenu->X;
 733                     window->ActiveMenu->Window->State.MouseY =
 734                         event.xbutton.y_root - window->ActiveMenu->Y;
 735                 }
 736
 737                 /* In the menu, invoke the callback and deactivate the menu*/
 738                 if( fgCheckActiveMenu( window->ActiveMenu->Window,
 739                                        window->ActiveMenu ) )
 740                 {
 741                     /*
 742                      * Save the current window and menu and set the current
 743                      * window to the window whose menu this is
 744                      */
 745                     SFG_Window *save_window = fgStructure.Window;
 746                     SFG_Menu *save_menu = fgStructure.Menu;
 747                     SFG_Window *parent_window =
 748                         window->ActiveMenu->ParentWindow;
 749                     fgSetWindow( parent_window );
 750                     fgStructure.Menu = window->ActiveMenu;
 751
 752                     /* Execute the menu callback */
 753                     fgExecuteMenuCallback( window->ActiveMenu );
 754                     fgDeactivateMenu( parent_window );
 755
 756                     /* Restore the current window and menu */
 757                     fgSetWindow( save_window );
 758                     fgStructure.Menu = save_menu;
 759                 }
 760                 else if( pressed )
 761                     /*
 762                      * Outside the menu, deactivate if it's a downclick
 763                      * XXX This isn't enough.  A downclick outside of
 764                      * XXX the interior of our freeglut windows should also
 765                      * XXX deactivate the menu.  This is more complicated.
 766                      */
 767                     fgDeactivateMenu( window->ActiveMenu->ParentWindow );
 768
 769                 window->State.Redisplay = GL_TRUE;
 770                 break;
 771             }
 772
 773             /*
 774              * No active menu, let's check whether we need to activate one.
 775              */
 776             if( ( 0 <= button ) &&
 777                 ( FREEGLUT_MAX_MENUS > button ) &&
 778                 ( window->Menu[ button ] ) &&
 779                 pressed )
 780             {
 781                 window->State.Redisplay = GL_TRUE;
 782                 fgSetWindow( window );
 783                 fgActivateMenu( window, button );
 784                 break;
 785             }
 786
 787             /*
 788              * Check if there is a mouse or mouse wheel callback hooked to the
 789              * window
 790              */
 791             if( ! FETCH_WCB( *window, Mouse ) &&
 792                 ! FETCH_WCB( *window, MouseWheel ) )
 793                 break;
 794
 795             fgState.Modifiers = fgGetXModifiers( &event );
 796
 797             /*
 798              * Finally execute the mouse or mouse wheel callback
 799              *
 800              * XXX Use a symbolic constant, *not* "4"!
 801              */
 802             if( ( button < 3 ) || ( ! FETCH_WCB( *window, MouseWheel ) ) )
 803                 INVOKE_WCB( *window, Mouse, ( button,
 804                                               pressed ? GLUT_DOWN : GLUT_UP,
 805                                               event.xbutton.x,
 806                                               event.xbutton.y )
 807                 );
 808             else
 809             {
 810                 /*
 811                  * Map 4 and 5 to wheel zero; EVEN to +1, ODD to -1
 812                  *  "  6 and 7 "    "   one; ...
 813                  *
 814                  * XXX This *should* be behind some variables/macros,
 815                  * XXX since the order and numbering isn't certain
 816                  * XXX See XFree86 configuration docs (even back in the
 817                  * XXX 3.x days, and especially with 4.x).
 818                  *
 819                  * XXX Note that {button} has already been decremeted
 820                  * XXX in mapping from X button numbering to GLUT.
 821                  */
 822                 int wheel_number = (button - 3) / 2;
 823                 int direction = -1;
 824                 if( button % 2 )
 825                     direction = 1;
 826
 827                 if( pressed )
 828                     INVOKE_WCB( *window, MouseWheel, ( wheel_number,
 829                                                        direction,
 830                                                        event.xbutton.x,
 831                                                        event.xbutton.y )
 832                     );
 833             }
 834
 835             /*
 836              * Trash the modifiers state
 837              */
 838             fgState.Modifiers = 0xffffffff;
 839         }
 840         break;
 841
 842         case KeyRelease:
 843         case KeyPress:
 844         {
 845             FGCBKeyboard keyboard_cb;
 846             FGCBSpecial special_cb;
 847
 848             GETWINDOW( xkey );
 849             GETMOUSE( xkey );
 850
 851             if( event.type == KeyPress )
 852             {
 853                 keyboard_cb = FETCH_WCB( *window, Keyboard );
 854                 special_cb  = FETCH_WCB( *window, Special  );
 855             }
 856             else
 857             {
 858                 keyboard_cb = FETCH_WCB( *window, KeyboardUp );
 859                 special_cb  = FETCH_WCB( *window, SpecialUp  );
 860             }
 861
 862             /*
 863              * Is there a keyboard/special callback hooked for this window?
 864              */
 865             if( keyboard_cb || special_cb )
 866             {
 867                 XComposeStatus composeStatus;
 868                 char asciiCode[ 32 ];
 869                 KeySym keySym;
 870                 int len;
 871
 872                 /*
 873                  * Check for the ASCII/KeySym codes associated with the event:
 874                  */
 875                 len = XLookupString( &event.xkey, asciiCode, sizeof(asciiCode),
 876                                      &keySym, &composeStatus
 877                 );
 878
 879                 /*
 880                  * GLUT API tells us to have two separate callbacks...
 881                  */
 882                 if( len > 0 )
 883                 {
 884                     /*
 885                      * ...one for the ASCII translateable keypresses...
 886                      */
 887                     if( keyboard_cb )
 888                     {
 889                         fgSetWindow( window );
 890                         fgState.Modifiers = fgGetXModifiers( &event );
 891                         keyboard_cb( asciiCode[ 0 ],
 892                                      event.xkey.x, event.xkey.y
 893                         );
 894                         fgState.Modifiers = 0xffffffff;
 895                     }
 896                 }
 897                 else
 898                 {
 899                     int special = -1;
 900
 901                     /*
 902                      * ...and one for all the others, which need to be
 903                      * translated to GLUT_KEY_Xs...
 904                      */
 905                     switch( keySym )
 906                     {
 907                     case XK_F1:     special = GLUT_KEY_F1;     break;
 908                     case XK_F2:     special = GLUT_KEY_F2;     break;
 909                     case XK_F3:     special = GLUT_KEY_F3;     break;
 910                     case XK_F4:     special = GLUT_KEY_F4;     break;
 911                     case XK_F5:     special = GLUT_KEY_F5;     break;
 912                     case XK_F6:     special = GLUT_KEY_F6;     break;
 913                     case XK_F7:     special = GLUT_KEY_F7;     break;
 914                     case XK_F8:     special = GLUT_KEY_F8;     break;
 915                     case XK_F9:     special = GLUT_KEY_F9;     break;
 916                     case XK_F10:    special = GLUT_KEY_F10;    break;
 917                     case XK_F11:    special = GLUT_KEY_F11;    break;
 918                     case XK_F12:    special = GLUT_KEY_F12;    break;
 919
 920                     case XK_Left:   special = GLUT_KEY_LEFT;   break;
 921                     case XK_Right:  special = GLUT_KEY_RIGHT;  break;
 922                     case XK_Up:     special = GLUT_KEY_UP;     break;
 923                     case XK_Down:   special = GLUT_KEY_DOWN;   break;
 924
 925                     case XK_KP_Prior:
 926                     case XK_Prior:  special = GLUT_KEY_PAGE_UP; break;
 927                     case XK_KP_Next:
 928                     case XK_Next:   special = GLUT_KEY_PAGE_DOWN; break;
 929                     case XK_KP_Home:
 930                     case XK_Home:   special = GLUT_KEY_HOME;   break;
 931                     case XK_KP_End:
 932                     case XK_End:    special = GLUT_KEY_END;    break;
 933                     case XK_KP_Insert:
 934                     case XK_Insert: special = GLUT_KEY_INSERT; break;
 935                     }
 936
 937                     /*
 938                      * Execute the callback (if one has been specified),
 939                      * given that the special code seems to be valid...
 940                      */
 941                     if( special_cb && (special != -1) )
 942                     {
 943                         fgSetWindow( window );
 944                         fgState.Modifiers = fgGetXModifiers( &event );
 945                         special_cb( special, event.xkey.x, event.xkey.y );
 946                         fgState.Modifiers = 0xffffffff;
 947                     }
 948                 }
 949             }
 950         }
 951         break;
 952
 953         case ReparentNotify:
 954             break; /* XXX Should disable this event */
 955
 956         default:
 957             fgWarning ("Unknown X event type: %d", event.type);
 958             break;
 959         }
 960     }
 961
 962 #elif TARGET_HOST_WIN32
 963
 964     MSG stMsg;
 965
 966     while( PeekMessage( &stMsg, NULL, 0, 0, PM_NOREMOVE ) )
 967     {
 968         if( GetMessage( &stMsg, NULL, 0, 0 ) == 0 )
 969         {
 970             if( fgState.ActionOnWindowClose == GLUT_ACTION_EXIT )
 971             {
 972                 fgDeinitialize( );
 973                 exit( 0 );
 974             }
 975             fgState.ExecState = GLUT_EXEC_STATE_STOP;
 976             return;
 977         }
 978
 979         TranslateMessage( &stMsg );
 980         DispatchMessage( &stMsg );
 981     }
 982 #endif
 983
 984     if( fgState.Timers.First )
 985         fghCheckTimers( );
 986     fghCheckJoystickPolls( );
 987     fghDisplayAll( );
 988
 989     fgCloseWindows( );
 990 }
 991
 992 /*
 993  * Enters the freeglut processing loop.
 994  * Stays until the "ExecState" changes to "GLUT_EXEC_STATE_STOP".
 995  */
 996 void FGAPIENTRY glutMainLoop( void )
 997 {
 998 #if TARGET_HOST_WIN32
 999     SFG_Window *window = (SFG_Window *)fgStructure.Windows.First ;
1000 #endif
1001
1002     freeglut_assert_ready;
1003
1004 #if TARGET_HOST_WIN32
1005     /*
1006      * Processing before the main loop:  If there is a window which is open and
1007      * which has a visibility callback, call it.  I know this is an ugly hack,
1008      * but I'm not sure what else to do about it.  Ideally we should leave
1009      * something uninitialized in the create window code and initialize it in
1010      * the main loop, and have that initialization create a "WM_ACTIVATE"
1011      * message.  Then we would put the visibility callback code in the
1012      * "case WM_ACTIVATE" block below.         - John Fay -- 10/24/02
1013      */
1014     while( window )
1015     {
1016         if ( FETCH_WCB( *window, Visibility ) )
1017         {
1018             SFG_Window *current_window = fgStructure.Window ;
1019
1020             INVOKE_WCB( *window, Visibility, ( window->State.Visible ) );
1021             fgSetWindow( current_window );
1022         }
1023
1024         window = (SFG_Window *)window->Node.Next ;
1025     }
1026 #endif
1027
1028     fgState.ExecState = GLUT_EXEC_STATE_RUNNING ;
1029     while( fgState.ExecState == GLUT_EXEC_STATE_RUNNING )
1030     {
1031         glutMainLoopEvent( );
1032
1033         if( fgStructure.Windows.First == NULL )
1034             fgState.ExecState = GLUT_EXEC_STATE_STOP;
1035         else
1036         {
1037             if( fgState.IdleCallback )
1038                 fgState.IdleCallback( );
1039
1040             fgSleepForEvents();
1041         }
1042     }
1043
1044     /*
1045      * When this loop terminates, destroy the display, state and structure
1046      * of a freeglut session, so that another glutInit() call can happen
1047      */
1048     fgDeinitialize( );
1049 }
1050
1051 /*
1052  * Leaves the freeglut processing loop.
1053  */
1054 void FGAPIENTRY glutLeaveMainLoop( void )
1055 {
1056     fgState.ExecState = GLUT_EXEC_STATE_STOP ;
1057 }
1058
1059
1060 #if TARGET_HOST_WIN32
1061 /*
1062  * Determine a GLUT modifer mask based on MS-WINDOWS system info.
1063  */
1064 int fgGetWin32Modifiers (void)
1065 {
1066     return
1067         ( ( ( GetKeyState( VK_LSHIFT   ) < 0 ) ||
1068             ( GetKeyState( VK_RSHIFT   ) < 0 )) ? GLUT_ACTIVE_SHIFT : 0 ) |
1069         ( ( ( GetKeyState( VK_LCONTROL ) < 0 ) ||
1070             ( GetKeyState( VK_RCONTROL ) < 0 )) ? GLUT_ACTIVE_CTRL  : 0 ) |
1071         ( ( ( GetKeyState( VK_LMENU    ) < 0 ) ||
1072             ( GetKeyState( VK_RMENU    ) < 0 )) ? GLUT_ACTIVE_ALT   : 0 );
1073 }
1074
1075 /*
1076  * The window procedure for handling Win32 events
1077  */
1078 LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam,
1079                                LPARAM lParam )
1080 {
1081     SFG_Window* window = fgWindowByHandle( hWnd );
1082     PAINTSTRUCT ps;
1083     LONG lRet = 1;
1084
1085     if ( ( window == NULL ) && ( uMsg != WM_CREATE ) )
1086       return DefWindowProc( hWnd, uMsg, wParam, lParam );
1087
1088     /* printf ( "Window %3d message <%04x> %12d %12d\n", window?window->ID:0,
1089              uMsg, wParam, lParam ); */
1090     switch( uMsg )
1091     {
1092     case WM_CREATE:
1093         /*
1094          * The window structure is passed as the creation structure paramter...
1095          */
1096         window = (SFG_Window *) (((LPCREATESTRUCT) lParam)->lpCreateParams);
1097         assert( window != NULL );
1098
1099         window->Window.Handle = hWnd;
1100         window->Window.Device = GetDC( hWnd );
1101         if( window->IsMenu )
1102         {
1103             unsigned int current_DisplayMode = fgState.DisplayMode;
1104             fgState.DisplayMode = GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH;
1105             fgSetupPixelFormat( window, GL_FALSE, PFD_MAIN_PLANE );
1106             fgState.DisplayMode = current_DisplayMode;
1107
1108             if( fgStructure.MenuContext )
1109                 wglMakeCurrent( window->Window.Device,
1110                                 fgStructure.MenuContext->Context
1111                 );
1112             else
1113             {
1114                 fgStructure.MenuContext =
1115                     (SFG_MenuContext *)malloc( sizeof(SFG_MenuContext) );
1116                 fgStructure.MenuContext->Context =
1117                     wglCreateContext( window->Window.Device );
1118             }
1119
1120             /* window->Window.Context = wglGetCurrentContext ();   */
1121             window->Window.Context = wglCreateContext( window->Window.Device );
1122         }
1123         else
1124         {
1125             fgSetupPixelFormat( window, GL_FALSE, PFD_MAIN_PLANE );
1126
1127             if( ! fgState.UseCurrentContext )
1128                 window->Window.Context =
1129                     wglCreateContext( window->Window.Device );
1130             else
1131             {
1132                 window->Window.Context = wglGetCurrentContext( );
1133                 if( ! window->Window.Context )
1134                     window->Window.Context =
1135                         wglCreateContext( window->Window.Device );
1136             }
1137         }
1138
1139         window->State.NeedToResize = GL_TRUE;
1140         window->State.Width  = fgState.Size.X;
1141         window->State.Height = fgState.Size.Y;
1142
1143         ReleaseDC( window->Window.Handle, window->Window.Device );
1144         break;
1145
1146     case WM_SIZE:
1147         /*
1148          * We got resized... But check if the window has been already added...
1149          */
1150         window->State.NeedToResize = GL_TRUE;
1151         window->State.Width  = LOWORD(lParam);
1152         window->State.Height = HIWORD(lParam);
1153         break;
1154 #if 0
1155     case WM_SETFOCUS:
1156         printf("WM_SETFOCUS: %p\n", window );
1157         lRet = DefWindowProc( hWnd, uMsg, wParam, lParam );
1158         break;
1159
1160     case WM_ACTIVATE:
1161         if (LOWORD(wParam) != WA_INACTIVE)
1162         {
1163             /* glutSetCursor( fgStructure.Window->State.Cursor ); */
1164             printf("WM_ACTIVATE: glutSetCursor( %p, %d)\n", window,
1165                    window->State.Cursor );
1166             glutSetCursor( window->State.Cursor );
1167         }
1168
1169         lRet = DefWindowProc( hWnd, uMsg, wParam, lParam );
1170         break;
1171 #endif
1172
1173         /*
1174          * XXX Why not re-use some common code with the glutSetCursor()
1175          * XXX function (or perhaps invoke glutSetCursor())?
1176          * XXX That is, why are we duplicating code, here, from
1177          * XXX glutSetCursor()?  The WIN32 code should be able to just
1178          * XXX call glutSetCurdsor() instead of defining two macros
1179          * XXX and implementing a nested case in-line.
1180          */
1181     case WM_SETCURSOR:
1182         /* Set the cursor AND change it for this window class. */
1183 #define MAP_CURSOR(a,b)                 \
1184     case a:                             \
1185     SetCursor( LoadCursor( NULL, b ) ); \
1186     break;
1187
1188         /* Nuke the cursor AND change it for this window class. */
1189 #define ZAP_CURSOR(a,b) \
1190     case a:             \
1191     SetCursor( NULL );  \
1192     break;
1193
1194         if( LOWORD( lParam ) == HTCLIENT )
1195             switch( window->State.Cursor )
1196             {
1197                 MAP_CURSOR( GLUT_CURSOR_RIGHT_ARROW, IDC_ARROW     );
1198                 MAP_CURSOR( GLUT_CURSOR_LEFT_ARROW,  IDC_ARROW     );
1199                 MAP_CURSOR( GLUT_CURSOR_INFO,        IDC_HELP      );
1200                 MAP_CURSOR( GLUT_CURSOR_DESTROY,     IDC_CROSS     );
1201                 MAP_CURSOR( GLUT_CURSOR_HELP,        IDC_HELP      );
1202                 MAP_CURSOR( GLUT_CURSOR_CYCLE,       IDC_SIZEALL   );
1203                 MAP_CURSOR( GLUT_CURSOR_SPRAY,       IDC_CROSS     );
1204                 MAP_CURSOR( GLUT_CURSOR_WAIT,        IDC_WAIT      );
1205                 MAP_CURSOR( GLUT_CURSOR_TEXT,        IDC_UPARROW   );
1206                 MAP_CURSOR( GLUT_CURSOR_CROSSHAIR,   IDC_CROSS     );
1207                 /* MAP_CURSOR( GLUT_CURSOR_NONE,        IDC_NO         ); */
1208                 ZAP_CURSOR( GLUT_CURSOR_NONE,        NULL          );
1209
1210             default:
1211                 MAP_CURSOR( GLUT_CURSOR_UP_DOWN,     IDC_ARROW     );
1212             }
1213         else
1214             lRet = DefWindowProc( hWnd, uMsg, wParam, lParam );
1215         break;
1216
1217     case WM_SHOWWINDOW:
1218         window->State.Visible = GL_TRUE;
1219         window->State.Redisplay = GL_TRUE;
1220         break;
1221
1222     case WM_PAINT:
1223         /* Turn on the visibility in case it was turned off somehow */
1224         window->State.Visible = GL_TRUE;
1225         BeginPaint( hWnd, &ps );
1226         fghRedrawWindowByHandle( hWnd );
1227         EndPaint( hWnd, &ps );
1228         break;
1229
1230     case WM_CLOSE:
1231         fgDestroyWindow ( window );
1232         if ( fgState.ActionOnWindowClose != GLUT_ACTION_CONTINUE_EXECUTION )
1233             PostQuitMessage(0);
1234         break;
1235
1236     case WM_DESTROY:
1237         /*
1238          * The window already got destroyed, so don't bother with it.
1239          */
1240         return 0;
1241
1242     case WM_MOUSEMOVE:
1243     {
1244         window->State.MouseX = LOWORD( lParam );
1245         window->State.MouseY = HIWORD( lParam );
1246
1247         if ( window->ActiveMenu )
1248         {
1249             window->State.Redisplay = GL_TRUE;
1250             fgSetWindow ( window->ActiveMenu->ParentWindow );
1251             break;
1252         }
1253
1254         fgState.Modifiers = fgGetWin32Modifiers( );
1255
1256         if( ( wParam & MK_LBUTTON ) ||
1257             ( wParam & MK_MBUTTON ) ||
1258             ( wParam & MK_RBUTTON ) )
1259             INVOKE_WCB( *window, Motion, ( window->State.MouseX,
1260                                            window->State.MouseY ) );
1261         else
1262             INVOKE_WCB( *window, Passive, ( window->State.MouseX,
1263                                             window->State.MouseY ) );
1264
1265         fgState.Modifiers = 0xffffffff;
1266     }
1267     break;
1268
1269     case WM_LBUTTONDOWN:
1270     case WM_MBUTTONDOWN:
1271     case WM_RBUTTONDOWN:
1272     case WM_LBUTTONUP:
1273     case WM_MBUTTONUP:
1274     case WM_RBUTTONUP:
1275     {
1276         GLboolean pressed = GL_TRUE;
1277         int button;
1278
1279         window->State.MouseX = LOWORD( lParam );
1280         window->State.MouseY = HIWORD( lParam );
1281
1282         switch( uMsg )
1283         {
1284         case WM_LBUTTONDOWN:
1285             pressed = GL_TRUE;
1286             button = GLUT_LEFT_BUTTON;
1287             break;
1288         case WM_MBUTTONDOWN:
1289             pressed = GL_TRUE;
1290             button = GLUT_MIDDLE_BUTTON;
1291             break;
1292         case WM_RBUTTONDOWN:
1293             pressed = GL_TRUE;
1294             button = GLUT_RIGHT_BUTTON;
1295             break;
1296         case WM_LBUTTONUP:
1297             pressed = GL_FALSE;
1298             button = GLUT_LEFT_BUTTON;
1299             break;
1300         case WM_MBUTTONUP:
1301             pressed = GL_FALSE;
1302             button = GLUT_MIDDLE_BUTTON;
1303             break;
1304         case WM_RBUTTONUP:
1305             pressed = GL_FALSE;
1306             button = GLUT_RIGHT_BUTTON;
1307             break;
1308         default:
1309             pressed = GL_FALSE;
1310             button = -1;
1311             break;
1312         }
1313
1314         if( GetSystemMetrics( SM_SWAPBUTTON ) )
1315             if( button == GLUT_LEFT_BUTTON )
1316                 button = GLUT_RIGHT_BUTTON;
1317             else if( button == GLUT_RIGHT_BUTTON )
1318                 button = GLUT_LEFT_BUTTON;
1319
1320         if( button == -1 )
1321             return DefWindowProc( hWnd, uMsg, lParam, wParam );
1322
1323         /*
1324          * XXX This comment is duplicated in two other spots.
1325          * XXX Can we centralize it?
1326          *
1327          * Do not execute the application's mouse callback if a
1328          * menu is hooked to this button.
1329          * In that case an appropriate private call should be generated.
1330          * Near as I can tell, this is the menu behaviour:
1331          *  - Down-click the menu button, menu not active:  activate
1332          *    the menu with its upper left-hand corner at the mouse location.
1333          *  - Down-click any button outside the menu, menu active:
1334          *    deactivate the menu
1335          *  - Down-click any button inside the menu, menu active:
1336          *    select the menu entry and deactivate the menu
1337          *  - Up-click the menu button, menu not active:  nothing happens
1338          *  - Up-click the menu button outside the menu, menu active:
1339          *    nothing happens
1340          *  - Up-click the menu button inside the menu, menu active:
1341          *    select the menu entry and deactivate the menu
1342          */
1343         /* Window has an active menu, it absorbs any mouse click */
1344         if( window->ActiveMenu )
1345         {
1346             /* Outside the menu, deactivate the menu if it's a downclick */
1347             if( ! fgCheckActiveMenu( window, window->ActiveMenu ) )
1348             {
1349                 if( pressed )
1350                     fgDeactivateMenu( window->ActiveMenu->ParentWindow );
1351             }
1352             else  /* In menu, invoke the callback and deactivate the menu*/
1353             {
1354                 /*
1355                  * Save the current window and menu and set the current
1356                  * window to the window whose menu this is
1357                  */
1358                 SFG_Window *save_window = fgStructure.Window;
1359                 SFG_Menu *save_menu = fgStructure.Menu;
1360                 SFG_Window *parent_window = window->ActiveMenu->ParentWindow;
1361                 fgSetWindow( parent_window );
1362                 fgStructure.Menu = window->ActiveMenu;
1363
1364                 /* Execute the menu callback */
1365                 fgExecuteMenuCallback( window->ActiveMenu );
1366                 fgDeactivateMenu( parent_window );
1367
1368                 /* Restore the current window and menu */
1369                 fgSetWindow( save_window );
1370                 fgStructure.Menu = save_menu;
1371             }
1372
1373             /*
1374              * Let's make the window redraw as a result of the mouse
1375              * click and menu activity.
1376              */
1377             if( ! window->IsMenu )
1378                 window->State.Redisplay = GL_TRUE;
1379
1380             break;
1381         }
1382
1383         if ( window->Menu[ button ] && pressed )
1384         {
1385             window->State.Redisplay = GL_TRUE;
1386             fgSetWindow( window );
1387             fgActivateMenu( window, button );
1388
1389             break;
1390         }
1391
1392         if( ! FETCH_WCB( *window, Mouse ) )
1393             break;
1394
1395         fgSetWindow( window );
1396         fgState.Modifiers = fgGetWin32Modifiers( );
1397
1398         INVOKE_WCB(
1399             *window, Mouse,
1400             ( button,
1401               pressed ? GLUT_DOWN : GLUT_UP,
1402               window->State.MouseX,
1403               window->State.MouseY
1404             )
1405         );
1406
1407         fgState.Modifiers = 0xffffffff;
1408     }
1409     break;
1410
1411     case 0x020a:
1412         /* Should be WM_MOUSEWHEEL but my compiler doesn't recognize it */
1413     {
1414         /*
1415          * XXX THIS IS SPECULATIVE -- John Fay, 10/2/03
1416          * XXX Should use WHEEL_DELTA instead of 120
1417          */
1418         int wheel_number = LOWORD( wParam );
1419         short ticks = ( short )HIWORD( wParam ) / 120;
1420         int direction = 1;
1421
1422         if( ticks < 0 )
1423         {
1424             direction = -1;
1425             ticks = -ticks;
1426         }
1427
1428         /*
1429          * The mouse cursor has moved. Remember the new mouse cursor's position
1430          */
1431         /*        window->State.MouseX = LOWORD( lParam ); */
1432         /* Need to adjust by window position, */
1433         /*        window->State.MouseY = HIWORD( lParam ); */
1434         /* change "lParam" to other parameter */
1435
1436         if( ! FETCH_WCB( *window, MouseWheel ) &&
1437             ! FETCH_WCB( *window, Mouse ) )
1438             break;
1439
1440         fgSetWindow( window );
1441         fgState.Modifiers = fgGetWin32Modifiers( );
1442
1443         while( ticks-- )
1444             if( FETCH_WCB( *window, MouseWheel ) )
1445                 INVOKE_WCB( *window, MouseWheel,
1446                             ( wheel_number,
1447                               direction,
1448                               window->State.MouseX,
1449                               window->State.MouseY
1450                             )
1451                 );
1452             else  /* No mouse wheel, call the mouse button callback twice */
1453             {
1454                 /*
1455                  * XXX The below assumes that you have no more than 3 mouse
1456                  * XXX buttons.  Sorry.
1457                  */
1458                 int button = wheel_number*2 + 4;
1459                 if( direction > 0 )
1460                     ++button;
1461                 INVOKE_WCB( *window, Mouse,
1462                             ( button, GLUT_DOWN,
1463                               window->State.MouseX, window->State.MouseY )
1464                 );
1465                 INVOKE_WCB( *window, Mouse,
1466                             ( button, GLUT_UP,
1467                               window->State.MouseX, window->State.MouseX )
1468                 );
1469             }
1470
1471         fgState.Modifiers = 0xffffffff;
1472     }
1473     break ;
1474
1475     case WM_SYSKEYDOWN:
1476     case WM_KEYDOWN:
1477     {
1478         int keypress = -1;
1479         POINT mouse_pos ;
1480
1481         if( fgState.IgnoreKeyRepeat && (lParam & KF_REPEAT) )
1482             break;
1483
1484         /*
1485          * Remember the current modifiers state. This is done here in order
1486          * to make sure the VK_DELETE keyboard callback is executed properly.
1487          */
1488         fgState.Modifiers = fgGetWin32Modifiers( );
1489
1490         GetCursorPos( &mouse_pos );
1491         ScreenToClient( window->Window.Handle, &mouse_pos );
1492
1493         window->State.MouseX = mouse_pos.x;
1494         window->State.MouseY = mouse_pos.y;
1495
1496         /*
1497          * Convert the Win32 keystroke codes to GLUTtish way
1498          */
1499 #       define KEY(a,b) case a: keypress = b; break;
1500
1501         switch( wParam )
1502         {
1503             KEY( VK_F1,     GLUT_KEY_F1        );
1504             KEY( VK_F2,     GLUT_KEY_F2        );
1505             KEY( VK_F3,     GLUT_KEY_F3        );
1506             KEY( VK_F4,     GLUT_KEY_F4        );
1507             KEY( VK_F5,     GLUT_KEY_F5        );
1508             KEY( VK_F6,     GLUT_KEY_F6        );
1509             KEY( VK_F7,     GLUT_KEY_F7        );
1510             KEY( VK_F8,     GLUT_KEY_F8        );
1511             KEY( VK_F9,     GLUT_KEY_F9        );
1512             KEY( VK_F10,    GLUT_KEY_F10       );
1513             KEY( VK_F11,    GLUT_KEY_F11       );
1514             KEY( VK_F12,    GLUT_KEY_F12       );
1515             KEY( VK_PRIOR,  GLUT_KEY_PAGE_UP   );
1516             KEY( VK_NEXT,   GLUT_KEY_PAGE_DOWN );
1517             KEY( VK_HOME,   GLUT_KEY_HOME      );
1518             KEY( VK_END,    GLUT_KEY_END       );
1519             KEY( VK_LEFT,   GLUT_KEY_LEFT      );
1520             KEY( VK_UP,     GLUT_KEY_UP        );
1521             KEY( VK_RIGHT,  GLUT_KEY_RIGHT     );
1522             KEY( VK_DOWN,   GLUT_KEY_DOWN      );
1523             KEY( VK_INSERT, GLUT_KEY_INSERT    );
1524
1525         case VK_DELETE:
1526             /*
1527              * The delete key should be treated as an ASCII keypress:
1528              */
1529             INVOKE_WCB( *window, Keyboard,
1530                         ( 127, window->State.MouseX, window->State.MouseY )
1531             );
1532         }
1533
1534         if( keypress != -1 )
1535             INVOKE_WCB( *window, Special,
1536                         ( keypress,
1537                           window->State.MouseX, window->State.MouseY )
1538             );
1539
1540         fgState.Modifiers = 0xffffffff;
1541     }
1542     break;
1543
1544     case WM_SYSKEYUP:
1545     case WM_KEYUP:
1546     {
1547         int keypress = -1;
1548         POINT mouse_pos;
1549
1550         /*
1551          * Remember the current modifiers state. This is done here in order
1552          * to make sure the VK_DELETE keyboard callback is executed properly.
1553          */
1554         fgState.Modifiers = fgGetWin32Modifiers( );
1555
1556         GetCursorPos( &mouse_pos );
1557         ScreenToClient( window->Window.Handle, &mouse_pos );
1558
1559         window->State.MouseX = mouse_pos.x;
1560         window->State.MouseY = mouse_pos.y;
1561
1562         /*
1563          * Convert the Win32 keystroke codes to GLUTtish way.
1564          * "KEY(a,b)" was defined under "WM_KEYDOWN"
1565          */
1566
1567         switch( wParam )
1568         {
1569             KEY( VK_F1,     GLUT_KEY_F1        );
1570             KEY( VK_F2,     GLUT_KEY_F2        );
1571             KEY( VK_F3,     GLUT_KEY_F3        );
1572             KEY( VK_F4,     GLUT_KEY_F4        );
1573             KEY( VK_F5,     GLUT_KEY_F5        );
1574             KEY( VK_F6,     GLUT_KEY_F6        );
1575             KEY( VK_F7,     GLUT_KEY_F7        );
1576             KEY( VK_F8,     GLUT_KEY_F8        );
1577             KEY( VK_F9,     GLUT_KEY_F9        );
1578             KEY( VK_F10,    GLUT_KEY_F10       );
1579             KEY( VK_F11,    GLUT_KEY_F11       );
1580             KEY( VK_F12,    GLUT_KEY_F12       );
1581             KEY( VK_PRIOR,  GLUT_KEY_PAGE_UP   );
1582             KEY( VK_NEXT,   GLUT_KEY_PAGE_DOWN );
1583             KEY( VK_HOME,   GLUT_KEY_HOME      );
1584             KEY( VK_END,    GLUT_KEY_END       );
1585             KEY( VK_LEFT,   GLUT_KEY_LEFT      );
1586             KEY( VK_UP,     GLUT_KEY_UP        );
1587             KEY( VK_RIGHT,  GLUT_KEY_RIGHT     );
1588             KEY( VK_DOWN,   GLUT_KEY_DOWN      );
1589             KEY( VK_INSERT, GLUT_KEY_INSERT    );
1590
1591           case VK_DELETE:
1592               /*
1593                * The delete key should be treated as an ASCII keypress:
1594                */
1595               INVOKE_WCB( *window, KeyboardUp,
1596                           ( 127, window->State.MouseX, window->State.MouseY )
1597               );
1598               break;
1599
1600         default:
1601         {
1602             BYTE state[ 256 ];
1603             WORD code[ 2 ];
1604
1605             GetKeyboardState( state );
1606
1607             if( ToAscii( wParam, 0, state, code, 0 ) == 1 )
1608                 wParam=code[ 0 ];
1609
1610             INVOKE_WCB( *window, KeyboardUp,
1611                         ( (char)wParam,
1612                           window->State.MouseX, window->State.MouseY )
1613             );
1614         }
1615         }
1616
1617         if( keypress != -1 )
1618             INVOKE_WCB( *window, SpecialUp,
1619                         ( keypress,
1620                           window->State.MouseX, window->State.MouseY )
1621             );
1622
1623         fgState.Modifiers = 0xffffffff;
1624     }
1625     break;
1626
1627     case WM_SYSCHAR:
1628     case WM_CHAR:
1629     {
1630         if( fgState.IgnoreKeyRepeat && (lParam & KF_REPEAT) )
1631             break;
1632
1633         fgState.Modifiers = fgGetWin32Modifiers( );
1634         INVOKE_WCB( *window, Keyboard,
1635                     ( (char)wParam,
1636                       window->State.MouseX, window->State.MouseY )
1637         );
1638         fgState.Modifiers = 0xffffffff;
1639     }
1640     break;
1641
1642     case WM_CAPTURECHANGED:
1643         /* User has finished resizing the window, force a redraw */
1644         INVOKE_WCB( *window, Display, ( ) );
1645
1646         /*lRet = DefWindowProc( hWnd, uMsg, wParam, lParam ); */
1647         break;
1648
1649         /*
1650          * Other messages that I have seen and which are not handled already
1651          */
1652     case WM_SETTEXT:  /* 0x000c */
1653         lRet = DefWindowProc( hWnd, uMsg, wParam, lParam );
1654         /* Pass it on to "DefWindowProc" to set the window text */
1655         break;
1656
1657     case WM_GETTEXT:  /* 0x000d */
1658         /* Ideally we would copy the title of the window into "lParam" */
1659         /* strncpy ( (char *)lParam, "Window Title", wParam );
1660            lRet = ( wParam > 12 ) ? 12 : wParam;  */
1661         /* the number of characters copied */
1662         lRet = DefWindowProc( hWnd, uMsg, wParam, lParam );
1663         break;
1664
1665     case WM_GETTEXTLENGTH:  /* 0x000e */
1666         /* Ideally we would get the length of the title of the window */
1667         lRet = 12;
1668         /* the number of characters in "Window Title\0" (see above) */
1669         break;
1670
1671     case WM_ERASEBKGND:  /* 0x0014 */
1672         lRet = DefWindowProc( hWnd, uMsg, wParam, lParam );
1673         break;
1674
1675     case WM_SYNCPAINT:  /* 0x0088 */
1676         /* Another window has moved, need to update this one */
1677         window->State.Redisplay = GL_TRUE;
1678         lRet = DefWindowProc( hWnd, uMsg, wParam, lParam );
1679         /* Help screen says this message must be passed to "DefWindowProc" */
1680         break;
1681
1682     case WM_NCPAINT:  /* 0x0085 */
1683       /* Need to update the border of this window */
1684         lRet = DefWindowProc( hWnd, uMsg, wParam, lParam );
1685         /* Pass it on to "DefWindowProc" to repaint a standard border */
1686         break;
1687
1688     case WM_SYSCOMMAND :  /* 0x0112 */
1689         {
1690           /*
1691            * We have received a system command message.  Try to act on it.
1692            * The commands are passed in through the "lParam" parameter:
1693            * Clicking on a corner to resize the window gives a "F004" message
1694            * but this is not defined in my header file.
1695            */
1696             switch ( lParam )
1697             {
1698             case SC_SIZE       :
1699                 break ;
1700
1701             case SC_MOVE       :
1702                 break ;
1703
1704             case SC_MINIMIZE   :
1705                 /* User has clicked on the "-" to minimize the window */
1706                 /* Turn off the visibility */
1707                 window->State.Visible = GL_FALSE ;
1708
1709                 break ;
1710
1711             case SC_MAXIMIZE   :
1712                 break ;
1713
1714             case SC_NEXTWINDOW :
1715                 break ;
1716
1717             case SC_PREVWINDOW :
1718                 break ;
1719
1720             case SC_CLOSE      :
1721                 /* Followed very closely by a WM_CLOSE message */
1722                 break ;
1723
1724             case SC_VSCROLL    :
1725                 break ;
1726
1727             case SC_HSCROLL    :
1728                 break ;
1729
1730             case SC_MOUSEMENU  :
1731                 break ;
1732
1733             case SC_KEYMENU    :
1734                 break ;
1735
1736             case SC_ARRANGE    :
1737                 break ;
1738
1739             case SC_RESTORE    :
1740                 break ;
1741
1742             case SC_TASKLIST   :
1743                 break ;
1744
1745             case SC_SCREENSAVE :
1746                 break ;
1747
1748             case SC_HOTKEY     :
1749                 break ;
1750             }
1751         }
1752
1753         /* We need to pass the message on to the operating system as well */
1754         lRet = DefWindowProc( hWnd, uMsg, wParam, lParam );
1755         break;
1756
1757     default:
1758         /*
1759          * Handle unhandled messages
1760          */
1761         lRet = DefWindowProc( hWnd, uMsg, wParam, lParam );
1762         break;
1763     }
1764
1765     return lRet;
1766 }
1767 #endif
1768
1769 /*** END OF FILE ***/