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 "sound.h"

     8

#include "window.h"

     9

#include <windows.h>

    10

#include <mmsystem.h>

    11

#include "hal.h"

    12

#include <winnt.h>

    13

#include <wininet.h>

    14

#include <io.h>

    15

#include <fcntl.h>

    16

#include "network.h"

    17

    18

#define SMART_PALETTE_ANIM

    19

    20

static struct {

    21

	HWND main_wnd;

    22

	HBITMAP dib_sect;

    23

	void *bitmap_bits;

    24

	void *buffer_bits;

    25

	void *alloced_bits;

    26

	HPALETTE gdi_palette;

    27

	int width,height;

    28

	int width_org, height_org;

    29

	bool cursor_visible;

    30

	bool switch_driver;

    31

	bool fullscreen;

    32

	bool double_size;

    33

	bool has_focus;

    34

	bool running;

    35

} _wnd;

    36

    37

static HINSTANCE _inst;

    38

static bool _has_console;

    39

    40

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

    41

	#define __TIMESTAMP__   __DATE__ __TIME__

    42

#endif

    43

    44

#ifdef WIN32_ENABLE_DIRECTMUSIC_SUPPORT

    45

extern const HalMusicDriver _dmusic_midi_driver;

    46

#endif

    47

    48

static void MakePalette(void)

    49

{

    50

	LOGPALETTE *pal;

    51

	int i;

    52

	byte *b;

    53

    54

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

    55

    56

	pal->palVersion = 0x300;

    57

	pal->palNumEntries = 256;

    58

    59

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

    60

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

    61

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

    62

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

    63

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

    64

    65

	}

    66

	_wnd.gdi_palette = CreatePalette(pal);

    67

	if (_wnd.gdi_palette == NULL)

    68

		error("CreatePalette failed!\n");

    69

}

    70

    71

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

    72

{

    73

	RGBQUAD rgb[256];

    74

	uint i;

    75

	byte *b;

    76

    77

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

    78

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

    79

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

    80

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

    81

		rgb[i].rgbReserved = 0;

    82

	}

    83

    84

	SetDIBColorTable(dc, start, count, rgb);

    85

}

    86

    87

static bool MyShowCursor(bool show)

    88

{

    89

	if (_wnd.cursor_visible == show)

    90

		return show;

    91

    92

	_wnd.cursor_visible = show;

    93

	ShowCursor(show);

    94

    95

	return !show;

    96

}

    97

    98

typedef struct {

    99

	byte vk_from;

   100

	byte vk_count;

   101

	byte map_to;

   102

} VkMapping;

   103

   104

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

   105

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

   106

   107

#ifndef	VK_OEM_3

   108

#define VK_OEM_3 0xC0

   109

#endif

   110

   111

static const VkMapping _vk_mapping[] = {

   112

	// Pageup stuff + up/down

   113

	AM(VK_PRIOR,VK_DOWN, WKC_PAGEUP, WKC_DOWN),

   114

	// Map letters & digits

   115

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

   116

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

   117

   118

	AS(VK_ESCAPE,		WKC_ESC),

   119

	AS(VK_PAUSE, WKC_PAUSE),

   120

	AS(VK_BACK,			WKC_BACKSPACE),

   121

	AM(VK_INSERT,VK_DELETE,WKC_INSERT, WKC_DELETE),

   122

   123

	AS(VK_SPACE,		WKC_SPACE),

   124

	AS(VK_RETURN,		WKC_RETURN),

   125

	AS(VK_TAB,			WKC_TAB),

   126

   127

	// Function keys

   128

	AM(VK_F1, VK_F12,	WKC_F1, WKC_F12),

   129

   130

	// Numeric part.

   131

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

   132

	AM(VK_NUMPAD0,VK_NUMPAD9, WKC_NUM_0, WKC_NUM_9),

   133

	AS(VK_DIVIDE,			WKC_NUM_DIV),

   134

	AS(VK_MULTIPLY,		WKC_NUM_MUL),

   135

	AS(VK_SUBTRACT,		WKC_NUM_MINUS),

   136

	AS(VK_ADD,				WKC_NUM_PLUS),

   137

	AS(VK_DECIMAL,		WKC_NUM_DECIMAL),

   138

	{0}

   139

};

   140

   141

static uint MapWindowsKey(uint key)

   142

{

   143

	const VkMapping	*map = _vk_mapping - 1;

   144

	uint from;

   145

	do {

   146

		map++;

   147

		from = map->vk_from;

   148

		if (from == 0) {

   149

			return 0; // Unknown key pressed.

   150

			}

   151

	}	while ((uint)(key - from) > map->vk_count);

   152

   153

	key = key - from + map->map_to;

   154

   155

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

   156

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

   157

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

   158

	return key;

   159

}

   160

   161

static void MakeWindow(bool full_screen);

   162

static bool AllocateDibSection(int w, int h);

   163

   164

static void ClientSizeChanged(int w, int h)

   165

{

   166

	if (_wnd.double_size) { w >>= 1; h >>= 1; }

   167

   168

	// allocate new dib section of the new size

   169

	if (AllocateDibSection(w, h)) {

   170

		// mark all palette colors dirty

   171

		_pal_first_dirty = 0;

   172

		_pal_last_dirty = 255;

   173

		GameSizeChanged();

   174

   175

		// redraw screen

   176

		if (_wnd.running) {

   177

			_screen.dst_ptr = _wnd.buffer_bits;

   178

			UpdateWindows();

   179

		}

   180

	}

   181

}

   182

   183

void DoExitSave(void);

   184

   185

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

   186

{

   187

	switch(msg) {

   188

	case WM_PAINT: {

   189

		PAINTSTRUCT ps;

   190

		HDC dc,dc2;

   191

		HBITMAP old_bmp;

   192

		HPALETTE old_palette;

   193

		BeginPaint(hwnd, &ps);

   194

		dc = ps.hdc;

   195

		dc2 = CreateCompatibleDC(dc);

   196

		old_bmp = SelectObject(dc2, _wnd.dib_sect);

   197

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

   198

   199

		if (_pal_last_dirty != -1) {

   200

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

   201

			_pal_last_dirty = -1;

   202

		}

   203

   204

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

   205

		SelectPalette(dc, old_palette, TRUE);

   206

		SelectObject(dc2, old_bmp);

   207

		DeleteDC(dc2);

   208

		EndPaint(hwnd, &ps);

   209

		}

   210

		return 0;

   211

   212

	case WM_PALETTECHANGED:

   213

		if ((HWND)wParam == hwnd)

   214

			return 0;

   215

		// FALL THROUGH

   216

	case WM_QUERYNEWPALETTE: {

   217

		HDC hDC = GetWindowDC(hwnd);

   218

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

   219

		UINT nChanged = RealizePalette(hDC);

   220

		SelectPalette(hDC, hOldPalette, TRUE);

   221

		ReleaseDC(hwnd, hDC);

   222

		if (nChanged)

   223

			InvalidateRect(hwnd, NULL, FALSE);

   224

		return 0;

   225

	}

   226

   227

	case WM_CLOSE:

   228

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

   229

			_exit_game = true;

   230

		} else if (_patches.autosave_on_exit) {

   231

				DoExitSave();

   232

				_exit_game = true;

   233

		} else

   234

			AskExitGame();

   235

   236

		return 0;

   237

   238

	case WM_LBUTTONDOWN:

   239

		SetCapture(hwnd);

   240

		_left_button_down = true;

   241

		return 0;

   242

   243

	case WM_LBUTTONUP:

   244

		ReleaseCapture();

   245

		_left_button_down = false;

   246

		_left_button_clicked = false;

   247

		return 0;

   248

   249

	case WM_RBUTTONDOWN:

   250

		SetCapture(hwnd);

   251

		_right_button_down = true;

   252

		_right_button_clicked = true;

   253

		return 0;

   254

   255

	case WM_RBUTTONUP:

   256

		ReleaseCapture();

   257

		_right_button_down = false;

   258

		return 0;

   259

   260

	case WM_MOUSEMOVE: {

   261

		int x = (int16)LOWORD(lParam);

   262

		int y = (int16)HIWORD(lParam);

   263

		POINT pt;

   264

   265

		if (_wnd.double_size) {

   266

			x >>= 1;

   267

			y >>= 1;

   268

		}

   269

   270

		if (_cursor.fix_at) {

   271

			int dx = x - _cursor.pos.x;

   272

			int dy = y - _cursor.pos.y;

   273

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

   274

				_cursor.delta.x += dx;

   275

				_cursor.delta.y += dy;

   276

   277

				pt.x = _cursor.pos.x;

   278

				pt.y = _cursor.pos.y;

   279

   280

				if (_wnd.double_size) {

   281

					pt.x *= 2;

   282

					pt.y *= 2;

   283

				}

   284

				ClientToScreen(hwnd, &pt);

   285

				SetCursorPos(pt.x, pt.y);

   286

			}

   287

		} else {

   288

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

   289

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

   290

			_cursor.pos.x = x;

   291

			_cursor.pos.y = y;

   292

			_cursor.dirty = true;

   293

		}

   294

		MyShowCursor(false);

   295

		return 0;

   296

	}

   297

   298

	case WM_KEYDOWN: {

   299

		// this is the rewritten ascii input function

   300

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

   301

    unsigned short w = 0;

   302

		int r = 0;

   303

		byte ks[256];

   304

		unsigned int scan = 0;

   305

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

   306

   307

		GetKeyboardState(ks);

   308

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

   309

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

   310

   311

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

   312

   313

		if( scancode == 41 )

   314

			_pressed_key = w | WKC_BACKQUOTE << 16;

   315

   316

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

   317

			_double_size ^= 1;

   318

			_wnd.double_size = _double_size;

   319

			ClientSizeChanged(_wnd.width, _wnd.height);

   320

			MarkWholeScreenDirty();

   321

		}

   322

	}	break;

   323

   324

   325

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

   326

		switch(wParam) {

   327

		case VK_RETURN: /* Full Screen */

   328

			MakeWindow(!_wnd.fullscreen);

   329

			return 0;

   330

		case VK_MENU: /* Just ALT */

   331

			return 0; // do nothing

   332

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

   333

			_pressed_key = MapWindowsKey(wParam) << 16;

   334

			break;

   335

		}

   336

		break;

   337

	case WM_NCMOUSEMOVE:

   338

		MyShowCursor(true);

   339

		return 0;

   340

   341

	case WM_SIZE: {

   342

		if (wParam != SIZE_MINIMIZED) {

   343

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

   344

		}

   345

		return 0;

   346

	}

   347

	case WM_SIZING: {

   348

		RECT* r = (RECT*)lParam;

   349

		RECT r2;

   350

		int w, h;

   351

   352

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

   353

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

   354

   355

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

   356

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

   357

		if (_wnd.double_size) { w >>= 1; h >>= 1; }

   358

		w = clamp(w, 64, MAX_SCREEN_WIDTH);

   359

		h = clamp(h, 64, MAX_SCREEN_HEIGHT);

   360

		if (_wnd.double_size) { w <<= 1; h <<= 1; }

   361

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

   362

   363

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

   364

		w = r2.right - r2.left;

   365

		h = r2.bottom - r2.top;

   366

   367

		switch (wParam) {

   368

		case WMSZ_BOTTOM:

   369

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

   370

			break;

   371

		case WMSZ_BOTTOMLEFT:

   372

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

   373

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

   374

			break;

   375

		case WMSZ_BOTTOMRIGHT:

   376

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

   377

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

   378

			break;

   379

		case WMSZ_LEFT:

   380

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

   381

			break;

   382

		case WMSZ_RIGHT:

   383

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

   384

			break;

   385

		case WMSZ_TOP:

   386

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

   387

			break;

   388

		case WMSZ_TOPLEFT:

   389

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

   390

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

   391

			break;

   392

		case WMSZ_TOPRIGHT:

   393

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

   394

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

   395

			break;

   396

		}

   397

		return TRUE;

   398

	}

   399

   400

// needed for wheel

   401

#if !defined(WM_MOUSEWHEEL)

   402

# define WM_MOUSEWHEEL                   0x020A

   403

#endif  //WM_MOUSEWHEEL

   404

#if !defined(GET_WHEEL_DELTA_WPARAM)

   405

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

   406

#endif  //GET_WHEEL_DELTA_WPARAM

   407

   408

	case WM_MOUSEWHEEL: {

   409

		int delta = GET_WHEEL_DELTA_WPARAM(wParam);

   410

		if (delta < 0) {

   411

			_cursor.wheel++;

   412

		} else if (delta > 0) {

   413

			_cursor.wheel--;

   414

		}

   415

		return 0;

   416

	}

   417

   418

	case WM_ACTIVATEAPP:

   419

		_wnd.has_focus = (bool)wParam;

   420

		break;

   421

	}

   422

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

   423

}

   424

   425

static void RegisterWndClass(void)

   426

{

   427

	static bool registered;

   428

	if (!registered) {

   429

		HINSTANCE hinst = GetModuleHandle(NULL);

   430

		WNDCLASS wnd = {

   431

			0,

   432

			WndProcGdi,

   433

			0,

   434

			0,

   435

			hinst,

   436

			LoadIcon(hinst, MAKEINTRESOURCE(100)),

   437

			LoadCursor(NULL, IDC_ARROW),

   438

			0,

   439

			0,

   440

			"TTD"

   441

		};

   442

		registered = true;

   443

		if (!RegisterClass(&wnd))

   444

			error("RegisterClass failed");

   445

	}

   446

}

   447

   448

extern const char _openttd_revision[];

   449

   450

static void MakeWindow(bool full_screen)

   451

{

   452

	_fullscreen = full_screen;

   453

   454

	_wnd.double_size = _double_size && !full_screen;

   455

   456

	// recreate window?

   457

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

   458

		DestroyWindow(_wnd.main_wnd);

   459

		_wnd.main_wnd = 0;

   460

	}

   461

   462

	if (full_screen) {

   463

		DEVMODE settings;

   464

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

   465

		settings.dmSize = sizeof(DEVMODE);

   466

		settings.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT;

   467

   468

		if (_fullscreen_bpp) {

   469

			settings.dmBitsPerPel = _fullscreen_bpp;

   470

			settings.dmFields |= DM_BITSPERPEL;

   471

		}

   472

		settings.dmPelsWidth = _wnd.width_org;

   473

		settings.dmPelsHeight = _wnd.height_org;

   474

		if ((settings.dmDisplayFrequency = _display_hz) != 0)

   475

			settings.dmFields |= DM_DISPLAYFREQUENCY;

   476

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

   477

			MakeWindow(false);

   478

			return;

   479

		}

   480

	} else if (_wnd.fullscreen) {

   481

		// restore display?

   482

		ChangeDisplaySettings(NULL, 0);

   483

	}

   484

   485

	{

   486

		RECT r;

   487

		uint style;

   488

		int x, y, w, h;

   489

   490

		if ((_wnd.fullscreen=full_screen) != false) {

   491

			style = WS_POPUP | WS_VISIBLE;

   492

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

   493

		} else {

   494

			style = WS_OVERLAPPEDWINDOW | WS_VISIBLE;

   495

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

   496

		}

   497

   498

		AdjustWindowRect(&r, style, FALSE);

   499

		w = r.right - r.left;

   500

		h = r.bottom - r.top;

   501

		x = (GetSystemMetrics(SM_CXSCREEN)-w)>>1;

   502

		y = (GetSystemMetrics(SM_CYSCREEN)-h)>>1;

   503

   504

		if (_wnd.main_wnd) {

   505

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

   506

		} else {

   507

			char Windowtitle[50] = "OpenTTD ";

   508

			// also show revision number/release in window title

   509

			strncat(Windowtitle, _openttd_revision, sizeof(Windowtitle)-(strlen(Windowtitle) + 1));

   510

   511

			_wnd.main_wnd = CreateWindow("TTD", Windowtitle, style, x, y, w, h, 0, 0, _inst, 0);

   512

			if (_wnd.main_wnd == NULL)

   513

				error("CreateWindow failed");

   514

		}

   515

	}

   516

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

   517

}

   518

   519

static bool AllocateDibSection(int w, int h)