1

/* $Id$ */

     2

     3

#include "../stdafx.h"

     4

#include "../openttd.h"

     5

#include "../functions.h"

     6

#include "../gfx.h"

     7

#include "../macros.h"

     8

#include "../network.h"

     9

#include "../variables.h"

    10

#include "../win32.h"

    11

#include "../window.h"

    12

#include "win32_v.h"

    13

#include <windows.h>

    14

    15

static struct {

    16

	HWND main_wnd;

    17

	HBITMAP dib_sect;

    18

	Pixel *bitmap_bits;

    19

	Pixel *buffer_bits;

    20

	Pixel *alloced_bits;

    21

	HPALETTE gdi_palette;

    22

	int width,height;

    23

	int width_org, height_org;

    24

	bool fullscreen;

    25

	bool double_size;

    26

	bool has_focus;

    27

	bool running;

    28

} _wnd;

    29

    30

static void MakePalette(void)

    31

{

    32

	LOGPALETTE *pal;

    33

	uint i;

    34

    35

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

    36

    37

	pal->palVersion = 0x300;

    38

	pal->palNumEntries = 256;

    39

    40

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

    41

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

    42

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

    43

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

    44

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

    45

    46

	}

    47

	_wnd.gdi_palette = CreatePalette(pal);

    48

	if (_wnd.gdi_palette == NULL)

    49

		error("CreatePalette failed!\n");

    50

}

    51

    52

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

    53

{

    54

	RGBQUAD rgb[256];

    55

	uint i;

    56

    57

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

    58

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

    59

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

    60

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

    61

		rgb[i].rgbReserved = 0;

    62

	}

    63

    64

	SetDIBColorTable(dc, start, count, rgb);

    65

}

    66

    67

typedef struct {

    68

	byte vk_from;

    69

	byte vk_count;

    70

	byte map_to;

    71

} VkMapping;

    72

    73

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

    74

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

    75

    76

#ifndef VK_OEM_3

    77

#define VK_OEM_3 0xC0

    78

#endif

    79

    80

static const VkMapping _vk_mapping[] = {

    81

	// Pageup stuff + up/down

    82

	AM(VK_PRIOR,VK_DOWN, WKC_PAGEUP, WKC_DOWN),

    83

	// Map letters & digits

    84

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

    85

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

    86

    87

	AS(VK_ESCAPE,		WKC_ESC),

    88

	AS(VK_PAUSE, WKC_PAUSE),

    89

	AS(VK_BACK,			WKC_BACKSPACE),

    90

	AM(VK_INSERT,VK_DELETE,WKC_INSERT, WKC_DELETE),

    91

    92

	AS(VK_SPACE,		WKC_SPACE),

    93

	AS(VK_RETURN,		WKC_RETURN),

    94

	AS(VK_TAB,			WKC_TAB),

    95

    96

	// Function keys

    97

	AM(VK_F1, VK_F12,	WKC_F1, WKC_F12),

    98

    99

	// Numeric part.

   100

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

   101

	AM(VK_NUMPAD0,VK_NUMPAD9, WKC_NUM_0, WKC_NUM_9),

   102

	AS(VK_DIVIDE,			WKC_NUM_DIV),

   103

	AS(VK_MULTIPLY,		WKC_NUM_MUL),

   104

	AS(VK_SUBTRACT,		WKC_NUM_MINUS),

   105

	AS(VK_ADD,				WKC_NUM_PLUS),

   106

	AS(VK_DECIMAL,		WKC_NUM_DECIMAL)

   107

};

   108

   109

static uint MapWindowsKey(uint sym)

   110

{

   111

	const VkMapping *map;

   112

	uint key = 0;

   113

   114

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

   115

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

   116

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

   117

			break;

   118

		}

   119

	}

   120

   121

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

   122

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

   123

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

   124

	return key;

   125

}

   126

   127

static void MakeWindow(bool full_screen);

   128

static bool AllocateDibSection(int w, int h);

   129

   130

static void ClientSizeChanged(int w, int h)

   131

{

   132

	if (_wnd.double_size) {

   133

		w /= 2;

   134

		h /= 2;

   135

	}

   136

   137

	// allocate new dib section of the new size

   138

	if (AllocateDibSection(w, h)) {

   139

		// mark all palette colors dirty

   140

		_pal_first_dirty = 0;

   141

		_pal_last_dirty = 255;

   142

		GameSizeChanged();

   143

   144

		// redraw screen

   145

		if (_wnd.running) {

   146

			_screen.dst_ptr = _wnd.buffer_bits;

   147

			UpdateWindows();

   148

		}

   149

	}

   150

}

   151

   152

extern void DoExitSave(void);

   153

   154

#ifdef _DEBUG

   155

// Keep this function here..

   156

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

   157

int RedrawScreenDebug(void)

   158

{

   159

	HDC dc,dc2;

   160

	static int _fooctr;

   161

	HBITMAP old_bmp;

   162

	HPALETTE old_palette;

   163

   164

	_screen.dst_ptr = _wnd.buffer_bits;

   165

	UpdateWindows();

   166

   167

	dc = GetDC(_wnd.main_wnd);

   168

	dc2 = CreateCompatibleDC(dc);

   169

   170

	old_bmp = SelectObject(dc2, _wnd.dib_sect);

   171

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

   172

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

   173

	SelectPalette(dc, old_palette, TRUE);

   174

	SelectObject(dc2, old_bmp);

   175

	DeleteDC(dc2);

   176

	ReleaseDC(_wnd.main_wnd, dc);

   177

   178

	return _fooctr++;

   179

}

   180

#endif

   181

   182

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

   183

{

   184

	switch (msg) {

   185

	case WM_PAINT: {

   186

		PAINTSTRUCT ps;

   187

		HDC dc,dc2;

   188

		HBITMAP old_bmp;

   189

		HPALETTE old_palette;

   190

		BeginPaint(hwnd, &ps);

   191

		dc = ps.hdc;

   192

		dc2 = CreateCompatibleDC(dc);

   193

		old_bmp = SelectObject(dc2, _wnd.dib_sect);

   194

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

   195

   196

		if (_pal_last_dirty != -1) {

   197

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

   198

			_pal_last_dirty = -1;

   199

		}

   200

   201

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

   202

		SelectPalette(dc, old_palette, TRUE);

   203

		SelectObject(dc2, old_bmp);

   204

		DeleteDC(dc2);

   205

		EndPaint(hwnd, &ps);

   206

		}

   207

		return 0;

   208

   209

	case WM_PALETTECHANGED:

   210

		if ((HWND)wParam == hwnd)

   211

			return 0;

   212

		// FALL THROUGH

   213

	case WM_QUERYNEWPALETTE: {

   214

		HDC hDC = GetWindowDC(hwnd);

   215

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

   216

		UINT nChanged = RealizePalette(hDC);

   217

		SelectPalette(hDC, hOldPalette, TRUE);

   218

		ReleaseDC(hwnd, hDC);

   219

		if (nChanged)

   220

			InvalidateRect(hwnd, NULL, FALSE);

   221

		return 0;

   222

	}

   223

   224

	case WM_CLOSE:

   225

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

   226

			_exit_game = true;

   227

		} else if (_patches.autosave_on_exit) {

   228

			DoExitSave();

   229

			_exit_game = true;

   230

		} else

   231

			AskExitGame();

   232

   233

		return 0;

   234

   235

	case WM_LBUTTONDOWN:

   236

		SetCapture(hwnd);

   237

		_left_button_down = true;

   238

		return 0;

   239

   240

	case WM_LBUTTONUP:

   241

		ReleaseCapture();

   242

		_left_button_down = false;

   243

		_left_button_clicked = false;

   244

		return 0;

   245

   246

	case WM_RBUTTONDOWN:

   247

		SetCapture(hwnd);

   248

		_right_button_down = true;

   249

		_right_button_clicked = true;

   250

		return 0;

   251

   252

	case WM_RBUTTONUP:

   253

		ReleaseCapture();

   254

		_right_button_down = false;

   255

		return 0;

   256

   257

	case WM_MOUSEMOVE: {

   258

		int x = (int16)LOWORD(lParam);

   259

		int y = (int16)HIWORD(lParam);

   260

		POINT pt;

   261

   262

		if (_wnd.double_size) {

   263

			x /= 2;

   264

			y /= 2;

   265

		}

   266

   267

		if (_cursor.fix_at) {

   268

			int dx = x - _cursor.pos.x;

   269

			int dy = y - _cursor.pos.y;

   270

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

   271

				_cursor.delta.x += dx;

   272

				_cursor.delta.y += dy;

   273

   274

				pt.x = _cursor.pos.x;

   275

				pt.y = _cursor.pos.y;

   276

   277

				if (_wnd.double_size) {

   278

					pt.x *= 2;

   279

					pt.y *= 2;

   280

				}

   281

				ClientToScreen(hwnd, &pt);

   282

				SetCursorPos(pt.x, pt.y);

   283

			}

   284

		} else {

   285

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

   286

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

   287

			_cursor.pos.x = x;

   288

			_cursor.pos.y = y;

   289

			_cursor.dirty = true;

   290

		}

   291

		MyShowCursor(false);

   292

		return 0;

   293

	}

   294

   295

	case WM_KEYDOWN: {

   296

		// this is the rewritten ascii input function

   297

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

   298

		unsigned short w = 0;

   299

		int r = 0;

   300

		byte ks[256];

   301

		unsigned int scan = 0;

   302

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

   303

   304

		GetKeyboardState(ks);

   305

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

   306

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

   307

   308

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

   309

   310

		if (scancode == 41)

   311

			_pressed_key = w | WKC_BACKQUOTE << 16;

   312

   313

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

   314

			_double_size ^= 1;

   315

			_wnd.double_size = _double_size;

   316

			ClientSizeChanged(_wnd.width, _wnd.height);

   317

			MarkWholeScreenDirty();

   318

		}

   319

	} break;

   320

   321

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

   322

		switch (wParam) {

   323

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

   324

			ToggleFullScreen(!_wnd.fullscreen);

   325

			return 0;

   326

		case VK_MENU: /* Just ALT */

   327

			return 0; // do nothing

   328

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

   329

			_pressed_key = MapWindowsKey(wParam) << 16;

   330

			return 0;

   331

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

   332

			_pressed_key = MapWindowsKey(wParam) << 16;

   333

			break;

   334

		}

   335

		break;

   336

	case WM_NCMOUSEMOVE:

   337

		MyShowCursor(true);

   338

		return 0;

   339

   340

	case WM_SIZE: {

   341

		if (wParam != SIZE_MINIMIZED) {

   342

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

   343

		}

   344

		return 0;

   345

	}

   346

	case WM_SIZING: {

   347

		RECT* r = (RECT*)lParam;

   348

		RECT r2;

   349

		int w, h;

   350

   351

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

   352

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

   353

   354

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

   355

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

   356

		if (_wnd.double_size) {

   357

			w /= 2;

   358

			h /= 2;

   359

		}

   360

		w = clamp(w, 64, MAX_SCREEN_WIDTH);

   361

		h = clamp(h, 64, MAX_SCREEN_HEIGHT);

   362

		if (_wnd.double_size) {

   363

			w *= 2;

   364

			h *= 2;

   365

		}

   366

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

   367

   368

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

   369

		w = r2.right - r2.left;

   370

		h = r2.bottom - r2.top;

   371

   372

		switch (wParam) {

   373

		case WMSZ_BOTTOM:

   374

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

   375

			break;

   376

		case WMSZ_BOTTOMLEFT:

   377

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

   378

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

   379

			break;

   380

		case WMSZ_BOTTOMRIGHT:

   381

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

   382

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

   383

			break;

   384

		case WMSZ_LEFT:

   385

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

   386

			break;

   387

		case WMSZ_RIGHT:

   388

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

   389

			break;

   390

		case WMSZ_TOP:

   391

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

   392

			break;

   393

		case WMSZ_TOPLEFT:

   394

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

   395

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

   396

			break;

   397

		case WMSZ_TOPRIGHT:

   398

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

   399

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

   400

			break;

   401

		}

   402

		return TRUE;

   403

	}

   404

   405

// needed for wheel

   406

#if !defined(WM_MOUSEWHEEL)

   407

# define WM_MOUSEWHEEL                   0x020A

   408

#endif  //WM_MOUSEWHEEL

   409

#if !defined(GET_WHEEL_DELTA_WPARAM)

   410

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

   411

#endif  //GET_WHEEL_DELTA_WPARAM

   412

   413

	case WM_MOUSEWHEEL: {

   414

		int delta = GET_WHEEL_DELTA_WPARAM(wParam);

   415

   416

		if (delta < 0) {

   417

			_cursor.wheel++;

   418

		} else if (delta > 0) {

   419

			_cursor.wheel--;

   420

		}

   421

		return 0;

   422

	}

   423

   424

	case WM_ACTIVATEAPP:

   425

		_wnd.has_focus = (bool)wParam;

   426

		break;

   427

	}

   428

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

   429

}

   430

   431

static void RegisterWndClass(void)

   432

{

   433

	static bool registered;

   434

	if (!registered) {

   435

		HINSTANCE hinst = GetModuleHandle(NULL);

   436

		WNDCLASS wnd = {

   437

			0,

   438

			WndProcGdi,

   439

			0,

   440

			0,

   441

			hinst,

   442

			LoadIcon(hinst, MAKEINTRESOURCE(100)),

   443

			LoadCursor(NULL, IDC_ARROW),

   444

			0,

   445

			0,

   446

			"OTTD"

   447

		};

   448

		registered = true;

   449

		if (!RegisterClass(&wnd))

   450

			error("RegisterClass failed");

   451

	}

   452

}

   453

   454

extern const char _openttd_revision[];

   455

   456

static void MakeWindow(bool full_screen)

   457

{

   458

	_fullscreen = full_screen;

   459

   460

	_wnd.double_size = _double_size && !full_screen;

   461

   462

	// recreate window?

   463

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

   464

		DestroyWindow(_wnd.main_wnd);

   465

		_wnd.main_wnd = 0;

   466

	}

   467

   468

	if (full_screen) {

   469

		DEVMODE settings;

   470

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

   471

		settings.dmSize = sizeof(DEVMODE);

   472

		settings.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT;

   473

   474

		if (_fullscreen_bpp) {

   475

			settings.dmBitsPerPel = _fullscreen_bpp;

   476

			settings.dmFields |= DM_BITSPERPEL;

   477

		}

   478

		settings.dmPelsWidth = _wnd.width_org;

   479

		settings.dmPelsHeight = _wnd.height_org;

   480

		settings.dmDisplayFrequency = _display_hz;

   481

		if (settings.dmDisplayFrequency != 0)

   482

			settings.dmFields |= DM_DISPLAYFREQUENCY;

   483

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

   484

			MakeWindow(false);

   485

			return;

   486

		}

   487

	} else if (_wnd.fullscreen) {

   488

		// restore display?

   489

		ChangeDisplaySettings(NULL, 0);

   490

	}

   491

   492

	{

   493

		RECT r;

   494

		uint style;

   495

		int x, y, w, h;

   496

   497

		_wnd.fullscreen = full_screen;

   498

		if (_wnd.fullscreen) {

   499

			style = WS_POPUP | WS_VISIBLE;

   500

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

   501

		} else {

   502

			style = WS_OVERLAPPEDWINDOW | WS_VISIBLE;

   503

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

   504

		}

   505

   506

		AdjustWindowRect(&r, style, FALSE);

   507

		w = r.right - r.left;

   508

		h = r.bottom - r.top;

   509

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

   510

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

   511