1

/* $Id$ */

     2

     3

/** @file build_vehicle_gui.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "train.h"

     8

#include "roadveh.h"

     9

#include "ship.h"

    10

#include "aircraft.h"

    11

#include "debug.h"

    12

#include "gui.h"

    13

#include "articulated_vehicles.h"

    14

#include "textbuf_gui.h"

    15

#include "command_func.h"

    16

#include "engine.h"

    17

#include "player_func.h"

    18

#include "depot.h"

    19

#include "airport.h"

    20

#include "vehicle_gui.h"

    21

#include "newgrf_engine.h"

    22

#include "cargotype.h"

    23

#include "group.h"

    24

#include "road_map.h"

    25

#include "strings_func.h"

    26

#include "window_func.h"

    27

#include "date_func.h"

    28

#include "vehicle_func.h"

    29

#include "settings_type.h"

    30

#include "gfx_func.h"

    31

#include "widgets/dropdown_func.h"

    32

    33

#include "table/sprites.h"

    34

#include "table/strings.h"

    35

    36

struct buildvehicle_d {

    37

	VehicleType vehicle_type;

    38

	union {

    39

		RailTypeByte railtype;

    40

		AirportFTAClass::Flags flags;

    41

		RoadTypes roadtypes;

    42

	} filter;

    43

	byte sel_index;  ///< deprecated value, used for 'unified' ship and road

    44

	bool descending_sort_order;

    45

	byte sort_criteria;

    46

	bool regenerate_list;

    47

	EngineID sel_engine;

    48

	EngineID rename_engine;

    49

	EngineList eng_list;

    50

};

    51

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(buildvehicle_d));

    52

    53

enum BuildVehicleWidgets {

    54

	BUILD_VEHICLE_WIDGET_CLOSEBOX = 0,

    55

	BUILD_VEHICLE_WIDGET_CAPTION,

    56

	BUILD_VEHICLE_WIDGET_SORT_ASSENDING_DESCENDING,

    57

	BUILD_VEHICLE_WIDGET_SORT_DROPDOWN,

    58

	BUILD_VEHICLE_WIDGET_LIST,

    59

	BUILD_VEHICLE_WIDGET_SCROLLBAR,

    60

	BUILD_VEHICLE_WIDGET_PANEL,

    61

	BUILD_VEHICLE_WIDGET_BUILD,

    62

	BUILD_VEHICLE_WIDGET_RENAME,

    63

	BUILD_VEHICLE_WIDGET_RESIZE,

    64

	BUILD_VEHICLE_WIDGET_END

    65

};

    66

    67

static const Widget _build_vehicle_widgets[] = {

    68

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

    69

	{    WWT_CAPTION,  RESIZE_RIGHT,    14,    11,   239,     0,    13, 0x0,                     STR_018C_WINDOW_TITLE_DRAG_THIS },

    70

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

    71

	{   WWT_DROPDOWN,  RESIZE_RIGHT,    14,    81,   239,    14,    25, 0x0,                     STR_SORT_CRITERIA_TIP},

    72

	{     WWT_MATRIX,     RESIZE_RB,    14,     0,   227,    26,    39, 0x101,                   STR_NULL },

    73

	{  WWT_SCROLLBAR,    RESIZE_LRB,    14,   228,   239,    26,    39, 0x0,                     STR_0190_SCROLL_BAR_SCROLLS_LIST },

    74

	{      WWT_PANEL,    RESIZE_RTB,    14,     0,   239,    40,   161, 0x0,                     STR_NULL },

    75

    76

	{ WWT_PUSHTXTBTN,     RESIZE_TB,    14,     0,   114,   162,   173, 0x0,                     STR_NULL },

    77

	{ WWT_PUSHTXTBTN,    RESIZE_RTB,    14,   115,   227,   162,   173, 0x0,                     STR_NULL },

    78

	{  WWT_RESIZEBOX,   RESIZE_LRTB,    14,   228,   239,   162,   173, 0x0,                     STR_RESIZE_BUTTON },

    79

	{   WIDGETS_END},

    80

};

    81

    82

/* Setup widget strings to fit the different types of vehicles */

    83

static void SetupWindowStrings(Window *w, VehicleType type)

    84

{

    85

	switch (type) {

    86

		default: NOT_REACHED();

    87

    88

		case VEH_TRAIN:

    89

			w->widget[BUILD_VEHICLE_WIDGET_CAPTION].data    = STR_JUST_STRING;

    90

			w->widget[BUILD_VEHICLE_WIDGET_LIST].tooltips   = STR_8843_TRAIN_VEHICLE_SELECTION;

    91

			w->widget[BUILD_VEHICLE_WIDGET_BUILD].data      = STR_881F_BUILD_VEHICLE;

    92

			w->widget[BUILD_VEHICLE_WIDGET_BUILD].tooltips  = STR_8844_BUILD_THE_HIGHLIGHTED_TRAIN;

    93

			w->widget[BUILD_VEHICLE_WIDGET_RENAME].data     = STR_8820_RENAME;

    94

			w->widget[BUILD_VEHICLE_WIDGET_RENAME].tooltips = STR_8845_RENAME_TRAIN_VEHICLE_TYPE;

    95

			break;

    96

    97

		case VEH_ROAD:

    98

			w->widget[BUILD_VEHICLE_WIDGET_CAPTION].data    = STR_9006_NEW_ROAD_VEHICLES;

    99

			w->widget[BUILD_VEHICLE_WIDGET_LIST].tooltips   = STR_9026_ROAD_VEHICLE_SELECTION;

   100

			w->widget[BUILD_VEHICLE_WIDGET_BUILD].data      = STR_9007_BUILD_VEHICLE;

   101

			w->widget[BUILD_VEHICLE_WIDGET_BUILD].tooltips  = STR_9027_BUILD_THE_HIGHLIGHTED_ROAD;

   102

			w->widget[BUILD_VEHICLE_WIDGET_RENAME].data     = STR_9034_RENAME;

   103

			w->widget[BUILD_VEHICLE_WIDGET_RENAME].tooltips = STR_9035_RENAME_ROAD_VEHICLE_TYPE;

   104

			break;

   105

   106

		case VEH_SHIP:

   107

			w->widget[BUILD_VEHICLE_WIDGET_CAPTION].data    = STR_9808_NEW_SHIPS;

   108

			w->widget[BUILD_VEHICLE_WIDGET_LIST].tooltips   = STR_9825_SHIP_SELECTION_LIST_CLICK;

   109

			w->widget[BUILD_VEHICLE_WIDGET_BUILD].data      = STR_9809_BUILD_SHIP;

   110

			w->widget[BUILD_VEHICLE_WIDGET_BUILD].tooltips  = STR_9826_BUILD_THE_HIGHLIGHTED_SHIP;

   111

			w->widget[BUILD_VEHICLE_WIDGET_RENAME].data     = STR_9836_RENAME;

   112

			w->widget[BUILD_VEHICLE_WIDGET_RENAME].tooltips = STR_9837_RENAME_SHIP_TYPE;

   113

			break;

   114

   115

		case VEH_AIRCRAFT:

   116

			w->widget[BUILD_VEHICLE_WIDGET_CAPTION].data    = STR_A005_NEW_AIRCRAFT;

   117

			w->widget[BUILD_VEHICLE_WIDGET_LIST].tooltips   = STR_A025_AIRCRAFT_SELECTION_LIST;

   118

			w->widget[BUILD_VEHICLE_WIDGET_BUILD].data      = STR_A006_BUILD_AIRCRAFT;

   119

			w->widget[BUILD_VEHICLE_WIDGET_BUILD].tooltips  = STR_A026_BUILD_THE_HIGHLIGHTED_AIRCRAFT;

   120

			w->widget[BUILD_VEHICLE_WIDGET_RENAME].data     = STR_A037_RENAME;

   121

			w->widget[BUILD_VEHICLE_WIDGET_RENAME].tooltips = STR_A038_RENAME_AIRCRAFT_TYPE;

   122

			break;

   123

	}

   124

}

   125

   126

static bool _internal_sort_order; // descending/ascending

   127

   128

static byte _last_sort_criteria[]    = {0, 0, 0, 0};

   129

static bool _last_sort_order[]       = {false, false, false, false};

   130

   131

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

   132

{

   133

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

   134

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

   135

	int r = va - vb;

   136

   137

	return _internal_sort_order ? -r : r;

   138

}

   139

   140

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

   141

{

   142

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

   143

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

   144

	const int r = va - vb;

   145

   146

	if (r == 0) {

   147

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

   148

		return EngineNumberSorter(a, b);

   149

	}

   150

	return _internal_sort_order ? -r : r;

   151

}

   152

   153

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

   154

{

   155

	static EngineID last_engine[2] = { INVALID_ENGINE, INVALID_ENGINE };

   156

	static char     last_name[2][64] = { "\0", "\0" };

   157

   158

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

   159

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

   160

	int r;

   161

   162

	if (va != last_engine[0]) {

   163

		last_engine[0] = va;

   164

		SetDParam(0, va);

   165

		GetString(last_name[0], STR_ENGINE_NAME, lastof(last_name[0]));

   166

	}

   167

   168

	if (vb != last_engine[1]) {

   169

		last_engine[1] = vb;

   170

		SetDParam(0, vb);

   171

		GetString(last_name[1], STR_ENGINE_NAME, lastof(last_name[1]));

   172

	}

   173

   174

	r = strcmp(last_name[0], last_name[1]); // sort by name

   175

   176

	if (r == 0) {

   177

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

   178

		return EngineNumberSorter(a, b);

   179

	}

   180

	return _internal_sort_order ? -r : r;

   181

}

   182

   183

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

   184

{

   185

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

   186

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

   187

	const int r = va - vb;

   188

   189

	if (r == 0) {

   190

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

   191

		return EngineNumberSorter(a, b);

   192

	}

   193

	return _internal_sort_order ? -r : r;

   194

}

   195

   196

/* Train sorting functions */

   197

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

   198

{

   199

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

   200

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

   201

	int r = va - vb;

   202

   203

	return _internal_sort_order ? -r : r;

   204

}

   205

   206

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

   207

{

   208

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

   209

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

   210

	int r = va - vb;

   211

   212

	return _internal_sort_order ? -r : r;

   213

}

   214

   215

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

   216

{

   217

	const RailVehicleInfo *rvi_a = RailVehInfo(*(const EngineID*)a);

   218

	const RailVehicleInfo *rvi_b = RailVehInfo(*(const EngineID*)b);

   219

   220

	int va = rvi_a->power << (rvi_a->railveh_type == RAILVEH_MULTIHEAD ? 1 : 0);

   221

	int vb = rvi_b->power << (rvi_b->railveh_type == RAILVEH_MULTIHEAD ? 1 : 0);

   222

	int r = va - vb;

   223

   224

	return _internal_sort_order ? -r : r;

   225

}

   226

   227

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

   228

{

   229

	const RailVehicleInfo *rvi_a = RailVehInfo(*(const EngineID*)a);

   230

	const RailVehicleInfo *rvi_b = RailVehInfo(*(const EngineID*)b);

   231

   232

	Money va = rvi_a->running_cost * GetPriceByIndex(rvi_a->running_cost_class) * (rvi_a->railveh_type == RAILVEH_MULTIHEAD ? 2 : 1);

   233

	Money vb = rvi_b->running_cost * GetPriceByIndex(rvi_b->running_cost_class) * (rvi_b->railveh_type == RAILVEH_MULTIHEAD ? 2 : 1);

   234

	int r = ClampToI32(va - vb);

   235

   236

	return _internal_sort_order ? -r : r;

   237

}

   238

   239

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

   240

{

   241

	const RailVehicleInfo *rvi_a = RailVehInfo(*(const EngineID*)a);

   242

	const RailVehicleInfo *rvi_b = RailVehInfo(*(const EngineID*)b);

   243

   244

	/* Here we are using a few tricks to get the right sort.

   245

		* We want power/running cost, but since we usually got higher running cost than power and we store the result in an int,

   246

		* we will actually calculate cunning cost/power (to make it more than 1).

   247

		* Because of this, the return value have to be reversed as well and we return b - a instead of a - b.

   248

		* Another thing is that both power and running costs should be doubled for multiheaded engines.

   249

		* Since it would be multipling with 2 in both numerator and denumerator, it will even themselves out and we skip checking for multiheaded. */

   250

	Money va = (rvi_a->running_cost * GetPriceByIndex(rvi_a->running_cost_class)) / max(1U, (uint)rvi_a->power);

   251

	Money vb = (rvi_b->running_cost * GetPriceByIndex(rvi_b->running_cost_class)) / max(1U, (uint)rvi_b->power);

   252

	int r = ClampToI32(vb - va);

   253

   254

	return _internal_sort_order ? -r : r;

   255

}

   256

   257

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

   258

{

   259

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

   260

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

   261

	int r = ListPositionOfEngine(va) - ListPositionOfEngine(vb);

   262

   263

	return _internal_sort_order ? -r : r;

   264

}

   265

   266

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

   267

{

   268

	int va = RailVehInfo(*(const EngineID*)a)->capacity;

   269

	int vb = RailVehInfo(*(const EngineID*)b)->capacity;

   270

	int r = va - vb;

   271

   272

	if (r == 0) {

   273

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

   274

		return EngineNumberSorter(a, b);

   275

	}

   276

	return _internal_sort_order ? -r : r;

   277

}

   278

   279

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

   280

{

   281

	EngineID va = *(const EngineID*)a;

   282

	EngineID vb = *(const EngineID*)b;

   283

	int val_a = (RailVehInfo(va)->railveh_type == RAILVEH_WAGON ? 1 : 0);

   284

	int val_b = (RailVehInfo(vb)->railveh_type == RAILVEH_WAGON ? 1 : 0);

   285

	int r = val_a - val_b;

   286

   287

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

   288

	if (r == 0) return EngineNumberSorter(a, b);

   289

   290

	return _internal_sort_order ? -r : r;

   291

}

   292

   293

/* Road vehicle sorting functions */

   294

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

   295

{

   296

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

   297

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

   298

	int r = va - vb;

   299

   300

	return _internal_sort_order ? -r : r;

   301

}

   302

   303

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

   304

{

   305

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

   306

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

   307

	int r = va - vb;

   308

   309

	return _internal_sort_order ? -r : r;

   310

}

   311

   312

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

   313

{

   314

	const RoadVehicleInfo *rvi_a = RoadVehInfo(*(const EngineID*)a);

   315

	const RoadVehicleInfo *rvi_b = RoadVehInfo(*(const EngineID*)b);

   316

   317

	Money va = rvi_a->running_cost * GetPriceByIndex(rvi_a->running_cost_class);

   318

	Money vb = rvi_b->running_cost * GetPriceByIndex(rvi_b->running_cost_class);

   319

	int r = ClampToI32(va - vb);

   320

   321

	if (r == 0) {

   322

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

   323

		return EngineNumberSorter(a, b);

   324

	}

   325

	return _internal_sort_order ? -r : r;

   326

}

   327

   328

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

   329

{

   330

	int va = RoadVehInfo(*(const EngineID*)a)->capacity;

   331

	int vb = RoadVehInfo(*(const EngineID*)b)->capacity;

   332

	int r = va - vb;

   333

   334

	if (r == 0) {

   335

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

   336

		return EngineNumberSorter(a, b);

   337

	}

   338

	return _internal_sort_order ? -r : r;

   339

}

   340

   341

/* Road vehicle sorting functions */

   342

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

   343

{

   344

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

   345

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

   346

	int r = va - vb;

   347

   348

	return _internal_sort_order ? -r : r;

   349

}

   350

   351

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

   352

{

   353

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

   354

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

   355

	int r = va - vb;

   356

   357

	return _internal_sort_order ? -r : r;

   358

}

   359

   360

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

   361

{

   362

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

   363

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

   364

	const int r = va - vb;

   365

   366

	if (r == 0) {

   367

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

   368

		return EngineNumberSorter(a, b);

   369

	}

   370

	return _internal_sort_order ? -r : r;

   371

}

   372

   373

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

   374

{

   375

	int va = ShipVehInfo(*(const EngineID*)a)->capacity;

   376

	int vb = ShipVehInfo(*(const EngineID*)b)->capacity;

   377

	int r = va - vb;

   378

   379

	if (r == 0) {

   380

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

   381

		return EngineNumberSorter(a, b);

   382

	}

   383

	return _internal_sort_order ? -r : r;

   384

}

   385

   386

/* Aircraft sorting functions */

   387

   388

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

   389

{

   390

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

   391

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

   392

	int r = va - vb;

   393

   394

	return _internal_sort_order ? -r : r;

   395

}

   396

   397

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

   398

{

   399

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

   400

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

   401

	const int r = va - vb;

   402

   403

	if (r == 0) {

   404

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

   405

		return EngineNumberSorter(a, b);

   406

	}

   407

	return _internal_sort_order ? -r : r;

   408

}

   409

   410

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

   411

{

   412

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

   413

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

   414

	const int r = va - vb;

   415

   416

	if (r == 0) {

   417

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

   418

		return EngineNumberSorter(a, b);

   419

	}

   420

	return _internal_sort_order ? -r : r;

   421

}

   422

   423

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

   424

{

   425

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

   426

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

   427

	int r = va - vb;

   428

   429

	if (r == 0) {

   430

		/* The planes has the same passenger capacity. Check mail capacity instead */

   431

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

   432

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

   433

		r = va - vb;

   434

   435

		if (r == 0) {

   436

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

   437

			return EngineNumberSorter(a, b);

   438

		}

   439

	}

   440

	return _internal_sort_order ? -r : r;

   441

}

   442

   443

static EngList_SortTypeFunction * const _sorter[][10] = {{

   444

	/* Trains */

   445

	&TrainEngineNumberSorter,

   446

	&TrainEngineCostSorter,

   447

	&TrainEngineSpeedSorter,

   448

	&TrainEnginePowerSorter,

   449

	&EngineIntroDateSorter,

   450

	&EngineNameSorter,

   451

	&TrainEngineRunningCostSorter,

   452

	&TrainEnginePowerVsRunningCostSorter,

   453

	&EngineReliabilitySorter,

   454

	&TrainEngineCapacitySorter,

   455

}, {

   456

	/* Road vehicles */

   457

	&EngineNumberSorter,

   458

	&RoadVehEngineCostSorter,

   459

	&RoadVehEngineSpeedSorter,

   460

	&EngineIntroDateSorter,

   461

	&EngineNameSorter,

   462

	&RoadVehEngineRunningCostSorter,

   463

	&EngineReliabilitySorter,

   464

	&RoadVehEngineCapacitySorter,

   465

}, {

   466

	/* Ships */

   467

	&EngineNumberSorter,

   468

	&ShipEngineCostSorter,

   469

	&ShipEngineSpeedSorter,

   470

	&EngineIntroDateSorter,

   471

	&EngineNameSorter,

   472

	&ShipEngineRunningCostSorter,

   473

	&EngineReliabilitySorter,

   474

	&ShipEngineCapacitySorter,

   475

}, {

   476

	/* Aircraft */

   477

	&EngineNumberSorter,

   478

	&AircraftEngineCostSorter,

   479

	&AircraftEngineSpeedSorter,

   480

	&EngineIntroDateSorter,

   481

	&EngineNameSorter,

   482

	&AircraftEngineRunningCostSorter,

   483

	&EngineReliabilitySorter,

   484

	&AircraftEngineCargoSorter,

   485

}};

   486

   487

static const StringID _sort_listing[][11] = {{

   488

	/* Trains */

   489

	STR_ENGINE_SORT_ENGINE_ID,

   490

	STR_ENGINE_SORT_COST,

   491

	STR_SORT_BY_MAX_SPEED,

   492

	STR_ENGINE_SORT_POWER,

   493

	STR_ENGINE_SORT_INTRO_DATE,

   494

	STR_SORT_BY_DROPDOWN_NAME,

   495

	STR_ENGINE_SORT_RUNNING_COST,

   496

	STR_ENGINE_SORT_POWER_VS_RUNNING_COST,

   497

	STR_SORT_BY_RELIABILITY,