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                 if (!wc.hIcon) {
 322                         ::LoadIcon(NULL, IDI_APPLICATION);
 323                 }
 324                 wc.hCursor = ::LoadCursor(0, IDC_ARROW);
 325                 wc.hbrBackground= (HBRUSH)::GetStockObject(BLACK_BRUSH);
 326                 wc.lpszMenuName = 0;
 327                 wc.lpszClassName= GHOST_WindowWin32::getWindowClassName();
 328
 329                 // Use RegisterClassEx for setting small icon
 330                 if (::RegisterClass(&wc) == 0) {
 331                         success = GHOST_kFailure;
 332                 }
 333         }
 334         return success;
 335 }
 336
 337
 338 GHOST_TSuccess GHOST_SystemWin32::exit()
 339 {
 340         return GHOST_System::exit();
 341 }
 342
 343
 344 GHOST_TKey GHOST_SystemWin32::convertKey(WPARAM wParam, LPARAM lParam) const
 345 {
 346         GHOST_TKey key;
 347         bool isExtended = (lParam&(1<<24))?true:false;
 348
 349         if ((wParam >= '0') && (wParam <= '9')) {
 350                 // VK_0 thru VK_9 are the same as ASCII '0' thru '9' (0x30 - 0x39)
 351                 key = (GHOST_TKey)(wParam - '0' + GHOST_kKey0);
 352         }
 353         else if ((wParam >= 'A') && (wParam <= 'Z')) {
 354                 // VK_A thru VK_Z are the same as ASCII 'A' thru 'Z' (0x41 - 0x5A)
 355                 key = (GHOST_TKey)(wParam - 'A' + GHOST_kKeyA);
 356         }
 357         else if ((wParam >= VK_F1) && (wParam <= VK_F24)) {
 358                 key = (GHOST_TKey)(wParam - VK_F1 + GHOST_kKeyF1);
 359         }
 360         else {
 361                 switch (wParam) {
 362                 case VK_RETURN:
 363                         key = isExtended?GHOST_kKeyNumpadEnter:GHOST_kKeyEnter;
 364                         break;
 365
 366                 case VK_BACK:     key = GHOST_kKeyBackSpace;            break;
 367                 case VK_TAB:      key = GHOST_kKeyTab;                          break;
 368                 case VK_ESCAPE:   key = GHOST_kKeyEsc;                          break;
 369                 case VK_SPACE:    key = GHOST_kKeySpace;                        break;
 370                 case VK_PRIOR:    key = GHOST_kKeyUpPage;                       break;
 371                 case VK_NEXT:     key = GHOST_kKeyDownPage;                     break;
 372                 case VK_END:      key = GHOST_kKeyEnd;                          break;
 373                 case VK_HOME:     key = GHOST_kKeyHome;                         break;
 374                 case VK_INSERT:   key = GHOST_kKeyInsert;                       break;
 375                 case VK_DELETE:   key = GHOST_kKeyDelete;                       break;
 376                 case VK_LEFT:     key = GHOST_kKeyLeftArrow;            break;
 377                 case VK_RIGHT:    key = GHOST_kKeyRightArrow;           break;
 378                 case VK_UP:       key = GHOST_kKeyUpArrow;                      break;
 379                 case VK_DOWN:     key = GHOST_kKeyDownArrow;            break;
 380                 case VK_NUMPAD0:  key = GHOST_kKeyNumpad0;                      break;
 381                 case VK_NUMPAD1:  key = GHOST_kKeyNumpad1;                      break;
 382                 case VK_NUMPAD2:  key = GHOST_kKeyNumpad2;                      break;
 383                 case VK_NUMPAD3:  key = GHOST_kKeyNumpad3;                      break;
 384                 case VK_NUMPAD4:  key = GHOST_kKeyNumpad4;                      break;
 385                 case VK_NUMPAD5:  key = GHOST_kKeyNumpad5;                      break;
 386                 case VK_NUMPAD6:  key = GHOST_kKeyNumpad6;                      break;
 387                 case VK_NUMPAD7:  key = GHOST_kKeyNumpad7;                      break;
 388                 case VK_NUMPAD8:  key = GHOST_kKeyNumpad8;                      break;
 389                 case VK_NUMPAD9:  key = GHOST_kKeyNumpad9;                      break;
 390                 case VK_SNAPSHOT: key = GHOST_kKeyPrintScreen;          break;
 391                 case VK_PAUSE:    key = GHOST_kKeyPause;                        break;
 392                 case VK_MULTIPLY: key = GHOST_kKeyNumpadAsterisk;        break;
 393                 case VK_SUBTRACT: key = GHOST_kKeyNumpadMinus;          break;
 394                 case VK_DECIMAL:  key = GHOST_kKeyNumpadPeriod;         break;
 395                 case VK_DIVIDE:   key = GHOST_kKeyNumpadSlash;          break;
 396                 case VK_ADD:      key = GHOST_kKeyNumpadPlus;           break;
 397
 398                 case VK_SEMICOLON:              key = GHOST_kKeySemicolon;              break;
 399                 case VK_EQUALS:                 key = GHOST_kKeyEqual;                  break;
 400                 case VK_COMMA:                  key = GHOST_kKeyComma;                  break;
 401                 case VK_MINUS:                  key = GHOST_kKeyMinus;                  break;
 402                 case VK_PERIOD:                 key = GHOST_kKeyPeriod;                 break;
 403                 case VK_SLASH:                  key = GHOST_kKeySlash;                  break;
 404                 case VK_BACK_QUOTE:             key = GHOST_kKeyAccentGrave;    break;
 405                 case VK_OPEN_BRACKET:   key = GHOST_kKeyLeftBracket;    break;
 406                 case VK_BACK_SLASH:             key = GHOST_kKeyBackslash;              break;
 407                 case VK_CLOSE_BRACKET:  key = GHOST_kKeyRightBracket;   break;
 408                 case VK_QUOTE:                  key = GHOST_kKeyQuote;                  break;
 409
 410                 // Process these keys separately because we need to distinguish right from left modifier keys
 411                 case VK_SHIFT:
 412                 case VK_CONTROL:
 413                 case VK_MENU:
 414
 415                 // Ignore these keys
 416                 case VK_NUMLOCK:
 417                 case VK_SCROLL:
 418                 case VK_CAPITAL:
 419                 default:
 420                         key = GHOST_kKeyUnknown;
 421                         break;
 422                 }
 423         }
 424         return key;
 425 }
 426
 427
 428 void GHOST_SystemWin32::processModifierKeys(GHOST_IWindow *window)
 429 {
 430         GHOST_ModifierKeys oldModifiers, newModifiers;
 431         // Retrieve old state of the modifier keys
 432         ((GHOST_SystemWin32*)getSystem())->retrieveModifierKeys(oldModifiers);
 433         // Retrieve current state of the modifier keys
 434         ((GHOST_SystemWin32*)getSystem())->getModifierKeys(newModifiers);
 435
 436         // Compare the old and the new
 437         if (!newModifiers.equals(oldModifiers)) {
 438                 // Create events for the masks that changed
 439                 for (int i = 0; i < GHOST_kModifierKeyNumMasks; i++) {
 440                         if (newModifiers.get((GHOST_TModifierKeyMask)i) != oldModifiers.get((GHOST_TModifierKeyMask)i)) {
 441                                 // Convert the mask to a key code
 442                                 GHOST_TKey key = GHOST_ModifierKeys::getModifierKeyCode((GHOST_TModifierKeyMask)i);
 443                                 bool keyDown = newModifiers.get((GHOST_TModifierKeyMask)i);
 444                                 GHOST_EventKey* event;
 445                                 if (key != GHOST_kKeyUnknown) {
 446                                         // Create an event
 447                                         event = new GHOST_EventKey(getSystem()->getMilliSeconds(), keyDown ? GHOST_kEventKeyDown: GHOST_kEventKeyUp, window, key);
 448                                         pushEvent(event);
 449                                 }
 450                         }
 451                 }
 452         }
 453
 454         // Store new modifier keys state
 455         ((GHOST_SystemWin32*)getSystem())->storeModifierKeys(newModifiers);
 456 }
 457
 458
 459 GHOST_EventButton* GHOST_SystemWin32::processButtonEvent(GHOST_TEventType type, GHOST_IWindow *window, GHOST_TButtonMask mask)
 460 {
 461         return new GHOST_EventButton (getSystem()->getMilliSeconds(), type, window, mask);
 462 }
 463
 464
 465 GHOST_EventCursor* GHOST_SystemWin32::processCursorEvent(GHOST_TEventType type, GHOST_IWindow *window)
 466 {
 467         GHOST_TInt32 x, y;
 468         getSystem()->getCursorPosition(x, y);
 469         return new GHOST_EventCursor (getSystem()->getMilliSeconds(), type, window, x, y);
 470 }
 471
 472
 473 GHOST_EventWheel* GHOST_SystemWin32::processWheelEvent(GHOST_IWindow *window, WPARAM wParam, LPARAM lParam)
 474 {
 475         // short fwKeys = LOWORD(wParam);                       // key flags
 476         int zDelta = (short) HIWORD(wParam);    // wheel rotation
 477         zDelta /= WHEEL_DELTA;
 478         // short xPos = (short) LOWORD(lParam); // horizontal position of pointer
 479         // short yPos = (short) HIWORD(lParam); // vertical position of pointer
 480         return new GHOST_EventWheel (getSystem()->getMilliSeconds(), window, zDelta);
 481 }
 482
 483
 484 GHOST_EventKey* GHOST_SystemWin32::processKeyEvent(GHOST_IWindow *window, bool keyDown, WPARAM wParam, LPARAM lParam)
 485 {
 486         GHOST_TKey key = ((GHOST_SystemWin32*)getSystem())->convertKey(wParam, lParam);
 487         GHOST_EventKey* event;
 488         if (key != GHOST_kKeyUnknown) {
 489                 MSG keyMsg;
 490                 char ascii = '\0';
 491
 492                         /* Eat any character related messages */
 493                 if (::PeekMessage(&keyMsg, NULL, WM_CHAR, WM_SYSDEADCHAR, PM_REMOVE)) {
 494                         ascii = (char) keyMsg.wParam;
 495                 }
 496
 497                 event = new GHOST_EventKey(getSystem()->getMilliSeconds(), keyDown ? GHOST_kEventKeyDown: GHOST_kEventKeyUp, window, key, ascii);
 498         }
 499         else {
 500                 event = 0;
 501         }
 502         return event;
 503 }
 504
 505
 506 GHOST_Event* GHOST_SystemWin32::processWindowEvent(GHOST_TEventType type, GHOST_IWindow* window)
 507 {
 508         return new GHOST_Event(getSystem()->getMilliSeconds(), type, window);
 509 }
 510
 511
 512 LRESULT WINAPI GHOST_SystemWin32::s_wndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
 513 {
 514         GHOST_Event* event = 0;
 515         LRESULT lResult;
 516         GHOST_SystemWin32* system = ((GHOST_SystemWin32*)getSystem());
 517         GHOST_ASSERT(system, "GHOST_SystemWin32::s_wndProc(): system not initialized")
 518
 519         if (hwnd) {
 520                 GHOST_WindowWin32* window = (GHOST_WindowWin32*)::GetWindowLong(hwnd, GWL_USERDATA);
 521                 if (window) {
 522                         switch (msg) {
 523                                 ////////////////////////////////////////////////////////////////////////
 524                                 // Keyboard events, processed
 525                                 ////////////////////////////////////////////////////////////////////////
 526                                 case WM_KEYDOWN:
 527                                         /* The WM_KEYDOWN message is posted to the window with the keyboard focus when a
 528                                          * nonsystem key is pressed. A nonsystem key is a key that is pressed when the alt
 529                                          * key is not pressed.
 530                                          */
 531                                 case WM_SYSKEYDOWN:
 532                                         /* The WM_SYSKEYDOWN message is posted to the window with the keyboard focus when
 533                                          * the user presses the F10 key (which activates the menu bar) or holds down the
 534                                          * alt key and then presses another key. It also occurs when no window currently
 535                                          * has the keyboard focus; in this case, the WM_SYSKEYDOWN message is sent to the
 536                                          * active window. The window that receives the message can distinguish between these
 537                                          * two contexts by checking the context code in the lKeyData parameter.
 538                                          */
 539                                         switch (wParam) {
 540                                                 case VK_SHIFT:
 541                                                 case VK_CONTROL:
 542                                                 case VK_MENU:
 543                                                         if (!system->m_seperateLeftRightInitialized) {
 544                                                                 // Check whether this system supports seperate left and right keys
 545                                                                 switch (wParam) {
 546                                                                         case VK_SHIFT:
 547                                                                                 system->m_seperateLeftRight =
 548                                                                                         (HIBYTE(::GetKeyState(VK_LSHIFT)) != 0) ||
 549                                                                                         (HIBYTE(::GetKeyState(VK_RSHIFT)) != 0) ?
 550                                                                                         true : false;
 551                                                                                 break;
 552                                                                         case VK_CONTROL:
 553                                                                                 system->m_seperateLeftRight =
 554                                                                                         (HIBYTE(::GetKeyState(VK_LCONTROL)) != 0) ||
 555                                                                                         (HIBYTE(::GetKeyState(VK_RCONTROL)) != 0) ?
 556                                                                                         true : false;
 557                                                                                 break;
 558                                                                         case VK_MENU:
 559                                                                                 system->m_seperateLeftRight =
 560                                                                                         (HIBYTE(::GetKeyState(VK_LMENU)) != 0) ||
 561                                                                                         (HIBYTE(::GetKeyState(VK_RMENU)) != 0) ?
 562                                                                                         true : false;
 563                                                                                 break;
 564                                                                 }
 565                                                                 system->m_seperateLeftRightInitialized = true;
 566                                                         }
 567                                                         system->processModifierKeys(window);
 568                                                         // Bypass call to DefWindowProc
 569                                                         return 0;
 570                                                 default:
 571                                                         event = processKeyEvent(window, true, wParam, lParam);
 572                                                         if (!event) {
 573                                                                 GHOST_PRINT("GHOST_SystemWin32::wndProc: key event ")
 574                                                                 GHOST_PRINT(msg)
 575                                                                 GHOST_PRINT(" key ignored\n")
 576                                                         }
 577                                                         break;
 578                                                 }
 579                                         break;
 580
 581                                 case WM_KEYUP:
 582                                 case WM_SYSKEYUP:
 583                                         switch (wParam) {
 584                                                 case VK_SHIFT:
 585                                                 case VK_CONTROL:
 586                                                 case VK_MENU:
 587                                                         system->processModifierKeys(window);
 588                                                         // Bypass call to DefWindowProc
 589                                                         return 0;
 590                                                 default:
 591                                                         event = processKeyEvent(window, false, wParam, lParam);
 592                                                         if (!event) {
 593                                                                 GHOST_PRINT("GHOST_SystemWin32::wndProc: key event ")
 594                                                                 GHOST_PRINT(msg)
 595                                                                 GHOST_PRINT(" key ignored\n")
 596                                                         }
 597                                                         break;
 598                                         }
 599                                         break;
 600
 601                                 ////////////////////////////////////////////////////////////////////////
 602                                 // Keyboard events, ignored
 603                                 ////////////////////////////////////////////////////////////////////////
 604                                 case WM_CHAR:
 605                                         /* The WM_CHAR message is posted to the window with the keyboard focus when
 606                                          * a WM_KEYDOWN message is translated by the TranslateMessage function. WM_CHAR
 607                                          * contains the character code of the key that was pressed.
 608                                          */
 609                                 case WM_DEADCHAR:
 610                                         /* The WM_DEADCHAR message is posted to the window with the keyboard focus when a
 611                                          * WM_KEYUP message is translated by the TranslateMessage function. WM_DEADCHAR
 612                                          * specifies a character code generated by a dead key. A dead key is a key that
 613                                          * generates a character, such as the umlaut (double-dot), that is combined with
 614                                          * another character to form a composite character. For example, the umlaut-O
 615                                          * character (Ù) is generated by typing the dead key for the umlaut character, and
 616                                          * then typing the O key.
 617                                          */
 618                                 case WM_SYSDEADCHAR:
 619                                         /* The WM_SYSDEADCHAR message is sent to the window with the keyboard focus when
 620                                          * a WM_SYSKEYDOWN message is translated by the TranslateMessage function.
 621                                          * WM_SYSDEADCHAR specifies the character code of a system dead key - that is,
 622                                          * a dead key that is pressed while holding down the alt key.
 623                                          */
 624                                         break;
 625
 626                                 ////////////////////////////////////////////////////////////////////////
 627                                 // Mouse events, processed
 628                                 ////////////////////////////////////////////////////////////////////////
 629                                 case WM_LBUTTONDOWN:
 630                                         window->registerMouseClickEvent(true);
 631                                         event = processButtonEvent(GHOST_kEventButtonDown, window, GHOST_kButtonMaskLeft);
 632                                         break;
 633                                 case WM_MBUTTONDOWN:
 634                                         window->registerMouseClickEvent(true);
 635                                         event = processButtonEvent(GHOST_kEventButtonDown, window, GHOST_kButtonMaskMiddle);
 636                                         break;
 637                                 case WM_RBUTTONDOWN:
 638                                         window->registerMouseClickEvent(true);
 639                                         event = processButtonEvent(GHOST_kEventButtonDown, window, GHOST_kButtonMaskRight);
 640                                         break;
 641                                 case WM_LBUTTONUP:
 642                                         window->registerMouseClickEvent(false);
 643                                         event = processButtonEvent(GHOST_kEventButtonUp, window, GHOST_kButtonMaskLeft);
 644                                         break;
 645                                 case WM_MBUTTONUP:
 646                                         window->registerMouseClickEvent(false);
 647                                         event = processButtonEvent(GHOST_kEventButtonUp, window, GHOST_kButtonMaskMiddle);
 648                                         break;
 649                                 case WM_RBUTTONUP:
 650                                         window->registerMouseClickEvent(false);
 651                                         event = processButtonEvent(GHOST_kEventButtonUp, window, GHOST_kButtonMaskRight);
 652                                         break;
 653                                 case WM_MOUSEMOVE:
 654                                         event = processCursorEvent(GHOST_kEventCursorMove, window);
 655                                         break;
 656                                 case WM_MOUSEWHEEL:
 657                                         /* The WM_MOUSEWHEEL message is sent to the focus window
 658                                          * when the mouse wheel is rotated. The DefWindowProc
 659                                          * function propagates the message to the window's parent.
 660                                          * There should be no internal forwarding of the message,
 661                                          * since DefWindowProc propagates it up the parent chain
 662                                          * until it finds a window that processes it.
 663                                          */
 664                                         event = processWheelEvent(window, wParam, lParam);
 665                                         break;
 666                                 case WM_SETCURSOR:
 667                                         /* The WM_SETCURSOR message is sent to a window if the mouse causes the cursor
 668                                          * to move within a window and mouse input is not captured.
 669                                          * This means we have to set the cursor shape every time the mouse moves!
 670                                          * The DefWindowProc function uses this message to set the cursor to an
 671                                          * arrow if it is not in the client area.
 672                                          */
 673                                         if (LOWORD(lParam) == HTCLIENT) {
 674                                                 // Load the current cursor
 675                                                 window->loadCursor(window->getCursorVisibility(), window->getCursorShape());
 676                                                 // Bypass call to DefWindowProc
 677                                                 return 0;
 678                                         }
 679                                         else {
 680                                                 // Outside of client area show standard cursor
 681                                                 window->loadCursor(true, GHOST_kStandardCursorDefault);
 682                                         }
 683                                         break;
 684
 685                                 ////////////////////////////////////////////////////////////////////////
 686                                 // Mouse events, ignored
 687                                 ////////////////////////////////////////////////////////////////////////
 688                                 case WM_NCMOUSEMOVE:
 689                                         /* The WM_NCMOUSEMOVE message is posted to a window when the cursor is moved
 690                                          * within the nonclient area of the window. This message is posted to the window
 691                                          * that contains the cursor. If a window has captured the mouse, this message is not posted.
 692                                          */
 693                                 case WM_NCHITTEST:
 694                                         /* The WM_NCHITTEST message is sent to a window when the cursor moves, or
 695                                          * when a mouse button is pressed or released. If the mouse is not captured,
 696                                          * the message is sent to the window beneath the cursor. Otherwise, the message
 697                                          * is sent to the window that has captured the mouse.
 698                                          */
 699                                         break;
 700
 701                                 ////////////////////////////////////////////////////////////////////////
 702                                 // Window events, processed
 703                                 ////////////////////////////////////////////////////////////////////////
 704                                 case WM_CLOSE:
 705                                         /* The WM_CLOSE message is sent as a signal that a window or an application should terminate. */
 706                                         event = processWindowEvent(GHOST_kEventWindowClose, window);
 707                                         break;
 708                                 case WM_ACTIVATE:
 709                                         /* The WM_ACTIVATE message is sent to both the window being activated and the window being
 710                                          * deactivated. If the windows use the same input queue, the message is sent synchronously,
 711                                          * first to the window procedure of the top-level window being deactivated, then to the window
 712                                          * procedure of the top-level window being activated. If the windows use different input queues,
 713                                          * the message is sent asynchronously, so the window is activated immediately.
 714                                          */
 715                                         event = processWindowEvent(LOWORD(wParam) ? GHOST_kEventWindowActivate : GHOST_kEventWindowDeactivate, window);
 716                                         break;
 717                                 case WM_PAINT:
 718                                         /* An application sends the WM_PAINT message when the system or another application
 719                                          * makes a request to paint a portion of an application's window. The message is sent
 720                                          * when the UpdateWindow or RedrawWindow function is called, or by the DispatchMessage
 721                                          * function when the application obtains a WM_PAINT message by using the GetMessage or
 722                                          * PeekMessage function.
 723                                          */
 724                                         event = processWindowEvent(GHOST_kEventWindowUpdate, window);
 725                                         ::ValidateRect(hwnd, NULL);
 726                                         break;
 727                                 case WM_SIZE:
 728                                         /* The WM_SIZE message is sent to a window after its size has changed.
 729                                          * The WM_SIZE and WM_MOVE messages are not sent if an application handles the
 730                                          * WM_WINDOWPOSCHANGED message without calling DefWindowProc. It is more efficient
 731                                          * to perform any move or size change processing during the WM_WINDOWPOSCHANGED
 732                                          * message without calling DefWindowProc.
 733                                          */
 734                                         event = processWindowEvent(GHOST_kEventWindowSize, window);
 735                                 case WM_CAPTURECHANGED:
 736                                         window->lostMouseCapture();
 737                                         break;
 738
 739                                 ////////////////////////////////////////////////////////////////////////
 740                                 // Window events, ignored
 741                                 ////////////////////////////////////////////////////////////////////////
 742                                 case WM_WINDOWPOSCHANGED:
 743                                         /* The WM_WINDOWPOSCHANGED message is sent to a window whose size, position, or place
 744                                          * in the Z order has changed as a result of a call to the SetWindowPos function or
 745                                          * another window-management function.
 746                                          * The WM_SIZE and WM_MOVE messages are not sent if an application handles the
 747                                          * WM_WINDOWPOSCHANGED message without calling DefWindowProc. It is more efficient
 748                                          * to perform any move or size change processing during the WM_WINDOWPOSCHANGED
 749                                          * message without calling DefWindowProc.
 750                                          */
 751                                 case WM_MOVE:
 752                                         /* The WM_SIZE and WM_MOVE messages are not sent if an application handles the
 753                                          * WM_WINDOWPOSCHANGED message without calling DefWindowProc. It is more efficient
 754                                          * to perform any move or size change processing during the WM_WINDOWPOSCHANGED
 755                                          * message without calling DefWindowProc.
 756                                          */
 757                                 case WM_ERASEBKGND:
 758                                         /* An application sends the WM_ERASEBKGND message when the window background must be
 759                                          * erased (for example, when a window is resized). The message is sent to prepare an
 760                                          * invalidated portion of a window for painting.
 761                                          */
 762                                 case WM_NCPAINT:
 763                                         /* An application sends the WM_NCPAINT message to a window when its frame must be painted. */
 764                                 case WM_NCACTIVATE:
 765                                         /* The WM_NCACTIVATE message is sent to a window when its nonclient area needs to be changed
 766                                          * to indicate an active or inactive state.
 767                                          */
 768                                 case WM_DESTROY:
 769                                         /* The WM_DESTROY message is sent when a window is being destroyed. It is sent to the window
 770                                          * procedure of the window being destroyed after the window is removed from the screen.
 771                                          * This message is sent first to the window being destroyed and then to the child windows
 772                                          * (if any) as they are destroyed. During the processing of the message, it can be assumed
 773                                          * that all child windows still exist.
 774                                          */
 775                                 case WM_NCDESTROY:
 776                                         /* The WM_NCDESTROY message informs a window that its nonclient area is being destroyed. The
 777                                          * DestroyWindow function sends the WM_NCDESTROY message to the window following the WM_DESTROY
 778                                          * message. WM_DESTROY is used to free the allocated memory object associated with the window.
 779                                          */
 780                                 case WM_KILLFOCUS:
 781                                         /* The WM_KILLFOCUS message is sent to a window immediately before it loses the keyboard focus. */
 782                                 case WM_SHOWWINDOW:
 783                                         /* The WM_SHOWWINDOW message is sent to a window when the window is about to be hidden or shown. */
 784                                 case WM_WINDOWPOSCHANGING:
 785                                         /* The WM_WINDOWPOSCHANGING message is sent to a window whose size, position, or place in
 786                                          * the Z order is about to change as a result of a call to the SetWindowPos function or
 787                                          * another window-management function.
 788                                          */
 789                                 case WM_SETFOCUS:
 790                                         /* The WM_SETFOCUS message is sent to a window after it has gained the keyboard focus. */
 791                                 case WM_MOVING:
 792                                         /* The WM_MOVING message is sent to a window that the user is moving. By processing
 793                                          * this message, an application can monitor the size and position of the drag rectangle
 794                                          * and, if needed, change its size or position.
 795                                          */
 796                                 case WM_ENTERSIZEMOVE:
 797                                         /* The WM_ENTERSIZEMOVE message is sent one time to a window after it enters the moving
 798                                          * or sizing modal loop. The window enters the moving or sizing modal loop when the user
 799                                          * clicks the window's title bar or sizing border, or when the window passes the
 800                                          * WM_SYSCOMMAND message to the DefWindowProc function and the wParam parameter of the
 801                                          * message specifies the SC_MOVE or SC_SIZE value. The operation is complete when
 802                                          * DefWindowProc returns.
 803                                          */
 804                                         break;
 805
 806                                 ////////////////////////////////////////////////////////////////////////
 807                                 // Other events
 808                                 ////////////////////////////////////////////////////////////////////////
 809                                 case WM_GETTEXT:
 810                                         /* An application sends a WM_GETTEXT message to copy the text that
 811                                          * corresponds to a window into a buffer provided by the caller.
 812                                          */
 813                                 case WM_ACTIVATEAPP:
 814                                         /* The WM_ACTIVATEAPP message is sent when a window belonging to a
 815                                          * different application than the active window is about to be activated.
 816                                          * The message is sent to the application whose window is being activated
 817                                          * and to the application whose window is being deactivated.
 818                                          */
 819                                 case WM_TIMER:
 820                                         /* The WIN32 docs say:
 821                                          * The WM_TIMER message is posted to the installing thread's message queue
 822                                          * when a timer expires. You can process the message by providing a WM_TIMER
 823                                          * case in the window procedure. Otherwise, the default window procedure will
 824                                          * call the TimerProc callback function specified in the call to the SetTimer
 825                                          * function used to install the timer.
 826                                          *
 827                                          * In GHOST, we let DefWindowProc call the timer callback.
 828                                          */
 829                                         break;
 830                         }
 831                 }
 832                 else {
 833                         // Event found for a window before the pointer to the class has been set.
 834                         GHOST_PRINT("GHOST_SystemWin32::wndProc: GHOST window event before creation\n")
 835                         /* These are events we typically miss at this point:
 836                            WM_GETMINMAXINFO     0x24
 837                            WM_NCCREATE                  0x81
 838                            WM_NCCALCSIZE                0x83
 839                            WM_CREATE                    0x01
 840                            We let DefWindowProc do the work.
 841                         */
 842                 }
 843         }
 844         else {
 845                 // Events without valid hwnd
 846                 GHOST_PRINT("GHOST_SystemWin32::wndProc: event without window\n")
 847         }
 848
 849         if (event) {
 850                 system->pushEvent(event);
 851                 lResult = 0;
 852         }
 853         else {
 854                 lResult = ::DefWindowProc(hwnd, msg, wParam, lParam);
 855         }
 856         return lResult;
 857 }