1

/* $Id$ */

     2

     3

/** @file win32_v.cpp Implementation of the Windows (GDI) video driver. */

     4

     5

#include "../stdafx.h"

     6

#include "../openttd.h"

     7

#include "../gfx_func.h"

     8

#include "../variables.h"

     9

#include "../win32.h"

    10

#include "../rev.h"

    11

#include "../blitter/factory.hpp"

    12

#include "../network/network.h"

    13

#include "../core/math_func.hpp"

    14

#include "../core/random_func.hpp"

    15

#include "../functions.h"

    16

#include "../texteff.hpp"

    17

#include "win32_v.h"

    18

#include <windows.h>

    19

#include <tchar.h>

    20

    21

static struct {

    22

	HWND main_wnd;

    23

	HBITMAP dib_sect;

    24

	void *buffer_bits;

    25

	HPALETTE gdi_palette;

    26

	int width;

    27

	int height;

    28

	int width_org;

    29

	int height_org;

    30

	bool fullscreen;

    31

	bool has_focus;

    32

	bool running;

    33

} _wnd;

    34

    35

bool _force_full_redraw;

    36

bool _window_maximize;

    37

uint _display_hz;

    38

uint _fullscreen_bpp;

    40

#if !defined(UNICODE)

    41

uint _codepage;

    42

#endif

    43

    44

static void MakePalette()

    45

{

    46

	LOGPALETTE *pal;

    47

	uint i;

    48

    49

	pal = (LOGPALETTE*)alloca(sizeof(LOGPALETTE) + (256 - 1) * sizeof(PALETTEENTRY));

    50

    51

	pal->palVersion = 0x300;

    52

	pal->palNumEntries = 256;

    53

    54

	for (i = 0; i != 256; i++) {

    55

		pal->palPalEntry[i].peRed   = _cur_palette[i].r;

    56

		pal->palPalEntry[i].peGreen = _cur_palette[i].g;

    57

		pal->palPalEntry[i].peBlue  = _cur_palette[i].b;

    58

		pal->palPalEntry[i].peFlags = 0;

    59

    60

	}

    61

	_wnd.gdi_palette = CreatePalette(pal);

    62

	if (_wnd.gdi_palette == NULL) usererror("CreatePalette failed!\n");

    63

}

    64

    65

static void UpdatePalette(HDC dc, uint start, uint count)

    66

{

    67

	RGBQUAD rgb[256];

    68

	uint i;

    69

    70

	for (i = 0; i != count; i++) {

    71

		rgb[i].rgbRed   = _cur_palette[start + i].r;

    72

		rgb[i].rgbGreen = _cur_palette[start + i].g;

    73

		rgb[i].rgbBlue  = _cur_palette[start + i].b;

    74

		rgb[i].rgbReserved = 0;

    75

	}

    76

    77

	SetDIBColorTable(dc, start, count, rgb);

    78

}

    79

    80

struct VkMapping {

    81

	byte vk_from;

    82

	byte vk_count;

    83

	byte map_to;

    84

};

    85

    86

#define AS(x, z) {x, 0, z}

    87

#define AM(x, y, z, w) {x, y - x, z}

    88

    89

static const VkMapping _vk_mapping[] = {

    90

	/* Pageup stuff + up/down */

    91

	AM(VK_PRIOR,VK_DOWN, WKC_PAGEUP, WKC_DOWN),

    92

	/* Map letters & digits */

    93

	AM('A','Z','A','Z'),

    94

	AM('0','9','0','9'),

    95

    96

	AS(VK_ESCAPE,   WKC_ESC),

    97

	AS(VK_PAUSE,    WKC_PAUSE),

    98

	AS(VK_BACK,     WKC_BACKSPACE),

    99

	AM(VK_INSERT,   VK_DELETE, WKC_INSERT, WKC_DELETE),

   100

   101

	AS(VK_SPACE,    WKC_SPACE),

   102

	AS(VK_RETURN,   WKC_RETURN),

   103

	AS(VK_TAB,      WKC_TAB),

   104

   105

	/* Function keys */

   106

	AM(VK_F1, VK_F12, WKC_F1, WKC_F12),

   107

   108

	/* Numeric part */

   109

	AM(VK_NUMPAD0, VK_NUMPAD9, WKC_NUM_0, WKC_NUM_9),

   110

	AS(VK_DIVIDE,   WKC_NUM_DIV),

   111

	AS(VK_MULTIPLY, WKC_NUM_MUL),

   112

	AS(VK_SUBTRACT, WKC_NUM_MINUS),

   113

	AS(VK_ADD,      WKC_NUM_PLUS),

   114

	AS(VK_DECIMAL,  WKC_NUM_DECIMAL),

   115

   116

	/* Other non-letter keys */

   117

	AS(0xBF,  WKC_SLASH),

   118

	AS(0xBA,  WKC_SEMICOLON),

   119

	AS(0xBB,  WKC_EQUALS),

   120

	AS(0xDB,  WKC_L_BRACKET),

   121

	AS(0xDC,  WKC_BACKSLASH),

   122

	AS(0xDD,  WKC_R_BRACKET),

   123

   124

	AS(0xDE,  WKC_SINGLEQUOTE),

   125

	AS(0xBC,  WKC_COMMA),

   126

	AS(0xBD,  WKC_MINUS),

   127

	AS(0xBE,  WKC_PERIOD)

   128

};

   129

   130

static uint MapWindowsKey(uint sym)

   131

{

   132

	const VkMapping *map;

   133

	uint key = 0;

   134

   135

	for (map = _vk_mapping; map != endof(_vk_mapping); ++map) {

   136

		if ((uint)(sym - map->vk_from) <= map->vk_count) {

   137

			key = sym - map->vk_from + map->map_to;

   138

			break;

   139

		}

   140

	}

   141

   142

	if (GetAsyncKeyState(VK_SHIFT)   < 0) key |= WKC_SHIFT;

   143

	if (GetAsyncKeyState(VK_CONTROL) < 0) key |= WKC_CTRL;

   144

	if (GetAsyncKeyState(VK_MENU)    < 0) key |= WKC_ALT;

   145

	return key;

   146

}

   147

   148

static bool AllocateDibSection(int w, int h);

   149

   150

static void ClientSizeChanged(int w, int h)

   151

{

   152

	// allocate new dib section of the new size

   153

	if (AllocateDibSection(w, h)) {

   154

		// mark all palette colors dirty

   155

		_pal_first_dirty = 0;

   156

		_pal_count_dirty = 256;

   157

		GameSizeChanged();

   158

   159

		// redraw screen

   160

		if (_wnd.running) {

   161

			_screen.dst_ptr = _wnd.buffer_bits;

   162

			UpdateWindows();

   163

		}

   164

	}

   165

}

   166

   167

#ifdef _DEBUG

   168

// Keep this function here..

   169

// It allows you to redraw the screen from within the MSVC debugger

   170

int RedrawScreenDebug()

   171

{

   172

	HDC dc,dc2;

   173

	static int _fooctr;

   174

	HBITMAP old_bmp;

   175

	HPALETTE old_palette;

   176

   177

	_screen.dst_ptr = _wnd.buffer_bits;

   178

	UpdateWindows();

   179

   180

	dc = GetDC(_wnd.main_wnd);

   181

	dc2 = CreateCompatibleDC(dc);

   182

   183

	old_bmp = (HBITMAP)SelectObject(dc2, _wnd.dib_sect);

   184

	old_palette = SelectPalette(dc, _wnd.gdi_palette, FALSE);

   185

	BitBlt(dc, 0, 0, _wnd.width, _wnd.height, dc2, 0, 0, SRCCOPY);

   186

	SelectPalette(dc, old_palette, TRUE);

   187

	SelectObject(dc2, old_bmp);

   188

	DeleteDC(dc2);

   189

	ReleaseDC(_wnd.main_wnd, dc);

   190

   191

	return _fooctr++;

   192

}

   193

#endif

   194

   195

/* Windows 95 will not have a WM_MOUSELEAVE message, so define it if needed */

   196

#if !defined(WM_MOUSELEAVE)

   197

#define WM_MOUSELEAVE 0x02A3

   198

#endif

   199

#define TID_POLLMOUSE 1

   200

#define MOUSE_POLL_DELAY 75

   201

   202

static void CALLBACK TrackMouseTimerProc(HWND hwnd, UINT msg, UINT event, DWORD time)

   203

{

   204

	RECT rc;

   205

	POINT pt;

   206

   207

	/* Get the rectangle of our window and translate it to screen coordinates.

   208

	 * Compare this with the current screen coordinates of the mouse and if it

   209

	 * falls outside of the area or our window we have left the window. */

   210

	GetClientRect(hwnd, &rc);

   211

	MapWindowPoints(hwnd, HWND_DESKTOP, (LPPOINT)(LPRECT)&rc, 2);

   212

	GetCursorPos(&pt);

   213

   214

	if (!PtInRect(&rc, pt) || (WindowFromPoint(pt) != hwnd)) {

   215

		KillTimer(hwnd, event);

   216

		PostMessage(hwnd, WM_MOUSELEAVE, 0, 0L);

   217

	}

   218

}

   219

   220

static bool MakeWindow(bool full_screen)

   221

{

   222

	_fullscreen = full_screen;

   223

   224

	// recreate window?

   225

	if ((full_screen || _wnd.fullscreen) && _wnd.main_wnd) {

   226

		DestroyWindow(_wnd.main_wnd);

   227

		_wnd.main_wnd = 0;

   228

	}

   229

   230

#if defined(WINCE)

   231

	/* WinCE is always fullscreen */

   232

#else

   233

	if (full_screen) {

   234

		DEVMODE settings;

   235

   236

		/* Make sure we are always at least the screen-depth of the blitter */

   237

		if (_fullscreen_bpp < BlitterFactoryBase::GetCurrentBlitter()->GetScreenDepth()) _fullscreen_bpp = BlitterFactoryBase::GetCurrentBlitter()->GetScreenDepth();

   238

   239

		memset(&settings, 0, sizeof(settings));

   240

		settings.dmSize = sizeof(settings);

   241

		settings.dmFields =

   242

			(_fullscreen_bpp != 0 ? DM_BITSPERPEL : 0) |

   243

			DM_PELSWIDTH |

   244

			DM_PELSHEIGHT |

   245

			(_display_hz != 0 ? DM_DISPLAYFREQUENCY : 0);

   246

		settings.dmBitsPerPel = _fullscreen_bpp;

   247

		settings.dmPelsWidth  = _wnd.width_org;

   248

		settings.dmPelsHeight = _wnd.height_org;

   249

		settings.dmDisplayFrequency = _display_hz;

   250

   251

		if (ChangeDisplaySettings(&settings, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL) {

   252

			MakeWindow(false);  // don't care about the result

   253

			return false;  // the request failed

   254

		}

   255

	} else if (_wnd.fullscreen) {

   256

		// restore display?

   257

		ChangeDisplaySettings(NULL, 0);

   258

	}

   259

#endif

   260

   261

	{

   262

		RECT r;

   263

		DWORD style, showstyle;

   264

		int x, y, w, h;

   265

   266

		showstyle = SW_SHOWNORMAL;

   267

		_wnd.fullscreen = full_screen;

   268

		if (_wnd.fullscreen) {

   269

			style = WS_POPUP;

   270

			SetRect(&r, 0, 0, _wnd.width_org, _wnd.height_org);

   271

		} else {

   272

			style = WS_OVERLAPPEDWINDOW;

   273

			/* On window creation, check if we were in maximize mode before */

   274

			if (_window_maximize) showstyle = SW_SHOWMAXIMIZED;

   275

			SetRect(&r, 0, 0, _wnd.width, _wnd.height);

   276

		}

   277

   278

#if !defined(WINCE)

   279

		AdjustWindowRect(&r, style, FALSE);

   280

#endif

   281

		w = r.right - r.left;

   282

		h = r.bottom - r.top;

   283

		x = (GetSystemMetrics(SM_CXSCREEN) - w) / 2;

   284

		y = (GetSystemMetrics(SM_CYSCREEN) - h) / 2;

   285

   286

		if (_wnd.main_wnd) {

   287

			ShowWindow(_wnd.main_wnd, SW_SHOWNORMAL); // remove maximize-flag

   288

			SetWindowPos(_wnd.main_wnd, 0, x, y, w, h, SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOZORDER);

   289

		} else {

   290

			TCHAR Windowtitle[50];

   291

   292

			_sntprintf(Windowtitle, sizeof(Windowtitle), _T("OpenTTD %s"), MB_TO_WIDE(_openttd_revision));

   293

   294

			_wnd.main_wnd = CreateWindow(_T("OTTD"), Windowtitle, style, x, y, w, h, 0, 0, GetModuleHandle(NULL), 0);

   295

			if (_wnd.main_wnd == NULL) usererror("CreateWindow failed");

   296

			ShowWindow(_wnd.main_wnd, showstyle);

   297

		}

   298

	}

   299

	GameSizeChanged(); // invalidate all windows, force redraw

   300

	return true; // the request succedded

   301

}

   302

   303

static LRESULT CALLBACK WndProcGdi(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)

   304

{

   305

	static uint32 keycode = 0;

   306

	static bool console = false;

   307

   308

	switch (msg) {

   309

		case WM_CREATE:

   310

			SetTimer(hwnd, TID_POLLMOUSE, MOUSE_POLL_DELAY, (TIMERPROC)TrackMouseTimerProc);

   311

			break;

   312

   313

		case WM_PAINT: {

   314

			PAINTSTRUCT ps;

   315

			HDC dc, dc2;

   316

			HBITMAP old_bmp;

   317

			HPALETTE old_palette;

   318

   319

			BeginPaint(hwnd, &ps);

   320

			dc = ps.hdc;

   321

			dc2 = CreateCompatibleDC(dc);

   322

			old_bmp = (HBITMAP)SelectObject(dc2, _wnd.dib_sect);

   323

			old_palette = SelectPalette(dc, _wnd.gdi_palette, FALSE);

   324

   325

			if (_pal_count_dirty != 0) {

   326

				Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();

   327

   328

				switch (blitter->UsePaletteAnimation()) {

   329

					case Blitter::PALETTE_ANIMATION_VIDEO_BACKEND:

   330

						UpdatePalette(dc2, _pal_first_dirty, _pal_count_dirty);

   331

						break;

   332

   333

					case Blitter::PALETTE_ANIMATION_BLITTER:

   334

						blitter->PaletteAnimate(_pal_first_dirty, _pal_count_dirty);

   335

						break;

   336

   337

					case Blitter::PALETTE_ANIMATION_NONE:

   338

						break;

   339

   340

					default:

   341

						NOT_REACHED();

   342

				}

   343

				_pal_count_dirty = 0;

   344

			}

   345

   346

			BitBlt(dc, 0, 0, _wnd.width, _wnd.height, dc2, 0, 0, SRCCOPY);

   347

			SelectPalette(dc, old_palette, TRUE);

   348

			SelectObject(dc2, old_bmp);

   349

			DeleteDC(dc2);

   350

			EndPaint(hwnd, &ps);

   351

			return 0;

   352

		}

   353

   354

		case WM_PALETTECHANGED:

   355

			if ((HWND)wParam == hwnd) return 0;

   356

			/* FALLTHROUGH */

   357

   358

		case WM_QUERYNEWPALETTE: {

   359

			HDC hDC = GetWindowDC(hwnd);

   360

			HPALETTE hOldPalette = SelectPalette(hDC, _wnd.gdi_palette, FALSE);

   361

			UINT nChanged = RealizePalette(hDC);

   362

   363

			SelectPalette(hDC, hOldPalette, TRUE);

   364

			ReleaseDC(hwnd, hDC);

   365

			if (nChanged) InvalidateRect(hwnd, NULL, FALSE);

   366

			return 0;

   367

		}

   368

   369

		case WM_CLOSE:

   370

			HandleExitGameRequest();

   371

			return 0;

   372

   373

		case WM_DESTROY:

   375

			return 0;

   376

   377

		case WM_LBUTTONDOWN:

   378

			SetCapture(hwnd);

   379

			_left_button_down = true;

   380

			HandleMouseEvents();

   381

			return 0;

   382

   383

		case WM_LBUTTONUP:

   384

			ReleaseCapture();

   385

			_left_button_down = false;

   386

			_left_button_clicked = false;

   387

			HandleMouseEvents();

   388

			return 0;

   389

   390

		case WM_RBUTTONDOWN:

   391

			SetCapture(hwnd);

   392

			_right_button_down = true;

   393

			_right_button_clicked = true;

   394

			HandleMouseEvents();

   395

			return 0;

   396

   397

		case WM_RBUTTONUP:

   398

			ReleaseCapture();

   399

			_right_button_down = false;

   400

			HandleMouseEvents();

   401

			return 0;

   402

   403

		case WM_MOUSELEAVE:

   404

			UndrawMouseCursor();

   405

			_cursor.in_window = false;

   406

   407

			if (!_left_button_down && !_right_button_down) MyShowCursor(true);

   408

			HandleMouseEvents();

   409

			return 0;

   410

   411

		case WM_MOUSEMOVE: {

   412

			int x = (int16)LOWORD(lParam);

   413

			int y = (int16)HIWORD(lParam);

   414

			POINT pt;

   415

   416

			/* If the mouse was not in the window and it has moved it means it has

   417

			 * come into the window, so start drawing the mouse. Also start

   418

			 * tracking the mouse for exiting the window */

   419

			if (!_cursor.in_window) {

   420

				_cursor.in_window = true;

   421

				SetTimer(hwnd, TID_POLLMOUSE, MOUSE_POLL_DELAY, (TIMERPROC)TrackMouseTimerProc);

   422

   423

				DrawMouseCursor();

   424

			}

   425

   426

			if (_cursor.fix_at) {

   427

				int dx = x - _cursor.pos.x;

   428

				int dy = y - _cursor.pos.y;

   429

				if (dx != 0 || dy != 0) {

   430

					_cursor.delta.x += dx;

   431

					_cursor.delta.y += dy;

   432

   433

					pt.x = _cursor.pos.x;

   434

					pt.y = _cursor.pos.y;

   435

   436

					ClientToScreen(hwnd, &pt);

   437

					SetCursorPos(pt.x, pt.y);

   438

				}

   439

			} else {

   440

				_cursor.delta.x += x - _cursor.pos.x;

   441

				_cursor.delta.y += y - _cursor.pos.y;

   442

				_cursor.pos.x = x;

   443

				_cursor.pos.y = y;

   444

				_cursor.dirty = true;

   445

			}

   446

			MyShowCursor(false);

   447

			HandleMouseEvents();

   448

			return 0;

   449

		}

   450

   451

#if !defined(UNICODE)

   452

		case WM_INPUTLANGCHANGE: {

   453

			TCHAR locale[6];

   454

			LCID lcid = GB(lParam, 0, 16);

   455

   456

			int len = GetLocaleInfo(lcid, LOCALE_IDEFAULTANSICODEPAGE, locale, lengthof(locale));

   457

			if (len != 0) _codepage = _ttoi(locale);

   458

			return 1;

   459

		}

   460

#endif /* UNICODE */

   461

   462

		case WM_DEADCHAR:

   463

			console = GB(lParam, 16, 8) == 41;

   464

			return 0;

   465

   466

		case WM_CHAR: {

   467

			/* Silently drop all non-text messages as those were handled by WM_KEYDOWN */

   468

			if (wParam < VK_SPACE) return 0;

   469

			uint scancode = GB(lParam, 16, 8);

   470

			uint charcode = wParam;

   471

   472

			/* If the console key is a dead-key, we need to press it twice to get a WM_CHAR message.

   473

			 * But we then get two WM_CHAR messages, so ignore the first one */

   474

			if (console && scancode == 41) {

   475

				console = false;

   476

				return 0;

   477

			}

   478

   479

#if !defined(UNICODE)

   480

			wchar_t w;

   481

			int len = MultiByteToWideChar(_codepage, 0, (char*)&charcode, 1, &w, 1);

   482

			charcode = len == 1 ? w : 0;

   483

#endif /* UNICODE */

   484

   485

			/* No matter the keyboard layout, we will map the '~' to the console */

   486

			scancode = scancode == 41 ? (int)WKC_BACKQUOTE : keycode;

   487

			HandleKeypress(GB(charcode, 0, 16) | (scancode << 16));

   488

			return 0;

   489

		}

   490

   491

		case WM_KEYDOWN: {

   492

			keycode = MapWindowsKey(wParam);