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