OpenTTD
win32_v.cpp
Go to the documentation of this file.
1 /* $Id: win32_v.cpp 26943 2014-09-30 21:10:32Z planetmaker $ */
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.fix_at) {
751  int dx = x - _cursor.pos.x;
752  int dy = y - _cursor.pos.y;
753  if (dx != 0 || dy != 0) {
754  _cursor.delta.x = dx;
755  _cursor.delta.y = dy;
756 
757  pt.x = _cursor.pos.x;
758  pt.y = _cursor.pos.y;
759 
760  ClientToScreen(hwnd, &pt);
761  SetCursorPos(pt.x, pt.y);
762  }
763  } else {
764  _cursor.delta.x = x - _cursor.pos.x;
765  _cursor.delta.y = y - _cursor.pos.y;
766  _cursor.pos.x = x;
767  _cursor.pos.y = y;
768  _cursor.dirty = true;
769  }
770  MyShowCursor(false);
772  return 0;
773  }
774 
775 #if !defined(WINCE) || _WIN32_WCE >= 0x400
776  case WM_INPUTLANGCHANGE:
777  _imm_props = ImmGetProperty(GetKeyboardLayout(0), IGP_PROPERTY);
778  break;
779 
780  case WM_IME_SETCONTEXT:
781  /* Don't show the composition window if we draw the string ourself. */
782  if (DrawIMECompositionString()) lParam &= ~ISC_SHOWUICOMPOSITIONWINDOW;
783  break;
784 
785  case WM_IME_STARTCOMPOSITION:
786  SetCompositionPos(hwnd);
787  if (DrawIMECompositionString()) return 0;
788  break;
789 
790  case WM_IME_COMPOSITION:
791  return HandleIMEComposition(hwnd, wParam, lParam);
792 
793  case WM_IME_ENDCOMPOSITION:
794  /* Clear any pending composition string. */
795  HandleTextInput(NULL, true);
796  if (DrawIMECompositionString()) return 0;
797  break;
798 
799  case WM_IME_NOTIFY:
800  if (wParam == IMN_OPENCANDIDATE) SetCandidatePos(hwnd);
801  break;
802 
803 #if !defined(UNICODE)
804  case WM_IME_CHAR:
805  if (GB(wParam, 8, 8) != 0) {
806  /* DBCS character, send lead byte first. */
807  HandleCharMsg(0, GB(wParam, 8, 8));
808  }
809  HandleCharMsg(0, GB(wParam, 0, 8));
810  return 0;
811 #endif
812 #endif
813 
814  case WM_DEADCHAR:
815  console = GB(lParam, 16, 8) == 41;
816  return 0;
817 
818  case WM_CHAR: {
819  uint scancode = GB(lParam, 16, 8);
820  uint charcode = wParam;
821 
822  /* If the console key is a dead-key, we need to press it twice to get a WM_CHAR message.
823  * But we then get two WM_CHAR messages, so ignore the first one */
824  if (console && scancode == 41) {
825  console = false;
826  return 0;
827  }
828 
829  /* IMEs and other input methods sometimes send a WM_CHAR without a WM_KEYDOWN,
830  * clear the keycode so a previous WM_KEYDOWN doesn't become 'stuck'. */
831  uint cur_keycode = keycode;
832  keycode = 0;
833 
834  return HandleCharMsg(cur_keycode, charcode);
835  }
836 
837  case WM_KEYDOWN: {
838  /* No matter the keyboard layout, we will map the '~' to the console. */
839  uint scancode = GB(lParam, 16, 8);
840  keycode = scancode == 41 ? (uint)WKC_BACKQUOTE : MapWindowsKey(wParam);
841 
842  /* Silently drop all messages handled by WM_CHAR. */
843  MSG msg;
844  if (PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE)) {
845  if ((msg.message == WM_CHAR || msg.message == WM_DEADCHAR) && GB(lParam, 16, 8) == GB(msg.lParam, 16, 8)) {
846  return 0;
847  }
848  }
849 
850  uint charcode = MapVirtualKey(wParam, MAPVK_VK_TO_CHAR);
851 
852  /* No character translation? */
853  if (charcode == 0) {
854  HandleKeypress(keycode, 0);
855  return 0;
856  }
857 
858  /* Is the console key a dead key? If yes, ignore the first key down event. */
859  if (HasBit(charcode, 31) && !console) {
860  if (scancode == 41) {
861  console = true;
862  return 0;
863  }
864  }
865  console = false;
866 
867  /* IMEs and other input methods sometimes send a WM_CHAR without a WM_KEYDOWN,
868  * clear the keycode so a previous WM_KEYDOWN doesn't become 'stuck'. */
869  uint cur_keycode = keycode;
870  keycode = 0;
871 
872  return HandleCharMsg(cur_keycode, LOWORD(charcode));
873  }
874 
875  case WM_SYSKEYDOWN: // user presses F10 or Alt, both activating the title-menu
876  switch (wParam) {
877  case VK_RETURN:
878  case 'F': // Full Screen on ALT + ENTER/F
879  ToggleFullScreen(!_wnd.fullscreen);
880  return 0;
881 
882  case VK_MENU: // Just ALT
883  return 0; // do nothing
884 
885  case VK_F10: // F10, ignore activation of menu
886  HandleKeypress(MapWindowsKey(wParam), 0);
887  return 0;
888 
889  default: // ALT in combination with something else
890  HandleKeypress(MapWindowsKey(wParam), 0);
891  break;
892  }
893  break;
894 
895  case WM_SIZE:
896  if (wParam != SIZE_MINIMIZED) {
897  /* Set maximized flag when we maximize (obviously), but also when we
898  * switched to fullscreen from a maximized state */
899  _window_maximize = (wParam == SIZE_MAXIMIZED || (_window_maximize && _fullscreen));
900  if (_window_maximize || _fullscreen) _bck_resolution = _cur_resolution;
901  ClientSizeChanged(LOWORD(lParam), HIWORD(lParam));
902  }
903  return 0;
904 
905 #if !defined(WINCE)
906  case WM_SIZING: {
907  RECT *r = (RECT*)lParam;
908  RECT r2;
909  int w, h;
910 
911  SetRect(&r2, 0, 0, 0, 0);
912  AdjustWindowRect(&r2, GetWindowLong(hwnd, GWL_STYLE), FALSE);
913 
914  w = r->right - r->left - (r2.right - r2.left);
915  h = r->bottom - r->top - (r2.bottom - r2.top);
916  w = max(w, 64);
917  h = max(h, 64);
918  SetRect(&r2, 0, 0, w, h);
919 
920  AdjustWindowRect(&r2, GetWindowLong(hwnd, GWL_STYLE), FALSE);
921  w = r2.right - r2.left;
922  h = r2.bottom - r2.top;
923 
924  switch (wParam) {
925  case WMSZ_BOTTOM:
926  r->bottom = r->top + h;
927  break;
928 
929  case WMSZ_BOTTOMLEFT:
930  r->bottom = r->top + h;
931  r->left = r->right - w;
932  break;
933 
934  case WMSZ_BOTTOMRIGHT:
935  r->bottom = r->top + h;
936  r->right = r->left + w;
937  break;
938 
939  case WMSZ_LEFT:
940  r->left = r->right - w;
941  break;
942 
943  case WMSZ_RIGHT:
944  r->right = r->left + w;
945  break;
946 
947  case WMSZ_TOP:
948  r->top = r->bottom - h;
949  break;
950 
951  case WMSZ_TOPLEFT:
952  r->top = r->bottom - h;
953  r->left = r->right - w;
954  break;
955 
956  case WMSZ_TOPRIGHT:
957  r->top = r->bottom - h;
958  r->right = r->left + w;
959  break;
960  }
961  return TRUE;
962  }
963 #endif
964 
965 /* needed for wheel */
966 #if !defined(WM_MOUSEWHEEL)
967 # define WM_MOUSEWHEEL 0x020A
968 #endif /* WM_MOUSEWHEEL */
969 #if !defined(GET_WHEEL_DELTA_WPARAM)
970 # define GET_WHEEL_DELTA_WPARAM(wparam) ((short)HIWORD(wparam))
971 #endif /* GET_WHEEL_DELTA_WPARAM */
972 
973  case WM_MOUSEWHEEL: {
974  int delta = GET_WHEEL_DELTA_WPARAM(wParam);
975 
976  if (delta < 0) {
977  _cursor.wheel++;
978  } else if (delta > 0) {
979  _cursor.wheel--;
980  }
982  return 0;
983  }
984 
985  case WM_SETFOCUS:
986  _wnd.has_focus = true;
987  SetCompositionPos(hwnd);
988  break;
989 
990  case WM_KILLFOCUS:
991  _wnd.has_focus = false;
992  break;
993 
994 #if !defined(WINCE)
995  case WM_ACTIVATE: {
996  /* Don't do anything if we are closing openttd */
997  if (_exit_game) break;
998 
999  bool active = (LOWORD(wParam) != WA_INACTIVE);
1000  bool minimized = (HIWORD(wParam) != 0);
1001  if (_wnd.fullscreen) {
1002  if (active && minimized) {
1003  /* Restore the game window */
1004  ShowWindow(hwnd, SW_RESTORE);
1005  static_cast<VideoDriver_Win32 *>(VideoDriver::GetInstance())->MakeWindow(true);
1006  } else if (!active && !minimized) {
1007  /* Minimise the window and restore desktop */
1008  ShowWindow(hwnd, SW_MINIMIZE);
1009  ChangeDisplaySettings(NULL, 0);
1010  }
1011  }
1012  break;
1013  }
1014 #endif
1015  }
1016 
1017  return DefWindowProc(hwnd, msg, wParam, lParam);
1018 }
1019 
1020 static void RegisterWndClass()
1021 {
1022  static bool registered = false;
1023 
1024  if (!registered) {
1025  HINSTANCE hinst = GetModuleHandle(NULL);
1026  WNDCLASS wnd = {
1027  CS_OWNDC,
1028  WndProcGdi,
1029  0,
1030  0,
1031  hinst,
1032  LoadIcon(hinst, MAKEINTRESOURCE(100)),
1033  LoadCursor(NULL, IDC_ARROW),
1034  0,
1035  0,
1036  _T("OTTD")
1037  };
1038 
1039  registered = true;
1040  if (!RegisterClass(&wnd)) usererror("RegisterClass failed");
1041  }
1042 }
1043 
1044 static bool AllocateDibSection(int w, int h, bool force)
1045 {
1046  BITMAPINFO *bi;
1047  HDC dc;
1049 
1050  w = max(w, 64);
1051  h = max(h, 64);
1052 
1053  if (bpp == 0) usererror("Can't use a blitter that blits 0 bpp for normal visuals");
1054 
1055  if (!force && w == _screen.width && h == _screen.height) return false;
1056 
1057  bi = (BITMAPINFO*)alloca(sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * 256);
1058  memset(bi, 0, sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * 256);
1059  bi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
1060 
1061  bi->bmiHeader.biWidth = _wnd.width = w;
1062  bi->bmiHeader.biHeight = -(_wnd.height = h);
1063 
1064  bi->bmiHeader.biPlanes = 1;
1065  bi->bmiHeader.biBitCount = BlitterFactory::GetCurrentBlitter()->GetScreenDepth();
1066  bi->bmiHeader.biCompression = BI_RGB;
1067 
1068  if (_wnd.dib_sect) DeleteObject(_wnd.dib_sect);
1069 
1070  dc = GetDC(0);
1071  _wnd.dib_sect = CreateDIBSection(dc, bi, DIB_RGB_COLORS, (VOID**)&_wnd.buffer_bits, NULL, 0);
1072  if (_wnd.dib_sect == NULL) usererror("CreateDIBSection failed");
1073  ReleaseDC(0, dc);
1074 
1075  _screen.width = w;
1076  _screen.pitch = (bpp == 8) ? Align(w, 4) : w;
1077  _screen.height = h;
1078  _screen.dst_ptr = _wnd.buffer_bits;
1079 
1080  return true;
1081 }
1082 
1083 static const Dimension default_resolutions[] = {
1084  { 640, 480 },
1085  { 800, 600 },
1086  { 1024, 768 },
1087  { 1152, 864 },
1088  { 1280, 800 },
1089  { 1280, 960 },
1090  { 1280, 1024 },
1091  { 1400, 1050 },
1092  { 1600, 1200 },
1093  { 1680, 1050 },
1094  { 1920, 1200 }
1095 };
1096 
1097 static void FindResolutions()
1098 {
1099  uint n = 0;
1100 #if defined(WINCE)
1101  /* EnumDisplaySettingsW is only supported in CE 4.2+
1102  * XXX -- One might argue that we assume 4.2+ on every system. Then we can use this function safely */
1103 #else
1104  uint i;
1105  DEVMODEA dm;
1106 
1107  /* Check modes for the relevant fullscreen bpp */
1108  uint bpp = _support8bpp != S8BPP_HARDWARE ? 32 : BlitterFactory::GetCurrentBlitter()->GetScreenDepth();
1109 
1110  /* XXX - EnumDisplaySettingsW crashes with unicows.dll on Windows95
1111  * Doesn't really matter since we don't pass a string anyways, but still
1112  * a letdown */
1113  for (i = 0; EnumDisplaySettingsA(NULL, i, &dm) != 0; i++) {
1114  if (dm.dmBitsPerPel == bpp &&
1115  dm.dmPelsWidth >= 640 && dm.dmPelsHeight >= 480) {
1116  uint j;
1117 
1118  for (j = 0; j < n; j++) {
1119  if (_resolutions[j].width == dm.dmPelsWidth && _resolutions[j].height == dm.dmPelsHeight) break;
1120  }
1121 
1122  /* In the previous loop we have checked already existing/added resolutions if
1123  * they are the same as the new ones. If this is not the case (j == n); we have
1124  * looped all and found none, add the new one to the list. If we have reached the
1125  * maximum amount of resolutions, then quit querying the display */
1126  if (j == n) {
1127  _resolutions[j].width = dm.dmPelsWidth;
1128  _resolutions[j].height = dm.dmPelsHeight;
1129  if (++n == lengthof(_resolutions)) break;
1130  }
1131  }
1132  }
1133 #endif
1134 
1135  /* We have found no resolutions, show the default list */
1136  if (n == 0) {
1137  memcpy(_resolutions, default_resolutions, sizeof(default_resolutions));
1138  n = lengthof(default_resolutions);
1139  }
1140 
1141  _num_resolutions = n;
1142  SortResolutions(_num_resolutions);
1143 }
1144 
1145 static FVideoDriver_Win32 iFVideoDriver_Win32;
1146 
1147 const char *VideoDriver_Win32::Start(const char * const *parm)
1148 {
1149  memset(&_wnd, 0, sizeof(_wnd));
1150 
1151  RegisterWndClass();
1152 
1153  MakePalette();
1154 
1155  FindResolutions();
1156 
1157  DEBUG(driver, 2, "Resolution for display: %ux%u", _cur_resolution.width, _cur_resolution.height);
1158 
1159  /* fullscreen uses those */
1160  _wnd.width_org = _cur_resolution.width;
1161  _wnd.height_org = _cur_resolution.height;
1162 
1163  AllocateDibSection(_cur_resolution.width, _cur_resolution.height);
1164  this->MakeWindow(_fullscreen);
1165 
1167 
1168  _draw_threaded = GetDriverParam(parm, "no_threads") == NULL && GetDriverParam(parm, "no_thread") == NULL && GetCPUCoreCount() > 1;
1169 
1170  return NULL;
1171 }
1172 
1174 {
1175  DeleteObject(_wnd.gdi_palette);
1176  DeleteObject(_wnd.dib_sect);
1177  DestroyWindow(_wnd.main_wnd);
1178 
1179 #if !defined(WINCE)
1180  if (_wnd.fullscreen) ChangeDisplaySettings(NULL, 0);
1181 #endif
1182  MyShowCursor(true);
1183 }
1184 
1185 void VideoDriver_Win32::MakeDirty(int left, int top, int width, int height)
1186 {
1187  RECT r = { left, top, left + width, top + height };
1188 
1189  InvalidateRect(_wnd.main_wnd, &r, FALSE);
1190 }
1191 
1192 static void CheckPaletteAnim()
1193 {
1194  if (_cur_palette.count_dirty == 0) return;
1195 
1196  _local_palette = _cur_palette;
1197  InvalidateRect(_wnd.main_wnd, NULL, FALSE);
1198 }
1199 
1201 {
1202  MSG mesg;
1203  uint32 cur_ticks = GetTickCount();
1204  uint32 last_cur_ticks = cur_ticks;
1205  uint32 next_tick = cur_ticks + MILLISECONDS_PER_TICK;
1206 
1207  if (_draw_threaded) {
1208  /* Initialise the mutex first, because that's the thing we *need*
1209  * directly in the newly created thread. */
1210  _draw_mutex = ThreadMutex::New();
1211  _draw_thread_initialized = CreateEvent(NULL, FALSE, FALSE, NULL);
1212  if (_draw_mutex == NULL || _draw_thread_initialized == NULL) {
1213  _draw_threaded = false;
1214  } else {
1215  _draw_continue = true;
1216  _draw_threaded = ThreadObject::New(&PaintWindowThread, NULL, &_draw_thread);
1217 
1218  /* Free the mutex if we won't be able to use it. */
1219  if (!_draw_threaded) {
1220  delete _draw_mutex;
1221  _draw_mutex = NULL;
1222  CloseHandle(_draw_thread_initialized);
1223  _draw_thread_initialized = NULL;
1224  } else {
1225  DEBUG(driver, 1, "Threaded drawing enabled");
1226  /* Wait till the draw thread has started itself. */
1227  WaitForSingleObject(_draw_thread_initialized, INFINITE);
1228  _draw_mutex->BeginCritical();
1229  }
1230  }
1231  }
1232 
1233  _wnd.running = true;
1234 
1235  CheckPaletteAnim();
1236  for (;;) {
1237  uint32 prev_cur_ticks = cur_ticks; // to check for wrapping
1238 
1239  while (PeekMessage(&mesg, NULL, 0, 0, PM_REMOVE)) {
1240  InteractiveRandom(); // randomness
1241  /* Convert key messages to char messages if we want text input. */
1242  if (EditBoxInGlobalFocus()) TranslateMessage(&mesg);
1243  DispatchMessage(&mesg);
1244  }
1245  if (_exit_game) return;
1246 
1247 #if defined(_DEBUG)
1248  if (_wnd.has_focus && GetAsyncKeyState(VK_SHIFT) < 0 &&
1249 #else
1250  /* Speed up using TAB, but disable for ALT+TAB of course */
1251  if (_wnd.has_focus && GetAsyncKeyState(VK_TAB) < 0 && GetAsyncKeyState(VK_MENU) >= 0 &&
1252 #endif
1253  !_networking && _game_mode != GM_MENU) {
1254  _fast_forward |= 2;
1255  } else if (_fast_forward & 2) {
1256  _fast_forward = 0;
1257  }
1258 
1259  cur_ticks = GetTickCount();
1260  if (cur_ticks >= next_tick || (_fast_forward && !_pause_mode) || cur_ticks < prev_cur_ticks) {
1261  _realtime_tick += cur_ticks - last_cur_ticks;
1262  last_cur_ticks = cur_ticks;
1263  next_tick = cur_ticks + MILLISECONDS_PER_TICK;
1264 
1265  bool old_ctrl_pressed = _ctrl_pressed;
1266 
1267  _ctrl_pressed = _wnd.has_focus && GetAsyncKeyState(VK_CONTROL)<0;
1268  _shift_pressed = _wnd.has_focus && GetAsyncKeyState(VK_SHIFT)<0;
1269 
1270  /* determine which directional keys are down */
1271  if (_wnd.has_focus) {
1272  _dirkeys =
1273  (GetAsyncKeyState(VK_LEFT) < 0 ? 1 : 0) +
1274  (GetAsyncKeyState(VK_UP) < 0 ? 2 : 0) +
1275  (GetAsyncKeyState(VK_RIGHT) < 0 ? 4 : 0) +
1276  (GetAsyncKeyState(VK_DOWN) < 0 ? 8 : 0);
1277  } else {
1278  _dirkeys = 0;
1279  }
1280 
1281  if (old_ctrl_pressed != _ctrl_pressed) HandleCtrlChanged();
1282 
1283 #if !defined(WINCE)
1284  /* Flush GDI buffer to ensure we don't conflict with the drawing thread. */
1285  GdiFlush();
1286 #endif
1287 
1288  /* The game loop is the part that can run asynchronously.
1289  * The rest except sleeping can't. */
1290  if (_draw_threaded) _draw_mutex->EndCritical();
1291  GameLoop();
1292  if (_draw_threaded) _draw_mutex->BeginCritical();
1293 
1294  if (_force_full_redraw) MarkWholeScreenDirty();
1295 
1296  UpdateWindows();
1297  CheckPaletteAnim();
1298  } else {
1299 #if !defined(WINCE)
1300  /* Flush GDI buffer to ensure we don't conflict with the drawing thread. */
1301  GdiFlush();
1302 #endif
1303 
1304  /* Release the thread while sleeping */
1305  if (_draw_threaded) _draw_mutex->EndCritical();
1306  Sleep(1);
1307  if (_draw_threaded) _draw_mutex->BeginCritical();
1308 
1310  DrawMouseCursor();
1311  }
1312  }
1313 
1314  if (_draw_threaded) {
1315  _draw_continue = false;
1316  /* Sending signal if there is no thread blocked
1317  * is very valid and results in noop */
1318  _draw_mutex->SendSignal();
1319  _draw_mutex->EndCritical();
1320  _draw_thread->Join();
1321 
1322  CloseHandle(_draw_thread_initialized);
1323  delete _draw_mutex;
1324  delete _draw_thread;
1325  }
1326 }
1327 
1329 {
1330  if (_draw_mutex != NULL) _draw_mutex->BeginCritical(true);
1331  if (_window_maximize) ShowWindow(_wnd.main_wnd, SW_SHOWNORMAL);
1332 
1333  _wnd.width = _wnd.width_org = w;
1334  _wnd.height = _wnd.height_org = h;
1335 
1336  bool ret = this->MakeWindow(_fullscreen); // _wnd.fullscreen screws up ingame resolution switching
1337  if (_draw_mutex != NULL) _draw_mutex->EndCritical(true);
1338  return ret;
1339 }
1340 
1342 {
1343  if (_draw_mutex != NULL) _draw_mutex->BeginCritical(true);
1344  bool ret = this->MakeWindow(full_screen);
1345  if (_draw_mutex != NULL) _draw_mutex->EndCritical(true);
1346  return ret;
1347 }
1348 
1350 {
1351  if (_draw_mutex != NULL) _draw_mutex->BeginCritical(true);
1352  bool ret = AllocateDibSection(_screen.width, _screen.height, true) && this->MakeWindow(_fullscreen);
1353  if (_draw_mutex != NULL) _draw_mutex->EndCritical(true);
1354  return ret;
1355 }
1356 
1358 {
1359  if (_draw_mutex != NULL) _draw_mutex->BeginCritical(true);
1360  CancelIMEComposition(_wnd.main_wnd);
1361  SetCompositionPos(_wnd.main_wnd);
1362  SetCandidatePos(_wnd.main_wnd);
1363  if (_draw_mutex != NULL) _draw_mutex->EndCritical(true);
1364 }