00001
00002
00003
00004
00005
00006
00007
00008
00009
00012 #include "../stdafx.h"
00013 #include "../openttd.h"
00014 #include "../gfx_func.h"
00015 #include "../os/windows/win32.h"
00016 #include "../rev.h"
00017 #include "../blitter/factory.hpp"
00018 #include "../network/network.h"
00019 #include "../core/math_func.hpp"
00020 #include "../core/random_func.hpp"
00021 #include "../texteff.hpp"
00022 #include "win32_v.h"
00023 #include <windows.h>
00024
00025 static struct {
00026 HWND main_wnd;
00027 HBITMAP dib_sect;
00028 void *buffer_bits;
00029 HPALETTE gdi_palette;
00030 int width;
00031 int height;
00032 int width_org;
00033 int height_org;
00034 bool fullscreen;
00035 bool has_focus;
00036 bool running;
00037 } _wnd;
00038
00039 bool _force_full_redraw;
00040 bool _window_maximize;
00041 uint _display_hz;
00042 uint _fullscreen_bpp;
00043 static Dimension _bck_resolution;
00044 #if !defined(UNICODE)
00045 uint _codepage;
00046 #endif
00047
00048 static void MakePalette()
00049 {
00050 LOGPALETTE *pal;
00051 uint i;
00052
00053 pal = (LOGPALETTE*)alloca(sizeof(LOGPALETTE) + (256 - 1) * sizeof(PALETTEENTRY));
00054
00055 pal->palVersion = 0x300;
00056 pal->palNumEntries = 256;
00057
00058 for (i = 0; i != 256; i++) {
00059 pal->palPalEntry[i].peRed = _cur_palette[i].r;
00060 pal->palPalEntry[i].peGreen = _cur_palette[i].g;
00061 pal->palPalEntry[i].peBlue = _cur_palette[i].b;
00062 pal->palPalEntry[i].peFlags = 0;
00063
00064 }
00065 _wnd.gdi_palette = CreatePalette(pal);
00066 if (_wnd.gdi_palette == NULL) usererror("CreatePalette failed!\n");
00067 }
00068
00069 static void UpdatePalette(HDC dc, uint start, uint count)
00070 {
00071 RGBQUAD rgb[256];
00072 uint i;
00073
00074 for (i = 0; i != count; i++) {
00075 rgb[i].rgbRed = _cur_palette[start + i].r;
00076 rgb[i].rgbGreen = _cur_palette[start + i].g;
00077 rgb[i].rgbBlue = _cur_palette[start + i].b;
00078 rgb[i].rgbReserved = 0;
00079 }
00080
00081 SetDIBColorTable(dc, start, count, rgb);
00082 }
00083
00084 struct VkMapping {
00085 byte vk_from;
00086 byte vk_count;
00087 byte map_to;
00088 };
00089
00090 #define AS(x, z) {x, 0, z}
00091 #define AM(x, y, z, w) {x, y - x, z}
00092
00093 static const VkMapping _vk_mapping[] = {
00094
00095 AM(VK_PRIOR, VK_DOWN, WKC_PAGEUP, WKC_DOWN),
00096
00097 AM('A', 'Z', 'A', 'Z'),
00098 AM('0', '9', '0', '9'),
00099
00100 AS(VK_ESCAPE, WKC_ESC),
00101 AS(VK_PAUSE, WKC_PAUSE),
00102 AS(VK_BACK, WKC_BACKSPACE),
00103 AM(VK_INSERT, VK_DELETE, WKC_INSERT, WKC_DELETE),
00104
00105 AS(VK_SPACE, WKC_SPACE),
00106 AS(VK_RETURN, WKC_RETURN),
00107 AS(VK_TAB, WKC_TAB),
00108
00109
00110 AM(VK_F1, VK_F12, WKC_F1, WKC_F12),
00111
00112
00113 AM(VK_NUMPAD0, VK_NUMPAD9, '0', '9'),
00114 AS(VK_DIVIDE, WKC_NUM_DIV),
00115 AS(VK_MULTIPLY, WKC_NUM_MUL),
00116 AS(VK_SUBTRACT, WKC_NUM_MINUS),
00117 AS(VK_ADD, WKC_NUM_PLUS),
00118 AS(VK_DECIMAL, WKC_NUM_DECIMAL),
00119
00120
00121 AS(0xBF, WKC_SLASH),
00122 AS(0xBA, WKC_SEMICOLON),
00123 AS(0xBB, WKC_EQUALS),
00124 AS(0xDB, WKC_L_BRACKET),
00125 AS(0xDC, WKC_BACKSLASH),
00126 AS(0xDD, WKC_R_BRACKET),
00127
00128 AS(0xDE, WKC_SINGLEQUOTE),
00129 AS(0xBC, WKC_COMMA),
00130 AS(0xBD, WKC_MINUS),
00131 AS(0xBE, WKC_PERIOD)
00132 };
00133
00134 static uint MapWindowsKey(uint sym)
00135 {
00136 const VkMapping *map;
00137 uint key = 0;
00138
00139 for (map = _vk_mapping; map != endof(_vk_mapping); ++map) {
00140 if ((uint)(sym - map->vk_from) <= map->vk_count) {
00141 key = sym - map->vk_from + map->map_to;
00142 break;
00143 }
00144 }
00145
00146 if (GetAsyncKeyState(VK_SHIFT) < 0) key |= WKC_SHIFT;
00147 if (GetAsyncKeyState(VK_CONTROL) < 0) key |= WKC_CTRL;
00148 if (GetAsyncKeyState(VK_MENU) < 0) key |= WKC_ALT;
00149 return key;
00150 }
00151
00152 static bool AllocateDibSection(int w, int h);
00153
00154 static void ClientSizeChanged(int w, int h)
00155 {
00156
00157 if (AllocateDibSection(w, h)) {
00158
00159 _pal_first_dirty = 0;
00160 _pal_count_dirty = 256;
00161
00162 BlitterFactoryBase::GetCurrentBlitter()->PostResize();
00163
00164 GameSizeChanged();
00165
00166
00167 if (_wnd.running) {
00168 _screen.dst_ptr = _wnd.buffer_bits;
00169 UpdateWindows();
00170 }
00171 }
00172 }
00173
00174 #ifdef _DEBUG
00175
00176
00177 int RedrawScreenDebug()
00178 {
00179 HDC dc, dc2;
00180 static int _fooctr;
00181 HBITMAP old_bmp;
00182 HPALETTE old_palette;
00183
00184 _screen.dst_ptr = _wnd.buffer_bits;
00185 UpdateWindows();
00186
00187 dc = GetDC(_wnd.main_wnd);
00188 dc2 = CreateCompatibleDC(dc);
00189
00190 old_bmp = (HBITMAP)SelectObject(dc2, _wnd.dib_sect);
00191 old_palette = SelectPalette(dc, _wnd.gdi_palette, FALSE);
00192 BitBlt(dc, 0, 0, _wnd.width, _wnd.height, dc2, 0, 0, SRCCOPY);
00193 SelectPalette(dc, old_palette, TRUE);
00194 SelectObject(dc2, old_bmp);
00195 DeleteDC(dc2);
00196 ReleaseDC(_wnd.main_wnd, dc);
00197
00198 return _fooctr++;
00199 }
00200 #endif
00201
00202
00203 #if !defined(WM_MOUSELEAVE)
00204 #define WM_MOUSELEAVE 0x02A3
00205 #endif
00206 #define TID_POLLMOUSE 1
00207 #define MOUSE_POLL_DELAY 75
00208
00209 static void CALLBACK TrackMouseTimerProc(HWND hwnd, UINT msg, UINT event, DWORD time)
00210 {
00211 RECT rc;
00212 POINT pt;
00213
00214
00215
00216
00217 GetClientRect(hwnd, &rc);
00218 MapWindowPoints(hwnd, HWND_DESKTOP, (LPPOINT)(LPRECT)&rc, 2);
00219 GetCursorPos(&pt);
00220
00221 if (!PtInRect(&rc, pt) || (WindowFromPoint(pt) != hwnd)) {
00222 KillTimer(hwnd, event);
00223 PostMessage(hwnd, WM_MOUSELEAVE, 0, 0L);
00224 }
00225 }
00226
00232 bool VideoDriver_Win32::MakeWindow(bool full_screen)
00233 {
00234 _fullscreen = full_screen;
00235
00236
00237 if ((full_screen || _wnd.fullscreen) && _wnd.main_wnd) {
00238 DestroyWindow(_wnd.main_wnd);
00239 _wnd.main_wnd = 0;
00240 }
00241
00242 #if defined(WINCE)
00243
00244 #else
00245 if (full_screen) {
00246 DEVMODE settings;
00247
00248
00249 if (_fullscreen_bpp < BlitterFactoryBase::GetCurrentBlitter()->GetScreenDepth()) _fullscreen_bpp = BlitterFactoryBase::GetCurrentBlitter()->GetScreenDepth();
00250
00251 memset(&settings, 0, sizeof(settings));
00252 settings.dmSize = sizeof(settings);
00253 settings.dmFields =
00254 (_fullscreen_bpp != 0 ? DM_BITSPERPEL : 0) |
00255 DM_PELSWIDTH |
00256 DM_PELSHEIGHT |
00257 (_display_hz != 0 ? DM_DISPLAYFREQUENCY : 0);
00258 settings.dmBitsPerPel = _fullscreen_bpp;
00259 settings.dmPelsWidth = _wnd.width_org;
00260 settings.dmPelsHeight = _wnd.height_org;
00261 settings.dmDisplayFrequency = _display_hz;
00262
00263
00264 if (ChangeDisplaySettings(&settings, CDS_FULLSCREEN | CDS_TEST) != DISP_CHANGE_SUCCESSFUL) {
00265 RECT r;
00266 GetWindowRect(GetDesktopWindow(), &r);
00267 return this->ChangeResolution(r.right - r.left, r.bottom - r.top);
00268 }
00269
00270 if (ChangeDisplaySettings(&settings, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL) {
00271 this->MakeWindow(false);
00272 return false;
00273 }
00274 } else if (_wnd.fullscreen) {
00275
00276 ChangeDisplaySettings(NULL, 0);
00277 }
00278 #endif
00279
00280 {
00281 RECT r;
00282 DWORD style, showstyle;
00283 int x, y, w, h;
00284
00285 showstyle = SW_SHOWNORMAL;
00286 _wnd.fullscreen = full_screen;
00287 if (_wnd.fullscreen) {
00288 style = WS_POPUP;
00289 SetRect(&r, 0, 0, _wnd.width_org, _wnd.height_org);
00290 } else {
00291 style = WS_OVERLAPPEDWINDOW;
00292
00293 if (_window_maximize) showstyle = SW_SHOWMAXIMIZED;
00294 SetRect(&r, 0, 0, _wnd.width, _wnd.height);
00295 }
00296
00297 #if !defined(WINCE)
00298 AdjustWindowRect(&r, style, FALSE);
00299 #endif
00300 w = r.right - r.left;
00301 h = r.bottom - r.top;
00302 x = (GetSystemMetrics(SM_CXSCREEN) - w) / 2;
00303 y = (GetSystemMetrics(SM_CYSCREEN) - h) / 2;
00304
00305 if (_wnd.main_wnd) {
00306 ShowWindow(_wnd.main_wnd, SW_SHOWNORMAL);
00307 SetWindowPos(_wnd.main_wnd, 0, x, y, w, h, SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOZORDER);
00308 } else {
00309 TCHAR Windowtitle[50];
00310
00311 _sntprintf(Windowtitle, lengthof(Windowtitle), _T("OpenTTD %s"), MB_TO_WIDE(_openttd_revision));
00312
00313 _wnd.main_wnd = CreateWindow(_T("OTTD"), Windowtitle, style, x, y, w, h, 0, 0, GetModuleHandle(NULL), 0);
00314 if (_wnd.main_wnd == NULL) usererror("CreateWindow failed");
00315 ShowWindow(_wnd.main_wnd, showstyle);
00316 }
00317 }
00318
00319 BlitterFactoryBase::GetCurrentBlitter()->PostResize();
00320
00321 GameSizeChanged();
00322 return true;
00323 }
00324
00325 static LRESULT CALLBACK WndProcGdi(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
00326 {
00327 static uint32 keycode = 0;
00328 static bool console = false;
00329
00330 switch (msg) {
00331 case WM_CREATE:
00332 SetTimer(hwnd, TID_POLLMOUSE, MOUSE_POLL_DELAY, (TIMERPROC)TrackMouseTimerProc);
00333 break;
00334
00335 case WM_PAINT: {
00336 PAINTSTRUCT ps;
00337 HDC dc, dc2;
00338 HBITMAP old_bmp;
00339 HPALETTE old_palette;
00340
00341 BeginPaint(hwnd, &ps);
00342 dc = ps.hdc;
00343 dc2 = CreateCompatibleDC(dc);
00344 old_bmp = (HBITMAP)SelectObject(dc2, _wnd.dib_sect);
00345 old_palette = SelectPalette(dc, _wnd.gdi_palette, FALSE);
00346
00347 if (_pal_count_dirty != 0) {
00348 Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();
00349
00350 switch (blitter->UsePaletteAnimation()) {
00351 case Blitter::PALETTE_ANIMATION_VIDEO_BACKEND:
00352 UpdatePalette(dc2, _pal_first_dirty, _pal_count_dirty);
00353 break;
00354
00355 case Blitter::PALETTE_ANIMATION_BLITTER:
00356 blitter->PaletteAnimate(_pal_first_dirty, _pal_count_dirty);
00357 break;
00358
00359 case Blitter::PALETTE_ANIMATION_NONE:
00360 break;
00361
00362 default:
00363 NOT_REACHED();
00364 }
00365 _pal_count_dirty = 0;
00366 }
00367
00368 BitBlt(dc, 0, 0, _wnd.width, _wnd.height, dc2, 0, 0, SRCCOPY);
00369 SelectPalette(dc, old_palette, TRUE);
00370 SelectObject(dc2, old_bmp);
00371 DeleteDC(dc2);
00372 EndPaint(hwnd, &ps);
00373 return 0;
00374 }
00375
00376 case WM_PALETTECHANGED:
00377 if ((HWND)wParam == hwnd) return 0;
00378
00379
00380 case WM_QUERYNEWPALETTE: {
00381 HDC hDC = GetWindowDC(hwnd);
00382 HPALETTE hOldPalette = SelectPalette(hDC, _wnd.gdi_palette, FALSE);
00383 UINT nChanged = RealizePalette(hDC);
00384
00385 SelectPalette(hDC, hOldPalette, TRUE);
00386 ReleaseDC(hwnd, hDC);
00387 if (nChanged != 0) InvalidateRect(hwnd, NULL, FALSE);
00388 return 0;
00389 }
00390
00391 case WM_CLOSE:
00392 HandleExitGameRequest();
00393 return 0;
00394
00395 case WM_DESTROY:
00396 if (_window_maximize) _cur_resolution = _bck_resolution;
00397 return 0;
00398
00399 case WM_LBUTTONDOWN:
00400 SetCapture(hwnd);
00401 _left_button_down = true;
00402 HandleMouseEvents();
00403 return 0;
00404
00405 case WM_LBUTTONUP:
00406 ReleaseCapture();
00407 _left_button_down = false;
00408 _left_button_clicked = false;
00409 HandleMouseEvents();
00410 return 0;
00411
00412 case WM_RBUTTONDOWN:
00413 SetCapture(hwnd);
00414 _right_button_down = true;
00415 _right_button_clicked = true;
00416 HandleMouseEvents();
00417 return 0;
00418
00419 case WM_RBUTTONUP:
00420 ReleaseCapture();
00421 _right_button_down = false;
00422 HandleMouseEvents();
00423 return 0;
00424
00425 case WM_MOUSELEAVE:
00426 UndrawMouseCursor();
00427 _cursor.in_window = false;
00428
00429 if (!_left_button_down && !_right_button_down) MyShowCursor(true);
00430 return 0;
00431
00432 case WM_MOUSEMOVE: {
00433 int x = (int16)LOWORD(lParam);
00434 int y = (int16)HIWORD(lParam);
00435 POINT pt;
00436
00437
00438
00439
00440 if (!_cursor.in_window) {
00441 _cursor.in_window = true;
00442 SetTimer(hwnd, TID_POLLMOUSE, MOUSE_POLL_DELAY, (TIMERPROC)TrackMouseTimerProc);
00443
00444 DrawMouseCursor();
00445 }
00446
00447 if (_cursor.fix_at) {
00448 int dx = x - _cursor.pos.x;
00449 int dy = y - _cursor.pos.y;
00450 if (dx != 0 || dy != 0) {
00451 _cursor.delta.x = dx;
00452 _cursor.delta.y = dy;
00453
00454 pt.x = _cursor.pos.x;
00455 pt.y = _cursor.pos.y;
00456
00457 ClientToScreen(hwnd, &pt);
00458 SetCursorPos(pt.x, pt.y);
00459 }
00460 } else {
00461 _cursor.delta.x = x - _cursor.pos.x;
00462 _cursor.delta.y = y - _cursor.pos.y;
00463 _cursor.pos.x = x;
00464 _cursor.pos.y = y;
00465 _cursor.dirty = true;
00466 }
00467 MyShowCursor(false);
00468 HandleMouseEvents();
00469 return 0;
00470 }
00471
00472 #if !defined(UNICODE)
00473 case WM_INPUTLANGCHANGE: {
00474 TCHAR locale[6];
00475 LCID lcid = GB(lParam, 0, 16);
00476
00477 int len = GetLocaleInfo(lcid, LOCALE_IDEFAULTANSICODEPAGE, locale, lengthof(locale));
00478 if (len != 0) _codepage = _ttoi(locale);
00479 return 1;
00480 }
00481 #endif
00482
00483 case WM_DEADCHAR:
00484 console = GB(lParam, 16, 8) == 41;
00485 return 0;
00486
00487 case WM_CHAR: {
00488 uint scancode = GB(lParam, 16, 8);
00489 uint charcode = wParam;
00490
00491
00492
00493 if (console && scancode == 41) {
00494 console = false;
00495 return 0;
00496 }
00497
00498 #if !defined(UNICODE)
00499 wchar_t w;
00500 int len = MultiByteToWideChar(_codepage, 0, (char*)&charcode, 1, &w, 1);
00501 charcode = len == 1 ? w : 0;
00502 #endif
00503
00504
00505 scancode = scancode == 41 ? (int)WKC_BACKQUOTE : keycode;
00506 HandleKeypress(GB(charcode, 0, 16) | (scancode << 16));
00507 return 0;
00508 }
00509
00510 case WM_KEYDOWN: {
00511 keycode = MapWindowsKey(wParam);
00512
00513
00514 MSG msg;
00515 if (PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE)) {
00516 if (msg.message == WM_CHAR && GB(lParam, 16, 8) == GB(msg.lParam, 16, 8)) {
00517 return 0;
00518 }
00519 }
00520
00521 HandleKeypress(0 | (keycode << 16));
00522 return 0;
00523 }
00524
00525 case WM_SYSKEYDOWN:
00526 switch (wParam) {
00527 case VK_RETURN:
00528 case 'F':
00529 ToggleFullScreen(!_wnd.fullscreen);
00530 return 0;
00531
00532 case VK_MENU:
00533 return 0;
00534
00535 case VK_F10:
00536 HandleKeypress(MapWindowsKey(wParam) << 16);
00537 return 0;
00538
00539 default:
00540 HandleKeypress(MapWindowsKey(wParam) << 16);
00541 break;
00542 }
00543 break;
00544
00545 case WM_SIZE:
00546 if (wParam != SIZE_MINIMIZED) {
00547
00548
00549 _window_maximize = (wParam == SIZE_MAXIMIZED || (_window_maximize && _fullscreen));
00550 if (_window_maximize) _bck_resolution = _cur_resolution;
00551 ClientSizeChanged(LOWORD(lParam), HIWORD(lParam));
00552 }
00553 return 0;
00554
00555 #if !defined(WINCE)
00556 case WM_SIZING: {
00557 RECT *r = (RECT*)lParam;
00558 RECT r2;
00559 int w, h;
00560
00561 SetRect(&r2, 0, 0, 0, 0);
00562 AdjustWindowRect(&r2, GetWindowLong(hwnd, GWL_STYLE), FALSE);
00563
00564 w = r->right - r->left - (r2.right - r2.left);
00565 h = r->bottom - r->top - (r2.bottom - r2.top);
00566 w = max(w, 64);
00567 h = max(h, 64);
00568 SetRect(&r2, 0, 0, w, h);
00569
00570 AdjustWindowRect(&r2, GetWindowLong(hwnd, GWL_STYLE), FALSE);
00571 w = r2.right - r2.left;
00572 h = r2.bottom - r2.top;
00573
00574 switch (wParam) {
00575 case WMSZ_BOTTOM:
00576 r->bottom = r->top + h;
00577 break;
00578
00579 case WMSZ_BOTTOMLEFT:
00580 r->bottom = r->top + h;
00581 r->left = r->right - w;
00582 break;
00583
00584 case WMSZ_BOTTOMRIGHT:
00585 r->bottom = r->top + h;
00586 r->right = r->left + w;
00587 break;
00588
00589 case WMSZ_LEFT:
00590 r->left = r->right - w;
00591 break;
00592
00593 case WMSZ_RIGHT:
00594 r->right = r->left + w;
00595 break;
00596
00597 case WMSZ_TOP:
00598 r->top = r->bottom - h;
00599 break;
00600
00601 case WMSZ_TOPLEFT:
00602 r->top = r->bottom - h;
00603 r->left = r->right - w;
00604 break;
00605
00606 case WMSZ_TOPRIGHT:
00607 r->top = r->bottom - h;
00608 r->right = r->left + w;
00609 break;
00610 }
00611 return TRUE;
00612 }
00613 #endif
00614
00615
00616 #if !defined(WM_MOUSEWHEEL)
00617 # define WM_MOUSEWHEEL 0x020A
00618 #endif
00619 #if !defined(GET_WHEEL_DELTA_WPARAM)
00620 # define GET_WHEEL_DELTA_WPARAM(wparam) ((short)HIWORD(wparam))
00621 #endif
00622
00623 case WM_MOUSEWHEEL: {
00624 int delta = GET_WHEEL_DELTA_WPARAM(wParam);
00625
00626 if (delta < 0) {
00627 _cursor.wheel++;
00628 } else if (delta > 0) {
00629 _cursor.wheel--;
00630 }
00631 HandleMouseEvents();
00632 return 0;
00633 }
00634
00635 case WM_SETFOCUS:
00636 _wnd.has_focus = true;
00637 break;
00638
00639 case WM_KILLFOCUS:
00640 _wnd.has_focus = false;
00641 break;
00642
00643 #if !defined(WINCE)
00644 case WM_ACTIVATE: {
00645
00646 if (_exit_game) break;
00647
00648 bool active = (LOWORD(wParam) != WA_INACTIVE);
00649 bool minimized = (HIWORD(wParam) != 0);
00650 if (_wnd.fullscreen) {
00651 if (active && minimized) {
00652
00653 ShowWindow(hwnd, SW_RESTORE);
00654 static_cast<VideoDriver_Win32 *>(_video_driver)->MakeWindow(true);
00655 } else if (!active && !minimized) {
00656
00657 ShowWindow(hwnd, SW_MINIMIZE);
00658 ChangeDisplaySettings(NULL, 0);
00659 }
00660 }
00661 break;
00662 }
00663 #endif
00664 }
00665
00666 return DefWindowProc(hwnd, msg, wParam, lParam);
00667 }
00668
00669 static void RegisterWndClass()
00670 {
00671 static bool registered = false;
00672
00673 if (!registered) {
00674 HINSTANCE hinst = GetModuleHandle(NULL);
00675 WNDCLASS wnd = {
00676 0,
00677 WndProcGdi,
00678 0,
00679 0,
00680 hinst,
00681 LoadIcon(hinst, MAKEINTRESOURCE(100)),
00682 LoadCursor(NULL, IDC_ARROW),
00683 0,
00684 0,
00685 _T("OTTD")
00686 };
00687
00688 registered = true;
00689 if (!RegisterClass(&wnd)) usererror("RegisterClass failed");
00690 }
00691 }
00692
00693 static bool AllocateDibSection(int w, int h)
00694 {
00695 BITMAPINFO *bi;
00696 HDC dc;
00697 int bpp = BlitterFactoryBase::GetCurrentBlitter()->GetScreenDepth();
00698
00699 w = max(w, 64);
00700 h = max(h, 64);
00701
00702 if (bpp == 0) usererror("Can't use a blitter that blits 0 bpp for normal visuals");
00703
00704 if (w == _screen.width && h == _screen.height) return false;
00705
00706 _screen.width = w;
00707 _screen.pitch = (bpp == 8) ? Align(w, 4) : w;
00708 _screen.height = h;
00709 bi = (BITMAPINFO*)alloca(sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * 256);
00710 memset(bi, 0, sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * 256);
00711 bi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
00712
00713 bi->bmiHeader.biWidth = _wnd.width = w;
00714 bi->bmiHeader.biHeight = -(_wnd.height = h);
00715
00716 bi->bmiHeader.biPlanes = 1;
00717 bi->bmiHeader.biBitCount = BlitterFactoryBase::GetCurrentBlitter()->GetScreenDepth();
00718 bi->bmiHeader.biCompression = BI_RGB;
00719
00720 if (_wnd.dib_sect) DeleteObject(_wnd.dib_sect);
00721
00722 dc = GetDC(0);
00723 _wnd.dib_sect = CreateDIBSection(dc, bi, DIB_RGB_COLORS, (VOID**)&_wnd.buffer_bits, NULL, 0);
00724 if (_wnd.dib_sect == NULL) usererror("CreateDIBSection failed");
00725 ReleaseDC(0, dc);
00726
00727 return true;
00728 }
00729
00730 static const Dimension default_resolutions[] = {
00731 { 640, 480 },
00732 { 800, 600 },
00733 { 1024, 768 },
00734 { 1152, 864 },
00735 { 1280, 800 },
00736 { 1280, 960 },
00737 { 1280, 1024 },
00738 { 1400, 1050 },
00739 { 1600, 1200 },
00740 { 1680, 1050 },
00741 { 1920, 1200 }
00742 };
00743
00744 static void FindResolutions()
00745 {
00746 uint n = 0;
00747 #if defined(WINCE)
00748
00749
00750 #else
00751 uint i;
00752 DEVMODEA dm;
00753
00754
00755
00756
00757 for (i = 0; EnumDisplaySettingsA(NULL, i, &dm) != 0; i++) {
00758 if (dm.dmBitsPerPel == BlitterFactoryBase::GetCurrentBlitter()->GetScreenDepth() &&
00759 dm.dmPelsWidth >= 640 && dm.dmPelsHeight >= 480) {
00760 uint j;
00761
00762 for (j = 0; j < n; j++) {
00763 if (_resolutions[j].width == dm.dmPelsWidth && _resolutions[j].height == dm.dmPelsHeight) break;
00764 }
00765
00766
00767
00768
00769
00770 if (j == n) {
00771 _resolutions[j].width = dm.dmPelsWidth;
00772 _resolutions[j].height = dm.dmPelsHeight;
00773 if (++n == lengthof(_resolutions)) break;
00774 }
00775 }
00776 }
00777 #endif
00778
00779
00780 if (n == 0) {
00781 memcpy(_resolutions, default_resolutions, sizeof(default_resolutions));
00782 n = lengthof(default_resolutions);
00783 }
00784
00785 _num_resolutions = n;
00786 SortResolutions(_num_resolutions);
00787 }
00788
00789 static FVideoDriver_Win32 iFVideoDriver_Win32;
00790
00791 const char *VideoDriver_Win32::Start(const char * const *parm)
00792 {
00793 memset(&_wnd, 0, sizeof(_wnd));
00794
00795 RegisterWndClass();
00796
00797 MakePalette();
00798
00799 FindResolutions();
00800
00801 DEBUG(driver, 2, "Resolution for display: %ux%u", _cur_resolution.width, _cur_resolution.height);
00802
00803
00804 _wnd.width_org = _cur_resolution.width;
00805 _wnd.height_org = _cur_resolution.height;
00806
00807 AllocateDibSection(_cur_resolution.width, _cur_resolution.height);
00808 this->MakeWindow(_fullscreen);
00809
00810 MarkWholeScreenDirty();
00811
00812 return NULL;
00813 }
00814
00815 void VideoDriver_Win32::Stop()
00816 {
00817 DeleteObject(_wnd.gdi_palette);
00818 DeleteObject(_wnd.dib_sect);
00819 DestroyWindow(_wnd.main_wnd);
00820
00821 #if !defined(WINCE)
00822 if (_wnd.fullscreen) ChangeDisplaySettings(NULL, 0);
00823 #endif
00824 MyShowCursor(true);
00825 }
00826
00827 void VideoDriver_Win32::MakeDirty(int left, int top, int width, int height)
00828 {
00829 RECT r = { left, top, left + width, top + height };
00830
00831 InvalidateRect(_wnd.main_wnd, &r, FALSE);
00832 }
00833
00834 static void CheckPaletteAnim()
00835 {
00836 if (_pal_count_dirty == 0) return;
00837
00838 InvalidateRect(_wnd.main_wnd, NULL, FALSE);
00839 }
00840
00841 void VideoDriver_Win32::MainLoop()
00842 {
00843 MSG mesg;
00844 uint32 cur_ticks = GetTickCount();
00845 uint32 last_cur_ticks = cur_ticks;
00846 uint32 next_tick = cur_ticks + MILLISECONDS_PER_TICK;
00847
00848 _wnd.running = true;
00849
00850 for (;;) {
00851 uint32 prev_cur_ticks = cur_ticks;
00852
00853 while (PeekMessage(&mesg, NULL, 0, 0, PM_REMOVE)) {
00854 InteractiveRandom();
00855 TranslateMessage(&mesg);
00856 DispatchMessage(&mesg);
00857 }
00858 if (_exit_game) return;
00859
00860 #if defined(_DEBUG)
00861 if (_wnd.has_focus && GetAsyncKeyState(VK_SHIFT) < 0 &&
00862 #else
00863
00864 if (_wnd.has_focus && GetAsyncKeyState(VK_TAB) < 0 && GetAsyncKeyState(VK_MENU) >= 0 &&
00865 #endif
00866 !_networking && _game_mode != GM_MENU) {
00867 _fast_forward |= 2;
00868 } else if (_fast_forward & 2) {
00869 _fast_forward = 0;
00870 }
00871
00872 cur_ticks = GetTickCount();
00873 if (cur_ticks >= next_tick || (_fast_forward && !_pause_mode) || cur_ticks < prev_cur_ticks) {
00874 _realtime_tick += cur_ticks - last_cur_ticks;
00875 last_cur_ticks = cur_ticks;
00876 next_tick = cur_ticks + MILLISECONDS_PER_TICK;
00877
00878 bool old_ctrl_pressed = _ctrl_pressed;
00879
00880 _ctrl_pressed = _wnd.has_focus && GetAsyncKeyState(VK_CONTROL)<0;
00881 _shift_pressed = _wnd.has_focus && GetAsyncKeyState(VK_SHIFT)<0;
00882
00883
00884 if (_wnd.has_focus) {
00885 _dirkeys =
00886 (GetAsyncKeyState(VK_LEFT) < 0 ? 1 : 0) +
00887 (GetAsyncKeyState(VK_UP) < 0 ? 2 : 0) +
00888 (GetAsyncKeyState(VK_RIGHT) < 0 ? 4 : 0) +
00889 (GetAsyncKeyState(VK_DOWN) < 0 ? 8 : 0);
00890 } else {
00891 _dirkeys = 0;
00892 }
00893
00894 if (old_ctrl_pressed != _ctrl_pressed) HandleCtrlChanged();
00895
00896 GameLoop();
00897
00898 if (_force_full_redraw) MarkWholeScreenDirty();
00899
00900 #if !defined(WINCE)
00901 GdiFlush();
00902 #endif
00903 _screen.dst_ptr = _wnd.buffer_bits;
00904 UpdateWindows();
00905 CheckPaletteAnim();
00906 } else {
00907 Sleep(1);
00908 #if !defined(WINCE)
00909 GdiFlush();
00910 #endif
00911 _screen.dst_ptr = _wnd.buffer_bits;
00912 NetworkDrawChatMessage();
00913 DrawMouseCursor();
00914 }
00915 }
00916 }
00917
00918 bool VideoDriver_Win32::ChangeResolution(int w, int h)
00919 {
00920 _wnd.width = _wnd.width_org = w;
00921 _wnd.height = _wnd.height_org = h;
00922
00923 return this->MakeWindow(_fullscreen);
00924 }
00925
00926 bool VideoDriver_Win32::ToggleFullscreen(bool full_screen)
00927 {
00928 return this->MakeWindow(full_screen);
00929 }