fc8774f42985091cfdd71e063bdcc1bcd0a9e722
[blender-staging.git] / intern / ghost / intern / GHOST_SystemWin32.cpp
1 /**
2  * $Id$
3  * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License
7  * as published by the Free Software Foundation; either version 2
8  * of the License, or (at your option) any later version. The Blender
9  * Foundation also sells licenses for use in proprietary software under
10  * the Blender License.  See http://www.blender.org/BL/ for information
11  * about this.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software Foundation,
20  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
21  *
22  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
23  * All rights reserved.
24  *
25  * The Original Code is: all of this file.
26  *
27  * Contributor(s): none yet.
28  *
29  * ***** END GPL/BL DUAL LICENSE BLOCK *****
30  */
31
32 /**
33
34  * $Id$
35  * Copyright (C) 2001 NaN Technologies B.V.
36  * @author      Maarten Gribnau
37  * @date        May 7, 2001
38  */
39
40 #ifdef HAVE_CONFIG_H
41 #include <config.h>
42 #endif
43
44 #pragma warning (disable:4786) // get rid of stupid stl-visual compiler debug warning
45
46 #include "GHOST_SystemWin32.h"
47
48 /*
49  * According to the docs the mouse wheel message is supported from windows 98 
50  * upwards. Leaving WINVER at default value, the WM_MOUSEWHEEL message and the 
51  * wheel detent value are undefined.
52  */
53 #ifndef WM_MOUSEWHEEL
54 #define WM_MOUSEWHEEL 0x020A
55 #endif // WM_MOUSEWHEEL
56 #ifndef WHEEL_DELTA
57 #define WHEEL_DELTA 120 /* Value for rolling one detent, (old convention! MS changed it) */
58 #endif // WHEEL_DELTA
59
60
61 #include "GHOST_Debug.h"
62 #include "GHOST_DisplayManagerWin32.h"
63 #include "GHOST_EventButton.h"
64 #include "GHOST_EventCursor.h"
65 #include "GHOST_EventKey.h"
66 #include "GHOST_EventWheel.h"
67 #include "GHOST_TimerTask.h"
68 #include "GHOST_TimerManager.h"
69 #include "GHOST_WindowManager.h"
70 #include "GHOST_WindowWin32.h"
71
72 // Key code values not found in winuser.h
73 #ifndef VK_MINUS
74 #define VK_MINUS 0xBD
75 #endif // VK_MINUS
76 #ifndef VK_SEMICOLON
77 #define VK_SEMICOLON 0xBA
78 #endif // VK_SEMICOLON
79 #ifndef VK_PERIOD
80 #define VK_PERIOD 0xBE
81 #endif // VK_PERIOD
82 #ifndef VK_COMMA
83 #define VK_COMMA 0xBC
84 #endif // VK_COMMA
85 #ifndef VK_QUOTE
86 #define VK_QUOTE 0xDE
87 #endif // VK_QUOTE
88 #ifndef VK_BACK_QUOTE
89 #define VK_BACK_QUOTE 0xC0
90 #endif // VK_BACK_QUOTE
91 #ifndef VK_SLASH
92 #define VK_SLASH 0xBF
93 #endif // VK_SLASH
94 #ifndef VK_BACK_SLASH
95 #define VK_BACK_SLASH 0xDC
96 #endif // VK_BACK_SLASH
97 #ifndef VK_EQUALS
98 #define VK_EQUALS 0xBB
99 #endif // VK_EQUALS
100 #ifndef VK_OPEN_BRACKET
101 #define VK_OPEN_BRACKET 0xDB
102 #endif // VK_OPEN_BRACKET
103 #ifndef VK_CLOSE_BRACKET
104 #define VK_CLOSE_BRACKET 0xDD
105 #endif // VK_CLOSE_BRACKET
106 #ifndef VK_GR_LESS
107 #define VK_GR_LESS 0xE2
108 #endif // VK_GR_LESS
109
110
111 GHOST_SystemWin32::GHOST_SystemWin32()
112 : m_hasPerformanceCounter(false), m_freq(0), m_start(0),
113   m_seperateLeftRight(false),
114   m_seperateLeftRightInitialized(false)
115 {
116         m_displayManager = new GHOST_DisplayManagerWin32 ();
117         GHOST_ASSERT(m_displayManager, "GHOST_SystemWin32::GHOST_SystemWin32(): m_displayManager==0\n");
118         m_displayManager->initialize();
119 }
120
121 GHOST_SystemWin32::~GHOST_SystemWin32()
122 {
123 }
124
125
126 GHOST_TUns64 GHOST_SystemWin32::getMilliSeconds() const
127 {
128         // Hardware does not support high resolution timers. We will use GetTickCount instead then.
129         if (!m_hasPerformanceCounter) {
130                 return ::GetTickCount();
131         }
132
133         // Retrieve current count
134         __int64 count = 0;
135         ::QueryPerformanceCounter((LARGE_INTEGER*)&count);
136
137         // Calculate the time passed since system initialization.
138         __int64 delta = 1000*(count-m_start);
139
140         GHOST_TUns64 t = (GHOST_TUns64)(delta/m_freq);
141         return t; 
142 }
143
144
145 GHOST_TUns8 GHOST_SystemWin32::getNumDisplays() const
146 {
147         GHOST_ASSERT(m_displayManager, "GHOST_SystemWin32::getNumDisplays(): m_displayManager==0\n");
148         GHOST_TUns8 numDisplays;
149         m_displayManager->getNumDisplays(numDisplays);
150         return numDisplays;
151 }
152
153
154 void GHOST_SystemWin32::getMainDisplayDimensions(GHOST_TUns32& width, GHOST_TUns32& height) const
155 {
156         width = ::GetSystemMetrics(SM_CXSCREEN);
157         height= ::GetSystemMetrics(SM_CYSCREEN);
158 }
159
160
161 GHOST_IWindow* GHOST_SystemWin32::createWindow(
162         const STR_String& title, 
163         GHOST_TInt32 left, GHOST_TInt32 top, GHOST_TUns32 width, GHOST_TUns32 height,
164         GHOST_TWindowState state, GHOST_TDrawingContextType type,
165         bool stereoVisual)
166 {
167         GHOST_Window* window = 0;
168         window = new GHOST_WindowWin32 (title, left, top, width, height, state, type, stereoVisual);
169         if (window) {
170                 if (window->getValid()) {
171                         // Store the pointer to the window
172 //                      if (state != GHOST_kWindowStateFullScreen) {
173                                 m_windowManager->addWindow(window);
174 //                      }
175                 }
176                 else {
177                         delete window;
178                         window = 0;
179                 }
180         }
181         return window;
182 }
183
184
185 bool GHOST_SystemWin32::processEvents(bool waitForEvent)
186 {
187         MSG msg;
188         bool anyProcessed = false;
189
190         do {
191                 GHOST_TimerManager* timerMgr = getTimerManager();
192
193                 if (waitForEvent && !::PeekMessage(&msg, 0, 0, 0, PM_NOREMOVE)) {
194 #if 1
195                         ::Sleep(1);
196 #else
197                         GHOST_TUns64 next = timerMgr->nextFireTime();
198                         
199                         if (next == GHOST_kFireTimeNever) {
200                                 ::WaitMessage();
201                         } else {
202                                 ::SetTimer(NULL, 0, next - getMilliSeconds(), NULL);
203                                 ::WaitMessage();
204                                 ::KillTimer(NULL, 0);
205                         }
206 #endif
207                 }
208
209                 if (timerMgr->fireTimers(getMilliSeconds())) {
210                         anyProcessed = true;
211                 }
212
213                 // Process all the events waiting for us
214                 while (::PeekMessage(&msg, 0, 0, 0, PM_REMOVE) != 0) {
215                         ::TranslateMessage(&msg);
216                         ::DispatchMessage(&msg);
217                         anyProcessed = true;
218                 }
219         } while (waitForEvent && !anyProcessed);
220
221         return anyProcessed;
222 }
223
224
225 GHOST_TSuccess GHOST_SystemWin32::getCursorPosition(GHOST_TInt32& x, GHOST_TInt32& y) const
226 {
227         POINT point;
228         bool success = ::GetCursorPos(&point) == TRUE;
229         x = point.x;
230         y = point.y;
231         return GHOST_kSuccess;
232 }
233
234
235 GHOST_TSuccess GHOST_SystemWin32::setCursorPosition(GHOST_TInt32 x, GHOST_TInt32 y) const
236 {
237         return ::SetCursorPos(x, y) == TRUE ? GHOST_kSuccess : GHOST_kFailure;
238 }
239
240
241 GHOST_TSuccess GHOST_SystemWin32::getModifierKeys(GHOST_ModifierKeys& keys) const
242 {
243         /*
244         GetKeyState and GetAsyncKeyState only work with Win95, Win98, NT4,
245         Terminal Server and Windows 2000.
246         But on WinME it always returns zero. These two functions are simply
247         skipped by Millenium Edition!
248
249         Official explanation from Microsoft:
250         Intentionally disabled.
251         It didn't work all that well on some newer hardware, and worked less 
252         well with the passage of time, so it was fully disabled in ME.
253         */
254         if (m_seperateLeftRight && m_seperateLeftRightInitialized) {
255                 bool down = HIBYTE(::GetKeyState(VK_LSHIFT)) != 0;
256                 keys.set(GHOST_kModifierKeyLeftShift, down);
257                 down = HIBYTE(::GetKeyState(VK_RSHIFT)) != 0;
258                 keys.set(GHOST_kModifierKeyRightShift, down);
259                 down = HIBYTE(::GetKeyState(VK_LMENU)) != 0;
260                 keys.set(GHOST_kModifierKeyLeftAlt, down);
261                 down = HIBYTE(::GetKeyState(VK_RMENU)) != 0;
262                 keys.set(GHOST_kModifierKeyRightAlt, down);
263                 down = HIBYTE(::GetKeyState(VK_LCONTROL)) != 0;
264                 keys.set(GHOST_kModifierKeyLeftControl, down);
265                 down = HIBYTE(::GetKeyState(VK_RCONTROL)) != 0;
266                 keys.set(GHOST_kModifierKeyRightControl, down);
267         }
268         else {
269                 bool down = HIBYTE(::GetKeyState(VK_SHIFT)) != 0;
270                 keys.set(GHOST_kModifierKeyLeftShift, down);
271                 keys.set(GHOST_kModifierKeyRightShift, down);
272                 down = HIBYTE(::GetKeyState(VK_MENU)) != 0;
273                 keys.set(GHOST_kModifierKeyLeftAlt, down);
274                 keys.set(GHOST_kModifierKeyRightAlt, down);
275                 down = HIBYTE(::GetKeyState(VK_CONTROL)) != 0;
276                 keys.set(GHOST_kModifierKeyLeftControl, down);
277                 keys.set(GHOST_kModifierKeyRightControl, down);
278         }
279         return GHOST_kSuccess;
280 }
281
282
283 GHOST_TSuccess GHOST_SystemWin32::getButtons(GHOST_Buttons& buttons) const
284 {
285         /* Check for swapped buttons (left-handed mouse buttons)
286          * GetAsyncKeyState() will give back the state of the physical mouse buttons.
287          */
288         bool swapped = ::GetSystemMetrics(SM_SWAPBUTTON) == TRUE;
289
290         bool down = HIBYTE(::GetKeyState(VK_LBUTTON)) != 0;
291         buttons.set(swapped ? GHOST_kButtonMaskRight : GHOST_kButtonMaskLeft, down);
292
293         down = HIBYTE(::GetKeyState(VK_MBUTTON)) != 0;
294         buttons.set(GHOST_kButtonMaskMiddle, down);
295
296         down = HIBYTE(::GetKeyState(VK_RBUTTON)) != 0;
297         buttons.set(swapped ? GHOST_kButtonMaskLeft : GHOST_kButtonMaskRight, down);
298         return GHOST_kSuccess;
299 }
300
301
302 GHOST_TSuccess GHOST_SystemWin32::init()
303 {
304         GHOST_TSuccess success = GHOST_System::init();
305
306         // Determine whether this system has a high frequency performance counter. */
307         m_hasPerformanceCounter = ::QueryPerformanceFrequency((LARGE_INTEGER*)&m_freq) == TRUE;
308         if (m_hasPerformanceCounter) {
309                 GHOST_PRINT("GHOST_SystemWin32::init: High Frequency Performance Timer available\n")
310                 ::QueryPerformanceCounter((LARGE_INTEGER*)&m_start);
311         }
312         else {
313                 GHOST_PRINT("GHOST_SystemWin32::init: High Frequency Performance Timer not available\n")
314         }
315
316         if (success) {
317                 WNDCLASS wc;
318                 wc.style= CS_HREDRAW | CS_VREDRAW;
319                 wc.lpfnWndProc= s_wndProc;
320                 wc.cbClsExtra= 0;
321                 wc.cbWndExtra= 0;
322                 wc.hInstance= ::GetModuleHandle(0);
323                 wc.hIcon = ::LoadIcon(wc.hInstance, "APPICON");
324                 
325                 if (!wc.hIcon) {
326                         ::LoadIcon(NULL, IDI_APPLICATION);
327                 }
328                 wc.hCursor = ::LoadCursor(0, IDC_ARROW);
329                 wc.hbrBackground= (HBRUSH)::GetStockObject(BLACK_BRUSH);
330                 wc.lpszMenuName = 0;
331                 wc.lpszClassName= GHOST_WindowWin32::getWindowClassName();
332     
333                 // Use RegisterClassEx for setting small icon
334                 if (::RegisterClass(&wc) == 0) {
335                         success = GHOST_kFailure;
336                 }
337         }
338         return success;
339 }
340
341
342 GHOST_TSuccess GHOST_SystemWin32::exit()
343 {
344         return GHOST_System::exit();
345 }
346
347
348 GHOST_TKey GHOST_SystemWin32::convertKey(WPARAM wParam, LPARAM lParam) const
349 {
350         GHOST_TKey key;
351         bool isExtended = (lParam&(1<<24))?true:false;
352
353         if ((wParam >= '0') && (wParam <= '9')) {
354                 // VK_0 thru VK_9 are the same as ASCII '0' thru '9' (0x30 - 0x39)
355                 key = (GHOST_TKey)(wParam - '0' + GHOST_kKey0);
356         }
357         else if ((wParam >= 'A') && (wParam <= 'Z')) {
358                 // VK_A thru VK_Z are the same as ASCII 'A' thru 'Z' (0x41 - 0x5A)
359                 key = (GHOST_TKey)(wParam - 'A' + GHOST_kKeyA);
360         }
361         else if ((wParam >= VK_F1) && (wParam <= VK_F24)) {
362                 key = (GHOST_TKey)(wParam - VK_F1 + GHOST_kKeyF1);
363         }
364         else {
365                 switch (wParam) {
366                 case VK_RETURN:
367                         key = isExtended?GHOST_kKeyNumpadEnter:GHOST_kKeyEnter;
368                         break;
369
370                 case VK_BACK:     key = GHOST_kKeyBackSpace;            break;
371                 case VK_TAB:      key = GHOST_kKeyTab;                          break;
372                 case VK_ESCAPE:   key = GHOST_kKeyEsc;                          break;
373                 case VK_SPACE:    key = GHOST_kKeySpace;                        break;
374                 case VK_PRIOR:    key = GHOST_kKeyUpPage;                       break;
375                 case VK_NEXT:     key = GHOST_kKeyDownPage;                     break;
376                 case VK_END:      key = GHOST_kKeyEnd;                          break;
377                 case VK_HOME:     key = GHOST_kKeyHome;                         break;
378                 case VK_INSERT:   key = GHOST_kKeyInsert;                       break;
379                 case VK_DELETE:   key = GHOST_kKeyDelete;                       break;
380                 case VK_LEFT:     key = GHOST_kKeyLeftArrow;            break;
381                 case VK_RIGHT:    key = GHOST_kKeyRightArrow;           break;
382                 case VK_UP:       key = GHOST_kKeyUpArrow;                      break;
383                 case VK_DOWN:     key = GHOST_kKeyDownArrow;            break;
384                 case VK_NUMPAD0:  key = GHOST_kKeyNumpad0;                      break;
385                 case VK_NUMPAD1:  key = GHOST_kKeyNumpad1;                      break;
386                 case VK_NUMPAD2:  key = GHOST_kKeyNumpad2;                      break;
387                 case VK_NUMPAD3:  key = GHOST_kKeyNumpad3;                      break;
388                 case VK_NUMPAD4:  key = GHOST_kKeyNumpad4;                      break;
389                 case VK_NUMPAD5:  key = GHOST_kKeyNumpad5;                      break;
390                 case VK_NUMPAD6:  key = GHOST_kKeyNumpad6;                      break;
391                 case VK_NUMPAD7:  key = GHOST_kKeyNumpad7;                      break;
392                 case VK_NUMPAD8:  key = GHOST_kKeyNumpad8;                      break;
393                 case VK_NUMPAD9:  key = GHOST_kKeyNumpad9;                      break;
394                 case VK_SNAPSHOT: key = GHOST_kKeyPrintScreen;          break;
395                 case VK_PAUSE:    key = GHOST_kKeyPause;                        break;
396                 case VK_MULTIPLY: key = GHOST_kKeyNumpadAsterisk;        break;
397                 case VK_SUBTRACT: key = GHOST_kKeyNumpadMinus;          break;
398                 case VK_DECIMAL:  key = GHOST_kKeyNumpadPeriod;         break;
399                 case VK_DIVIDE:   key = GHOST_kKeyNumpadSlash;          break;
400                 case VK_ADD:      key = GHOST_kKeyNumpadPlus;           break;
401
402                 case VK_SEMICOLON:              key = GHOST_kKeySemicolon;              break;
403                 case VK_EQUALS:                 key = GHOST_kKeyEqual;                  break;
404                 case VK_COMMA:                  key = GHOST_kKeyComma;                  break;
405                 case VK_MINUS:                  key = GHOST_kKeyMinus;                  break;
406                 case VK_PERIOD:                 key = GHOST_kKeyPeriod;                 break;
407                 case VK_SLASH:                  key = GHOST_kKeySlash;                  break;
408                 case VK_BACK_QUOTE:             key = GHOST_kKeyAccentGrave;    break;
409                 case VK_OPEN_BRACKET:   key = GHOST_kKeyLeftBracket;    break;
410                 case VK_BACK_SLASH:             key = GHOST_kKeyBackslash;              break;
411                 case VK_CLOSE_BRACKET:  key = GHOST_kKeyRightBracket;   break;
412                 case VK_QUOTE:                  key = GHOST_kKeyQuote;                  break;
413                 case VK_GR_LESS:                key = GHOST_kKeyGrLess;                 break;
414
415                 // Process these keys separately because we need to distinguish right from left modifier keys
416                 case VK_SHIFT:
417                 case VK_CONTROL:
418                 case VK_MENU:
419
420                 // Ignore these keys
421                 case VK_NUMLOCK:
422                 case VK_SCROLL:
423                 case VK_CAPITAL:
424                 default:
425                         key = GHOST_kKeyUnknown;
426                         break;
427                 }
428         }
429         return key;
430 }
431
432
433 void GHOST_SystemWin32::processModifierKeys(GHOST_IWindow *window)
434 {
435         GHOST_ModifierKeys oldModifiers, newModifiers;
436         // Retrieve old state of the modifier keys
437         ((GHOST_SystemWin32*)getSystem())->retrieveModifierKeys(oldModifiers);
438         // Retrieve current state of the modifier keys
439         ((GHOST_SystemWin32*)getSystem())->getModifierKeys(newModifiers);
440
441         // Compare the old and the new
442         if (!newModifiers.equals(oldModifiers)) {
443                 // Create events for the masks that changed
444                 for (int i = 0; i < GHOST_kModifierKeyNumMasks; i++) {
445                         if (newModifiers.get((GHOST_TModifierKeyMask)i) != oldModifiers.get((GHOST_TModifierKeyMask)i)) {
446                                 // Convert the mask to a key code
447                                 GHOST_TKey key = GHOST_ModifierKeys::getModifierKeyCode((GHOST_TModifierKeyMask)i);
448                                 bool keyDown = newModifiers.get((GHOST_TModifierKeyMask)i);
449                                 GHOST_EventKey* event;
450                                 if (key != GHOST_kKeyUnknown) {
451                                         // Create an event
452                                         event = new GHOST_EventKey(getSystem()->getMilliSeconds(), keyDown ? GHOST_kEventKeyDown: GHOST_kEventKeyUp, window, key);
453                                         pushEvent(event);
454                                 }
455                         }
456                 }
457         }
458
459         // Store new modifier keys state
460         ((GHOST_SystemWin32*)getSystem())->storeModifierKeys(newModifiers);
461 }
462
463
464 GHOST_EventButton* GHOST_SystemWin32::processButtonEvent(GHOST_TEventType type, GHOST_IWindow *window, GHOST_TButtonMask mask)
465 {
466         return new GHOST_EventButton (getSystem()->getMilliSeconds(), type, window, mask);
467 }
468
469
470 GHOST_EventCursor* GHOST_SystemWin32::processCursorEvent(GHOST_TEventType type, GHOST_IWindow *window)
471 {
472         GHOST_TInt32 x, y;
473         getSystem()->getCursorPosition(x, y);
474         return new GHOST_EventCursor (getSystem()->getMilliSeconds(), type, window, x, y);
475 }
476
477
478 GHOST_EventWheel* GHOST_SystemWin32::processWheelEvent(GHOST_IWindow *window, WPARAM wParam, LPARAM lParam)
479 {
480         // short fwKeys = LOWORD(wParam);                       // key flags
481         int zDelta = (short) HIWORD(wParam);    // wheel rotation
482         
483         // zDelta /= WHEEL_DELTA;
484         // temporary fix below: microsoft now has added more precision, making the above division not work
485         if (zDelta <= 0 ) zDelta= -1; else zDelta= 1;   
486         
487         // short xPos = (short) LOWORD(lParam); // horizontal position of pointer
488         // short yPos = (short) HIWORD(lParam); // vertical position of pointer
489         return new GHOST_EventWheel (getSystem()->getMilliSeconds(), window, zDelta);
490 }
491
492
493 GHOST_EventKey* GHOST_SystemWin32::processKeyEvent(GHOST_IWindow *window, bool keyDown, WPARAM wParam, LPARAM lParam)
494 {
495         GHOST_TKey key = ((GHOST_SystemWin32*)getSystem())->convertKey(wParam, lParam);
496         GHOST_EventKey* event;
497         if (key != GHOST_kKeyUnknown) {
498                 MSG keyMsg;
499                 char ascii = '\0';
500
501                         /* Eat any character related messages */
502                 if (::PeekMessage(&keyMsg, NULL, WM_CHAR, WM_SYSDEADCHAR, PM_REMOVE)) {
503                         ascii = (char) keyMsg.wParam;
504                 }
505
506                 event = new GHOST_EventKey(getSystem()->getMilliSeconds(), keyDown ? GHOST_kEventKeyDown: GHOST_kEventKeyUp, window, key, ascii);
507         }
508         else {
509                 event = 0;
510         }
511         return event;
512 }
513
514
515 GHOST_Event* GHOST_SystemWin32::processWindowEvent(GHOST_TEventType type, GHOST_IWindow* window)
516 {
517         return new GHOST_Event(getSystem()->getMilliSeconds(), type, window);
518 }
519
520
521 LRESULT WINAPI GHOST_SystemWin32::s_wndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
522 {
523         GHOST_Event* event = 0;
524         LRESULT lResult;
525         GHOST_SystemWin32* system = ((GHOST_SystemWin32*)getSystem());
526         GHOST_ASSERT(system, "GHOST_SystemWin32::s_wndProc(): system not initialized")
527
528         if (hwnd) {
529                 GHOST_WindowWin32* window = (GHOST_WindowWin32*)::GetWindowLong(hwnd, GWL_USERDATA);
530                 if (window) {
531                         switch (msg) {
532                                 ////////////////////////////////////////////////////////////////////////
533                                 // Keyboard events, processed
534                                 ////////////////////////////////////////////////////////////////////////
535                                 case WM_KEYDOWN:
536                                         /* The WM_KEYDOWN message is posted to the window with the keyboard focus when a 
537                                          * nonsystem key is pressed. A nonsystem key is a key that is pressed when the alt
538                                          * key is not pressed. 
539                                          */
540                                 case WM_SYSKEYDOWN:
541                                         /* The WM_SYSKEYDOWN message is posted to the window with the keyboard focus when 
542                                          * the user presses the F10 key (which activates the menu bar) or holds down the 
543                                          * alt key and then presses another key. It also occurs when no window currently 
544                                          * has the keyboard focus; in this case, the WM_SYSKEYDOWN message is sent to the 
545                                          * active window. The window that receives the message can distinguish between these 
546                                          * two contexts by checking the context code in the lKeyData parameter. 
547                                          */
548                                         switch (wParam) {
549                                                 case VK_SHIFT:
550                                                 case VK_CONTROL:
551                                                 case VK_MENU:
552                                                         if (!system->m_seperateLeftRightInitialized) {
553                                                                 // Check whether this system supports seperate left and right keys
554                                                                 switch (wParam) {
555                                                                         case VK_SHIFT:
556                                                                                 system->m_seperateLeftRight = 
557                                                                                         (HIBYTE(::GetKeyState(VK_LSHIFT)) != 0) ||
558                                                                                         (HIBYTE(::GetKeyState(VK_RSHIFT)) != 0) ?
559                                                                                         true : false;
560                                                                                 break;
561                                                                         case VK_CONTROL:
562                                                                                 system->m_seperateLeftRight = 
563                                                                                         (HIBYTE(::GetKeyState(VK_LCONTROL)) != 0) ||
564                                                                                         (HIBYTE(::GetKeyState(VK_RCONTROL)) != 0) ?
565                                                                                         true : false;
566                                                                                 break;
567                                                                         case VK_MENU:
568                                                                                 system->m_seperateLeftRight = 
569                                                                                         (HIBYTE(::GetKeyState(VK_LMENU)) != 0) ||
570                                                                                         (HIBYTE(::GetKeyState(VK_RMENU)) != 0) ?
571                                                                                         true : false;
572                                                                                 break;
573                                                                 }
574                                                                 system->m_seperateLeftRightInitialized = true;
575                                                         }
576                                                         system->processModifierKeys(window);
577                                                         // Bypass call to DefWindowProc
578                                                         return 0;
579                                                 default:
580                                                         event = processKeyEvent(window, true, wParam, lParam);
581                                                         if (!event) {
582                                                                 GHOST_PRINT("GHOST_SystemWin32::wndProc: key event ")
583                                                                 GHOST_PRINT(msg)
584                                                                 GHOST_PRINT(" key ignored\n")
585                                                         }
586                                                         break;
587                                                 }
588                                         break;
589
590                                 case WM_KEYUP:
591                                 case WM_SYSKEYUP:
592                                         switch (wParam) {
593                                                 case VK_SHIFT:
594                                                 case VK_CONTROL:
595                                                 case VK_MENU:
596                                                         system->processModifierKeys(window);
597                                                         // Bypass call to DefWindowProc
598                                                         return 0;
599                                                 default:
600                                                         event = processKeyEvent(window, false, wParam, lParam);
601                                                         if (!event) {
602                                                                 GHOST_PRINT("GHOST_SystemWin32::wndProc: key event ")
603                                                                 GHOST_PRINT(msg)
604                                                                 GHOST_PRINT(" key ignored\n")
605                                                         }
606                                                         break;
607                                         }
608                                         break;
609
610                                 ////////////////////////////////////////////////////////////////////////
611                                 // Keyboard events, ignored
612                                 ////////////////////////////////////////////////////////////////////////
613                                 case WM_CHAR:
614                                         /* The WM_CHAR message is posted to the window with the keyboard focus when 
615                                          * a WM_KEYDOWN message is translated by the TranslateMessage function. WM_CHAR 
616                                          * contains the character code of the key that was pressed. 
617                                          */
618                                 case WM_DEADCHAR:
619                                         /* The WM_DEADCHAR message is posted to the window with the keyboard focus when a
620                                          * WM_KEYUP message is translated by the TranslateMessage function. WM_DEADCHAR 
621                                          * specifies a character code generated by a dead key. A dead key is a key that 
622                                          * generates a character, such as the umlaut (double-dot), that is combined with 
623                                          * another character to form a composite character. For example, the umlaut-O 
624                                          * character (Ù) is generated by typing the dead key for the umlaut character, and 
625                                          * then typing the O key.
626                                          */
627                                 case WM_SYSDEADCHAR:
628                                         /* The WM_SYSDEADCHAR message is sent to the window with the keyboard focus when 
629                                          * a WM_SYSKEYDOWN message is translated by the TranslateMessage function. 
630                                          * WM_SYSDEADCHAR specifies the character code of a system dead key - that is, 
631                                          * a dead key that is pressed while holding down the alt key. 
632                                          */
633                                         break;
634                                 ////////////////////////////////////////////////////////////////////////
635                                 // Tablet events, processed
636                                 ////////////////////////////////////////////////////////////////////////
637                                 case WT_PACKET:
638                                         ((GHOST_WindowWin32*)window)->processWin32TabletEvent(wParam, lParam);
639                                         break;
640                                 case WT_CSRCHANGE:
641                                 case WT_PROXIMITY:
642                                         ((GHOST_WindowWin32*)window)->processWin32TabletInitEvent();
643                                         break;
644                                 ////////////////////////////////////////////////////////////////////////
645                                 // Mouse events, processed
646                                 ////////////////////////////////////////////////////////////////////////
647                                 case WM_LBUTTONDOWN:
648                                         window->registerMouseClickEvent(true);
649                                         event = processButtonEvent(GHOST_kEventButtonDown, window, GHOST_kButtonMaskLeft);
650                                         break;
651                                 case WM_MBUTTONDOWN:
652                                         window->registerMouseClickEvent(true);
653                                         event = processButtonEvent(GHOST_kEventButtonDown, window, GHOST_kButtonMaskMiddle);
654                                         break;
655                                 case WM_RBUTTONDOWN:
656                                         window->registerMouseClickEvent(true);
657                                         event = processButtonEvent(GHOST_kEventButtonDown, window, GHOST_kButtonMaskRight);
658                                         break;
659                                 case WM_LBUTTONUP:
660                                         window->registerMouseClickEvent(false);
661                                         event = processButtonEvent(GHOST_kEventButtonUp, window, GHOST_kButtonMaskLeft);
662                                         break;
663                                 case WM_MBUTTONUP:
664                                         window->registerMouseClickEvent(false);
665                                         event = processButtonEvent(GHOST_kEventButtonUp, window, GHOST_kButtonMaskMiddle);
666                                         break;
667                                 case WM_RBUTTONUP:
668                                         window->registerMouseClickEvent(false);
669                                         event = processButtonEvent(GHOST_kEventButtonUp, window, GHOST_kButtonMaskRight);
670                                         break;
671                                 case WM_MOUSEMOVE:
672                                         event = processCursorEvent(GHOST_kEventCursorMove, window);
673                                         break;
674                                 case WM_MOUSEWHEEL:
675                                         /* The WM_MOUSEWHEEL message is sent to the focus window 
676                                          * when the mouse wheel is rotated. The DefWindowProc 
677                                          * function propagates the message to the window's parent.
678                                          * There should be no internal forwarding of the message, 
679                                          * since DefWindowProc propagates it up the parent chain 
680                                          * until it finds a window that processes it.
681                                          */
682                                         event = processWheelEvent(window, wParam, lParam);
683                                         break;
684                                 case WM_SETCURSOR:
685                                         /* The WM_SETCURSOR message is sent to a window if the mouse causes the cursor
686                                          * to move within a window and mouse input is not captured.
687                                          * This means we have to set the cursor shape every time the mouse moves!
688                                          * The DefWindowProc function uses this message to set the cursor to an 
689                                          * arrow if it is not in the client area.
690                                          */
691                                         if (LOWORD(lParam) == HTCLIENT) {
692                                                 // Load the current cursor
693                                                 window->loadCursor(window->getCursorVisibility(), window->getCursorShape());
694                                                 // Bypass call to DefWindowProc
695                                                 return 0;
696                                         } 
697                                         else {
698                                                 // Outside of client area show standard cursor
699                                                 window->loadCursor(true, GHOST_kStandardCursorDefault);
700                                         }
701                                         break;
702
703                                 ////////////////////////////////////////////////////////////////////////
704                                 // Mouse events, ignored
705                                 ////////////////////////////////////////////////////////////////////////
706                                 case WM_NCMOUSEMOVE:
707                                         /* The WM_NCMOUSEMOVE message is posted to a window when the cursor is moved 
708                                          * within the nonclient area of the window. This message is posted to the window 
709                                          * that contains the cursor. If a window has captured the mouse, this message is not posted.
710                                          */
711                                 case WM_NCHITTEST:
712                                         /* The WM_NCHITTEST message is sent to a window when the cursor moves, or 
713                                          * when a mouse button is pressed or released. If the mouse is not captured, 
714                                          * the message is sent to the window beneath the cursor. Otherwise, the message 
715                                          * is sent to the window that has captured the mouse. 
716                                          */
717                                         break;
718
719                                 ////////////////////////////////////////////////////////////////////////
720                                 // Window events, processed
721                                 ////////////////////////////////////////////////////////////////////////
722                                 case WM_CLOSE:
723                                         /* The WM_CLOSE message is sent as a signal that a window or an application should terminate. */
724                                         event = processWindowEvent(GHOST_kEventWindowClose, window);
725                                         break;
726                                 case WM_ACTIVATE:
727                                         /* The WM_ACTIVATE message is sent to both the window being activated and the window being 
728                                          * deactivated. If the windows use the same input queue, the message is sent synchronously, 
729                                          * first to the window procedure of the top-level window being deactivated, then to the window
730                                          * procedure of the top-level window being activated. If the windows use different input queues,
731                                          * the message is sent asynchronously, so the window is activated immediately. 
732                                          */
733                                         event = processWindowEvent(LOWORD(wParam) ? GHOST_kEventWindowActivate : GHOST_kEventWindowDeactivate, window);
734                                         break;
735                                 case WM_PAINT:
736                                         /* An application sends the WM_PAINT message when the system or another application 
737                                          * makes a request to paint a portion of an application's window. The message is sent
738                                          * when the UpdateWindow or RedrawWindow function is called, or by the DispatchMessage 
739                                          * function when the application obtains a WM_PAINT message by using the GetMessage or 
740                                          * PeekMessage function. 
741                                          */
742                                         event = processWindowEvent(GHOST_kEventWindowUpdate, window);
743                                         ::ValidateRect(hwnd, NULL);
744                                         break;
745                                 case WM_SIZE:
746                                         /* The WM_SIZE message is sent to a window after its size has changed.
747                                          * The WM_SIZE and WM_MOVE messages are not sent if an application handles the 
748                                          * WM_WINDOWPOSCHANGED message without calling DefWindowProc. It is more efficient
749                                          * to perform any move or size change processing during the WM_WINDOWPOSCHANGED 
750                                          * message without calling DefWindowProc.
751                                          */
752                                         event = processWindowEvent(GHOST_kEventWindowSize, window);
753                                         break;
754                                 case WM_CAPTURECHANGED:
755                                         window->lostMouseCapture();
756                                         break;
757
758                                 ////////////////////////////////////////////////////////////////////////
759                                 // Window events, ignored
760                                 ////////////////////////////////////////////////////////////////////////
761                                 case WM_WINDOWPOSCHANGED:
762                                         /* The WM_WINDOWPOSCHANGED message is sent to a window whose size, position, or place
763                                          * in the Z order has changed as a result of a call to the SetWindowPos function or 
764                                          * another window-management function.
765                                          * The WM_SIZE and WM_MOVE messages are not sent if an application handles the 
766                                          * WM_WINDOWPOSCHANGED message without calling DefWindowProc. It is more efficient
767                                          * to perform any move or size change processing during the WM_WINDOWPOSCHANGED 
768                                          * message without calling DefWindowProc.
769                                          */
770                                 case WM_MOVE:
771                                         /* The WM_SIZE and WM_MOVE messages are not sent if an application handles the 
772                                          * WM_WINDOWPOSCHANGED message without calling DefWindowProc. It is more efficient
773                                          * to perform any move or size change processing during the WM_WINDOWPOSCHANGED 
774                                          * message without calling DefWindowProc. 
775                                          */
776                                         event = processWindowEvent(GHOST_kEventWindowMove, window);
777                                         break;
778                                 case WM_ERASEBKGND:
779                                         /* An application sends the WM_ERASEBKGND message when the window background must be 
780                                          * erased (for example, when a window is resized). The message is sent to prepare an 
781                                          * invalidated portion of a window for painting. 
782                                          */
783                                 case WM_NCPAINT:
784                                         /* An application sends the WM_NCPAINT message to a window when its frame must be painted. */
785                                 case WM_NCACTIVATE:
786                                         /* The WM_NCACTIVATE message is sent to a window when its nonclient area needs to be changed 
787                                          * to indicate an active or inactive state. 
788                                          */
789                                 case WM_DESTROY:
790                                         /* The WM_DESTROY message is sent when a window is being destroyed. It is sent to the window 
791                                          * procedure of the window being destroyed after the window is removed from the screen. 
792                                          * This message is sent first to the window being destroyed and then to the child windows 
793                                          * (if any) as they are destroyed. During the processing of the message, it can be assumed 
794                                          * that all child windows still exist. 
795                                          */
796                                 case WM_NCDESTROY:
797                                         /* The WM_NCDESTROY message informs a window that its nonclient area is being destroyed. The 
798                                          * DestroyWindow function sends the WM_NCDESTROY message to the window following the WM_DESTROY
799                                          * message. WM_DESTROY is used to free the allocated memory object associated with the window. 
800                                          */
801                                 case WM_KILLFOCUS:
802                                         /* The WM_KILLFOCUS message is sent to a window immediately before it loses the keyboard focus. */
803                                 case WM_SHOWWINDOW:
804                                         /* The WM_SHOWWINDOW message is sent to a window when the window is about to be hidden or shown. */
805                                 case WM_WINDOWPOSCHANGING:
806                                         /* The WM_WINDOWPOSCHANGING message is sent to a window whose size, position, or place in 
807                                          * the Z order is about to change as a result of a call to the SetWindowPos function or 
808                                          * another window-management function. 
809                                          */
810                                 case WM_SETFOCUS:
811                                         /* The WM_SETFOCUS message is sent to a window after it has gained the keyboard focus. */
812                                 case WM_MOVING:
813                                         /* The WM_MOVING message is sent to a window that the user is moving. By processing 
814                                          * this message, an application can monitor the size and position of the drag rectangle
815                                          * and, if needed, change its size or position.
816                                          */
817                                 case WM_ENTERSIZEMOVE:
818                                         /* The WM_ENTERSIZEMOVE message is sent one time to a window after it enters the moving 
819                                          * or sizing modal loop. The window enters the moving or sizing modal loop when the user 
820                                          * clicks the window's title bar or sizing border, or when the window passes the 
821                                          * WM_SYSCOMMAND message to the DefWindowProc function and the wParam parameter of the 
822                                          * message specifies the SC_MOVE or SC_SIZE value. The operation is complete when 
823                                          * DefWindowProc returns. 
824                                          */
825                                         break;
826                                         
827                                 ////////////////////////////////////////////////////////////////////////
828                                 // Other events
829                                 ////////////////////////////////////////////////////////////////////////
830                                 case WM_GETTEXT:
831                                         /* An application sends a WM_GETTEXT message to copy the text that 
832                                          * corresponds to a window into a buffer provided by the caller. 
833                                          */
834                                 case WM_ACTIVATEAPP:
835                                         /* The WM_ACTIVATEAPP message is sent when a window belonging to a 
836                                          * different application than the active window is about to be activated.
837                                          * The message is sent to the application whose window is being activated
838                                          * and to the application whose window is being deactivated. 
839                                          */
840                                 case WM_TIMER:
841                                         /* The WIN32 docs say:
842                                          * The WM_TIMER message is posted to the installing thread's message queue
843                                          * when a timer expires. You can process the message by providing a WM_TIMER
844                                          * case in the window procedure. Otherwise, the default window procedure will
845                                          * call the TimerProc callback function specified in the call to the SetTimer
846                                          * function used to install the timer. 
847                                          *
848                                          * In GHOST, we let DefWindowProc call the timer callback.
849                                          */
850                                         break;
851                         }
852                 }
853                 else {
854                         // Event found for a window before the pointer to the class has been set.
855                         GHOST_PRINT("GHOST_SystemWin32::wndProc: GHOST window event before creation\n")
856                         /* These are events we typically miss at this point:
857                            WM_GETMINMAXINFO     0x24
858                            WM_NCCREATE                  0x81
859                            WM_NCCALCSIZE                0x83
860                            WM_CREATE                    0x01
861                            We let DefWindowProc do the work.
862                         */
863                 }
864         }
865         else {
866                 // Events without valid hwnd
867                 GHOST_PRINT("GHOST_SystemWin32::wndProc: event without window\n")
868         }
869
870         if (event) {
871                 system->pushEvent(event);
872                 lResult = 0;
873         }
874         else {
875                 lResult = ::DefWindowProc(hwnd, msg, wParam, lParam);
876         }
877         return lResult;
878 }