Otclient 1.0  14/8/2020
win32window.cpp
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2010-2020 OTClient <https://github.com/edubart/otclient>
3  *
4  * Permission is hereby granted, free of charge, to any person obtaining a copy
5  * of this software and associated documentation files (the "Software"), to deal
6  * in the Software without restriction, including without limitation the rights
7  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8  * copies of the Software, and to permit persons to whom the Software is
9  * furnished to do so, subject to the following conditions:
10  *
11  * The above copyright notice and this permission notice shall be included in
12  * all copies or substantial portions of the Software.
13  *
14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
20  * THE SOFTWARE.
21  */
22 
23 #ifdef WIN32
24 
25 #include "win32window.h"
26 #include <framework/graphics/image.h>
27 #include <framework/core/application.h>
28 #include <framework/core/resourcemanager.h>
29 
30 #define HSB_BIT_SET(p, n) (p[(n)/8] |= (128 >>((n)%8)))
31 
32 WIN32Window::WIN32Window()
33 {
34  m_window = 0;
35  m_instance = 0;
36  m_deviceContext = 0;
37  m_cursor = 0;
38  m_minimumSize = Size(600, 480);
39  m_size = Size(600, 480);
40  m_hidden = true;
41 
42 #ifdef OPENGL_ES
43  m_eglConfig = 0;
44  m_eglContext = 0;
45  m_eglDisplay = 0;
46  m_eglSurface = 0;
47 #else
48  m_wglContext = 0;
49 #endif
50 
51  m_keyMap[VK_ESCAPE] = Fw::KeyEscape;
52  m_keyMap[VK_TAB] = Fw::KeyTab;
53  m_keyMap[VK_RETURN] = Fw::KeyEnter;
54  m_keyMap[VK_BACK] = Fw::KeyBackspace;
55  m_keyMap[VK_SPACE] = Fw::KeySpace;
56 
57  m_keyMap[VK_PRIOR] = Fw::KeyPageUp;
58  m_keyMap[VK_NEXT] = Fw::KeyPageDown;
59  m_keyMap[VK_HOME] = Fw::KeyHome;
60  m_keyMap[VK_END] = Fw::KeyEnd;
61  m_keyMap[VK_INSERT] = Fw::KeyInsert;
62  m_keyMap[VK_DELETE] = Fw::KeyDelete;
63 
64  m_keyMap[VK_UP] = Fw::KeyUp;
65  m_keyMap[VK_DOWN] = Fw::KeyDown;
66  m_keyMap[VK_LEFT] = Fw::KeyLeft;
67  m_keyMap[VK_RIGHT] = Fw::KeyRight;
68 
69  m_keyMap[VK_NUMLOCK] = Fw::KeyNumLock;
70  m_keyMap[VK_SCROLL] = Fw::KeyScrollLock;
71  m_keyMap[VK_CAPITAL] = Fw::KeyCapsLock;
72  m_keyMap[VK_SNAPSHOT] = Fw::KeyPrintScreen;
73  m_keyMap[VK_PAUSE] = Fw::KeyPause;
74 
75  m_keyMap[VK_CONTROL] = Fw::KeyCtrl;
76  m_keyMap[VK_LCONTROL] = Fw::KeyCtrl;
77  m_keyMap[VK_RCONTROL] = Fw::KeyCtrl;
78  m_keyMap[VK_SHIFT] = Fw::KeyShift;
79  m_keyMap[VK_LSHIFT] = Fw::KeyShift;
80  m_keyMap[VK_RSHIFT] = Fw::KeyShift;
81  m_keyMap[VK_MENU] = Fw::KeyAlt;
82  m_keyMap[VK_LMENU] = Fw::KeyAlt;
83  m_keyMap[VK_RMENU] = Fw::KeyAlt;
84  m_keyMap[VK_LWIN] = Fw::KeyMeta;
85  m_keyMap[VK_RWIN] = Fw::KeyMeta;
86  m_keyMap[VK_APPS] = Fw::KeyMenu;
87 
88  // ascii characters
89  /*
90  m_keyMap['!'] = Fw::KeyExclamation;
91  m_keyMap['"'] = Fw::KeyQuote;
92  m_keyMap['#'] = Fw::KeyNumberSign;
93  m_keyMap['$'] = Fw::KeyDollar;
94  m_keyMap['%'] = Fw::KeyPercent;
95  m_keyMap['$'] = Fw::KeyAmpersand;
96  m_keyMap['\''] = Fw::KeyApostrophe;
97  m_keyMap['('] = Fw::KeyLeftParen;
98  m_keyMap[')'] = Fw::KeyRightParen;
99  m_keyMap['*'] = Fw::KeyAsterisk;
100  m_keyMap['+'] = Fw::KeyPlus;
101  m_keyMap['.'] = Fw::KeyComma;
102  m_keyMap['-'] = Fw::KeyMinus;
103  m_keyMap['.'] = Fw::KeyPeriod;
104  m_keyMap['/'] = Fw::KeySlash;
105  */
106 
107  m_keyMap['0'] = Fw::Key0;
108  m_keyMap['1'] = Fw::Key1;
109  m_keyMap['2'] = Fw::Key2;
110  m_keyMap['3'] = Fw::Key3;
111  m_keyMap['4'] = Fw::Key4;
112  m_keyMap['5'] = Fw::Key5;
113  m_keyMap['6'] = Fw::Key6;
114  m_keyMap['7'] = Fw::Key7;
115  m_keyMap['8'] = Fw::Key8;
116  m_keyMap['9'] = Fw::Key9;
117 
118  /*
119  m_keyMap[':'] = Fw::KeyColon;
120  m_keyMap[';'] = Fw::KeySemicolon;
121  m_keyMap['<'] = Fw::KeyLess;
122  m_keyMap['='] = Fw::KeyEqual;
123  m_keyMap['>'] = Fw::KeyGreater;
124  m_keyMap['?'] = Fw::KeyQuestion;
125  m_keyMap['@'] = Fw::KeyAtSign;
126  */
127 
128  m_keyMap['A'] = Fw::KeyA;
129  m_keyMap['B'] = Fw::KeyB;
130  m_keyMap['C'] = Fw::KeyC;
131  m_keyMap['D'] = Fw::KeyD;
132  m_keyMap['E'] = Fw::KeyE;
133  m_keyMap['F'] = Fw::KeyF;
134  m_keyMap['G'] = Fw::KeyG;
135  m_keyMap['H'] = Fw::KeyH;
136  m_keyMap['I'] = Fw::KeyI;
137  m_keyMap['J'] = Fw::KeyJ;
138  m_keyMap['K'] = Fw::KeyK;
139  m_keyMap['L'] = Fw::KeyL;
140  m_keyMap['M'] = Fw::KeyM;
141  m_keyMap['N'] = Fw::KeyN;
142  m_keyMap['O'] = Fw::KeyO;
143  m_keyMap['P'] = Fw::KeyP;
144  m_keyMap['Q'] = Fw::KeyQ;
145  m_keyMap['R'] = Fw::KeyR;
146  m_keyMap['S'] = Fw::KeyS;
147  m_keyMap['T'] = Fw::KeyT;
148  m_keyMap['U'] = Fw::KeyU;
149  m_keyMap['V'] = Fw::KeyV;
150  m_keyMap['W'] = Fw::KeyW;
151  m_keyMap['X'] = Fw::KeyX;
152  m_keyMap['Y'] = Fw::KeyY;
153  m_keyMap['Z'] = Fw::KeyZ;
154 
155  /*
156  m_keyMap['['] = Fw::KeyLeftBracket;
157  m_keyMap['\\'] = Fw::KeyBackslash;
158  m_keyMap[']'] = Fw::KeyRightBracket;
159  m_keyMap['^'] = Fw::KeyCaret;
160  m_keyMap['_'] = Fw::KeyUnderscore;
161  m_keyMap['`'] = Fw::KeyGrave;
162  m_keyMap['{'] = Fw::KeyLeftCurly;
163  m_keyMap['|'] = Fw::KeyBar;
164  m_keyMap['}'] = Fw::KeyRightCurly;
165  m_keyMap['~'] = Fw::KeyTilde;
166  */
167 
168  // keypad
169  /*
170  m_keyMap[VK_ADD] = Fw::KeyPlus;
171  m_keyMap[VK_SUBTRACT] = Fw::KeyMinus;
172  m_keyMap[VK_DECIMAL] = Fw::KeyPeriod;
173  m_keyMap[VK_DIVIDE] = Fw::KeySlash;
174  m_keyMap[VK_MULTIPLY] = Fw::KeyAsterisk;
175  */
176 
177  m_keyMap[VK_OEM_1] = Fw::KeySemicolon;
178  m_keyMap[VK_OEM_2] = Fw::KeySlash;
179  m_keyMap[VK_OEM_3] = Fw::KeyGrave;
180  m_keyMap[VK_OEM_4] = Fw::KeyLeftBracket;
181  m_keyMap[VK_OEM_5] = Fw::KeyBackslash;
182  m_keyMap[VK_OEM_6] = Fw::KeyRightBracket;
183  m_keyMap[VK_OEM_7] = Fw::KeyApostrophe;
184  m_keyMap[VK_OEM_MINUS] = Fw::KeyMinus;
185  m_keyMap[VK_OEM_PLUS] = Fw::KeyEqual;
186  m_keyMap[VK_OEM_COMMA] = Fw::KeyComma;
187  m_keyMap[VK_OEM_PERIOD] = Fw::KeyPeriod;
188 
189  m_keyMap[VK_F1] = Fw::KeyF1;
190  m_keyMap[VK_F2] = Fw::KeyF2;
191  m_keyMap[VK_F3] = Fw::KeyF3;
192  m_keyMap[VK_F4] = Fw::KeyF4;
193  m_keyMap[VK_F5] = Fw::KeyF5;
194  m_keyMap[VK_F6] = Fw::KeyF6;
195  m_keyMap[VK_F7] = Fw::KeyF7;
196  m_keyMap[VK_F8] = Fw::KeyF8;
197  m_keyMap[VK_F9] = Fw::KeyF9;
198  m_keyMap[VK_F10] = Fw::KeyF10;
199  m_keyMap[VK_F11] = Fw::KeyF11;
200  m_keyMap[VK_F12] = Fw::KeyF12;
201 }
202 
203 void WIN32Window::init()
204 {
205  m_instance = GetModuleHandle(NULL);
206 
207 #ifdef DIRECTX
208  m_d3d = Direct3DCreate9(D3D_SDK_VERSION); // create the Direct3D interface
209 
210  D3DPRESENT_PARAMETERS d3dpp; // create a struct to hold various device information
211 
212  ZeroMemory(&d3dpp, sizeof(d3dpp)); // clear out the struct for use
213  d3dpp.Windowed = TRUE; // program windowed, not fullscreen
214  d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD; // discard old frames
215  d3dpp.hDeviceWindow = m_window; // set the window to be used by Direct3D
216 
217  // create a device class using this information and information from the d3dpp stuct
218  m_d3d->CreateDevice(D3DADAPTER_DEFAULT,
219  D3DDEVTYPE_HAL,
220  m_window,
221  D3DCREATE_SOFTWARE_VERTEXPROCESSING,
222  &d3dpp,
223  &m_d3ddev);
224 
225 #endif
226 
227  internalCreateWindow();
228  internalCreateGLContext();
229  internalRestoreGLContext();
230 }
231 
232 void WIN32Window::terminate()
233 {
234  SetCursor(NULL);
235  if (m_defaultCursor) {
236  DestroyCursor(m_defaultCursor);
237  m_defaultCursor = NULL;
238  }
239 
240  for (HCURSOR& cursor : m_cursors)
241  DestroyCursor(cursor);
242  m_cursors.clear();
243 
244  internalDestroyGLContext();
245 
246  if (m_deviceContext) {
247  if (!ReleaseDC(m_window, m_deviceContext))
248  g_logger.error("Release device context failed.");
249  m_deviceContext = NULL;
250  }
251 
252  if (m_window) {
253  if (!DestroyWindow(m_window))
254  g_logger.error("ERROR: Destroy window failed.");
255  m_window = NULL;
256  }
257 
258  if (m_instance) {
259  if (!UnregisterClassA(g_app.getCompactName().c_str(), m_instance))
260  g_logger.error("UnregisterClassA failed");
261  m_instance = NULL;
262  }
263 }
264 
265 struct WindowProcProxy {
266  static LRESULT CALLBACK call(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
267  WIN32Window* window = static_cast<WIN32Window*>(&g_window);
268  return window->windowProc(hWnd, uMsg, wParam, lParam);
269  }
270 };
271 
272 void WIN32Window::internalCreateWindow()
273 {
274  m_defaultCursor = LoadCursor(NULL, IDC_ARROW);
275  WNDCLASSA wc;
276  wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
277  wc.lpfnWndProc = static_cast<WNDPROC>(WindowProcProxy::call);
278  wc.cbClsExtra = 0;
279  wc.cbWndExtra = 0;
280  wc.hInstance = m_instance;
281  wc.hIcon = LoadIcon(NULL, IDI_WINLOGO);
282  wc.hCursor = m_defaultCursor;
283  wc.hbrBackground = static_cast<HBRUSH>(GetStockObject(WHITE_BRUSH));
284  wc.lpszMenuName = NULL;
285  wc.lpszClassName = g_app.getCompactName().c_str();
286 
287  if (!RegisterClassA(&wc))
288  g_logger.fatal("Failed to register the window class.");
289  DWORD dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;
290  DWORD dwStyle = WS_OVERLAPPEDWINDOW;
291 
292  // initialize in the center of the screen
293  m_position = ((getDisplaySize() - m_size) / 2).toPoint();
294 
295  Rect screenRect = adjustWindowRect(Rect(m_position, m_size));
296 
297  updateUnmaximizedCoords();
298  m_window = CreateWindowExA(dwExStyle,
299  g_app.getCompactName().c_str(),
300  NULL,
301  dwStyle,
302  screenRect.left(),
303  screenRect.top(),
304  screenRect.width(),
305  screenRect.height(),
306  NULL,
307  NULL,
308  m_instance,
309  NULL);
310 
311  if (!m_window)
312  g_logger.fatal("Unable to create window");
313 
314  ShowWindow(m_window, SW_HIDE);
315 
316  m_deviceContext = GetDC(m_window);
317  if (!m_deviceContext)
318  g_logger.fatal("GetDC failed");
319 }
320 
321 void WIN32Window::internalCreateGLContext()
322 {
323 #ifdef OPENGL_ES
324  m_eglDisplay = eglGetDisplay(m_deviceContext);
325  if (m_eglDisplay == EGL_NO_DISPLAY)
326  g_logger.fatal("EGL not supported");
327 
328  if (!eglInitialize(m_eglDisplay, NULL, NULL))
329  g_logger.fatal("Unable to initialize EGL");
330 
331  static int configList[] = {
332 #if OPENGL_ES==2
333  EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
334 #else
335  EGL_RENDERABLE_TYPE, EGL_OPENGL_ES_BIT,
336 #endif
337  EGL_RED_SIZE, 4,
338  EGL_GREEN_SIZE, 4,
339  EGL_BLUE_SIZE, 4,
340  EGL_ALPHA_SIZE, 4,
341  EGL_NONE
342  };
343 
344  EGLint numConfig;
345 
346  if (!eglGetConfigs(m_eglDisplay, NULL, 0, &numConfig))
347  g_logger.fatal("No valid GL configurations");
348 
349  if (!eglChooseConfig(m_eglDisplay, configList, &m_eglConfig, 1, &numConfig))
350  g_logger.fatal("Failed to choose EGL config");
351 
352  if (numConfig != 1)
353  g_logger.warning("Didn't got the exact EGL config");
354 
355  EGLint contextAtrrList[] = {
356 #if OPENGL_ES==2
357  EGL_CONTEXT_CLIENT_VERSION, 2,
358 #else
359  EGL_CONTEXT_CLIENT_VERSION, 1,
360 #endif
361  EGL_NONE
362  };
363 
364  m_eglSurface = eglCreateWindowSurface(m_eglDisplay, m_eglConfig, m_window, NULL);
365  if (m_eglSurface == EGL_NO_SURFACE)
366  g_logger.fatal(stdext::format("Unable to create EGL surface: %s", eglGetError()));
367 
368  m_eglContext = eglCreateContext(m_eglDisplay, m_eglConfig, EGL_NO_CONTEXT, contextAtrrList);
369  if (m_eglContext == EGL_NO_CONTEXT)
370  g_logger.fatal(stdext::format("Unable to create EGL context: %s", eglGetError()));
371 
372 #else
373  uint pixelFormat;
374  static PIXELFORMATDESCRIPTOR pfd = { sizeof(PIXELFORMATDESCRIPTOR),
375  1,
376  PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
377  PFD_TYPE_RGBA,
378  32, // Select Our Color Depth
379  8, 0, 8, 0, 8, 0, // Color Bits Ignored
380  8, // Alpha Buffer Bits
381  0, // Shift Bit Ignored
382  0, // No Accumulation Buffer
383  0, 0, 0, 0, // Accumulation Bits Ignored
384  0, // Z-Buffer (Depth Buffer)
385  0, // No Stencil Buffer
386  0, // No Auxiliary Buffer
387  PFD_MAIN_PLANE, // Main Drawing Layer
388  0, // Reserved
389  0, 0, 0 }; // Layer Masks Ignored
390 
391  pixelFormat = ChoosePixelFormat(m_deviceContext, &pfd);
392  if (!pixelFormat)
393  g_logger.fatal("Could not find a suitable pixel format");
394 
395  if (!SetPixelFormat(m_deviceContext, pixelFormat, &pfd))
396  g_logger.fatal("Could not set the pixel format");
397 
398  if ((m_wglContext = wglCreateContext(m_deviceContext)) == nullptr)
399  g_logger.fatal("Unable to create GL context");
400 #endif
401 }
402 
403 void WIN32Window::internalDestroyGLContext()
404 {
405 #ifdef OPENGL_ES
406  if (m_eglDisplay) {
407  if (m_eglContext) {
408  eglDestroyContext(m_eglDisplay, m_eglContext);
409  m_eglContext = 0;
410  }
411  if (m_eglSurface) {
412  eglDestroySurface(m_eglDisplay, m_eglSurface);
413  m_eglSurface = 0;
414  }
415  eglTerminate(m_eglDisplay);
416  m_eglDisplay = 0;
417  }
418 #else
419  if (m_wglContext) {
420  if (!wglMakeCurrent(NULL, NULL))
421  g_logger.error("Release of dc and rc failed.");
422  if (!wglDeleteContext(m_wglContext))
423  g_logger.error("Release rendering context failed.");
424  m_wglContext = NULL;
425  }
426 #endif
427 }
428 
429 void WIN32Window::internalRestoreGLContext()
430 {
431 #ifdef OPENGL_ES
432  if (!eglMakeCurrent(m_eglDisplay, m_eglSurface, m_eglSurface, m_eglContext))
433  g_logger.fatal("Unable to make current EGL context");
434 #else
435  if (!wglMakeCurrent(m_deviceContext, m_wglContext))
436  g_logger.fatal("Unable to make current WGL context");
437 #endif
438 }
439 
440 bool WIN32Window::isExtensionSupported(const char* ext)
441 {
442 #ifdef OPENGL_ES
443  //TODO
444  return false;
445 #else
446  typedef const char* (WINAPI* wglGetExtensionsStringProc)();
447  wglGetExtensionsStringProc wglGetExtensionsString = static_cast<wglGetExtensionsStringProc>(getExtensionProcAddress("wglGetExtensionsStringEXT"));
448  if (!wglGetExtensionsString)
449  return false;
450 
451  const char* exts = wglGetExtensionsString();
452  if (exts && strstr(exts, ext))
453  return true;
454 
455  return false;
456 #endif
457 }
458 
459 void* WIN32Window::getExtensionProcAddress(const char* ext)
460 {
461 #ifdef OPENGL_ES
462  //TODO
463  return NULL;
464 #else
465  return static_cast<void*>(wglGetProcAddress(ext));
466 #endif
467 }
468 
469 void WIN32Window::move(const Point& pos)
470 {
471  Rect clientRect(pos, getClientRect().size());
472  Rect windowRect = adjustWindowRect(clientRect);
473  MoveWindow(m_window, windowRect.x(), windowRect.y(), windowRect.width(), windowRect.height(), TRUE);
474  if (m_hidden)
475  ShowWindow(m_window, SW_HIDE);
476 }
477 
478 void WIN32Window::resize(const Size& size)
479 {
480  if (size.width() < m_minimumSize.width() || size.height() < m_minimumSize.height())
481  return;
482  Rect clientRect(getClientRect().topLeft(), size);
483  Rect windowRect = adjustWindowRect(clientRect);
484  MoveWindow(m_window, windowRect.x(), windowRect.y(), windowRect.width(), windowRect.height(), TRUE);
485  if (m_hidden)
486  ShowWindow(m_window, SW_HIDE);
487 }
488 
489 void WIN32Window::show()
490 {
491  m_hidden = false;
492  if (m_maximized)
493  ShowWindow(m_window, SW_MAXIMIZE);
494  else
495  ShowWindow(m_window, SW_SHOW);
496 }
497 
498 void WIN32Window::hide()
499 {
500  m_hidden = true;
501  ShowWindow(m_window, SW_HIDE);
502 }
503 
504 void WIN32Window::maximize()
505 {
506  if (!m_hidden)
507  ShowWindow(m_window, SW_MAXIMIZE);
508  else
509  m_maximized = true;
510 }
511 
512 void WIN32Window::poll()
513 {
514  fireKeysPress();
515 
516  MSG msg;
517  while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
518  TranslateMessage(&msg);
519  DispatchMessage(&msg);
520  }
521 
522  updateUnmaximizedCoords();
523 }
524 
525 Fw::Key WIN32Window::retranslateVirtualKey(WPARAM wParam, LPARAM lParam)
526 {
527  // ignore numpad keys when numlock is on
528  if ((wParam >= VK_NUMPAD0 && wParam <= VK_NUMPAD9) || wParam == VK_SEPARATOR)
529  return Fw::KeyUnknown;
530 
531  // lParam will have this state when receiving insert,end,down,etc presses from numpad
532  if (!(((HIWORD(lParam) >> 8) & 0xFF) & 1)) {
533  bool numlockOn = GetKeyState(VK_NUMLOCK);
534  // retranslate numpad keys
535  switch (wParam) {
536  case VK_INSERT:
537  return numlockOn ? Fw::KeyUnknown : Fw::KeyNumpad0;
538  case VK_END:
539  return numlockOn ? Fw::KeyUnknown : Fw::KeyNumpad1;
540  case VK_DOWN:
541  return numlockOn ? Fw::KeyUnknown : Fw::KeyNumpad2;
542  case VK_NEXT:
543  return numlockOn ? Fw::KeyUnknown : Fw::KeyNumpad3;
544  case VK_LEFT:
545  return numlockOn ? Fw::KeyUnknown : Fw::KeyNumpad4;
546  case VK_CLEAR:
547  return numlockOn ? Fw::KeyUnknown : Fw::KeyNumpad5;
548  case VK_RIGHT:
549  return numlockOn ? Fw::KeyUnknown : Fw::KeyNumpad6;
550  case VK_HOME:
551  return numlockOn ? Fw::KeyUnknown : Fw::KeyNumpad7;
552  case VK_UP:
553  return numlockOn ? Fw::KeyUnknown : Fw::KeyNumpad8;
554  case VK_PRIOR:
555  return numlockOn ? Fw::KeyUnknown : Fw::KeyNumpad9;
556  }
557  }
558 
559  Fw::Key key = Fw::KeyUnknown;
560  if (m_keyMap.find(wParam) != m_keyMap.end())
561  key = m_keyMap[wParam];
562 
563  // actually ignore alt/ctrl/shift keys, they is states are already stored in m_inputEvent.keyboardModifiers
564  if (key == Fw::KeyAlt || key == Fw::KeyCtrl || key == Fw::KeyShift)
565  key = Fw::KeyUnknown;
566 
567  return key;
568 }
569 
570 #define IsKeyDown(a) (GetKeyState(a) & 0x80)
571 
572 LRESULT WIN32Window::windowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
573 {
574  m_inputEvent.keyboardModifiers = 0;
575  if (IsKeyDown(VK_CONTROL))
576  m_inputEvent.keyboardModifiers |= Fw::KeyboardCtrlModifier;
577  if (IsKeyDown(VK_SHIFT))
578  m_inputEvent.keyboardModifiers |= Fw::KeyboardShiftModifier;
579  if (IsKeyDown(VK_MENU))
580  m_inputEvent.keyboardModifiers |= Fw::KeyboardAltModifier;
581 
582  switch (uMsg)
583  {
584  case WM_SETCURSOR:
585  {
586  if (m_cursor)
587  SetCursor(m_cursor);
588  else
589  return DefWindowProc(hWnd, uMsg, wParam, lParam);
590  break;
591  }
592  case WM_ACTIVATE:
593  {
594  m_focused = !(wParam == WA_INACTIVE);
595  releaseAllKeys();
596  break;
597  }
598  case WM_SETFOCUS:
599  case WM_KILLFOCUS:
600  {
601  releaseAllKeys();
602  break;
603  }
604  case WM_CHAR:
605  {
606  if (wParam >= 32 && wParam <= 255) {
607  m_inputEvent.reset(Fw::KeyTextInputEvent);
608  m_inputEvent.keyText = wParam;
609  if (m_onInputEvent)
610  m_onInputEvent(m_inputEvent);
611  }
612  break;
613  }
614  case WM_CLOSE:
615  {
616  m_onClose();
617  break;
618  }
619  case WM_KEYDOWN:
620  {
621  processKeyDown(retranslateVirtualKey(wParam, lParam));
622  break;
623  }
624  case WM_KEYUP:
625  {
626  processKeyUp(retranslateVirtualKey(wParam, lParam));
627  break;
628  }
629  case WM_SYSKEYUP:
630  {
631  processKeyUp(retranslateVirtualKey(wParam, lParam));
632  break;
633  }
634  case WM_SYSKEYDOWN:
635  {
636  if (wParam == VK_F4 && m_inputEvent.keyboardModifiers & Fw::KeyboardAltModifier)
637  return DefWindowProc(hWnd, uMsg, wParam, lParam);
638 
639  processKeyDown(retranslateVirtualKey(wParam, lParam));
640  break;
641  }
642  case WM_LBUTTONDOWN:
643  {
644  SetCapture(m_window);
645  m_inputEvent.reset(Fw::MousePressInputEvent);
646  m_inputEvent.mouseButton = Fw::MouseLeftButton;
647  m_mouseButtonStates[Fw::MouseLeftButton] = true;
648  if (m_onInputEvent)
649  m_onInputEvent(m_inputEvent);
650  break;
651  }
652  case WM_LBUTTONUP:
653  {
654  SetCapture(NULL);
655  m_inputEvent.reset(Fw::MouseReleaseInputEvent);
656  m_inputEvent.mouseButton = Fw::MouseLeftButton;
657  m_mouseButtonStates[Fw::MouseLeftButton] = false;
658  if (m_onInputEvent)
659  m_onInputEvent(m_inputEvent);
660  break;
661  }
662  case WM_MBUTTONDOWN:
663  {
664  SetCapture(m_window);
665  m_inputEvent.reset(Fw::MousePressInputEvent);
666  m_inputEvent.mouseButton = Fw::MouseMidButton;
667  m_mouseButtonStates[Fw::MouseMidButton] = true;
668  if (m_onInputEvent)
669  m_onInputEvent(m_inputEvent);
670  break;
671  }
672  case WM_MBUTTONUP:
673  {
674  SetCapture(NULL);
675  m_inputEvent.reset(Fw::MouseReleaseInputEvent);
676  m_inputEvent.mouseButton = Fw::MouseMidButton;
677  m_mouseButtonStates[Fw::MouseMidButton] = false;
678  if (m_onInputEvent)
679  m_onInputEvent(m_inputEvent);
680  break;
681  }
682  case WM_RBUTTONDOWN:
683  {
684  SetCapture(m_window);
685  m_inputEvent.reset(Fw::MousePressInputEvent);
686  m_inputEvent.mouseButton = Fw::MouseRightButton;
687  m_mouseButtonStates[Fw::MouseRightButton] = true;
688  if (m_onInputEvent)
689  m_onInputEvent(m_inputEvent);
690  break;
691  }
692  case WM_RBUTTONUP:
693  {
694  SetCapture(NULL);
695  m_inputEvent.reset(Fw::MouseReleaseInputEvent);
696  m_inputEvent.mouseButton = Fw::MouseRightButton;
697  m_mouseButtonStates[Fw::MouseRightButton] = false;
698  if (m_onInputEvent)
699  m_onInputEvent(m_inputEvent);
700  break;
701  }
702  case WM_MOUSEMOVE:
703  {
704  m_inputEvent.reset(Fw::MouseMoveInputEvent);
705 
706  Point newMousePos(LOWORD(lParam), HIWORD(lParam));
707  if (newMousePos.x >= 32767)
708  newMousePos.x = 0;
709  else
710  newMousePos.x = std::min<int32>(newMousePos.x, m_size.width());
711 
712  if (newMousePos.y >= 32767)
713  newMousePos.y = 0;
714  else
715  newMousePos.y = std::min<int32>(newMousePos.y, m_size.height());
716 
717  m_inputEvent.mouseMoved = newMousePos - m_inputEvent.mousePos;
718  m_inputEvent.mousePos = newMousePos;
719  if (m_onInputEvent)
720  m_onInputEvent(m_inputEvent);
721  break;
722  }
723  case WM_MOUSEWHEEL:
724  {
725  m_inputEvent.reset(Fw::MouseWheelInputEvent);
726  m_inputEvent.mouseButton = Fw::MouseMidButton;
727  m_inputEvent.wheelDirection = static_cast<short>(HIWORD(wParam)) > 0 ? Fw::MouseWheelUp : Fw::MouseWheelDown;
728  if (m_onInputEvent)
729  m_onInputEvent(m_inputEvent);
730  break;
731  }
732  case WM_MOVE:
733  {
734  m_position.x = static_cast<short>(LOWORD(lParam));
735  m_position.y = static_cast<short>(HIWORD(lParam));
736  break;
737  }
738  case WM_GETMINMAXINFO:
739  {
740  LPMINMAXINFO pMMI = (LPMINMAXINFO)lParam;
741  Rect adjustedRect = adjustWindowRect(Rect(0, 0, m_minimumSize));
742  pMMI->ptMinTrackSize.x = adjustedRect.width();
743  pMMI->ptMinTrackSize.y = adjustedRect.height();
744  break;
745  }
746  case WM_SIZE:
747  {
748  bool forceResize = false;
749  switch (wParam) {
750  case SIZE_MAXIMIZED:
751  m_maximized = true;
752  m_visible = true;
753  forceResize = true;
754  break;
755  case SIZE_RESTORED:
756  m_maximized = false;
757  m_visible = true;
758  forceResize = true;
759  break;
760  case SIZE_MINIMIZED:
761  m_visible = false;
762  break;
763  }
764 
765  if (m_visible && m_deviceContext)
766  internalRestoreGLContext();
767 
768  Size size = Size(LOWORD(lParam), HIWORD(lParam));
769  size.setWidth(std::max<int32>(std::min<int32>(size.width(), 7680), 32));
770  size.setHeight(std::max<int32>(std::min<int32>(size.height(), 4320), 32));
771 
772  if (m_visible && (forceResize || m_size != size)) {
773  m_size = size;
774  m_onResize(m_size);
775  }
776 
777  break;
778  }
779  default:
780  return DefWindowProc(hWnd, uMsg, wParam, lParam);
781  }
782 
783  return 0;
784 }
785 
786 void WIN32Window::swapBuffers()
787 {
788 #ifdef OPENGL_ES
789  eglSwapBuffers(m_eglDisplay, m_eglSurface);
790 #else
791  SwapBuffers(m_deviceContext);
792 #endif
793 }
794 
795 void WIN32Window::showMouse()
796 {
797  ShowCursor(true);
798 }
799 
800 void WIN32Window::hideMouse()
801 {
802  ShowCursor(false);
803 }
804 
805 void WIN32Window::displayFatalError(const std::string& message)
806 {
807  MessageBoxW(m_window, stdext::latin1_to_utf16(message).c_str(), L"FATAL ERROR", MB_OK | MB_ICONERROR);
808 }
809 
810 int WIN32Window::internalLoadMouseCursor(const ImagePtr& image, const Point& hotSpot)
811 {
812  int width = image->getWidth();
813  int height = image->getHeight();
814  int numbits = width * height;
815  int numbytes = (width * height) / 8;
816 
817  std::vector<uchar> andMask(numbytes, 0);
818  std::vector<uchar> xorMask(numbytes, 0);
819 
820  for (int i = 0; i < numbits; ++i) {
821  uint32 rgba = stdext::readULE32(image->getPixelData() + i * 4);
822  if (rgba == 0xffffffff) { //white
823  HSB_BIT_SET(xorMask, i);
824  }
825  else if (rgba == 0x00000000) { //alpha
826  HSB_BIT_SET(andMask, i);
827  } // otherwise 0xff000000 => black
828  }
829 
830  HCURSOR cursor = CreateCursor(m_instance, hotSpot.x, hotSpot.y, width, height, &andMask[0], &xorMask[0]);
831  m_cursors.push_back(cursor);
832  return m_cursors.size() - 1;
833 }
834 
835 void WIN32Window::setMouseCursor(int cursorId)
836 {
837  if (cursorId >= static_cast<int>(m_cursors.size()) || cursorId < 0)
838  return;
839 
840  m_cursor = m_cursors[cursorId];
841  SetCursor(m_cursor);
842  ShowCursor(true);
843 }
844 
845 void WIN32Window::restoreMouseCursor()
846 {
847  if (m_cursor) {
848  m_cursor = NULL;
849  SetCursor(m_defaultCursor);
850  ShowCursor(true);
851  }
852 }
853 
854 void WIN32Window::setTitle(const std::string& title)
855 {
856  SetWindowTextW(m_window, stdext::latin1_to_utf16(title).c_str());
857 }
858 
859 void WIN32Window::setMinimumSize(const Size& minimumSize)
860 {
861  m_minimumSize = minimumSize;
862 }
863 
864 void WIN32Window::setFullscreen(bool fullscreen)
865 {
866  if (m_fullscreen == fullscreen)
867  return;
868 
869  m_fullscreen = fullscreen;
870 
871  DWORD dwStyle = GetWindowLong(m_window, GWL_STYLE);
872  static WINDOWPLACEMENT wpPrev;
873  wpPrev.length = sizeof(wpPrev);
874 
875  if (fullscreen) {
876  Size size = getDisplaySize();
877  GetWindowPlacement(m_window, &wpPrev);
878  SetWindowLong(m_window, GWL_STYLE, (dwStyle & ~WS_OVERLAPPEDWINDOW) | WS_POPUP | WS_EX_TOPMOST);
879  SetWindowPos(m_window, HWND_TOPMOST, 0, 0, size.width(), size.height(), SWP_FRAMECHANGED);
880  }
881  else {
882  SetWindowLong(m_window, GWL_STYLE, (dwStyle & ~(WS_POPUP | WS_EX_TOPMOST)) | WS_OVERLAPPEDWINDOW);
883  SetWindowPlacement(m_window, &wpPrev);
884  SetWindowPos(m_window, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_FRAMECHANGED);
885  }
886 }
887 
888 void WIN32Window::setVerticalSync(bool enable)
889 {
890 #ifdef OPENGL_ES
891  eglSwapInterval(m_eglDisplay, enable ? 1 : 0);
892 #else
893  if (!isExtensionSupported("WGL_EXT_swap_control"))
894  return;
895 
896  typedef BOOL(WINAPI* wglSwapIntervalProc)(int);
897  wglSwapIntervalProc wglSwapInterval = static_cast<wglSwapIntervalProc>(getExtensionProcAddress("wglSwapIntervalEXT"));
898  if (!wglSwapInterval)
899  return;
900 
901  wglSwapInterval(enable ? 1 : 0);
902 #endif
903 }
904 
905 void WIN32Window::setIcon(const std::string& file)
906 {
907  ImagePtr image = Image::load(file);
908 
909  if (!image) {
910  g_logger.traceError(stdext::format("unable to load icon file %s", file));
911  return;
912  }
913 
914  if (image->getBpp() != 4) {
915  g_logger.error("the app icon must have 4 channels");
916  return;
917  }
918 
919  int n = image->getWidth() * image->getHeight();
920  std::vector<uint32> iconData(n);
921  for (int i = 0; i < n; ++i) {
922  uint8* pixel = (uint8*)&iconData[i];
923  pixel[2] = *(image->getPixelData() + (i * 4) + 0);
924  pixel[1] = *(image->getPixelData() + (i * 4) + 1);
925  pixel[0] = *(image->getPixelData() + (i * 4) + 2);
926  pixel[3] = *(image->getPixelData() + (i * 4) + 3);
927  }
928 
929  HBITMAP hbmColor = CreateBitmap(image->getWidth(), image->getHeight(), 1, 32, &iconData[0]);
930  HBITMAP hbmMask = CreateCompatibleBitmap(GetDC(NULL), image->getWidth(), image->getHeight());
931 
932  ICONINFO ii;
933  ii.fIcon = TRUE;
934  ii.hbmColor = hbmColor;
935  ii.hbmMask = hbmMask;
936  ii.xHotspot = 0;
937  ii.yHotspot = 0;
938 
939  HICON icon = CreateIconIndirect(&ii);
940  DeleteObject(hbmMask);
941  DeleteObject(hbmColor);
942 
943  SendMessage(m_window, WM_SETICON, ICON_SMALL, (LPARAM)icon);
944  SendMessage(m_window, WM_SETICON, ICON_BIG, (LPARAM)icon);
945 }
946 
947 void WIN32Window::setClipboardText(const std::string& text)
948 {
949  if (!OpenClipboard(m_window))
950  return;
951 
952  HGLOBAL hglb = GlobalAlloc(GMEM_MOVEABLE, (text.length() + 1) * sizeof(WCHAR));
953  if (!hglb)
954  return;
955 
956  std::wstring wtext = stdext::latin1_to_utf16(text);
957 
958  LPWSTR lpwstr = static_cast<LPWSTR>(GlobalLock(hglb));
959  memcpy(lpwstr, (char*)&wtext[0], wtext.length() * sizeof(WCHAR));
960  lpwstr[text.length()] = static_cast<WCHAR>(0);
961  GlobalUnlock(hglb);
962 
963  EmptyClipboard();
964  SetClipboardData(CF_UNICODETEXT, hglb);
965  CloseClipboard();
966 }
967 
968 Size WIN32Window::getDisplaySize()
969 {
970  return Size(GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN));
971 }
972 
973 std::string WIN32Window::getClipboardText()
974 {
975  std::string text;
976 
977  if (!OpenClipboard(m_window))
978  return text;
979 
980  HGLOBAL hglb = GetClipboardData(CF_UNICODETEXT);
981  if (hglb) {
982  LPWSTR lpwstr = static_cast<LPWSTR>(GlobalLock(hglb));
983  if (lpwstr) {
984  text = stdext::utf16_to_latin1(lpwstr);
985  GlobalUnlock(hglb);
986  }
987  }
988  CloseClipboard();
989  return text;
990 }
991 
992 
993 std::string WIN32Window::getPlatformType()
994 {
995 #ifndef OPENGL_ES
996  return "WIN32-WGL";
997 #else
998  return "WIN32-EGL";
999 #endif
1000 }
1001 
1002 Rect WIN32Window::getClientRect()
1003 {
1004  if (m_window) {
1005  RECT clientRect = { 0,0,0,0 };
1006  int ret = GetClientRect(m_window, &clientRect);
1007  assert(ret != 0);
1008  return Rect(Point(clientRect.left, clientRect.top), Point(clientRect.right, clientRect.bottom));
1009  }
1010  else {
1011  return Rect(m_position, m_size);
1012  }
1013 }
1014 
1015 Rect WIN32Window::getWindowRect()
1016 {
1017  if (m_window) {
1018  RECT windowRect = { 0,0,0,0 };
1019  int ret = GetWindowRect(m_window, &windowRect);
1020  assert(ret != 0);
1021  return Rect(Point(windowRect.left, windowRect.top), Point(windowRect.right, windowRect.bottom));
1022  }
1023  else {
1024  return adjustWindowRect(getClientRect());
1025  }
1026 }
1027 
1028 Rect WIN32Window::adjustWindowRect(const Rect& clientRect)
1029 {
1030  Rect rect;
1031  DWORD dwStyle;
1032  DWORD dwExStyle;
1033  RECT windowRect = { clientRect.left(), clientRect.top(), clientRect.right(), clientRect.bottom() };
1034  if (m_window) {
1035  dwStyle = GetWindowLong(m_window, GWL_STYLE);
1036  dwExStyle = GetWindowLong(m_window, GWL_EXSTYLE);
1037  }
1038  else {
1039  dwStyle = WS_OVERLAPPEDWINDOW;
1040  dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;
1041  }
1042  if (AdjustWindowRectEx(&windowRect, dwStyle, FALSE, dwExStyle) != 0) {
1043  rect = Rect(Point(windowRect.left, windowRect.top), Point(windowRect.right, windowRect.bottom));
1044  }
1045  else {
1046  g_logger.traceError("AdjustWindowRectEx failed");
1047  rect = Rect(0, 0, m_minimumSize);
1048  }
1049  return rect;
1050 }
1051 
1052 #endif
Fw::KeyUp
@ KeyUp
Definition: const.h:72
Fw::KeyComma
@ KeyComma
Definition: const.h:97
Fw::KeyNumpad9
@ KeyNumpad9
Definition: const.h:175
Fw::KeyUnknown
@ KeyUnknown
Definition: const.h:58
Fw::KeyEscape
@ KeyEscape
Definition: const.h:59
WIN32Window::setMinimumSize
void setMinimumSize(const Size &minimumSize)
Fw::KeyBackspace
@ KeyBackspace
Definition: const.h:61
Fw::KeyF10
@ KeyF10
Definition: const.h:163
PlatformWindow::m_position
Point m_position
Definition: platformwindow.h:115
Fw::KeyEnter
@ KeyEnter
Definition: const.h:63
Fw::KeyR
@ KeyR
Definition: const.h:135
Fw::KeyCapsLock
@ KeyCapsLock
Definition: const.h:78
Fw::KeyMenu
@ KeyMenu
Definition: const.h:84
Fw::KeyNumpad1
@ KeyNumpad1
Definition: const.h:167
Fw::KeyN
@ KeyN
Definition: const.h:131
Fw::KeyI
@ KeyI
Definition: const.h:126
TPoint::y
T y
Definition: point.h:83
Fw::KeyB
@ KeyB
Definition: const.h:119
Fw::MouseWheelInputEvent
@ MouseWheelInputEvent
Definition: const.h:243
Fw::KeyNumpad6
@ KeyNumpad6
Definition: const.h:172
Fw::KeyZ
@ KeyZ
Definition: const.h:143
TSize::setWidth
void setWidth(T w)
Definition: size.h:47
Fw::KeyNumpad3
@ KeyNumpad3
Definition: const.h:169
WIN32Window::terminate
void terminate()
Fw::Key7
@ Key7
Definition: const.h:108
WIN32Window::swapBuffers
void swapBuffers()
Fw::KeyW
@ KeyW
Definition: const.h:140
WIN32Window::setIcon
void setIcon(const std::string &file)
TRect< int >
TRect::x
T x() const
Definition: rect.h:58
Application::getCompactName
const std::string & getCompactName()
Definition: application.h:52
PlatformWindow::m_focused
stdext::boolean< false > m_focused
Definition: platformwindow.h:123
Image::load
static ImagePtr load(std::string file)
Definition: image.cpp:40
Fw::MouseMidButton
@ MouseMidButton
Definition: const.h:250
uint32
uint32_t uint32
Definition: types.h:35
Fw::KeyPeriod
@ KeyPeriod
Definition: const.h:99
Fw::KeyNumpad5
@ KeyNumpad5
Definition: const.h:171
Fw::KeyP
@ KeyP
Definition: const.h:133
Fw::KeyF9
@ KeyF9
Definition: const.h:162
Fw::Key3
@ Key3
Definition: const.h:104
Fw::KeyF2
@ KeyF2
Definition: const.h:155
TRect::left
T left() const
Definition: rect.h:52
resourcemanager.h
WIN32Window::WIN32Window
WIN32Window()
Fw::KeyRight
@ KeyRight
Definition: const.h:75
Logger::error
void error(const std::string &what)
Definition: logger.h:54
Fw::KeyInsert
@ KeyInsert
Definition: const.h:64
Fw::KeyT
@ KeyT
Definition: const.h:137
WIN32Window::resize
void resize(const Size &size)
Fw::KeyBackslash
@ KeyBackslash
Definition: const.h:145
Fw::KeyX
@ KeyX
Definition: const.h:141
Fw::KeyC
@ KeyC
Definition: const.h:120
Fw::KeyTextInputEvent
@ KeyTextInputEvent
Definition: const.h:236
Fw::Key
Key
Definition: const.h:57
Fw::KeyL
@ KeyL
Definition: const.h:129
TRect::bottom
T bottom() const
Definition: rect.h:55
Fw::KeyNumpad2
@ KeyNumpad2
Definition: const.h:168
WIN32Window::move
void move(const Point &pos)
WIN32Window::restoreMouseCursor
void restoreMouseCursor()
Point
TPoint< int > Point
Definition: point.h:86
Fw::KeyboardShiftModifier
@ KeyboardShiftModifier
Definition: const.h:263
Fw::KeyLeft
@ KeyLeft
Definition: const.h:74
WIN32Window::setMouseCursor
void setMouseCursor(int cursorId)
stdext::format
std::string format()
Definition: format.h:84
PlatformWindow::updateUnmaximizedCoords
void updateUnmaximizedCoords()
Definition: platformwindow.cpp:61
TSize::width
int width() const
Definition: size.h:43
PlatformWindow::m_inputEvent
InputEvent m_inputEvent
Definition: platformwindow.h:118
Fw::MousePressInputEvent
@ MousePressInputEvent
Definition: const.h:240
Fw::KeyNumpad8
@ KeyNumpad8
Definition: const.h:174
Fw::Key8
@ Key8
Definition: const.h:109
Fw::KeySemicolon
@ KeySemicolon
Definition: const.h:112
WIN32Window::setClipboardText
void setClipboardText(const std::string &text)
Fw::MouseLeftButton
@ MouseLeftButton
Definition: const.h:248
Fw::KeySlash
@ KeySlash
Definition: const.h:100
Fw::MouseMoveInputEvent
@ MouseMoveInputEvent
Definition: const.h:242
Fw::KeyScrollLock
@ KeyScrollLock
Definition: const.h:77
WIN32Window::show
void show()
PlatformWindow::releaseAllKeys
void releaseAllKeys()
Definition: platformwindow.cpp:139
WIN32Window::setVerticalSync
void setVerticalSync(bool enable)
Fw::KeyShift
@ KeyShift
Definition: const.h:80
window
X11Window window
Definition: platformwindow.cpp:31
PlatformWindow::m_fullscreen
stdext::boolean< false > m_fullscreen
Definition: platformwindow.h:124
Fw::KeyQ
@ KeyQ
Definition: const.h:134
Logger::fatal
void fatal(const std::string &what)
Definition: logger.h:55
Fw::Key2
@ Key2
Definition: const.h:103
Fw::KeyPause
@ KeyPause
Definition: const.h:66
Fw::KeyD
@ KeyD
Definition: const.h:121
Fw::KeyU
@ KeyU
Definition: const.h:138
Fw::KeyJ
@ KeyJ
Definition: const.h:127
InputEvent::keyboardModifiers
int keyboardModifiers
Definition: inputevent.h:49
Fw::KeyH
@ KeyH
Definition: const.h:125
g_window
PlatformWindow & g_window
Definition: platformwindow.cpp:37
Fw::KeyEnd
@ KeyEnd
Definition: const.h:69
uint
unsigned int uint
Definition: types.h:31
TSize::setHeight
void setHeight(T h)
Definition: size.h:48
Fw::KeyF12
@ KeyF12
Definition: const.h:165
PlatformWindow::m_onInputEvent
OnInputEventCallback m_onInputEvent
Definition: platformwindow.h:129
Fw::KeyAlt
@ KeyAlt
Definition: const.h:81
WIN32Window::hideMouse
void hideMouse()
g_logger
Logger g_logger
Definition: logger.cpp:35
PlatformWindow::m_mouseButtonStates
stdext::boolean< false > m_mouseButtonStates[4]
Definition: platformwindow.h:119
Fw::KeyF11
@ KeyF11
Definition: const.h:164
Fw::KeyF4
@ KeyF4
Definition: const.h:157
WIN32Window::init
void init()
WIN32Window::setFullscreen
void setFullscreen(bool fullscreen)
WIN32Window::getDisplaySize
Size getDisplaySize()
WIN32Window::showMouse
void showMouse()
Fw::KeyS
@ KeyS
Definition: const.h:136
TRect::y
T y() const
Definition: rect.h:59
Fw::KeyNumpad4
@ KeyNumpad4
Definition: const.h:170
PlatformWindow::processKeyDown
void processKeyDown(Fw::Key keyCode)
Definition: platformwindow.cpp:69
Fw::KeyO
@ KeyO
Definition: const.h:132
Fw::KeyHome
@ KeyHome
Definition: const.h:68
image.h
Size
TSize< int > Size
Definition: size.h:107
Fw::KeyA
@ KeyA
Definition: const.h:118
TPoint::x
T x
Definition: point.h:83
Fw::KeyGrave
@ KeyGrave
Definition: const.h:149
WIN32Window::getPlatformType
std::string getPlatformType()
Fw::KeyY
@ KeyY
Definition: const.h:142
Fw::KeyboardAltModifier
@ KeyboardAltModifier
Definition: const.h:262
PlatformWindow::m_visible
stdext::boolean< false > m_visible
Definition: platformwindow.h:122
Fw::KeyF7
@ KeyF7
Definition: const.h:160
Fw::KeyF
@ KeyF
Definition: const.h:123
g_app
ConsoleApplication g_app
Definition: consoleapplication.cpp:32
Fw::MouseRightButton
@ MouseRightButton
Definition: const.h:249
Fw::MouseWheelUp
@ MouseWheelUp
Definition: const.h:255
WIN32Window
Definition: win32window.h:41
Fw::Key9
@ Key9
Definition: const.h:110
PlatformWindow::m_size
Size m_size
Definition: platformwindow.h:113
Rect
TRect< int > Rect
Definition: rect.h:319
Fw::KeyRightBracket
@ KeyRightBracket
Definition: const.h:146
WIN32Window::maximize
void maximize()
Fw::KeyNumpad7
@ KeyNumpad7
Definition: const.h:173
Fw::KeyMinus
@ KeyMinus
Definition: const.h:98
InputEvent::keyText
std::string keyText
Definition: inputevent.h:48
Fw::Key0
@ Key0
Definition: const.h:101
Fw::KeyF8
@ KeyF8
Definition: const.h:161
WIN32Window::displayFatalError
void displayFatalError(const std::string &message)
PlatformWindow::m_onResize
OnResizeCallback m_onResize
Definition: platformwindow.h:128
PlatformWindow::m_onClose
std::function< void()> m_onClose
Definition: platformwindow.h:127
TSize::height
int height() const
Definition: size.h:44
Fw::KeyM
@ KeyM
Definition: const.h:130
Fw::KeyEqual
@ KeyEqual
Definition: const.h:114
TRect::right
T right() const
Definition: rect.h:54
Fw::KeyPrintScreen
@ KeyPrintScreen
Definition: const.h:67
Fw::KeyG
@ KeyG
Definition: const.h:124
WIN32Window::internalLoadMouseCursor
int internalLoadMouseCursor(const ImagePtr &image, const Point &hotSpot)
stdext::shared_object_ptr
Definition: shared_object.h:39
Fw::KeyV
@ KeyV
Definition: const.h:139
PlatformWindow::m_keyMap
std::map< int, Fw::Key > m_keyMap
Definition: platformwindow.h:107
Fw::KeyE
@ KeyE
Definition: const.h:122
WIN32Window::hide
void hide()
Fw::KeyNumpad0
@ KeyNumpad0
Definition: const.h:166
Fw::KeyF6
@ KeyF6
Definition: const.h:159
Fw::Key1
@ Key1
Definition: const.h:102
TRect::height
T height() const
Definition: rect.h:70
Fw::KeyDown
@ KeyDown
Definition: const.h:73
PlatformWindow::m_maximized
stdext::boolean< false > m_maximized
Definition: platformwindow.h:125
Fw::MouseReleaseInputEvent
@ MouseReleaseInputEvent
Definition: const.h:241
TRect::top
T top() const
Definition: rect.h:53
InputEvent::mousePos
Point mousePos
Definition: inputevent.h:50
Fw::KeyApostrophe
@ KeyApostrophe
Definition: const.h:92
Fw::KeyboardCtrlModifier
@ KeyboardCtrlModifier
Definition: const.h:261
Fw::Key5
@ Key5
Definition: const.h:106
Fw::KeyPageUp
@ KeyPageUp
Definition: const.h:70
Fw::Key4
@ Key4
Definition: const.h:105
TPoint< int >
Fw::KeyLeftBracket
@ KeyLeftBracket
Definition: const.h:144
win32window.h
PlatformWindow::processKeyUp
void processKeyUp(Fw::Key keyCode)
Definition: platformwindow.cpp:106
WIN32Window::poll
void poll()
TRect::width
T width() const
Definition: rect.h:69
WIN32Window::getClipboardText
std::string getClipboardText()
Fw::MouseWheelDown
@ MouseWheelDown
Definition: const.h:256
InputEvent::mouseButton
Fw::MouseButton mouseButton
Definition: inputevent.h:46
InputEvent::mouseMoved
Point mouseMoved
Definition: inputevent.h:51
TSize< int >
Fw::Key6
@ Key6
Definition: const.h:107
stdext::readULE32
uint32_t readULE32(const uchar *addr)
Definition: math.h:35
Fw::KeyMeta
@ KeyMeta
Definition: const.h:83
Fw::KeyF5
@ KeyF5
Definition: const.h:158
Fw::KeyF1
@ KeyF1
Definition: const.h:154
PlatformWindow::fireKeysPress
void fireKeysPress()
Definition: platformwindow.cpp:157
Fw::KeyCtrl
@ KeyCtrl
Definition: const.h:79
Fw::KeyF3
@ KeyF3
Definition: const.h:156
InputEvent::wheelDirection
Fw::MouseWheelDirection wheelDirection
Definition: inputevent.h:45
Fw::KeyK
@ KeyK
Definition: const.h:128
PlatformWindow::m_minimumSize
Size m_minimumSize
Definition: platformwindow.h:114
uint8
uint8_t uint8
Definition: types.h:37
Fw::KeyDelete
@ KeyDelete
Definition: const.h:65
Fw::KeyPageDown
@ KeyPageDown
Definition: const.h:71
InputEvent::reset
void reset(Fw::InputEventType eventType=Fw::NoInputEvent)
Definition: inputevent.h:34
Fw::KeyTab
@ KeyTab
Definition: const.h:60
WIN32Window::setTitle
void setTitle(const std::string &title)
application.h
Logger::warning
void warning(const std::string &what)
Definition: logger.h:53
Fw::KeyNumLock
@ KeyNumLock
Definition: const.h:76
Fw::KeySpace
@ KeySpace
Definition: const.h:85