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