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

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