git.mutantstargoat.com Git - freeglut/blob - src/mswin/fg_main_mswin.c

   1 /*
   2  * freeglut_main_mswin.c
   3  *
   4  * The Windows-specific mouse cursor related stuff.
   5  *
   6  * Copyright (c) 2012 Stephen J. Baker. All Rights Reserved.
   7  * Written by John F. Fay, <fayjf@sourceforge.net>
   8  * Creation date: Sat Jan 21, 2012
   9  *
  10  * Permission is hereby granted, free of charge, to any person obtaining a
  11  * copy of this software and associated documentation files (the "Software"),
  12  * to deal in the Software without restriction, including without limitation
  13  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  14  * and/or sell copies of the Software, and to permit persons to whom the
  15  * Software is furnished to do so, subject to the following conditions:
  16  *
  17  * The above copyright notice and this permission notice shall be included
  18  * in all copies or substantial portions of the Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  21  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  23  * PAWEL W. OLSZTA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
  24  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  25  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  26  */
  27
  28 #include <GL/freeglut.h>
  29 #include "../fg_internal.h"
  30
  31
  32 extern void fghRedrawWindow ( SFG_Window *window );
  33
  34 extern void fgNewWGLCreateContext( SFG_Window* window );
  35 extern GLboolean fgSetupPixelFormat( SFG_Window* window, GLboolean checkOnly,
  36                                      unsigned char layer_type );
  37
  38 #ifdef WM_TOUCH
  39 typedef BOOL (WINAPI *pGetTouchInputInfo)(HTOUCHINPUT,UINT,PTOUCHINPUT,int);
  40 typedef BOOL (WINAPI *pCloseTouchInputHandle)(HTOUCHINPUT);
  41 static pGetTouchInputInfo fghGetTouchInputInfo = (pGetTouchInputInfo)0xDEADBEEF;
  42 static pCloseTouchInputHandle fghCloseTouchInputHandle = (pCloseTouchInputHandle)0xDEADBEEF;
  43 #endif
  44
  45 #ifdef _WIN32_WCE
  46 typedef struct GXDisplayProperties GXDisplayProperties;
  47 typedef struct GXKeyList GXKeyList;
  48 #include <gx.h>
  49
  50 typedef struct GXKeyList (*GXGETDEFAULTKEYS)(int);
  51 typedef int (*GXOPENINPUT)();
  52
  53 GXGETDEFAULTKEYS GXGetDefaultKeys_ = NULL;
  54 GXOPENINPUT GXOpenInput_ = NULL;
  55
  56 struct GXKeyList gxKeyList;
  57 #endif /* _WIN32_WCE */
  58
  59 /*
  60  * Helper functions for getting client area from the window rect
  61  * and the window rect from the client area given the style of the window
  62  * (or a valid window pointer from which the style can be queried).
  63  */
  64 extern void fghComputeWindowRectFromClientArea_QueryWindow( const SFG_Window *window, RECT *clientRect, BOOL posIsOutside );
  65 extern RECT fghGetClientArea                              ( const SFG_Window *window,                   BOOL wantPosOutside );
  66
  67
  68 void fgPlatformReshapeWindow ( SFG_Window *window, int width, int height )
  69 {
  70     RECT windowRect;
  71
  72     /*
  73      * For windowed mode, get the current position of the
  74      * window and resize taking the size of the frame
  75      * decorations into account.
  76      */
  77
  78     /* "GetWindowRect" returns the pixel coordinates of the outside of the window */
  79     GetWindowRect( window->Window.Handle, &windowRect );
  80
  81     /* Create rect in FreeGLUT format, (X,Y) topleft outside window, WxH of client area */
  82     windowRect.right    = windowRect.left+width;
  83     windowRect.bottom   = windowRect.top+height;
  84
  85     if (window->Parent == NULL)
  86         /* get the window rect from this to feed to SetWindowPos, correct for window decorations */
  87         fghComputeWindowRectFromClientArea_QueryWindow(window,&windowRect,TRUE);
  88     else
  89     {
  90         /* correct rect for position client area of parent window
  91          * (SetWindowPos input for child windows is in coordinates
  92          * relative to the parent's client area).
  93          * Child windows don't have decoration, so no need to correct
  94          * for them.
  95          */
  96         RECT parentRect;
  97         parentRect = fghGetClientArea( window->Parent, FALSE );
  98         windowRect.left   -= parentRect.left;
  99         windowRect.right  -= parentRect.left;
 100         windowRect.top    -= parentRect.top;
 101         windowRect.bottom -= parentRect.top;
 102     }
 103
 104     /* Do the actual resizing */
 105     SetWindowPos( window->Window.Handle,
 106                   HWND_TOP,
 107                   windowRect.left, windowRect.top,
 108                   windowRect.right - windowRect.left,
 109                   windowRect.bottom- windowRect.top,
 110                   SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOSENDCHANGING |
 111                   SWP_NOZORDER
 112     );
 113 }
 114
 115
 116 void fgPlatformDisplayWindow ( SFG_Window *window )
 117 {
 118     RedrawWindow(
 119         window->Window.Handle, NULL, NULL,
 120         RDW_NOERASE | RDW_INTERNALPAINT | RDW_INVALIDATE | RDW_UPDATENOW
 121     );
 122 }
 123
 124
 125 fg_time_t fgPlatformSystemTime ( void )
 126 {
 127 #if defined(_WIN32_WCE)
 128     return GetTickCount();
 129 #else
 130     /* TODO: do this with QueryPerformanceCounter as timeGetTime has
 131      * insufficient resolution (only about 5 ms on system under low load).
 132      * See:
 133      * http://msdn.microsoft.com/en-us/library/windows/desktop/dd757629(v=vs.85).aspx
 134      * Or maybe QueryPerformanceCounter is not a good idea either, see
 135      * http://old.nabble.com/Re%3A-glutTimerFunc-does-not-detect-if-system-time-moved-backward-p33479674.html
 136      * for some other ideas (at bottom)...
 137      */
 138     return timeGetTime();
 139 #endif
 140 }
 141
 142
 143 void fgPlatformSleepForEvents( fg_time_t msec )
 144 {
 145     MsgWaitForMultipleObjects( 0, NULL, FALSE, (DWORD) msec, QS_ALLINPUT );
 146 }
 147
 148
 149 void fgPlatformProcessSingleEvent ( void )
 150 {
 151     MSG stMsg;
 152
 153     FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutMainLoopEvent" );
 154
 155     while( PeekMessage( &stMsg, NULL, 0, 0, PM_NOREMOVE ) )
 156     {
 157         if( GetMessage( &stMsg, NULL, 0, 0 ) == 0 )
 158         {
 159             if( fgState.ActionOnWindowClose == GLUT_ACTION_EXIT )
 160             {
 161                 fgDeinitialize( );
 162                 exit( 0 );
 163             }
 164             else if( fgState.ActionOnWindowClose == GLUT_ACTION_GLUTMAINLOOP_RETURNS )
 165                 fgState.ExecState = GLUT_EXEC_STATE_STOP;
 166
 167             return;
 168         }
 169
 170         TranslateMessage( &stMsg );
 171         DispatchMessage( &stMsg );
 172     }
 173 }
 174
 175
 176
 177 void fgPlatformMainLoopPreliminaryWork ( void )
 178 {
 179     SFG_Window *window = (SFG_Window *)fgStructure.Windows.First ;
 180
 181     /*
 182      * Processing before the main loop:  If there is a window which is open and
 183      * which has a visibility callback, call it.  I know this is an ugly hack,
 184      * but I'm not sure what else to do about it.  Ideally we should leave
 185      * something uninitialized in the create window code and initialize it in
 186      * the main loop, and have that initialization create a "WM_ACTIVATE"
 187      * message.  Then we would put the visibility callback code in the
 188      * "case WM_ACTIVATE" block below.         - John Fay -- 10/24/02
 189      */
 190     while( window )
 191     {
 192         if ( FETCH_WCB( *window, Visibility ) )
 193         {
 194             SFG_Window *current_window = fgStructure.CurrentWindow ;
 195
 196             INVOKE_WCB( *window, Visibility, ( window->State.Visible ) );
 197             fgSetWindow( current_window );
 198         }
 199
 200         window = (SFG_Window *)window->Node.Next ;
 201     }
 202 }
 203
 204
 205 /*
 206  * Determine a GLUT modifer mask based on MS-WINDOWS system info.
 207  */
 208 static int fgPlatformGetModifiers (void)
 209 {
 210     return
 211         ( ( ( GetKeyState( VK_LSHIFT   ) < 0 ) ||
 212             ( GetKeyState( VK_RSHIFT   ) < 0 )) ? GLUT_ACTIVE_SHIFT : 0 ) |
 213         ( ( ( GetKeyState( VK_LCONTROL ) < 0 ) ||
 214             ( GetKeyState( VK_RCONTROL ) < 0 )) ? GLUT_ACTIVE_CTRL  : 0 ) |
 215         ( ( ( GetKeyState( VK_LMENU    ) < 0 ) ||
 216             ( GetKeyState( VK_RMENU    ) < 0 )) ? GLUT_ACTIVE_ALT   : 0 );
 217 }
 218
 219 /*
 220  * The window procedure for handling Win32 events
 221  */
 222 LRESULT CALLBACK fgPlatformWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam,
 223                                        LPARAM lParam )
 224 {
 225     static unsigned char lControl = 0, rControl = 0, lShift = 0,
 226                          rShift = 0, lAlt = 0, rAlt = 0;
 227
 228     SFG_Window* window;
 229     PAINTSTRUCT ps;
 230     LRESULT lRet = 1;
 231
 232     FREEGLUT_INTERNAL_ERROR_EXIT_IF_NOT_INITIALISED ( "Event Handler" ) ;
 233
 234     window = fgWindowByHandle( hWnd );
 235
 236     if ( ( window == NULL ) && ( uMsg != WM_CREATE ) )
 237       return DefWindowProc( hWnd, uMsg, wParam, lParam );
 238
 239     /* printf ( "Window %3d message <%04x> %12d %12d\n", window?window->ID:0,
 240              uMsg, wParam, lParam ); */
 241
 242     /* events only sent to main window. Check if the current window that the mouse
 243        is over is a child window and if so, make sure we call the callback on that
 244        child instead.
 245     */
 246     if (window && window->Children.First)
 247     {
 248         POINT mouse_pos;
 249         SFG_WindowHandleType hwnd;
 250
 251         GetCursorPos( &mouse_pos );
 252         ScreenToClient( window->Window.Handle, &mouse_pos );
 253         hwnd = ChildWindowFromPoint(window->Window.Handle, mouse_pos);
 254         if (hwnd)   /* can be NULL if mouse outside parent by the time we get here */
 255             window = fgWindowByHandle(hwnd);
 256     }
 257
 258     if ( window )
 259     {
 260       fgState.Modifiers = fgPlatformGetModifiers( );
 261
 262       /* Checking for CTRL, ALT, and SHIFT key positions:  Key Down! */
 263       if ( !lControl && GetAsyncKeyState ( VK_LCONTROL ) )
 264       {
 265           INVOKE_WCB    ( *window, Special,
 266                         ( GLUT_KEY_CTRL_L, window->State.MouseX, window->State.MouseY )
 267                       );
 268
 269           lControl = 1;
 270       }
 271
 272       if ( !rControl && GetAsyncKeyState ( VK_RCONTROL ) )
 273       {
 274           INVOKE_WCB ( *window, Special,
 275                        ( GLUT_KEY_CTRL_R, window->State.MouseX, window->State.MouseY )
 276                      );
 277
 278           rControl = 1;
 279       }
 280
 281       if ( !lShift && GetAsyncKeyState ( VK_LSHIFT ) )
 282       {
 283           INVOKE_WCB ( *window, Special,
 284                        ( GLUT_KEY_SHIFT_L, window->State.MouseX, window->State.MouseY )
 285                      );
 286
 287           lShift = 1;
 288       }
 289
 290       if ( !rShift && GetAsyncKeyState ( VK_RSHIFT ) )
 291       {
 292           INVOKE_WCB ( *window, Special,
 293                        ( GLUT_KEY_SHIFT_R, window->State.MouseX, window->State.MouseY )
 294                      );
 295
 296           rShift = 1;
 297       }
 298
 299       if ( !lAlt && GetAsyncKeyState ( VK_LMENU ) )
 300       {
 301           INVOKE_WCB ( *window, Special,
 302                        ( GLUT_KEY_ALT_L, window->State.MouseX, window->State.MouseY )
 303                      );
 304
 305           lAlt = 1;
 306       }
 307
 308       if ( !rAlt && GetAsyncKeyState ( VK_RMENU ) )
 309       {
 310           INVOKE_WCB ( *window, Special,
 311                        ( GLUT_KEY_ALT_R, window->State.MouseX, window->State.MouseY )
 312                      );
 313
 314           rAlt = 1;
 315       }
 316
 317       /* Checking for CTRL, ALT, and SHIFT key positions:  Key Up! */
 318       if ( lControl && !GetAsyncKeyState ( VK_LCONTROL ) )
 319       {
 320           INVOKE_WCB ( *window, SpecialUp,
 321                        ( GLUT_KEY_CTRL_L, window->State.MouseX, window->State.MouseY )
 322                      );
 323
 324           lControl = 0;
 325       }
 326
 327       if ( rControl && !GetAsyncKeyState ( VK_RCONTROL ) )
 328       {
 329           INVOKE_WCB ( *window, SpecialUp,
 330                        ( GLUT_KEY_CTRL_R, window->State.MouseX, window->State.MouseY )
 331                      );
 332
 333           rControl = 0;
 334       }
 335
 336       if ( lShift && !GetAsyncKeyState ( VK_LSHIFT ) )
 337       {
 338           INVOKE_WCB ( *window, SpecialUp,
 339                        ( GLUT_KEY_SHIFT_L, window->State.MouseX, window->State.MouseY )
 340                      );
 341
 342           lShift = 0;
 343       }
 344
 345       if ( rShift && !GetAsyncKeyState ( VK_RSHIFT ) )
 346       {
 347           INVOKE_WCB ( *window, SpecialUp,
 348                        ( GLUT_KEY_SHIFT_R, window->State.MouseX, window->State.MouseY )
 349                      );
 350
 351           rShift = 0;
 352       }
 353
 354       if ( lAlt && !GetAsyncKeyState ( VK_LMENU ) )
 355       {
 356           INVOKE_WCB ( *window, SpecialUp,
 357                        ( GLUT_KEY_ALT_L, window->State.MouseX, window->State.MouseY )
 358                      );
 359
 360           lAlt = 0;
 361       }
 362
 363       if ( rAlt && !GetAsyncKeyState ( VK_RMENU ) )
 364       {
 365           INVOKE_WCB ( *window, SpecialUp,
 366                        ( GLUT_KEY_ALT_R, window->State.MouseX, window->State.MouseY )
 367                      );
 368
 369           rAlt = 0;
 370       }
 371
 372       fgState.Modifiers = INVALID_MODIFIERS;
 373     }
 374
 375     switch( uMsg )
 376     {
 377     case WM_CREATE:
 378         /* The window structure is passed as the creation structure parameter... */
 379         window = (SFG_Window *) (((LPCREATESTRUCT) lParam)->lpCreateParams);
 380         FREEGLUT_INTERNAL_ERROR_EXIT ( ( window != NULL ), "Cannot create window",
 381                                        "fgPlatformWindowProc" );
 382
 383         window->Window.Handle = hWnd;
 384         window->Window.pContext.Device = GetDC( hWnd );
 385         if( window->IsMenu )
 386         {
 387             unsigned int current_DisplayMode = fgState.DisplayMode;
 388             fgState.DisplayMode = GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH;
 389 #if !defined(_WIN32_WCE)
 390             fgSetupPixelFormat( window, GL_FALSE, PFD_MAIN_PLANE );
 391 #endif
 392             fgState.DisplayMode = current_DisplayMode;
 393
 394             if( fgStructure.MenuContext )
 395                 wglMakeCurrent( window->Window.pContext.Device,
 396                                 fgStructure.MenuContext->MContext
 397                 );
 398             else
 399             {
 400                 fgStructure.MenuContext =
 401                     (SFG_MenuContext *)malloc( sizeof(SFG_MenuContext) );
 402                 fgStructure.MenuContext->MContext =
 403                     wglCreateContext( window->Window.pContext.Device );
 404             }
 405
 406             /* window->Window.Context = wglGetCurrentContext ();   */
 407             window->Window.Context = wglCreateContext( window->Window.pContext.Device );
 408         }
 409         else
 410         {
 411 #if !defined(_WIN32_WCE)
 412             fgSetupPixelFormat( window, GL_FALSE, PFD_MAIN_PLANE );
 413 #endif
 414
 415             if( ! fgState.UseCurrentContext )
 416                 window->Window.Context =
 417                     wglCreateContext( window->Window.pContext.Device );
 418             else
 419             {
 420                 window->Window.Context = wglGetCurrentContext( );
 421                 if( ! window->Window.Context )
 422                     window->Window.Context =
 423                         wglCreateContext( window->Window.pContext.Device );
 424             }
 425
 426 #if !defined(_WIN32_WCE)
 427             fgNewWGLCreateContext( window );
 428 #endif
 429         }
 430
 431         window->State.NeedToResize = GL_TRUE;
 432         /* if we used CW_USEDEFAULT (thats a negative value) for the size
 433          * of the window, query the window now for the size at which it
 434          * was created.
 435          */
 436         if( ( window->State.Width < 0 ) || ( window->State.Height < 0 ) )
 437         {
 438             SFG_Window *current_window = fgStructure.CurrentWindow;
 439
 440             fgSetWindow( window );
 441             window->State.Width = glutGet( GLUT_WINDOW_WIDTH );
 442             window->State.Height = glutGet( GLUT_WINDOW_HEIGHT );
 443             fgSetWindow( current_window );
 444         }
 445
 446         ReleaseDC( window->Window.Handle, window->Window.pContext.Device );
 447
 448 #if defined(_WIN32_WCE)
 449         /* Take over button handling */
 450         {
 451             HINSTANCE dxDllLib=LoadLibrary(_T("gx.dll"));
 452             if (dxDllLib)
 453             {
 454                 GXGetDefaultKeys_=(GXGETDEFAULTKEYS)GetProcAddress(dxDllLib, _T("?GXGetDefaultKeys@@YA?AUGXKeyList@@H@Z"));
 455                 GXOpenInput_=(GXOPENINPUT)GetProcAddress(dxDllLib, _T("?GXOpenInput@@YAHXZ"));
 456             }
 457
 458             if(GXOpenInput_)
 459                 (*GXOpenInput_)();
 460             if(GXGetDefaultKeys_)
 461                 gxKeyList = (*GXGetDefaultKeys_)(GX_LANDSCAPEKEYS);
 462         }
 463
 464 #endif /* defined(_WIN32_WCE) */
 465         break;
 466
 467     case WM_SIZE:
 468         /*
 469          * If the window is visible, then it is the user manually resizing it.
 470          * If it is not, then it is the system sending us a dummy resize with
 471          * zero dimensions on a "glutIconifyWindow" call.
 472          */
 473         if( window->State.Visible )
 474         {
 475             window->State.NeedToResize = GL_TRUE;
 476 #if defined(_WIN32_WCE)
 477             window->State.Width  = HIWORD(lParam);
 478             window->State.Height = LOWORD(lParam);
 479 #else
 480             window->State.Width  = LOWORD(lParam);
 481             window->State.Height = HIWORD(lParam);
 482 #endif /* defined(_WIN32_WCE) */
 483         }
 484
 485         break;
 486
 487     case WM_SETFOCUS:
 488 /*        printf("WM_SETFOCUS: %p\n", window ); */
 489         lRet = DefWindowProc( hWnd, uMsg, wParam, lParam );
 490         INVOKE_WCB( *window, Entry, ( GLUT_ENTERED ) );
 491
 492                 UpdateWindow ( hWnd );
 493         break;
 494
 495     case WM_KILLFOCUS:
 496 /*        printf("WM_KILLFOCUS (ismenu: %i): %p\n", window->IsMenu, window ); */
 497         lRet = DefWindowProc( hWnd, uMsg, wParam, lParam );
 498         INVOKE_WCB( *window, Entry, ( GLUT_LEFT ) );
 499
 500         /* If this is a menu that lost focus, see if user either switched
 501            application or FreeGLUT window (if one is running multiple
 502            windows). If so, close menu that lost focus.
 503          */
 504         if( window->IsMenu &&
 505             window->ActiveMenu && window->ActiveMenu->IsActive )
 506         {
 507             SFG_Window* wnd = NULL;
 508             HWND hwnd = GetForegroundWindow();  /* Get window with current focus */
 509             if (hwnd)
 510                 /* See if its one of our windows */
 511                 wnd = fgWindowByHandle(hwnd);
 512
 513             if (!hwnd || !wnd)
 514                 /* User switched to another application*/
 515                 fgDeactivateMenu(window->ActiveMenu->ParentWindow);
 516             else if (
 517                 ( wnd->IsMenu && wnd->ActiveMenu->ParentWindow!=window->ActiveMenu->ParentWindow) ||    /* Make sure we don't kill the menu when trying to enter a submenu */
 518                 (!wnd->IsMenu && wnd!=window->ActiveMenu->ParentWindow)
 519                 )
 520                 /* User switched to another FreeGLUT window */
 521                 fgDeactivateMenu(window->ActiveMenu->ParentWindow);
 522         }
 523
 524         break;
 525
 526 #if 0
 527     case WM_ACTIVATE:
 528         if (LOWORD(wParam) != WA_INACTIVE)
 529         {
 530 /*            printf("WM_ACTIVATE: fgSetCursor( %p, %d)\n", window,
 531                    window->State.Cursor ); */
 532             fgSetCursor( window, window->State.Cursor );
 533         }
 534
 535         lRet = DefWindowProc( hWnd, uMsg, wParam, lParam );
 536         break;
 537 #endif
 538
 539     case WM_SETCURSOR:
 540 /*      printf ( "Cursor event %x %x %x %x\n", window, window->State.Cursor, lParam, wParam ) ; */
 541         if( LOWORD( lParam ) == HTCLIENT )
 542             fgSetCursor ( window, window->State.Cursor ) ;
 543         else
 544             lRet = DefWindowProc( hWnd, uMsg, wParam, lParam );
 545         break;
 546
 547     case WM_SHOWWINDOW:
 548         window->State.Visible = GL_TRUE;
 549         window->State.Redisplay = GL_TRUE;
 550         break;
 551
 552     case WM_PAINT:
 553         /* Turn on the visibility in case it was turned off somehow */
 554         window->State.Visible = GL_TRUE;
 555         BeginPaint( hWnd, &ps );
 556         fghRedrawWindow( window );
 557         EndPaint( hWnd, &ps );
 558         break;
 559
 560     case WM_CLOSE:
 561         fgDestroyWindow ( window );
 562         if ( fgState.ActionOnWindowClose != GLUT_ACTION_CONTINUE_EXECUTION )
 563             PostQuitMessage(0);
 564         break;
 565
 566     case WM_DESTROY:
 567         /*
 568          * The window already got destroyed, so don't bother with it.
 569          */
 570         return 0;
 571
 572     case WM_MOUSEMOVE:
 573     {
 574 #if defined(_WIN32_WCE)
 575         window->State.MouseX = 320-HIWORD( lParam );
 576         window->State.MouseY = LOWORD( lParam );
 577 #else
 578         window->State.MouseX = LOWORD( lParam );
 579         window->State.MouseY = HIWORD( lParam );
 580 #endif /* defined(_WIN32_WCE) */
 581         /* Restrict to [-32768, 32767] to match X11 behaviour       */
 582         /* See comment in "freeglut_developer" mailing list 10/4/04 */
 583         if ( window->State.MouseX > 32767 ) window->State.MouseX -= 65536;
 584         if ( window->State.MouseY > 32767 ) window->State.MouseY -= 65536;
 585
 586         if ( window->ActiveMenu )
 587         {
 588             fgUpdateMenuHighlight( window->ActiveMenu );
 589             break;
 590         }
 591
 592         fgState.Modifiers = fgPlatformGetModifiers( );
 593
 594         if( ( wParam & MK_LBUTTON ) ||
 595             ( wParam & MK_MBUTTON ) ||
 596             ( wParam & MK_RBUTTON ) )
 597             INVOKE_WCB( *window, Motion, ( window->State.MouseX,
 598                                            window->State.MouseY ) );
 599         else
 600             INVOKE_WCB( *window, Passive, ( window->State.MouseX,
 601                                             window->State.MouseY ) );
 602
 603         fgState.Modifiers = INVALID_MODIFIERS;
 604     }
 605     break;
 606
 607     case WM_LBUTTONDOWN:
 608     case WM_MBUTTONDOWN:
 609     case WM_RBUTTONDOWN:
 610     case WM_LBUTTONUP:
 611     case WM_MBUTTONUP:
 612     case WM_RBUTTONUP:
 613     {
 614         GLboolean pressed = GL_TRUE;
 615         int button;
 616
 617 #if defined(_WIN32_WCE)
 618         window->State.MouseX = 320-HIWORD( lParam );
 619         window->State.MouseY = LOWORD( lParam );
 620 #else
 621         window->State.MouseX = LOWORD( lParam );
 622         window->State.MouseY = HIWORD( lParam );
 623 #endif /* defined(_WIN32_WCE) */
 624
 625         /* Restrict to [-32768, 32767] to match X11 behaviour       */
 626         /* See comment in "freeglut_developer" mailing list 10/4/04 */
 627         if ( window->State.MouseX > 32767 ) window->State.MouseX -= 65536;
 628         if ( window->State.MouseY > 32767 ) window->State.MouseY -= 65536;
 629
 630         switch( uMsg )
 631         {
 632         case WM_LBUTTONDOWN:
 633             pressed = GL_TRUE;
 634             button = GLUT_LEFT_BUTTON;
 635             break;
 636         case WM_MBUTTONDOWN:
 637             pressed = GL_TRUE;
 638             button = GLUT_MIDDLE_BUTTON;
 639             break;
 640         case WM_RBUTTONDOWN:
 641             pressed = GL_TRUE;
 642             button = GLUT_RIGHT_BUTTON;
 643             break;
 644         case WM_LBUTTONUP:
 645             pressed = GL_FALSE;
 646             button = GLUT_LEFT_BUTTON;
 647             break;
 648         case WM_MBUTTONUP:
 649             pressed = GL_FALSE;
 650             button = GLUT_MIDDLE_BUTTON;
 651             break;
 652         case WM_RBUTTONUP:
 653             pressed = GL_FALSE;
 654             button = GLUT_RIGHT_BUTTON;
 655             break;
 656         default:
 657             pressed = GL_FALSE;
 658             button = -1;
 659             break;
 660         }
 661
 662 #if !defined(_WIN32_WCE)
 663         if( GetSystemMetrics( SM_SWAPBUTTON ) )
 664         {
 665             if( button == GLUT_LEFT_BUTTON )
 666                 button = GLUT_RIGHT_BUTTON;
 667             else
 668                 if( button == GLUT_RIGHT_BUTTON )
 669                     button = GLUT_LEFT_BUTTON;
 670         }
 671 #endif /* !defined(_WIN32_WCE) */
 672
 673         if( button == -1 )
 674             return DefWindowProc( hWnd, uMsg, lParam, wParam );
 675
 676         /*
 677          * Do not execute the application's mouse callback if a menu
 678          * is hooked to this button.  In that case an appropriate
 679          * private call should be generated.
 680          */
 681         if( fgCheckActiveMenu( window, button, pressed,
 682                                window->State.MouseX, window->State.MouseY ) )
 683             break;
 684
 685         /* Set capture so that the window captures all the mouse messages */
 686         /*
 687          * XXX - Multiple button support:  Under X11, the mouse is not released
 688          * XXX - from the window until all buttons have been released, even if the
 689          * XXX - user presses a button in another window.  This will take more
 690          * XXX - code changes than I am up to at the moment (10/5/04).  The present
 691          * XXX - is a 90 percent solution.
 692          */
 693         if ( pressed == GL_TRUE )
 694           SetCapture ( window->Window.Handle ) ;
 695         else
 696           ReleaseCapture () ;
 697
 698         if( ! FETCH_WCB( *window, Mouse ) )
 699             break;
 700
 701         fgSetWindow( window );
 702         fgState.Modifiers = fgPlatformGetModifiers( );
 703
 704         INVOKE_WCB(
 705             *window, Mouse,
 706             ( button,
 707               pressed ? GLUT_DOWN : GLUT_UP,
 708               window->State.MouseX,
 709               window->State.MouseY
 710             )
 711         );
 712
 713         fgState.Modifiers = INVALID_MODIFIERS;
 714     }
 715     break;
 716
 717     case WM_MOUSEWHEEL:
 718     {
 719         int wheel_number = LOWORD( wParam );
 720         short ticks = ( short )HIWORD( wParam );
 721                 fgState.MouseWheelTicks += ticks;
 722
 723         /*
 724          * XXX Should use WHEEL_DELTA instead of 120
 725          */
 726                 if ( abs ( fgState.MouseWheelTicks ) >= 120 )
 727                 {
 728                         int direction = ( fgState.MouseWheelTicks > 0 ) ? 1 : -1;
 729
 730             if( ! FETCH_WCB( *window, MouseWheel ) &&
 731                 ! FETCH_WCB( *window, Mouse ) )
 732                 break;
 733
 734             fgSetWindow( window );
 735             fgState.Modifiers = fgPlatformGetModifiers( );
 736
 737             /*
 738              * XXX Should use WHEEL_DELTA instead of 120
 739              */
 740             while( abs ( fgState.MouseWheelTicks ) >= 120 )
 741                         {
 742                 if( FETCH_WCB( *window, MouseWheel ) )
 743                     INVOKE_WCB( *window, MouseWheel,
 744                                 ( wheel_number,
 745                                   direction,
 746                                   window->State.MouseX,
 747                                   window->State.MouseY
 748                                 )
 749                     );
 750                 else  /* No mouse wheel, call the mouse button callback twice */
 751                                 {
 752                     /*
 753                      * Map wheel zero to button 3 and 4; +1 to 3, -1 to 4
 754                      *  "    "   one                     +1 to 5, -1 to 6, ...
 755                      *
 756                      * XXX The below assumes that you have no more than 3 mouse
 757                      * XXX buttons.  Sorry.
 758                      */
 759                     int button = wheel_number * 2 + 3;
 760                     if( direction < 0 )
 761                         ++button;
 762                     INVOKE_WCB( *window, Mouse,
 763                                 ( button, GLUT_DOWN,
 764                                   window->State.MouseX, window->State.MouseY )
 765                     );
 766                     INVOKE_WCB( *window, Mouse,
 767                                 ( button, GLUT_UP,
 768                                   window->State.MouseX, window->State.MouseY )
 769                     );
 770                                 }
 771
 772                 /*
 773                  * XXX Should use WHEEL_DELTA instead of 120
 774                  */
 775                                 fgState.MouseWheelTicks -= 120 * direction;
 776                         }
 777
 778             fgState.Modifiers = INVALID_MODIFIERS;
 779                 }
 780     }
 781     break ;
 782
 783     case WM_SYSKEYDOWN:
 784     case WM_KEYDOWN:
 785     {
 786         int keypress = -1;
 787         POINT mouse_pos ;
 788
 789
 790         if( ( fgState.KeyRepeat==GLUT_KEY_REPEAT_OFF || window->State.IgnoreKeyRepeat==GL_TRUE ) && (HIWORD(lParam) & KF_REPEAT) )
 791             break;
 792
 793         /*
 794          * Remember the current modifiers state. This is done here in order
 795          * to make sure the VK_DELETE keyboard callback is executed properly.
 796          */
 797         fgState.Modifiers = fgPlatformGetModifiers( );
 798
 799         GetCursorPos( &mouse_pos );
 800         ScreenToClient( window->Window.Handle, &mouse_pos );
 801
 802         window->State.MouseX = mouse_pos.x;
 803         window->State.MouseY = mouse_pos.y;
 804
 805         /* Convert the Win32 keystroke codes to GLUTtish way */
 806 #       define KEY(a,b) case a: keypress = b; break;
 807
 808         switch( wParam )
 809         {
 810             KEY( VK_F1,     GLUT_KEY_F1        );
 811             KEY( VK_F2,     GLUT_KEY_F2        );
 812             KEY( VK_F3,     GLUT_KEY_F3        );
 813             KEY( VK_F4,     GLUT_KEY_F4        );
 814             KEY( VK_F5,     GLUT_KEY_F5        );
 815             KEY( VK_F6,     GLUT_KEY_F6        );
 816             KEY( VK_F7,     GLUT_KEY_F7        );
 817             KEY( VK_F8,     GLUT_KEY_F8        );
 818             KEY( VK_F9,     GLUT_KEY_F9        );
 819             KEY( VK_F10,    GLUT_KEY_F10       );
 820             KEY( VK_F11,    GLUT_KEY_F11       );
 821             KEY( VK_F12,    GLUT_KEY_F12       );
 822             KEY( VK_PRIOR,  GLUT_KEY_PAGE_UP   );
 823             KEY( VK_NEXT,   GLUT_KEY_PAGE_DOWN );
 824             KEY( VK_HOME,   GLUT_KEY_HOME      );
 825             KEY( VK_END,    GLUT_KEY_END       );
 826             KEY( VK_LEFT,   GLUT_KEY_LEFT      );
 827             KEY( VK_UP,     GLUT_KEY_UP        );
 828             KEY( VK_RIGHT,  GLUT_KEY_RIGHT     );
 829             KEY( VK_DOWN,   GLUT_KEY_DOWN      );
 830             KEY( VK_INSERT, GLUT_KEY_INSERT    );
 831
 832         case VK_LCONTROL:  case VK_RCONTROL:  case VK_CONTROL:
 833         case VK_LSHIFT:    case VK_RSHIFT:    case VK_SHIFT:
 834         case VK_LMENU:     case VK_RMENU:     case VK_MENU:
 835             /* These keypresses and releases are handled earlier in the function */
 836             break;
 837
 838         case VK_DELETE:
 839             /* The delete key should be treated as an ASCII keypress: */
 840             INVOKE_WCB( *window, Keyboard,
 841                         ( 127, window->State.MouseX, window->State.MouseY )
 842             );
 843         }
 844
 845 #if defined(_WIN32_WCE)
 846         if(!(lParam & 0x40000000)) /* Prevent auto-repeat */
 847         {
 848             if(wParam==(unsigned)gxKeyList.vkRight)
 849                 keypress = GLUT_KEY_RIGHT;
 850             else if(wParam==(unsigned)gxKeyList.vkLeft)
 851                 keypress = GLUT_KEY_LEFT;
 852             else if(wParam==(unsigned)gxKeyList.vkUp)
 853                 keypress = GLUT_KEY_UP;
 854             else if(wParam==(unsigned)gxKeyList.vkDown)
 855                 keypress = GLUT_KEY_DOWN;
 856             else if(wParam==(unsigned)gxKeyList.vkA)
 857                 keypress = GLUT_KEY_F1;
 858             else if(wParam==(unsigned)gxKeyList.vkB)
 859                 keypress = GLUT_KEY_F2;
 860             else if(wParam==(unsigned)gxKeyList.vkC)
 861                 keypress = GLUT_KEY_F3;
 862             else if(wParam==(unsigned)gxKeyList.vkStart)
 863                 keypress = GLUT_KEY_F4;
 864         }
 865 #endif
 866
 867         if( keypress != -1 )
 868             INVOKE_WCB( *window, Special,
 869                         ( keypress,
 870                           window->State.MouseX, window->State.MouseY )
 871             );
 872
 873         fgState.Modifiers = INVALID_MODIFIERS;
 874     }
 875     break;
 876
 877     case WM_SYSKEYUP:
 878     case WM_KEYUP:
 879     {
 880         int keypress = -1;
 881         POINT mouse_pos;
 882
 883         /*
 884          * Remember the current modifiers state. This is done here in order
 885          * to make sure the VK_DELETE keyboard callback is executed properly.
 886          */
 887         fgState.Modifiers = fgPlatformGetModifiers( );
 888
 889         GetCursorPos( &mouse_pos );
 890         ScreenToClient( window->Window.Handle, &mouse_pos );
 891
 892         window->State.MouseX = mouse_pos.x;
 893         window->State.MouseY = mouse_pos.y;
 894
 895         /*
 896          * Convert the Win32 keystroke codes to GLUTtish way.
 897          * "KEY(a,b)" was defined under "WM_KEYDOWN"
 898          */
 899
 900         switch( wParam )
 901         {
 902             KEY( VK_F1,     GLUT_KEY_F1        );
 903             KEY( VK_F2,     GLUT_KEY_F2        );
 904             KEY( VK_F3,     GLUT_KEY_F3        );
 905             KEY( VK_F4,     GLUT_KEY_F4        );
 906             KEY( VK_F5,     GLUT_KEY_F5        );
 907             KEY( VK_F6,     GLUT_KEY_F6        );
 908             KEY( VK_F7,     GLUT_KEY_F7        );
 909             KEY( VK_F8,     GLUT_KEY_F8        );
 910             KEY( VK_F9,     GLUT_KEY_F9        );
 911             KEY( VK_F10,    GLUT_KEY_F10       );
 912             KEY( VK_F11,    GLUT_KEY_F11       );
 913             KEY( VK_F12,    GLUT_KEY_F12       );
 914             KEY( VK_PRIOR,  GLUT_KEY_PAGE_UP   );
 915             KEY( VK_NEXT,   GLUT_KEY_PAGE_DOWN );
 916             KEY( VK_HOME,   GLUT_KEY_HOME      );
 917             KEY( VK_END,    GLUT_KEY_END       );
 918             KEY( VK_LEFT,   GLUT_KEY_LEFT      );
 919             KEY( VK_UP,     GLUT_KEY_UP        );
 920             KEY( VK_RIGHT,  GLUT_KEY_RIGHT     );
 921             KEY( VK_DOWN,   GLUT_KEY_DOWN      );
 922             KEY( VK_INSERT, GLUT_KEY_INSERT    );
 923
 924           case VK_LCONTROL:  case VK_RCONTROL:  case VK_CONTROL:
 925           case VK_LSHIFT:    case VK_RSHIFT:    case VK_SHIFT:
 926           case VK_LMENU:     case VK_RMENU:     case VK_MENU:
 927               /* These keypresses and releases are handled earlier in the function */
 928               break;
 929
 930           case VK_DELETE:
 931               /* The delete key should be treated as an ASCII keypress: */
 932               INVOKE_WCB( *window, KeyboardUp,
 933                           ( 127, window->State.MouseX, window->State.MouseY )
 934               );
 935               break;
 936
 937         default:
 938         {
 939 #if !defined(_WIN32_WCE)
 940             BYTE state[ 256 ];
 941             WORD code[ 2 ];
 942
 943             GetKeyboardState( state );
 944
 945             if( ToAscii( (UINT)wParam, 0, state, code, 0 ) == 1 )
 946                 wParam=code[ 0 ];
 947
 948             INVOKE_WCB( *window, KeyboardUp,
 949                         ( (char)wParam,
 950                           window->State.MouseX, window->State.MouseY )
 951             );
 952 #endif /* !defined(_WIN32_WCE) */
 953         }
 954         }
 955
 956         if( keypress != -1 )
 957             INVOKE_WCB( *window, SpecialUp,
 958                         ( keypress,
 959                           window->State.MouseX, window->State.MouseY )
 960             );
 961
 962         fgState.Modifiers = INVALID_MODIFIERS;
 963     }
 964     break;
 965
 966     case WM_SYSCHAR:
 967     case WM_CHAR:
 968     {
 969       if( (fgState.KeyRepeat==GLUT_KEY_REPEAT_OFF || window->State.IgnoreKeyRepeat==GL_TRUE) && (HIWORD(lParam) & KF_REPEAT) )
 970             break;
 971
 972         fgState.Modifiers = fgPlatformGetModifiers( );
 973         INVOKE_WCB( *window, Keyboard,
 974                     ( (char)wParam,
 975                       window->State.MouseX, window->State.MouseY )
 976         );
 977         fgState.Modifiers = INVALID_MODIFIERS;
 978     }
 979     break;
 980
 981     case WM_CAPTURECHANGED:
 982         /* User has finished resizing the window, force a redraw */
 983         INVOKE_WCB( *window, Display, ( ) );
 984
 985         /*lRet = DefWindowProc( hWnd, uMsg, wParam, lParam ); */
 986         break;
 987
 988         /* Other messages that I have seen and which are not handled already */
 989     case WM_SETTEXT:  /* 0x000c */
 990         lRet = DefWindowProc( hWnd, uMsg, wParam, lParam );
 991         /* Pass it on to "DefWindowProc" to set the window text */
 992         break;
 993
 994     case WM_GETTEXT:  /* 0x000d */
 995         /* Ideally we would copy the title of the window into "lParam" */
 996         /* strncpy ( (char *)lParam, "Window Title", wParam );
 997            lRet = ( wParam > 12 ) ? 12 : wParam;  */
 998         /* the number of characters copied */
 999         lRet = DefWindowProc( hWnd, uMsg, wParam, lParam );
1000         break;
1001
1002     case WM_GETTEXTLENGTH:  /* 0x000e */
1003         /* Ideally we would get the length of the title of the window */
1004         lRet = 12;
1005         /* the number of characters in "Window Title\0" (see above) */
1006         break;
1007
1008     case WM_ERASEBKGND:  /* 0x0014 */
1009         lRet = DefWindowProc( hWnd, uMsg, wParam, lParam );
1010         break;
1011
1012 #if !defined(_WIN32_WCE)
1013     case WM_SYNCPAINT:  /* 0x0088 */
1014         /* Another window has moved, need to update this one */
1015         window->State.Redisplay = GL_TRUE;
1016         lRet = DefWindowProc( hWnd, uMsg, wParam, lParam );
1017         /* Help screen says this message must be passed to "DefWindowProc" */
1018         break;
1019
1020     case WM_NCPAINT:  /* 0x0085 */
1021       /* Need to update the border of this window */
1022         lRet = DefWindowProc( hWnd, uMsg, wParam, lParam );
1023         /* Pass it on to "DefWindowProc" to repaint a standard border */
1024         break;
1025
1026     case WM_SYSCOMMAND :  /* 0x0112 */
1027         {
1028           /*
1029            * We have received a system command message.  Try to act on it.
1030            * The commands are passed in through the "wParam" parameter:
1031            * The least significant digit seems to be which edge of the window
1032            * is being used for a resize event:
1033            *     4  3  5
1034            *     1     2
1035            *     7  6  8
1036            * Congratulations and thanks to Richard Rauch for figuring this out..
1037            */
1038             switch ( wParam & 0xfff0 )
1039             {
1040             case SC_SIZE       :
1041                 break ;
1042
1043             case SC_MOVE       :
1044                 break ;
1045
1046             case SC_MINIMIZE   :
1047                 /* User has clicked on the "-" to minimize the window */
1048                 /* Turn off the visibility */
1049                 window->State.Visible = GL_FALSE ;
1050
1051                 break ;
1052
1053             case SC_MAXIMIZE   :
1054                 break ;
1055
1056             case SC_NEXTWINDOW :
1057                 break ;
1058
1059             case SC_PREVWINDOW :
1060                 break ;
1061
1062             case SC_CLOSE      :
1063                 /* Followed very closely by a WM_CLOSE message */
1064                 break ;
1065
1066             case SC_VSCROLL    :
1067                 break ;
1068
1069             case SC_HSCROLL    :
1070                 break ;
1071
1072             case SC_MOUSEMENU  :
1073                 break ;
1074
1075             case SC_KEYMENU    :
1076                 break ;
1077
1078             case SC_ARRANGE    :
1079                 break ;
1080
1081             case SC_RESTORE    :
1082                 break ;
1083
1084             case SC_TASKLIST   :
1085                 break ;
1086
1087             case SC_SCREENSAVE :
1088                 break ;
1089
1090             case SC_HOTKEY     :
1091                 break ;
1092
1093 #if(WINVER >= 0x0400)
1094             case SC_DEFAULT    :
1095                 break ;
1096
1097             case SC_MONITORPOWER    :
1098                 break ;
1099
1100             case SC_CONTEXTHELP    :
1101                 break ;
1102 #endif /* WINVER >= 0x0400 */
1103
1104             default:
1105 #if _DEBUG
1106                 fgWarning( "Unknown wParam type 0x%x", wParam );
1107 #endif
1108                 break;
1109             }
1110         }
1111 #endif /* !defined(_WIN32_WCE) */
1112
1113         /* We need to pass the message on to the operating system as well */
1114         lRet = DefWindowProc( hWnd, uMsg, wParam, lParam );
1115         break;
1116
1117 #ifdef WM_TOUCH
1118         /* handle multi-touch messages */
1119         case WM_TOUCH:
1120         {
1121                 unsigned int numInputs = (unsigned int)wParam;
1122                 unsigned int i = 0;
1123                 TOUCHINPUT* ti = (TOUCHINPUT*)malloc( sizeof(TOUCHINPUT)*numInputs);
1124
1125                 if (fghGetTouchInputInfo == (pGetTouchInputInfo)0xDEADBEEF) {
1126                     fghGetTouchInputInfo = (pGetTouchInputInfo)GetProcAddress(GetModuleHandle("user32"),"GetTouchInputInfo");
1127                     fghCloseTouchInputHandle = (pCloseTouchInputHandle)GetProcAddress(GetModuleHandle("user32"),"CloseTouchInputHandle");
1128                 }
1129
1130                 if (!fghGetTouchInputInfo) {
1131                         free( (void*)ti );
1132                         break;
1133                 }
1134
1135                 if (fghGetTouchInputInfo( (HTOUCHINPUT)lParam, numInputs, ti, sizeof(TOUCHINPUT) )) {
1136                         /* Handle each contact point */
1137                         for (i = 0; i < numInputs; ++i ) {
1138
1139                                 POINT tp;
1140                                 tp.x = TOUCH_COORD_TO_PIXEL(ti[i].x);
1141                                 tp.y = TOUCH_COORD_TO_PIXEL(ti[i].y);
1142                                 ScreenToClient( hWnd, &tp );
1143
1144                                 ti[i].dwID = ti[i].dwID * 2;
1145
1146                                 if (ti[i].dwFlags & TOUCHEVENTF_DOWN) {
1147                                         INVOKE_WCB( *window, MultiEntry,  ( ti[i].dwID, GLUT_ENTERED ) );
1148                                         INVOKE_WCB( *window, MultiButton, ( ti[i].dwID, tp.x, tp.y, 0, GLUT_DOWN ) );
1149                                 } else if (ti[i].dwFlags & TOUCHEVENTF_MOVE) {
1150                                         INVOKE_WCB( *window, MultiMotion, ( ti[i].dwID, tp.x, tp.y ) );
1151                                 } else if (ti[i].dwFlags & TOUCHEVENTF_UP)   {
1152                                         INVOKE_WCB( *window, MultiButton, ( ti[i].dwID, tp.x, tp.y, 0, GLUT_UP ) );
1153                                         INVOKE_WCB( *window, MultiEntry,  ( ti[i].dwID, GLUT_LEFT ) );
1154                                 }
1155                         }
1156                 }
1157                 fghCloseTouchInputHandle((HTOUCHINPUT)lParam);
1158                 free( (void*)ti );
1159                 lRet = 0; /*DefWindowProc( hWnd, uMsg, wParam, lParam );*/
1160                 break;
1161         }
1162 #endif
1163     default:
1164         /* Handle unhandled messages */
1165         lRet = DefWindowProc( hWnd, uMsg, wParam, lParam );
1166         break;
1167     }
1168
1169     return lRet;
1170 }