1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "gfx.h"

     4

#include "sound.h"

     5

#include "window.h"

     6

#include <windows.h>

     7

#include <mmsystem.h>

     8

#include "hal.h"

     9

#include <winnt.h>

    10

#include <wininet.h>

    11

#include <io.h>

    12

#include <fcntl.h>

    13

    14

#define SMART_PALETTE_ANIM

    15

    16

static struct {

    17

	HWND main_wnd;

    18

	HBITMAP dib_sect;

    19

	void *bitmap_bits;

    20

	void *buffer_bits;

    21

	void *alloced_bits;

    22

	HPALETTE gdi_palette;

    23

	int width,height;

    24

	int width_org, height_org;

    25

	bool cursor_visible;

    26

	bool switch_driver;

    27

	bool fullscreen;

    28

	bool double_size;

    29

	bool has_focus;

    30

	bool running;

    31

} _wnd;

    32

    33

static HINSTANCE _inst;

    34

static bool _has_console;

    35

    36

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

    37

	#define __TIMESTAMP__   __DATE__ __TIME__

    38

#endif

    39

    40

#ifdef WIN32_ENABLE_DIRECTMUSIC_SUPPORT

    41

extern const HalMusicDriver _dmusic_midi_driver;

    42

#endif

    43

    44

static void MakePalette()

    45

{

    46

	LOGPALETTE *pal;

    47

	int i;

    48

	byte *b;

    49

    50

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

    51

    52

	pal->palVersion = 0x300;

    53

	pal->palNumEntries = 256;

    54

    55

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

    56

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

    57

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

    58

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

    59

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

    60

    61

	}

    62

	_wnd.gdi_palette = CreatePalette(pal);

    63

	if (_wnd.gdi_palette == NULL)	

    64

		error("CreatePalette failed!\n");

    65

}

    66

    67

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

    68

{

    69

	RGBQUAD rgb[256];

    70

	uint i;

    71

	byte *b;

    72

    73

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

    74

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

    75

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

    76

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

    77

		rgb[i].rgbReserved = 0;

    78

	}

    79

    80

	SetDIBColorTable(dc, start, count, rgb);

    81

}

    82

    83

static bool MyShowCursor(bool show)

    84

{

    85

	if (_wnd.cursor_visible == show)

    86

		return show;

    87

    88

	_wnd.cursor_visible = show;

    89

	ShowCursor(show);

    90

    91

	return !show;

    92

}

    93

    94

typedef struct {

    95

	byte vk_from;

    96

	byte vk_count;

    97

	byte map_to;

    98

} VkMapping;

    99

   100

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

   101

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

   102

   103

static const VkMapping _vk_mapping[] = {

   104

	// Pageup stuff + up/down

   105

	AM(VK_PRIOR,VK_DOWN, WKC_PAGEUP, WKC_DOWN),

   106

	// Map letters & digits

   107

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

   108

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

   109

   110

	AS(VK_ESCAPE,		WKC_ESC),

   111

	AS(VK_BACK,			WKC_BACKSPACE),

   112

	AM(VK_INSERT,VK_DELETE,WKC_INSERT, WKC_DELETE),

   113

   114

	AS(VK_SPACE,		WKC_SPACE),

   115

	AS(VK_RETURN,		WKC_RETURN),

   116

	AS(VK_TAB,			WKC_TAB),

   117

   118

	// Function keys

   119

	AM(VK_F1, VK_F12,	WKC_F1, WKC_F12),

   120

   121

	// Numeric part.

   122

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

   123

	AM(VK_NUMPAD0,VK_NUMPAD9, WKC_NUM_0, WKC_NUM_9),

   124

	AS(VK_DIVIDE,			WKC_NUM_DIV),

   125

	AS(VK_MULTIPLY,		WKC_NUM_MUL),

   126

	AS(VK_SUBTRACT,		WKC_NUM_MINUS),

   127

	AS(VK_ADD,				WKC_NUM_PLUS),

   128

	AS(VK_DECIMAL,		WKC_NUM_DECIMAL),

   129

	{0}	

   130

};

   131

   132

static uint MapWindowsKey(uint key)

   133

{

   134

	const VkMapping	*map = _vk_mapping - 1;

   135

	uint from;

   136

	do {

   137

		map++;

   138

		from = map->vk_from;

   139

		if (from == 0) return 0; // Unknown key pressed.

   140

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

   141

   142

	key = key - from + map->map_to;

   143

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

   144

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

   145

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

   146

	return key;

   147

}

   148

   149

static void MakeWindow(bool full_screen);

   150

static bool AllocateDibSection(int w, int h);

   151

   152

static void ClientSizeChanged(int w, int h)

   153

{

   154

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

   155

   156

	// allocate new dib section of the new size

   157

	if (AllocateDibSection(w, h)) {

   158

		// mark all palette colors dirty

   159

		_pal_first_dirty = 0;

   160

		_pal_last_dirty = 255;

   161

		GameSizeChanged();

   162

   163

		// redraw screen

   164

		if (_wnd.running) {

   165

			_screen.dst_ptr = _wnd.buffer_bits;

   166

			UpdateWindows();

   167

		}

   168

	}

   169

}

   170

   171

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

   172

{

   173

	switch(msg) {

   174

	case WM_PAINT: {

   175

		PAINTSTRUCT ps;

   176

		HDC dc,dc2;

   177

		HBITMAP old_bmp;

   178

		HPALETTE old_palette;

   179

		BeginPaint(hwnd, &ps);

   180

		dc = ps.hdc;

   181

		dc2 = CreateCompatibleDC(dc);

   182

		old_bmp = SelectObject(dc2, _wnd.dib_sect);

   183

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

   184

   185

		if (_pal_last_dirty != -1) {

   186

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

   187

			_pal_last_dirty = -1;

   188

		}

   189

   190

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

   191

		SelectPalette(dc, old_palette, TRUE);

   192

		SelectObject(dc2, old_bmp);

   193

		DeleteDC(dc2);

   194

		EndPaint(hwnd, &ps);

   195

		}

   196

		return 0;

   197

   198

	case WM_PALETTECHANGED:

   199

		if ((HWND)wParam == hwnd)

   200

			return 0;

   201

		// FALL THROUGH

   202

	case WM_QUERYNEWPALETTE: {

   203

		HDC hDC = GetWindowDC(hwnd);

   204

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

   205

		UINT nChanged = RealizePalette(hDC);

   206

		SelectPalette(hDC, hOldPalette, TRUE);

   207

		ReleaseDC(hwnd, hDC);

   208

		if (nChanged)

   209

			InvalidateRect(hwnd, NULL, FALSE);

   210

		return 0;

   211

	}

   212

   213

	case WM_CLOSE:

   214

		AskExitGame();

   215

		return 0;

   216

   217

	case WM_LBUTTONDOWN:

   218

		SetCapture(hwnd);

   219

		_left_button_down = true;

   220

		return 0;

   221

   222

	case WM_LBUTTONUP:

   223

		ReleaseCapture();

   224

		_left_button_down = false;

   225

		_left_button_clicked = false;

   226

		return 0;

   227

   228

	case WM_RBUTTONDOWN:

   229

		SetCapture(hwnd);

   230

		_right_button_down = true;

   231

		_right_button_clicked = true;

   232

		return 0;

   233

   234

	case WM_RBUTTONUP:

   235

		ReleaseCapture();

   236

		_right_button_down = false;

   237

		return 0;

   238

   239

	case WM_MOUSEMOVE: {

   240

		int x = (int16)LOWORD(lParam);

   241

		int y = (int16)HIWORD(lParam);

   242

		POINT pt;

   243

   244

		if (_wnd.double_size) {

   245

			x >>= 1;

   246

			y >>= 1;

   247

		}

   248

   249

		if (_cursor.fix_at) {

   250

			int dx = x - _cursor.pos.x;

   251

			int dy = y - _cursor.pos.y;

   252

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

   253

				_cursor.delta.x += dx;

   254

				_cursor.delta.y += dy;

   255

   256

				pt.x = _cursor.pos.x;

   257

				pt.y = _cursor.pos.y;

   258

   259

				if (_wnd.double_size) {

   260

					pt.x *= 2;

   261

					pt.y *= 2;

   262

				}

   263

				ClientToScreen(hwnd, &pt);

   264

				SetCursorPos(pt.x, pt.y);

   265

			}

   266

		} else {

   267

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

   268

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

   269

			_cursor.pos.x = x;

   270

			_cursor.pos.y = y;

   271

			_cursor.dirty = true;

   272

		}

   273

		MyShowCursor(false);

   274

		return 0;

   275

	}

   276

   277

	case WM_KEYDOWN:

   278

		_pressed_key = MapWindowsKey(wParam) << 16;

   279

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

   280

			_double_size ^= 1;

   281

			_wnd.double_size = _double_size;

   282

			ClientSizeChanged(_wnd.width, _wnd.height);

   283

			MarkWholeScreenDirty();

   284

		}

   285

		break;

   286

   287

	case WM_CHAR: 

   288

		_pressed_key |= wParam;

   289

		break;

   290

   291

	case WM_SYSKEYDOWN:

   292

		switch(wParam) {

   293

		case VK_RETURN:

   294

			MakeWindow(!_wnd.fullscreen);

   295

			return 0;

   296

		default:

   297

			_pressed_key = MapWindowsKey(wParam) << 16;

   298

			break;

   299

		}

   300

		break;

   301

	case WM_NCMOUSEMOVE:

   302

		MyShowCursor(true);

   303

		return 0;

   304

   305

	case WM_SIZE: {

   306

		if (wParam != SIZE_MINIMIZED) {

   307

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

   308

		}

   309

		return 0;

   310

	}

   311

	case WM_SIZING: {

   312

		RECT* r = (RECT*)lParam;

   313

		RECT r2;

   314

		int w, h;

   315

   316

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

   317

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

   318

   319

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

   320

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

   321

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

   322

		w = clamp(w & ~0x7, 64, MAX_SCREEN_WIDTH);

   323

		h = clamp(h & ~0x7, 64, MAX_SCREEN_HEIGHT);

   324

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

   325

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

   326

   327

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

   328

		w = r2.right - r2.left;

   329

		h = r2.bottom - r2.top;

   330

   331

		switch (wParam) {

   332

		case WMSZ_BOTTOM:

   333

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

   334

			break;

   335

		case WMSZ_BOTTOMLEFT:

   336

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

   337

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

   338

			break;

   339

		case WMSZ_BOTTOMRIGHT:

   340

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

   341

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

   342

			break;

   343

		case WMSZ_LEFT:

   344

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

   345

			break;

   346

		case WMSZ_RIGHT:

   347

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

   348

			break;

   349

		case WMSZ_TOP:

   350

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

   351

			break;

   352

		case WMSZ_TOPLEFT:

   353

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

   354

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

   355

			break;

   356

		case WMSZ_TOPRIGHT:

   357

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

   358

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

   359

			break;

   360

		}

   361

		return TRUE;

   362

	}

   363

   364

// needed for wheel

   365

#if !defined(WM_MOUSEWHEEL)

   366

# define WM_MOUSEWHEEL                   0x020A

   367

#endif  //WM_MOUSEWHEEL

   368

#if !defined(GET_WHEEL_DELTA_WPARAM)

   369

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

   370

#endif  //GET_WHEEL_DELTA_WPARAM

   371

   372

	case WM_MOUSEWHEEL: {

   373

		int delta = GET_WHEEL_DELTA_WPARAM(wParam);	

   374

		if (delta < 0) {

   375

			_cursor.wheel++;

   376

		} else if (delta > 0) {

   377

			_cursor.wheel--;

   378

		}

   379

		return 0;

   380

	}

   381

   382

	case WM_ACTIVATEAPP:

   383

		_wnd.has_focus = (bool)wParam;

   384

		break;

   385

	}

   386

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

   387

}

   388

   389

static void RegisterWndClass()

   390

{

   391

	static bool registered;

   392

	if (!registered) {

   393

		HINSTANCE hinst = GetModuleHandle(NULL);

   394

		WNDCLASS wnd = {

   395

			0,

   396

			WndProcGdi,

   397

			0,

   398

			0,

   399

			hinst,

   400

			LoadIcon(hinst, MAKEINTRESOURCE(100)),

   401

			LoadCursor(NULL, IDC_ARROW),

   402

			0,

   403

			0,

   404

			"TTD"

   405

		};

   406

		registered = true;

   407

		if (!RegisterClass(&wnd))

   408

			error("RegisterClass failed");

   409

	}

   410

}

   411

   412

static void MakeWindow(bool full_screen)

   413

{

   414

	_fullscreen = full_screen;

   415

   416

	_wnd.double_size = _double_size && !full_screen;

   417

   418

	// recreate window?

   419

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

   420

		DestroyWindow(_wnd.main_wnd);

   421

		_wnd.main_wnd = 0;

   422

	}

   423

   424

	if (full_screen) {

   425

		DEVMODE settings;

   426

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

   427

		settings.dmSize = sizeof(DEVMODE);

   428

		settings.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT;

   429

   430

		if (_fullscreen_bpp) {

   431

			settings.dmBitsPerPel = _fullscreen_bpp;

   432

			settings.dmFields |= DM_BITSPERPEL;

   433

		}

   434

		settings.dmPelsWidth = _wnd.width_org;

   435

		settings.dmPelsHeight = _wnd.height_org;

   436

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

   437

			settings.dmFields |= DM_DISPLAYFREQUENCY;

   438

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

   439

			MakeWindow(false);

   440

			return;

   441

		}

   442

	} else if (_wnd.fullscreen) {

   443

		// restore display?

   444

		ChangeDisplaySettings(NULL, 0);

   445

	}

   446

   447

	{

   448

		RECT r;

   449

		uint style;

   450

		int x, y, w, h;

   451

   452

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

   453

			style = WS_POPUP | WS_VISIBLE;

   454

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

   455

		} else {

   456

			style = WS_OVERLAPPEDWINDOW | WS_VISIBLE;

   457

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

   458

		}

   459

   460

		AdjustWindowRect(&r, style, FALSE);

   461

		w = r.right - r.left;

   462

		h = r.bottom - r.top;

   463

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

   464

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

   465

   466

		if (_wnd.main_wnd) {

   467

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

   468

		} else {

   469

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

   470

			if (_wnd.main_wnd == NULL)

   471

				error("CreateWindow failed");

   472

		}

   473

	}

   474

}

   475

   476

static bool AllocateDibSection(int w, int h)

   477

{

   478

	BITMAPINFO *bi;

   479

	HDC dc;

   480

   481

	w = clamp(w & ~7, 64, MAX_SCREEN_WIDTH);

   482

	h = clamp(h & ~7, 64, MAX_SCREEN_HEIGHT);

   483

   484

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

   485

		return false;

   486

   487

	_screen.width = _screen.pitch = w;

   488

	_screen.height = h;

   489

   490

	if (_wnd.alloced_bits) {

   491

		free(_wnd.alloced_bits);

   492

		_wnd.alloced_bits = NULL;

   493

	}

   494

   495

	bi = alloca(sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD)*256);

   496

	memset(bi, 0, sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD)*256);

   497

	bi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);

   498

   499

	{

   500

		if (_wnd.double_size) {

   501

			_wnd.alloced_bits = _wnd.buffer_bits = (byte*)malloc(w * h);

   502

			w *= 2;

   503

			h *= 2;

   504

		}

   505

   506

		bi->bmiHeader.biWidth = _wnd.width = w;

   507

		bi->bmiHeader.biHeight = -(_wnd.height = h);

   508

	}

   509

   510

	bi->bmiHeader.biPlanes = 1;

   511

	bi->bmiHeader.biBitCount = 8;

   512

	bi->bmiHeader.biCompression = BI_RGB;

   513

   514

	if (_wnd.dib_sect)

   515

		DeleteObject(_wnd.dib_sect);

   516

   517

	dc = GetDC(0);

   518

	_wnd.dib_sect = CreateDIBSection(dc, bi, DIB_RGB_COLORS, &_wnd.bitmap_bits, NULL, 0);

   519

	if (_wnd.dib_sect == NULL)

   520

		error("CreateDIBSection failed");

   521

	ReleaseDC(0, dc);

   522

   523

	if (!_wnd.double_size) 

   524

		_wnd.buffer_bits = _wnd.bitmap_bits;

   525

   526

	return true;

   527

}

   528

   529

static const uint16 default_resolutions[][2] = {

   530