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;

    23

	int height;

    24

	int width_org;

    25

	int height_org;

    26

	bool fullscreen;

    27

	bool double_size;

    28

	bool has_focus;

    29

	bool running;

    30

} _wnd;

    31

    32

bool _force_full_redraw;

    33

bool _double_size;

    34

bool _window_maximize;

    35

uint _display_hz;

    36

uint _fullscreen_bpp;

    37

    38

static void MakePalette(void)

    39

{

    40

	LOGPALETTE *pal;

    41

	uint i;

    42

    43

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

    44

    45

	pal->palVersion = 0x300;

    46

	pal->palNumEntries = 256;

    47

    48

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

    49

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

    50

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

    51

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

    52

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

    53

    54

	}

    55

	_wnd.gdi_palette = CreatePalette(pal);

    56

	if (_wnd.gdi_palette == NULL) 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

static const VkMapping _vk_mapping[] = {

    84

	// Pageup stuff + up/down

    85

	AM(VK_PRIOR,VK_DOWN, WKC_PAGEUP, WKC_DOWN),

    86

	// Map letters & digits

    87

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

    88

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

    89

    90

	AS(VK_ESCAPE,   WKC_ESC),

    91

	AS(VK_PAUSE,    WKC_PAUSE),

    92

	AS(VK_BACK,     WKC_BACKSPACE),

    93

	AM(VK_INSERT,   VK_DELETE, WKC_INSERT, WKC_DELETE),

    94

    95

	AS(VK_SPACE,    WKC_SPACE),

    96

	AS(VK_RETURN,   WKC_RETURN),

    97

	AS(VK_TAB,      WKC_TAB),

    98

    99

	// Function keys

   100

	AM(VK_F1, VK_F12, WKC_F1, WKC_F12),

   101

   102

	// Numeric part.

   103

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

   104

	AM(VK_NUMPAD0, VK_NUMPAD9, WKC_NUM_0, WKC_NUM_9),

   105

	AS(VK_DIVIDE,   WKC_NUM_DIV),

   106

	AS(VK_MULTIPLY, WKC_NUM_MUL),

   107

	AS(VK_SUBTRACT, WKC_NUM_MINUS),

   108

	AS(VK_ADD,      WKC_NUM_PLUS),

   109

	AS(VK_DECIMAL,  WKC_NUM_DECIMAL)

   110

};

   111

   112

static uint MapWindowsKey(uint sym)

   113

{

   114

	const VkMapping *map;

   115

	uint key = 0;

   116

   117

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

   118

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

   119

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

   120

			break;

   121

		}

   122

	}

   123

   124

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

   125

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

   126

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

   127

	return key;

   128

}

   129

   130

static bool AllocateDibSection(int w, int h);

   131

   132

static void ClientSizeChanged(int w, int h)

   133

{

   134

	if (_wnd.double_size) {

   135

		w /= 2;

   136

		h /= 2;

   137

	}

   138

   139

	// allocate new dib section of the new size

   140

	if (AllocateDibSection(w, h)) {

   141

		// mark all palette colors dirty

   142

		_pal_first_dirty = 0;

   143

		_pal_last_dirty = 255;

   144

		GameSizeChanged();

   145

   146

		// redraw screen

   147

		if (_wnd.running) {

   148

			_screen.dst_ptr = _wnd.buffer_bits;

   149

			UpdateWindows();

   150

		}

   151

	}

   152

}

   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

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

   183

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

   184

#define WM_MOUSEENTER WM_USER + 1

   185

#if !defined(WM_MOUSELEAVE)

   186

#define WM_MOUSELEAVE 0x02A3

   187

#endif

   188

#define TID_POLLMOUSE 1

   189

#define MOUSE_POLL_DELAY 75

   190

   191

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

   192

{

   193

	RECT rc;

   194

	POINT pt;

   195

   196

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

   197

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

   198

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

   199

	GetClientRect(hwnd, &rc);

   200

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

   201

	GetCursorPos(&pt);

   202

   203

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

   204

		KillTimer(hwnd, event);

   205

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

   206

	}

   207

}

   208

   209

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

   210

{

   211

	switch (msg) {

   212

		case WM_CREATE:

   213

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

   214

			break;

   215

   216

		case WM_PAINT: {

   217

			PAINTSTRUCT ps;

   218

			HDC dc,dc2;

   219

			HBITMAP old_bmp;

   220

			HPALETTE old_palette;

   221

   222

			BeginPaint(hwnd, &ps);

   223

			dc = ps.hdc;

   224

			dc2 = CreateCompatibleDC(dc);

   225

			old_bmp = SelectObject(dc2, _wnd.dib_sect);

   226

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

   227

   228

			if (_pal_last_dirty != -1) {

   229

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

   230

				_pal_last_dirty = -1;

   231

			}

   232

   233

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

   234

			SelectPalette(dc, old_palette, TRUE);

   235

			SelectObject(dc2, old_bmp);

   236

			DeleteDC(dc2);

   237

			EndPaint(hwnd, &ps);

   238

			return 0;

   239

		}

   240

   241

		case WM_PALETTECHANGED:

   242

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

   243

			/* FALLTHROUGH */

   244

   245

		case WM_QUERYNEWPALETTE: {

   246

			HDC hDC = GetWindowDC(hwnd);

   247

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

   248

			UINT nChanged = RealizePalette(hDC);

   249

   250

			SelectPalette(hDC, hOldPalette, TRUE);

   251

			ReleaseDC(hwnd, hDC);

   252

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

   253

			return 0;

   254

		}

   255

   256

		case WM_CLOSE:

   257

			HandleExitGameRequest();

   258

			_window_maximize = IsZoomed(_wnd.main_wnd);

   259

			return 0;

   260

   261

		case WM_LBUTTONDOWN:

   262

			SetCapture(hwnd);

   263

			_left_button_down = true;

   264

			return 0;

   265

   266

		case WM_LBUTTONUP:

   267

			ReleaseCapture();

   268

			_left_button_down = false;

   269

			_left_button_clicked = false;

   270

			return 0;

   271

   272

		case WM_RBUTTONDOWN:

   273

			SetCapture(hwnd);

   274

			_right_button_down = true;

   275

			_right_button_clicked = true;

   276

			return 0;

   277

   278

		case WM_RBUTTONUP:

   279

			ReleaseCapture();

   280

			_right_button_down = false;

   281

			return 0;

   282

   283

		case WM_MOUSEENTER:

   284

			_cursor.in_window = true;

   285

			DrawMouseCursor();

   286

			break;

   287

   288

		case WM_MOUSELEAVE:

   289

			UndrawMouseCursor();

   290

			_cursor.in_window = false;

   291

			break;

   292

   293

		case WM_MOUSEMOVE: {

   294

			int x = (int16)LOWORD(lParam);

   295

			int y = (int16)HIWORD(lParam);

   296

			POINT pt;

   297

   298

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

   299

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

   300

			 * tracking the mouse for exiting the window */

   301

			if (!_cursor.in_window) {

   302

				_cursor.in_window = true;

   303

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

   304

   305

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

   306

			}

   307

   308

			if (_wnd.double_size) {

   309

				x /= 2;

   310

				y /= 2;

   311

			}

   312

   313

			if (_cursor.fix_at) {

   314

				int dx = x - _cursor.pos.x;

   315

				int dy = y - _cursor.pos.y;

   316

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

   317

					_cursor.delta.x += dx;

   318

					_cursor.delta.y += dy;

   319

   320

					pt.x = _cursor.pos.x;

   321

					pt.y = _cursor.pos.y;

   322

   323

					if (_wnd.double_size) {

   324

						pt.x *= 2;

   325

						pt.y *= 2;

   326

					}

   327

					ClientToScreen(hwnd, &pt);

   328

					SetCursorPos(pt.x, pt.y);

   329

				}

   330

			} else {

   331

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

   332

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

   333

				_cursor.pos.x = x;

   334

				_cursor.pos.y = y;

   335

				_cursor.dirty = true;

   336

			}

   337

			MyShowCursor(false);

   338

			return 0;

   339

		}

   340

   341

		case WM_KEYDOWN: {

   342

			// this is the rewritten ascii input function

   343

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

   344

			WORD w = 0;

   345

			byte ks[256];

   346

			uint scancode;

   347

   348

			GetKeyboardState(ks);

   349

			if (ToAscii(wParam, 0, ks, &w, 0) == 0) {

   350

				w = 0; // no translation was possible

   351

			}

   352

   353

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

   354

   355

			scancode = GB(lParam, 16, 8);

   356

			if (scancode == 41) _pressed_key = w | WKC_BACKQUOTE << 16;

   357

   358

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

   359

				_double_size ^= 1;

   360

				_wnd.double_size = _double_size;

   361

				ClientSizeChanged(_wnd.width, _wnd.height);

   362

				MarkWholeScreenDirty();

   363

			}

   364

			break;

   365

		}

   366

   367

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

   368

			switch (wParam) {

   369

				case VK_RETURN:

   370

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

   371

					ToggleFullScreen(!_wnd.fullscreen);

   372

					return 0;

   373

   374

				case VK_MENU: /* Just ALT */

   375

					return 0; // do nothing

   376

   377

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

   378

					_pressed_key = MapWindowsKey(wParam) << 16;

   379

					return 0;

   380

   381

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

   382

					_pressed_key = MapWindowsKey(wParam) << 16;

   383

					break;

   384

			}

   385

			break;

   386

   387

		case WM_NCMOUSEMOVE:

   388

			MyShowCursor(true);

   389

			return 0;

   390

   391

		case WM_SIZE:

   392

			if (wParam != SIZE_MINIMIZED) {

   393

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

   394

			}

   395

			return 0;

   396

   397

		case WM_SIZING: {

   398

			RECT* r = (RECT*)lParam;

   399

			RECT r2;

   400

			int w, h;

   401

   402

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

   403

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

   404

   405

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

   406

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

   407

			if (_wnd.double_size) {

   408

				w /= 2;

   409

				h /= 2;

   410

			}

   411

			w = clamp(w, 64, MAX_SCREEN_WIDTH);

   412

			h = clamp(h, 64, MAX_SCREEN_HEIGHT);

   413

			if (_wnd.double_size) {

   414

				w *= 2;

   415

				h *= 2;

   416

			}

   417

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

   418

   419

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

   420

			w = r2.right - r2.left;

   421

			h = r2.bottom - r2.top;

   422

   423

			switch (wParam) {

   424

				case WMSZ_BOTTOM:

   425

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

   426

					break;

   427

   428

				case WMSZ_BOTTOMLEFT:

   429

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

   430

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

   431

					break;

   432

   433

				case WMSZ_BOTTOMRIGHT:

   434

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

   435

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

   436

					break;

   437

   438

				case WMSZ_LEFT:

   439

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

   440

					break;

   441

   442

				case WMSZ_RIGHT:

   443

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

   444

					break;

   445

   446

				case WMSZ_TOP:

   447

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

   448

					break;

   449

   450

				case WMSZ_TOPLEFT:

   451

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

   452

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

   453

					break;

   454

   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 = false;

   492

   493

	if (!registered) {

   494

		HINSTANCE hinst = GetModuleHandle(NULL);

   495

		WNDCLASS wnd = {

   496

			0,

   497

			WndProcGdi,

   498

			0,

   499

			0,

   500

			hinst,

   501

			LoadIcon(hinst, MAKEINTRESOURCE(100)),

   502

			LoadCursor(NULL, IDC_ARROW),

   503

			0,

   504

			0,

   505