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