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

    13

#include "table/sprites.h"

    14

#include "table/strings.h"

    15

#include "window.h"

    16

#include "gui.h"

    17

#include "vehicle.h"

    18

#include "gfx.h"

    19

#include "station.h"

    20

#include "command.h"

    21

#include "engine.h"

    22

#include "player.h"

    23

#include "depot.h"

    24

#include "airport.h"

    25

#include "vehicle_gui.h"

    26

#include "newgrf_engine.h"

    27

#include "date.h"

    28

#include "strings.h"

    29

#include "cargotype.h"

    30

    31

    32

enum BuildVehicleWidgets {

    33

	BUILD_VEHICLE_WIDGET_CLOSEBOX = 0,

    34

	BUILD_VEHICLE_WIDGET_CAPTION,

    35

	BUILD_VEHICLE_WIDGET_SORT_ASSENDING_DESCENDING,

    36

	BUILD_VEHICLE_WIDGET_SORT_TEXT,

    37

	BUILD_VEHICLE_WIDGET_SORT_DROPDOWN,

    38

	BUILD_VEHICLE_WIDGET_LIST,

    39

	BUILD_VEHICLE_WIDGET_SCROLLBAR,

    40

	BUILD_VEHICLE_WIDGET_PANEL,

    41

	BUILD_VEHICLE_WIDGET_BUILD,

    42

	BUILD_VEHICLE_WIDGET_RENAME,

    43

	BUILD_VEHICLE_WIDGET_RESIZE,

    44

};

    45

    46

static const Widget _build_vehicle_widgets[] = {

    47

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

    48

	{    WWT_CAPTION,  RESIZE_RIGHT,    14,    11,   227,     0,    13, 0x0,                     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_RIGHT,    14,    81,   215,    14,    25, 0x0,                     STR_SORT_CRITERIA_TIP},

    51

	{    WWT_TEXTBTN,     RESIZE_LR,    14,   216,   227,    14,    25, STR_0225,                STR_SORT_CRITERIA_TIP},

    52

	{     WWT_MATRIX,     RESIZE_RB,    14,     0,   215,    26,   121, 0x0,                     STR_NULL },

    53

	{  WWT_SCROLLBAR,    RESIZE_LRB,    14,   216,   227,    26,   121, 0x0,                     STR_0190_SCROLL_BAR_SCROLLS_LIST },

    54

	{      WWT_PANEL,    RESIZE_RTB,    14,     0,   227,   122,   223, 0x0,                     STR_NULL },

    55

    56

	{ WWT_PUSHTXTBTN,     RESIZE_TB,    14,     0,   114,   224,   235, 0x0,                     STR_NULL },

    57

	{ WWT_PUSHTXTBTN,    RESIZE_RTB,    14,   115,   215,   224,   235, 0x0,                     STR_NULL },

    58

	{  WWT_RESIZEBOX,   RESIZE_LRTB,    14,   216,   227,   224,   235, 0x0,                     STR_RESIZE_BUTTON },

    59

	{   WIDGETS_END},

    60

};

    61

    62

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

    63

static void SetupWindowStrings(Window *w, byte type)

    64

{

    65

	switch (type) {

    66

		case VEH_TRAIN:

    67

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

    68

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

    69

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

    70

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

    71

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

    72

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

    73

			break;

    74

		case VEH_ROAD:

    75

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

    76

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

    77

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

    78

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

    79

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

    80

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

    81

			break;

    82

		case VEH_SHIP:

    83

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

    84

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

    85

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

    86

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

    87

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

    88

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

    89

			break;

    90

		case VEH_AIRCRAFT:

    91

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

    92

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

    93

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

    94

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

    95

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

    96

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

    97

			break;

    98

	}

    99

}

   100

   101

static bool _internal_sort_order; // descending/ascending

   102

   103

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

   104

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

   105

   106

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

   107

{

   108

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

   109

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

   110

	int r = va - vb;

   111

   112

	return _internal_sort_order ? -r : r;

   113

}

   114

   115

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

   116

{

   117

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

   118

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

   119

	const int r = va - vb;

   120

   121

	if (r == 0) {

   122

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

   123

		return EngineNumberSorter(a, b);

   124

	}

   125

	return _internal_sort_order ? -r : r;

   126

}

   127

   128

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

   129

{

   130

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

   131

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

   132

   133

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

   134

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

   135

	int r;

   136

   137

	if (va != last_engine[0]) {

   138

		last_engine[0] = va;

   139

		GetString(last_name[0], GetCustomEngineName(va), lastof(last_name[0]));

   140

	}

   141

   142

	if (vb != last_engine[1]) {

   143

		last_engine[1] = vb;

   144

		GetString(last_name[1], GetCustomEngineName(vb), lastof(last_name[1]));

   145

	}

   146

   147

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

   148

   149

	if (r == 0) {

   150

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

   151

		return EngineNumberSorter(a, b);

   152

	}

   153

	return _internal_sort_order ? -r : r;

   154

}

   155

   156

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

   157

{

   158

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

   159

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

   160

	const int r = va - vb;

   161

   162

	if (r == 0) {

   163

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

   164

		return EngineNumberSorter(a, b);

   165

	}

   166

	return _internal_sort_order ? -r : r;

   167

}

   168

   169

/* Train sorting functions */

   170

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

   171

{

   172

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

   173

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

   174

	int r = va - vb;

   175

   176

	return _internal_sort_order ? -r : r;

   177

}

   178

   179

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

   180

{

   181

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

   182

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

   183

	int r = va - vb;

   184

   185

	return _internal_sort_order ? -r : r;

   186

}

   187

   188

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

   189

{

   190

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

   191

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

   192

   193

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

   194

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

   195

	int r = va - vb;

   196

   197

	return _internal_sort_order ? -r : r;

   198

}

   199

   200

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

   201

{

   202

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

   203

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

   205

   222

	int r = va - vb;

   223

   224

	return _internal_sort_order ? -r : r;

   225

}

   226

   227

static int CDECL TrainEnginePowerVsRunningCostSorter(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);

   246

   247

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

   248

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

   249

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

   250

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

   251

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

   252

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

   255

	int r = vb - va;

   256

   257

	return _internal_sort_order ? -r : r;

   258

}

   259

   260

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

   261

{

   262

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

   263

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

   264

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

   265

   266

	return _internal_sort_order ? -r : r;

   267

}

   268

   269

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

   270

{

   271

	EngineID va = *(const EngineID*)a;

   272

	EngineID vb = *(const EngineID*)b;

   273

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

   274

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

   275

	int r = val_a - val_b;

   276

   277

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

   278

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

   279

   280

	return _internal_sort_order ? -r : r;

   281

}

   282

   283

/* Aircraft sorting functions */

   284

   285

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

   286

{

   287

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

   288

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

   289

	int r = va - vb;

   290

   291

	return _internal_sort_order ? -r : r;

   292

}

   293

   294

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

   295

{

   296

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

   297

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

   298

	const int r = va - vb;

   299

   300

	if (r == 0) {

   301

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

   302

		return EngineNumberSorter(a, b);

   303

	}

   304

	return _internal_sort_order ? -r : r;

   305

}

   306

   307

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

   308

{

   309

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

   310

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

   311

	const int r = va - vb;

   312

   313

	if (r == 0) {

   314

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

   315

		return EngineNumberSorter(a, b);

   316

	}

   317

	return _internal_sort_order ? -r : r;

   318

}

   319

   320

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

   321

{

   322

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

   323

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

   324

	const int r = va - vb;

   325

   326

	if (r == 0) {

   327

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

   328

		return EngineNumberSorter(a, b);

   329

	}

   330

	return _internal_sort_order ? -r : r;

   331

}

   332

   333

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

   334

	/* Trains */

   335

	&TrainEngineNumberSorter,

   336

	&TrainEngineCostSorter,

   337

	&TrainEngineSpeedSorter,

   338

	&TrainEnginePowerSorter,

   339

	&EngineIntroDateSorter,

   340

	&EngineNameSorter,

   341

	&TrainEngineRunningCostSorter,

   342

	&TrainEnginePowerVsRunningCostSorter,

   343

	&EngineReliabilitySorter,

   344

},{

   345

	/* Road vehicles */

   346

	&EngineNumberSorter,

   347

	&EngineIntroDateSorter,

   348

	&EngineNameSorter,

   349

	&EngineReliabilitySorter,

   350

},{

   351

	/* Ships */

   352

	&EngineNumberSorter,

   353

	&EngineIntroDateSorter,

   354

	&EngineNameSorter,

   355

	&EngineReliabilitySorter,

   356

},{

   357

	/* Aircraft */

   358

	&EngineNumberSorter,

   359

	&AircraftEngineCostSorter,

   360

	&AircraftEngineSpeedSorter,

   361

	&EngineIntroDateSorter,

   362

	&EngineNameSorter,

   363

	&AircraftEngineRunningCostSorter,

   364

	&EngineReliabilitySorter,

   365

	&AircraftEngineCargoSorter,

   366

}};

   367

   368

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

   369

	/* Trains */

   370

	STR_ENGINE_SORT_ENGINE_ID,

   371

	STR_ENGINE_SORT_COST,

   372

	STR_SORT_BY_MAX_SPEED,

   373

	STR_ENGINE_SORT_POWER,

   374

	STR_ENGINE_SORT_INTRO_DATE,

   375

	STR_SORT_BY_DROPDOWN_NAME,

   376

	STR_ENGINE_SORT_RUNNING_COST,

   377

	STR_ENGINE_SORT_POWER_VS_RUNNING_COST,

   378

	STR_SORT_BY_RELIABILITY,

   379

	INVALID_STRING_ID

   380

},{

   381

	/* Road vehicles */

   382

	STR_ENGINE_SORT_ENGINE_ID,

   383

	STR_ENGINE_SORT_INTRO_DATE,

   384

	STR_SORT_BY_DROPDOWN_NAME,

   385

	STR_SORT_BY_RELIABILITY,

   386

	INVALID_STRING_ID

   387

},{

   388

	/* Ships */

   389

	STR_ENGINE_SORT_ENGINE_ID,

   390

	STR_ENGINE_SORT_INTRO_DATE,

   391

	STR_SORT_BY_DROPDOWN_NAME,

   392

	STR_SORT_BY_RELIABILITY,

   393

	INVALID_STRING_ID

   394

},{

   395

	/* Aircraft */

   396

	STR_ENGINE_SORT_ENGINE_ID,

   397

	STR_ENGINE_SORT_COST,

   398

	STR_SORT_BY_MAX_SPEED,

   399

	STR_ENGINE_SORT_INTRO_DATE,

   400

	STR_SORT_BY_DROPDOWN_NAME,

   401

	STR_ENGINE_SORT_RUNNING_COST,

   402

	STR_SORT_BY_RELIABILITY,

   403

	STR_ENGINE_SORT_CARGO_CAPACITY,

   404

	INVALID_STRING_ID

   405

}};

   406

   407

/* Draw rail wagon specific details */

   408

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

   409

{

   410

	/* Purchase cost */

   412

	DrawString(x, y, STR_PURCHASE_INFO_COST, 0);

   413

	y += 10;

   414

   415

	/* Wagon weight - (including cargo) */

   416

	SetDParam(0, rvi->weight);

   417

	SetDParam(1, (GetCargo(rvi->cargo_type)->weight * rvi->capacity >> 4) + rvi->weight);

   418

	DrawString(x, y, STR_PURCHASE_INFO_WEIGHT_CWEIGHT, 0);

   419

	y += 10;

   420

   421

	/* Wagon speed limit, displayed if above zero */

   422

	if (rvi->max_speed > 0 && _patches.wagon_speed_limits) {

   423

		SetDParam(0, rvi->max_speed * 10 / 16);

   424

		DrawString(x,y, STR_PURCHASE_INFO_SPEED, 0);

   425

		y += 10;

   426

	}

   427

	return y;

   428

}

   429

   430

/* Draw locomotive specific details */

   431

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

   432

{

   433

	int multihead = (rvi->railveh_type == RAILVEH_MULTIHEAD ? 1 : 0);

   434

   435

	/* Purchase Cost - Engine weight */

   437

	SetDParam(1, rvi->weight << multihead);

   438

	DrawString(x,y, STR_PURCHASE_INFO_COST_WEIGHT, 0);

   439

	y += 10;

   440

   441

	/* Max speed - Engine power */

   442

	SetDParam(0, rvi->max_speed * 10 / 16);

   443

	SetDParam(1, rvi->power << multihead);

   444

	DrawString(x,y, STR_PURCHASE_INFO_SPEED_POWER, 0);

   445

	y += 10;

   446

   447

	/* Max tractive effort - not applicable if old acceleration or maglev */

   448

	if (_patches.realistic_acceleration && rvi->railtype != RAILTYPE_MAGLEV) {

   449

		SetDParam(0, ((rvi->weight << multihead) * 10 * rvi->tractive_effort) / 256);

   450

		DrawString(x, y, STR_PURCHASE_INFO_MAX_TE, 0);

   451

		y += 10;

   452

	}

   453

   463

	/* Running cost */

   465

	DrawString(x,y, STR_PURCHASE_INFO_RUNNINGCOST, 0);

   466

	y += 10;

   467

   468

	/* Powered wagons power - Powered wagons extra weight */

   469

	if (rvi->pow_wag_power != 0) {

   470

		SetDParam(0, rvi->pow_wag_power);

   471

		SetDParam(1, rvi->pow_wag_weight);

   472

		DrawString(x,y, STR_PURCHASE_INFO_PWAGPOWER_PWAGWEIGHT, 0);

   473

		y += 10;

   474

	};

   475

   476

	return y;

   477

}

   478

   479

/* Draw road vehicle specific details */

   480

static int DrawRoadVehPurchaseInfo(int x, int y, EngineID engine_number, const RoadVehicleInfo *rvi)

   481

{

   482

	bool refittable = (_engine_info[engine_number].refit_mask != 0);

   483

   484

	/* Purchase cost - Max speed */

   486

	SetDParam(1, rvi->max_speed * 10 / 32);

   487

	DrawString(x, y, STR_PURCHASE_INFO_COST_SPEED, 0);

   488

	y += 10;

   489

   490

	/* Running cost */

   492

	DrawString(x, y, STR_PURCHASE_INFO_RUNNINGCOST, 0);

   493

	y += 10;

   494

   495

	/* Cargo type + capacity */

   496

	SetDParam(0, rvi->cargo_type);

   497

	SetDParam(1, rvi->capacity);

   498

	SetDParam(2, refittable ? STR_9842_REFITTABLE : STR_EMPTY);

   499