4 * The windows message processing methods.
6 * Copyright (c) 1999-2000 Pawel W. Olszta. All Rights Reserved.
7 * Written by Pawel W. Olszta, <olszta@sourceforge.net>
8 * Creation date: Fri Dec 3 1999
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:
17 * The above copyright notice and this permission notice shall be included
18 * in all copies or substantial portions of the Software.
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.
32 #define G_LOG_DOMAIN "freeglut-main"
34 #include "../include/GL/freeglut.h"
35 #include "../include/GL/freeglut_internal.h"
38 * TODO BEFORE THE STABLE RELEASE:
40 * There are some issues concerning window redrawing under X11, and maybe
41 * some events are not handled. The Win32 version lacks some more features,
42 * but seems acceptable for not demanding purposes.
44 * Need to investigate why the X11 version breaks out with an error when
45 * closing a window (using the window manager, not glutDestroyWindow)...
48 /* -- PRIVATE FUNCTIONS ---------------------------------------------------- */
51 * Calls a window's redraw method. This is used when
52 * a redraw is forced by the incoming window messages.
54 static void fghRedrawWindowByHandle
55 #if TARGET_HOST_UNIX_X11
57 #elif TARGET_HOST_WIN32
62 * Find the window we have to redraw...
64 SFG_Window* window = fgWindowByHandle( handle );
65 freeglut_return_if_fail( window != NULL );
68 * Check if there is a display callback hooked to it
70 freeglut_return_if_fail( window->Callbacks.Display != NULL );
73 * Return if the window is not visible
75 freeglut_return_if_fail( window->State.Visible != TRUE );
78 * Set the window as the current one. Calling glutSetWindow()
79 * might seem slow and generally redundant, but it is portable.
81 glutSetWindow( window->ID );
84 * Have the callback executed now. The buffers should
85 * be swapped by the glutSwapBuffers() execution inside
86 * the callback itself.
88 window->Callbacks.Display();
92 * Handle a window configuration change. When no reshape
93 * callback is hooked, the viewport size is updated to
94 * match the new window size.
96 static void fghReshapeWindowByHandle
97 #if TARGET_HOST_UNIX_X11
98 ( Window handle, int width, int height )
99 #elif TARGET_HOST_WIN32
100 ( HWND handle, int width, int height )
104 * Find the window that received the reshape event
106 SFG_Window* window = fgWindowByHandle( handle );
107 freeglut_return_if_fail( window != NULL );
110 * Remember about setting the current window...
112 glutSetWindow( window->ID );
115 * Check if there is a reshape callback hooked
117 if( window->Callbacks.Reshape != NULL )
120 * OKi, have it called immediately
122 window->Callbacks.Reshape( width, height );
127 * Otherwise just resize the viewport
129 glViewport( 0, 0, width, height );
134 * A static helper function to execute display callback for a window
136 static void fghcbDisplayWindow( SFG_Window *window, SFG_Enumerator *enumerator )
138 #if TARGET_HOST_UNIX_X11
140 * Check if there is an idle callback hooked
142 # warning there is a redisplay hack here (see the code commented out)
143 if( (window->Callbacks.Display != NULL) &&
144 /*(window->State.Redisplay == TRUE) &&*/
145 (window->State.Visible == TRUE) )
148 * OKi, this is the case: have the window set as the current one
150 glutSetWindow( window->ID );
153 * Do not exagerate with the redisplaying
155 window->State.Redisplay = FALSE;
158 * And execute the display callback immediately after
160 window->Callbacks.Display();
163 #elif TARGET_HOST_WIN32
166 * Do we need to explicitly resize the window?
168 if( window->State.NeedToResize )
170 glutSetWindow( window->ID );
172 fghReshapeWindowByHandle(
173 window->Window.Handle,
174 glutGet( GLUT_WINDOW_WIDTH ),
175 glutGet( GLUT_WINDOW_HEIGHT )
179 * Never ever do that again:
181 window->State.NeedToResize = FALSE;
185 * This is done in a bit different way under Windows
188 window->Window.Handle, NULL, NULL,
189 RDW_NOERASE | RDW_INTERNALPAINT | RDW_INVALIDATE
195 * Process this window's children (if any)
197 fgEnumSubWindows( window, fghcbDisplayWindow, enumerator );
201 * Make all windows perform a display call
203 static void fghDisplayAll( void )
205 SFG_Enumerator enumerator;
208 * Uses a method very similiar for fgWindowByHandle...
210 enumerator.found = FALSE;
211 enumerator.data = NULL;
214 * Start the enumeration now:
216 fgEnumWindows( fghcbDisplayWindow, &enumerator );
220 * Window enumerator callback to check for the joystick polling code
222 static void fghcbCheckJoystickPolls( SFG_Window *window, SFG_Enumerator *enumerator )
224 double checkTime = fgElapsedTime();
227 * Check if actually need to do the poll for the currently enumerated window:
229 if( window->State.JoystickLastPoll + window->State.JoystickPollRate >= checkTime )
232 * Yeah, that's it. Poll the joystick...
234 fgJoystickPollWindow( window );
237 * ...and reset the polling counters:
239 window->State.JoystickLastPoll = checkTime;
243 * Process this window's children (if any)
245 fgEnumSubWindows( window, fghcbCheckJoystickPolls, enumerator );
249 * Check all windows for joystick polling
251 static void fghCheckJoystickPolls( void )
253 SFG_Enumerator enumerator;
256 * Uses a method very similiar for fgWindowByHandle...
258 enumerator.found = FALSE;
259 enumerator.data = NULL;
262 * Start the enumeration now:
264 fgEnumWindows( fghcbCheckJoystickPolls, &enumerator );
268 * Check the global timers
270 static void fghCheckTimers( void )
272 long checkTime = fgElapsedTime();
273 SFG_Timer *timer, *next;
276 fgListInit(&timedOut);
279 * For every timer that is waiting for triggering
281 for( timer = fgState.Timers.First; timer; timer = next )
283 next = timer->Node.Next;
286 * Check for the timeout:
288 if( timer->TriggerTime <= checkTime )
291 * Add the timer to the timed out timers list
293 fgListRemove( &fgState.Timers, &timer->Node );
294 fgListAppend( &timedOut, &timer->Node );
299 * Now feel free to execute all the hooked and timed out timer callbacks
300 * And delete the timed out timers...
302 while ( (timer = timedOut.First) )
304 if( timer->Callback != NULL )
305 timer->Callback( timer->ID );
306 fgListRemove( &timedOut, &timer->Node );
314 long fgElapsedTime( void )
320 gettimeofday( &now, NULL );
322 elapsed = (now.tv_usec - fgState.Time.Value.tv_usec) / 1000;
323 elapsed += (now.tv_sec - fgState.Time.Value.tv_sec) * 1000;
327 return (timeGetTime() - fgState.Time.Value);
334 void fgError( const char *fmt, ... )
340 fprintf( stderr, "freeglut: ");
341 vfprintf( stderr, fmt, ap );
342 fprintf( stderr, "\n" );
349 void fgWarning( const char *fmt, ... )
355 fprintf( stderr, "freeglut: ");
356 vfprintf( stderr, fmt, ap );
357 fprintf( stderr, "\n" );
362 /* -- INTERFACE FUNCTIONS -------------------------------------------------- */
365 * Enters the FreeGLUT processing loop. Never returns.
367 void FGAPIENTRY glutMainLoop( void )
369 #if TARGET_HOST_UNIX_X11
374 * This code was repeated constantly, so here it goes into a definition:
376 # define GETWINDOW(a) window = fgWindowByHandle( event.a.window );if( window == NULL ) break;
377 # define GETMOUSE(a) window->State.MouseX = event.a.x; window->State.MouseY = event.a.y;
380 * Make sure the display has been created etc.
382 freeglut_assert_ready;
385 * Enter the loop. Iterate as long as there are
386 * any windows in the freeglut structure.
388 while( fgStructure.Windows.First != NULL )
391 * Do we have any event messages pending?
393 if( XPending( fgDisplay.Display ) )
396 * Grab the next event to be processed...
398 XNextEvent( fgDisplay.Display, &event );
401 * Check the event's type
407 * The window creation confirmation
413 * This is sent to confirm the XDestroyWindow call. Ignore it.
419 * Destroy the window when the WM_DELETE_WINDOW message arrives
421 if( (Atom) event.xclient.data.l[ 0 ] == fgDisplay.DeleteWindow )
424 * I wonder if the window still exists ;-)
426 fgDestroyWindow( fgWindowByHandle( event.xclient.window ), TRUE );
432 * A window of ours has been unmapped...
438 * We are too dumb to process partial exposes...
440 if( event.xexpose.count == 0 )
441 fghRedrawWindowByHandle( event.xexpose.window );
444 case ConfigureNotify:
446 * The window gets resized
448 fghReshapeWindowByHandle(
449 event.xconfigure.window,
450 event.xconfigure.width,
451 event.xconfigure.height
457 * Have the client's keyboard knowledge updated (xlib.ps,
458 * page 206, says that's a good thing to do)
460 XRefreshKeyboardMapping( (XMappingEvent *) &event );
463 case VisibilityNotify:
466 * The window's visiblity might have changed
468 GETWINDOW( xvisibility );
471 * Break now if no window status callback has been hooked to that window
473 if( window->Callbacks.WindowStatus == NULL )
477 * We're going to send a callback to a window. Make it current.
479 glutSetWindow( window->ID );
482 * Sending this event, the X server can notify us that the window has just
483 * acquired one of the three possible visibility states: VisibilityUnobscured,
484 * VisibilityPartiallyObscured or VisibilityFullyObscured
486 switch( event.xvisibility.state )
488 case VisibilityUnobscured:
490 * We are fully visible...
492 window->Callbacks.WindowStatus( GLUT_FULLY_RETAINED );
493 window->State.Visible = TRUE;
496 case VisibilityPartiallyObscured:
498 * The window is partially visible
500 window->Callbacks.WindowStatus( GLUT_PARTIALLY_RETAINED );
501 window->State.Visible = TRUE;
504 case VisibilityFullyObscured:
506 * The window is totally obscured
508 window->Callbacks.WindowStatus( GLUT_FULLY_COVERED );
509 window->State.Visible = FALSE;
518 * Mouse is over one of our windows
520 GETWINDOW( xcrossing ); GETMOUSE( xcrossing );
523 * Is there an entry callback hooked to the window?
525 if( window->Callbacks.Entry != NULL )
528 * Yeah. Notify the window about having the mouse cursor over
530 window->Callbacks.Entry( GLUT_ENTERED );
538 * Mouse is no longer over one of our windows
540 GETWINDOW( xcrossing ); GETMOUSE( xcrossing );
543 * Is there an entry callback hooked to the window?
545 if( window->Callbacks.Entry != NULL )
548 * Yeah. Notify the window about having the mouse cursor over
550 window->Callbacks.Entry( GLUT_LEFT );
558 * The mouse cursor was moved...
560 GETWINDOW( xmotion ); GETMOUSE( xmotion );
563 * What kind of a movement was it?
565 if( (event.xmotion.state & Button1Mask) || (event.xmotion.state & Button2Mask) ||
566 (event.xmotion.state & Button3Mask) || (event.xmotion.state & Button4Mask) ||
567 (event.xmotion.state & Button5Mask) )
570 * A mouse button was pressed during the movement...
571 * Is there a motion callback hooked to the window?
573 if( window->Callbacks.Motion != NULL )
576 * Yup. Have it executed immediately
578 window->Callbacks.Motion( event.xmotion.x, event.xmotion.y );
584 * Otherwise it was a passive movement...
586 if( window->Callbacks.Passive != NULL )
589 * That's right, and there is a passive callback, too.
591 window->Callbacks.Passive( event.xmotion.x, event.xmotion.y );
603 * A mouse button has been pressed or released. Traditionally,
604 * break if the window was found within the freeglut structures.
606 GETWINDOW( xbutton ); GETMOUSE( xbutton );
609 * GLUT API assumes that you can't have more than three mouse buttons, so:
611 switch( event.xbutton.button )
614 * WARNING: this might be wrong, if we only have two mouse buttons,
615 * Button2 might mean the right button, isn't that right?
617 case Button1: button = GLUT_LEFT_BUTTON; break;
618 case Button2: button = GLUT_MIDDLE_BUTTON; break;
619 case Button3: button = GLUT_RIGHT_BUTTON; break;
620 default: button = -1; break;
624 * Skip the unwanted mouse buttons...
630 * Do not execute the callback if a menu is hooked to this key.
631 * In that case an appropriate private call should be generated
633 if( window->Menu[ button ] != NULL )
636 * Set the current window
638 glutSetWindow( window->ID );
640 if( event.type == ButtonPress )
643 * Activate the appropriate menu structure...
645 fgActivateMenu( button );
650 * There are two general cases generated when a menu button
651 * is released -- it can provoke a menu call (when released
652 * over a menu area) or just deactivate the menu (when released
653 * somewhere else). Unfortunately, both cases must be checked
654 * recursively due to the submenu possibilities.
656 fgDeactivateMenu( button );
662 * Check if there is a mouse callback hooked to the window
664 if( window->Callbacks.Mouse == NULL )
668 * Set the current window
670 glutSetWindow( window->ID );
673 * Remember the current modifiers state
675 window->State.Modifiers = event.xbutton.state;
678 * Finally execute the mouse callback
680 window->Callbacks.Mouse(
682 event.type == ButtonPress ? GLUT_DOWN : GLUT_UP,
688 * Trash the modifiers state
690 window->State.Modifiers = 0xffffffff;
697 * A key has been pressed, find the window that had the focus:
699 GETWINDOW( xkey ); GETMOUSE( xkey );
702 * Is there a keyboard/special callback hooked for this window?
704 if( (window->Callbacks.Keyboard != NULL) || (window->Callbacks.Special != NULL) )
706 XComposeStatus composeStatus;
707 char asciiCode[ 32 ];
712 * Check for the ASCII/KeySym codes associated with the event:
714 len = XLookupString( &event.xkey, asciiCode, sizeof(asciiCode), &keySym, &composeStatus );
717 * Get ready to calling the keyboard/special callbacks
719 glutSetWindow( window->ID );
722 * GLUT API tells us to have two separate callbacks...
727 * ...one for the ASCII translateable keypresses...
729 if( window->Callbacks.Keyboard != NULL )
732 * Remember the current modifiers state
734 window->State.Modifiers = event.xkey.state;
737 * Execute the callback
739 window->Callbacks.Keyboard( asciiCode[ 0 ], event.xkey.x, event.xkey.y );
742 * Trash the modifiers state
744 window->State.Modifiers = 0xffffffff;
752 * ...and one for all the others, which need to be translated to GLUT_KEY_Xs...
757 * First the function keys come:
759 case XK_F1: special = GLUT_KEY_F1; break;
760 case XK_F2: special = GLUT_KEY_F2; break;
761 case XK_F3: special = GLUT_KEY_F3; break;
762 case XK_F4: special = GLUT_KEY_F4; break;
763 case XK_F5: special = GLUT_KEY_F5; break;
764 case XK_F6: special = GLUT_KEY_F6; break;
765 case XK_F7: special = GLUT_KEY_F7; break;
766 case XK_F8: special = GLUT_KEY_F8; break;
767 case XK_F9: special = GLUT_KEY_F9; break;
768 case XK_F10: special = GLUT_KEY_F10; break;
769 case XK_F11: special = GLUT_KEY_F11; break;
770 case XK_F12: special = GLUT_KEY_F12; break;
773 * Then the arrows and stuff:
775 case XK_Left: special = GLUT_KEY_LEFT; break;
776 case XK_Right: special = GLUT_KEY_RIGHT; break;
777 case XK_Up: special = GLUT_KEY_UP; break;
778 case XK_Down: special = GLUT_KEY_DOWN; break;
782 * Execute the callback (if one has been specified),
783 * given that the special code seems to be valid...
785 if( (window->Callbacks.Special != NULL) && (special != -1) )
788 * Remember the current modifiers state
790 window->State.Modifiers = event.xkey.state;
792 window->Callbacks.Special( special, event.xkey.x, event.xkey.y );
795 * Trash the modifiers state
797 window->State.Modifiers = 0xffffffff;
808 * Have all the timers checked.
813 * Poll the joystick and notify all windows that want to be notified...
815 fghCheckJoystickPolls();
818 * No messages in the queue, which means we are idling...
820 if( fgState.IdleCallback != NULL )
821 fgState.IdleCallback();
824 * Remember about displaying all the windows that have
825 * been marked for a redisplay (possibly in the idle call):
831 #elif TARGET_HOST_WIN32
833 GLboolean bLoop = TRUE;
837 * The windows main loop is considerably smaller
841 if( PeekMessage( &stMsg, NULL, 0, 0, PM_NOREMOVE ) )
844 * Grab the message now, checking for WM_QUIT
846 if( GetMessage( &stMsg, NULL, 0, 0 ) == 0 )
850 * Translate virtual-key messages and send them to the window...
852 TranslateMessage( &stMsg );
853 DispatchMessage( &stMsg );
858 * Have all the timers checked.
863 * Poll the joystick and notify all windows that want to be notified...
865 fghCheckJoystickPolls();
868 * No messages in the queue, which means we are idling...
870 if( fgState.IdleCallback != NULL )
871 fgState.IdleCallback();
874 * Remember about displaying all the windows that have
875 * been marked for a redisplay (possibly in the idle call):
880 * We need to terminate the main loop if no windows are left
882 bLoop = (g_list_length( fgStructure.Windows ) != 0);
889 * When this loop terminates, destroy the display, state and structure
890 * of a freeglut session, so that another glutInit() call can happen
896 * The window procedure for handling Win32 events
898 #if TARGET_HOST_WIN32
899 LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
901 SFG_Window* window = fgWindowByHandle( hWnd );
905 # define assert_window_registered if( window == NULL ) return( DefWindowProc( hWnd, uMsg, wParam, lParam ) );
908 * Check what type of message are we receiving
914 * The window structure is passed as the creation structure paramter...
916 window = (SFG_Window *) (((LPCREATESTRUCT) lParam)->lpCreateParams);
917 assert( window != NULL );
920 * We can safely store the window's handle now:
922 window->Window.Handle = hWnd;
925 * Get the window's device context
927 window->Window.Device = GetDC( hWnd );
930 * Setup the pixel format of our window
932 fgSetupPixelFormat( window, FALSE );
935 * Create the OpenGL rendering context now
937 window->Window.Context = wglCreateContext( window->Window.Device );
940 * Still, we'll be needing to explicitly resize the window
942 window->State.NeedToResize = TRUE;
945 * Finally, have the window's device context released
947 ReleaseDC( window->Window.Handle, window->Window.Device );
952 * We got resized... But check if the window has been already added...
954 fghReshapeWindowByHandle( hWnd, LOWORD(lParam), HIWORD(lParam) );
959 * Start the painting job
961 BeginPaint( hWnd, &ps );
964 * Call the engine's main frame drawing method
966 fghRedrawWindowByHandle( hWnd );
969 * End the painting job, release the device context
971 EndPaint( hWnd, &ps );
976 * Make sure we don't close a window with current context active
978 if( fgStructure.Window == window )
980 wglMakeCurrent( NULL, NULL );
981 wglDeleteContext( window->Window.Context );
985 * Proceed with the window destruction
987 DestroyWindow( window->Window.Handle );
992 * The window already got destroyed, so forget about it's existence:
994 fgDestroyWindow( window, FALSE );
999 assert_window_registered;
1002 * The mouse cursor has moved. Remember the new mouse cursor's position
1004 window->State.MouseX = LOWORD( lParam );
1005 window->State.MouseY = HIWORD( lParam );
1008 * Fallback if there's an active menu hooked to this window
1010 if( window->MenuActive[ 0 ] || window->MenuActive[ 1 ] || window->MenuActive[ 2 ] )
1014 * Remember the current modifiers state.
1016 window->State.Modifiers =
1017 (GetKeyState( VK_LSHIFT ) || GetKeyState( VK_RSHIFT )) ? GLUT_ACTIVE_SHIFT : 0 |
1018 (GetKeyState( VK_LCONTROL ) || GetKeyState( VK_RCONTROL )) ? GLUT_ACTIVE_CTRL : 0 |
1019 (GetKeyState( VK_LMENU ) || GetKeyState( VK_RMENU )) ? GLUT_ACTIVE_ALT : 0;
1022 * Check if any of the mouse buttons is pressed...
1024 if( (wParam & MK_LBUTTON) || (wParam & MK_MBUTTON) || (wParam & MK_RBUTTON) )
1027 * Yeah, indeed. We need to use the motion callback then:
1029 if( window->Callbacks.Motion != NULL )
1032 * Make sure the current window is set...
1034 glutSetWindow( window->ID );
1037 * Execute the active mouse motion callback now
1039 window->Callbacks.Motion( window->State.MouseX, window->State.MouseY );
1045 * All mouse buttons are up, execute the passive mouse motion callback
1047 if( window->Callbacks.Passive != NULL )
1050 * Make sure the current window is set
1052 glutSetWindow( window->ID );
1055 * Execute the passive mouse motion callback
1057 window->Callbacks.Passive( window->State.MouseX, window->State.MouseY );
1062 * Thrash the current modifiers state now
1064 window->State.Modifiers = 0xffffffff;
1068 case WM_LBUTTONDOWN:
1069 case WM_MBUTTONDOWN:
1070 case WM_RBUTTONDOWN:
1075 GLboolean pressed = TRUE;
1079 * A mouse button has been pressed *or* released. Again, break off
1080 * if the message was not directed towards a freeglut window...
1082 assert_window_registered;
1085 * The mouse cursor has moved. Remember the new mouse cursor's position
1087 window->State.MouseX = LOWORD( lParam );
1088 window->State.MouseY = HIWORD( lParam );
1091 * We're curious about the GLUT API button name...
1095 case WM_LBUTTONDOWN: pressed = TRUE; button = GLUT_LEFT_BUTTON; break;
1096 case WM_MBUTTONDOWN: pressed = TRUE; button = GLUT_MIDDLE_BUTTON; break;
1097 case WM_RBUTTONDOWN: pressed = TRUE; button = GLUT_RIGHT_BUTTON; break;
1098 case WM_LBUTTONUP: pressed = FALSE; button = GLUT_LEFT_BUTTON; break;
1099 case WM_MBUTTONUP: pressed = FALSE; button = GLUT_MIDDLE_BUTTON; break;
1100 case WM_RBUTTONUP: pressed = FALSE; button = GLUT_RIGHT_BUTTON; break;
1101 default: pressed = FALSE; button = -1; break;
1105 * The left and right mouse buttons might have been swapped...
1107 if( GetSystemMetrics( SM_SWAPBUTTON ) )
1108 if( button == GLUT_LEFT_BUTTON ) button = GLUT_RIGHT_BUTTON;
1109 else if( button == GLUT_RIGHT_BUTTON ) button = GLUT_LEFT_BUTTON;
1112 * Hey, what's up with you?
1115 return( DefWindowProc( hWnd, uMsg, lParam, wParam ) );
1118 * Do not execute the callback if a menu is hooked to this key.
1119 * In that case an appropriate private call should be generated
1121 if( window->Menu[ button ] != NULL )
1124 * Set the current window
1126 glutSetWindow( window->ID );
1128 if( pressed == TRUE )
1131 * Activate the appropriate menu structure...
1133 fgActivateMenu( button );
1138 * There are two general cases generated when a menu button
1139 * is released -- it can provoke a menu call (when released
1140 * over a menu area) or just deactivate the menu (when released
1141 * somewhere else). Unfortunately, both cases must be checked
1142 * recursively due to the submenu possibilities.
1144 fgDeactivateMenu( button );
1150 * Check if there is a mouse callback hooked to the window
1152 if( window->Callbacks.Mouse == NULL )
1156 * Set the current window
1158 glutSetWindow( window->ID );
1161 * Remember the current modifiers state.
1163 window->State.Modifiers =
1164 (GetKeyState( VK_LSHIFT ) || GetKeyState( VK_RSHIFT )) ? GLUT_ACTIVE_SHIFT : 0 |
1165 (GetKeyState( VK_LCONTROL ) || GetKeyState( VK_RCONTROL )) ? GLUT_ACTIVE_CTRL : 0 |
1166 (GetKeyState( VK_LMENU ) || GetKeyState( VK_RMENU )) ? GLUT_ACTIVE_ALT : 0;
1169 * Finally execute the mouse callback
1171 window->Callbacks.Mouse(
1173 pressed == TRUE ? GLUT_DOWN : GLUT_UP,
1174 window->State.MouseX,
1175 window->State.MouseY
1179 * Trash the modifiers state
1181 window->State.Modifiers = 0xffffffff;
1191 * First of all, make sure that there is a window to be notified of this
1193 assert_window_registered;
1196 * Ignore the automatic key repetition if needed:
1198 if( fgState.IgnoreKeyRepeat && (lParam & KF_REPEAT) )
1202 * Remember the current modifiers state. This is done here in order
1203 * to make sure the VK_DELETE keyboard callback is executed properly.
1205 window->State.Modifiers =
1206 (GetKeyState( VK_LSHIFT ) || GetKeyState( VK_RSHIFT )) ? GLUT_ACTIVE_SHIFT : 0 |
1207 (GetKeyState( VK_LCONTROL ) || GetKeyState( VK_RCONTROL )) ? GLUT_ACTIVE_CTRL : 0 |
1208 (GetKeyState( VK_LMENU ) || GetKeyState( VK_RMENU )) ? GLUT_ACTIVE_ALT : 0;
1211 * Convert the Win32 keystroke codes to GLUTtish way
1213 # define KEY(a,b) case a: keypress = b; break;
1218 * Most of the special characters can be handled automagically...
1220 KEY( VK_F1, GLUT_KEY_F1 ); KEY( VK_F2, GLUT_KEY_F2 );
1221 KEY( VK_F3, GLUT_KEY_F3 ); KEY( VK_F4, GLUT_KEY_F4 );
1222 KEY( VK_F5, GLUT_KEY_F5 ); KEY( VK_F6, GLUT_KEY_F6 );
1223 KEY( VK_F7, GLUT_KEY_F7 ); KEY( VK_F8, GLUT_KEY_F8 );
1224 KEY( VK_F9, GLUT_KEY_F9 ); KEY( VK_F10, GLUT_KEY_F10 );
1225 KEY( VK_F11, GLUT_KEY_F11 ); KEY( VK_F12, GLUT_KEY_F12 );
1226 KEY( VK_PRIOR, GLUT_KEY_PAGE_UP ); KEY( VK_NEXT, GLUT_KEY_PAGE_DOWN );
1227 KEY( VK_HOME, GLUT_KEY_HOME ); KEY( VK_END, GLUT_KEY_END );
1228 KEY( VK_LEFT, GLUT_KEY_LEFT ); KEY( VK_UP, GLUT_KEY_UP );
1229 KEY( VK_RIGHT, GLUT_KEY_RIGHT ); KEY( VK_DOWN, GLUT_KEY_DOWN );
1230 KEY( VK_INSERT, GLUT_KEY_INSERT );
1233 * ...yet there is a small exception we need to have handled...
1237 * The delete key should be treated as an ASCII keypress:
1239 if( window->Callbacks.Keyboard != NULL )
1240 window->Callbacks.Keyboard( 127, window->State.MouseX, window->State.MouseY );
1244 * Execute the special callback, if present, given the conversion was a success:
1246 if( (keypress != -1) && (window->Callbacks.Special != NULL) )
1249 * Have the special callback executed:
1251 window->Callbacks.Special( keypress, window->State.MouseX, window->State.MouseY );
1255 * Thrash the modifiers register now
1257 window->State.Modifiers = 0xffffffff;
1265 * First of all, make sure that there is a window to be notified of this
1267 assert_window_registered;
1270 * Ignore the automatic key repetition if needed:
1272 if( fgState.IgnoreKeyRepeat && (lParam & KF_REPEAT) )
1276 * Clear to go with the keyboard callback, if registered:
1278 if( window->Callbacks.Keyboard != NULL )
1281 * Remember the current modifiers state
1283 window->State.Modifiers =
1284 (GetKeyState( VK_LSHIFT ) || GetKeyState( VK_RSHIFT )) ? GLUT_ACTIVE_SHIFT : 0 |
1285 (GetKeyState( VK_LCONTROL ) || GetKeyState( VK_RCONTROL )) ? GLUT_ACTIVE_CTRL : 0 |
1286 (GetKeyState( VK_LMENU ) || GetKeyState( VK_RMENU )) ? GLUT_ACTIVE_ALT : 0;
1289 * Have the special callback executed:
1291 window->Callbacks.Keyboard( wParam, window->State.MouseX, window->State.MouseY );
1294 * Thrash the modifiers register now
1296 window->State.Modifiers = 0xffffffff;
1303 * Handle unhandled messages
1305 lRet = DefWindowProc( hWnd, uMsg, wParam, lParam );
1313 /*** END OF FILE ***/