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 "../genworld.h"

    13

#include "win32_v.h"

    14

#include <windows.h>

    15

    16

static struct {

    17

	HWND main_wnd;

    18

	HBITMAP dib_sect;

    19

	Pixel *bitmap_bits;

    20

	Pixel *buffer_bits;

    21

	Pixel *alloced_bits;

    22

	HPALETTE gdi_palette;

    23

	int width,height;

    24

	int width_org, height_org;

    25

	bool fullscreen;

    26

	bool double_size;

    27

	bool has_focus;

    28

	bool running;

    29

} _wnd;

    30

    31

bool _force_full_redraw;

    32

bool _double_size;

    33

bool _window_maximize;

    34

uint _display_hz;

    35

uint _fullscreen_bpp;

    36

    37

static void MakePalette(void)

    38

{

    39

	LOGPALETTE *pal;

    40

	uint i;

    41

    42

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

    43

    44

	pal->palVersion = 0x300;

    45

	pal->palNumEntries = 256;

    46

    47

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

    48

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

    49

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

    50

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

    51

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

    52

    53

	}

    54

	_wnd.gdi_palette = CreatePalette(pal);

    55

	if (_wnd.gdi_palette == NULL)

    56

		error("CreatePalette failed!\n");

    57

}

    58

    59

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

    60

{

    61

	RGBQUAD rgb[256];

    62

	uint i;

    63

    64

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

    65

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

    66

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

    67

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

    68

		rgb[i].rgbReserved = 0;

    69

	}

    70

    71

	SetDIBColorTable(dc, start, count, rgb);

    72

}

    73

    74

typedef struct {

    75

	byte vk_from;

    76

	byte vk_count;

    77

	byte map_to;

    78

} VkMapping;

    79

    80

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

    81

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

    82

    83

#ifndef VK_OEM_3

    84

#define VK_OEM_3 0xC0

    85

#endif

    86

    87

static const VkMapping _vk_mapping[] = {

    88

	// Pageup stuff + up/down

    89

	AM(VK_PRIOR,VK_DOWN, WKC_PAGEUP, WKC_DOWN),

    90

	// Map letters & digits

    91

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

    92

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

    93

    94

	AS(VK_ESCAPE,		WKC_ESC),

    95

	AS(VK_PAUSE, WKC_PAUSE),

    96

	AS(VK_BACK,			WKC_BACKSPACE),

    97

	AM(VK_INSERT,VK_DELETE,WKC_INSERT, WKC_DELETE),

    98

    99

	AS(VK_SPACE,		WKC_SPACE),

   100

	AS(VK_RETURN,		WKC_RETURN),

   101

	AS(VK_TAB,			WKC_TAB),

   102

   103

	// Function keys

   104

	AM(VK_F1, VK_F12,	WKC_F1, WKC_F12),

   105

   106

	// Numeric part.

   107

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

   108

	AM(VK_NUMPAD0,VK_NUMPAD9, WKC_NUM_0, WKC_NUM_9),

   109

	AS(VK_DIVIDE,			WKC_NUM_DIV),

   110

	AS(VK_MULTIPLY,		WKC_NUM_MUL),

   111

	AS(VK_SUBTRACT,		WKC_NUM_MINUS),

   112

	AS(VK_ADD,				WKC_NUM_PLUS),

   113

	AS(VK_DECIMAL,		WKC_NUM_DECIMAL)

   114

};

   115

   116

static uint MapWindowsKey(uint sym)

   117

{

   118

	const VkMapping *map;

   119

	uint key = 0;

   120

   121

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

   122

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

   123

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

   124

			break;

   125

		}

   126

	}

   127

   128

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

   129

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

   130

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

   131

	return key;

   132

}

   133

   134

static void MakeWindow(bool full_screen);

   135

static bool AllocateDibSection(int w, int h);

   136

   137

static void ClientSizeChanged(int w, int h)

   138

{

   139

	if (_wnd.double_size) {

   140

		w /= 2;

   141

		h /= 2;

   142

	}

   143

   144

	// allocate new dib section of the new size

   145

	if (AllocateDibSection(w, h)) {

   146

		// mark all palette colors dirty

   147

		_pal_first_dirty = 0;

   148

		_pal_last_dirty = 255;

   149

		GameSizeChanged();

   150

   151

		// redraw screen

   152

		if (_wnd.running) {

   153

			_screen.dst_ptr = _wnd.buffer_bits;

   154

			UpdateWindows();

   155

		}

   156

	}

   157

}

   158

   159

extern void DoExitSave(void);

   160

   161

#ifdef _DEBUG

   162

// Keep this function here..

   163

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

   164

int RedrawScreenDebug(void)

   165

{

   166

	HDC dc,dc2;

   167

	static int _fooctr;

   168

	HBITMAP old_bmp;

   169

	HPALETTE old_palette;

   170

   171

	_screen.dst_ptr = _wnd.buffer_bits;

   172

	UpdateWindows();

   173

   174

	dc = GetDC(_wnd.main_wnd);

   175

	dc2 = CreateCompatibleDC(dc);

   176

   177

	old_bmp = SelectObject(dc2, _wnd.dib_sect);

   178

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

   179

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

   180

	SelectPalette(dc, old_palette, TRUE);

   181

	SelectObject(dc2, old_bmp);

   182

	DeleteDC(dc2);

   183

	ReleaseDC(_wnd.main_wnd, dc);

   184

   185

	return _fooctr++;

   186

}

   187

#endif

   188

   189

/* Windows 95 will not have a WM_MOUSELEAVE message, so define it if

   190

 * needed. There is no such event as WM_MOUSEENTER, we just made this up :) */

   191

#define WM_MOUSEENTER WM_USER + 1

   192

#if !defined(WM_MOUSELEAVE)

   193

#define WM_MOUSELEAVE 0x02A3

   194

#endif

   195

#define TID_POLLMOUSE 1

   196

#define MOUSE_POLL_DELAY 75

   197

   198

static void CALLBACK TrackMouseTimerProc(HWND hwnd, UINT msg, UINT event, DWORD time)

   199

{

   200

	RECT rc;

   201

	POINT pt;

   202

   203

	/* Get the rectangle of our window and translate it to screen coordinates.

   204

	 * Compare this with the current screen coordinates of the mouse and if it

   205

	 * falls outside of the area or our window we have left the window. */

   206

	GetClientRect(hwnd, &rc);

   207

	MapWindowPoints(hwnd, HWND_DESKTOP, (LPPOINT)(LPRECT)&rc, 2);

   208

	GetCursorPos(&pt);

   209

   210

	if (!PtInRect(&rc, pt) || (WindowFromPoint(pt) != hwnd)) {

   211

		KillTimer(hwnd, event);

   212

		PostMessage(hwnd, WM_MOUSELEAVE, 0, 0L);

   213

	}

   214

}

   215

   216

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

   217

{

   218

	switch (msg) {

   219

	case WM_CREATE:

   220

		SetTimer(hwnd, TID_POLLMOUSE, MOUSE_POLL_DELAY, (TIMERPROC)TrackMouseTimerProc);

   221

		break;

   222

   223

	case WM_PAINT: {

   224

		PAINTSTRUCT ps;

   225

		HDC dc,dc2;

   226

		HBITMAP old_bmp;

   227

		HPALETTE old_palette;

   228

		BeginPaint(hwnd, &ps);

   229

		dc = ps.hdc;

   230

		dc2 = CreateCompatibleDC(dc);

   231

		old_bmp = SelectObject(dc2, _wnd.dib_sect);

   232

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

   233

   234

		if (_pal_last_dirty != -1) {

   235

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

   236

			_pal_last_dirty = -1;

   237

		}

   238

   239

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

   240

		SelectPalette(dc, old_palette, TRUE);

   241

		SelectObject(dc2, old_bmp);

   242

		DeleteDC(dc2);

   243

		EndPaint(hwnd, &ps);

   244

		}

   245

		return 0;

   246

   247

	case WM_PALETTECHANGED:

   248

		if ((HWND)wParam == hwnd)

   249

			return 0;

   250

		// FALL THROUGH

   251

	case WM_QUERYNEWPALETTE: {

   252

		HDC hDC = GetWindowDC(hwnd);

   253

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

   254

		UINT nChanged = RealizePalette(hDC);

   255

		SelectPalette(hDC, hOldPalette, TRUE);

   256

		ReleaseDC(hwnd, hDC);

   257

		if (nChanged) InvalidateRect(hwnd, NULL, FALSE);

   258

		return 0;

   259

	}

   260

   261

	case WM_CLOSE:

   262

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

   263

			_exit_game = true;

   264

		} else if (_patches.autosave_on_exit) {

   265

			DoExitSave();

   266

			_exit_game = true;

   267

		} else {

   268

			AskExitGame();

   269

		}

   270

		_window_maximize = IsZoomed(_wnd.main_wnd);

   271

		return 0;

   272

   273

	case WM_LBUTTONDOWN:

   274

		SetCapture(hwnd);

   275

		_left_button_down = true;

   276

		return 0;

   277

   278

	case WM_LBUTTONUP:

   279

		ReleaseCapture();

   280

		_left_button_down = false;

   281

		_left_button_clicked = false;

   282

		return 0;

   283

   284

	case WM_RBUTTONDOWN:

   285

		SetCapture(hwnd);

   286

		_right_button_down = true;

   287

		_right_button_clicked = true;

   288

		return 0;

   289

   290

	case WM_RBUTTONUP:

   291

		ReleaseCapture();

   292

		_right_button_down = false;

   293

		return 0;

   294

   295

	case WM_MOUSEENTER:

   296

		_cursor.in_window = true;

   297

		DrawMouseCursor();

   298

		break;

   299

   300

	case WM_MOUSELEAVE:

   301

		UndrawMouseCursor();

   302

		_cursor.in_window = false;

   303

		break;

   304

   305

	case WM_MOUSEMOVE: {

   306

		int x = (int16)LOWORD(lParam);

   307

		int y = (int16)HIWORD(lParam);

   308

		POINT pt;

   309

   310

		/* If the mouse was not in the window and it has moved it means it has

   311

		 * come into the window, so send a WM_MOUSEENTER message. Also start

   312

		 * tracking the mouse for exiting the window */

   313

		if (!_cursor.in_window) {

   314

			_cursor.in_window = true;

   315

			SetTimer(hwnd, TID_POLLMOUSE, MOUSE_POLL_DELAY, (TIMERPROC)TrackMouseTimerProc);

   316

   317

			if (hwnd != GetCapture()) PostMessage(hwnd, WM_MOUSEENTER, 0, 0L);

   318

		}

   319

   320

		if (_wnd.double_size) {

   321

			x /= 2;

   322

			y /= 2;

   323

		}

   324

   325

		if (_cursor.fix_at) {

   326

			int dx = x - _cursor.pos.x;

   327

			int dy = y - _cursor.pos.y;

   328

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

   329

				_cursor.delta.x += dx;

   330

				_cursor.delta.y += dy;

   331

   332

				pt.x = _cursor.pos.x;

   333

				pt.y = _cursor.pos.y;

   334

   335

				if (_wnd.double_size) {

   336

					pt.x *= 2;

   337

					pt.y *= 2;

   338

				}

   339

				ClientToScreen(hwnd, &pt);

   340

				SetCursorPos(pt.x, pt.y);

   341

			}

   342

		} else {

   343

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

   344

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

   345

			_cursor.pos.x = x;

   346

			_cursor.pos.y = y;

   347

			_cursor.dirty = true;

   348

		}

   349

		MyShowCursor(false);

   350

		return 0;

   351

	}

   352

   353

	case WM_KEYDOWN: {

   354

		// this is the rewritten ascii input function

   355

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

   356

		unsigned short w = 0;

   357

		int r = 0;

   358

		byte ks[256];

   359

		unsigned int scan = 0;

   360

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

   361

   362

		GetKeyboardState(ks);

   363

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

   364

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

   365

   366

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

   367

   368

		if (scancode == 41)

   369

			_pressed_key = w | WKC_BACKQUOTE << 16;

   370

   371

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

   372

			_double_size ^= 1;

   373

			_wnd.double_size = _double_size;

   374

			ClientSizeChanged(_wnd.width, _wnd.height);

   375

			MarkWholeScreenDirty();

   376

		}

   377

	} break;

   378

   379

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

   380

		switch (wParam) {

   381

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

   382

			ToggleFullScreen(!_wnd.fullscreen);

   383

			return 0;

   384

		case VK_MENU: /* Just ALT */

   385

			return 0; // do nothing

   386

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

   387

			_pressed_key = MapWindowsKey(wParam) << 16;

   388

			return 0;

   389

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

   390

			_pressed_key = MapWindowsKey(wParam) << 16;

   391

			break;

   392

		}

   393

		break;

   394

	case WM_NCMOUSEMOVE:

   395

		MyShowCursor(true);

   396

		return 0;

   397

   398

	case WM_SIZE: {

   399

		if (wParam != SIZE_MINIMIZED) {

   400

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

   401

		}

   402

		return 0;

   403

	}

   404

	case WM_SIZING: {

   405

		RECT* r = (RECT*)lParam;

   406

		RECT r2;

   407

		int w, h;

   408

   409

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

   410

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

   411

   412

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

   413

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

   414

		if (_wnd.double_size) {

   415

			w /= 2;

   416

			h /= 2;

   417

		}

   418

		w = clamp(w, 64, MAX_SCREEN_WIDTH);

   419

		h = clamp(h, 64, MAX_SCREEN_HEIGHT);

   420

		if (_wnd.double_size) {

   421

			w *= 2;

   422

			h *= 2;

   423

		}

   424

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

   425

   426

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

   427

		w = r2.right - r2.left;

   428

		h = r2.bottom - r2.top;

   429

   430

		switch (wParam) {

   431

		case WMSZ_BOTTOM:

   432

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

   433

			break;

   434

		case WMSZ_BOTTOMLEFT:

   435

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

   436

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

   437

			break;

   438

		case WMSZ_BOTTOMRIGHT:

   439

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

   440

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

   441

			break;

   442

		case WMSZ_LEFT:

   443

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

   444

			break;

   445

		case WMSZ_RIGHT:

   446

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

   447

			break;

   448

		case WMSZ_TOP:

   449

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

   450

			break;

   451

		case WMSZ_TOPLEFT:

   452

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

   453

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

   454

			break;

   455

		case WMSZ_TOPRIGHT:

   456

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

   457

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

   458

			break;

   459

		}

   460

		return TRUE;

   461

	}

   462

   463

// needed for wheel

   464

#if !defined(WM_MOUSEWHEEL)

   465

# define WM_MOUSEWHEEL                   0x020A

   466

#endif  //WM_MOUSEWHEEL

   467

#if !defined(GET_WHEEL_DELTA_WPARAM)

   468

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

   469

#endif  //GET_WHEEL_DELTA_WPARAM

   470

   471

	case WM_MOUSEWHEEL: {

   472

		int delta = GET_WHEEL_DELTA_WPARAM(wParam);

   473

   474

		if (delta < 0) {

   475

			_cursor.wheel++;

   476

		} else if (delta > 0) {

   477

			_cursor.wheel--;

   478

		}

   479

		return 0;

   480

	}

   481

   482

	case WM_ACTIVATEAPP:

   483

		_wnd.has_focus = (bool)wParam;

   484

		break;

   485

	}

   486

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

   487

}

   488

   489

static void RegisterWndClass(void)

   490

{

   491

	static bool registered;

   492

	if (!registered) {

   493

		HINSTANCE hinst = GetModuleHandle(NULL);

   494

		WNDCLASS wnd = {

   495

			0,

   496

			WndProcGdi,

   497

			0,

   498

			0,

   499

			hinst,

   500

			LoadIcon(hinst, MAKEINTRESOURCE(100)),

   501

			LoadCursor(NULL, IDC_ARROW),

   502

			0,

   503

			0,

   504

			"OTTD"

   505

		};

   506

		registered = true;

   507

		if (!RegisterClass(&wnd))

   508

			error("RegisterClass failed");

   509

	}

   510

}

   511

   512

extern const char _openttd_revision[];

   513

   514

static void MakeWindow(bool full_screen)

   515

{

   516

	_fullscreen = full_screen;

   517

   518

	_wnd.double_size = _double_size && !full_screen;

   519

   520

	// recreate window?

   521

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

   522

		DestroyWindow(_wnd.main_wnd);

   523