1

/* $Id$ */

     2

     3

/** @file airport_gui.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     8

#include "window_gui.h"

    10

#include "terraform_gui.h"

    11

#include "command_func.h"

    14

#include "airport.h"

    15

#include "depot.h"

    16

#include "newgrf_callbacks.h"

    17

#include "sound_func.h"

    22

#include "window_func.h"

    23

#include "viewport_func.h"

    24

#include "gfx_func.h"

    25

#include "widgets/dropdown_func.h"

    27

    28

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

    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();

    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

static void PlaceAir_DemolishArea(TileIndex tile)

    67

{

    68

	VpStartPlaceSizing(tile, VPM_X_AND_Y, DDSP_DEMOLISH_AREA);

    69

}

    70

    71

    72

enum {

    73

	ATW_AIRPORT  = 3,

    74

	ATW_DEMOLISH = 4

    75

};

    76

    77

    78

static void BuildAirClick_Airport(Window *w)

    79

{

    80

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

    81

}

    82

    83

static void BuildAirClick_Demolish(Window *w)

    84

{

    85

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

    86

}

    87

    88

    89

typedef void OnButtonClick(Window *w);

    90

static OnButtonClick * const _build_air_button_proc[] = {

    91

	BuildAirClick_Airport,

    92

	BuildAirClick_Demolish,

    93

};

    94

    95

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

    96

{

    97

	switch (e->event) {

    98

	case WE_PAINT:

    99

		DrawWindowWidgets(w);

   100

		break;

   101

   102

	case WE_CLICK:

   103

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

   104

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

   105

		break;

   106

   107

	case WE_KEYPRESS: {

   108

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

   109

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

   110

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

   111

			default: return;

   112

		}

   113

	} break;

   114

   115

	case WE_PLACE_OBJ:

   116

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

   117

		break;

   118

   119

	case WE_PLACE_DRAG:

   120

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

   121

		break;

   122

   123

	case WE_PLACE_MOUSEUP:

   124

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

   125

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

   126

		}

   127

		break;

   128

   129

	case WE_ABORT_PLACE_OBJ:

   130

		w->RaiseButtons();

   131

   132

		w = FindWindowById(WC_BUILD_STATION, 0);

   133

		if (w != 0)

   134

			WP(w, def_d).close = true;

   135

		break;

   136

   137

	case WE_DESTROY:

   138

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

   139

		break;

   140

	}

   141

}

   142

   143

static const Widget _air_toolbar_widgets[] = {

   144

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

   145

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

   146

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

   147

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

   148

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

   149

{   WIDGETS_END},

   150

};

   151

   152

   153

static const WindowDesc _air_toolbar_desc = {

   154

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

   155

	WC_BUILD_TOOLBAR, WC_NONE,

   156

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_STICKY_BUTTON,

   157

	_air_toolbar_widgets,

   158

	BuildAirToolbWndProc

   159

};

   160

   161

void ShowBuildAirToolbar()

   162

{

   163

	if (!IsValidPlayer(_current_player)) return;

   164

   165

	DeleteWindowById(WC_BUILD_TOOLBAR, 0);

   166

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

   167

	if (_patches.link_terraform_toolbar) ShowTerraformToolbar(w);

   168

}

   169

   170

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

   171

enum BuildAirportWidgets {

   172

	BAPW_CLOSEBOX = 0,

   173

	BAPW_CAPTION,

   174

	BAPW_BACKGROUND,

   175

   176

	BAPW_NEWAP_DROPDOWN,

   177

	BAPW_NEWAP_LIST,

   178

	BAPW_NEWAP_SCROLL,

   179

   180

	BAPW_MINIPIC_PANEL,

   181

	BAPW_ORIENT_NE,

   182

	BAPW_ORIENT_SE,

   183

	BAPW_ORIENT_SW,

   184

	BAPW_ORIENT_NW,

   185

   186

	BAPW_HIGHLIGHT_OFF,

   187

	BAPW_HIGHLIGHT_ON,

   188

   189

};

   190

   191

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

   192

{

   193

	switch (e->event) {

   194

	case WE_CREATE:

   195

		w->SetWidgetLoweredState(BAPW_HIGHLIGHT_OFF, !_station_show_coverage);

   196

		w->SetWidgetLoweredState(BAPW_HIGHLIGHT_ON, _station_show_coverage);

   197

		break;

   198

   199

	case WE_PAINT: {

   200

		byte preview_sprite = 0xFF;

   201

   202

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

   203

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

   204

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

   205

			/* port not available, find new one*/

   206

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

   207

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

   208

				fsmportspec = GetCustomFSMportsSpec(_airport.fsmports_class, i);

   209

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

   210

					_airport.station_type = i;

   211

					break;

   212

				}

   213

			}

   214

		}

   215

   216

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

   217

   218

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

   219

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

   220

			w->RaiseWidget(BAPW_ORIENT_NE + j);

   221

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

   222

		}

   223

   224

		if (_airport.station_type != 0xFF) {

   225

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

   226

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

   227

			SetTileSelectSize(x, y);

   228

   229

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

   230

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

   231

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

   232

				/* enable the permitted orientations */

   233

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

   234

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

   235

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

   236

				if (j == _airport.layout_set) {

   237

					layout_ptr++;

   238

					preview_sprite = *layout_ptr;

   239

				}

   240

			}

   241

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

   242

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

   243

		}

   244

   245

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

   246

		DrawWindowWidgets(w);

   247

   248

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

   249

		// 'Coverage Area'

   250

		if (_airport.station_type != 0xFF) {

   251

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

   252

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

   253

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

   254

			}

   255

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

   256

			_thd.FSMportMask = NULL;

   257

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

   258

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

   259

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

   262

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

   263

				SetWindowDirty(w);

   264

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

   265

				SetWindowDirty(w);

   266

			}

   267

		} else {

   268

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

   269

			fsmportspec = GetCustomFSMportsSpec(_airport.fsmports_class, 0);

   270

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

   271

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

   272

			layout_ptr++;

   273

			preview_sprite = *layout_ptr;

   274

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

   275

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

   276

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

   277

			_thd.FSMportMask = NULL;

   278

			SetTileSelectSize(1,1);

   279

		}

   280

   281

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

   282

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

   283

   284

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

   285

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

   286

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

   287

				}

   288

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

   289

			} else {

   290

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

   291

			}

   292

		}

   293

		break;

   294

	}

   295

   296

	case WE_CLICK: {

   297

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

   298

		case BAPW_HIGHLIGHT_OFF: case BAPW_HIGHLIGHT_ON:

   299

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

   300

			w->SetWidgetLoweredState(BAPW_HIGHLIGHT_OFF, !_station_show_coverage);

   301

			w->SetWidgetLoweredState(BAPW_HIGHLIGHT_ON, _station_show_coverage);

   302

			SndPlayFx(SND_15_BEEP);

   303

			SetWindowDirty(w);

   304

			break;

   305

		case BAPW_NEWAP_DROPDOWN:

   306

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

   307

			break;

   308

   309

		case BAPW_NEWAP_LIST: {

   310

			const FSMportsSpec *fsmportspec;

   311

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

   312

   313

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

   314

			y += w->vscroll.pos;

   315

			if (y >= _airport.station_count) return;

   316

   317

			/* Check station availability callback */

   318

			fsmportspec = GetCustomFSMportsSpec(_airport.fsmports_class, y);

   319

			if (fsmportspec != NULL &&

   320

				HasBit(fsmportspec->callbackmask, CBM_STATION_AVAIL) &&

   321

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

   322

   323

			_airport.station_type = y;

   324

			_airport.layout_set = 0;

   325

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

   326

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

   327

   328

			SndPlayFx(SND_15_BEEP);

   329

			SetWindowDirty(w);

   330

			break;

   331

			}

   332

		case BAPW_ORIENT_NE:

   333

		case BAPW_ORIENT_SE:

   334

		case BAPW_ORIENT_SW:

   335

		case BAPW_ORIENT_NW:

   336

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

   337

   338

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

   339

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

   340

			_airport.layout_set = 0;

   341

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

   342

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

   343

				int x = fsmportspec->size_x[j];

   344

				int y = fsmportspec->size_y[j];

   345

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

   346

				/* enable the permitted orientations */

   347

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

   348

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

   349

				if (*layout_ptr == _airport.direction) {

   350

					_airport.layout_set = j;

   351

					break;

   352

				}

   353

			}

   354

   355

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

   356

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

   357

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

   358

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

   359

			SndPlayFx(SND_15_BEEP);

   360

			SetWindowDirty(w);

   361

			break;

   362

		}

   363

	} break;

   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

	case WE_MOUSELOOP: {

   383

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

   384

			DeleteWindow(w);

   385

			return;

   386

		}

   387

   388

		CheckRedrawStationCoverage(w);

   389

	} break;

   390

   391

	case WE_DESTROY:

   392

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

   393

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

   394

		_thd.FSMportMask = NULL;

   395

		break;

   396

	}

   397

}

   398

   399

static const Widget _build_airport_picker_widgets[] = {

   400

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

   401

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

   402

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

   403

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

   404

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

   405

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

   406

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

   407

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

   408

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

   409

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

   410

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

   411

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

   412

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

   413

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

   414

{   WIDGETS_END},

   415

};

   416

   417

static const WindowDesc _build_airport_desc = {

   418

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

   419

	WC_BUILD_STATION, WC_BUILD_TOOLBAR,

   420

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET,

   421

	_build_airport_picker_widgets,

   422

	BuildAirportPickerWndProc

   423

};

   424

   425

static void ShowBuildAirportPicker()

   426

{

   427

	Window *w = AllocateWindowDesc(&_build_airport_desc);

   428

	if (w == NULL) return;

   429

   430

	_airport.station_type = 0;

   431

	_airport.layout_set = 0;

   432

	_airport.direction = DIR_NE;

   433

	_airport.station_count = GetNumCustomFSMports(_airport.fsmports_class);

   434

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

   435

	//	_airport.station_type = 0;

   436

	//}

   437

   438

	w->vscroll.count = _airport.station_count;

   439

	w->vscroll.cap   = 5;

   440

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

   441

}

   442

   443

void InitializeAirportGui()

   444

{

   445

}