1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "table/strings.h"

     4

#include "gfx.h"

     5

#include "sound.h"

     6

#include "window.h"

     7

#include <windows.h>

     8

#include <mmsystem.h>

     9

#include "hal.h"

    10

#include <winnt.h>

    11

#include <wininet.h>

    12

#include <io.h>

    13

#include <fcntl.h>

    15

    16

#define SMART_PALETTE_ANIM

    17

    18

static struct {

    19

	HWND main_wnd;

    20

	HBITMAP dib_sect;

    21

	void *bitmap_bits;

    22

	void *buffer_bits;

    23

	void *alloced_bits;

    24

	HPALETTE gdi_palette;

    25

	int width,height;

    26

	int width_org, height_org;

    27

	bool cursor_visible;

    28

	bool switch_driver;

    29

	bool fullscreen;

    30

	bool double_size;

    31

	bool has_focus;

    32

	bool running;

    33

} _wnd;

    34

    35

static HINSTANCE _inst;

    36

static bool _has_console;

    37

    38

#if defined(MINGW32) || defined(__CYGWIN__)

    39

	#define __TIMESTAMP__   __DATE__ __TIME__

    40

#endif

    41

    42

#ifdef WIN32_ENABLE_DIRECTMUSIC_SUPPORT

    43

extern const HalMusicDriver _dmusic_midi_driver;

    44

#endif

    45

    46

static void MakePalette()

    47

{

    48

	LOGPALETTE *pal;

    49

	int i;

    50

	byte *b;

    51

    52

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

    53

    54

	pal->palVersion = 0x300;

    55

	pal->palNumEntries = 256;

    56

    57

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

    58

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

    59

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

    60

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

    61

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

    62

    63

	}

    64

	_wnd.gdi_palette = CreatePalette(pal);

    65

	if (_wnd.gdi_palette == NULL)

    66

		error("CreatePalette failed!\n");

    67

}

    68

    69

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

    70

{

    71

	RGBQUAD rgb[256];

    72

	uint i;

    73

	byte *b;

    74

    75

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

    76

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

    77

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

    78

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

    79

		rgb[i].rgbReserved = 0;

    80

	}

    81

    82

	SetDIBColorTable(dc, start, count, rgb);

    83

}

    84

    85

static bool MyShowCursor(bool show)

    86

{

    87

	if (_wnd.cursor_visible == show)

    88

		return show;

    89

    90

	_wnd.cursor_visible = show;

    91

	ShowCursor(show);

    92

    93

	return !show;

    94

}

    95

    96

typedef struct {

    97

	byte vk_from;

    98

	byte vk_count;

    99

	byte map_to;

   100

} VkMapping;

   101

   102

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

   103

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

   104

   105

#ifndef	VK_OEM_3

   106

#define VK_OEM_3 0xC0

   107

#endif

   108

   109

static const VkMapping _vk_mapping[] = {

   110

	// Pageup stuff + up/down

   111

	AM(VK_PRIOR,VK_DOWN, WKC_PAGEUP, WKC_DOWN),

   112

	// Map letters & digits

   113

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

   114

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

   115

   116

	AS(VK_OEM_3,	WKC_BACKQUOTE),

   117

	AS(220,				WKC_BACKQUOTE),

   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

	{0}

   140

};

   141

   142

static uint MapWindowsKey(uint key)

   143

{

   144

	const VkMapping	*map = _vk_mapping - 1;

   145

	uint from;

   146

	do {

   147

		map++;

   148

		from = map->vk_from;

   149

		if (from == 0) {

   150

			return 0; // Unknown key pressed.

   151

			}

   152

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

   153

   154

	key = key - from + map->map_to;

   155

   156

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

   157

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

   158

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

   159

	return key;

   160

}

   161

   162

static void MakeWindow(bool full_screen);

   163

static bool AllocateDibSection(int w, int h);

   164

   165

static void ClientSizeChanged(int w, int h)

   166

{

   167

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

   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

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

   185

{

   186

	switch(msg) {

   187

	case WM_PAINT: {

   188

		PAINTSTRUCT ps;

   189

		HDC dc,dc2;

   190

		HBITMAP old_bmp;

   191

		HPALETTE old_palette;

   192

		BeginPaint(hwnd, &ps);

   193

		dc = ps.hdc;

   194

		dc2 = CreateCompatibleDC(dc);

   195

		old_bmp = SelectObject(dc2, _wnd.dib_sect);

   196

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

   197

   198

		if (_pal_last_dirty != -1) {

   199

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

   200

			_pal_last_dirty = -1;

   201

		}

   202

   203

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

   204

		SelectPalette(dc, old_palette, TRUE);

   205

		SelectObject(dc2, old_bmp);

   206

		DeleteDC(dc2);

   207

		EndPaint(hwnd, &ps);

   208

		}

   209

		return 0;

   210

   211

	case WM_PALETTECHANGED:

   212

		if ((HWND)wParam == hwnd)

   213

			return 0;

   214

		// FALL THROUGH

   215

	case WM_QUERYNEWPALETTE: {

   216

		HDC hDC = GetWindowDC(hwnd);

   217

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

   218

		UINT nChanged = RealizePalette(hDC);

   219

		SelectPalette(hDC, hOldPalette, TRUE);

   220

		ReleaseDC(hwnd, hDC);

   221

		if (nChanged)

   222

			InvalidateRect(hwnd, NULL, FALSE);

   223

		return 0;

   224

	}

   225

   226

	case WM_CLOSE:

   227

		AskExitGame();

   228

		return 0;

   229

   230

	case WM_LBUTTONDOWN:

   231

		SetCapture(hwnd);

   232

		_left_button_down = true;

   233

		return 0;

   234

   235

	case WM_LBUTTONUP:

   236

		ReleaseCapture();

   237

		_left_button_down = false;

   238

		_left_button_clicked = false;

   239

		return 0;

   240

   241

	case WM_RBUTTONDOWN:

   242

		SetCapture(hwnd);

   243

		_right_button_down = true;

   244

		_right_button_clicked = true;

   245

		return 0;

   246

   247

	case WM_RBUTTONUP:

   248

		ReleaseCapture();

   249

		_right_button_down = false;

   250

		return 0;

   251

   252

	case WM_MOUSEMOVE: {

   253

		int x = (int16)LOWORD(lParam);

   254

		int y = (int16)HIWORD(lParam);

   255

		POINT pt;

   256

   257

		if (_wnd.double_size) {

   258

			x >>= 1;

   259

			y >>= 1;

   260

		}

   261

   262

		if (_cursor.fix_at) {

   263

			int dx = x - _cursor.pos.x;

   264

			int dy = y - _cursor.pos.y;

   265

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

   266

				_cursor.delta.x += dx;

   267

				_cursor.delta.y += dy;

   268

   269

				pt.x = _cursor.pos.x;

   270

				pt.y = _cursor.pos.y;

   271

   272

				if (_wnd.double_size) {

   273

					pt.x *= 2;

   274

					pt.y *= 2;

   275

				}

   276

				ClientToScreen(hwnd, &pt);

   277

				SetCursorPos(pt.x, pt.y);

   278

			}

   279

		} else {

   280

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

   281

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

   282

			_cursor.pos.x = x;

   283

			_cursor.pos.y = y;

   284

			_cursor.dirty = true;

   285

		}

   286

		MyShowCursor(false);

   287

		return 0;

   288

	}

   289

   290

	case WM_KEYDOWN: {

   291

		// this is the rewritten ascii input function

   292

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

   293

    unsigned short w = 0;

   294

		int r = 0;

   295

		byte ks[256];

   296

		unsigned int scan = 0;

   297

		GetKeyboardState(ks);

   298

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

   299

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

   300

   301

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

   302

   303

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

   304

			_double_size ^= 1;

   305

			_wnd.double_size = _double_size;

   306

			ClientSizeChanged(_wnd.width, _wnd.height);

   307

			MarkWholeScreenDirty();

   308

		}

   309

	}	break;

   310

   311

   312

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

   313

		switch(wParam) {

   314

		case VK_RETURN: /* Full Screen */

   315

			MakeWindow(!_wnd.fullscreen);

   316

			return 0;

   317

		case VK_MENU: /* Just ALT */

   318

			return 0; // do nothing

   319

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

   320

			_pressed_key = MapWindowsKey(wParam) << 16;

   321

			break;

   322

		}

   323

		break;

   324

	case WM_NCMOUSEMOVE:

   325

		MyShowCursor(true);

   326

		return 0;

   327

   328

	case WM_SIZE: {

   329

		if (wParam != SIZE_MINIMIZED) {

   330

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

   331

		}

   332

		return 0;

   333

	}

   334

	case WM_SIZING: {

   335

		RECT* r = (RECT*)lParam;

   336

		RECT r2;

   337

		int w, h;

   338

   339

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

   340

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

   341

   342

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

   343

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

   344

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

   345

		w = clamp(w, 64, MAX_SCREEN_WIDTH);

   346

		h = clamp(h, 64, MAX_SCREEN_HEIGHT);

   347

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

   348

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

   349

   350

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

   351

		w = r2.right - r2.left;

   352

		h = r2.bottom - r2.top;

   353

   354

		switch (wParam) {

   355

		case WMSZ_BOTTOM:

   356

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

   357

			break;

   358

		case WMSZ_BOTTOMLEFT:

   359

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

   360

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

   361

			break;

   362

		case WMSZ_BOTTOMRIGHT:

   363

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

   364

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

   365

			break;

   366

		case WMSZ_LEFT:

   367

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

   368

			break;

   369

		case WMSZ_RIGHT:

   370

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

   371

			break;

   372

		case WMSZ_TOP:

   373

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

   374

			break;

   375

		case WMSZ_TOPLEFT:

   376

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

   377

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

   378

			break;

   379

		case WMSZ_TOPRIGHT:

   380

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

   381

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

   382

			break;

   383

		}

   384

		return TRUE;

   385

	}

   386

   387

// needed for wheel

   388

#if !defined(WM_MOUSEWHEEL)

   389

# define WM_MOUSEWHEEL                   0x020A

   390

#endif  //WM_MOUSEWHEEL

   391

#if !defined(GET_WHEEL_DELTA_WPARAM)

   392

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

   393

#endif  //GET_WHEEL_DELTA_WPARAM

   394

   395

	case WM_MOUSEWHEEL: {

   396

		int delta = GET_WHEEL_DELTA_WPARAM(wParam);

   397

		if (delta < 0) {

   398

			_cursor.wheel++;

   399

		} else if (delta > 0) {

   400

			_cursor.wheel--;

   401

		}

   402

		return 0;

   403

	}

   404

   405

	case WM_ACTIVATEAPP:

   406

		_wnd.has_focus = (bool)wParam;

   407

		break;

   408

	}

   409

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

   410

}

   411

   412

static void RegisterWndClass()

   413

{

   414

	static bool registered;

   415

	if (!registered) {

   416

		HINSTANCE hinst = GetModuleHandle(NULL);

   417

		WNDCLASS wnd = {

   418

			0,

   419

			WndProcGdi,

   420

			0,

   421

			0,

   422

			hinst,

   423

			LoadIcon(hinst, MAKEINTRESOURCE(100)),

   424

			LoadCursor(NULL, IDC_ARROW),

   425

			0,

   426

			0,

   427

			"TTD"

   428

		};

   429

		registered = true;

   430

		if (!RegisterClass(&wnd))

   431

			error("RegisterClass failed");

   432

	}

   433

}

   434

   435

static void MakeWindow(bool full_screen)

   436

{

   437

	_fullscreen = full_screen;

   438

   439

	_wnd.double_size = _double_size && !full_screen;

   440

   441

	// recreate window?

   442

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

   443

		DestroyWindow(_wnd.main_wnd);

   444

		_wnd.main_wnd = 0;

   445

	}

   446

   447

	if (full_screen) {

   448

		DEVMODE settings;

   449

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

   450

		settings.dmSize = sizeof(DEVMODE);

   451

		settings.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT;

   452

   453

		if (_fullscreen_bpp) {

   454

			settings.dmBitsPerPel = _fullscreen_bpp;

   455

			settings.dmFields |= DM_BITSPERPEL;

   456

		}

   457

		settings.dmPelsWidth = _wnd.width_org;

   458

		settings.dmPelsHeight = _wnd.height_org;

   459

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

   460

			settings.dmFields |= DM_DISPLAYFREQUENCY;

   461

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

   462

			MakeWindow(false);

   463

			return;

   464

		}

   465

	} else if (_wnd.fullscreen) {

   466

		// restore display?

   467

		ChangeDisplaySettings(NULL, 0);

   468

	}

   469

   470

	{

   471

		RECT r;

   472

		uint style;

   473

		int x, y, w, h;

   474

   475

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

   476

			style = WS_POPUP | WS_VISIBLE;

   477

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

   478

		} else {

   479

			style = WS_OVERLAPPEDWINDOW | WS_VISIBLE;

   480

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

   481

		}

   482

   483

		AdjustWindowRect(&r, style, FALSE);

   484

		w = r.right - r.left;

   485

		h = r.bottom - r.top;

   486

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

   487

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

   488

   489

		if (_wnd.main_wnd) {

   490

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

   491

		} else {

   492

			char Windowtitle[50] = "OpenTTD ";

   493

			#ifdef WITH_REV_HACK

   494

				// also show revision number/release in window title

   495

				extern const char _openttd_revision[];

   496

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

   497

			#endif

   498

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

   499

			if (_wnd.main_wnd == NULL)

   500

				error("CreateWindow failed");

   501

		}

   502

	}

   503

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

   504

}

   505

   506

static bool AllocateDibSection(int w, int h)

   507

{

   508

	BITMAPINFO *bi;

   509

	HDC dc;

   510

   511

	w = clamp(w, 64, MAX_SCREEN_WIDTH);

   512

	h = clamp(h, 64, MAX_SCREEN_HEIGHT);

   513

   514

	if (w == _screen.width && h == _screen.height)

   515

		return false;

   516

   517

	_screen.width = w;

   518

	_screen.pitch = (w + 3) & ~0x3;

   519

	_screen.height = h;

   520

   521