1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "debug.h"

     4

#include "string.h"

     5

#include "table/strings.h"

     6

#include "gfx.h"

     7

#include "mixer.h"

     8

#include "window.h"

     9

#include "gui.h"

    10

#include <windows.h>

    11

#include <mmsystem.h>

    12

#include "hal.h"

    13

#include <winnt.h>

    14

#include <wininet.h>

    15

#include <io.h>

    16

#include <fcntl.h>

    17

#include "network.h"

    18

    19

#define SMART_PALETTE_ANIM

    20

    21

static struct {

    22

	HWND main_wnd;

    23

	HBITMAP dib_sect;

    24

	void *bitmap_bits;

    25

	void *buffer_bits;

    26

	void *alloced_bits;

    27

	HPALETTE gdi_palette;

    28

	int width,height;

    29

	int width_org, height_org;

    30

	bool cursor_visible;

    31

	bool switch_driver;

    32

	bool fullscreen;

    33

	bool double_size;

    34

	bool has_focus;

    35

	bool running;

    36

} _wnd;

    37

    38

static HINSTANCE _inst;

    39

static bool _has_console;

    40

    41

#if defined(__MINGW32__) || defined(__CYGWIN__)

    42

	#define __TIMESTAMP__   __DATE__ __TIME__

    43

#endif

    44

    45

#ifdef WIN32_ENABLE_DIRECTMUSIC_SUPPORT

    46

extern const HalMusicDriver _dmusic_midi_driver;

    47

#endif

    48

    49

static void MakePalette(void)

    50

{

    51

	LOGPALETTE *pal;

    52

	uint i;

    53

	byte *b;

    54

    55

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

    56

    57

	pal->palVersion = 0x300;

    58

	pal->palNumEntries = 256;

    59

    60

	for (i = 0, b = _cur_palette; i != 256; i++, b += 3) {

    61

		pal->palPalEntry[i].peRed = b[0];

    62

		pal->palPalEntry[i].peGreen = b[1];

    63

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

    64

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

    65

    66

	}

    67

	_wnd.gdi_palette = CreatePalette(pal);

    68

	if (_wnd.gdi_palette == NULL)

    69

		error("CreatePalette failed!\n");

    70

}

    71

    72

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

    73

{

    74

	RGBQUAD rgb[256];

    75

	uint i;

    76

	byte *b;

    77

    78

		for (i = 0, b = _cur_palette + start * 3; i != count; i++, b += 3) {

    79

		rgb[i].rgbRed = b[0];

    80

		rgb[i].rgbGreen = b[1];

    81

		rgb[i].rgbBlue = b[2];

    82

		rgb[i].rgbReserved = 0;

    83

	}

    84

    85

	SetDIBColorTable(dc, start, count, rgb);

    86

}

    87

    88

static bool MyShowCursor(bool show)

    89

{

    90

	if (_wnd.cursor_visible == show)

    91

		return show;

    92

    93

	_wnd.cursor_visible = show;

    94

	ShowCursor(show);

    95

    96

	return !show;

    97

}

    98

    99

typedef struct {

   100

	byte vk_from;

   101

	byte vk_count;

   102

	byte map_to;

   103

} VkMapping;

   104

   105

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

   106

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

   107

   108

#ifndef	VK_OEM_3

   109

#define VK_OEM_3 0xC0

   110

#endif

   111

   112

static const VkMapping _vk_mapping[] = {

   113

	// Pageup stuff + up/down

   114

	AM(VK_PRIOR,VK_DOWN, WKC_PAGEUP, WKC_DOWN),

   115

	// Map letters & digits

   116

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

   117

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

   118

   119

	AS(VK_ESCAPE,		WKC_ESC),

   120

	AS(VK_PAUSE, WKC_PAUSE),

   121

	AS(VK_BACK,			WKC_BACKSPACE),

   122

	AM(VK_INSERT,VK_DELETE,WKC_INSERT, WKC_DELETE),

   123

   124

	AS(VK_SPACE,		WKC_SPACE),

   125

	AS(VK_RETURN,		WKC_RETURN),

   126

	AS(VK_TAB,			WKC_TAB),

   127

   128

	// Function keys

   129

	AM(VK_F1, VK_F12,	WKC_F1, WKC_F12),

   130

   131

	// Numeric part.

   132

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

   133

	AM(VK_NUMPAD0,VK_NUMPAD9, WKC_NUM_0, WKC_NUM_9),

   134

	AS(VK_DIVIDE,			WKC_NUM_DIV),

   135

	AS(VK_MULTIPLY,		WKC_NUM_MUL),

   136

	AS(VK_SUBTRACT,		WKC_NUM_MINUS),

   137

	AS(VK_ADD,				WKC_NUM_PLUS),

   138

	AS(VK_DECIMAL,		WKC_NUM_DECIMAL)

   139

};

   140

   141

static uint MapWindowsKey(uint sym)

   142

{

   143

	const VkMapping *map;

   144

	uint key = 0;

   145

   146

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

   147

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

   148

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

   149

			break;

   150

		}

   151

	}

   152

   153

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

   154

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

   155

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

   156

	return key;

   157

}

   158

   159

static void MakeWindow(bool full_screen);

   160

static bool AllocateDibSection(int w, int h);

   161

   162

static void ClientSizeChanged(int w, int h)

   163

{

   164

	if (_wnd.double_size) {

   165

		w /= 2;

   166

		h /= 2;

   167

	}

   168

   169

	// allocate new dib section of the new size

   170

	if (AllocateDibSection(w, h)) {

   171

		// mark all palette colors dirty

   172

		_pal_first_dirty = 0;

   173

		_pal_last_dirty = 255;

   174

		GameSizeChanged();

   175

   176

		// redraw screen

   177

		if (_wnd.running) {

   178

			_screen.dst_ptr = _wnd.buffer_bits;

   179

			UpdateWindows();

   180

		}

   181

	}

   182

}

   183

   184

void DoExitSave(void);

   185

   186

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

   187

{

   188

	switch (msg) {

   189

	case WM_PAINT: {

   190

		PAINTSTRUCT ps;

   191

		HDC dc,dc2;

   192

		HBITMAP old_bmp;

   193

		HPALETTE old_palette;

   194

		BeginPaint(hwnd, &ps);

   195

		dc = ps.hdc;

   196

		dc2 = CreateCompatibleDC(dc);

   197

		old_bmp = SelectObject(dc2, _wnd.dib_sect);

   198

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

   199

   200

		if (_pal_last_dirty != -1) {

   201

			UpdatePalette(dc2, _pal_first_dirty, _pal_last_dirty - _pal_first_dirty + 1);

   202

			_pal_last_dirty = -1;

   203

		}

   204

   205

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

   206

		SelectPalette(dc, old_palette, TRUE);

   207

		SelectObject(dc2, old_bmp);

   208

		DeleteDC(dc2);

   209

		EndPaint(hwnd, &ps);

   210

		}

   211

		return 0;

   212

   213

	case WM_PALETTECHANGED:

   214

		if ((HWND)wParam == hwnd)

   215

			return 0;

   216

		// FALL THROUGH

   217

	case WM_QUERYNEWPALETTE: {

   218

		HDC hDC = GetWindowDC(hwnd);

   219

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

   220

		UINT nChanged = RealizePalette(hDC);

   221

		SelectPalette(hDC, hOldPalette, TRUE);

   222

		ReleaseDC(hwnd, hDC);

   223

		if (nChanged)

   224

			InvalidateRect(hwnd, NULL, FALSE);

   225

		return 0;

   226

	}

   227

   228

	case WM_CLOSE:

   229

		if (_game_mode == GM_MENU) { // do not ask to quit on the main screen

   230

			_exit_game = true;

   231

		} else if (_patches.autosave_on_exit) {

   232

			DoExitSave();

   233

			_exit_game = true;

   234

		} else

   235

			AskExitGame();

   236

   237

		return 0;

   238

   239

	case WM_LBUTTONDOWN:

   240

		SetCapture(hwnd);

   241

		_left_button_down = true;

   242

		return 0;

   243

   244

	case WM_LBUTTONUP:

   245

		ReleaseCapture();

   246

		_left_button_down = false;

   247

		_left_button_clicked = false;

   248

		return 0;

   249

   250

	case WM_RBUTTONDOWN:

   251

		SetCapture(hwnd);

   252

		_right_button_down = true;

   253

		_right_button_clicked = true;

   254

		return 0;

   255

   256

	case WM_RBUTTONUP:

   257

		ReleaseCapture();

   258

		_right_button_down = false;

   259

		return 0;

   260

   261

	case WM_MOUSEMOVE: {

   262

		int x = (int16)LOWORD(lParam);

   263

		int y = (int16)HIWORD(lParam);

   264

		POINT pt;

   265

   266

		if (_wnd.double_size) {

   267

			x /= 2;

   268

			y /= 2;

   269

		}

   270

   271

		if (_cursor.fix_at) {

   272

			int dx = x - _cursor.pos.x;

   273

			int dy = y - _cursor.pos.y;

   274

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

   275

				_cursor.delta.x += dx;

   276

				_cursor.delta.y += dy;

   277

   278

				pt.x = _cursor.pos.x;

   279

				pt.y = _cursor.pos.y;

   280

   281

				if (_wnd.double_size) {

   282

					pt.x *= 2;

   283

					pt.y *= 2;

   284

				}

   285

				ClientToScreen(hwnd, &pt);

   286

				SetCursorPos(pt.x, pt.y);

   287

			}

   288

		} else {

   289

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

   290

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

   291

			_cursor.pos.x = x;

   292

			_cursor.pos.y = y;

   293

			_cursor.dirty = true;

   294

		}

   295

		MyShowCursor(false);

   296

		return 0;

   297

	}

   298

   299

	case WM_KEYDOWN: {

   300

		// this is the rewritten ascii input function

   301

		// it disables windows deadkey handling --> more linux like :D

   302

    unsigned short w = 0;

   303

		int r = 0;

   304

		byte ks[256];

   305

		unsigned int scan = 0;

   306

		uint16 scancode = (( lParam & 0xFF0000 ) >> 16 );

   307

   308

		GetKeyboardState(ks);

   309

		r = ToAscii(wParam, scan, ks, &w, 0);

   310

		if (r == 0) w = 0; // no translation was possible

   311

   312

		_pressed_key = w | MapWindowsKey(wParam) << 16;

   313

   314

		if (scancode == 41)

   315

			_pressed_key = w | WKC_BACKQUOTE << 16;

   316

   317

		if ((_pressed_key >> 16) == ('D' | WKC_CTRL) && !_wnd.fullscreen) {

   318

			_double_size ^= 1;

   319

			_wnd.double_size = _double_size;

   320

			ClientSizeChanged(_wnd.width, _wnd.height);

   321

			MarkWholeScreenDirty();

   322

		}

   323

	}	break;

   324

   325

   326

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

   327

		switch (wParam) {

   328

		case VK_RETURN: /* Full Screen */

   329

			MakeWindow(!_wnd.fullscreen);

   330

			return 0;

   331

		case VK_MENU: /* Just ALT */

   332

			return 0; // do nothing

   333

		default: /* ALT in combination with something else */

   334

			_pressed_key = MapWindowsKey(wParam) << 16;

   335

			return 0;

   336

		}

   337

		break;

   338

	case WM_NCMOUSEMOVE:

   339

		MyShowCursor(true);

   340

		return 0;

   341

   342

	case WM_SIZE: {

   343

		if (wParam != SIZE_MINIMIZED) {

   344

			ClientSizeChanged(LOWORD(lParam), HIWORD(lParam));

   345

		}

   346

		return 0;

   347

	}

   348

	case WM_SIZING: {

   349

		RECT* r = (RECT*)lParam;

   350

		RECT r2;

   351

		int w, h;

   352

   353

		SetRect(&r2, 0, 0, 0, 0);

   354

		AdjustWindowRect(&r2, GetWindowLong(hwnd, GWL_STYLE), FALSE);

   355

   356

		w = r->right - r->left - (r2.right - r2.left);

   357

		h = r->bottom - r->top - (r2.bottom - r2.top);

   358

		if (_wnd.double_size) {

   359

			w /= 2;

   360

			h /= 2;

   361

		}

   362

		w = clamp(w, 64, MAX_SCREEN_WIDTH);

   363

		h = clamp(h, 64, MAX_SCREEN_HEIGHT);

   364

		if (_wnd.double_size) {

   365

			w *= 2;

   366

			h *= 2;

   367

		}

   368

		SetRect(&r2, 0, 0, w, h);

   369

   370

		AdjustWindowRect(&r2, GetWindowLong(hwnd, GWL_STYLE), FALSE);

   371

		w = r2.right - r2.left;

   372

		h = r2.bottom - r2.top;

   373

   374

		switch (wParam) {

   375

		case WMSZ_BOTTOM:

   376

			r->bottom = r->top + h;

   377

			break;

   378

		case WMSZ_BOTTOMLEFT:

   379

			r->bottom = r->top + h;

   380

			r->left = r->right - w;

   381

			break;

   382

		case WMSZ_BOTTOMRIGHT:

   383

			r->bottom = r->top + h;

   384

			r->right = r->left + w;

   385

			break;

   386

		case WMSZ_LEFT:

   387

			r->left = r->right - w;

   388

			break;

   389

		case WMSZ_RIGHT:

   390

			r->right = r->left + w;

   391

			break;

   392

		case WMSZ_TOP:

   393

			r->top = r->bottom - h;

   394

			break;

   395

		case WMSZ_TOPLEFT:

   396

			r->top = r->bottom - h;

   397

			r->left = r->right - w;

   398

			break;

   399

		case WMSZ_TOPRIGHT:

   400

			r->top = r->bottom - h;

   401

			r->right = r->left + w;

   402

			break;

   403

		}

   404

		return TRUE;

   405

	}

   406

   407

// needed for wheel

   408

#if !defined(WM_MOUSEWHEEL)

   409

# define WM_MOUSEWHEEL                   0x020A

   410

#endif  //WM_MOUSEWHEEL

   411

#if !defined(GET_WHEEL_DELTA_WPARAM)

   412

# define GET_WHEEL_DELTA_WPARAM(wparam) ((short)HIWORD(wparam))

   413

#endif  //GET_WHEEL_DELTA_WPARAM

   414

   415

	case WM_MOUSEWHEEL: {

   416

		int delta = GET_WHEEL_DELTA_WPARAM(wParam);

   417

   418

		if (delta < 0) {

   419

			_cursor.wheel++;

   420

		} else if (delta > 0) {

   421

			_cursor.wheel--;

   422

		}

   423

		return 0;

   424

	}

   425

   426

	case WM_ACTIVATEAPP:

   427

		_wnd.has_focus = (bool)wParam;

   428

		break;

   429

	}

   430

	return DefWindowProc(hwnd, msg, wParam, lParam);

   431

}

   432

   433

static void RegisterWndClass(void)

   434

{

   435

	static bool registered;

   436

	if (!registered) {

   437

		HINSTANCE hinst = GetModuleHandle(NULL);

   438

		WNDCLASS wnd = {

   439

			0,

   440

			WndProcGdi,

   441

			0,

   442

			0,

   443

			hinst,

   444

			LoadIcon(hinst, MAKEINTRESOURCE(100)),

   445

			LoadCursor(NULL, IDC_ARROW),

   446

			0,

   447

			0,

   448

			"TTD"

   449

		};

   450

		registered = true;

   451

		if (!RegisterClass(&wnd))

   452

			error("RegisterClass failed");

   453

	}

   454

}

   455

   456

extern const char _openttd_revision[];

   457

   458

static void MakeWindow(bool full_screen)

   459

{

   460

	_fullscreen = full_screen;

   461

   462

	_wnd.double_size = _double_size && !full_screen;

   463

   464

	// recreate window?

   465

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

   466

		DestroyWindow(_wnd.main_wnd);

   467

		_wnd.main_wnd = 0;

   468

	}

   469

   470

	if (full_screen) {

   471

		DEVMODE settings;

   472

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

   473

		settings.dmSize = sizeof(DEVMODE);

   474

		settings.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT;

   475

   476

		if (_fullscreen_bpp) {

   477

			settings.dmBitsPerPel = _fullscreen_bpp;

   478

			settings.dmFields |= DM_BITSPERPEL;

   479

		}

   480

		settings.dmPelsWidth = _wnd.width_org;

   481

		settings.dmPelsHeight = _wnd.height_org;

   482

		settings.dmDisplayFrequency = _display_hz;

   483

		if (settings.dmDisplayFrequency != 0)

   484

			settings.dmFields |= DM_DISPLAYFREQUENCY;

   485

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

   486

			MakeWindow(false);

   487

			return;

   488

		}

   489

	} else if (_wnd.fullscreen) {

   490

		// restore display?

   491

		ChangeDisplaySettings(NULL, 0);

   492

	}

   493

   494

	{

   495

		RECT r;

   496

		uint style;

   497

		int x, y, w, h;

   498

   499

		_wnd.fullscreen = full_screen;

   500

		if (_wnd.fullscreen) {

   501

			style = WS_POPUP | WS_VISIBLE;

   502

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

   503

		} else {

   504

			style = WS_OVERLAPPEDWINDOW | WS_VISIBLE;

   505

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

   506

		}

   507

   508

		AdjustWindowRect(&r, style, FALSE);

   509

		w = r.right - r.left;

   510

		h = r.bottom - r.top;

   511

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

   512

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

   513

   514

		if (_wnd.main_wnd) {

   515