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

     9

#include "../variables.h"

    10

#include "../win32.h"

    11

#include "../window.h"

    12

#include "win32_v.h"

    13

#include <windows.h>

    14

#include <tchar.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;

    24

	int height;

    25

	int width_org;

    26

	int height_org;

    27

	bool fullscreen;

    28

	bool double_size;

    29

	bool has_focus;

    30

	bool running;

    31

} _wnd;

    32

    33

bool _force_full_redraw;

    34

bool _double_size;

    35

bool _window_maximize;

    36

uint _display_hz;

    37

uint _fullscreen_bpp;

    38

static uint16 _bck_resolution[2];

    39

#if !defined(UNICODE)

    40

uint _codepage;

    41

#endif

    42

    43

static void MakePalette()

    44

{

    45

	LOGPALETTE *pal;

    46

	uint i;

    47

    48

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

    49

    50

	pal->palVersion = 0x300;

    51

	pal->palNumEntries = 256;

    52

    53

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

    54

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

    55

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

    56

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

    57

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

    58

    59

	}

    60

	_wnd.gdi_palette = CreatePalette(pal);

    61

	if (_wnd.gdi_palette == NULL) error("CreatePalette failed!\n");

    62

}

    63

    64

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

    65

{

    66

	RGBQUAD rgb[256];

    67

	uint i;

    68

    69

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

    70

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

    71

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

    72

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

    73

		rgb[i].rgbReserved = 0;

    74

	}

    75

    76

	SetDIBColorTable(dc, start, count, rgb);

    77

}

    78

    79

struct VkMapping {

    80

	byte vk_from;

    81

	byte vk_count;

    82

	byte map_to;

    83

};

    84

    85

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

    86

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

    87

    88

static const VkMapping _vk_mapping[] = {

    89

	// Pageup stuff + up/down

    90

	AM(VK_PRIOR,VK_DOWN, WKC_PAGEUP, WKC_DOWN),

    91

	// Map letters & digits

    92

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

    93

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

    94

    95

	AS(VK_ESCAPE,   WKC_ESC),

    96

	AS(VK_PAUSE,    WKC_PAUSE),

    97

	AS(VK_BACK,     WKC_BACKSPACE),

    98

	AM(VK_INSERT,   VK_DELETE, WKC_INSERT, WKC_DELETE),

    99

   100

	AS(VK_SPACE,    WKC_SPACE),

   101

	AS(VK_RETURN,   WKC_RETURN),

   102

	AS(VK_TAB,      WKC_TAB),

   103

   104

	// Function keys

   105

	AM(VK_F1, VK_F12, WKC_F1, WKC_F12),

   106

   107

	// Numeric part.

   108

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

   109

	AM(VK_NUMPAD0, VK_NUMPAD9, WKC_NUM_0, WKC_NUM_9),

   110

	AS(VK_DIVIDE,   WKC_NUM_DIV),

   111

	AS(VK_MULTIPLY, WKC_NUM_MUL),

   112

	AS(VK_SUBTRACT, WKC_NUM_MINUS),

   113

	AS(VK_ADD,      WKC_NUM_PLUS),

   114

	AS(VK_DECIMAL,  WKC_NUM_DECIMAL)

   115

};

   116

   117

static uint MapWindowsKey(uint sym)

   118

{

   119

	const VkMapping *map;

   120

	uint key = 0;

   121

   122

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

   123

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

   124

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

   125

			break;

   126

		}

   127

	}

   128

   129

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

   130

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

   131

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

   132

	return key;

   133

}

   134

   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

#ifdef _DEBUG

   160

// Keep this function here..

   161

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

   162

int RedrawScreenDebug()

   163

{

   164

	HDC dc,dc2;

   165

	static int _fooctr;

   166

	HBITMAP old_bmp;

   167

	HPALETTE old_palette;

   168

   169

	_screen.dst_ptr = _wnd.buffer_bits;

   170

	UpdateWindows();

   171

   172

	dc = GetDC(_wnd.main_wnd);

   173

	dc2 = CreateCompatibleDC(dc);

   174

   175

	old_bmp = (HBITMAP)SelectObject(dc2, _wnd.dib_sect);

   176

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

   177

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

   178

	SelectPalette(dc, old_palette, TRUE);

   179

	SelectObject(dc2, old_bmp);

   180

	DeleteDC(dc2);

   181

	ReleaseDC(_wnd.main_wnd, dc);

   182

   183

	return _fooctr++;

   184

}

   185

#endif

   186

   187

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

   188

#if !defined(WM_MOUSELEAVE)

   189

#define WM_MOUSELEAVE 0x02A3

   190

#endif

   191

#define TID_POLLMOUSE 1

   192

#define MOUSE_POLL_DELAY 75

   193

   194

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

   195

{

   196

	RECT rc;

   197

	POINT pt;

   198

   199

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

   200

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

   201

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

   202

	GetClientRect(hwnd, &rc);

   203

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

   204

	GetCursorPos(&pt);

   205

   206

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

   207

		KillTimer(hwnd, event);

   208

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

   209

	}

   210

}

   211

   212

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

   213

{

   214

	static uint32 keycode = 0;

   216

   217

	switch (msg) {

   218

		case WM_CREATE:

   219

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

   220

			break;

   221

   222

		case WM_PAINT: {

   223

			PAINTSTRUCT ps;

   224

			HDC dc,dc2;

   225

			HBITMAP old_bmp;

   226

			HPALETTE old_palette;

   227

   228

			BeginPaint(hwnd, &ps);

   229

			dc = ps.hdc;

   230

			dc2 = CreateCompatibleDC(dc);

   231

			old_bmp = (HBITMAP)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

			return 0;

   245

		}

   246

   247

		case WM_PALETTECHANGED:

   248

			if ((HWND)wParam == hwnd) return 0;

   249

			/* FALLTHROUGH */

   250

   251

		case WM_QUERYNEWPALETTE: {

   252

			HDC hDC = GetWindowDC(hwnd);

   253

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

   254

			UINT nChanged = RealizePalette(hDC);

   255

   256

			SelectPalette(hDC, hOldPalette, TRUE);

   257

			ReleaseDC(hwnd, hDC);

   258

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

   259

			return 0;

   260

		}

   261

   262

		case WM_CLOSE:

   263

			HandleExitGameRequest();

   264

			return 0;

   265

   266

		case WM_DESTROY:

   267

			if (_window_maximize) {

   268

				_cur_resolution[0] = _bck_resolution[0];

   269

				_cur_resolution[1] = _bck_resolution[1];

   270

			}

   271

			return 0;

   272

   273

		case WM_LBUTTONDOWN:

   274

			SetCapture(hwnd);

   275

			_left_button_down = true;

   276

			HandleMouseEvents();

   277

			return 0;

   278

   279

		case WM_LBUTTONUP:

   280

			ReleaseCapture();

   281

			_left_button_down = false;

   282

			_left_button_clicked = false;

   283

			HandleMouseEvents();

   284

			return 0;

   285

   286

		case WM_RBUTTONDOWN:

   287

			SetCapture(hwnd);

   288

			_right_button_down = true;

   289

			_right_button_clicked = true;

   290

			HandleMouseEvents();

   291

			return 0;

   292

   293

		case WM_RBUTTONUP:

   294

			ReleaseCapture();

   295

			_right_button_down = false;

   296

			HandleMouseEvents();

   297

			return 0;

   298

   299

		case WM_MOUSELEAVE:

   300

			UndrawMouseCursor();

   301

			_cursor.in_window = false;

   302

   303

			if (!_left_button_down && !_right_button_down) MyShowCursor(true);

   304

			HandleMouseEvents();

   305

			return 0;

   306

   307

		case WM_MOUSEMOVE: {

   308

			int x = (int16)LOWORD(lParam);

   309

			int y = (int16)HIWORD(lParam);

   310

			POINT pt;

   311

   312

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

   313

			 * come into the window, so start drawing the mouse. Also start

   314

			 * tracking the mouse for exiting the window */

   315

			if (!_cursor.in_window) {

   316

				_cursor.in_window = true;

   317

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

   318

   319

				DrawMouseCursor();

   320

			}

   321

   322

			if (_wnd.double_size) {

   323

				x /= 2;

   324

				y /= 2;

   325

			}

   326

   327

			if (_cursor.fix_at) {

   328

				int dx = x - _cursor.pos.x;

   329

				int dy = y - _cursor.pos.y;

   330

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

   331

					_cursor.delta.x += dx;

   332

					_cursor.delta.y += dy;

   333

   334

					pt.x = _cursor.pos.x;

   335

					pt.y = _cursor.pos.y;

   336

   337

					if (_wnd.double_size) {

   338

						pt.x *= 2;

   339

						pt.y *= 2;

   340

					}

   341

					ClientToScreen(hwnd, &pt);

   342

					SetCursorPos(pt.x, pt.y);

   343

				}

   344

			} else {

   345

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

   346

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

   347

				_cursor.pos.x = x;

   348

				_cursor.pos.y = y;

   349

				_cursor.dirty = true;

   350

			}

   351

			MyShowCursor(false);

   352

			HandleMouseEvents();

   353

			return 0;

   354

		}

   355

   356

#if !defined(UNICODE)

   357

		case WM_INPUTLANGCHANGE: {

   358

			TCHAR locale[6];

   359

			LCID lcid = GB(lParam, 0, 16);

   360

   361

			int len = GetLocaleInfo(lcid, LOCALE_IDEFAULTANSICODEPAGE, locale, lengthof(locale));

   362

			if (len != 0) _codepage = _ttoi(locale);

   363

			return 1;

   364

		}

   365

#endif /* UNICODE */

   366

   371

		case WM_CHAR: {

   372

			/* Silently drop all non-text messages as those were handled by WM_KEYDOWN */

   373

			if (wParam < VK_SPACE) return 0;

   374

			uint scancode = GB(lParam, 16, 8);

   375

			uint charcode = wParam;

   376

   384

#if !defined(UNICODE)

   385

			wchar_t w;

   386

			int len = MultiByteToWideChar(_codepage, 0, (char*)&charcode, 1, &w, 1);

   387

			charcode = len == 1 ? w : 0;

   388

#endif /* UNICODE */

   389

   390

			/* No matter the keyboard layout, we will map the '~' to the console */

   391

			scancode = scancode == 41 ? (int)WKC_BACKQUOTE : keycode;

   392

			HandleKeypress(GB(charcode, 0, 16) | (scancode << 16));

   393

			return 0;

   394

		}

   395

   396

		case WM_KEYDOWN: {

   397

			keycode = MapWindowsKey(wParam);

   398

   399

			/* Silently drop all text messages as those will be handled by WM_CHAR

   400

			 * WM_KEYDOWN only handles CTRL+ commands and special keys like VK_LEFT, etc. */

   401

			if (keycode == 0 || (keycode > WKC_PAUSE && GB(keycode, 13, 4) == 0)) return 0;

   402

   403

			if (keycode == ('D' | WKC_CTRL) && !_wnd.fullscreen) {

   404

				_double_size ^= 1;

   405

				_wnd.double_size = _double_size;

   406

				ClientSizeChanged(_wnd.width, _wnd.height);

   407

				MarkWholeScreenDirty();

   408

			}

   409

   410

			HandleKeypress(0 | (keycode << 16));

   411

			return 0;

   412

		}

   413

   414

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

   415

			switch (wParam) {

   416

				case VK_RETURN:

   417

				case 'F': /* Full Screen on ALT + ENTER/F */

   418

					ToggleFullScreen(!_wnd.fullscreen);

   419

					return 0;

   420

   421

				case VK_MENU: /* Just ALT */

   422

					return 0; // do nothing

   423

   424

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

   425

					HandleKeypress(MapWindowsKey(wParam) << 16);

   426

					return 0;

   427

   428

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

   429

					HandleKeypress(MapWindowsKey(wParam) << 16);

   430

					break;

   431

			}

   432

			break;

   433

   434

		case WM_SIZE:

   435

			if (wParam != SIZE_MINIMIZED) {

   436

				/* Set maximized flag when we maximize (obviously), but also when we

   437

				 * switched to fullscreen from a maximized state */

   438

				_window_maximize = (wParam == SIZE_MAXIMIZED || (_window_maximize && _fullscreen));

   439

				if (_window_maximize) {

   440

					_bck_resolution[0] = _cur_resolution[0];

   441

					_bck_resolution[1] = _cur_resolution[1];

   442

				}

   443

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

   444

			}

   445

			return 0;

   446

   447

#if !defined(WINCE)

   448

		case WM_SIZING: {

   449

			RECT* r = (RECT*)lParam;

   450

			RECT r2;

   451

			int w, h;

   452

   453

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

   454

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

   455

   456

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

   457

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

   458

			if (_wnd.double_size) {

   459

				w /= 2;

   460

				h /= 2;

   461

			}

   462

			w = clamp(w, 64, MAX_SCREEN_WIDTH);

   463

			h = clamp(h, 64, MAX_SCREEN_HEIGHT);

   464

			if (_wnd.double_size) {

   465

				w *= 2;

   466

				h *= 2;

   467

			}

   468

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

   469

   470

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

   471

			w = r2.right - r2.left;

   472

			h = r2.bottom - r2.top;

   473

   474

			switch (wParam) {

   475

				case WMSZ_BOTTOM:

   476

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

   477

					break;

   478

   479

				case WMSZ_BOTTOMLEFT:

   480

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

   481

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

   482

					break;

   483

   484

				case WMSZ_BOTTOMRIGHT:

   485

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

   486

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

   487

					break;

   488

   489

				case WMSZ_LEFT:

   490

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

   491

					break;

   492

   493

				case WMSZ_RIGHT: