1

/* $Id$ */

     2

     3

/** @file airport_gui.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "table/sprites.h"

     8

#include "table/strings.h"

     9

#include "functions.h"

    10

#include "map.h"

    11

#include "window.h"

    12

#include "gui.h"

    13

#include "viewport.h"

    14

#include "gfx.h"

    15

#include "sound.h"

    16

#include "command.h"

    17

#include "vehicle.h"

    18

#include "station.h"

    19

#include "airport.h"

    20

#include "depot.h"

    21

#include "strings.h"

    22

#include "newgrf_callbacks.h"

    23

    24

//TODO: remove station.h once converted to newgrf airports. stations just used as temporary loader

    25

#include "station.h"

    26

    27

static struct {

    28

	byte layout_set;

    29

	byte numtracks;

    30

	byte platlength;

    31

	bool dragdrop;

    32

    33

	FSMportsClassIDByte fsmports_class;

    34

	byte station_type;

    35

	byte station_count;

    36

	DirectionByte direction;

    37

} _airport;

    38

    39

static void ShowBuildAirportPicker();

    40

    41

    42

void CcBuildAirport(bool success, TileIndex tile, uint32 p1, uint32 p2)

    43

{

    44

	if (success) {

    45

		SndPlayTileFx(SND_1F_SPLAT, tile);

    46

		ResetObjectToPlace();

    47

	}

    48

}

    49

    50

static void PlaceAirport(TileIndex tile)

    51

{

    52

	if (_airport.station_type != 0xFF) /*0xFF represents No Airports Available to build */

    53

		DoCommandP(tile,

    54

				_airport.layout_set | (_airport.numtracks << 8) | (_airport.platlength << 16) | (_ctrl_pressed << 24),

    55

				0x80 | (_airport.fsmports_class << 8) | (_airport.station_type << 16), CcBuildAirport,

    57

}

    58

    59

static void PlaceAir_DemolishArea(TileIndex tile)

    60

{

    61

	VpStartPlaceSizing(tile, VPM_X_AND_Y, DDSP_DEMOLISH_AREA);

    62

}

    63

    64

    65

enum {

    66

	ATW_AIRPORT  = 3,

    67

	ATW_DEMOLISH = 4

    68

};

    69

    70

    71

static void BuildAirClick_Airport(Window *w)

    72

{

    73

	if (HandlePlacePushButton(w, ATW_AIRPORT, SPR_CURSOR_AIRPORT, 1, PlaceAirport)) ShowBuildAirportPicker();

    74

}

    75

    76

static void BuildAirClick_Demolish(Window *w)

    77

{

    78

	HandlePlacePushButton(w, ATW_DEMOLISH, ANIMCURSOR_DEMOLISH, 1, PlaceAir_DemolishArea);

    79

}

    80

    81

    82

typedef void OnButtonClick(Window *w);

    83

static OnButtonClick * const _build_air_button_proc[] = {

    84

	BuildAirClick_Airport,

    85

	BuildAirClick_Demolish,

    86

};

    87

    88

static void BuildAirToolbWndProc(Window *w, WindowEvent *e)

    89

{

    90

	switch (e->event) {

    91

	case WE_PAINT:

    92

		DrawWindowWidgets(w);

    93

		break;

    94

    95

	case WE_CLICK:

    96

		if (e->we.click.widget - 3 >= 0)

    97

			_build_air_button_proc[e->we.click.widget - 3](w);

    98

		break;

    99

   100

	case WE_KEYPRESS: {

   101

		switch (e->we.keypress.keycode) {

   102

			case '1': BuildAirClick_Airport(w); break;

   103

			case '2': BuildAirClick_Demolish(w); break;

   104

			default: return;

   105

		}

   106

	} break;

   107

   108

	case WE_PLACE_OBJ:

   109

		_place_proc(e->we.place.tile);

   110

		break;

   111

   112

	case WE_PLACE_DRAG:

   113

		VpSelectTilesWithMethod(e->we.place.pt.x, e->we.place.pt.y, e->we.place.select_method);

   114

		break;

   115

   116

	case WE_PLACE_MOUSEUP:

   117

		if (e->we.place.pt.x != -1 && e->we.place.select_proc == DDSP_DEMOLISH_AREA) {

   118

			DoCommandP(e->we.place.tile, e->we.place.starttile, 0, CcPlaySound10, CMD_CLEAR_AREA | CMD_MSG(STR_00B5_CAN_T_CLEAR_THIS_AREA));

   119

		}

   120

		break;

   121

   122

	case WE_ABORT_PLACE_OBJ:

   123

		RaiseWindowButtons(w);

   124

   125

		w = FindWindowById(WC_BUILD_STATION, 0);

   126

		if (w != 0)

   127

			WP(w, def_d).close = true;

   128

		break;

   129

   130

	case WE_DESTROY:

   131

		if (_patches.link_terraform_toolbar) DeleteWindowById(WC_SCEN_LAND_GEN, 0);

   132

		break;

   133

	}

   134

}

   135

   136

static const Widget _air_toolbar_widgets[] = {

   137

{   WWT_CLOSEBOX,   RESIZE_NONE,     7,     0,    10,     0,    13, STR_00C5,            STR_018B_CLOSE_WINDOW },

   138

{    WWT_CAPTION,   RESIZE_NONE,     7,    11,    51,     0,    13, STR_A000_AIRPORTS,   STR_018C_WINDOW_TITLE_DRAG_THIS },

   139

{  WWT_STICKYBOX,   RESIZE_NONE,     7,    52,    63,     0,    13, 0x0,                 STR_STICKY_BUTTON },

   140

{     WWT_IMGBTN,   RESIZE_NONE,     7,     0,    41,    14,    35, SPR_IMG_AIRPORT,     STR_A01E_BUILD_AIRPORT },

   141

{     WWT_IMGBTN,   RESIZE_NONE,     7,    42,    63,    14,    35, SPR_IMG_DYNAMITE,    STR_018D_DEMOLISH_BUILDINGS_ETC },

   142

{   WIDGETS_END},

   143

};

   144

   145

   146

static const WindowDesc _air_toolbar_desc = {

   147

	WDP_ALIGN_TBR, 22, 64, 36, 64, 36,

   148

	WC_BUILD_TOOLBAR, WC_NONE,

   149

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_STICKY_BUTTON,

   150

	_air_toolbar_widgets,

   151

	BuildAirToolbWndProc

   152

};

   153

   154

void ShowBuildAirToolbar()

   155

{

   156

	if (!IsValidPlayer(_current_player)) return;

   157

   158

	DeleteWindowById(WC_BUILD_TOOLBAR, 0);

   159

	Window *w = AllocateWindowDescFront(&_air_toolbar_desc, 0);

   160

	if (_patches.link_terraform_toolbar) ShowTerraformToolbar(w);

   161

}

   162

   163

static void BuildAirportPickerWndProc(Window *w, WindowEvent *e)

   164

{

   165

	switch (e->event) {

   166

	case WE_CREATE:

   167

		SetWindowWidgetLoweredState(w, 12, !_station_show_coverage);

   168

		SetWindowWidgetLoweredState(w, 13, _station_show_coverage);

   169

		break;

   170

   171

	case WE_PAINT: {

   172

		byte preview_sprite = 0xFF;

   173

   174

		FSMportsSpec *fsmportspec = GetCustomFSMportsSpec(_airport.fsmports_class, _airport.station_type);

   175

		/* if the port is no longer available, find one that is */

   176

		if ((fsmportspec == NULL) || (HASBIT(fsmportspec->callbackmask, CBM_STATION_AVAIL) && GetFSMportsCallback(CBID_STATION_AVAILABILITY, 0, 0, fsmportspec, NULL, INVALID_TILE) == 0)) {

   177

			/* port not available, find new one*/

   178

			_airport.station_type = 0xFF;  //set to the invalid condition to prevent any selection if nothing is available

   179

			for (uint i = 0; i < _airport.station_count; i++) {

   180

				fsmportspec = GetCustomFSMportsSpec(_airport.fsmports_class, i);

   181

				if (!HASBIT(fsmportspec->callbackmask, CBM_STATION_AVAIL) || GetFSMportsCallback(CBID_STATION_AVAILABILITY, 0, 0, fsmportspec, NULL, INVALID_TILE) != 0) {

   182

					_airport.station_type = i;

   183

					break;

   184

				}

   185

			}

   186

		}

   187

   188

		if (WP(w, def_d).close) return;

   189

   190

		for (byte j = 0; j < 4; j++) {

   191

			SetWindowWidgetDisabledState(w, 8 + j, true);

   192

			RaiseWindowWidget(w, 8 + j);

   193

			w->widget[8 + j].data = SPR_IMG_ARROW_NE_WHITE + j;  //reset arrows to white

   194

		}

   195

   196

		if (_airport.station_type != 0xFF) {

   197

			int x = fsmportspec->size_x[_airport.layout_set];

   198

			int y = fsmportspec->size_y[_airport.layout_set];

   199

			SetTileSelectSize(x, y);

   200

   201

			/* an airport is available, so read it and update screen accordingly */

   202

			for (byte j = 0; j < fsmportspec->numlayouts; j++) {

   203

				if (fsmportspec->layouts[j] == NULL) break;

   204

				/* enable the permitted orientations */

   205

				byte *layout_ptr = (byte*)alloca(x*y + 2);

   206

				memcpy(layout_ptr, fsmportspec->layouts[j], (x * y) + 2);

   207

				SetWindowWidgetDisabledState(w, 8 + GB((byte)*layout_ptr, 1, 2), false);

   208

				if (j == _airport.layout_set) {

   209

					layout_ptr++;

   210

					preview_sprite = *layout_ptr;

   211

				}

   212

			}

   213

			LowerWindowWidget(w, 8 + DirToDiagDir(_airport.direction));

   214

			w->widget[8 + DirToDiagDir(_airport.direction)].data = SPR_IMG_ARROW_NE_YELLOW + DirToDiagDir(_airport.direction);  //show in yellow

   215

   216

   217

		}

   218

   219

		SetDParam(0, GetFSMportsClassName(_airport.fsmports_class));

   220

		DrawWindowWidgets(w);

   221

   222

		// strings such as 'Size' and 'Coverage Area'

   223

		// 'Coverage Area'

   224

		if (_airport.station_type != 0xFF) {

   225

			/* draw the preview image if the station is available */

   226

			if (!HASBIT(fsmportspec->callbackmask, CBM_STATION_AVAIL) || GetFSMportsCallback(CBID_STATION_AVAILABILITY, 0, 0, fsmportspec, NULL, INVALID_TILE) != 0) {

   227

				DrawFSMportsTile(9, 106, preview_sprite, _airport.fsmports_class, _airport.station_type);

   228

			}

   229

			_thd.FSMportLayout = &fsmportspec->layouts[_airport.layout_set];  // irregular airport support

   230

			_thd.FSMportMask = NULL;

   231

			if (fsmportspec->layout_mask != NULL) _thd.FSMportMask = &fsmportspec->layout_mask[_airport.layout_set];  // irregular airport support

   232

			int rad = _patches.modified_catchment ? fsmportspec->portFSM->catchment : 4;

   233

			if (_station_show_coverage) SetTileSelectBigSize(-rad, -rad, 2 * rad, 2 * rad);

   234

			DrawStationCoverageAreaText(2, 206, SCT_ALL, rad);

   235

		} else {

   236

			/* if nothing is selectable, draw the image of the first in the non-selectable list, but grey out the preview */

   237

			fsmportspec = GetCustomFSMportsSpec(_airport.fsmports_class, 0);

   238

			byte *layout_ptr = (byte*)alloca(fsmportspec->size_x[0] * fsmportspec->size_y[0] + 2);

   239

			memcpy(layout_ptr, fsmportspec->layouts[0], (fsmportspec->size_x[0] * fsmportspec->size_y[0]) + 2);

   240

			layout_ptr++;

   241

			preview_sprite = *layout_ptr;

   242

			DrawFSMportsTile(9, 106, preview_sprite, _airport.fsmports_class, 0);

   243

			GfxFillRect(8, 106, 105, 172, (1 << PALETTE_MODIFIER_GREYOUT));

   244

			_thd.FSMportLayout = NULL;  // ensure irregular airport support disabled

   245

			_thd.FSMportMask = NULL;

   246

			SetTileSelectSize(1,1);

   247

		}

   248

   249

		for (uint16 i = w->vscroll.pos, y = 35; i < _airport.station_count && i < (uint)(w->vscroll.pos + w->vscroll.cap); i++, y += 14) {

   250

			const FSMportsSpec *fsmportspec = GetCustomFSMportsSpec(_airport.fsmports_class, i);

   251

   252

			if (fsmportspec != NULL && fsmportspec->name != 0) {

   253

				if (HASBIT(fsmportspec->callbackmask, CBM_STATION_AVAIL) && GetFSMportsCallback(CBID_STATION_AVAILABILITY, 0, 0, fsmportspec, NULL, INVALID_TILE) == 0) {

   254

					GfxFillRect(8, y - 2, 127, y + 10, (1 << PALETTE_MODIFIER_GREYOUT));

   255

				}

   256

				DrawStringTruncated(9, y, fsmportspec->name, i == _airport.station_type ? 12 : 16, 118);

   257

			} else {

   258

				DrawStringTruncated(9, y, STR_STAT_CLASS_DFLT, i == _airport.station_type ? 12 : 16, 118);

   259

			}

   260

		}

   261

   262

   263

		break;

   264

	}

   265

   266

	case WE_CLICK: {

   267

		switch (e->we.click.widget) {

   268

		case 12: case 13:

   269

			_station_show_coverage = (e->we.click.widget != 12);

   270

			SetWindowWidgetLoweredState(w, 12, !_station_show_coverage);

   271

			SetWindowWidgetLoweredState(w, 13, _station_show_coverage);

   272

			SndPlayFx(SND_15_BEEP);

   273

			SetWindowDirty(w);

   274

			break;

   275

		case 3:

   276

		case 4:

   277

			ShowDropDownMenu(w, BuildFSMportsClassDropdown(), _airport.fsmports_class, 4, 0, 0);

   278

			break;

   279

   280

		case 5: {

   281

			const FSMportsSpec *fsmportspec;

   282

			int y = (e->we.click.pt.y - 32) / 14;

   283

   284

			if (y >= w->vscroll.cap) return;

   285

			y += w->vscroll.pos;

   286

			if (y >= _airport.station_count) return;

   287

   288

			/* Check station availability callback */

   289

			fsmportspec = GetCustomFSMportsSpec(_airport.fsmports_class, y);

   290

			if (fsmportspec != NULL &&

   291

				HASBIT(fsmportspec->callbackmask, CBM_STATION_AVAIL) &&

   292

				GetFSMportsCallback(CBID_STATION_AVAILABILITY, 0, 0, fsmportspec, NULL, INVALID_TILE) == 0) return;

   293

   294

			_airport.station_type = y;

   295

			_airport.layout_set = 0;

   296

			_airport.platlength= fsmportspec->size_y[_airport.layout_set];

   297

			_airport.numtracks = fsmportspec->size_x[_airport.layout_set];

   298

   299

			SndPlayFx(SND_15_BEEP);

   300

			SetWindowDirty(w);

   301

			break;

   302

			}

   303

		case 8: case 9: case 10: case 11:

   304

			w->widget[8 + DirToDiagDir(_airport.direction)].data = SPR_IMG_ARROW_NE_WHITE + DirToDiagDir(_airport.direction);  //reset arrow to white

   305

   306

			/* find the layout_set that corresponds to the selected orientation */

   307

			FSMportsSpec *fsmportspec = GetCustomFSMportsSpec(_airport.fsmports_class, _airport.station_type);

   308

			_airport.layout_set = 0;

   309

			_airport.direction = DiagDirToDir((DiagDirection)(e->we.click.widget - 8));

   310

			for (byte j = 0; j < fsmportspec->numlayouts; j++) {

   311

				int x = fsmportspec->size_x[j];

   312

				int y = fsmportspec->size_y[j];

   313

				if (fsmportspec->layouts[j] == NULL) break;

   314

				/* enable the permitted orientations */

   315

				byte *layout_ptr = (byte*)alloca(x * y + 2);

   316

				memcpy(layout_ptr, fsmportspec->layouts[j], (x * y) + 2);

   317

				if (*layout_ptr == _airport.direction) {

   318

					_airport.layout_set = j;

   319

					break;

   320

				}

   321

			}

   322

   323

			SetWindowWidgetLoweredState(w,  8, (_airport.direction == DIR_NE));

   324

			SetWindowWidgetLoweredState(w,  9, (_airport.direction == DIR_SE));

   325

			SetWindowWidgetLoweredState(w, 10, (_airport.direction == DIR_SW));

   326

			SetWindowWidgetLoweredState(w, 11, (_airport.direction == DIR_NW));

   327

			SndPlayFx(SND_15_BEEP);

   328

			SetWindowDirty(w);

   329

			break;

   330

		}

   331

	} break;

   332

   333

	case WE_DROPDOWN_SELECT: {

   334

		if (_airport.fsmports_class != e->we.dropdown.index) {

   335

			_airport.fsmports_class = (FSMportsClassID)e->we.dropdown.index;

   336

			_airport.station_type  = 0;

   337

			_airport.layout_set = 0;

   338

			_airport.direction = DIR_NE;

   339

			_airport.station_count = GetNumCustomFSMports(_airport.fsmports_class);

   340

   341

			w->vscroll.count = _airport.station_count;

   342

			w->vscroll.pos   = _airport.station_type;

   343

		}

   344

   345

		SndPlayFx(SND_15_BEEP);

   346

		SetWindowDirty(w);

   347

	} break;

   348

   349

   350

	case WE_MOUSELOOP: {

   351

		if (WP(w, def_d).close) {

   352

			DeleteWindow(w);

   353

			return;

   354

		}

   355

   356

		CheckRedrawStationCoverage(w);

   357

	} break;

   358

   359

	case WE_DESTROY:

   360

		if (!WP(w, def_d).close) ResetObjectToPlace();

   361

		_thd.FSMportLayout = NULL;  // ensure irregular airport support disabled

   362

		_thd.FSMportMask = NULL;

   363

		break;

   364

	}

   365

}

   366

   367

static const Widget _build_airport_picker_widgets[] = {

   368

{   WWT_CLOSEBOX,   RESIZE_NONE,     7,     0,    10,     0,    13, STR_00C5,                         STR_018B_CLOSE_WINDOW},

   369

{    WWT_CAPTION,   RESIZE_NONE,     7,    11,   147,     0,    13, STR_3001_AIRPORT_SELECTION,       STR_018C_WINDOW_TITLE_DRAG_THIS},

   370

{      WWT_PANEL,   RESIZE_NONE,     7,     0,   147,    14,   239, 0x0,                              STR_NULL},

   371

{      WWT_INSET,   RESIZE_NONE,    14,     7,   140,    17,    28, STR_02BD,                         STR_SELECT_STATION_CLASS_TIP},

   372

{    WWT_TEXTBTN,   RESIZE_NONE,    14,   129,   139,    18,    27, STR_0225,                         STR_SELECT_STATION_CLASS_TIP},

   373

{     WWT_MATRIX,   RESIZE_NONE,    14,     7,   128,    32,   102, 0x501,                            STR_SELECT_STATION_TYPE_TIP},

   374

{  WWT_SCROLLBAR,   RESIZE_NONE,    14,   129,   140,    32,   102, 0x0,                              STR_0190_SCROLL_BAR_SCROLLS_LIST},

   375

{      WWT_INSET,   RESIZE_NONE,     7,     7,   107,   104,   173, 0x0,                              STR_NULL},

   376

{     WWT_IMGBTN,   RESIZE_NONE,    14,   109,   140,   104,   119, SPR_IMG_ARROW_NE_WHITE,           STR_NULL},

   377

{     WWT_IMGBTN,   RESIZE_NONE,    14,   109,   140,   122,   137, SPR_IMG_ARROW_SE_WHITE,           STR_NULL},

   378

{     WWT_IMGBTN,   RESIZE_NONE,    14,   109,   140,   140,   155, SPR_IMG_ARROW_SW_WHITE,           STR_NULL},

   379

{     WWT_IMGBTN,   RESIZE_NONE,    14,   109,   140,   158,   173, SPR_IMG_ARROW_NW_WHITE,           STR_NULL},

   380

{    WWT_TEXTBTN,   RESIZE_NONE,    14,    14,    73,   191,   202, STR_02DB_OFF,                     STR_3065_DON_T_HIGHLIGHT_COVERAGE},

   381

{    WWT_TEXTBTN,   RESIZE_NONE,    14,    74,   133,   191,   202, STR_02DA_ON,                      STR_3064_HIGHLIGHT_COVERAGE_AREA},

   382

{      WWT_LABEL,   RESIZE_NONE,     7,     0,   147,   178,   191, STR_3066_COVERAGE_AREA_HIGHLIGHT, STR_NULL},

   383

{   WIDGETS_END},

   384

};

   385

   386

static const WindowDesc _build_airport_desc = {

   387

	WDP_AUTO, WDP_AUTO, 148, 240, 148, 240,

   388

	WC_BUILD_STATION, WC_BUILD_TOOLBAR,

   389

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET,

   390

	_build_airport_picker_widgets,

   391

	BuildAirportPickerWndProc

   392

};

   393

   394

static void ShowBuildAirportPicker()

   395

{

   396

	Window *w = AllocateWindowDesc(&_build_airport_desc);

   397

	if (w == NULL) return;

   398

   399

	_airport.station_type = 0;

   400

	_airport.layout_set = 0;

   401

	_airport.direction = DIR_NE;

   402

	_airport.station_count = GetNumCustomFSMports(_airport.fsmports_class);

   403

	//if (HASBIT(fsmportspec->callbackmask, CBM_STATION_AVAIL) && GetFSMportsCallback(CBID_STATION_AVAILABILITY, 0, 0, fsmportspec, NULL, INVALID_TILE) == 0) {

   404

	//	_airport.station_type = 0;

   405

	//}

   406

   407

	w->vscroll.count = _airport.station_count;

   408

	w->vscroll.cap   = 5;

   409

	w->vscroll.pos   = clamp(_airport.station_type - 2, 0, w->vscroll.count - w->vscroll.cap);

   410

}

   411

   412

void InitializeAirportGui()

   413

{

   414

}