1

/* $Id$ */

     2

     3

#include "../stdafx.h"

     4

#include "../openttd.h"

     5

#include "../functions.h"

     6

#include "../gfx.h"

     7

#include "../macros.h"

     8

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

     9

#include "../variables.h"

    10

#include "../win32.h"

    11

#include "../window.h"

    12

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

    13

#include "win32_v.h"

    14

#include <windows.h>

    15

#include <tchar.h>

    16

    17

static struct {

    18

	HWND main_wnd;

    19

	HBITMAP dib_sect;

    20

	void *buffer_bits;

    21

	HPALETTE gdi_palette;

    22

	int width;

    23

	int height;

    24

	int width_org;

    25

	int height_org;

    26

	bool minimized;

    27

	bool fullscreen;

    28

	bool has_focus;

    29

	bool running;

    30

} _wnd;

    31

    32

bool _force_full_redraw;

    33

bool _window_maximize;

    34

uint _display_hz;

    35

uint _fullscreen_bpp;

    36

static uint16 _bck_resolution[2];

    37

#if !defined(UNICODE)

    38

uint _codepage;

    39

#endif

    40

    41

static void MakePalette()

    42

{

    43

	LOGPALETTE *pal;

    44

	uint i;

    45

    46

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

    47

    48

	pal->palVersion = 0x300;

    49

	pal->palNumEntries = 256;

    50

    51

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

    52

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

    53

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

    54

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

    55

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

    56

    57

	}

    58

	_wnd.gdi_palette = CreatePalette(pal);

    59

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

    60

}

    61

    62

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

    63

{

    64

	RGBQUAD rgb[256];

    65

	uint i;

    66

    67

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

    68

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

    69

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

    70

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

    71

		rgb[i].rgbReserved = 0;

    72

	}

    73

    74

	SetDIBColorTable(dc, start, count, rgb);

    75

}

    76

    77

struct VkMapping {

    78

	byte vk_from;

    79

	byte vk_count;

    80

	byte map_to;

    81

};

    82

    83

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

    84

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

    85

    86

static const VkMapping _vk_mapping[] = {

    87

	// Pageup stuff + up/down

    88

	AM(VK_PRIOR,VK_DOWN, WKC_PAGEUP, WKC_DOWN),

    89

	// Map letters & digits

    90

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

    91

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

    92

    93

	AS(VK_ESCAPE,   WKC_ESC),

    94

	AS(VK_PAUSE,    WKC_PAUSE),

    95

	AS(VK_BACK,     WKC_BACKSPACE),

    96

	AM(VK_INSERT,   VK_DELETE, WKC_INSERT, WKC_DELETE),

    97

    98

	AS(VK_SPACE,    WKC_SPACE),

    99

	AS(VK_RETURN,   WKC_RETURN),

   100

	AS(VK_TAB,      WKC_TAB),

   101

   102

	// Function keys

   103

	AM(VK_F1, VK_F12, WKC_F1, WKC_F12),

   104

   105

	// Numeric part.

   106

	// What is the virtual keycode for numeric enter??

   107

	AM(VK_NUMPAD0, VK_NUMPAD9, WKC_NUM_0, WKC_NUM_9),

   108

	AS(VK_DIVIDE,   WKC_NUM_DIV),

   109

	AS(VK_MULTIPLY, WKC_NUM_MUL),

   110

	AS(VK_SUBTRACT, WKC_NUM_MINUS),

   111

	AS(VK_ADD,      WKC_NUM_PLUS),

   112

	AS(VK_DECIMAL,  WKC_NUM_DECIMAL)

   113

};

   114

   115

static uint MapWindowsKey(uint sym)

   116

{

   117

	const VkMapping *map;

   118

	uint key = 0;

   119

   120

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

   121

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

   122

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

   123

			break;

   124

		}

   125

	}

   126

   127

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

   128

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

   129

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

   130

	return key;

   131

}

   132

   133

static bool AllocateDibSection(int w, int h);

   134

   135

static void ClientSizeChanged(int w, int h)

   136

{

   137

	// allocate new dib section of the new size

   138

	if (AllocateDibSection(w, h)) {

   139

		// mark all palette colors dirty

   140

		_pal_first_dirty = 0;

   141

		_pal_count_dirty = 255;

   142

		GameSizeChanged();

   143

   144

		// redraw screen

   145

		if (_wnd.running) {

   146

			_screen.dst_ptr = _wnd.buffer_bits;

   147

			UpdateWindows();

   148

		}

   149

	}

   150

}

   151

   152

#ifdef _DEBUG

   153

// Keep this function here..

   154

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

   155

int RedrawScreenDebug()

   156

{

   157

	HDC dc,dc2;

   158

	static int _fooctr;

   159

	HBITMAP old_bmp;

   160

	HPALETTE old_palette;

   161

   162

	_screen.dst_ptr = _wnd.buffer_bits;

   163

	UpdateWindows();

   164

   165

	dc = GetDC(_wnd.main_wnd);

   166

	dc2 = CreateCompatibleDC(dc);

   167

   168

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

   169

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

   170

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

   171

	SelectPalette(dc, old_palette, TRUE);

   172

	SelectObject(dc2, old_bmp);

   173

	DeleteDC(dc2);

   174

	ReleaseDC(_wnd.main_wnd, dc);

   175

   176

	return _fooctr++;

   177

}

   178

#endif

   179

   180

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

   181

#if !defined(WM_MOUSELEAVE)

   182

#define WM_MOUSELEAVE 0x02A3

   183

#endif

   184

#define TID_POLLMOUSE 1

   185

#define MOUSE_POLL_DELAY 75

   186

   187

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

   188

{

   189

	RECT rc;

   190

	POINT pt;

   191

   192

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

   193

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

   194

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

   195

	GetClientRect(hwnd, &rc);

   196

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

   197

	GetCursorPos(&pt);

   198

   199

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

   200

		KillTimer(hwnd, event);

   201

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

   202

	}

   203

}

   204

   205

static void MakeWindow(bool full_screen)

   206

{

   207

	_fullscreen = full_screen;

   208

   209

	// recreate window?

   210

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

   211

		DestroyWindow(_wnd.main_wnd);

   212

		_wnd.main_wnd = 0;

   213

	}

   214

   215

#if defined(WINCE)

   216

	/* WinCE is always fullscreen */

   217

#else

   218

	if (full_screen) {

   219

		DEVMODE settings;

   220

   221

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

   222

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

   223

   224

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

   225

		settings.dmSize = sizeof(settings);

   226

		settings.dmFields =

   227

			(_fullscreen_bpp != 0 ? DM_BITSPERPEL : 0) |

   228

			DM_PELSWIDTH |

   229

			DM_PELSHEIGHT |

   230

			(_display_hz != 0 ? DM_DISPLAYFREQUENCY : 0);

   231

		settings.dmBitsPerPel = _fullscreen_bpp;

   232

		settings.dmPelsWidth  = _wnd.width_org;

   233

		settings.dmPelsHeight = _wnd.height_org;

   234

		settings.dmDisplayFrequency = _display_hz;

   235

   236

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

   237

			MakeWindow(false);

   238

			return;

   239

		}

   240

	} else if (_wnd.fullscreen) {

   241

		// restore display?

   242

		ChangeDisplaySettings(NULL, 0);

   243

	}

   244

#endif

   245

   246

	{

   247

		RECT r;

   248

		DWORD style, showstyle;

   249

		int x, y, w, h;

   250

   251

		showstyle = SW_SHOWNORMAL;

   252

		_wnd.fullscreen = full_screen;

   253

		if (_wnd.fullscreen) {

   254

			style = WS_POPUP;

   255

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

   256

		} else {

   257

			style = WS_OVERLAPPEDWINDOW;

   258

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

   259

			if (_window_maximize) showstyle = SW_SHOWMAXIMIZED;

   260

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

   261

		}

   262

   263

#if !defined(WINCE)

   264

		AdjustWindowRect(&r, style, FALSE);

   265

#endif

   266

		w = r.right - r.left;

   267

		h = r.bottom - r.top;

   268

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

   269

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

   270

   271

		if (_wnd.main_wnd) {

   272

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

   273

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

   274

		} else {

   275

			extern const char _openttd_revision[];

   276

			TCHAR Windowtitle[50];

   277

   278

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

   279

   280

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

   281

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

   282

			ShowWindow(_wnd.main_wnd, showstyle);

   283

		}

   284

	}

   285

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

   286

}

   287

   288

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

   289

{

   290

	static uint32 keycode = 0;

   291

	static bool console = false;

   292

   293

	switch (msg) {

   294

		case WM_CREATE:

   295

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

   296

			break;

   297

   298

		case WM_PAINT: {

   299

			PAINTSTRUCT ps;

   300

			HDC dc,dc2;

   301

			HBITMAP old_bmp;

   302

			HPALETTE old_palette;

   303

   304

			BeginPaint(hwnd, &ps);

   305

			dc = ps.hdc;

   306

			dc2 = CreateCompatibleDC(dc);

   307

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

   308

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

   309

   310

			if (_pal_count_dirty != 0) {

   311

				Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();

   312

   313

				switch (blitter->UsePaletteAnimation()) {

   314

					case Blitter::PALETTE_ANIMATION_VIDEO_BACKEND:

   315

						UpdatePalette(dc2, _pal_first_dirty, _pal_count_dirty);

   316

						break;

   317

   318

					case Blitter::PALETTE_ANIMATION_BLITTER:

   319

						blitter->PaletteAnimate(_pal_first_dirty, _pal_count_dirty);

   320

						break;

   321

   322

					case Blitter::PALETTE_ANIMATION_NONE:

   323

						break;

   324

   325

					default:

   326

						NOT_REACHED();

   327

				}

   328

				_pal_count_dirty = 0;

   329

			}

   330

   331

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

   332

			SelectPalette(dc, old_palette, TRUE);

   333

			SelectObject(dc2, old_bmp);

   334

			DeleteDC(dc2);

   335

			EndPaint(hwnd, &ps);

   336

			return 0;

   337

		}

   338

   339

		case WM_PALETTECHANGED:

   340

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

   341

			/* FALLTHROUGH */

   342

   343

		case WM_QUERYNEWPALETTE: {

   344

			HDC hDC = GetWindowDC(hwnd);

   345

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

   346

			UINT nChanged = RealizePalette(hDC);

   347

   348

			SelectPalette(hDC, hOldPalette, TRUE);

   349

			ReleaseDC(hwnd, hDC);

   350

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

   351

			return 0;

   352

		}

   353

   354

		case WM_CLOSE:

   355

			HandleExitGameRequest();

   356

			return 0;

   357

   358

		case WM_DESTROY:

   359

			if (_window_maximize) {

   360

				_cur_resolution[0] = _bck_resolution[0];

   361

				_cur_resolution[1] = _bck_resolution[1];

   362

			}

   363

			return 0;

   364

   365

		case WM_LBUTTONDOWN:

   366

			SetCapture(hwnd);

   367

			_left_button_down = true;

   368

			HandleMouseEvents();

   369

			return 0;

   370

   371

		case WM_LBUTTONUP:

   372

			ReleaseCapture();

   373

			_left_button_down = false;

   374

			_left_button_clicked = false;

   375

			HandleMouseEvents();

   376

			return 0;

   377

   378

		case WM_RBUTTONDOWN:

   379

			SetCapture(hwnd);

   380

			_right_button_down = true;

   381

			_right_button_clicked = true;

   382

			HandleMouseEvents();

   383

			return 0;

   384

   385

		case WM_RBUTTONUP:

   386

			ReleaseCapture();

   387

			_right_button_down = false;

   388

			HandleMouseEvents();

   389

			return 0;

   390

   391

		case WM_MOUSELEAVE:

   392

			UndrawMouseCursor();

   393

			_cursor.in_window = false;

   394

   395

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

   396

			HandleMouseEvents();

   397

			return 0;

   398

   399

		case WM_MOUSEMOVE: {

   400

			int x = (int16)LOWORD(lParam);

   401

			int y = (int16)HIWORD(lParam);

   402

			POINT pt;

   403

   404

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

   405

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

   406

			 * tracking the mouse for exiting the window */

   407

			if (!_cursor.in_window) {

   408

				_cursor.in_window = true;

   409

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

   410

   411

				DrawMouseCursor();

   412

			}

   413

   414

			if (_cursor.fix_at) {

   415

				int dx = x - _cursor.pos.x;

   416

				int dy = y - _cursor.pos.y;

   417

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

   418

					_cursor.delta.x += dx;

   419

					_cursor.delta.y += dy;

   420

   421

					pt.x = _cursor.pos.x;

   422

					pt.y = _cursor.pos.y;

   423

   424

					ClientToScreen(hwnd, &pt);

   425

					SetCursorPos(pt.x, pt.y);

   426

				}

   427

			} else {

   428

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

   429

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

   430

				_cursor.pos.x = x;

   431

				_cursor.pos.y = y;

   432

				_cursor.dirty = true;

   433

			}

   434

			MyShowCursor(false);

   435

			HandleMouseEvents();

   436

			return 0;

   437

		}

   438

   439

#if !defined(UNICODE)

   440

		case WM_INPUTLANGCHANGE: {

   441

			TCHAR locale[6];

   442

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

   443

   444

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

   445

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

   446

			return 1;

   447

		}

   448

#endif /* UNICODE */

   449

   450

		case WM_DEADCHAR:

   451

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

   452

			return 0;

   453

   454

		case WM_CHAR: {

   455

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

   456

			if (wParam < VK_SPACE) return 0;

   457

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

   458

			uint charcode = wParam;

   459

   460

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

   461

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

   462

			if (console && scancode == 41) {

   463

				console = false;

   464

				return 0;

   465

			}

   466

   467

#if !defined(UNICODE)

   468

			wchar_t w;

   469

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

   470

			charcode = len == 1 ? w : 0;

   471

#endif /* UNICODE */

   472

   473

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

   474

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

   475

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

   476

			return 0;

   477

		}

   478

   479

		case WM_KEYDOWN: {

   480

			keycode = MapWindowsKey(wParam);

   481

   482

			/* Silently drop all text messages as those will be handled by WM_CHAR

   483

			 * WM_KEYDOWN only handles CTRL+ commands and special keys like VK_LEFT, etc. */

   484

			if (keycode == 0 || (keycode > WKC_PAUSE && GB(keycode, 13, 4) == 0)) return 0;

   485

   486

			HandleKeypress(0 | (keycode << 16));

   487

			return 0;

   488

		}

   489

   490

		case WM_SYSKEYDOWN: /* user presses F10 or Alt, both activating the title-menu */

   491

			switch (wParam) {

   492

				case VK_RETURN:

   493

				case 'F': /* Full Screen on ALT + ENTER/F */