OpenTTD
win32_v.cpp
Go to the documentation of this file.
1 /* $Id: win32_v.cpp 27673 2016-10-30 18:22:55Z michi_cc $ */
2 
3 /*
4  * This file is part of OpenTTD.
5  * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
6  * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
7  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
8  */
9 
12 #include "../stdafx.h"
13 #include "../openttd.h"
14 #include "../gfx_func.h"
15 #include "../os/windows/win32.h"
16 #include "../rev.h"
17 #include "../blitter/factory.hpp"
18 #include "../network/network.h"
19 #include "../core/math_func.hpp"
20 #include "../core/random_func.hpp"
21 #include "../texteff.hpp"
22 #include "../thread/thread.h"
23 #include "../progress.h"
24 #include "../window_gui.h"
25 #include "../window_func.h"
26 #include "win32_v.h"
27 #include <windows.h>
28 #include <imm.h>
29 
30 #include "../safeguards.h"
31 
32 /* Missing define in MinGW headers. */
33 #ifndef MAPVK_VK_TO_CHAR
34 #define MAPVK_VK_TO_CHAR (2)
35 #endif
36 
37 static struct {
38  HWND main_wnd;
39  HBITMAP dib_sect;
40  void *buffer_bits;
41  HPALETTE gdi_palette;
42  RECT update_rect;
43  int width;
44  int height;
45  int width_org;
46  int height_org;
47  bool fullscreen;
48  bool has_focus;
49  bool running;
50 } _wnd;
51 
52 bool _force_full_redraw;
53 bool _window_maximize;
54 uint _display_hz;
55 static Dimension _bck_resolution;
56 #if !defined(WINCE) || _WIN32_WCE >= 0x400
57 DWORD _imm_props;
58 #endif
59 
61 static bool _draw_threaded;
63 static ThreadObject *_draw_thread = NULL;
65 static ThreadMutex *_draw_mutex = NULL;
67 static HANDLE _draw_thread_initialized = NULL;
69 static volatile bool _draw_continue;
72 
73 static void MakePalette()
74 {
75  LOGPALETTE *pal = (LOGPALETTE*)alloca(sizeof(LOGPALETTE) + (256 - 1) * sizeof(PALETTEENTRY));
76 
77  pal->palVersion = 0x300;
78  pal->palNumEntries = 256;
79 
80  for (uint i = 0; i != 256; i++) {
81  pal->palPalEntry[i].peRed = _cur_palette.palette[i].r;
82  pal->palPalEntry[i].peGreen = _cur_palette.palette[i].g;
83  pal->palPalEntry[i].peBlue = _cur_palette.palette[i].b;
84  pal->palPalEntry[i].peFlags = 0;
85 
86  }
87  _wnd.gdi_palette = CreatePalette(pal);
88  if (_wnd.gdi_palette == NULL) usererror("CreatePalette failed!\n");
89 
92  _local_palette = _cur_palette;
93 }
94 
95 static void UpdatePalette(HDC dc, uint start, uint count)
96 {
97  RGBQUAD rgb[256];
98  uint i;
99 
100  for (i = 0; i != count; i++) {
101  rgb[i].rgbRed = _local_palette.palette[start + i].r;
102  rgb[i].rgbGreen = _local_palette.palette[start + i].g;
103  rgb[i].rgbBlue = _local_palette.palette[start + i].b;
104  rgb[i].rgbReserved = 0;
105  }
106 
107  SetDIBColorTable(dc, start, count, rgb);
108 }
109 
110 bool VideoDriver_Win32::ClaimMousePointer()
111 {
112  MyShowCursor(false, true);
113  return true;
114 }
115 
116 struct VkMapping {
117  byte vk_from;
118  byte vk_count;
119  byte map_to;
120 };
121 
122 #define AS(x, z) {x, 0, z}
123 #define AM(x, y, z, w) {x, y - x, z}
124 
125 static const VkMapping _vk_mapping[] = {
126  /* Pageup stuff + up/down */
127  AM(VK_PRIOR, VK_DOWN, WKC_PAGEUP, WKC_DOWN),
128  /* Map letters & digits */
129  AM('A', 'Z', 'A', 'Z'),
130  AM('0', '9', '0', '9'),
131 
132  AS(VK_ESCAPE, WKC_ESC),
133  AS(VK_PAUSE, WKC_PAUSE),
134  AS(VK_BACK, WKC_BACKSPACE),
135  AM(VK_INSERT, VK_DELETE, WKC_INSERT, WKC_DELETE),
136 
137  AS(VK_SPACE, WKC_SPACE),
138  AS(VK_RETURN, WKC_RETURN),
139  AS(VK_TAB, WKC_TAB),
140 
141  /* Function keys */
142  AM(VK_F1, VK_F12, WKC_F1, WKC_F12),
143 
144  /* Numeric part */
145  AM(VK_NUMPAD0, VK_NUMPAD9, '0', '9'),
146  AS(VK_DIVIDE, WKC_NUM_DIV),
147  AS(VK_MULTIPLY, WKC_NUM_MUL),
148  AS(VK_SUBTRACT, WKC_NUM_MINUS),
149  AS(VK_ADD, WKC_NUM_PLUS),
150  AS(VK_DECIMAL, WKC_NUM_DECIMAL),
151 
152  /* Other non-letter keys */
153  AS(0xBF, WKC_SLASH),
154  AS(0xBA, WKC_SEMICOLON),
155  AS(0xBB, WKC_EQUALS),
156  AS(0xDB, WKC_L_BRACKET),
157  AS(0xDC, WKC_BACKSLASH),
158  AS(0xDD, WKC_R_BRACKET),
159 
160  AS(0xDE, WKC_SINGLEQUOTE),
161  AS(0xBC, WKC_COMMA),
162  AS(0xBD, WKC_MINUS),
163  AS(0xBE, WKC_PERIOD)
164 };
165 
166 static uint MapWindowsKey(uint sym)
167 {
168  const VkMapping *map;
169  uint key = 0;
170 
171  for (map = _vk_mapping; map != endof(_vk_mapping); ++map) {
172  if ((uint)(sym - map->vk_from) <= map->vk_count) {
173  key = sym - map->vk_from + map->map_to;
174  break;
175  }
176  }
177 
178  if (GetAsyncKeyState(VK_SHIFT) < 0) key |= WKC_SHIFT;
179  if (GetAsyncKeyState(VK_CONTROL) < 0) key |= WKC_CTRL;
180  if (GetAsyncKeyState(VK_MENU) < 0) key |= WKC_ALT;
181  return key;
182 }
183 
184 static bool AllocateDibSection(int w, int h, bool force = false);
185 
186 static void ClientSizeChanged(int w, int h)
187 {
188  /* allocate new dib section of the new size */
189  if (AllocateDibSection(w, h)) {
190  /* mark all palette colours dirty */
193  _local_palette = _cur_palette;
194 
196 
197  GameSizeChanged();
198  }
199 }
200 
201 #ifdef _DEBUG
202 /* Keep this function here..
203  * It allows you to redraw the screen from within the MSVC debugger */
204 int RedrawScreenDebug()
205 {
206  HDC dc, dc2;
207  static int _fooctr;
208  HBITMAP old_bmp;
209  HPALETTE old_palette;
210 
211  UpdateWindows();
212 
213  dc = GetDC(_wnd.main_wnd);
214  dc2 = CreateCompatibleDC(dc);
215 
216  old_bmp = (HBITMAP)SelectObject(dc2, _wnd.dib_sect);
217  old_palette = SelectPalette(dc, _wnd.gdi_palette, FALSE);
218  BitBlt(dc, 0, 0, _wnd.width, _wnd.height, dc2, 0, 0, SRCCOPY);
219  SelectPalette(dc, old_palette, TRUE);
220  SelectObject(dc2, old_bmp);
221  DeleteDC(dc2);
222  ReleaseDC(_wnd.main_wnd, dc);
223 
224  return _fooctr++;
225 }
226 #endif
227 
228 /* Windows 95 will not have a WM_MOUSELEAVE message, so define it if needed */
229 #if !defined(WM_MOUSELEAVE)
230 #define WM_MOUSELEAVE 0x02A3
231 #endif
232 #define TID_POLLMOUSE 1
233 #define MOUSE_POLL_DELAY 75
234 
235 static void CALLBACK TrackMouseTimerProc(HWND hwnd, UINT msg, UINT event, DWORD time)
236 {
237  RECT rc;
238  POINT pt;
239 
240  /* Get the rectangle of our window and translate it to screen coordinates.
241  * Compare this with the current screen coordinates of the mouse and if it
242  * falls outside of the area or our window we have left the window. */
243  GetClientRect(hwnd, &rc);
244  MapWindowPoints(hwnd, HWND_DESKTOP, (LPPOINT)(LPRECT)&rc, 2);
245  GetCursorPos(&pt);
246 
247  if (!PtInRect(&rc, pt) || (WindowFromPoint(pt) != hwnd)) {
248  KillTimer(hwnd, event);
249  PostMessage(hwnd, WM_MOUSELEAVE, 0, 0L);
250  }
251 }
252 
258 bool VideoDriver_Win32::MakeWindow(bool full_screen)
259 {
260  _fullscreen = full_screen;
261 
262  /* recreate window? */
263  if ((full_screen || _wnd.fullscreen) && _wnd.main_wnd) {
264  DestroyWindow(_wnd.main_wnd);
265  _wnd.main_wnd = 0;
266  }
267 
268 #if defined(WINCE)
269  /* WinCE is always fullscreen */
270 #else
271  if (full_screen) {
272  DEVMODE settings;
273 
274  memset(&settings, 0, sizeof(settings));
275  settings.dmSize = sizeof(settings);
276  settings.dmFields =
277  DM_BITSPERPEL |
278  DM_PELSWIDTH |
279  DM_PELSHEIGHT |
280  (_display_hz != 0 ? DM_DISPLAYFREQUENCY : 0);
281  settings.dmBitsPerPel = BlitterFactory::GetCurrentBlitter()->GetScreenDepth();
282  settings.dmPelsWidth = _wnd.width_org;
283  settings.dmPelsHeight = _wnd.height_org;
284  settings.dmDisplayFrequency = _display_hz;
285 
286  /* Check for 8 bpp support. */
287  if (settings.dmBitsPerPel == 8 &&
288  (_support8bpp != S8BPP_HARDWARE || ChangeDisplaySettings(&settings, CDS_FULLSCREEN | CDS_TEST) != DISP_CHANGE_SUCCESSFUL)) {
289  settings.dmBitsPerPel = 32;
290  }
291 
292  /* Test fullscreen with current resolution, if it fails use desktop resolution. */
293  if (ChangeDisplaySettings(&settings, CDS_FULLSCREEN | CDS_TEST) != DISP_CHANGE_SUCCESSFUL) {
294  RECT r;
295  GetWindowRect(GetDesktopWindow(), &r);
296  /* Guard against recursion. If we already failed here once, just fall through to
297  * the next ChangeDisplaySettings call which will fail and error out appropriately. */
298  if ((int)settings.dmPelsWidth != r.right - r.left || (int)settings.dmPelsHeight != r.bottom - r.top) {
299  return this->ChangeResolution(r.right - r.left, r.bottom - r.top);
300  }
301  }
302 
303  if (ChangeDisplaySettings(&settings, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL) {
304  this->MakeWindow(false); // don't care about the result
305  return false; // the request failed
306  }
307  } else if (_wnd.fullscreen) {
308  /* restore display? */
309  ChangeDisplaySettings(NULL, 0);
310  /* restore the resolution */
311  _wnd.width = _bck_resolution.width;
312  _wnd.height = _bck_resolution.height;
313  }
314 #endif
315 
316  {
317  RECT r;
318  DWORD style, showstyle;
319  int w, h;
320 
321  showstyle = SW_SHOWNORMAL;
322  _wnd.fullscreen = full_screen;
323  if (_wnd.fullscreen) {
324  style = WS_POPUP;
325  SetRect(&r, 0, 0, _wnd.width_org, _wnd.height_org);
326  } else {
327  style = WS_OVERLAPPEDWINDOW;
328  /* On window creation, check if we were in maximize mode before */
329  if (_window_maximize) showstyle = SW_SHOWMAXIMIZED;
330  SetRect(&r, 0, 0, _wnd.width, _wnd.height);
331  }
332 
333 #if !defined(WINCE)
334  AdjustWindowRect(&r, style, FALSE);
335 #endif
336  w = r.right - r.left;
337  h = r.bottom - r.top;
338 
339  if (_wnd.main_wnd != NULL) {
340  if (!_window_maximize) SetWindowPos(_wnd.main_wnd, 0, 0, 0, w, h, SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOZORDER | SWP_NOMOVE);
341  } else {
342  TCHAR Windowtitle[50];
343  int x = (GetSystemMetrics(SM_CXSCREEN) - w) / 2;
344  int y = (GetSystemMetrics(SM_CYSCREEN) - h) / 2;
345 
346  _sntprintf(Windowtitle, lengthof(Windowtitle), _T("OpenTTD %s"), MB_TO_WIDE(_openttd_revision));
347 
348  _wnd.main_wnd = CreateWindow(_T("OTTD"), Windowtitle, style, x, y, w, h, 0, 0, GetModuleHandle(NULL), 0);
349  if (_wnd.main_wnd == NULL) usererror("CreateWindow failed");
350  ShowWindow(_wnd.main_wnd, showstyle);
351  }
352  }
353 
355 
356  GameSizeChanged(); // invalidate all windows, force redraw
357  return true; // the request succeeded
358 }
359 
361 static void PaintWindow(HDC dc)
362 {
363  HDC dc2 = CreateCompatibleDC(dc);
364  HBITMAP old_bmp = (HBITMAP)SelectObject(dc2, _wnd.dib_sect);
365  HPALETTE old_palette = SelectPalette(dc, _wnd.gdi_palette, FALSE);
366 
367  if (_cur_palette.count_dirty != 0) {
369 
370  switch (blitter->UsePaletteAnimation()) {
372  UpdatePalette(dc2, _local_palette.first_dirty, _local_palette.count_dirty);
373  break;
374 
376  blitter->PaletteAnimate(_local_palette);
377  break;
378 
380  break;
381 
382  default:
383  NOT_REACHED();
384  }
386  }
387 
388  BitBlt(dc, 0, 0, _wnd.width, _wnd.height, dc2, 0, 0, SRCCOPY);
389  SelectPalette(dc, old_palette, TRUE);
390  SelectObject(dc2, old_bmp);
391  DeleteDC(dc2);
392 }
393 
394 static void PaintWindowThread(void *)
395 {
396  /* First tell the main thread we're started */
397  _draw_mutex->BeginCritical();
398  SetEvent(_draw_thread_initialized);
399 
400  /* Now wait for the first thing to draw! */
401  _draw_mutex->WaitForSignal();
402 
403  while (_draw_continue) {
404  /* Convert update region from logical to device coordinates. */
405  POINT pt = {0, 0};
406  ClientToScreen(_wnd.main_wnd, &pt);
407  OffsetRect(&_wnd.update_rect, pt.x, pt.y);
408 
409  /* Create a device context that is clipped to the region we need to draw.
410  * GetDCEx 'consumes' the update region, so we may not destroy it ourself. */
411  HRGN rgn = CreateRectRgnIndirect(&_wnd.update_rect);
412  HDC dc = GetDCEx(_wnd.main_wnd, rgn, DCX_CLIPSIBLINGS | DCX_CLIPCHILDREN | DCX_INTERSECTRGN);
413 
414  PaintWindow(dc);
415 
416  /* Clear update rect. */
417  SetRectEmpty(&_wnd.update_rect);
418  ReleaseDC(_wnd.main_wnd, dc);
419 
420  /* Flush GDI buffer to ensure drawing here doesn't conflict with any GDI usage in the main WndProc. */
421  GdiFlush();
422 
423  _draw_mutex->WaitForSignal();
424  }
425 
426  _draw_mutex->EndCritical();
427  _draw_thread->Exit();
428 }
429 
431 static LRESULT HandleCharMsg(uint keycode, WChar charcode)
432 {
433 #if !defined(UNICODE)
434  static char prev_char = 0;
435 
436  char input[2] = {(char)charcode, 0};
437  int input_len = 1;
438 
439  if (prev_char != 0) {
440  /* We stored a lead byte previously, combine it with this byte. */
441  input[0] = prev_char;
442  input[1] = (char)charcode;
443  input_len = 2;
444  } else if (IsDBCSLeadByte(charcode)) {
445  /* We got a lead byte, store and exit. */
446  prev_char = charcode;
447  return 0;
448  }
449  prev_char = 0;
450 
451  wchar_t w[2]; // Can get up to two code points as a result.
452  int len = MultiByteToWideChar(CP_ACP, 0, input, input_len, w, 2);
453  switch (len) {
454  case 1: // Normal unicode character.
455  charcode = w[0];
456  break;
457 
458  case 2: // Got an UTF-16 surrogate pair back.
459  charcode = Utf16DecodeSurrogate(w[0], w[1]);
460  break;
461 
462  default: // Some kind of error.
463  DEBUG(driver, 1, "Invalid DBCS character sequence encountered, dropping input");
464  charcode = 0;
465  break;
466  }
467 #else
468  static WChar prev_char = 0;
469 
470  /* Did we get a lead surrogate? If yes, store and exit. */
471  if (Utf16IsLeadSurrogate(charcode)) {
472  if (prev_char != 0) DEBUG(driver, 1, "Got two UTF-16 lead surrogates, dropping the first one");
473  prev_char = charcode;
474  return 0;
475  }
476 
477  /* Stored lead surrogate and incoming trail surrogate? Combine and forward to input handling. */
478  if (prev_char != 0) {
479  if (Utf16IsTrailSurrogate(charcode)) {
480  charcode = Utf16DecodeSurrogate(prev_char, charcode);
481  } else {
482  DEBUG(driver, 1, "Got an UTF-16 lead surrogate without a trail surrogate, dropping the lead surrogate");
483  }
484  }
485  prev_char = 0;
486 #endif /* UNICODE */
487 
488  HandleKeypress(keycode, charcode);
489 
490  return 0;
491 }
492 
493 #if !defined(WINCE) || _WIN32_WCE >= 0x400
494 
496 {
497  return (_imm_props & IME_PROP_AT_CARET) && !(_imm_props & IME_PROP_SPECIAL_UI);
498 }
499 
501 static void SetCompositionPos(HWND hwnd)
502 {
503  HIMC hIMC = ImmGetContext(hwnd);
504  if (hIMC != NULL) {
505  COMPOSITIONFORM cf;
506  cf.dwStyle = CFS_POINT;
507 
508  if (EditBoxInGlobalFocus()) {
509  /* Get caret position. */
510  Point pt = _focused_window->GetCaretPosition();
511  cf.ptCurrentPos.x = _focused_window->left + pt.x;
512  cf.ptCurrentPos.y = _focused_window->top + pt.y;
513  } else {
514  cf.ptCurrentPos.x = 0;
515  cf.ptCurrentPos.y = 0;
516  }
517  ImmSetCompositionWindow(hIMC, &cf);
518  }
519  ImmReleaseContext(hwnd, hIMC);
520 }
521 
523 static void SetCandidatePos(HWND hwnd)
524 {
525  HIMC hIMC = ImmGetContext(hwnd);
526  if (hIMC != NULL) {
527  CANDIDATEFORM cf;
528  cf.dwIndex = 0;
529  cf.dwStyle = CFS_EXCLUDE;
530 
531  if (EditBoxInGlobalFocus()) {
532  Point pt = _focused_window->GetCaretPosition();
533  cf.ptCurrentPos.x = _focused_window->left + pt.x;
534  cf.ptCurrentPos.y = _focused_window->top + pt.y;
535  if (_focused_window->window_class == WC_CONSOLE) {
536  cf.rcArea.left = _focused_window->left;
537  cf.rcArea.top = _focused_window->top;
538  cf.rcArea.right = _focused_window->left + _focused_window->width;
539  cf.rcArea.bottom = _focused_window->top + _focused_window->height;
540  } else {
541  cf.rcArea.left = _focused_window->left + _focused_window->nested_focus->pos_x;
542  cf.rcArea.top = _focused_window->top + _focused_window->nested_focus->pos_y;
543  cf.rcArea.right = cf.rcArea.left + _focused_window->nested_focus->current_x;
544  cf.rcArea.bottom = cf.rcArea.top + _focused_window->nested_focus->current_y;
545  }
546  } else {
547  cf.ptCurrentPos.x = 0;
548  cf.ptCurrentPos.y = 0;
549  SetRectEmpty(&cf.rcArea);
550  }
551  ImmSetCandidateWindow(hIMC, &cf);
552  }
553  ImmReleaseContext(hwnd, hIMC);
554 }
555 
557 static LRESULT HandleIMEComposition(HWND hwnd, WPARAM wParam, LPARAM lParam)
558 {
559  HIMC hIMC = ImmGetContext(hwnd);
560 
561  if (hIMC != NULL) {
562  if (lParam & GCS_RESULTSTR) {
563  /* Read result string from the IME. */
564  LONG len = ImmGetCompositionString(hIMC, GCS_RESULTSTR, NULL, 0); // Length is always in bytes, even in UNICODE build.
565  TCHAR *str = (TCHAR *)_alloca(len + sizeof(TCHAR));
566  len = ImmGetCompositionString(hIMC, GCS_RESULTSTR, str, len);
567  str[len / sizeof(TCHAR)] = '\0';
568 
569  /* Transmit text to windowing system. */
570  if (len > 0) {
571  HandleTextInput(NULL, true); // Clear marked string.
572  HandleTextInput(FS2OTTD(str));
573  }
574  SetCompositionPos(hwnd);
575 
576  /* Don't pass the result string on to the default window proc. */
577  lParam &= ~(GCS_RESULTSTR | GCS_RESULTCLAUSE | GCS_RESULTREADCLAUSE | GCS_RESULTREADSTR);
578  }
579 
580  if ((lParam & GCS_COMPSTR) && DrawIMECompositionString()) {
581  /* Read composition string from the IME. */
582  LONG len = ImmGetCompositionString(hIMC, GCS_COMPSTR, NULL, 0); // Length is always in bytes, even in UNICODE build.
583  TCHAR *str = (TCHAR *)_alloca(len + sizeof(TCHAR));
584  len = ImmGetCompositionString(hIMC, GCS_COMPSTR, str, len);
585  str[len / sizeof(TCHAR)] = '\0';
586 
587  if (len > 0) {
588  static char utf8_buf[1024];
589  convert_from_fs(str, utf8_buf, lengthof(utf8_buf));
590 
591  /* Convert caret position from bytes in the input string to a position in the UTF-8 encoded string. */
592  LONG caret_bytes = ImmGetCompositionString(hIMC, GCS_CURSORPOS, NULL, 0);
593  const char *caret = utf8_buf;
594  for (const TCHAR *c = str; *c != '\0' && *caret != '\0' && caret_bytes > 0; c++, caret_bytes--) {
595  /* Skip DBCS lead bytes or leading surrogates. */
596 #ifdef UNICODE
597  if (Utf16IsLeadSurrogate(*c)) {
598 #else
599  if (IsDBCSLeadByte(*c)) {
600 #endif
601  c++;
602  caret_bytes--;
603  }
604  Utf8Consume(&caret);
605  }
606 
607  HandleTextInput(utf8_buf, true, caret);
608  } else {
609  HandleTextInput(NULL, true);
610  }
611 
612  lParam &= ~(GCS_COMPSTR | GCS_COMPATTR | GCS_COMPCLAUSE | GCS_CURSORPOS | GCS_DELTASTART);
613  }
614  }
615  ImmReleaseContext(hwnd, hIMC);
616 
617  return lParam != 0 ? DefWindowProc(hwnd, WM_IME_COMPOSITION, wParam, lParam) : 0;
618 }
619 
621 static void CancelIMEComposition(HWND hwnd)
622 {
623  HIMC hIMC = ImmGetContext(hwnd);
624  if (hIMC != NULL) ImmNotifyIME(hIMC, NI_COMPOSITIONSTR, CPS_CANCEL, 0);
625  ImmReleaseContext(hwnd, hIMC);
626  /* Clear any marked string from the current edit box. */
627  HandleTextInput(NULL, true);
628 }
629 
630 #else
631 
632 static bool DrawIMECompositionString() { return false; }
633 static void SetCompositionPos(HWND hwnd) {}
634 static void SetCandidatePos(HWND hwnd) {}
635 static void CancelIMEComposition(HWND hwnd) {}
636 
637 #endif /* !defined(WINCE) || _WIN32_WCE >= 0x400 */
638 
639 static LRESULT CALLBACK WndProcGdi(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
640 {
641  static uint32 keycode = 0;
642  static bool console = false;
643  static bool in_sizemove = false;
644 
645  switch (msg) {
646  case WM_CREATE:
647  SetTimer(hwnd, TID_POLLMOUSE, MOUSE_POLL_DELAY, (TIMERPROC)TrackMouseTimerProc);
648  SetCompositionPos(hwnd);
649 #if !defined(WINCE) || _WIN32_WCE >= 0x400
650  _imm_props = ImmGetProperty(GetKeyboardLayout(0), IGP_PROPERTY);
651 #endif
652  break;
653 
654  case WM_ENTERSIZEMOVE:
655  in_sizemove = true;
656  break;
657 
658  case WM_EXITSIZEMOVE:
659  in_sizemove = false;
660  break;
661 
662  case WM_PAINT:
663  if (!in_sizemove && _draw_mutex != NULL && !HasModalProgress()) {
664  /* Get the union of the old update rect and the new update rect. */
665  RECT r;
666  GetUpdateRect(hwnd, &r, FALSE);
667  UnionRect(&_wnd.update_rect, &_wnd.update_rect, &r);
668 
669  /* Mark the window as updated, otherwise Windows would send more WM_PAINT messages. */
670  ValidateRect(hwnd, NULL);
671  _draw_mutex->SendSignal();
672  } else {
673  PAINTSTRUCT ps;
674 
675  BeginPaint(hwnd, &ps);
676  PaintWindow(ps.hdc);
677  EndPaint(hwnd, &ps);
678  }
679  return 0;
680 
681  case WM_PALETTECHANGED:
682  if ((HWND)wParam == hwnd) return 0;
683  /* FALL THROUGH */
684 
685  case WM_QUERYNEWPALETTE: {
686  HDC hDC = GetWindowDC(hwnd);
687  HPALETTE hOldPalette = SelectPalette(hDC, _wnd.gdi_palette, FALSE);
688  UINT nChanged = RealizePalette(hDC);
689 
690  SelectPalette(hDC, hOldPalette, TRUE);
691  ReleaseDC(hwnd, hDC);
692  if (nChanged != 0) InvalidateRect(hwnd, NULL, FALSE);
693  return 0;
694  }
695 
696  case WM_CLOSE:
697  HandleExitGameRequest();
698  return 0;
699 
700  case WM_DESTROY:
701  if (_window_maximize) _cur_resolution = _bck_resolution;
702  return 0;
703 
704  case WM_LBUTTONDOWN:
705  SetCapture(hwnd);
706  _left_button_down = true;
708  return 0;
709 
710  case WM_LBUTTONUP:
711  ReleaseCapture();
712  _left_button_down = false;
713  _left_button_clicked = false;
715  return 0;
716 
717  case WM_RBUTTONDOWN:
718  SetCapture(hwnd);
719  _right_button_down = true;
720  _right_button_clicked = true;
722  return 0;
723 
724  case WM_RBUTTONUP:
725  ReleaseCapture();
726  _right_button_down = false;
728  return 0;
729 
730  case WM_MOUSELEAVE:
731  UndrawMouseCursor();
732  _cursor.in_window = false;
733 
734  if (!_left_button_down && !_right_button_down) MyShowCursor(true);
735  return 0;
736 
737  case WM_MOUSEMOVE: {
738  int x = (int16)LOWORD(lParam);
739  int y = (int16)HIWORD(lParam);
740  POINT pt;
741 
742  /* If the mouse was not in the window and it has moved it means it has
743  * come into the window, so start drawing the mouse. Also start
744  * tracking the mouse for exiting the window */
745  if (!_cursor.in_window) {
746  _cursor.in_window = true;
747  SetTimer(hwnd, TID_POLLMOUSE, MOUSE_POLL_DELAY, (TIMERPROC)TrackMouseTimerProc);
748  }
749 
750  if (_cursor.UpdateCursorPosition(x, y, true)) {
751  pt.x = _cursor.pos.x;
752  pt.y = _cursor.pos.y;
753  ClientToScreen(hwnd, &pt);
754  SetCursorPos(pt.x, pt.y);
755  }
756  MyShowCursor(false);
758  return 0;
759  }
760 
761 #if !defined(WINCE) || _WIN32_WCE >= 0x400
762  case WM_INPUTLANGCHANGE:
763  _imm_props = ImmGetProperty(GetKeyboardLayout(0), IGP_PROPERTY);
764  break;
765 
766  case WM_IME_SETCONTEXT:
767  /* Don't show the composition window if we draw the string ourself. */
768  if (DrawIMECompositionString()) lParam &= ~ISC_SHOWUICOMPOSITIONWINDOW;
769  break;
770 
771  case WM_IME_STARTCOMPOSITION:
772  SetCompositionPos(hwnd);
773  if (DrawIMECompositionString()) return 0;
774  break;
775 
776  case WM_IME_COMPOSITION:
777  return HandleIMEComposition(hwnd, wParam, lParam);
778 
779  case WM_IME_ENDCOMPOSITION:
780  /* Clear any pending composition string. */
781  HandleTextInput(NULL, true);
782  if (DrawIMECompositionString()) return 0;
783  break;
784 
785  case WM_IME_NOTIFY:
786  if (wParam == IMN_OPENCANDIDATE) SetCandidatePos(hwnd);
787  break;
788 
789 #if !defined(UNICODE)
790  case WM_IME_CHAR:
791  if (GB(wParam, 8, 8) != 0) {
792  /* DBCS character, send lead byte first. */
793  HandleCharMsg(0, GB(wParam, 8, 8));
794  }
795  HandleCharMsg(0, GB(wParam, 0, 8));
796  return 0;
797 #endif
798 #endif
799 
800  case WM_DEADCHAR:
801  console = GB(lParam, 16, 8) == 41;
802  return 0;
803 
804  case WM_CHAR: {
805  uint scancode = GB(lParam, 16, 8);
806  uint charcode = wParam;
807 
808  /* If the console key is a dead-key, we need to press it twice to get a WM_CHAR message.
809  * But we then get two WM_CHAR messages, so ignore the first one */
810  if (console && scancode == 41) {
811  console = false;
812  return 0;
813  }
814 
815  /* IMEs and other input methods sometimes send a WM_CHAR without a WM_KEYDOWN,
816  * clear the keycode so a previous WM_KEYDOWN doesn't become 'stuck'. */
817  uint cur_keycode = keycode;
818  keycode = 0;
819 
820  return HandleCharMsg(cur_keycode, charcode);
821  }
822 
823  case WM_KEYDOWN: {
824  /* No matter the keyboard layout, we will map the '~' to the console. */
825  uint scancode = GB(lParam, 16, 8);
826  keycode = scancode == 41 ? (uint)WKC_BACKQUOTE : MapWindowsKey(wParam);
827 
828  /* Silently drop all messages handled by WM_CHAR. */
829  MSG msg;
830  if (PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE)) {
831  if ((msg.message == WM_CHAR || msg.message == WM_DEADCHAR) && GB(lParam, 16, 8) == GB(msg.lParam, 16, 8)) {
832  return 0;
833  }
834  }
835 
836  uint charcode = MapVirtualKey(wParam, MAPVK_VK_TO_CHAR);
837 
838  /* No character translation? */
839  if (charcode == 0) {
840  HandleKeypress(keycode, 0);
841  return 0;
842  }
843 
844  /* Is the console key a dead key? If yes, ignore the first key down event. */
845  if (HasBit(charcode, 31) && !console) {
846  if (scancode == 41) {
847  console = true;
848  return 0;
849  }
850  }
851  console = false;
852 
853  /* IMEs and other input methods sometimes send a WM_CHAR without a WM_KEYDOWN,
854  * clear the keycode so a previous WM_KEYDOWN doesn't become 'stuck'. */
855  uint cur_keycode = keycode;
856  keycode = 0;
857 
858  return HandleCharMsg(cur_keycode, LOWORD(charcode));
859  }
860 
861  case WM_SYSKEYDOWN: // user presses F10 or Alt, both activating the title-menu
862  switch (wParam) {
863  case VK_RETURN:
864  case 'F': // Full Screen on ALT + ENTER/F
865  ToggleFullScreen(!_wnd.fullscreen);
866  return 0;
867 
868  case VK_MENU: // Just ALT
869  return 0; // do nothing
870 
871  case VK_F10: // F10, ignore activation of menu
872  HandleKeypress(MapWindowsKey(wParam), 0);
873  return 0;
874 
875  default: // ALT in combination with something else
876  HandleKeypress(MapWindowsKey(wParam), 0);
877  break;
878  }
879  break;
880 
881  case WM_SIZE:
882  if (wParam != SIZE_MINIMIZED) {
883  /* Set maximized flag when we maximize (obviously), but also when we
884  * switched to fullscreen from a maximized state */
885  _window_maximize = (wParam == SIZE_MAXIMIZED || (_window_maximize && _fullscreen));
886  if (_window_maximize || _fullscreen) _bck_resolution = _cur_resolution;
887  ClientSizeChanged(LOWORD(lParam), HIWORD(lParam));
888  }
889  return 0;
890 
891 #if !defined(WINCE)
892  case WM_SIZING: {
893  RECT *r = (RECT*)lParam;
894  RECT r2;
895  int w, h;
896 
897  SetRect(&r2, 0, 0, 0, 0);
898  AdjustWindowRect(&r2, GetWindowLong(hwnd, GWL_STYLE), FALSE);
899 
900  w = r->right - r->left - (r2.right - r2.left);
901  h = r->bottom - r->top - (r2.bottom - r2.top);
902  w = max(w, 64);
903  h = max(h, 64);
904  SetRect(&r2, 0, 0, w, h);
905 
906  AdjustWindowRect(&r2, GetWindowLong(hwnd, GWL_STYLE), FALSE);
907  w = r2.right - r2.left;
908  h = r2.bottom - r2.top;
909 
910  switch (wParam) {
911  case WMSZ_BOTTOM:
912  r->bottom = r->top + h;
913  break;
914 
915  case WMSZ_BOTTOMLEFT:
916  r->bottom = r->top + h;
917  r->left = r->right - w;
918  break;
919 
920  case WMSZ_BOTTOMRIGHT:
921  r->bottom = r->top + h;
922  r->right = r->left + w;
923  break;
924 
925  case WMSZ_LEFT:
926  r->left = r->right - w;
927  break;
928 
929  case WMSZ_RIGHT:
930  r->right = r->left + w;
931  break;
932 
933  case WMSZ_TOP:
934  r->top = r->bottom - h;
935  break;
936 
937  case WMSZ_TOPLEFT:
938  r->top = r->bottom - h;
939  r->left = r->right - w;
940  break;
941 
942  case WMSZ_TOPRIGHT:
943  r->top = r->bottom - h;
944  r->right = r->left + w;
945  break;
946  }
947  return TRUE;
948  }
949 #endif
950 
951 /* needed for wheel */
952 #if !defined(WM_MOUSEWHEEL)
953 # define WM_MOUSEWHEEL 0x020A
954 #endif /* WM_MOUSEWHEEL */
955 #if !defined(GET_WHEEL_DELTA_WPARAM)
956 # define GET_WHEEL_DELTA_WPARAM(wparam) ((short)HIWORD(wparam))
957 #endif /* GET_WHEEL_DELTA_WPARAM */
958 
959  case WM_MOUSEWHEEL: {
960  int delta = GET_WHEEL_DELTA_WPARAM(wParam);
961 
962  if (delta < 0) {
963  _cursor.wheel++;
964  } else if (delta > 0) {
965  _cursor.wheel--;
966  }
968  return 0;
969  }
970 
971  case WM_SETFOCUS:
972  _wnd.has_focus = true;
973  SetCompositionPos(hwnd);
974  break;
975 
976  case WM_KILLFOCUS:
977  _wnd.has_focus = false;
978  break;
979 
980 #if !defined(WINCE)
981  case WM_ACTIVATE: {
982  /* Don't do anything if we are closing openttd */
983  if (_exit_game) break;
984 
985  bool active = (LOWORD(wParam) != WA_INACTIVE);
986  bool minimized = (HIWORD(wParam) != 0);
987  if (_wnd.fullscreen) {
988  if (active && minimized) {
989  /* Restore the game window */
990  ShowWindow(hwnd, SW_RESTORE);
991  static_cast<VideoDriver_Win32 *>(VideoDriver::GetInstance())->MakeWindow(true);
992  } else if (!active && !minimized) {
993  /* Minimise the window and restore desktop */
994  ShowWindow(hwnd, SW_MINIMIZE);
995  ChangeDisplaySettings(NULL, 0);
996  }
997  }
998  break;
999  }
1000 #endif
1001  }
1002 
1003  return DefWindowProc(hwnd, msg, wParam, lParam);
1004 }
1005 
1006 static void RegisterWndClass()
1007 {
1008  static bool registered = false;
1009 
1010  if (!registered) {
1011  HINSTANCE hinst = GetModuleHandle(NULL);
1012  WNDCLASS wnd = {
1013  CS_OWNDC,
1014  WndProcGdi,
1015  0,
1016  0,
1017  hinst,
1018  LoadIcon(hinst, MAKEINTRESOURCE(100)),
1019  LoadCursor(NULL, IDC_ARROW),
1020  0,
1021  0,
1022  _T("OTTD")
1023  };
1024 
1025  registered = true;
1026  if (!RegisterClass(&wnd)) usererror("RegisterClass failed");
1027  }
1028 }
1029 
1030 static bool AllocateDibSection(int w, int h, bool force)
1031 {
1032  BITMAPINFO *bi;
1033  HDC dc;
1035 
1036  w = max(w, 64);
1037  h = max(h, 64);
1038 
1039  if (bpp == 0) usererror("Can't use a blitter that blits 0 bpp for normal visuals");
1040 
1041  if (!force && w == _screen.width && h == _screen.height) return false;
1042 
1043  bi = (BITMAPINFO*)alloca(sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * 256);
1044  memset(bi, 0, sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * 256);
1045  bi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
1046 
1047  bi->bmiHeader.biWidth = _wnd.width = w;
1048  bi->bmiHeader.biHeight = -(_wnd.height = h);
1049 
1050  bi->bmiHeader.biPlanes = 1;
1051  bi->bmiHeader.biBitCount = BlitterFactory::GetCurrentBlitter()->GetScreenDepth();
1052  bi->bmiHeader.biCompression = BI_RGB;
1053 
1054  if (_wnd.dib_sect) DeleteObject(_wnd.dib_sect);
1055 
1056  dc = GetDC(0);
1057  _wnd.dib_sect = CreateDIBSection(dc, bi, DIB_RGB_COLORS, (VOID**)&_wnd.buffer_bits, NULL, 0);
1058  if (_wnd.dib_sect == NULL) usererror("CreateDIBSection failed");
1059  ReleaseDC(0, dc);
1060 
1061  _screen.width = w;
1062  _screen.pitch = (bpp == 8) ? Align(w, 4) : w;
1063  _screen.height = h;
1064  _screen.dst_ptr = _wnd.buffer_bits;
1065 
1066  return true;
1067 }
1068 
1069 static const Dimension default_resolutions[] = {
1070  { 640, 480 },
1071  { 800, 600 },
1072  { 1024, 768 },
1073  { 1152, 864 },
1074  { 1280, 800 },
1075  { 1280, 960 },
1076  { 1280, 1024 },
1077  { 1400, 1050 },
1078  { 1600, 1200 },
1079  { 1680, 1050 },
1080  { 1920, 1200 }
1081 };
1082 
1083 static void FindResolutions()
1084 {
1085  uint n = 0;
1086 #if defined(WINCE)
1087  /* EnumDisplaySettingsW is only supported in CE 4.2+
1088  * XXX -- One might argue that we assume 4.2+ on every system. Then we can use this function safely */
1089 #else
1090  uint i;
1091  DEVMODEA dm;
1092 
1093  /* Check modes for the relevant fullscreen bpp */
1094  uint bpp = _support8bpp != S8BPP_HARDWARE ? 32 : BlitterFactory::GetCurrentBlitter()->GetScreenDepth();
1095 
1096  /* XXX - EnumDisplaySettingsW crashes with unicows.dll on Windows95
1097  * Doesn't really matter since we don't pass a string anyways, but still
1098  * a letdown */
1099  for (i = 0; EnumDisplaySettingsA(NULL, i, &dm) != 0; i++) {
1100  if (dm.dmBitsPerPel == bpp &&
1101  dm.dmPelsWidth >= 640 && dm.dmPelsHeight >= 480) {
1102  uint j;
1103 
1104  for (j = 0; j < n; j++) {
1105  if (_resolutions[j].width == dm.dmPelsWidth && _resolutions[j].height == dm.dmPelsHeight) break;
1106  }
1107 
1108  /* In the previous loop we have checked already existing/added resolutions if
1109  * they are the same as the new ones. If this is not the case (j == n); we have
1110  * looped all and found none, add the new one to the list. If we have reached the
1111  * maximum amount of resolutions, then quit querying the display */
1112  if (j == n) {
1113  _resolutions[j].width = dm.dmPelsWidth;
1114  _resolutions[j].height = dm.dmPelsHeight;
1115  if (++n == lengthof(_resolutions)) break;
1116  }
1117  }
1118  }
1119 #endif
1120 
1121  /* We have found no resolutions, show the default list */
1122  if (n == 0) {
1123  memcpy(_resolutions, default_resolutions, sizeof(default_resolutions));
1124  n = lengthof(default_resolutions);
1125  }
1126 
1127  _num_resolutions = n;
1128  SortResolutions(_num_resolutions);
1129 }
1130 
1131 static FVideoDriver_Win32 iFVideoDriver_Win32;
1132 
1133 const char *VideoDriver_Win32::Start(const char * const *parm)
1134 {
1135  memset(&_wnd, 0, sizeof(_wnd));
1136 
1137  RegisterWndClass();
1138 
1139  MakePalette();
1140 
1141  FindResolutions();
1142 
1143  DEBUG(driver, 2, "Resolution for display: %ux%u", _cur_resolution.width, _cur_resolution.height);
1144 
1145  /* fullscreen uses those */
1146  _wnd.width_org = _cur_resolution.width;
1147  _wnd.height_org = _cur_resolution.height;
1148 
1149  AllocateDibSection(_cur_resolution.width, _cur_resolution.height);
1150  this->MakeWindow(_fullscreen);
1151 
1153 
1154  _draw_threaded = GetDriverParam(parm, "no_threads") == NULL && GetDriverParam(parm, "no_thread") == NULL && GetCPUCoreCount() > 1;
1155 
1156  return NULL;
1157 }
1158 
1160 {
1161  DeleteObject(_wnd.gdi_palette);
1162  DeleteObject(_wnd.dib_sect);
1163  DestroyWindow(_wnd.main_wnd);
1164 
1165 #if !defined(WINCE)
1166  if (_wnd.fullscreen) ChangeDisplaySettings(NULL, 0);
1167 #endif
1168  MyShowCursor(true);
1169 }
1170 
1171 void VideoDriver_Win32::MakeDirty(int left, int top, int width, int height)
1172 {
1173  RECT r = { left, top, left + width, top + height };
1174 
1175  InvalidateRect(_wnd.main_wnd, &r, FALSE);
1176 }
1177 
1178 static void CheckPaletteAnim()
1179 {
1180  if (_cur_palette.count_dirty == 0) return;
1181 
1182  _local_palette = _cur_palette;
1183  InvalidateRect(_wnd.main_wnd, NULL, FALSE);
1184 }
1185 
1187 {
1188  MSG mesg;
1189  uint32 cur_ticks = GetTickCount();
1190  uint32 last_cur_ticks = cur_ticks;
1191  uint32 next_tick = cur_ticks + MILLISECONDS_PER_TICK;
1192 
1193  if (_draw_threaded) {
1194  /* Initialise the mutex first, because that's the thing we *need*
1195  * directly in the newly created thread. */
1196  _draw_mutex = ThreadMutex::New();
1197  _draw_thread_initialized = CreateEvent(NULL, FALSE, FALSE, NULL);
1198  if (_draw_mutex == NULL || _draw_thread_initialized == NULL) {
1199  _draw_threaded = false;
1200  } else {
1201  _draw_continue = true;
1202  _draw_threaded = ThreadObject::New(&PaintWindowThread, NULL, &_draw_thread, "ottd:draw-win32");
1203 
1204  /* Free the mutex if we won't be able to use it. */
1205  if (!_draw_threaded) {
1206  delete _draw_mutex;
1207  _draw_mutex = NULL;
1208  CloseHandle(_draw_thread_initialized);
1209  _draw_thread_initialized = NULL;
1210  } else {
1211  DEBUG(driver, 1, "Threaded drawing enabled");
1212  /* Wait till the draw thread has started itself. */
1213  WaitForSingleObject(_draw_thread_initialized, INFINITE);
1214  _draw_mutex->BeginCritical();
1215  }
1216  }
1217  }
1218 
1219  _wnd.running = true;
1220 
1221  CheckPaletteAnim();
1222  for (;;) {
1223  uint32 prev_cur_ticks = cur_ticks; // to check for wrapping
1224 
1225  while (PeekMessage(&mesg, NULL, 0, 0, PM_REMOVE)) {
1226  InteractiveRandom(); // randomness
1227  /* Convert key messages to char messages if we want text input. */
1228  if (EditBoxInGlobalFocus()) TranslateMessage(&mesg);
1229  DispatchMessage(&mesg);
1230  }
1231  if (_exit_game) return;
1232 
1233 #if defined(_DEBUG)
1234  if (_wnd.has_focus && GetAsyncKeyState(VK_SHIFT) < 0 &&
1235 #else
1236  /* Speed up using TAB, but disable for ALT+TAB of course */
1237  if (_wnd.has_focus && GetAsyncKeyState(VK_TAB) < 0 && GetAsyncKeyState(VK_MENU) >= 0 &&
1238 #endif
1239  !_networking && _game_mode != GM_MENU) {
1240  _fast_forward |= 2;
1241  } else if (_fast_forward & 2) {
1242  _fast_forward = 0;
1243  }
1244 
1245  cur_ticks = GetTickCount();
1246  if (cur_ticks >= next_tick || (_fast_forward && !_pause_mode) || cur_ticks < prev_cur_ticks) {
1247  _realtime_tick += cur_ticks - last_cur_ticks;
1248  last_cur_ticks = cur_ticks;
1249  next_tick = cur_ticks + MILLISECONDS_PER_TICK;
1250 
1251  bool old_ctrl_pressed = _ctrl_pressed;
1252 
1253  _ctrl_pressed = _wnd.has_focus && GetAsyncKeyState(VK_CONTROL)<0;
1254  _shift_pressed = _wnd.has_focus && GetAsyncKeyState(VK_SHIFT)<0;
1255 
1256  /* determine which directional keys are down */
1257  if (_wnd.has_focus) {
1258  _dirkeys =
1259  (GetAsyncKeyState(VK_LEFT) < 0 ? 1 : 0) +
1260  (GetAsyncKeyState(VK_UP) < 0 ? 2 : 0) +
1261  (GetAsyncKeyState(VK_RIGHT) < 0 ? 4 : 0) +
1262  (GetAsyncKeyState(VK_DOWN) < 0 ? 8 : 0);
1263  } else {
1264  _dirkeys = 0;
1265  }
1266 
1267  if (old_ctrl_pressed != _ctrl_pressed) HandleCtrlChanged();
1268 
1269 #if !defined(WINCE)
1270  /* Flush GDI buffer to ensure we don't conflict with the drawing thread. */
1271  GdiFlush();
1272 #endif
1273 
1274  /* The game loop is the part that can run asynchronously.
1275  * The rest except sleeping can't. */
1276  if (_draw_threaded) _draw_mutex->EndCritical();
1277  GameLoop();
1278  if (_draw_threaded) _draw_mutex->BeginCritical();
1279 
1280  if (_force_full_redraw) MarkWholeScreenDirty();
1281 
1282  UpdateWindows();
1283  CheckPaletteAnim();
1284  } else {
1285 #if !defined(WINCE)
1286  /* Flush GDI buffer to ensure we don't conflict with the drawing thread. */
1287  GdiFlush();
1288 #endif
1289 
1290  /* Release the thread while sleeping */
1291  if (_draw_threaded) _draw_mutex->EndCritical();
1292  Sleep(1);
1293  if (_draw_threaded) _draw_mutex->BeginCritical();
1294 
1296  DrawMouseCursor();
1297  }
1298  }
1299 
1300  if (_draw_threaded) {
1301  _draw_continue = false;
1302  /* Sending signal if there is no thread blocked
1303  * is very valid and results in noop */
1304  _draw_mutex->SendSignal();
1305  _draw_mutex->EndCritical();
1306  _draw_thread->Join();
1307 
1308  CloseHandle(_draw_thread_initialized);
1309  delete _draw_mutex;
1310  delete _draw_thread;
1311  }
1312 }
1313 
1315 {
1316  if (_draw_mutex != NULL) _draw_mutex->BeginCritical(true);
1317  if (_window_maximize) ShowWindow(_wnd.main_wnd, SW_SHOWNORMAL);
1318 
1319  _wnd.width = _wnd.width_org = w;
1320  _wnd.height = _wnd.height_org = h;
1321 
1322  bool ret = this->MakeWindow(_fullscreen); // _wnd.fullscreen screws up ingame resolution switching
1323  if (_draw_mutex != NULL) _draw_mutex->EndCritical(true);
1324  return ret;
1325 }
1326 
1328 {
1329  if (_draw_mutex != NULL) _draw_mutex->BeginCritical(true);
1330  bool ret = this->MakeWindow(full_screen);
1331  if (_draw_mutex != NULL) _draw_mutex->EndCritical(true);
1332  return ret;
1333 }
1334 
1336 {
1337  if (_draw_mutex != NULL) _draw_mutex->BeginCritical(true);
1338  bool ret = AllocateDibSection(_screen.width, _screen.height, true) && this->MakeWindow(_fullscreen);
1339  if (_draw_mutex != NULL) _draw_mutex->EndCritical(true);
1340  return ret;
1341 }
1342 
1344 {
1345  if (_draw_mutex != NULL) _draw_mutex->BeginCritical(true);
1346  CancelIMEComposition(_wnd.main_wnd);
1347  SetCompositionPos(_wnd.main_wnd);
1348  SetCandidatePos(_wnd.main_wnd);
1349  if (_draw_mutex != NULL) _draw_mutex->EndCritical(true);
1350 }