1

/* $Id$ */

     2

     3

/** @file airport_gui.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "gui.h"

     8

#include "window_gui.h"

     9

#include "player_func.h"

    10

#include "terraform_gui.h"

    11

#include "command_func.h"

    12

#include "station_gui.h"

    13

#include "station_func.h"

    14

#include "airport.h"

    15

#include "newgrf_callbacks.h"

    16

#include "sound_func.h"

    17

#include "settings_type.h"

    18

    19

#include "strings_func.h"

    20

#include "core/alloc_func.hpp"

    21

#include "window_func.h"

    22

#include "viewport_func.h"

    23

#include "gfx_func.h"

    24

#include "widgets/dropdown_func.h"

    25

#include "order_func.h"

    27

    28

#include "table/sprites.h"

    29

#include "table/strings.h"

    30

    31

static struct {

    32

	byte layout_set;

    33

	byte numtracks;

    34

	byte platlength;

    35

	bool dragdrop;

    36

    37

	FSMportsClassIDByte fsmports_class;

    38

	byte station_type;

    39

	byte station_count;

    40

	DirectionByte direction;

    41

} _airport;

    42

    43

static void ShowBuildAirportPicker();

    44

    45

    46

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

    47

{

    48

	if (success) {

    49

		SndPlayTileFx(SND_1F_SPLAT, tile);

    50

		ResetObjectToPlace();

    51

	}

    52

}

    53

    54

static void PlaceAirport(TileIndex tile)

    55

{

    56

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

    57

		DoCommandP(tile,

    58

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

    59

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

    60

				CMD_BUILD_AIRPORT | CMD_MSG(STR_A001_CAN_T_BUILD_AIRPORT_HERE));

    61

}

    62

    63

static void PlaceAir_DemolishArea(TileIndex tile)

    64

{

    65

	VpStartPlaceSizing(tile, VPM_X_AND_Y, DDSP_DEMOLISH_AREA);

    66

}

    67

    68

    69

enum {

    70

	ATW_AIRPORT  = 3,

    71

	ATW_DEMOLISH = 4

    72

};

    73

    74

    75

static void BuildAirClick_Airport(Window *w)

    76

{

    77

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

    78

}

    79

    80

static void BuildAirClick_Demolish(Window *w)

    81

{

    82

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

    83

}

    84

    85

    86

typedef void OnButtonClick(Window *w);

    87

static OnButtonClick * const _build_air_button_proc[] = {

    88

	BuildAirClick_Airport,

    89

	BuildAirClick_Demolish,

    90

};

    91

    92

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

    93

{

    94

	switch (e->event) {

    95

		case WE_PAINT:

    96

			DrawWindowWidgets(w);

    97

			break;

    98

    99

		case WE_CLICK:

   100

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

   101

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

   102

			break;

   103

   104

		case WE_KEYPRESS: {

   105

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

   106

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

   107

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

   108

				default: return;

   109

			}

   110

			break;

   111

		}

   112

   113

		case WE_PLACE_OBJ:

   114

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

   115

			break;

   116

   117

		case WE_PLACE_DRAG:

   118

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

   119

			break;

   120

   121

		case WE_PLACE_MOUSEUP:

   122

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

   123

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

   124

			}

   125

			break;

   126

   127

		case WE_ABORT_PLACE_OBJ:

   128

			w->RaiseButtons();

   129

   130

			w = FindWindowById(WC_BUILD_STATION, 0);

   131

			if (w != 0)

   132

				WP(w, def_d).close = true;

   133

			break;

   134

   135

		case WE_DESTROY:

   136

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

   137

			break;

   138

	}

   139

}

   140

   141

static const Widget _air_toolbar_widgets[] = {

   142

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

   143

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

   144

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

   145

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

   146

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

   147

{   WIDGETS_END},

   148

};

   149

   150

   151

static const WindowDesc _air_toolbar_desc = {

   152

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

   153

	WC_BUILD_TOOLBAR, WC_NONE,

   154

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_STICKY_BUTTON,

   155

	_air_toolbar_widgets,

   156

	BuildAirToolbWndProc

   157

};

   158

   159

void ShowBuildAirToolbar()

   160

{

   161

	if (!IsValidPlayer(_current_player)) return;

   162

   163

	DeleteWindowById(WC_BUILD_TOOLBAR, 0);

   164

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

   165

	if (_patches.link_terraform_toolbar) ShowTerraformToolbar(w);

   166

}

   167

   168

/** Enum referring to the widgets of the airport build window */

   169

enum BuildAirportWidgets {

   170

	BAPW_CLOSEBOX = 0,

   171

	BAPW_CAPTION,

   172

	BAPW_BACKGROUND,

   173

   174

	BAPW_NEWAP_DROPDOWN,

   175

	BAPW_NEWAP_LIST,

   176

	BAPW_NEWAP_SCROLL,

   177

   178

	BAPW_MINIPIC_PANEL,

   179

	BAPW_ORIENT_NE,

   180

	BAPW_ORIENT_SE,

   181

	BAPW_ORIENT_SW,

   182

	BAPW_ORIENT_NW,

   183

   184

	BAPW_HIGHLIGHT_OFF,

   185

	BAPW_HIGHLIGHT_ON,

   186

   187

};

   188

   189

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

   190

{

   191

	switch (e->event) {

   192

		case WE_CREATE:

   193

			w->SetWidgetLoweredState(BAPW_HIGHLIGHT_OFF, !_station_show_coverage);

   194

			w->SetWidgetLoweredState(BAPW_HIGHLIGHT_ON, _station_show_coverage);

   195

			break;

   196

   197

		case WE_PAINT: {

   198

			byte preview_sprite = 0xFF;

   199

   200

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

   201

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

   202

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

   203

				/* port not available, find new one*/

   204

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

   205

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

   206

					fsmportspec = GetCustomFSMportsSpec(_airport.fsmports_class, i);

   207

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

   208

						_airport.station_type = i;

   209

						break;

   210

					}

   211

				}

   212

			}

   213

   214

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

   215

   216

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

   217

				w->SetWidgetDisabledState(BAPW_ORIENT_NE + j, true);

   218

				w->RaiseWidget(BAPW_ORIENT_NE + j);

   219

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

   220

			}

   221

   222

			if (_airport.station_type != 0xFF) {

   223

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

   224

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

   225

				SetTileSelectSize(x, y);

   226

   227

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

   228

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

   229

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

   230

					/* enable the permitted orientations */

   231

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

   232

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

   233

					w->SetWidgetDisabledState(BAPW_ORIENT_NE + GB((byte)*layout_ptr, 1, 2), false);

   234

					if (j == _airport.layout_set) {

   235

						layout_ptr++;

   236

						preview_sprite = *layout_ptr;

   237

					}

   238

				}

   239

				w->LowerWidget(BAPW_ORIENT_NE + DirToDiagDir(_airport.direction));

   240

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

   241

			}

   242

   243

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

   244

			DrawWindowWidgets(w);

   245

   246

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

   247

   248

			if (_airport.station_type != 0xFF) {

   249

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

   250

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

   251

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

   252

				}

   253

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

   254

				_thd.FSMportMask = NULL;

   255

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

   256

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

   257

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

   258

				int text_end = DrawStationCoverageAreaText(2, 206, SCT_ALL, rad, false);

   259

				text_end = DrawStationCoverageAreaText(2, text_end + 4, SCT_ALL, rad, true) + 4;

   260

				if (text_end > w->widget[BAPW_BACKGROUND].bottom) {

   261

					SetWindowDirty(w);

   262

					ResizeWindowForWidget(w, BAPW_BACKGROUND, 0, text_end - w->widget[BAPW_BACKGROUND].bottom);

   263

					SetWindowDirty(w);

   264

				}

   265

			} else {

   266

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

   267

				fsmportspec = GetCustomFSMportsSpec(_airport.fsmports_class, 0);

   268

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

   269

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

   270

				layout_ptr++;

   271

				preview_sprite = *layout_ptr;

   272

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

   273

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

   274

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

   275

				_thd.FSMportMask = NULL;

   276

				SetTileSelectSize(1,1);

   277

			}

   278

   279

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

   280

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

   281

   282

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

   283

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

   284

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

   285

					}

   286

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

   287

				} else {

   288

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

   289

				}

   290

			}

   291

			break;

   292

		}

   293

   294

		case WE_CLICK: {

   295

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

   296

				case BAPW_HIGHLIGHT_OFF: case BAPW_HIGHLIGHT_ON:

   297

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

   298

					w->SetWidgetLoweredState(BAPW_HIGHLIGHT_OFF, !_station_show_coverage);

   299

					w->SetWidgetLoweredState(BAPW_HIGHLIGHT_ON, _station_show_coverage);

   300

					SndPlayFx(SND_15_BEEP);

   301

					SetWindowDirty(w);

   302

					break;

   303

				case BAPW_NEWAP_DROPDOWN:

   304

					ShowDropDownList(w, BuildFSMportsClassDropdown(), _airport.fsmports_class, BAPW_NEWAP_DROPDOWN);

   305

					break;

   306

   307

				case BAPW_NEWAP_LIST: {

   308

					const FSMportsSpec *fsmportspec;

   309

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

   310

   311

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

   312

					y += w->vscroll.pos;

   313

					if (y >= _airport.station_count) return;

   314

   315

					/* Check station availability callback */

   316

					fsmportspec = GetCustomFSMportsSpec(_airport.fsmports_class, y);

   317

					if (fsmportspec != NULL &&

   318

						HasBit(fsmportspec->callbackmask, CBM_STATION_AVAIL) &&

   319

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

   320

   321

					_airport.station_type = y;

   322

					_airport.layout_set = 0;

   323

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

   324

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

   325

   326

					SndPlayFx(SND_15_BEEP);

   327

					SetWindowDirty(w);

   328

					break;

   329

				}

   330

   331

				case BAPW_ORIENT_NE:

   332

				case BAPW_ORIENT_SE:

   333

				case BAPW_ORIENT_SW:

   334

				case BAPW_ORIENT_NW:

   335

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

   336

   337

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

   338

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

   339

					_airport.layout_set = 0;

   340

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

   341

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

   342

						int x = fsmportspec->size_x[j];

   343

						int y = fsmportspec->size_y[j];

   344

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

   345

						/* enable the permitted orientations */

   346

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

   347

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

   348

						if (*layout_ptr == _airport.direction) {

   349

							_airport.layout_set = j;

   350

							break;

   351

						}

   352

					}

   353

   354

					w->SetWidgetLoweredState( BAPW_ORIENT_NE, (_airport.direction == DIR_NE));

   355

					w->SetWidgetLoweredState( BAPW_ORIENT_SE, (_airport.direction == DIR_SE));

   356

					w->SetWidgetLoweredState( BAPW_ORIENT_SW, (_airport.direction == DIR_SW));

   357

					w->SetWidgetLoweredState( BAPW_ORIENT_NW, (_airport.direction == DIR_NW));

   358

					SndPlayFx(SND_15_BEEP);

   359

					SetWindowDirty(w);

   360

					break;

   361

			}

   362

			break;

   363

		}

   364

   365

		case WE_DROPDOWN_SELECT: {

   366

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

   367

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

   368

				_airport.station_type  = 0;

   369

				_airport.layout_set = 0;

   370

				_airport.direction = DIR_NE;

   371

				_airport.station_count = GetNumCustomFSMports(_airport.fsmports_class);

   372

   373

				w->vscroll.count = _airport.station_count;

   374

				w->vscroll.pos   = _airport.station_type;

   375

			}

   376

   377

			SndPlayFx(SND_15_BEEP);

   378

			SetWindowDirty(w);

   379

			break;

   380

		}

   381

   382

   383

		case WE_MOUSELOOP: {

   384

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

   385

				DeleteWindow(w);

   386

				return;

   387

			}

   388

   389

			CheckRedrawStationCoverage(w);

   390

			break;

   391

		}

   392

   393

		case WE_DESTROY:

   394

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

   395

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

   396

			_thd.FSMportMask = NULL;

   397

			break;

   398

	}

   399

}

   400

   401

static const Widget _build_airport_picker_widgets[] = {

   402

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

   403

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

   404

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

   405

{ WWT_DROPDOWNIN,   RESIZE_NONE,    14,     7,   140,    17,    28, STR_02BD,                         STR_SELECT_STATION_CLASS_TIP},        // BAPW_NEWAP_DROPDOWN

   406

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

   407

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

   408

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

   409

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

   410

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

   411

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

   412

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

   413

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

   414

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

   415

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

   416

{   WIDGETS_END},

   417

};

   418

   419

static const WindowDesc _build_airport_desc = {

   420

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

   421

	WC_BUILD_STATION, WC_BUILD_TOOLBAR,

   422

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET,

   423

	_build_airport_picker_widgets,

   424

	BuildAirportPickerWndProc

   425

};

   426

   427

static void ShowBuildAirportPicker()

   428

{

   429

	Window *w = AllocateWindowDesc(&_build_airport_desc);

   430

	if (w == NULL) return;

   431

   432

	_airport.station_type = 0;

   433

	_airport.layout_set = 0;

   434

	_airport.direction = DIR_NE;

   435

	_airport.station_count = GetNumCustomFSMports(_airport.fsmports_class);

   436

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

   437

	//	_airport.station_type = 0;

   438

	//}

   439

   440

	w->vscroll.count = _airport.station_count;

   441

	w->vscroll.cap   = 5;

   442

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

   443

}

   444

   445

void InitializeAirportGui()

   446

{

   447

}