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

static struct {

    27

	byte layout_set;

    28

	byte numtracks;

    29

	byte platlength;

    30

	bool dragdrop;

    31

    32

	bool newstations;

    33

	bool newstation_selected;

    34

	FSMportsClassIDByte fsmports_class;

    35

	byte station_type;

    36

	byte station_count;

    37

	byte direction;

    38

} _airport;

    39

    40

static byte _selected_airport_type = 0;

    41

    42

static void ShowBuildAirportPicker();

    43

    44

    45

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

    46

{

    47

	if (success) {

    48

		SndPlayTileFx(SND_1F_SPLAT, tile);

    49

		ResetObjectToPlace();

    50

	}

    51

}

    52

    53

static void PlaceAirport(TileIndex tile)

    54

{

    55

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

    56

		DoCommandP(tile,

    57

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

    58

				_selected_airport_type | ((_airport.newstation_selected)? 0x80 : 0x00) | (_airport.fsmports_class << 8) | (_airport.station_type << 16), CcBuildAirport,

    59

				CMD_BUILD_AIRPORT | CMD_NO_WATER | CMD_AUTO | CMD_MSG(STR_A001_CAN_T_BUILD_AIRPORT_HERE));

    60

}

    61

    62

static void PlaceAir_DemolishArea(TileIndex tile)

    63

{

    64

	VpStartPlaceSizing(tile, VPM_X_AND_Y, DDSP_DEMOLISH_AREA);

    65

}

    66

    67

    68

enum {

    69

	ATW_AIRPORT  = 3,

    70

	ATW_DEMOLISH = 4

    71

};

    72

    73

    74

static void BuildAirClick_Airport(Window *w)

    75

{

    76

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

    77

}

    78

    79

static void BuildAirClick_Demolish(Window *w)

    80

{

    81

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

    82

}

    83

    84

    85

typedef void OnButtonClick(Window *w);

    86

static OnButtonClick * const _build_air_button_proc[] = {

    87

	BuildAirClick_Airport,

    88

	BuildAirClick_Demolish,

    89

};

    90

    91

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

    92

{

    93

	switch (e->event) {

    94

	case WE_PAINT:

    95

		DrawWindowWidgets(w);

    96

		break;

    97

    98

	case WE_CLICK:

    99

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

   100

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

   101

		break;

   102

   103

	case WE_KEYPRESS: {

   104

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

   105

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

   106

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

   107

			default: return;

   108

		}

   109

	} break;

   110

   111

	case WE_PLACE_OBJ:

   112

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

   113

		break;

   114

   115

	case WE_PLACE_DRAG:

   116

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

   117

		break;

   118

   119

	case WE_PLACE_MOUSEUP:

   120

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

   121

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

   122

		}

   123

		break;

   124

   125

	case WE_ABORT_PLACE_OBJ:

   126

		RaiseWindowButtons(w);

   127

   128

		w = FindWindowById(WC_BUILD_STATION, 0);

   129

		if (w != 0)

   130

			WP(w, def_d).close = true;

   131

		break;

   132

   133

	case WE_DESTROY:

   134

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

   135

		break;

   136

	}

   137

}

   138

   139

static const Widget _air_toolbar_widgets[] = {

   140

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

   141

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

   142

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

   143

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

   144

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

   145

{   WIDGETS_END},

   146

};

   147

   148

   149

static const WindowDesc _air_toolbar_desc = {

   150

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

   151

	WC_BUILD_TOOLBAR, WC_NONE,

   152

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_STICKY_BUTTON,

   153

	_air_toolbar_widgets,

   154

	BuildAirToolbWndProc

   155

};

   156

   157

void ShowBuildAirToolbar()

   158

{

   159

	if (!IsValidPlayer(_current_player)) return;

   160

   161

	DeleteWindowById(WC_BUILD_TOOLBAR, 0);

   162

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

   163

	if (_patches.link_terraform_toolbar) ShowTerraformToolbar(w);

   164

}

   165

   166

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

   167

{

   168

	switch (e->event) {

   169

	case WE_CREATE:

   170

		SetWindowWidgetLoweredState(w, 16, !_station_show_coverage);

   171

		SetWindowWidgetLoweredState(w, 17, _station_show_coverage);

   172

		LowerWindowWidget(w, _selected_airport_type + 7);

   173

		break;

   174

   175

	case WE_PAINT: {

   176

		bool newstations = (GetNumFSMportsClasses() != 0);

   177

		byte preview_sprite = 0xFF;

   178

		int y_offset;

   179

   180

		FSMportsSpec *fsmportspec = newstations ? GetCustomFSMportsSpec(_airport.fsmports_class, _airport.station_type) : NULL;

   181

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

   182

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

   183

			/* port not available, find new one*/

   184

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

   185

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

   186

				fsmportspec = GetCustomFSMportsSpec(_airport.fsmports_class, i);

   187

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

   188

					_airport.station_type = i;

   189

					break;

   190

				}

   191

			}

   192

		}

   193

   194

		int i; // airport enabling loop

   195

		uint32 avail_airports;

   196

		const AirportFTAClass *airport;

   197

   198

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

   199

   200

		airport = GetAirport(_selected_airport_type);

   201

   202

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

   203

		{

   204

			SetWindowWidgetDisabledState(w, 28 + j, true);

   205

			RaiseWindowWidget(w, 28 + j);

   206

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

   207

		}

   208

   209

		if (_airport.station_type != 0xFF)

   210

		{

   211

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

   212

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

   213

			SetTileSelectSize(x, y);

   214

   215

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

   216

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

   217

			{

   218

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

   219

				/* enable the permitted orientations */

   220

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

   221

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

   222

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

   223

				if (j == _airport.layout_set) {

   224

					layout_ptr++;

   225

					preview_sprite = *layout_ptr;

   226

				}

   227

			}

   228

			LowerWindowWidget(w, 28 + ((_airport.direction - 1) / 2));

   229

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

   230

   231

			_thd.airport = _airport.station_type;

   232

			_thd.airport_template = true;

   233

   234

		}

   235

   236

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

   237

		DrawWindowWidgets(w);

   238

   239

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

   240

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

   241

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

   242

		}

   243

   244

		y_offset = newstations ? 170 : 0;

   245

   246

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

   247

		// 'Coverage Area'

   248

		if (_airport.station_type != 0xFF)

   249

		{

   250

			int rad = _patches.modified_catchment ? ((_airport.newstation_selected)? fsmportspec->portFSM->catchment : airport->catchment) : 4;

   251

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

   252

			DrawStationCoverageAreaText(2, 206 + y_offset, SCT_ALL, rad);

   253

		}

   254

   255

		if (newstations) {

   256

			uint16 i;

   257

			uint y = 35;

   258

   259

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

   260

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

   261

   262

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

   263

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

   264

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

   265

					}

   266

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

   267

				} else {

   268

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

   269

				}

   270

   271

				y += 14;

   272

			}

   273

		}

   274

   275

   276

		break;

   277

	}

   278

   279

	case WE_CLICK: {

   280

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

   281

		case 7: case 8: case 9: case 10: case 11: case 12: case 13: case 14: case 15:

   282

			RaiseWindowWidget(w, _selected_airport_type + 7);

   283

			_selected_airport_type = e->we.click.widget - 7;

   284

			if (GetNumFSMportsClasses() == 0) _airport.newstation_selected = false;

   285

			LowerWindowWidget(w, _selected_airport_type + 7);

   286

			SndPlayFx(SND_15_BEEP);

   287

			SetWindowDirty(w);

   288

			break;

   289

		case 16: case 17:

   290

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

   291

			SetWindowWidgetLoweredState(w, 16, !_station_show_coverage);

   292

			SetWindowWidgetLoweredState(w, 17, _station_show_coverage);

   293

			SndPlayFx(SND_15_BEEP);

   294

			SetWindowDirty(w);

   295

			break;

   296

		case 23:

   297

		case 24:

   298

			ShowDropDownMenu(w, BuildFSMportsClassDropdown(), _airport.fsmports_class, 24, 0, 1 << FSMPORTS_CLASS_WAYP);

   299

			break;

   300

   301

		case 25: {

   302

			const FSMportsSpec *fsmportspec;

   303

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

   304

   305

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

   306

			y += w->vscroll.pos;

   307

			if (y >= _airport.station_count) return;

   308

   309

			/* Check station availability callback */

   310

			fsmportspec = GetCustomFSMportsSpec(_airport.fsmports_class, y);

   311

			if (fsmportspec != NULL &&

   312

				HASBIT(fsmportspec->callbackmask, CBM_STATION_AVAIL) &&

   313

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

   314

   315

			_airport.station_type = y;

   316

			_airport.layout_set = 0;

   317

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

   318

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

   319

			_airport.newstation_selected = true;

   320

   321

			SndPlayFx(SND_15_BEEP);

   322

			SetWindowDirty(w);

   323

			break;

   324

			}

   325

		case 28: case 29: case 30: case 31:

   326

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

   327

   328

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

   329

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

   330

			_airport.layout_set = 0;

   331

			_airport.direction = (byte)((e->we.click.widget - 28) * 2 + 1);

   332

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

   333

			{

   334

				int x = fsmportspec->size_x[j];

   335

				int y = fsmportspec->size_y[j];

   336

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

   337

				/* enable the permitted orientations */

   338

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

   339

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

   340

				if (*layout_ptr == _airport.direction) {

   341

					_airport.layout_set = j;

   342

					break;

   343

				}

   344

			}

   345

   346

			SetWindowWidgetLoweredState(w, 28, (_airport.direction == 01));

   347

			SetWindowWidgetLoweredState(w, 29, (_airport.direction == 03));

   348

			SetWindowWidgetLoweredState(w, 30, (_airport.direction == 05));

   349

			SetWindowWidgetLoweredState(w, 31, (_airport.direction == 07));

   350

			SndPlayFx(SND_15_BEEP);

   351

			SetWindowDirty(w);

   352

			break;

   353

		}

   354

	} break;

   355

   356

	case WE_DROPDOWN_SELECT: {

   357

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

   358

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

   359

			_airport.station_type  = 0;

   360

			_airport.layout_set = 0;

   361

			_airport.direction = 1;

   362

			_airport.station_count = GetNumCustomFSMports(_airport.fsmports_class);

   363

   364

			w->vscroll.count = _airport.station_count;

   365

			w->vscroll.pos   = _airport.station_type;

   366

		}

   367

   368

		SndPlayFx(SND_15_BEEP);

   369

		SetWindowDirty(w);

   370

	} break;

   371

   372

   373

	case WE_MOUSELOOP: {

   374

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

   375

			DeleteWindow(w);

   376

			return;

   377

		}

   378

   379

		CheckRedrawStationCoverage(w);

   380

	} break;

   381

   382

	case WE_DESTROY:

   383

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

   384

		break;

   385

	}

   386

}

   387

   388

static const Widget _build_airport_picker_widgets[] = {

   389

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

   390

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

   391

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

   392

{      WWT_PANEL,   RESIZE_NONE,     7,     0,   147,    53,    89, 0x0,                              STR_NULL},

   393

{      WWT_PANEL,   RESIZE_NONE,     7,     0,   147,    90,   127, 0x0,                              STR_NULL},

   394

{      WWT_PANEL,   RESIZE_NONE,     7,     0,   147,   128,   177, 0x0,                              STR_NULL},

   395

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

   396

{    WWT_TEXTBTN,   RESIZE_NONE,    14,     2,   145,    27,    38, STR_SMALL_AIRPORT,                STR_3058_SELECT_SIZE_TYPE_OF_AIRPORT},

   397

{    WWT_TEXTBTN,   RESIZE_NONE,    14,     2,   145,    65,    76, STR_CITY_AIRPORT,                 STR_3058_SELECT_SIZE_TYPE_OF_AIRPORT},

   398

{    WWT_TEXTBTN,   RESIZE_NONE,    14,     2,   145,   141,   152, STR_HELIPORT,                     STR_3058_SELECT_SIZE_TYPE_OF_AIRPORT},

   399

{    WWT_TEXTBTN,   RESIZE_NONE,    14,     2,   145,    77,    88, STR_METRO_AIRPORT ,               STR_3058_SELECT_SIZE_TYPE_OF_AIRPORT},

   400

{    WWT_TEXTBTN,   RESIZE_NONE,    14,     2,   145,   103,   114, STR_INTERNATIONAL_AIRPORT,        STR_3058_SELECT_SIZE_TYPE_OF_AIRPORT},

   401

{    WWT_TEXTBTN,   RESIZE_NONE,    14,     2,   145,    39,    50, STR_COMMUTER_AIRPORT,             STR_3058_SELECT_SIZE_TYPE_OF_AIRPORT},

   402

{    WWT_TEXTBTN,   RESIZE_NONE,    14,     2,   145,   165,   176, STR_HELIDEPOT,                    STR_3058_SELECT_SIZE_TYPE_OF_AIRPORT},

   403

{    WWT_TEXTBTN,   RESIZE_NONE,    14,     2,   145,   115,   126, STR_INTERCONTINENTAL_AIRPORT,     STR_3058_SELECT_SIZE_TYPE_OF_AIRPORT},

   404

{    WWT_TEXTBTN,   RESIZE_NONE,    14,     2,   145,   153,   164, STR_HELISTATION,                  STR_3058_SELECT_SIZE_TYPE_OF_AIRPORT},

   405

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

   406

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

   407

{      WWT_LABEL,   RESIZE_NONE,     7,     0,   147,    14,    27, STR_SMALL_AIRPORTS,               STR_NULL},

   408

{      WWT_LABEL,   RESIZE_NONE,     7,     0,   147,    52,    65, STR_LARGE_AIRPORTS,               STR_NULL},

   409

{      WWT_LABEL,   RESIZE_NONE,     7,     0,   147,    90,   103, STR_HUB_AIRPORTS,                 STR_NULL},

   410

{      WWT_LABEL,   RESIZE_NONE,     7,     0,   147,   128,   141, STR_HELIPORTS,                    STR_NULL},

   411

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

   412

{   WIDGETS_END},

   413

};

   414

   415

static const Widget _newports_build_airport_picker_widgets[] = {

   416

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

   417

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

   418

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

   419

{      WWT_PANEL,   RESIZE_NONE,     7,     0,   147,   223,   259, 0x0,                              STR_NULL},

   420

{      WWT_PANEL,   RESIZE_NONE,     7,     0,   147,   260,   297, 0x0,                              STR_NULL},

   421

{      WWT_PANEL,   RESIZE_NONE,     7,     0,   147,   298,   347, 0x0,                              STR_NULL},

   422

{      WWT_PANEL,   RESIZE_NONE,     7,     0,   147,   348,   409, 0x0,                              STR_NULL},

   423

{    WWT_TEXTBTN,   RESIZE_NONE,    14,     2,   145,   197,   208, STR_SMALL_AIRPORT,                STR_3058_SELECT_SIZE_TYPE_OF_AIRPORT},

   424

{    WWT_TEXTBTN,   RESIZE_NONE,    14,     2,   145,   235,   246, STR_CITY_AIRPORT,                 STR_3058_SELECT_SIZE_TYPE_OF_AIRPORT},

   425

{    WWT_TEXTBTN,   RESIZE_NONE,    14,     2,   145,   311,   322, STR_HELIPORT,                     STR_3058_SELECT_SIZE_TYPE_OF_AIRPORT},

   426

{    WWT_TEXTBTN,   RESIZE_NONE,    14,     2,   145,   247,   258, STR_METRO_AIRPORT ,               STR_3058_SELECT_SIZE_TYPE_OF_AIRPORT},

   427

{    WWT_TEXTBTN,   RESIZE_NONE,    14,     2,   145,   273,   284, STR_INTERNATIONAL_AIRPORT,        STR_3058_SELECT_SIZE_TYPE_OF_AIRPORT},

   428

{    WWT_TEXTBTN,   RESIZE_NONE,    14,     2,   145,   209,   220, STR_COMMUTER_AIRPORT,             STR_3058_SELECT_SIZE_TYPE_OF_AIRPORT},

   429

{    WWT_TEXTBTN,   RESIZE_NONE,    14,     2,   145,   335,   346, STR_HELIDEPOT,                    STR_3058_SELECT_SIZE_TYPE_OF_AIRPORT},

   430

{    WWT_TEXTBTN,   RESIZE_NONE,    14,     2,   145,   285,   296, STR_INTERCONTINENTAL_AIRPORT,     STR_3058_SELECT_SIZE_TYPE_OF_AIRPORT},

   431

{    WWT_TEXTBTN,   RESIZE_NONE,    14,     2,   145,   323,   334, STR_HELISTATION,                  STR_3058_SELECT_SIZE_TYPE_OF_AIRPORT},

   432

{    WWT_TEXTBTN,   RESIZE_NONE,    14,    14,    73,   361,   372, STR_02DB_OFF,                     STR_3065_DON_T_HIGHLIGHT_COVERAGE},

   433

{    WWT_TEXTBTN,   RESIZE_NONE,    14,    74,   133,   361,   372, STR_02DA_ON,                      STR_3064_HIGHLIGHT_COVERAGE_AREA},

   434

{      WWT_LABEL,   RESIZE_NONE,     7,     0,   147,   184,   197, STR_SMALL_AIRPORTS,               STR_NULL},

   435

{      WWT_LABEL,   RESIZE_NONE,     7,     0,   147,   222,   235, STR_LARGE_AIRPORTS,               STR_NULL},

   436

{      WWT_LABEL,   RESIZE_NONE,     7,     0,   147,   260,   273, STR_HUB_AIRPORTS,                 STR_NULL},

   437

{      WWT_LABEL,   RESIZE_NONE,     7,     0,   147,   298,   311, STR_HELIPORTS,                    STR_NULL},

   438

{      WWT_LABEL,   RESIZE_NONE,     7,     0,   147,   348,   361, STR_3066_COVERAGE_AREA_HIGHLIGHT, STR_NULL},

   439

/* newstations gui additions */

   440

//TODO: modify for airport specific texts

   441

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

   442

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

   443

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

   444

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

   446

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

   450

   451

   452

{   WIDGETS_END},

   453

};

   454

   455

static const WindowDesc _build_airport_desc = {

   456

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

   457

	WC_BUILD_STATION, WC_BUILD_TOOLBAR,

   458

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET,

   459

	_build_airport_picker_widgets,

   460

	BuildAirportPickerWndProc

   461

};

   462

   463

static const WindowDesc _newports_build_airport_desc = {

   464

	WDP_AUTO, WDP_AUTO, 148, 410, 148, 410,

   465

	WC_BUILD_STATION, WC_BUILD_TOOLBAR,

   466

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET,

   467

	_newports_build_airport_picker_widgets,

   468

	BuildAirportPickerWndProc

   469

};

   470

   471

static void ShowBuildAirportPicker()

   472

{

   473

	Window *w;

   474

	if (GetNumFSMportsClasses() == 0) {

   475

		w = AllocateWindowDesc(&_build_airport_desc);

   476

		_airport.station_type = 0;

   477

		_airport.newstations = false;

   478

	} else

   479

	{

   480

		w = AllocateWindowDesc(&_newports_build_airport_desc);

   481

		_airport.station_type = 0;

   482

		_airport.layout_set = 0;

   483

		_airport.direction = 1;

   484

		_airport.newstation_selected = true;

   485

		_airport.newstations = true;

   486

		_airport.station_count = GetNumCustomFSMports(_airport.fsmports_class);

   487

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

   488

		//	_airport.station_type = 0;

   489

		//}

   490