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