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