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