1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "aircraft.h"

     6

#include "debug.h"

     7

#include "functions.h"

     8

#include "station_map.h"

     9

#include "table/sprites.h"

    10

#include "table/strings.h"

    11

#include "map.h"

    12

#include "tile.h"

    13

#include "window.h"

    14

#include "gui.h"

    15

#include "vehicle.h"

    16

#include "gfx.h"

    17

#include "station.h"

    18

#include "command.h"

    19

#include "engine.h"

    20

#include "viewport.h"

    21

#include "player.h"

    22

#include "depot.h"

    23

#include "airport.h"

    24

#include "vehicle_gui.h"

    25

#include "newgrf_engine.h"

    26

#include "date.h"

    27

#include "strings.h"

    28

    29

typedef enum BuildAircraftWidgets {

    30

	BUILD_AIRCRAFT_WIDGET_CLOSEBOX = 0,

    31

	BUILD_AIRCRAFT_WIDGET_CAPTION,

    33

	BUILD_AIRCRAFT_WIDGET_SORT_TEXT,

    34

	BUILD_AIRCRAFT_WIDGET_SORT_DROPDOWN,

    35

	BUILD_AIRCRAFT_WIDGET_LIST,

    36

	BUILD_AIRCRAFT_WIDGET_SCROLLBAR,

    37

	BUILD_AIRCRAFT_WIDGET_PANEL,

    38

	BUILD_AIRCRAFT_WIDGET_PLANES,

    39

	BUILD_AIRCRAFT_WIDGET_JETS,

    40

	BUILD_AIRCRAFT_WIDGET_HELICOPTERS,

    41

	BUILD_AIRCRAFT_WIDGET_BUILD,

    42

	BUILD_AIRCRAFT_WIDGET_RENAME,

    43

	BUILD_AIRCRAFT_WIDGET_RESIZE,

    44

} BuildAircraftWidget;

    45

    46

static const Widget _new_aircraft_widgets[] = {

    47

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

    48

	{    WWT_CAPTION,   RESIZE_NONE,    14,    11,   239,     0,    13, STR_A005_NEW_AIRCRAFT,   STR_018C_WINDOW_TITLE_DRAG_THIS },

    49

	{ WWT_PUSHTXTBTN,   RESIZE_NONE,    14,     0,    80,    14,    25, STR_SORT_BY,             STR_SORT_ORDER_TIP},

    50

	{      WWT_PANEL,   RESIZE_NONE,    14,    81,   227,    14,    25, 0x0,                     STR_SORT_CRITERIA_TIP},

    51

	{    WWT_TEXTBTN,   RESIZE_NONE,    14,   228,   239,    14,    25, STR_0225,                STR_SORT_CRITERIA_TIP},

    52

	{     WWT_MATRIX, RESIZE_BOTTOM,    14,     0,   227,    26,   121, 0x401,                   STR_A025_AIRCRAFT_SELECTION_LIST },

    53

	{  WWT_SCROLLBAR, RESIZE_BOTTOM,    14,   228,   239,    26,   121, 0x0,                     STR_0190_SCROLL_BAR_SCROLLS_LIST },

    54

	{     WWT_IMGBTN,     RESIZE_TB,    14,     0,   239,   122,   193, 0x0,                     STR_NULL },

    55

    56

	{ WWT_PUSHTXTBTN,     RESIZE_TB,    14,     0,    79,   194,   205, STR_BLACK_PLANES,        STR_BUILD_PLANES_TIP },

    57

	{ WWT_PUSHTXTBTN,     RESIZE_TB,    14,    80,   159,   194,   205, STR_BLACK_JETS,          STR_BUILD_JETS_TIP },

    58

	{ WWT_PUSHTXTBTN,     RESIZE_TB,    14,   160,   239,   194,   205, STR_BLACK_HELICOPTERS,   STR_BUILD_HELICOPTERS_TIP },

    59

    60

	{ WWT_PUSHTXTBTN,     RESIZE_TB,    14,     0,   114,   206,   217, STR_A006_BUILD_AIRCRAFT, STR_A026_BUILD_THE_HIGHLIGHTED_AIRCRAFT },

    61

	{ WWT_PUSHTXTBTN,     RESIZE_TB,    14,   115,   227,   206,   217, STR_A037_RENAME,         STR_A038_RENAME_AIRCRAFT_TYPE },

    62

	{  WWT_RESIZEBOX,     RESIZE_TB,    14,   228,   239,   206,   217, 0x0,                     STR_RESIZE_BUTTON },

    63

	{   WIDGETS_END},

    64

};

    65

    66

static bool _internal_sort_order; // descending/ascending

    67

static byte _last_sort_criteria = 0;

    68

static bool _last_sort_order = false;

    69

    70

typedef int CDECL VehicleSortListingTypeFunction(const void*, const void*);

    71

    72

static int CDECL AircraftEngineNumberSorter(const void *a, const void *b)

    73

{

    74

	const EngineID va = *(const EngineID*)a;

    75

	const EngineID vb = *(const EngineID*)b;

    76

	int r = va - vb;

    77

    78

	return _internal_sort_order ? -r : r;

    79

}

    80

    81

static int CDECL AircraftEngineCostSorter(const void *a, const void *b)

    82

{

    83

	const int va = AircraftVehInfo(*(const EngineID*)a)->base_cost;

    84

	const int vb = AircraftVehInfo(*(const EngineID*)b)->base_cost;

    85

	int r = va - vb;

    86

    87

	return _internal_sort_order ? -r : r;

    88

}

    89

    90

static int CDECL AircraftEngineSpeedSorter(const void *a, const void *b)

    91

{

    92

	const int va = AircraftVehInfo(*(const EngineID*)a)->max_speed;

    93

	const int vb = AircraftVehInfo(*(const EngineID*)b)->max_speed;

    94

	const int r = va - vb;

    95

    96

	if (r == 0) {

    97

		/* Use EngineID to sort instead since we want consistent sorting */

    98

		return AircraftEngineNumberSorter(a, b);

    99

	}

   100

	return _internal_sort_order ? -r : r;

   101

}

   102

   103

static int CDECL AircraftEngineIntroDateSorter(const void *a, const void *b)

   104

{

   105

	const int va = GetEngine(*(const EngineID*)a)->intro_date;

   106

	const int vb = GetEngine(*(const EngineID*)b)->intro_date;

   107

	const int r = va - vb;

   108

   109

	if (r == 0) {

   110

		/* Use EngineID to sort instead since we want consistent sorting */

   111

		return AircraftEngineNumberSorter(a, b);

   112

	}

   113

	return _internal_sort_order ? -r : r;

   114

}

   115

   116

static EngineID _last_engine; // cached vehicle to hopefully speed up name-sorting

   117

   118

static char _bufcache[64]; // used together with _last_vehicle to hopefully speed up stringsorting

   119

static int CDECL AircraftEngineNameSorter(const void *a, const void *b)

   120

{

   121

	const EngineID va = *(const EngineID*)a;

   122

	const EngineID vb = *(const EngineID*)b;

   123

	char buf1[64] = "\0";

   124

	int r;

   125

   126

	SetDParam(0, GetCustomEngineName(va));

   127

	GetString(buf1, STR_JUST_STRING);

   128

   129

	if (vb != _last_engine) {

   130

		_last_engine = vb;

   131

		_bufcache[0] = '\0';

   132

   133

		SetDParam(0, GetCustomEngineName(vb));

   134

		GetString(_bufcache, STR_JUST_STRING);

   135

	}

   136

   137

	r =  strcmp(buf1, _bufcache); // sort by name

   138

   139

	if (r == 0) {

   140

		/* Use EngineID to sort instead since we want consistent sorting */

   141

		return AircraftEngineNumberSorter(a, b);

   142

	}

   143

   144

	return (_internal_sort_order & 1) ? -r : r;

   145

}

   146

   147

static int CDECL AircraftEngineRunningCostSorter(const void *a, const void *b)

   148

{

   149

	const int va = AircraftVehInfo(*(const EngineID*)a)->running_cost;

   150

	const int vb = AircraftVehInfo(*(const EngineID*)b)->running_cost;

   151

	const int r = va - vb;

   152

   153

	if (r == 0) {

   154

		/* Use EngineID to sort instead since we want consistent sorting */

   155

		return AircraftEngineNumberSorter(a, b);

   156

	}

   157

	return _internal_sort_order ? -r : r;

   158

}

   159

   160

static int CDECL AircraftEngineReliabilitySorter(const void *a, const void *b)

   161

{

   162

	const int va = GetEngine(*(const EngineID*)a)->reliability;

   163

	const int vb = GetEngine(*(const EngineID*)b)->reliability;

   164

	const int r = va - vb;

   165

   166

	if (r == 0) {

   167

		/* Use EngineID to sort instead since we want consistent sorting */

   168

		return AircraftEngineNumberSorter(a, b);

   169

	}

   170

	return _internal_sort_order ? -r : r;

   171

}

   172

   173

static int CDECL AircraftEngineCargoSorter(const void *a, const void *b)

   174

{

   175

	const int va = AircraftVehInfo(*(const EngineID*)a)->passenger_capacity;

   176

	const int vb = AircraftVehInfo(*(const EngineID*)b)->passenger_capacity;

   177

	const int r = va - vb;

   178

   179

	if (r == 0) {

   180

		/* Use EngineID to sort instead since we want consistent sorting */

   181

		return AircraftEngineNumberSorter(a, b);

   182

	}

   183

	return _internal_sort_order ? -r : r;

   184

}

   185

   186

static VehicleSortListingTypeFunction* const _engine_sorter[] = {

   187

	&AircraftEngineNumberSorter,

   188

	&AircraftEngineCostSorter,

   189

	&AircraftEngineSpeedSorter,

   190

	&AircraftEngineIntroDateSorter,

   191

	&AircraftEngineNameSorter,

   192

	&AircraftEngineRunningCostSorter,

   193

	&AircraftEngineReliabilitySorter,

   194

	&AircraftEngineCargoSorter,

   195

};

   196

   197

static const StringID _engine_sort_listing[] = {

   198

	STR_ENGINE_SORT_ENGINE_ID,

   199

	STR_ENGINE_SORT_COST,

   200

	STR_SORT_BY_MAX_SPEED,

   201

	STR_ENGINE_SORT_INTRO_DATE,

   202

	STR_SORT_BY_DROPDOWN_NAME,

   203

	STR_ENGINE_SORT_RUNNING_COST,

   204

	STR_SORT_BY_RELIABILITY,

   205

	STR_ENGINE_SORT_CARGO_CAPACITY,

   206

	INVALID_STRING_ID

   207

};

   208

   209

   210

/**

   211

 * Draw the purchase info details of an aircraft at a given location.

   212

 * @param x,y location where to draw the info

   213

 * @param engine_number the engine of which to draw the info of

   214

 */

   215

void DrawAircraftPurchaseInfo(int x, int y, EngineID engine_number)

   216

{

   217

	const AircraftVehicleInfo *avi = AircraftVehInfo(engine_number);

   218

	const Engine *e = GetEngine(engine_number);

   219

	CargoID cargo;

   220

	YearMonthDay ymd;

   221

	ConvertDateToYMD(e->intro_date, &ymd);

   222

   223

	/* Purchase cost - Max speed */

   224

	SetDParam(0, avi->base_cost * (_price.aircraft_base>>3)>>5);

   225

	SetDParam(1, avi->max_speed * 128 / 10);

   226

	DrawString(x, y, STR_PURCHASE_INFO_COST_SPEED, 0);

   227

	y += 10;

   228

   229

	/* Cargo capacity */

   230

	cargo = FindFirstRefittableCargo(engine_number);

   231

	if (cargo == CT_INVALID || cargo == CT_PASSENGERS) {

   232

		SetDParam(0, avi->passenger_capacity);

   233

		SetDParam(1, avi->mail_capacity);

   234

		DrawString(x, y, STR_PURCHASE_INFO_AIRCRAFT_CAPACITY, 0);

   235

	} else {

   236

		/* Note, if the default capacity is selected by the refit capacity

   237

		 * callback, then the capacity shown is likely to be incorrect. */

   238

		SetDParam(0, _cargoc.names_long[cargo]);

   239

		SetDParam(1, AircraftDefaultCargoCapacity(cargo, engine_number));

   240

		SetDParam(2, STR_9842_REFITTABLE);

   241

		DrawString(x, y, STR_PURCHASE_INFO_CAPACITY, 0);

   242

	}

   243

	y += 10;

   244

   245

	/* Running cost */

   246

	SetDParam(0, avi->running_cost * _price.aircraft_running >> 8);

   247

	DrawString(x, y, STR_PURCHASE_INFO_RUNNINGCOST, 0);

   248

	y += 10;

   249

   250

	/* Design date - Life length */

   251

	SetDParam(0, ymd.year);

   252

	SetDParam(1, e->lifelength);

   253

	DrawString(x, y, STR_PURCHASE_INFO_DESIGNED_LIFE, 0);

   254

	y += 10;

   255

   256

	/* Reliability */

   257

	SetDParam(0, e->reliability * 100 >> 16);

   258

	DrawString(x, y, STR_PURCHASE_INFO_RELIABILITY, 0);

   259

	y += 10;

   260

   261

	/* Additional text from NewGRF */

   262

	// XXX 227 will become a calculated width...

   263

	y += ShowAdditionalText(x, y, 227, engine_number);

   264

}

   265

   266

void DrawAircraftImage(const Vehicle *v, int x, int y, VehicleID selection)

   267

{

   268

	PalSpriteID pal = (v->vehstatus & VS_CRASHED) ? PALETTE_CRASH : GetVehiclePalette(v);

   269

	DrawSprite(GetAircraftImage(v, DIR_W) | pal, x + 25, y + 10);

   270

	if (v->subtype == 0) {

   271

		SpriteID rotor_sprite = GetCustomRotorSprite(v, true);

   272

		if (rotor_sprite == 0) rotor_sprite = SPR_ROTOR_STOPPED;

   273

		DrawSprite(rotor_sprite, x + 25, y + 5);

   274

	}

   275

	if (v->index == selection) {

   276

		DrawFrameRect(x - 1, y - 1, x + 58, y + 21, 0xF, FR_BORDERONLY);

   277

	}

   278

}

   279

   280

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

   281

{

   282

	if (success) {

   283

		const Vehicle *v = GetVehicle(_new_vehicle_id);

   284

   285

		if (v->tile == _backup_orders_tile) {

   286

			_backup_orders_tile = 0;

   287

			RestoreVehicleOrders(v, _backup_orders_data);

   288

		}

   289

		ShowAircraftViewWindow(v);

   290

	}

   291

}

   292

   293

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

   294

{

   295

	if (success) ShowAircraftViewWindow(GetVehicle(_new_vehicle_id));

   296

}

   297

   298

static inline void ExtendEngineListSize(const EngineID **engine_list, uint16 *engine_list_length, uint16 step_size)

   299

{

   300

	*engine_list_length = min(*engine_list_length + step_size, NUM_TRAIN_ENGINES);

   301

	*engine_list = realloc((void*)*engine_list, (*engine_list_length) * sizeof((*engine_list)[0]));

   302

}

   303

   304

static void GenerateBuildList(EngineID **planes, uint16 *num_planes, EngineID **jets, uint16 *num_jets, EngineID **helicopters, uint16 *num_helicopters)

   305

{

   306

	uint16 plane_length      = *num_planes;

   307

	uint16 jet_length        = *num_jets;

   308

	uint16 helicopter_length = *num_helicopters;

   309

	EngineID eid;

   310

   311

	(*num_planes)      = 0;

   312

	(*num_jets)        = 0;

   313

	(*num_helicopters) = 0;

   314

   315

	for (eid = AIRCRAFT_ENGINES_INDEX; eid < AIRCRAFT_ENGINES_INDEX + NUM_AIRCRAFT_ENGINES; eid++) {

   316

   317

		if (IsEngineBuildable(eid, VEH_Aircraft)) {

   318

			const AircraftVehicleInfo *avi = AircraftVehInfo(eid);

   319

   320

			switch (avi->subtype) {

   321

				case AIR_CTOL: // Propeller planes

   322

					if (*num_planes == plane_length) ExtendEngineListSize((const EngineID**)planes, &plane_length, 5);

   323

					(*planes)[(*num_planes)++] = eid;

   324

					break;

   325

   326

				case (AIR_CTOL | AIR_FAST): // Jet planes

   327

					if (*num_jets == jet_length) ExtendEngineListSize((const EngineID**)jets, &jet_length, 5);

   328

					(*jets)[(*num_jets)++] = eid;

   329

					break;

   330

   331

				case 0: // Helicopters

   332

					if (*num_helicopters == helicopter_length) ExtendEngineListSize((const EngineID**)helicopters, &plane_length, 5);

   333

					(*helicopters)[(*num_helicopters)++] = eid;

   334

					break;

   335

			}

   336

		}

   337

   338

	}

   339

   340

	/* Reduce array sizes if they are too big */

   341

	if (*num_planes      != plane_length)      *planes      = realloc((void*)*planes,      (*num_planes)      * sizeof((*planes)[0]));

   342

	if (*num_jets        != jet_length)        *jets        = realloc((void*)*jets,        (*num_jets)        * sizeof((*jets)[0]));

   343

	if (*num_helicopters != helicopter_length) *helicopters = realloc((void*)*helicopters, (*num_helicopters) * sizeof((*helicopters)[0]));

   344

}

   345

   346

static inline EngineID *GetEngineArray(Window *w)

   347

{

   348

	switch (WP(w,buildvehicle_d).show_engine_button) {

   349

		case 1: return WP(w, buildvehicle_d).list_a;

   350

		case 2: return WP(w, buildvehicle_d).list_b;

   351

		case 3: return WP(w, buildvehicle_d).list_c;

   352

		default: NOT_REACHED();

   353

	}

   354

	return NULL;

   355

}

   356

   357

static inline uint16 GetEngineArrayLength(Window *w)

   358

{

   359

	switch (WP(w,buildvehicle_d).show_engine_button) {

   360

		case 1: return WP(w, buildvehicle_d).list_a_length;

   361

		case 2: return WP(w, buildvehicle_d).list_b_length;

   362

		case 3: return WP(w, buildvehicle_d).list_c_length;

   363

		default: NOT_REACHED();

   364

	}

   365

	return 0;

   366

}

   367

   368

static void SortAircraftBuildList(Window *w)

   369

{

   370

	_internal_sort_order = WP(w,buildvehicle_d).decenting_sort_order;

   371

	qsort((void*)GetEngineArray(w), GetEngineArrayLength(w), sizeof(GetEngineArray(w)[0]),

   372

		  _engine_sorter[WP(w,buildvehicle_d).sort_criteria]);

   373

}

   374

   375

static void DrawBuildAircraftWindow(Window *w)

   376

{

   377

	SetWindowWidgetLoweredState(w, BUILD_AIRCRAFT_WIDGET_PLANES,      WP(w,buildvehicle_d).show_engine_button == 1);

   378

	SetWindowWidgetLoweredState(w, BUILD_AIRCRAFT_WIDGET_JETS,        WP(w,buildvehicle_d).show_engine_button == 2);

   379

	SetWindowWidgetLoweredState(w, BUILD_AIRCRAFT_WIDGET_HELICOPTERS, WP(w,buildvehicle_d).show_engine_button == 3);

   380

   381

	SetWindowWidgetDisabledState(w, BUILD_AIRCRAFT_WIDGET_BUILD, w->window_number == 0);

   382

   383

	if (WP(w, buildvehicle_d).data_invalidated) {

   384

		GenerateBuildList(&WP(w, buildvehicle_d).list_a, &WP(w, buildvehicle_d).list_a_length,

   385

						  &WP(w, buildvehicle_d).list_b, &WP(w, buildvehicle_d).list_b_length,

   386

						  &WP(w, buildvehicle_d).list_c, &WP(w, buildvehicle_d).list_c_length);

   387

		WP(w, buildvehicle_d).data_invalidated = false;

   388

   389

		if (WP(w,buildvehicle_d).sel_engine != INVALID_ENGINE) {

   390

			int i;

   391

			bool found = false;

   392

			if (HASBIT(WP(w,buildvehicle_d).show_engine_button, 0)) {

   393

				for (i = 0; i < GetEngineArrayLength(w); i++) {

   394

					if (WP(w,buildvehicle_d).sel_engine != GetEngineArray(w)[i]) continue;

   395

					found = true;

   396

					break;

   397

				}

   398

			}

   399

			if (!found) WP(w,buildvehicle_d).sel_engine = INVALID_ENGINE;

   400

		}

   401

	}

   402

   403

	SetVScrollCount(w, GetEngineArrayLength(w));

   404

	DrawWindowWidgets(w);

   405

   406

	if (WP(w,buildvehicle_d).sel_engine == INVALID_ENGINE && GetEngineArrayLength(w) != 0) {

   407

		WP(w,buildvehicle_d).sel_engine = GetEngineArray(w)[0];

   408

	}

   409

   410

	{

   411

		int x = 2;

   412

		int y = 27;

   413

		EngineID selected_id = WP(w,buildvehicle_d).sel_engine;

   414

		EngineID eid = w->vscroll.pos;

   415

		EngineID *list = GetEngineArray(w);

   416

		uint16 list_length = GetEngineArrayLength(w);

   417

		uint16 max = min(w->vscroll.pos + w->vscroll.cap, list_length);

   418

   419

		for(; eid < max; eid++) {

   420

			const EngineID engine = list[eid];

   421

   422

			DrawString(x + 62, y + 7, GetCustomEngineName(engine), engine == selected_id ? 0xC : 0x10);

   423

			DrawAircraftEngine(x + 29, y + 10, engine, GetEnginePalette(engine, _local_player));

   424

			y += 24;

   425

		}

   426

   427

		if (selected_id != INVALID_ENGINE) {

   428

			DrawAircraftPurchaseInfo(x, w->widget[BUILD_AIRCRAFT_WIDGET_PANEL].top + 1, selected_id);

   429

		}

   430

	}

   431

	DrawString(85, 15, _engine_sort_listing[WP(w,buildvehicle_d).sort_criteria], 0x10);

   432

	DoDrawString(WP(w,buildvehicle_d).decenting_sort_order ? DOWNARROW : UPARROW, 69, 15, 0x10);

   433

}

   434

   435

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

   436

{

   437

	byte click_state = 0;

   438

   439

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

   441

			WP(w,buildvehicle_d).decenting_sort_order = !WP(w,buildvehicle_d).decenting_sort_order;

   442

			_last_sort_order = WP(w,buildvehicle_d).decenting_sort_order;

   443

			SortAircraftBuildList(w);

   444

			SetWindowDirty(w);

   445

			break;

   446

   447

		case BUILD_AIRCRAFT_WIDGET_LIST: {

   448

			uint i = (e->we.click.pt.y - 26) / 24;

   449

			if (i < w->vscroll.cap) {

   450

				i += w->vscroll.pos;

   451

   452

				if (i < GetEngineArrayLength(w)) {

   453

					WP(w,buildvehicle_d).sel_engine = GetEngineArray(w)[i];

   454

					SetWindowDirty(w);

   455

				}

   456

			}

   457

		} break;

   458

   459

		case BUILD_AIRCRAFT_WIDGET_SORT_TEXT: case BUILD_AIRCRAFT_WIDGET_SORT_DROPDOWN:/* Select sorting criteria dropdown menu */

   460

			ShowDropDownMenu(w, _engine_sort_listing, WP(w,buildvehicle_d).sort_criteria, BUILD_AIRCRAFT_WIDGET_SORT_DROPDOWN, 0, 0);

   461

			return;

   462

   463

		case BUILD_AIRCRAFT_WIDGET_HELICOPTERS: click_state++;

   464

		case BUILD_AIRCRAFT_WIDGET_JETS:        click_state++;

   465

		case BUILD_AIRCRAFT_WIDGET_PLANES:      click_state++;

   466

   467

			if (WP(w,buildvehicle_d).show_engine_button == click_state) break; // We clicked the pressed button

   468

   469

			WP(w,buildvehicle_d).sel_engine = INVALID_ENGINE;

   470

			WP(w,buildvehicle_d).show_engine_button = click_state;

   471

			w->vscroll.pos = 0;

   472

			SortAircraftBuildList(w);

   473

			SetWindowDirty(w);

   474

			break;

   475

   476

		case BUILD_AIRCRAFT_WIDGET_BUILD: {

   477

			EngineID sel_eng = WP(w,buildvehicle_d).sel_engine;

   478

			if (sel_eng != INVALID_ENGINE)

   479

				DoCommandP(w->window_number, sel_eng, 0, CcBuildAircraft, CMD_BUILD_AIRCRAFT | CMD_MSG(STR_A008_CAN_T_BUILD_AIRCRAFT));

   480

		} break;

   481

   482

		case BUILD_AIRCRAFT_WIDGET_RENAME: {

   483

			EngineID sel_eng = WP(w,buildvehicle_d).sel_engine;

   484

			if (sel_eng != INVALID_ENGINE) {

   485

				WP(w,buildvehicle_d).rename_engine = sel_eng;

   486

				ShowQueryString(GetCustomEngineName(sel_eng),

   487

								STR_A039_RENAME_AIRCRAFT_TYPE, 31, 160, w->window_class, w->window_number, CS_ALPHANUMERAL);

   488

			}

   489

		} break;

   490

	}