1

/* $Id$ */

     2

     3

/** @file airport_gui.cpp The GUI for airports. */

     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 "strings_func.h"

    23

#include "settings_type.h"

    24

#include "viewport_func.h"

    25

#include "gfx_func.h"

    26

#include "widgets/dropdown_func.h"

    27

#include "order_func.h"

    28

#include "station_type.h"

    29

#include "tilehighlight_func.h"

    30

    31

#include "table/sprites.h"

    32

#include "table/strings.h"

    33

    34

static struct {

    35

	byte layout_set;

    36

	byte numtracks;

    37

	byte platlength;

    38

	bool dragdrop;

    39

    40

	FSMportsClassIDByte fsmports_class;

    41

	byte station_type;

    42

	byte station_count;

    43

	DirectionByte direction;

    44

} _airport;

    45

    46

static void ShowBuildAirportPicker(Window *parent);

    47

    48

    49

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

    50

{

    51

	if (success) {

    52

		SndPlayTileFx(SND_1F_SPLAT, tile);

    53

		ResetObjectToPlace();

    54

	}

    55

}

    56

    57

static void PlaceAirport(TileIndex tile)

    58

{

    59

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

    60

		DoCommandP(tile,

    61

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

    62

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

    63

				CMD_BUILD_AIRPORT | CMD_MSG(STR_A001_CAN_T_BUILD_AIRPORT_HERE));

    64

}

    65

    66

enum {

    67

	ATW_AIRPORT  = 3,

    68

	ATW_DEMOLISH = 4

    69

};

    70

    71

    72

static void BuildAirClick_Airport(Window *w)

    73

{

    74

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

    75

}

    76

    77

static void BuildAirClick_Demolish(Window *w)

    78

{

    79

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

    80

}

    81

    82

    83

typedef void OnButtonClick(Window *w);

    84

static OnButtonClick * const _build_air_button_proc[] = {

    85

	BuildAirClick_Airport,

    86

	BuildAirClick_Demolish,

    87

};

    88

    89

struct BuildAirToolbarWindow : Window {

    90

	BuildAirToolbarWindow(const WindowDesc *desc, WindowNumber window_number) : Window(desc, window_number)

    91

	{

    92

		this->FindWindowPlacementAndResize(desc);

    93

		if (_settings_client.gui.link_terraform_toolbar) ShowTerraformToolbar(this);

    94

	}

    95

    96

	~BuildAirToolbarWindow()

    97

	{

    98

		if (_settings_client.gui.link_terraform_toolbar) DeleteWindowById(WC_SCEN_LAND_GEN, 0);

    99

	}

   100

   101

	virtual void OnPaint()

   102

	{

   103

		this->DrawWidgets();

   104

	}

   105

   106

	virtual void OnClick(Point pt, int widget)

   107

	{

   108

		if (widget - 3 >= 0) {

   109

			_build_air_button_proc[widget - 3](this);

   110

		}

   111

	}

   112

   113

   114

	virtual EventState OnKeyPress(uint16 key, uint16 keycode)

   115

	{

   116

		switch (keycode) {

   117

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

   118

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

   119

			default: return ES_NOT_HANDLED;

   120

		}

   121

		return ES_HANDLED;

   122

	}

   123

   124

	virtual void OnPlaceObject(Point pt, TileIndex tile)

   125

	{

   126

		_place_proc(tile);

   127

	}

   128

   129

	virtual void OnPlaceDrag(ViewportPlaceMethod select_method, ViewportDragDropSelectionProcess select_proc, Point pt)

   130

	{

   131

		VpSelectTilesWithMethod(pt.x, pt.y, select_method);

   132

	}

   133

   134

	virtual void OnPlaceMouseUp(ViewportPlaceMethod select_method, ViewportDragDropSelectionProcess select_proc, Point pt, TileIndex start_tile, TileIndex end_tile)

   135

	{

   136

		if (pt.x != -1 && select_proc == DDSP_DEMOLISH_AREA) {

   137

			GUIPlaceProcDragXY(select_proc, start_tile, end_tile);

   138

		}

   139

	}

   140

   141

	virtual void OnPlaceObjectAbort()

   142

	{

   143

		this->RaiseButtons();

   144

   145

		delete FindWindowById(WC_BUILD_STATION, 0);

   146

	}

   147

};

   148

   149

static const Widget _air_toolbar_widgets[] = {

   150

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

   151

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

   152

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

   153

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

   154

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

   155

{   WIDGETS_END},

   156

};

   157

   158

   159

static const WindowDesc _air_toolbar_desc = {

   160

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

   161

	WC_BUILD_TOOLBAR, WC_NONE,

   162

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_STICKY_BUTTON,

   163

	_air_toolbar_widgets,

   164

};

   165

   166

void ShowBuildAirToolbar()

   167

{

   168

	if (!IsValidPlayer(_current_player)) return;

   169

   170

	DeleteWindowByClass(WC_BUILD_TOOLBAR);

   171

	AllocateWindowDescFront<BuildAirToolbarWindow>(&_air_toolbar_desc, TRANSPORT_AIR);

   172

}

   173

   174

class AirportPickerWindow : public PickerWindowBase {

   175

   176

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

   177

	enum BuildAirportWidgets {

   178

		BAPW_CLOSEBOX = 0,

   179

		BAPW_CAPTION,

   180

		BAPW_BACKGROUND,

   181

   182

		BAPW_NEWAP_DROPDOWN,

   183

		BAPW_NEWAP_LIST,

   184

		BAPW_NEWAP_SCROLL,

   185

   186

		BAPW_MINIPIC_PANEL,

   187

		BAPW_ORIENT_NE,

   188

		BAPW_ORIENT_SE,

   189

		BAPW_ORIENT_SW,

   190

		BAPW_ORIENT_NW,

   191

   192

		BAPW_HIGHLIGHT_OFF,

   193

		BAPW_HIGHLIGHT_ON,

   194

	};

   195

   196

public:

   197

	AirportPickerWindow(const WindowDesc *desc, Window *parent) : PickerWindowBase(desc, parent)

   198

	{

   199

		_airport.station_type = 0;

   200

		_airport.layout_set = 0;

   201

		_airport.direction = DIR_NE;

   202

		_airport.station_count = GetNumCustomFSMports(_airport.fsmports_class);

   203

   204

		if (_settings_game.economy.station_noise_level) {

   205

			ResizeWindowForWidget(this, BAPW_BACKGROUND, 0, 10);

   206

		}

   207

   208

		this->vscroll.count = _airport.station_count;

   209

		this->vscroll.cap   = 5;

   210

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

   211

   212

		this->SetWidgetLoweredState(BAPW_HIGHLIGHT_OFF, !_station_show_coverage);

   213

		this->SetWidgetLoweredState(BAPW_HIGHLIGHT_ON, _station_show_coverage);

   214

		this->FindWindowPlacementAndResize(desc);

   215

	}

   216

   217

	virtual void OnPaint()

   218

	{

   219

		byte preview_sprite = 0xFF;

   220

		uint16 y_noise_offset = 0;

   221

   222

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

   223

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

   224

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

   225

			/* port not available, find new one*/

   226

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

   227

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

   228

				fsmportspec = GetCustomFSMportsSpec(_airport.fsmports_class, i);

   229

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

   230

					_airport.station_type = i;

   231

					break;

   232

				}

   233

			}

   234

		}

   235

   236

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

   237

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

   238

			this->RaiseWidget(BAPW_ORIENT_NE + j);

   239

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

   240

		}

   241

   242

		if (_airport.station_type != 0xFF) {

   243

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

   244

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

   245

			SetTileSelectSize(x, y);

   246

   247

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

   248

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

   249

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

   250

				/* enable the permitted orientations */

   251

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

   252

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

   253

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

   254

				if (j == _airport.layout_set) {

   255

					layout_ptr++;

   256

					preview_sprite = *layout_ptr;

   257

				}

   258

			}

   259

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

   260

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

   261

		}

   262

   263

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

   264

   265

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

   266

   267

		this->DrawWidgets();

   268

   269

		/* only show the station (airport) noise, if the noise option is activated */

   270

		if (_settings_game.economy.station_noise_level) {

   271

			/* show the noise of the selected airport */

   272

			SetDParam(0, fsmportspec->portFSM->noise_level);

   273

			DrawString(2, 206, STR_STATION_NOISE, 0);

   274

			y_noise_offset = 10;

   275

		}

   276

		if (_airport.station_type != 0xFF) {

   277

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

   278

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

   279

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

   280

			}

   281

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

   282

			_thd.FSMportMask = NULL;

   283

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

   284

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

   285

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

   286

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

   287

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

   288

			int text_end = DrawStationCoverageAreaText(2, this->widget[BAPW_HIGHLIGHT_ON].bottom + 4 + y_noise_offset, SCT_ALL, rad, false);

   289

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

   290

				this->SetDirty();

   291

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

   292

				this->SetDirty();

   293

			}

   294

		} else {

   295

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

   296

			fsmportspec = GetCustomFSMportsSpec(_airport.fsmports_class, 0);

   297

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

   298

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

   299

			layout_ptr++;

   300

			preview_sprite = *layout_ptr;

   301

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

   302

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

   303

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

   304

			_thd.FSMportMask = NULL;

   305

			SetTileSelectSize(1,1);

   306

		}

   307

   308

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

   309

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

   310

   311

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

   312

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

   313

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

   314

				}

   315

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

   316

			} else {

   317

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

   318

			}

   319

		}

   320

	}

   321

   322

	virtual void OnClick(Point pt, int widget)

   323

	{

   324

		switch (widget) {

   325

			case BAPW_HIGHLIGHT_OFF: case BAPW_HIGHLIGHT_ON:

   326

				_station_show_coverage = (widget != BAPW_HIGHLIGHT_OFF);

   327

				this->SetWidgetLoweredState(BAPW_HIGHLIGHT_OFF, !_station_show_coverage);

   328

				this->SetWidgetLoweredState(BAPW_HIGHLIGHT_ON, _station_show_coverage);

   329

				SndPlayFx(SND_15_BEEP);

   330

				this->SetDirty();

   331

				break;

   332

			case BAPW_NEWAP_DROPDOWN:

   333

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

   334

				break;

   335

   336

			case BAPW_NEWAP_LIST: {

   337

				const FSMportsSpec *fsmportspec;

   338

				int y = (pt.y - 32) / 14;

   339

   340

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

   341

				y += this->vscroll.pos;

   342

				if (y >= _airport.station_count) return;

   343

   344

				/* Check station availability callback */

   345

				fsmportspec = GetCustomFSMportsSpec(_airport.fsmports_class, y);

   346

				if (fsmportspec != NULL &&

   347

					HasBit(fsmportspec->callbackmask, CBM_STATION_AVAIL) &&

   348

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

   349

   350

				_airport.station_type = y;

   351

				_airport.layout_set = 0;

   352

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

   353

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

   354

   355

				SndPlayFx(SND_15_BEEP);

   356

				this->SetDirty();

   357

				break;

   358

			}

   359

   360

			case BAPW_ORIENT_NE:

   361

			case BAPW_ORIENT_SE:

   362

			case BAPW_ORIENT_SW:

   363

			case BAPW_ORIENT_NW:

   364

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

   365

   366

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

   367

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

   368

				_airport.layout_set = 0;

   369

				_airport.direction = DiagDirToDir((DiagDirection)(widget - BAPW_ORIENT_NE));

   370

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

   371

					int x = fsmportspec->size_x[j];

   372

					int y = fsmportspec->size_y[j];

   373

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

   374

					/* enable the permitted orientations */

   375

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

   376

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

   377

					if (*layout_ptr == _airport.direction) {

   378

						_airport.layout_set = j;

   379

						break;

   380

					}

   381

				}

   382

   383

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

   384

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

   385

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

   386

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

   387

				SndPlayFx(SND_15_BEEP);

   388

				this->SetDirty();

   389

				break;

   390

		}

   391

	}

   392

   393

	virtual void OnDropdownSelect(int widget, int index)

   394

	{

   395

		if (_airport.fsmports_class != index) {

   396

			_airport.fsmports_class = (FSMportsClassID)index;

   397

			_airport.station_type  = 0;

   398

			_airport.layout_set = 0;

   399

			_airport.direction = DIR_NE;

   400

			_airport.station_count = GetNumCustomFSMports(_airport.fsmports_class);

   401

   402

			this->vscroll.count = _airport.station_count;

   403

			this->vscroll.pos   = _airport.station_type;

   404

		}

   405

   406

		SndPlayFx(SND_15_BEEP);

   407

		this->SetDirty();

   408

	}

   409

   410

   411

	virtual void OnTick()

   412

	{

   413

		CheckRedrawStationCoverage(this);

   414

	}

   415

   416

};

   417

   418

static const Widget _build_airport_picker_widgets[] = {

   419

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

   420

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

   421

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

   422

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

   423

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

   424

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

   425

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

   426

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

   427

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

   428

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

   429

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

   430

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

   431

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

   432

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

   433

{   WIDGETS_END},

   434

};

   435

   436

static const WindowDesc _build_airport_desc = {

   437

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

   438

	WC_BUILD_STATION, WC_BUILD_TOOLBAR,

   439

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET,

   440

	_build_airport_picker_widgets,

   441

};

   442

   443

static void ShowBuildAirportPicker(Window *parent)

   444

{

   445

	new AirportPickerWindow(&_build_airport_desc, parent);

   446

}

   447

   448

void InitializeAirportGui()

   449

{

   450

}