1

#include "stdafx.h"

     2

#include "openttd.h"

     3

#include "debug.h"

     5

#include "saveload.h"

     6

#include "string.h"

     7

#include "table/strings.h"

     8

#include "gfx.h"

     9

#include "mixer.h"

    10

#include "window.h"

    11

#include "gui.h"

    12

#include <windows.h>

    13

#include <mmsystem.h>

    14

#include "hal.h"

    15

#include <winnt.h>

    16

#include <wininet.h>

    17

#include <io.h>

    18

#include <fcntl.h>

    19

#include "network.h"

    20

#include "variables.h"

    21

    22

#define SMART_PALETTE_ANIM

    23

    24

static struct {

    25

	HWND main_wnd;

    26

	HBITMAP dib_sect;

    27

	Pixel *bitmap_bits;

    28

	Pixel *buffer_bits;

    29

	Pixel *alloced_bits;

    30

	HPALETTE gdi_palette;

    31

	int width,height;

    32

	int width_org, height_org;

    33

	bool cursor_visible;

    34

	bool switch_driver;

    35

	bool fullscreen;

    36

	bool double_size;

    37

	bool has_focus;

    38

	bool running;

    39

} _wnd;

    40

    41

static HINSTANCE _inst;

    42

static bool _has_console;

    43

    44

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

    45

	#define __TIMESTAMP__   __DATE__ __TIME__

    46

#endif

    47

    48

#ifdef WIN32_ENABLE_DIRECTMUSIC_SUPPORT

    49

extern const HalMusicDriver _dmusic_midi_driver;

    50

#endif

    51

    52

static void MakePalette(void)

    53

{

    54

	LOGPALETTE *pal;

    55

	uint i;

    56

    57

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

    58

    59

	pal->palVersion = 0x300;

    60

	pal->palNumEntries = 256;

    61

    62

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

    63

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

    64

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

    65

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

    66

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

    67

    68

	}

    69

	_wnd.gdi_palette = CreatePalette(pal);

    70

	if (_wnd.gdi_palette == NULL)

    71

		error("CreatePalette failed!\n");

    72

}

    73

    74

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

    75

{

    76

	RGBQUAD rgb[256];

    77

	uint i;

    78

    79

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

    80

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

    81

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

    82

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

    83

		rgb[i].rgbReserved = 0;

    84

	}

    85

    86

	SetDIBColorTable(dc, start, count, rgb);

    87

}

    88

    89

static bool MyShowCursor(bool show)

    90

{

    91

	if (_wnd.cursor_visible == show)

    92

		return show;

    93

    94

	_wnd.cursor_visible = show;

    95

	ShowCursor(show);

    96

    97

	return !show;

    98

}

    99

   100

typedef struct {

   101

	byte vk_from;

   102

	byte vk_count;

   103

	byte map_to;

   104

} VkMapping;

   105

   106

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

   107

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

   108

   109

#ifndef VK_OEM_3

   110

#define VK_OEM_3 0xC0

   111

#endif

   112

   113

static const VkMapping _vk_mapping[] = {

   114

	// Pageup stuff + up/down

   115

	AM(VK_PRIOR,VK_DOWN, WKC_PAGEUP, WKC_DOWN),

   116

	// Map letters & digits

   117

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

   118

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

   119

   120

	AS(VK_ESCAPE,		WKC_ESC),

   121

	AS(VK_PAUSE, WKC_PAUSE),

   122

	AS(VK_BACK,			WKC_BACKSPACE),

   123

	AM(VK_INSERT,VK_DELETE,WKC_INSERT, WKC_DELETE),

   124

   125

	AS(VK_SPACE,		WKC_SPACE),

   126

	AS(VK_RETURN,		WKC_RETURN),

   127

	AS(VK_TAB,			WKC_TAB),

   128

   129

	// Function keys

   130

	AM(VK_F1, VK_F12,	WKC_F1, WKC_F12),

   131

   132

	// Numeric part.

   133

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

   134

	AM(VK_NUMPAD0,VK_NUMPAD9, WKC_NUM_0, WKC_NUM_9),

   135

	AS(VK_DIVIDE,			WKC_NUM_DIV),

   136

	AS(VK_MULTIPLY,		WKC_NUM_MUL),

   137

	AS(VK_SUBTRACT,		WKC_NUM_MINUS),

   138

	AS(VK_ADD,				WKC_NUM_PLUS),

   139

	AS(VK_DECIMAL,		WKC_NUM_DECIMAL)

   140

};

   141

   142

static uint MapWindowsKey(uint sym)

   143

{

   144

	const VkMapping *map;

   145

	uint key = 0;

   146

   147

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

   148

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

   149

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

   150

			break;

   151

		}

   152

	}

   153

   154

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

   155

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

   156

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

   157

	return key;

   158

}

   159

   160

static void MakeWindow(bool full_screen);

   161

static bool AllocateDibSection(int w, int h);

   162

   163

static void ClientSizeChanged(int w, int h)

   164

{

   165

	if (_wnd.double_size) {

   166

		w /= 2;

   167

		h /= 2;

   168

	}

   169

   170

	// allocate new dib section of the new size

   171

	if (AllocateDibSection(w, h)) {

   172

		// mark all palette colors dirty

   173

		_pal_first_dirty = 0;

   174

		_pal_last_dirty = 255;

   175

		GameSizeChanged();

   176

   177

		// redraw screen

   178

		if (_wnd.running) {

   179

			_screen.dst_ptr = _wnd.buffer_bits;

   180

			UpdateWindows();

   181

		}

   182

	}

   183

}

   184

   185

extern void DoExitSave(void);

   186

   187

#ifdef _DEBUG

   188

// Keep this function here..

   189

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

   190

int RedrawScreenDebug()

   191

{

   192

	HDC dc,dc2;

   193

	static int _fooctr;

   194

	HBITMAP old_bmp;

   195

	HPALETTE old_palette;

   196

   197

	_screen.dst_ptr = _wnd.buffer_bits;

   198

	UpdateWindows();

   199

   200

	dc = GetDC(_wnd.main_wnd);

   201

	dc2 = CreateCompatibleDC(dc);

   202

   203

	old_bmp = SelectObject(dc2, _wnd.dib_sect);

   204

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

   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

	ReleaseDC(_wnd.main_wnd, dc);

   210

   211

	return _fooctr++;

   212

}

   213

#endif

   214

   215

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

   216

{

   217

	switch (msg) {

   218

	case WM_PAINT: {

   219

		PAINTSTRUCT ps;

   220

		HDC dc,dc2;

   221

		HBITMAP old_bmp;

   222

		HPALETTE old_palette;

   223

		BeginPaint(hwnd, &ps);

   224

		dc = ps.hdc;

   225

		dc2 = CreateCompatibleDC(dc);

   226

		old_bmp = SelectObject(dc2, _wnd.dib_sect);

   227

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

   228

   229

		if (_pal_last_dirty != -1) {

   230

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

   231

			_pal_last_dirty = -1;

   232

		}

   233

   234

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

   235

		SelectPalette(dc, old_palette, TRUE);

   236

		SelectObject(dc2, old_bmp);

   237

		DeleteDC(dc2);

   238

		EndPaint(hwnd, &ps);

   239

		}

   240

		return 0;

   241

   242

	case WM_PALETTECHANGED:

   243

		if ((HWND)wParam == hwnd)

   244

			return 0;

   245

		// FALL THROUGH

   246

	case WM_QUERYNEWPALETTE: {

   247

		HDC hDC = GetWindowDC(hwnd);

   248

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

   249

		UINT nChanged = RealizePalette(hDC);

   250

		SelectPalette(hDC, hOldPalette, TRUE);

   251

		ReleaseDC(hwnd, hDC);

   252

		if (nChanged)

   253

			InvalidateRect(hwnd, NULL, FALSE);

   254

		return 0;

   255

	}

   256

   257

	case WM_CLOSE:

   258

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

   259

			_exit_game = true;

   260

		} else if (_patches.autosave_on_exit) {

   261

			DoExitSave();

   262

			_exit_game = true;

   263

		} else

   264

			AskExitGame();

   265

   266

		return 0;

   267

   268

	case WM_LBUTTONDOWN:

   269

		SetCapture(hwnd);

   270

		_left_button_down = true;

   271

		return 0;

   272

   273

	case WM_LBUTTONUP:

   274

		ReleaseCapture();

   275

		_left_button_down = false;

   276

		_left_button_clicked = false;

   277

		return 0;

   278

   279

	case WM_RBUTTONDOWN:

   280

		SetCapture(hwnd);

   281

		_right_button_down = true;

   282

		_right_button_clicked = true;

   283

		return 0;

   284

   285

	case WM_RBUTTONUP:

   286

		ReleaseCapture();

   287

		_right_button_down = false;

   288

		return 0;

   289

   290

	case WM_MOUSEMOVE: {

   291

		int x = (int16)LOWORD(lParam);

   292

		int y = (int16)HIWORD(lParam);

   293

		POINT pt;

   294

   295

		if (_wnd.double_size) {

   296

			x /= 2;

   297

			y /= 2;

   298

		}

   299

   300

		if (_cursor.fix_at) {

   301

			int dx = x - _cursor.pos.x;

   302

			int dy = y - _cursor.pos.y;

   303

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

   304

				_cursor.delta.x += dx;

   305

				_cursor.delta.y += dy;

   306

   307

				pt.x = _cursor.pos.x;

   308

				pt.y = _cursor.pos.y;

   309

   310

				if (_wnd.double_size) {

   311

					pt.x *= 2;

   312

					pt.y *= 2;

   313

				}

   314

				ClientToScreen(hwnd, &pt);

   315

				SetCursorPos(pt.x, pt.y);

   316

			}

   317

		} else {

   318

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

   319

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

   320

			_cursor.pos.x = x;

   321

			_cursor.pos.y = y;

   322

			_cursor.dirty = true;

   323

		}

   324

		MyShowCursor(false);

   325

		return 0;

   326

	}

   327

   328

	case WM_KEYDOWN: {

   329

		// this is the rewritten ascii input function

   330

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

   331

		unsigned short w = 0;

   332

		int r = 0;

   333

		byte ks[256];

   334

		unsigned int scan = 0;

   335

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

   336

   337

		GetKeyboardState(ks);

   338

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

   339

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

   340

   341

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

   342

   343

		if (scancode == 41)

   344

			_pressed_key = w | WKC_BACKQUOTE << 16;

   345

   346

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

   347

			_double_size ^= 1;

   348

			_wnd.double_size = _double_size;

   349

			ClientSizeChanged(_wnd.width, _wnd.height);

   350

			MarkWholeScreenDirty();

   351

		}

   352

	} break;

   353

   354

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

   355

		switch (wParam) {

   356

		case VK_RETURN: case 0x46: /* Full Screen on ALT + ENTER/F(VK_F) */

   357

			ToggleFullScreen(!_wnd.fullscreen);

   358

			return 0;

   359

		case VK_MENU: /* Just ALT */

   360

			return 0; // do nothing

   361

		case VK_F10: /* F10, ignore activation of menu */

   362

			_pressed_key = MapWindowsKey(wParam) << 16;

   363

			return 0;

   364

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

   365

			_pressed_key = MapWindowsKey(wParam) << 16;

   366

			break;

   367

		}

   368

		break;

   369

	case WM_NCMOUSEMOVE:

   370

		MyShowCursor(true);

   371

		return 0;

   372

   373

	case WM_SIZE: {

   374

		if (wParam != SIZE_MINIMIZED) {

   375

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

   376

		}

   377

		return 0;

   378

	}

   379

	case WM_SIZING: {

   380

		RECT* r = (RECT*)lParam;

   381

		RECT r2;

   382

		int w, h;

   383

   384

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

   385

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

   386

   387

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

   388

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

   389

		if (_wnd.double_size) {

   390

			w /= 2;

   391

			h /= 2;

   392

		}

   393

		w = clamp(w, 64, MAX_SCREEN_WIDTH);

   394

		h = clamp(h, 64, MAX_SCREEN_HEIGHT);

   395

		if (_wnd.double_size) {

   396

			w *= 2;

   397

			h *= 2;

   398

		}

   399

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

   400

   401

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

   402

		w = r2.right - r2.left;

   403

		h = r2.bottom - r2.top;

   404

   405

		switch (wParam) {

   406

		case WMSZ_BOTTOM:

   407

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

   408

			break;

   409

		case WMSZ_BOTTOMLEFT:

   410

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

   411

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

   412

			break;

   413

		case WMSZ_BOTTOMRIGHT:

   414

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

   415

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

   416

			break;

   417

		case WMSZ_LEFT:

   418

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

   419

			break;

   420

		case WMSZ_RIGHT:

   421

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

   422

			break;

   423

		case WMSZ_TOP:

   424

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

   425

			break;

   426

		case WMSZ_TOPLEFT:

   427

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

   428

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

   429

			break;

   430

		case WMSZ_TOPRIGHT:

   431

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

   432

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

   433

			break;

   434

		}

   435

		return TRUE;

   436

	}

   437

   438

// needed for wheel

   439

#if !defined(WM_MOUSEWHEEL)

   440

# define WM_MOUSEWHEEL                   0x020A

   441

#endif  //WM_MOUSEWHEEL

   442

#if !defined(GET_WHEEL_DELTA_WPARAM)

   443

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

   444

#endif  //GET_WHEEL_DELTA_WPARAM

   445

   446

	case WM_MOUSEWHEEL: {

   447

		int delta = GET_WHEEL_DELTA_WPARAM(wParam);

   448

   449

		if (delta < 0) {

   450

			_cursor.wheel++;

   451

		} else if (delta > 0) {

   452

			_cursor.wheel--;

   453

		}

   454

		return 0;

   455

	}

   456

   457

	case WM_ACTIVATEAPP:

   458

		_wnd.has_focus = (bool)wParam;

   459

		break;

   460

	}

   461

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

   462

}

   463

   464

static void RegisterWndClass(void)

   465

{

   466

	static bool registered;

   467

	if (!registered) {

   468

		HINSTANCE hinst = GetModuleHandle(NULL);

   469

		WNDCLASS wnd = {

   470

			0,

   471

			WndProcGdi,

   472

			0,

   473

			0,

   474

			hinst,

   475

			LoadIcon(hinst, MAKEINTRESOURCE(100)),

   476

			LoadCursor(NULL, IDC_ARROW),

   477

			0,

   478

			0,

   479

			"OTTD"

   480

		};

   481

		registered = true;

   482

		if (!RegisterClass(&wnd))

   483

			error("RegisterClass failed");

   484

	}

   485

}

   486

   487

extern const char _openttd_revision[];

   488

   489

static void MakeWindow(bool full_screen)

   490

{

   491

	_fullscreen = full_screen;

   492

   493

	_wnd.double_size = _double_size && !full_screen;

   494

   495

	// recreate window?

   496

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

   497

		DestroyWindow(_wnd.main_wnd);

   498

		_wnd.main_wnd = 0;

   499

	}

   500

   501

	if (full_screen) {

   502

		DEVMODE settings;

   503

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

   504

		settings.dmSize = sizeof(DEVMODE);

   505

		settings.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT;

   506

   507

		if (_fullscreen_bpp) {

   508

			settings.dmBitsPerPel = _fullscreen_bpp;

   509

			settings.dmFields |= DM_BITSPERPEL;

   510

		}

   511

		settings.dmPelsWidth = _wnd.width_org;

   512