1

/* $Id$ */

     2

     3

/** @file train_gui.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "debug.h"

     8

#include "functions.h"

     9

#include "table/sprites.h"

    10

#include "table/strings.h"

    11

#include "strings.h"

    12

#include "window.h"

    13

#include "gui.h"

    14

#include "vehicle.h"

    15

#include "viewport.h"

    16

#include "command.h"

    17

#include "vehicle_gui.h"

    18

#include "depot.h"

    19

#include "train.h"

    20

#include "newgrf_engine.h"

    21

    22

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

    23

{

    24

	Vehicle *v, *found;

    25

    26

	if (!success) return;

    27

    28

	/* find a locomotive in the depot. */

    29

	found = NULL;

    30

	FOR_ALL_VEHICLES(v) {

    31

		if (v->type == VEH_TRAIN && IsFrontEngine(v) &&

    32

				v->tile == tile &&

    33

				v->u.rail.track == TRACK_BIT_DEPOT) {

    34

			if (found != NULL) return; // must be exactly one.

    35

			found = v;

    36

		}

    37

	}

    38

    39

	/* if we found a loco, */

    40

	if (found != NULL) {

    41

		found = GetLastVehicleInChain(found);

    42

		/* put the new wagon at the end of the loco. */

    43

		DoCommandP(0, _new_vehicle_id | (found->index << 16), 0, NULL, CMD_MOVE_RAIL_VEHICLE);

    44

		RebuildVehicleLists();

    45

	}

    46

}

    47

    48

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

    49

{

    50

	const Vehicle *v;

    51

    52

	if (!success) return;

    53

    54

	v = GetVehicle(_new_vehicle_id);

    55

	if (tile == _backup_orders_tile) {

    56

		_backup_orders_tile = 0;

    57

		RestoreVehicleOrders(v, _backup_orders_data);

    58

	}

    60

}

    61

    62

/**

    63

 * Get the number of pixels for the given wagon length.

    64

 * @param len Length measured in 1/8ths of a standard wagon.

    65

 * @return Number of pixels across.

    66

 */

    67

int WagonLengthToPixels(int len)

    68

{

    69

	return (len * _traininfo_vehicle_width) / 8;

    70

}

    71

    72

void DrawTrainImage(const Vehicle *v, int x, int y, int count, int skip, VehicleID selection)

    73

{

    74

	DrawPixelInfo tmp_dpi, *old_dpi;

    75

	int dx = -(skip * 8) / _traininfo_vehicle_width;

    76

	/* Position of highlight box */

    77

	int highlight_l = 0;

    78

	int highlight_r = 0;

    79

    80

	if (!FillDrawPixelInfo(&tmp_dpi, x - 2, y - 1, count + 1, 14)) return;

    81

    82

	count = (count * 8) / _traininfo_vehicle_width;

    83

    84

	old_dpi = _cur_dpi;

    85

	_cur_dpi = &tmp_dpi;

    86

    87

	do {

    88

		int width = v->u.rail.cached_veh_length;

    89

    90

		if (dx + width > 0) {

    91

			if (dx <= count) {

    92

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

    93

				DrawSprite(v->GetImage(DIR_W), pal, 16 + WagonLengthToPixels(dx), 7 + (is_custom_sprite(RailVehInfo(v->engine_type)->image_index) ? _traininfo_vehicle_pitch : 0));

    94

				if (v->index == selection) {

    95

					/* Set the highlight position */

    96

					highlight_l = WagonLengthToPixels(dx) + 1;

    97

					highlight_r = WagonLengthToPixels(dx + width) + 1;

    98

				}

    99

			}

   100

		}

   101

		dx += width;

   102

   103

		v = v->next;

   104

	} while (dx < count && v != NULL);

   105

   106

	if (highlight_l != highlight_r) {

   107

		/* Draw the highlight. Now done after drawing all the engines, as

   108

		 * the next engine after the highlight could overlap it. */

   109

		DrawFrameRect(highlight_l, 0, highlight_r, 13, 15, FR_BORDERONLY);

   110

	}

   111

   112

	_cur_dpi = old_dpi;

   113

}

   114

   115

static void TrainDetailsCargoTab(const Vehicle *v, int x, int y)

   116

{

   117

	if (v->cargo_cap != 0) {

   118

		StringID str = STR_8812_EMPTY;

   119

   120

		if (!v->cargo.Empty()) {

   121

			SetDParam(0, v->cargo_type);

   122

			SetDParam(1, v->cargo.Count());

   123

			SetDParam(2, v->cargo.Source());

   124

			SetDParam(3, _patches.freight_trains);

   125

			str = FreightWagonMult(v->cargo_type) > 1 ? STR_FROM_MULT : STR_8813_FROM;

   126

		}

   127

		DrawString(x, y, str, 0);

   128

	}

   129

}

   130

   131

static void TrainDetailsInfoTab(const Vehicle *v, int x, int y)

   132

{

   133

	if (RailVehInfo(v->engine_type)->railveh_type == RAILVEH_WAGON) {

   134

		SetDParam(0, v->engine_type);

   135

		SetDParam(1, v->value);

   136

		DrawString(x, y, STR_882D_VALUE, 0x10);

   137

	} else {

   138

		SetDParam(0, v->engine_type);

   139

		SetDParam(1, v->build_year);

   140

		SetDParam(2, v->value);

   141

		DrawString(x, y, STR_882C_BUILT_VALUE, 0x10);

   142

	}

   143

}

   144

   145

static void TrainDetailsCapacityTab(const Vehicle *v, int x, int y)

   146

{

   147

	if (v->cargo_cap != 0) {

   148

		SetDParam(0, v->cargo_type);

   149

		SetDParam(1, v->cargo_cap);

   150

		SetDParam(2, _patches.freight_trains);

   151

		DrawString(x, y, FreightWagonMult(v->cargo_type) > 1 ? STR_CAPACITY_MULT : STR_013F_CAPACITY, 0);

   152

	}

   153

}

   154

   155

   156

static void DrawTrainDetailsWindow(Window *w)

   157

{

   158

	byte det_tab = WP(w, traindetails_d).tab;

   159

	const Vehicle *v;

   160

	const Vehicle *u;

   161

	AcceptedCargo act_cargo;

   162

	AcceptedCargo max_cargo;

   163

	int num;

   164

	int x;

   165

	int y;

   166

	int sel;

   167

   168

	num = 0;

   169

	u = v = GetVehicle(w->window_number);

   170

	if (det_tab == 3) { // Total cargo tab

   171

		for (CargoID i = 0; i < lengthof(act_cargo); i++) {

   172

			act_cargo[i] = 0;

   173

			max_cargo[i] = 0;

   174

		}

   175

   176

		do {

   177

			act_cargo[u->cargo_type] += u->cargo.Count();

   178

			max_cargo[u->cargo_type] += u->cargo_cap;

   179

		} while ((u = u->next) != NULL);

   180

   181

		/* Set scroll-amount seperately from counting, as to not compute num double

   182

		 * for more carriages of the same type

   183

		 */

   184

		for (CargoID i = 0; i < NUM_CARGO; i++) {

   185

			if (max_cargo[i] > 0) num++; // only count carriages that the train has

   186

		}

   187

		num++; // needs one more because first line is description string

   188

	} else {

   189

		do {

   190

			if (!IsArticulatedPart(u) || u->cargo_cap != 0) num++;

   191

		} while ((u = u->next) != NULL);

   192

	}

   193

   194

	SetVScrollCount(w, num);

   195

   196

	DisableWindowWidget(w, det_tab + 9);

   197

	SetWindowWidgetDisabledState(w, 2, v->owner != _local_player);

   198

   199

	/* disable service-scroller when interval is set to disabled */

   200

	SetWindowWidgetDisabledState(w, 6, !_patches.servint_trains);

   201

	SetWindowWidgetDisabledState(w, 7, !_patches.servint_trains);

   202

   203

	SetDParam(0, v->index);

   204

	DrawWindowWidgets(w);

   205

   206

	SetDParam(1, v->age / 366);

   207

   208

	x = 2;

   209

   210

	SetDParam(0, (v->age + 365 < v->max_age) ? STR_AGE : STR_AGE_RED);

   211

	SetDParam(2, v->max_age / 366);

   212

	SetDParam(3, GetTrainRunningCost(v) >> 8);

   213

	DrawString(x, 15, STR_885D_AGE_RUNNING_COST_YR, 0);

   214

   215

	SetDParam(2, v->GetDisplayMaxSpeed());

   216

	SetDParam(1, v->u.rail.cached_power);

   217

	SetDParam(0, v->u.rail.cached_weight);

   218

	SetDParam(3, v->u.rail.cached_max_te / 1000);

   219

	DrawString(x, 25, (_patches.realistic_acceleration && v->u.rail.railtype != RAILTYPE_MAGLEV) ?

   220

		STR_VEHICLE_INFO_WEIGHT_POWER_MAX_SPEED_MAX_TE :

   221

		STR_VEHICLE_INFO_WEIGHT_POWER_MAX_SPEED, 0);

   222

   223

	SetDParam(0, v->profit_this_year);

   224

	SetDParam(1, v->profit_last_year);

   225

	DrawString(x, 35, STR_885F_PROFIT_THIS_YEAR_LAST_YEAR, 0);

   226

   227

	SetDParam(0, 100 * (v->reliability>>8) >> 8);

   228

	SetDParam(1, v->breakdowns_since_last_service);

   229

	DrawString(x, 45, STR_8860_RELIABILITY_BREAKDOWNS, 0);

   230

   231

	SetDParam(0, v->service_interval);

   232

	SetDParam(1, v->date_of_last_service);

   233

	DrawString(x + 11, 57 + (w->vscroll.cap * 14), _patches.servint_ispercent ? STR_SERVICING_INTERVAL_PERCENT : STR_883C_SERVICING_INTERVAL_DAYS, 0);

   234

   235

	y = 57;

   236

	sel = w->vscroll.pos;

   237

   238

	/* draw the first 3 details tabs */

   239

	if (det_tab != 3) {

   240

		x = 1;

   241

		for (;;) {

   242

			if (--sel < 0 && sel >= -w->vscroll.cap) {

   243

				int dx = 0;

   244

				int px;

   245

				int py;

   246

   247

				u = v;

   248

				do {

   249

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

   250

					DrawSprite(u->GetImage(DIR_W), pal, x + WagonLengthToPixels(4 + dx), y + 6 + (is_custom_sprite(RailVehInfo(u->engine_type)->image_index) ? _traininfo_vehicle_pitch : 0));

   251

					dx += u->u.rail.cached_veh_length;

   252

					u = u->next;

   253

				} while (u != NULL && IsArticulatedPart(u) && u->cargo_cap == 0);

   254

   255

				px = x + WagonLengthToPixels(dx) + 2;

   256

				py = y + 2;

   257

				switch (det_tab) {

   258

					default: NOT_REACHED();

   259

					case 0: TrainDetailsCargoTab(   v, px, py); break;

   260

					case 1:

   261

						/* Only show name and value for the 'real' part */

   262

						if (!IsArticulatedPart(v)) {

   263

							TrainDetailsInfoTab(v, px, py);

   264

						}

   265

						break;

   266

					case 2: TrainDetailsCapacityTab(v, px, py); break;

   267

				}

   268

				y += 14;

   269

   270

				v = u;

   271

			} else {

   272

				/* Move to the next line */

   273

				do {

   274

					v = v->next;

   275

				} while (v != NULL && IsArticulatedPart(v) && v->cargo_cap == 0);

   276

			}

   277

			if (v == NULL) return;

   278

		}

   279

	} else {

   280

		/* draw total cargo tab */

   281

		DrawString(x, y + 2, STR_013F_TOTAL_CAPACITY_TEXT, 0);

   282

		for (CargoID i = 0; i < NUM_CARGO; i++) {

   283

			if (max_cargo[i] > 0 && --sel < 0 && sel > -w->vscroll.cap) {

   284

				y += 14;

   285

				SetDParam(0, i);            // {CARGO} #1

   286

				SetDParam(1, act_cargo[i]); // {CARGO} #2

   287

				SetDParam(2, i);            // {SHORTCARGO} #1

   288

				SetDParam(3, max_cargo[i]); // {SHORTCARGO} #2

   289

				SetDParam(4, _patches.freight_trains);

   290

				DrawString(x, y + 2, FreightWagonMult(i) > 1 ? STR_TOTAL_CAPACITY_MULT : STR_013F_TOTAL_CAPACITY, 0);

   291

			}

   292

		}

   293

		SetDParam(0, v->cargo.FeederShare());

   294

		DrawString(x, y + 15, STR_FEEDER_CARGO_VALUE, 0);

   295

	}

   296

}

   297

   298

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

   299

{

   300

	switch (e->event) {

   301

	case WE_PAINT:

   302

		DrawTrainDetailsWindow(w);

   303

		break;

   304

	case WE_CLICK: {

   305

		int mod;

   306

		const Vehicle *v;

   307

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

   308

		case 2: /* name train */

   309

			v = GetVehicle(w->window_number);

   310

			SetDParam(0, v->index);

   311

			ShowQueryString(STR_VEHICLE_NAME, STR_8865_NAME_TRAIN, 31, 150, w, CS_ALPHANUMERAL);

   312

			break;

   313

		case 6: /* inc serv interval */

   314

			mod = _ctrl_pressed? 5 : 10;

   315

			goto do_change_service_int;

   316

   317

		case 7: /* dec serv interval */

   318

			mod = _ctrl_pressed? -5 : -10;

   319

do_change_service_int:

   320

			v = GetVehicle(w->window_number);

   321

   322

			mod = GetServiceIntervalClamped(mod + v->service_interval);

   323

			if (mod == v->service_interval) return;

   324

   325

			DoCommandP(v->tile, v->index, mod, NULL, CMD_CHANGE_SERVICE_INT | CMD_MSG(STR_018A_CAN_T_CHANGE_SERVICING));

   326

			break;

   327

		/* details buttons*/

   328

		case 9:  // Cargo

   329

		case 10: // Information

   330

		case 11: // Capacities

   331

		case 12: // Total cargo

   332

			EnableWindowWidget(w,  9);

   333

			EnableWindowWidget(w, 10);

   334

			EnableWindowWidget(w, 11);

   335

			EnableWindowWidget(w, 12);

   336

			EnableWindowWidget(w, e->we.click.widget);

   337

			WP(w,traindetails_d).tab = e->we.click.widget - 9;

   338

			SetWindowDirty(w);

   339

			break;

   340

		}

   341

	} break;

   342

   343

	case WE_ON_EDIT_TEXT:

   344

		if (e->we.edittext.str[0] != '\0') {

   345

			_cmd_text = e->we.edittext.str;

   346

			DoCommandP(0, w->window_number, 0, NULL,

   347

				CMD_NAME_VEHICLE | CMD_MSG(STR_8866_CAN_T_NAME_TRAIN));

   348

		}

   349

		break;

   350

   351

	case WE_RESIZE:

   352

		if (e->we.sizing.diff.x != 0) ResizeButtons(w, 9, 12);

   353

		if (e->we.sizing.diff.y == 0) break;

   354

   355

		w->vscroll.cap += e->we.sizing.diff.y / 14;

   356

		w->widget[4].data = (w->vscroll.cap << 8) + 1;

   357

		break;

   358

	}

   359

}

   360

   361

static const Widget _train_details_widgets[] = {

   362

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

   363

{    WWT_CAPTION, RESIZE_RIGHT,  14,  11, 329,   0,  13, STR_8802_DETAILS,     STR_018C_WINDOW_TITLE_DRAG_THIS},

   364

{ WWT_PUSHTXTBTN, RESIZE_LR,     14, 330, 369,   0,  13, STR_01AA_NAME,        STR_8867_NAME_TRAIN},

   365

{      WWT_PANEL, RESIZE_RIGHT,  14,   0, 369,  14,  55, 0x0,                  STR_NULL},

   366

{     WWT_MATRIX, RESIZE_RB,     14,   0, 357,  56, 139, 0x601,                STR_NULL},

   367

{  WWT_SCROLLBAR, RESIZE_LRB,    14, 358, 369,  56, 139, 0x0,                  STR_0190_SCROLL_BAR_SCROLLS_LIST},

   368

{ WWT_PUSHTXTBTN, RESIZE_TB,     14,   0,  10, 140, 145, STR_0188,             STR_884D_INCREASE_SERVICING_INTERVAL},

   369

{ WWT_PUSHTXTBTN, RESIZE_TB,     14,   0,  10, 146, 151, STR_0189,             STR_884E_DECREASE_SERVICING_INTERVAL},

   370

{      WWT_PANEL, RESIZE_RTB,    14,  11, 369, 140, 151, 0x0,                  STR_NULL},

   371

{ WWT_PUSHTXTBTN, RESIZE_TB,     14,   0,  89, 152, 163, STR_013C_CARGO,       STR_884F_SHOW_DETAILS_OF_CARGO_CARRIED},

   372

{ WWT_PUSHTXTBTN, RESIZE_TB,     14,  90, 178, 152, 163, STR_013D_INFORMATION, STR_8850_SHOW_DETAILS_OF_TRAIN_VEHICLES},

   373

{ WWT_PUSHTXTBTN, RESIZE_TB,     14, 179, 268, 152, 163, STR_013E_CAPACITIES,  STR_8851_SHOW_CAPACITIES_OF_EACH},

   374

{ WWT_PUSHTXTBTN, RESIZE_RTB,    14, 269, 357, 152, 163, STR_013E_TOTAL_CARGO, STR_8852_SHOW_TOTAL_CARGO},

   375

{  WWT_RESIZEBOX, RESIZE_LRTB,   14, 358, 369, 152, 163, 0x0,                  STR_RESIZE_BUTTON},

   376

{   WIDGETS_END},

   377

};

   378

   379

   380

static const WindowDesc _train_details_desc = {

   381

	WDP_AUTO, WDP_AUTO, 370, 164, 370, 164,

   382

	WC_VEHICLE_DETAILS,WC_VEHICLE_VIEW,

   383

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS | WDF_RESIZABLE,

   384

	_train_details_widgets,

   385

	TrainDetailsWndProc

   386

};

   387

   388

   390

{

   391

	Window *w;

   392

	VehicleID veh = v->index;

   393

   394

	DeleteWindowById(WC_VEHICLE_ORDERS, veh);

   395

	DeleteWindowById(WC_VEHICLE_DETAILS, veh);

   396

   397

	w = AllocateWindowDescFront(&_train_details_desc, veh);

   398

   399

	w->caption_color = v->owner;

   400

	w->vscroll.cap = 6;

   401

	w->widget[4].data = (w->vscroll.cap << 8) + 1;

   402

   403

	w->resize.step_height = 14;

   404

	w->resize.height = w->height - 14 * 2; /* Minimum of 4 wagons in the display */

   405

   406

	WP(w,traindetails_d).tab = 0;

   407

}