1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "debug.h"

     6

#include "functions.h"

     7

#include "rail_map.h"

     8

#include "table/sprites.h"

     9

#include "table/strings.h"

    10

#include "map.h"

    11

#include "window.h"

    12

#include "gui.h"

    13

#include "gfx.h"

    14

#include "vehicle.h"

    15

#include "viewport.h"

    16

#include "station.h"

    17

#include "command.h"

    18

#include "player.h"

    19

#include "engine.h"

    20

#include "vehicle_gui.h"

    21

#include "depot.h"

    22

#include "train.h"

    23

#include "newgrf_engine.h"

    24

#include "date.h"

    25

    26

typedef enum BuildTrainWidgets {

    27

	BUILD_TRAIN_WIDGET_CLOSEBOX = 0,

    28

	BUILD_TRAIN_WIDGET_CAPTION,

    29

	BUILD_TRAIN_WIDGET_LIST,

    30

	BUILD_TRAIN_WIDGET_SCROLLBAR,

    31

	BUILD_TRAIN_WIDGET_PANEL,

    32

	BUILD_TRAIN_WIDGET_ENGINES,

    33

	BUILD_TRAIN_WIDGET_WAGONS,

    34

	BUILD_TRAIN_WIDGET_BOTH,

    35

	BUILD_TRAIN_WIDGET_BUILD,

    36

	BUILD_TRAIN_WIDGET_RENAME,

    37

	BUILD_TRAIN_WIDGET_RESIZE,

    38

} BuildTrainWidget;

    39

    40

static const Widget _new_rail_vehicle_widgets[] = {

    41

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

    42

	{    WWT_CAPTION,   RESIZE_NONE,    14,    11,   227,     0,    13, STR_JUST_STRING,        STR_018C_WINDOW_TITLE_DRAG_THIS},

    43

	{     WWT_MATRIX, RESIZE_BOTTOM,    14,     0,   215,    14,   125, 0x801,                  STR_8843_TRAIN_VEHICLE_SELECTION},

    44

	{  WWT_SCROLLBAR, RESIZE_BOTTOM,    14,   216,   227,    14,   125, 0x0,                    STR_0190_SCROLL_BAR_SCROLLS_LIST},

    45

	{      WWT_PANEL,     RESIZE_TB,    14,     0,   227,   126,   197, 0x0,                    STR_NULL},

    46

	{ WWT_PUSHTXTBTN,     RESIZE_TB,    14,     0,    76,   198,   209, STR_BLACK_ENGINES,      STR_BUILD_TRAIN_ENGINES_TIP},

    47

	{ WWT_PUSHTXTBTN,     RESIZE_TB,    14,    77,   151,   198,   209, STR_BLACK_WAGONS,       STR_BUILD_TRAIN_WAGONS_TIP},

    48

	{ WWT_PUSHTXTBTN,     RESIZE_TB,    14,   152,   227,   198,   209, STR_BLACK_BOTH,         STR_BUILD_TRAIN_BOTH_TIP},

    49

	{ WWT_PUSHTXTBTN,     RESIZE_TB,    14,     0,   107,   210,   221, STR_881F_BUILD_VEHICLE, STR_8844_BUILD_THE_HIGHLIGHTED_TRAIN},

    50

	{ WWT_PUSHTXTBTN,     RESIZE_TB,    14,   108,   215,   210,   221, STR_8820_RENAME,        STR_8845_RENAME_TRAIN_VEHICLE_TYPE},

    51

	{  WWT_RESIZEBOX,     RESIZE_TB,    14,   216,   227,   210,   221, 0x0,                    STR_RESIZE_BUTTON},

    52

	{   WIDGETS_END},

    53

};

    54

    55

    56

/**

    57

 * Draw the purchase info details of train engine at a given location.

    58

 * @param x,y location where to draw the info

    59

 * @param engine_number the engine of which to draw the info of

    60

 */

    61

void DrawTrainEnginePurchaseInfo(int x, int y, EngineID engine_number)

    62

{

    63

	const RailVehicleInfo *rvi = RailVehInfo(engine_number);

    64

	const Engine *e = GetEngine(engine_number);

    65

	int multihead = (rvi->flags&RVI_MULTIHEAD?1:0);

    66

	YearMonthDay ymd;

    67

	ConvertDateToYMD(e->intro_date, &ymd);

    68

    69

	/* Purchase Cost - Engine weight */

    70

	SetDParam(0, rvi->base_cost * (_price.build_railvehicle >> 3) >> 5);

    71

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

    72

	DrawString(x,y, STR_PURCHASE_INFO_COST_WEIGHT, 0);

    73

	y += 10;

    74

    75

	/* Max speed - Engine power */

    76

	SetDParam(0, rvi->max_speed);

    77

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

    78

	DrawString(x,y, STR_PURCHASE_INFO_SPEED_POWER, 0);

    79

	y += 10;

    80

    81

	/* Running cost */

    82

	SetDParam(0, (rvi->running_cost_base * _price.running_rail[rvi->running_cost_class] >> 8) << multihead);

    83

	DrawString(x,y, STR_PURCHASE_INFO_RUNNINGCOST, 0);

    84

	y += 10;

    85

    86

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

    87

	if (rvi->pow_wag_power != 0) {

    88

		SetDParam(0, rvi->pow_wag_power);

    89

		SetDParam(1, rvi->pow_wag_weight);

    90

		DrawString(x,y, STR_PURCHASE_INFO_PWAGPOWER_PWAGWEIGHT, 0);

    91

		y += 10;

    92

	};

    93

    94

	/* Cargo type + capacity, or N/A */

    95

	SetDParam(0, STR_8838_N_A);

    96

	SetDParam(2, STR_EMPTY);

    97

	if (rvi->capacity != 0) {

    98

		SetDParam(0, _cargoc.names_long[rvi->cargo_type]);

    99

		SetDParam(1, (rvi->capacity * (CountArticulatedParts(engine_number) + 1)) << multihead);

   100

		SetDParam(2, STR_9842_REFITTABLE);

   101

	}

   102

	DrawString(x,y, STR_PURCHASE_INFO_CAPACITY, 0);

   103

	y += 10;

   104

   105

	/* Design date - Life length */

   106

	SetDParam(0, ymd.year);

   107

	SetDParam(1, e->lifelength);

   108

	DrawString(x,y, STR_PURCHASE_INFO_DESIGNED_LIFE, 0);

   109

	y += 10;

   110

   111

	/* Reliability */

   112

	SetDParam(0, e->reliability * 100 >> 16);

   113

	DrawString(x,y, STR_PURCHASE_INFO_RELIABILITY, 0);

   114

	y += 10;

   115

   116

	/* Additional text from NewGRF */

   117

	// XXX 227 will become a calculated width...

   118

	y += ShowAdditionalText(x, y, 227, engine_number);

   119

}

   120

   121

/**

   122

 * Draw the purchase info details of a train wagon at a given location.

   123

 * @param x,y location where to draw the info

   124

 * @param engine_number the engine of which to draw the info of

   125

 */

   126

void DrawTrainWagonPurchaseInfo(int x, int y, EngineID engine_number)

   127

{

   128

	const RailVehicleInfo *rvi = RailVehInfo(engine_number);

   129

	bool refittable = (EngInfo(engine_number)->refit_mask != 0);

   130

   131

	/* Purchase cost */

   132

	SetDParam(0, (rvi->base_cost * _price.build_railwagon) >> 8);

   133

	DrawString(x, y, STR_PURCHASE_INFO_COST, 0);

   134

	y += 10;

   135

   136

	/* Wagon weight - (including cargo) */

   137

	SetDParam(0, rvi->weight);

   138

	SetDParam(1, (_cargoc.weights[rvi->cargo_type] * rvi->capacity >> 4) + rvi->weight);

   139

	DrawString(x, y, STR_PURCHASE_INFO_WEIGHT_CWEIGHT, 0);

   140

	y += 10;

   141

   142

	/* Cargo type + capacity, or N/A */

   143

	SetDParam(0, STR_8838_N_A);

   144

	SetDParam(2, STR_EMPTY);

   145

	if (rvi->capacity != 0) {

   146

		SetDParam(0, _cargoc.names_long[rvi->cargo_type]);

   147

		SetDParam(1, rvi->capacity * (CountArticulatedParts(engine_number) + 1));

   148

		SetDParam(2, refittable ? STR_9842_REFITTABLE : STR_EMPTY);

   149

	}

   150

	DrawString(x, y, STR_PURCHASE_INFO_CAPACITY, 0);

   151

	y += 10;

   152

   153

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

   154

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

   155

		SetDParam(0, rvi->max_speed);

   156

		DrawString(x,y, STR_PURCHASE_INFO_SPEED, 0);

   157

		y += 10;

   158

	}

   159

   160

	/* Additional text from NewGRF */

   161

	y += ShowAdditionalText(x, y, 227, engine_number);

   162

}

   163

   164

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

   165

{

   166

	Vehicle *v, *found;

   167

   168

	if (!success) return;

   169

   170

	// find a locomotive in the depot.

   171

	found = NULL;

   172

	FOR_ALL_VEHICLES(v) {

   173

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

   174

				v->tile == tile &&

   175

				v->u.rail.track == 0x80) {

   176

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

   177

			found = v;

   178

		}

   179

	}

   180

   181

	// if we found a loco,

   182

	if (found != NULL) {

   183

		found = GetLastVehicleInChain(found);

   184

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

   185

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

   186

		RebuildVehicleLists();

   187

	}

   188

}

   189

   190

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

   191

{

   192

	const Vehicle *v;

   193

   194

	if (!success) return;

   195

   196

	v = GetVehicle(_new_vehicle_id);

   197

	if (tile == _backup_orders_tile) {

   198

		_backup_orders_tile = 0;

   199

		RestoreVehicleOrders(v, _backup_orders_data);

   200

	}

   201

	ShowTrainViewWindow(v);

   202

}

   203

   204

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

   205

{

   206

	if (success) ShowTrainViewWindow(GetVehicle(_new_vehicle_id));

   207

}

   208

static void engine_drawing_loop(const EngineID *engines, const uint16 engine_count,

   209

								const int x, int *y, const EngineID sel, EngineID *position, const int16 show_max)

   210

{

   211

	for (; (*position) < min(engine_count, show_max); (*position)++) {

   212

		EngineID i = engines[*position];

   213

   214

		DrawString(x + 59, *y + 2, GetCustomEngineName(i), sel == i ? 0xC : 0x10);

   215

		DrawTrainEngine(x + 29, *y + 6, i, GetEnginePalette(i, _local_player));

   216

		*y += 14;

   217

	}

   218

}

   219

   220

static inline void ExtendEngineListSize(const EngineID **engine_list, uint16 *engine_list_length, uint16 step_size)

   221

{

   222

	*engine_list_length = min(*engine_list_length + step_size, NUM_TRAIN_ENGINES);

   223

	*engine_list = realloc((void*)*engine_list, (*engine_list_length) * sizeof((*engine_list)[0]));

   224

}

   225

   226

static void GenerateBuildList(EngineID **engines, uint16 *num_engines, EngineID **wagons, uint16 *num_wagons, RailType railtype)

   227

{

   228

	uint16 engine_length = *num_engines;

   229

	uint16 wagon_length  = *num_wagons;

   230

	EngineID j;

   231

   232

	(*num_engines) = 0;

   233

	(*num_wagons)  = 0;

   234

   235

	if (engines == NULL) ExtendEngineListSize((const EngineID**)engines, &engine_length, 25);

   236

	if (wagons  == NULL) ExtendEngineListSize((const EngineID**)wagons,  &wagon_length,  25);

   237

   238

	for (j = 0; j < NUM_TRAIN_ENGINES; j++) {

   239

		EngineID i = GetRailVehAtPosition(j);

   240

		const Engine *e = GetEngine(i);

   241

		const RailVehicleInfo *rvi = RailVehInfo(i);

   242

   243

		if (!HasPowerOnRail(e->railtype, railtype)) continue;

   244

		if (!IsEngineBuildable(i, VEH_Train)) continue;

   245

   246

		if (rvi->flags & RVI_WAGON) {

   247

			if (*num_wagons == wagon_length) ExtendEngineListSize((const EngineID**)wagons, &wagon_length, 5);

   248

			(*wagons)[(*num_wagons)++] = i;

   249

		} else {

   250

			if (*num_engines == engine_length) ExtendEngineListSize((const EngineID**)engines, &engine_length, 5);

   251

			(*engines)[(*num_engines)++] = i;

   252

		}

   253

	}

   254

   255

	/* Reduce array sizes if they are too big */

   256

	if (*num_engines == engine_length) *engines = realloc((void*)*engines, (*num_engines) * sizeof((*engines)[0]));

   257

	if (*num_wagons == wagon_length) *wagons = realloc((void*)*wagons, (*num_wagons) * sizeof((*wagons)[0]));

   258

}

   259

   260

static void DrawTrainBuildWindow(Window *w)

   261

{

   262

	int x = 1;

   263

	int y = 15;

   264

	EngineID position = w->vscroll.pos;

   265

	EngineID selected_id = WP(w,buildtrain_d).sel_engine;

   266

	int max = w->vscroll.pos + w->vscroll.cap;

   267

	uint16 scrollcount = 0;

   268

   269

	SetWindowWidgetDisabledState(w, BUILD_TRAIN_WIDGET_BUILD, w->window_number == 0); // Disable unless we got a depot to build in

   270

   271

	/* Draw the clicked engine/wagon/both button pressed and unpress the other two */

   272

	SetWindowWidgetLoweredState(w, BUILD_TRAIN_WIDGET_ENGINES, WP(w,buildtrain_d).show_engine_wagon == 1);

   273

	SetWindowWidgetLoweredState(w, BUILD_TRAIN_WIDGET_WAGONS,  WP(w,buildtrain_d).show_engine_wagon == 2);

   274

	SetWindowWidgetLoweredState(w, BUILD_TRAIN_WIDGET_BOTH,    WP(w,buildtrain_d).show_engine_wagon == 3);

   275

   276

	if (WP(w,buildtrain_d).data_invalidated) {

   277

		GenerateBuildList(&WP(w,buildtrain_d).engines, &WP(w,buildtrain_d).num_engines, &WP(w,buildtrain_d).wagons, &WP(w,buildtrain_d).num_wagons, WP(w,buildtrain_d).railtype);

   278

		WP(w,buildtrain_d).data_invalidated = false;

   300

	}

   301

   302

	if (HASBIT(WP(w,buildtrain_d).show_engine_wagon, 0)) scrollcount += WP(w,buildtrain_d).num_engines;

   303

	if (HASBIT(WP(w,buildtrain_d).show_engine_wagon, 1)) scrollcount += WP(w,buildtrain_d).num_wagons;

   304

   305

	SetVScrollCount(w, scrollcount);

   306

	SetDParam(0, WP(w,buildtrain_d).railtype + STR_881C_NEW_RAIL_VEHICLES);

   307

	DrawWindowWidgets(w);

   308

   309

	if (selected_id == INVALID_ENGINE && scrollcount != 0) {

   310

		if (HASBIT(WP(w,buildtrain_d).show_engine_wagon, 0) && WP(w,buildtrain_d).num_engines != 0) {

   311

			selected_id = WP(w,buildtrain_d).engines[0];

   312

		} else {

   313

			selected_id = WP(w,buildtrain_d).wagons[0];

   314

		}

   315

		WP(w,buildtrain_d).sel_engine = selected_id;

   316

	}

   317

   318

	/* Draw the engines */

   319

	if (HASBIT(WP(w,buildtrain_d).show_engine_wagon, 0)) {

   320

		engine_drawing_loop(WP(w,buildtrain_d).engines, WP(w,buildtrain_d).num_engines, x, &y, selected_id, &position, max);

   321

   322

		/* Magically set the number 0 line to the one right after the last engine

   323

		* This way the line numbers fit the indexes in the wagon array */

   324

		position -= WP(w,buildtrain_d).num_engines;

   325

		max      -= WP(w,buildtrain_d).num_engines;

   326

	}

   327

   328

	/* Draw the wagons */

   329

	if (HASBIT(WP(w,buildtrain_d).show_engine_wagon, 1)) {

   330

		engine_drawing_loop(WP(w,buildtrain_d).wagons,  WP(w,buildtrain_d).num_wagons,  x, &y, selected_id, &position, max);

   331

	}

   332

   333

	if (selected_id != INVALID_ENGINE) {

   334

		const RailVehicleInfo *rvi = RailVehInfo(selected_id);

   335

   336

		if (rvi->flags & RVI_WAGON) {

   337

			DrawTrainWagonPurchaseInfo(2, w->widget[BUILD_TRAIN_WIDGET_PANEL].top + 1, selected_id);

   338

		} else {

   339

			DrawTrainEnginePurchaseInfo(2, w->widget[BUILD_TRAIN_WIDGET_PANEL].top + 1, selected_id);

   340

		}

   341

	}

   342

}

   343

   344

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

   345

{

   346

	switch (e->event) {

   347

		case WE_CREATE:

   348

			WP(w,buildtrain_d).num_engines = 0;

   349

			WP(w,buildtrain_d).num_wagons  = 0;

   350

			WP(w,buildtrain_d).engines = NULL;

   351

			WP(w,buildtrain_d).wagons  = NULL;

   352

			WP(w,buildtrain_d).show_engine_wagon = 3;

   353

			WP(w,buildtrain_d).data_invalidated  = true;

   355

			break;

   356

   357

		case WE_INVALIDATE_DATA:

   358

			WP(w,buildtrain_d).data_invalidated = true;

   359

			break;

   360

   361

		case WE_DESTROY:

   362

			free((void*)WP(w,buildtrain_d).engines);

   363

			free((void*)WP(w,buildtrain_d).wagons);

   364

			break;

   365

   366

		case WE_PAINT:

   367

			DrawTrainBuildWindow(w);

   368

			break;

   369

   370

   371

		case WE_CLICK: {

   372

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

   373

				case BUILD_TRAIN_WIDGET_LIST: {

   374

					uint i = ((e->we.click.pt.y - 14) / 14) + w->vscroll.pos;

   375

					if (i < WP(w,buildtrain_d).num_engines + WP(w,buildtrain_d).num_wagons) {

   376

						if (i < WP(w,buildtrain_d).num_engines && HASBIT(WP(w,buildtrain_d).show_engine_wagon, 0)) {

   377

							WP(w,buildtrain_d).sel_engine = WP(w,buildtrain_d).engines[i];

   378

						} else {

   379

							WP(w,buildtrain_d).sel_engine = WP(w,buildtrain_d).wagons[i - (HASBIT(WP(w,buildtrain_d).show_engine_wagon, 0) ? WP(w,buildtrain_d).num_engines : 0)];

   380

						}

   381

						SetWindowDirty(w);

   382

					}

   383

				} break;

   384

   385

				case BUILD_TRAIN_WIDGET_ENGINES:

   386

				case BUILD_TRAIN_WIDGET_WAGONS:

   387

				case BUILD_TRAIN_WIDGET_BOTH: {

   388

					/* First we need to figure out the new show_engine_wagon setting

   389

					 * Because the button widgets are ordered as they are (in a row), we can calculate as following:

   390

					 * engines = bit 0 (1 for set), wagons bit 1 (2 for set), both (2 | 1 = 3)

   391

					 * Those numbers are the same as the clicked button - BUILD_TRAIN_WIDGET_ENGINES + 1 */

   392

   393

					byte click_state = e->we.click.widget - BUILD_TRAIN_WIDGET_ENGINES + 1;

   394

					if (WP(w,buildtrain_d).show_engine_wagon == click_state) break; // We clicked the pressed button

   395

					WP(w,buildtrain_d).sel_engine = INVALID_ENGINE;

   396

					WP(w,buildtrain_d).show_engine_wagon = click_state;

   397

					w->vscroll.pos = 0;

   398

					SetWindowDirty(w);

   399

					}

   400

					break;

   401

   402

				case BUILD_TRAIN_WIDGET_BUILD: {

   403

					EngineID sel_eng = WP(w,buildtrain_d).sel_engine;

   404

					if (sel_eng != INVALID_ENGINE)

   405

						DoCommandP(w->window_number, sel_eng, 0, (RailVehInfo(sel_eng)->flags & RVI_WAGON) ? CcBuildWagon : CcBuildLoco, CMD_BUILD_RAIL_VEHICLE | CMD_MSG(STR_882B_CAN_T_BUILD_RAILROAD_VEHICLE));

   406

				}	break;

   407

   408

				case BUILD_TRAIN_WIDGET_RENAME: {

   409

					EngineID sel_eng = WP(w,buildtrain_d).sel_engine;

   410

					if (sel_eng != INVALID_ENGINE) {

   411

						WP(w,buildtrain_d).rename_engine = sel_eng;

   412

						ShowQueryString(GetCustomEngineName(sel_eng),

   413

										STR_886A_RENAME_TRAIN_VEHICLE_TYPE, 31, 160, w->window_class, w->window_number, CS_ALPHANUMERAL);

   414

					}

   415

				} break;

   416

			}

   417

		} break;

   418

   419

		case WE_ON_EDIT_TEXT: {

   420

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

   421

				_cmd_text = e->we.edittext.str;

   422

				DoCommandP(0, WP(w,buildtrain_d).rename_engine, 0, NULL,

   423

					CMD_RENAME_ENGINE | CMD_MSG(STR_886B_CAN_T_RENAME_TRAIN_VEHICLE));

   424

			}

   425

		} break;

   426

   427

		case WE_RESIZE: {

   428

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

   429

   430

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

   431

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

   432

		} break;

   433

	}

   434

}

   435

   436

static const WindowDesc _new_rail_vehicle_desc = {

   437

	-1, -1, 228, 222,

   438

	WC_BUILD_VEHICLE,0,

   439

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS | WDF_RESIZABLE,

   440

	_new_rail_vehicle_widgets,

   441

	NewRailVehicleWndProc

   442

};

   443

   444

void ShowBuildTrainWindow(TileIndex tile)

   445

{

   446

	Window *w;

   447

   448

	DeleteWindowById(WC_BUILD_VEHICLE, tile);

   449

   450

	w = AllocateWindowDesc(&_new_rail_vehicle_desc);

   451

	w->window_number = tile;

   452

	w->vscroll.cap = 8;

   453

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

   454

   455

	w->resize.step_height = 14;

   456

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

   457

   458

	if (tile != 0) {

   459

		w->caption_color = GetTileOwner(tile);

   460

		WP(w,buildtrain_d).railtype = GetRailType(tile);

   461

	} else {

   462

		w->caption_color = _local_player;

   463

		WP(w,buildtrain_d).railtype = GetBestRailtype(GetPlayer(_local_player));

   464

	}

   465

}

   466

   467

/**

   468

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

   469

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

   470

 * @return Number of pixels across.

   471

 */

   472

int WagonLengthToPixels(int len) {

   473

	return (len * _traininfo_vehicle_width) / 8;

   474

}

   475

   476

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

   477

{

   478

	DrawPixelInfo tmp_dpi, *old_dpi;

   479

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

   480

	/* Position of highlight box */

   481

	int highlight_l = 0;

   482

	int highlight_r = 0;

   483

   484

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

   485

   486

	count = (count * 8) / _traininfo_vehicle_width;

   487

   488

	old_dpi = _cur_dpi;

   489

	_cur_dpi = &tmp_dpi;

   490