1

/* $Id$ */

     2

     3

/** @file build_vehicle_gui.cpp GUI for building vehicles. */

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

    17

#include "airport.h"

    18

#include "vehicle_gui.h"

    19

#include "newgrf_engine.h"

    20

#include "cargotype.h"

    21

#include "group.h"

    22

#include "road_map.h"

    23

#include "strings_func.h"

    24

#include "window_func.h"

    25

#include "date_func.h"

    26

#include "vehicle_func.h"

    27

#include "settings_type.h"

    28

#include "gfx_func.h"

    29

#include "widgets/dropdown_func.h"

    30

#include "string_func.h"

    31

#include "window_gui.h"

    32

#include "engine_gui.h"

    33

    34

#include "table/sprites.h"

    35

#include "table/strings.h"

    36

    37

enum BuildVehicleWidgets {

    38

	BUILD_VEHICLE_WIDGET_CLOSEBOX = 0,

    39

	BUILD_VEHICLE_WIDGET_CAPTION,

    40

	BUILD_VEHICLE_WIDGET_SORT_ASSENDING_DESCENDING,

    41

	BUILD_VEHICLE_WIDGET_SORT_DROPDOWN,

    42

	BUILD_VEHICLE_WIDGET_LIST,

    43

	BUILD_VEHICLE_WIDGET_SCROLLBAR,

    44

	BUILD_VEHICLE_WIDGET_PANEL,

    45

	BUILD_VEHICLE_WIDGET_BUILD,

    46

	BUILD_VEHICLE_WIDGET_RENAME,

    47

	BUILD_VEHICLE_WIDGET_RESIZE,

    48

	BUILD_VEHICLE_WIDGET_END

    49

};

    50

    51

static const Widget _build_vehicle_widgets[] = {

    52

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

    53

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

    54

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

    55

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

    56

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

    57

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

    58

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

    59

    60

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

    61

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

    62

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

    63

	{   WIDGETS_END},

    64

};

    65

    66

static bool _internal_sort_order; // descending/ascending

    67

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

    68

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

    69

    70

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

    71

{

    72

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

    73

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

    74

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

    75

    76

	return _internal_sort_order ? -r : r;

    77

}

    78

    79

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

    80

{

    81

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

    82

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

    83

	const int r = va - vb;

    84

    85

	if (r == 0) {

    86

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

    87

		return EngineNumberSorter(a, b);

    88

	}

    89

	return _internal_sort_order ? -r : r;

    90

}

    91

    92

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

    93

{

    94

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

    95

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

    96

    97

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

    98

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

    99

	int r;

   100

   101

	if (va != last_engine[0]) {

   102

		last_engine[0] = va;

   103

		SetDParam(0, va);

   104

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

   105

	}

   106

   107

	if (vb != last_engine[1]) {

   108

		last_engine[1] = vb;

   109

		SetDParam(0, vb);

   110

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

   111

	}

   112

   113

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

   114

   115

	if (r == 0) {

   116

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

   117

		return EngineNumberSorter(a, b);

   118

	}

   119

	return _internal_sort_order ? -r : r;

   120

}

   121

   122

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

   123

{

   124

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

   125

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

   126

	const int r = va - vb;

   127

   128

	if (r == 0) {

   129

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

   130

		return EngineNumberSorter(a, b);

   131

	}

   132

	return _internal_sort_order ? -r : r;

   133

}

   134

   135

/* Train sorting functions */

   136

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

   137

{

   138

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

   139

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

   140

	int r = va - vb;

   141

   142

	return _internal_sort_order ? -r : r;

   143

}

   144

   145

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

   146

{

   147

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

   148

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

   149

	int r = va - vb;

   150

   151

	return _internal_sort_order ? -r : r;

   152

}

   153

   154

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

   155

{

   156

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

   157

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

   158

   159

	int va = rvi_a->power;

   160

	int vb = rvi_b->power;

   161

	int r = va - vb;

   162

   163

	return _internal_sort_order ? -r : r;

   164

}

   165

   166

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

   167

{

   168

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

   169

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

   170

   171

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

   172

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

   173

	int r = ClampToI32(va - vb);

   174

   175

	return _internal_sort_order ? -r : r;

   176

}

   177

   178

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

   179

{

   180

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

   181

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

   182

   183

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

   184

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

   185

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

   186

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

   187

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

   188

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

   189

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

   190

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

   191

	int r = ClampToI32(vb - va);

   192

   193

	return _internal_sort_order ? -r : r;

   194

}

   195

   196

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

   197

{

   198

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

   199

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

   200

   201

	int va = rvi_a->capacity * (rvi_a->railveh_type == RAILVEH_MULTIHEAD ? 2 : 1);

   202

	int vb = rvi_b->capacity * (rvi_b->railveh_type == RAILVEH_MULTIHEAD ? 2 : 1);

   203

	int r = va - vb;

   204

   205

	if (r == 0) {

   206

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

   207

		return EngineNumberSorter(a, b);

   208

	}

   209

	return _internal_sort_order ? -r : r;

   210

}

   211

   212

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

   213

{

   214

	EngineID va = *(const EngineID*)a;

   215

	EngineID vb = *(const EngineID*)b;

   216

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

   217

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

   218

	int r = val_a - val_b;

   219

   220

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

   221

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

   222

   223

	return _internal_sort_order ? -r : r;

   224

}

   225

   226

/* Road vehicle sorting functions */

   227

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

   228

{

   229

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

   230

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

   231

	int r = va - vb;

   232

   233

	return _internal_sort_order ? -r : r;

   234

}

   235

   236

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

   237

{

   238

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

   239

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

   240

	int r = va - vb;

   241

   242

	return _internal_sort_order ? -r : r;

   243

}

   244

   245

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

   246

{

   247

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

   248

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

   249

   250

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

   251

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

   252

	int r = ClampToI32(va - vb);

   253

   254

	if (r == 0) {

   255

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

   256

		return EngineNumberSorter(a, b);

   257

	}

   258

	return _internal_sort_order ? -r : r;

   259

}

   260

   261

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

   262

{

   263

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

   264

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

   265

	int r = va - vb;

   266

   267

	if (r == 0) {

   268

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

   269

		return EngineNumberSorter(a, b);

   270

	}

   271

	return _internal_sort_order ? -r : r;

   272

}

   273

   274

/* Road vehicle sorting functions */

   275

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

   276

{

   277

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

   278

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

   279

	int r = va - vb;

   280

   281

	return _internal_sort_order ? -r : r;

   282

}

   283

   284

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

   285

{

   286

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

   287

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

   288

	int r = va - vb;

   289

   290

	return _internal_sort_order ? -r : r;

   291

}

   292

   293

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

   294

{

   295

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

   296

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

   297

	const int r = va - vb;

   298

   299

	if (r == 0) {

   300

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

   301

		return EngineNumberSorter(a, b);

   302

	}

   303

	return _internal_sort_order ? -r : r;

   304

}

   305

   306

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

   307

{

   308

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

   309

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

   310

	int r = va - vb;

   311

   312

	if (r == 0) {

   313

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

   314

		return EngineNumberSorter(a, b);

   315

	}

   316

	return _internal_sort_order ? -r : r;

   317

}

   318

   319

/* Aircraft sorting functions */

   320

   321

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

   322

{

   323

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

   324

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

   325

	int r = va - vb;

   326

   327

	return _internal_sort_order ? -r : r;

   328

}

   329

   330

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

   331

{

   332

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

   333

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

   334

	const int r = va - vb;

   335

   336

	if (r == 0) {

   337

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

   338

		return EngineNumberSorter(a, b);

   339

	}

   340

	return _internal_sort_order ? -r : r;

   341

}

   342

   343

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

   344

{

   345

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

   346

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

   347

	const int r = va - vb;

   348

   349

	if (r == 0) {

   350

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

   351

		return EngineNumberSorter(a, b);

   352

	}

   353

	return _internal_sort_order ? -r : r;

   354

}

   355

   356

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

   357

{

   358

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

   359

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

   360

	int r = va - vb;

   361

   362

	if (r == 0) {

   363

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

   364

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

   365

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

   366

		r = va - vb;

   367

   368

		if (r == 0) {

   369

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

   370

			return EngineNumberSorter(a, b);

   371

		}

   372

	}

   373

	return _internal_sort_order ? -r : r;

   374

}

   375

   376

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

   377

	/* Trains */

   378

	&EngineNumberSorter,

   379

	&TrainEngineCostSorter,

   380

	&TrainEngineSpeedSorter,

   381

	&TrainEnginePowerSorter,

   382

	&EngineIntroDateSorter,

   383

	&EngineNameSorter,

   384

	&TrainEngineRunningCostSorter,

   385

	&TrainEnginePowerVsRunningCostSorter,

   386

	&EngineReliabilitySorter,

   387

	&TrainEngineCapacitySorter,

   388

}, {

   389

	/* Road vehicles */

   390

	&EngineNumberSorter,

   391

	&RoadVehEngineCostSorter,

   392

	&RoadVehEngineSpeedSorter,

   393

	&EngineIntroDateSorter,

   394

	&EngineNameSorter,

   395

	&RoadVehEngineRunningCostSorter,

   396

	&EngineReliabilitySorter,

   397

	&RoadVehEngineCapacitySorter,

   398

}, {

   399

	/* Ships */

   400

	&EngineNumberSorter,

   401

	&ShipEngineCostSorter,

   402

	&ShipEngineSpeedSorter,

   403

	&EngineIntroDateSorter,

   404

	&EngineNameSorter,

   405

	&ShipEngineRunningCostSorter,

   406

	&EngineReliabilitySorter,

   407

	&ShipEngineCapacitySorter,

   408

}, {

   409

	/* Aircraft */

   410

	&EngineNumberSorter,

   411

	&AircraftEngineCostSorter,

   412

	&AircraftEngineSpeedSorter,

   413

	&EngineIntroDateSorter,

   414

	&EngineNameSorter,

   415

	&AircraftEngineRunningCostSorter,

   416

	&EngineReliabilitySorter,

   417

	&AircraftEngineCargoSorter,

   418

}};

   419

   420

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

   421

	/* Trains */

   422

	STR_ENGINE_SORT_ENGINE_ID,

   423

	STR_ENGINE_SORT_COST,

   424

	STR_SORT_BY_MAX_SPEED,

   425

	STR_ENGINE_SORT_POWER,

   426

	STR_ENGINE_SORT_INTRO_DATE,

   427

	STR_SORT_BY_DROPDOWN_NAME,

   428

	STR_ENGINE_SORT_RUNNING_COST,

   429

	STR_ENGINE_SORT_POWER_VS_RUNNING_COST,

   430

	STR_SORT_BY_RELIABILITY,

   431

	STR_ENGINE_SORT_CARGO_CAPACITY,

   432

	INVALID_STRING_ID

   433

}, {

   434

	/* Road vehicles */

   435

	STR_ENGINE_SORT_ENGINE_ID,

   436

	STR_ENGINE_SORT_COST,

   437

	STR_SORT_BY_MAX_SPEED,

   438

	STR_ENGINE_SORT_INTRO_DATE,

   439

	STR_SORT_BY_DROPDOWN_NAME,

   440

	STR_ENGINE_SORT_RUNNING_COST,

   441

	STR_SORT_BY_RELIABILITY,

   442

	STR_ENGINE_SORT_CARGO_CAPACITY,

   443

	INVALID_STRING_ID

   444

}, {

   445

	/* Ships */

   446

	STR_ENGINE_SORT_ENGINE_ID,

   447

	STR_ENGINE_SORT_COST,

   448

	STR_SORT_BY_MAX_SPEED,

   449

	STR_ENGINE_SORT_INTRO_DATE,

   450

	STR_SORT_BY_DROPDOWN_NAME,

   451

	STR_ENGINE_SORT_RUNNING_COST,

   452

	STR_SORT_BY_RELIABILITY,

   453

	STR_ENGINE_SORT_CARGO_CAPACITY,

   454

	INVALID_STRING_ID

   455

}, {

   456

	/* Aircraft */

   457

	STR_ENGINE_SORT_ENGINE_ID,

   458

	STR_ENGINE_SORT_COST,

   459

	STR_SORT_BY_MAX_SPEED,

   460

	STR_ENGINE_SORT_INTRO_DATE,

   461

	STR_SORT_BY_DROPDOWN_NAME,

   462

	STR_ENGINE_SORT_RUNNING_COST,

   463

	STR_SORT_BY_RELIABILITY,

   464

	STR_ENGINE_SORT_CARGO_CAPACITY,

   465

	INVALID_STRING_ID

   466

}};

   467

   468

static int DrawCargoCapacityInfo(int x, int y, EngineID engine, VehicleType type, bool refittable)

   469

{

   470

	uint16 *cap = GetCapacityOfArticulatedParts(engine, type);

   471

   472

	for (uint c = 0; c < NUM_CARGO; c++) {

   473

		if (cap[c] == 0) continue;

   474

   475

		SetDParam(0, c);

   476

		SetDParam(1, cap[c]);

   477

		SetDParam(2, refittable ? STR_9842_REFITTABLE : STR_EMPTY);

   478

		DrawString(x, y, STR_PURCHASE_INFO_CAPACITY, TC_FROMSTRING);

   479

		y += 10;

   480

   481

		/* Only show as refittable once */

   482

		refittable = false;

   483

	}

   484

   485

	return y;

   486

}

   487

   488

/* Draw rail wagon specific details */

   489

static int DrawRailWagonPurchaseInfo(int x, int y, EngineID engine_number, const RailVehicleInfo *rvi)

   490

{

   491

	/* Purchase cost */

   492

	SetDParam(0, (GetEngineProperty(engine_number, 0x17, rvi->cost_factor) * _price.build_railwagon) >> 8);

   493

	DrawString(x, y, STR_PURCHASE_INFO_COST, TC_FROMSTRING);

   494

	y += 10;

   495

   496

	/* Wagon weight - (including cargo) */