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