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 "player_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

    33

#include "table/sprites.h"

    34

#include "table/strings.h"

    35

    36

enum BuildVehicleWidgets {

    37

	BUILD_VEHICLE_WIDGET_CLOSEBOX = 0,

    38

	BUILD_VEHICLE_WIDGET_CAPTION,

    39

	BUILD_VEHICLE_WIDGET_SORT_ASSENDING_DESCENDING,

    40

	BUILD_VEHICLE_WIDGET_SORT_DROPDOWN,

    41

	BUILD_VEHICLE_WIDGET_LIST,

    42

	BUILD_VEHICLE_WIDGET_SCROLLBAR,

    43

	BUILD_VEHICLE_WIDGET_PANEL,

    44

	BUILD_VEHICLE_WIDGET_BUILD,

    45

	BUILD_VEHICLE_WIDGET_RENAME,

    46

	BUILD_VEHICLE_WIDGET_RESIZE,

    47

	BUILD_VEHICLE_WIDGET_END

    48

};

    49

    50

static const Widget _build_vehicle_widgets[] = {

    51

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

    52

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

    53

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

    54

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

    55

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

    56

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

    57

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

    58

    59

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

    60

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

    61

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

    62

	{   WIDGETS_END},

    63

};

    64

    65

static bool _internal_sort_order; // descending/ascending

    66

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

    67

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

    68

    69

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

    70

{

    71

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

    72

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

    73

	int r = va - vb;

    74

    75

	return _internal_sort_order ? -r : r;

    76

}

    77

    78

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

    79

{

    80

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

    81

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

    82

	const int r = va - vb;

    83

    84

	if (r == 0) {

    85

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

    86

		return EngineNumberSorter(a, b);

    87

	}

    88

	return _internal_sort_order ? -r : r;

    89

}

    90

    91

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

    92

{

    93

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

    94

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

    95

    96

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

    97

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

    98

	int r;

    99

   100

	if (va != last_engine[0]) {

   101

		last_engine[0] = va;

   102

		SetDParam(0, va);

   103

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

   104

	}

   105

   106

	if (vb != last_engine[1]) {

   107

		last_engine[1] = vb;

   108

		SetDParam(0, vb);

   109

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

   110

	}

   111

   112

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

   113

   114

	if (r == 0) {

   115

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

   116

		return EngineNumberSorter(a, b);

   117

	}

   118

	return _internal_sort_order ? -r : r;

   119

}

   120

   121

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

   122

{

   123

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

   124

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

   125

	const int r = va - vb;

   126

   127

	if (r == 0) {

   128

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

   129

		return EngineNumberSorter(a, b);

   130

	}

   131

	return _internal_sort_order ? -r : r;

   132

}

   133

   134

/* Train sorting functions */

   135

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

   136

{

   137

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

   138

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

   139

	int r = va - vb;

   140

   141

	return _internal_sort_order ? -r : r;

   142

}

   143

   144

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

   145

{

   146

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

   147

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

   148

	int r = va - vb;

   149

   150

	return _internal_sort_order ? -r : r;

   151

}

   152

   153

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

   154

{

   155

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

   156

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

   157

   158

	int va = rvi_a->power;

   159

	int vb = rvi_b->power;

   160

	int r = va - vb;

   161

   162

	return _internal_sort_order ? -r : r;

   163

}

   164

   165

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

   166

{

   167

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

   168

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

   169

   170

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

   171

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

   172

	int r = ClampToI32(va - vb);

   173

   174

	return _internal_sort_order ? -r : r;

   175

}

   176

   177

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

   178

{

   179

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

   180

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

   181

   182

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

   183

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

   184

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

   185

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

   186

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

   187

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

   188

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

   189

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

   190

	int r = ClampToI32(vb - va);

   191

   192

	return _internal_sort_order ? -r : r;

   193

}

   194

   195

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

   196

{

   197

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

   198

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

   199

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

   200

   201

	return _internal_sort_order ? -r : r;

   202

}

   203

   204

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

   205

{

   206

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

   207

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

   208

	int r = va - vb;

   209

   210

	if (r == 0) {

   211

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

   212

		return EngineNumberSorter(a, b);

   213

	}

   214

	return _internal_sort_order ? -r : r;

   215

}

   216

   217

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

   218

{

   219

	EngineID va = *(const EngineID*)a;

   220

	EngineID vb = *(const EngineID*)b;

   221

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

   222

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

   223

	int r = val_a - val_b;

   224

   225

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

   226

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

   227

   228

	return _internal_sort_order ? -r : r;

   229

}

   230

   231

/* Road vehicle sorting functions */

   232

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

   233

{

   234

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

   235

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

   236

	int r = va - vb;

   237

   238

	return _internal_sort_order ? -r : r;

   239

}

   240

   241

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

   242

{

   243

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

   244

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

   245

	int r = va - vb;

   246

   247

	return _internal_sort_order ? -r : r;

   248

}

   249

   250

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

   251

{

   252

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

   253

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

   254

   255

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

   256

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

   257

	int r = ClampToI32(va - vb);

   258

   259

	if (r == 0) {

   260

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

   261

		return EngineNumberSorter(a, b);

   262

	}

   263

	return _internal_sort_order ? -r : r;

   264

}

   265

   266

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

   267

{

   268

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

   269

	int vb = RoadVehInfo(*(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

/* Road vehicle sorting functions */

   280

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

   281

{

   282

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

   283

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

   284

	int r = va - vb;

   285

   286

	return _internal_sort_order ? -r : r;

   287

}

   288

   289

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

   290

{

   291

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

   292

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

   293

	int r = va - vb;

   294

   295

	return _internal_sort_order ? -r : r;

   296

}

   297

   298

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

   299

{

   300

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

   301

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

   302

	const int r = va - vb;

   303

   304

	if (r == 0) {

   305

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

   306

		return EngineNumberSorter(a, b);

   307

	}

   308

	return _internal_sort_order ? -r : r;

   309

}

   310

   311

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

   312

{

   313

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

   314

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

   315

	int r = va - vb;

   316

   317

	if (r == 0) {

   318

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

   319

		return EngineNumberSorter(a, b);

   320

	}

   321

	return _internal_sort_order ? -r : r;

   322

}

   323

   324

/* Aircraft sorting functions */

   325

   326

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

   327

{

   328

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

   329

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

   330

	int r = va - vb;

   331

   332

	return _internal_sort_order ? -r : r;

   333

}

   334

   335

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

   336

{

   337

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

   338

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

   339

	const int r = va - vb;

   340

   341

	if (r == 0) {

   342

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

   343

		return EngineNumberSorter(a, b);

   344

	}

   345

	return _internal_sort_order ? -r : r;

   346

}

   347

   348

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

   349

{

   350

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

   351

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

   352

	const int r = va - vb;

   353

   354

	if (r == 0) {

   355

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

   356

		return EngineNumberSorter(a, b);

   357

	}

   358

	return _internal_sort_order ? -r : r;

   359

}

   360

   361

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

   362

{

   363

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

   364

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

   365

	int r = va - vb;

   366

   367

	if (r == 0) {

   368

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

   369

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

   370

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

   371

		r = va - vb;

   372

   373

		if (r == 0) {

   374

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

   375

			return EngineNumberSorter(a, b);

   376

		}

   377

	}

   378

	return _internal_sort_order ? -r : r;

   379

}

   380

   381

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

   382

	/* Trains */

   383

	&TrainEngineNumberSorter,

   384

	&TrainEngineCostSorter,

   385

	&TrainEngineSpeedSorter,

   386

	&TrainEnginePowerSorter,

   387

	&EngineIntroDateSorter,

   388

	&EngineNameSorter,

   389

	&TrainEngineRunningCostSorter,

   390

	&TrainEnginePowerVsRunningCostSorter,

   391

	&EngineReliabilitySorter,

   392

	&TrainEngineCapacitySorter,

   393

}, {

   394

	/* Road vehicles */

   395

	&EngineNumberSorter,

   396

	&RoadVehEngineCostSorter,

   397

	&RoadVehEngineSpeedSorter,

   398

	&EngineIntroDateSorter,

   399

	&EngineNameSorter,

   400

	&RoadVehEngineRunningCostSorter,

   401

	&EngineReliabilitySorter,

   402

	&RoadVehEngineCapacitySorter,

   403

}, {

   404

	/* Ships */

   405

	&EngineNumberSorter,

   406

	&ShipEngineCostSorter,

   407

	&ShipEngineSpeedSorter,

   408

	&EngineIntroDateSorter,

   409

	&EngineNameSorter,

   410

	&ShipEngineRunningCostSorter,

   411

	&EngineReliabilitySorter,

   412

	&ShipEngineCapacitySorter,

   413

}, {

   414

	/* Aircraft */

   415

	&EngineNumberSorter,

   416

	&AircraftEngineCostSorter,

   417

	&AircraftEngineSpeedSorter,

   418

	&EngineIntroDateSorter,

   419

	&EngineNameSorter,

   420

	&AircraftEngineRunningCostSorter,

   421

	&EngineReliabilitySorter,

   422

	&AircraftEngineCargoSorter,

   423

}};

   424

   425

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

   426

	/* Trains */

   427

	STR_ENGINE_SORT_ENGINE_ID,

   428

	STR_ENGINE_SORT_COST,

   429

	STR_SORT_BY_MAX_SPEED,

   430

	STR_ENGINE_SORT_POWER,

   431

	STR_ENGINE_SORT_INTRO_DATE,

   432

	STR_SORT_BY_DROPDOWN_NAME,

   433

	STR_ENGINE_SORT_RUNNING_COST,

   434

	STR_ENGINE_SORT_POWER_VS_RUNNING_COST,

   435

	STR_SORT_BY_RELIABILITY,

   436

	STR_ENGINE_SORT_CARGO_CAPACITY,

   437

	INVALID_STRING_ID

   438

}, {

   439

	/* Road vehicles */

   440

	STR_ENGINE_SORT_ENGINE_ID,

   441

	STR_ENGINE_SORT_COST,

   442

	STR_SORT_BY_MAX_SPEED,

   443

	STR_ENGINE_SORT_INTRO_DATE,

   444

	STR_SORT_BY_DROPDOWN_NAME,

   445

	STR_ENGINE_SORT_RUNNING_COST,

   446

	STR_SORT_BY_RELIABILITY,

   447

	STR_ENGINE_SORT_CARGO_CAPACITY,

   448

	INVALID_STRING_ID

   449

}, {

   450

	/* Ships */

   451

	STR_ENGINE_SORT_ENGINE_ID,

   452

	STR_ENGINE_SORT_COST,

   453

	STR_SORT_BY_MAX_SPEED,

   454

	STR_ENGINE_SORT_INTRO_DATE,

   455

	STR_SORT_BY_DROPDOWN_NAME,

   456

	STR_ENGINE_SORT_RUNNING_COST,

   457

	STR_SORT_BY_RELIABILITY,

   458

	STR_ENGINE_SORT_CARGO_CAPACITY,

   459

	INVALID_STRING_ID

   460

}, {

   461

	/* Aircraft */

   462

	STR_ENGINE_SORT_ENGINE_ID,

   463

	STR_ENGINE_SORT_COST,

   464

	STR_SORT_BY_MAX_SPEED,

   465

	STR_ENGINE_SORT_INTRO_DATE,

   466

	STR_SORT_BY_DROPDOWN_NAME,

   467

	STR_ENGINE_SORT_RUNNING_COST,

   468

	STR_SORT_BY_RELIABILITY,

   469

	STR_ENGINE_SORT_CARGO_CAPACITY,

   470

	INVALID_STRING_ID

   471

}};

   472

   473

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

   474

{

   475

	uint16 *cap = GetCapacityOfArticulatedParts(engine, type);

   476

   477

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

   478

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

   479

   480

		SetDParam(0, c);

   481

		SetDParam(1, cap[c]);

   482

		SetDParam(2, refittable ? STR_9842_REFITTABLE : STR_EMPTY);

   483

		DrawString(x, y, STR_PURCHASE_INFO_CAPACITY, TC_FROMSTRING);

   484

		y += 10;

   485

   486

		/* Only show as refittable once */

   487

		refittable = false;

   488

	}

   489

   490

	return y;

   491

}

   492

   493

/* Draw rail wagon specific details */

   494

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

   495

{

   496

	/* Purchase cost */

   497