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