1

/* $Id$ */

     2

     3

/** @file depot_gui.cpp The GUI for depots. */

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

    12

#include "textbuf_gui.h"

    13

#include "viewport_func.h"

    14

#include "gfx_func.h"

    15

#include "command_func.h"

    16

#include "depot_base.h"

    17

#include "vehicle_gui.h"

    18

#include "station_map.h"

    19

#include "newgrf_engine.h"

    20

#include "spritecache.h"

    21

#include "strings_func.h"

    22

#include "window_func.h"

    23

#include "vehicle_func.h"

    24

#include "player_func.h"

    25

#include "order_func.h"

    26

#include "depot_base.h"

    27

#include "tilehighlight_func.h"

    28

    29

#include "table/strings.h"

    30

#include "table/sprites.h"

    31

    32

/*

    33

 * Since all depot window sizes aren't the same, we need to modify sizes a little.

    34

 * It's done with the following arrays of widget indexes. Each of them tells if a widget side should be moved and in what direction.

    35

 * How long they should be moved and for what window types are controlled in ShowDepotWindow()

    36

 */

    37

    38

/* Names of the widgets. Keep them in the same order as in the widget array */

    39

enum DepotWindowWidgets {

    40

	DEPOT_WIDGET_CLOSEBOX = 0,

    41

	DEPOT_WIDGET_CAPTION,

    42

	DEPOT_WIDGET_STICKY,

    43

	DEPOT_WIDGET_SELL,

    44

	DEPOT_WIDGET_SELL_CHAIN,

    45

	DEPOT_WIDGET_SELL_ALL,

    46

	DEPOT_WIDGET_AUTOREPLACE,

    47

	DEPOT_WIDGET_MATRIX,

    48

	DEPOT_WIDGET_V_SCROLL, ///< Vertical scrollbar

    49

	DEPOT_WIDGET_H_SCROLL, ///< Horizontal scrollbar

    50

	DEPOT_WIDGET_BUILD,

    51

	DEPOT_WIDGET_CLONE,

    52

	DEPOT_WIDGET_LOCATION,

    53

	DEPOT_WIDGET_VEHICLE_LIST,

    54

	DEPOT_WIDGET_STOP_ALL,

    55

	DEPOT_WIDGET_START_ALL,

    56

	DEPOT_WIDGET_RESIZE,

    57

};

    58

    59

/* Widget array for all depot windows.

    60

 * If a widget is needed in some windows only (like train specific), add it for all windows

    61

 * and use HideWindowWidget in ShowDepotWindow() to remove it in the windows where it should not be

    62

 * Keep the widget numbers in sync with the enum or really bad stuff will happen!!! */

    63

    64

/* When adding widgets, place them as you would place them for the ship depot and define how you want it to move in widget_moves[]

    65

 * If you want a widget for one window only, set it to be hidden in ShowDepotWindow() for the windows where you don't want it

    66

 * NOTE: the train only widgets are moved/resized in ShowDepotWindow() so they follow certain other widgets if they are moved to ensure that they stick together.

    67

 *    Changing the size of those here will not have an effect at all. It should be done in ShowDepotWindow()

    68

 */

    69

    70

/*

    71

 * Some of the widgets are placed outside the window (negative coordinates).

    72

 * The reason is that they are placed relatively to the matrix and the matrix is just one pixel (in 0, 14).

    73

 * The matrix and the rest of the window will be resized when the size of the boxes is set and then all the widgets will be inside the window.

    74

 */

    75

static const Widget _depot_widgets[] = {

    76

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

    77

	{    WWT_CAPTION,  RESIZE_RIGHT,    14,    11,    23,     0,    13, 0x0,                 STR_018C_WINDOW_TITLE_DRAG_THIS},  // DEPOT_WIDGET_CAPTION

    78

	{  WWT_STICKYBOX,     RESIZE_LR,    14,    24,    35,     0,    13, 0x0,                 STR_STICKY_BUTTON},                // DEPOT_WIDGET_STICKY

    79

    80

	/* Widgets are set up run-time */

    81

	{     WWT_IMGBTN,    RESIZE_LRB,    14,     1,    23,    14,   -32, 0x0,                 STR_NULL},                         // DEPOT_WIDGET_SELL

    82

	{     WWT_IMGBTN,   RESIZE_LRTB,    14,     1,    23,   -55,   -32, SPR_SELL_CHAIN_TRAIN,STR_DRAG_WHOLE_TRAIN_TO_SELL_TIP}, // DEPOT_WIDGET_SELL_CHAIN, trains only

    83

	{ WWT_PUSHIMGBTN,   RESIZE_LRTB,    14,     1,    23,   -31,    -9, 0x0,                 STR_NULL},                         // DEPOT_WIDGET_SELL_ALL

    84

	{ WWT_PUSHIMGBTN,   RESIZE_LRTB,    14,     1,    23,    -8,    14, 0x0,                 STR_NULL},                         // DEPOT_WIDGET_AUTOREPLACE

    85

    86

	{     WWT_MATRIX,     RESIZE_RB,    14,     0,     0,    14,    14, 0x0,                 STR_NULL},                         // DEPOT_WIDGET_MATRIX

    87

	{  WWT_SCROLLBAR,    RESIZE_LRB,    14,    24,    35,    14,    14, 0x0,                 STR_0190_SCROLL_BAR_SCROLLS_LIST}, // DEPOT_WIDGET_V_SCROLL

    88

    89

	{ WWT_HSCROLLBAR,    RESIZE_RTB,    14,     0,     0,     3,    14, 0x0,                 STR_HSCROLL_BAR_SCROLLS_LIST},     // DEPOT_WIDGET_H_SCROLL, trains only

    90

    91

	/* The buttons in the bottom of the window. left and right is not important as they are later resized to be equal in size

    92

	 * This calculation is based on right in DEPOT_WIDGET_LOCATION and it presumes left of DEPOT_WIDGET_BUILD is 0            */

    93

	{ WWT_PUSHTXTBTN,     RESIZE_TB,    14,     0,     0,    15,    26, 0x0,                 STR_NULL},                         // DEPOT_WIDGET_BUILD

    94

	{    WWT_TEXTBTN,     RESIZE_TB,    14,     0,     0,    15,    26, 0x0,                 STR_NULL},                         // DEPOT_WIDGET_CLONE

    95

	{ WWT_PUSHTXTBTN,    RESIZE_RTB,    14,     0,   -12,    15,    26, STR_00E4_LOCATION,   STR_NULL},                         // DEPOT_WIDGET_LOCATION

    96

	{ WWT_PUSHTXTBTN,   RESIZE_LRTB,    14,   -11,     0,    15,    26, 0x0,                 STR_NULL},                         // DEPOT_WIDGET_VEHICLE_LIST

    97

	{ WWT_PUSHIMGBTN,   RESIZE_LRTB,    14,     1,    11,    15,    26, SPR_FLAG_VEH_STOPPED,STR_NULL},                         // DEPOT_WIDGET_STOP_ALL

    98

	{ WWT_PUSHIMGBTN,   RESIZE_LRTB,    14,    12,    23,    15,    26, SPR_FLAG_VEH_RUNNING,STR_NULL},                         // DEPOT_WIDGET_START_ALL

    99

	{  WWT_RESIZEBOX,   RESIZE_LRTB,    14,    24,    35,    15,    26, 0x0,                 STR_RESIZE_BUTTON},                // DEPOT_WIDGET_RESIZE

   100

	{   WIDGETS_END},

   101

};

   102

   117

static void DepotWndProc(Window *w, WindowEvent *e);

   118

   119

static const WindowDesc _train_depot_desc = {

   120

	WDP_AUTO, WDP_AUTO, 36, 27, 36, 27,

   121

	WC_VEHICLE_DEPOT, WC_NONE,

   122

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS | WDF_STICKY_BUTTON | WDF_RESIZABLE,

   123

	_depot_widgets,

   124

	DepotWndProc

   125

};

   126

   127

static const WindowDesc _road_depot_desc = {

   128

	WDP_AUTO, WDP_AUTO, 36, 27, 36, 27,

   129

	WC_VEHICLE_DEPOT, WC_NONE,

   130

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS | WDF_STICKY_BUTTON | WDF_RESIZABLE,

   131

	_depot_widgets,

   132

	DepotWndProc

   133

};

   134

   135

static const WindowDesc _ship_depot_desc = {

   136

	WDP_AUTO, WDP_AUTO, 36, 27, 36, 27,

   137

	WC_VEHICLE_DEPOT, WC_NONE,

   138

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS | WDF_STICKY_BUTTON | WDF_RESIZABLE,

   139

	_depot_widgets,

   140

	DepotWndProc

   141

};

   142

   143

static const WindowDesc _aircraft_depot_desc = {

   144

	WDP_AUTO, WDP_AUTO, 36, 27, 36, 27,

   145

	WC_VEHICLE_DEPOT, WC_NONE,

   146

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS | WDF_STICKY_BUTTON | WDF_RESIZABLE,

   147

	_depot_widgets,

   148

	DepotWndProc

   149

};

   150

   151

extern int WagonLengthToPixels(int len);

   152

   153

/**

   154

 * This is the Callback method after the cloning attempt of a vehicle

   155

 * @param success indicates completion (or not) of the operation

   156

 * @param tile unused

   157

 * @param p1 unused

   158

 * @param p2 unused

   159

 */

   160

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

   161

{

   162

	if (!success) return;

   163

   164

	Vehicle *v = GetVehicle(_new_vehicle_id);

   165

   166

	ShowVehicleViewWindow(v);

   167

}

   168

   169

static void DepotSellAllConfirmationCallback(Window *w, bool confirmed)

   170

{

   171

	if (confirmed) {

   172

		TileIndex tile = w->window_number;

   173

		byte vehtype = WP(w, depot_d).type;

   174

		DoCommandP(tile, vehtype, 0, NULL, CMD_DEPOT_SELL_ALL_VEHICLES);

   175

	}

   176

}

   177

   178

const Sprite *GetAircraftSprite(EngineID engine);

   179

   180

/** Draw a vehicle in the depot window in the box with the top left corner at x,y

   181

 * @param *w Window to draw in

   182

 * @param *v Vehicle to draw

   183

 * @param x Left side of the box to draw in

   184

 * @param y Top of the box to draw in

   185

 */

   186

static void DrawVehicleInDepot(Window *w, const Vehicle *v, int x, int y)

   187

{

   188

	byte diff_x = 0, diff_y = 0;

   189

   190

	int sprite_y = y + w->resize.step_height - GetVehicleListHeight(v->type);

   191

   192

	switch (v->type) {

   193

		case VEH_TRAIN:

   194

			DrawTrainImage(v, x + 21, sprite_y, WP(w, depot_d).sel, w->hscroll.cap + 4, w->hscroll.pos);

   195

   196

			/* Number of wagons relative to a standard length wagon (rounded up) */

   197

			SetDParam(0, (v->u.rail.cached_total_length + 7) / 8);

   198

			DrawStringRightAligned(w->widget[DEPOT_WIDGET_MATRIX].right - 1, y + 4, STR_TINY_BLACK, TC_FROMSTRING); // Draw the counter

   199

			break;

   200

   201

		case VEH_ROAD:     DrawRoadVehImage( v, x + 24, sprite_y, WP(w, depot_d).sel, 1); break;

   202

		case VEH_SHIP:     DrawShipImage(    v, x + 19, sprite_y - 1, WP(w, depot_d).sel); break;

   203

		case VEH_AIRCRAFT: {

   204

			const Sprite *spr = GetSprite(v->GetImage(DIR_W));

   205

			DrawAircraftImage(v, x + 12,

   206

							  y + max(spr->height + spr->y_offs - 14, 0), // tall sprites needs an y offset

   207

							  WP(w, depot_d).sel);

   208

		} break;

   209

		default: NOT_REACHED();

   210

	}

   211

   212

	if (w->resize.step_height == 14) {

   213

		/* VEH_TRAIN and VEH_ROAD, which are low */

   214

		diff_x = 15;

   215

	} else {

   216

		/* VEH_SHIP and VEH_AIRCRAFT, which are tall */

   217

		diff_y = 12;

   218

	}

   219

   220

	DrawSprite((v->vehstatus & VS_STOPPED) ? SPR_FLAG_VEH_STOPPED : SPR_FLAG_VEH_RUNNING, PAL_NONE, x + diff_x, y + diff_y);

   221

   222

	SetDParam(0, v->unitnumber);

   223

	DrawString(x, y + 2, (uint16)(v->max_age - 366) >= v->age ? STR_00E2 : STR_00E3, TC_FROMSTRING);

   224

}

   225

   226

static void DrawDepotWindow(Window *w)

   227

{

   228

	Vehicle **vl = WP(w, depot_d).vehicle_list;

   229

	TileIndex tile = w->window_number;

   230

	int x, y, i, maxval;

   231

	uint16 hnum;

   232

	uint16 num = WP(w, depot_d).engine_count;

   233

   234

	/* Set the row and number of boxes in each row based on the number of boxes drawn in the matrix */

   235

	uint16 rows_in_display   = w->widget[DEPOT_WIDGET_MATRIX].data >> 8;

   236

	uint16 boxes_in_each_row = w->widget[DEPOT_WIDGET_MATRIX].data & 0xFF;

   237

   238

	/* setup disabled buttons */

   239

	w->SetWidgetsDisabledState(!IsTileOwner(tile, _local_player),

   240

		DEPOT_WIDGET_STOP_ALL,

   241

		DEPOT_WIDGET_START_ALL,

   242

		DEPOT_WIDGET_SELL,

   243

		DEPOT_WIDGET_SELL_CHAIN,

   244

		DEPOT_WIDGET_SELL_ALL,

   245

		DEPOT_WIDGET_BUILD,

   246

		DEPOT_WIDGET_CLONE,

   247

		DEPOT_WIDGET_AUTOREPLACE,

   248

		WIDGET_LIST_END);

   249

   250

	/* determine amount of items for scroller */

   251

	if (WP(w, depot_d).type == VEH_TRAIN) {

   252

		hnum = 8;

   253

		for (num = 0; num < WP(w, depot_d).engine_count; num++) {

   254

			const Vehicle *v = vl[num];

   255

			hnum = max(hnum, v->u.rail.cached_total_length);

   256

		}

   257

		/* Always have 1 empty row, so people can change the setting of the train */

   258

		SetVScrollCount(w, WP(w, depot_d).engine_count + WP(w, depot_d).wagon_count + 1);

   259

		SetHScrollCount(w, WagonLengthToPixels(hnum));

   260

	} else {

   261

		SetVScrollCount(w, (num + w->hscroll.cap - 1) / w->hscroll.cap);

   262

	}

   263

   264

	/* locate the depot struct */

   265

	if (WP(w, depot_d).type == VEH_AIRCRAFT) {

   266

		SetDParam(0, GetStationIndex(tile)); // Airport name

   267

	} else {

   268

		Depot *depot = GetDepotByTile(tile);

   269

		assert(depot != NULL);

   270

   271

		SetDParam(0, depot->town_index);

   272

	}

   273

   274

	DrawWindowWidgets(w);

   275

   276

	num = w->vscroll.pos * boxes_in_each_row;

   277

	maxval = min(WP(w, depot_d).engine_count, num + (rows_in_display * boxes_in_each_row));

   278

   279

	for (x = 2, y = 15; num < maxval; y += w->resize.step_height, x = 2) { // Draw the rows

   280

		byte i;

   281

   282

		for (i = 0; i < boxes_in_each_row && num < maxval; i++, num++, x += w->resize.step_width) {

   283

			/* Draw all vehicles in the current row */

   284

			const Vehicle *v = vl[num];

   285

			DrawVehicleInDepot(w, v, x, y);

   286

		}

   287

	}

   288

   289

	maxval = min(WP(w, depot_d).engine_count + WP(w, depot_d).wagon_count, (w->vscroll.pos * boxes_in_each_row) + (rows_in_display * boxes_in_each_row));

   290

   291

	/* draw the train wagons, that do not have an engine in front */

   292

	for (; num < maxval; num++, y += 14) {

   293

		const Vehicle *v = WP(w, depot_d).wagon_list[num - WP(w, depot_d).engine_count];

   294

		const Vehicle *u;

   295

   296

		DrawTrainImage(v, x + 50, y, WP(w, depot_d).sel, w->hscroll.cap - 29, 0);

   297

		DrawString(x, y + 2, STR_8816, TC_FROMSTRING);

   298

   299

		/*Draw the train counter */

   300

		i = 0;

   301

		u = v;

   302

		do i++; while ((u = u->Next()) != NULL); // Determine length of train

   303

		SetDParam(0, i);                      // Set the counter

   304

		DrawStringRightAligned(w->widget[DEPOT_WIDGET_MATRIX].right - 1, y + 4, STR_TINY_BLACK, TC_FROMSTRING); // Draw the counter

   305

	}

   306

}

   307

   308

struct GetDepotVehiclePtData {

   309

	Vehicle *head;

   310

	Vehicle *wagon;

   311

};

   312

   313

enum DepotGUIAction {

   314

	MODE_ERROR,

   315

	MODE_DRAG_VEHICLE,

   316

	MODE_SHOW_VEHICLE,

   317

	MODE_START_STOP,

   318

};

   319

   320

static DepotGUIAction GetVehicleFromDepotWndPt(const Window *w, int x, int y, Vehicle **veh, GetDepotVehiclePtData *d)

   321

{

   322

	Vehicle **vl = WP(w, depot_d).vehicle_list;

   323

	uint xt, row, xm = 0, ym = 0;

   324

	int pos, skip = 0;

   325

	uint16 boxes_in_each_row = w->widget[DEPOT_WIDGET_MATRIX].data & 0xFF;

   326

   327

	if (WP(w, depot_d).type == VEH_TRAIN) {

   328

		xt = 0;

   329

		x -= 23;

   330

	} else {

   331

		xt = x / w->resize.step_width;

   332

		xm = x % w->resize.step_width;

   333

		if (xt >= w->hscroll.cap) return MODE_ERROR;

   334

   335

		ym = (y - 14) % w->resize.step_height;

   336

	}

   337

   338

	row = (y - 14) / w->resize.step_height;

   339

	if (row >= w->vscroll.cap) return MODE_ERROR;

   340

   341

	pos = ((row + w->vscroll.pos) * boxes_in_each_row) + xt;

   342

   343

	if (WP(w, depot_d).engine_count + WP(w, depot_d).wagon_count <= pos) {

   344

		if (WP(w, depot_d).type == VEH_TRAIN) {

   345

			d->head  = NULL;

   346

			d->wagon = NULL;

   347

			return MODE_DRAG_VEHICLE;

   348

		} else {

   349

			return MODE_ERROR; // empty block, so no vehicle is selected

   350

		}

   351

	}

   352

   353

	if (WP(w, depot_d).engine_count > pos) {

   354

		*veh = vl[pos];

   355

		skip = w->hscroll.pos;

   356

	} else {

   357

		vl = WP(w, depot_d).wagon_list;

   358

		pos -= WP(w, depot_d).engine_count;

   359

		*veh = vl[pos];

   360

		/* free wagons don't have an initial loco. */

   361

		x -= _traininfo_vehicle_width;

   362

	}

   363

   364

	switch (WP(w, depot_d).type) {

   365

		case VEH_TRAIN: {

   366

			Vehicle *v = *veh;

   367

			d->head = d->wagon = v;

   368

   369

			/* either pressed the flag or the number, but only when it's a loco */

   370

			if (x < 0 && IsFrontEngine(v)) return (x >= -10) ? MODE_START_STOP : MODE_SHOW_VEHICLE;

   371

   372

			skip = (skip * 8) / _traininfo_vehicle_width;

   373

			x = (x * 8) / _traininfo_vehicle_width;

   374

   375

			/* Skip vehicles that are scrolled off the list */

   376

			x += skip;

   377

   378

			/* find the vehicle in this row that was clicked */

   379

			while (v != NULL && (x -= v->u.rail.cached_veh_length) >= 0) v = v->Next();

   380

   381

			/* if an articulated part was selected, find its parent */

   382

			while (v != NULL && IsArticulatedPart(v)) v = v->Previous();

   383

   384

			d->wagon = v;

   385

   386

			return MODE_DRAG_VEHICLE;

   387

			}

   388

			break;

   389

   390

		case VEH_ROAD:

   391

			if (xm >= 24) return MODE_DRAG_VEHICLE;

   392

			if (xm <= 16) return MODE_SHOW_VEHICLE;

   393

			break;

   394

   395

		case VEH_SHIP:

   396

			if (xm >= 19) return MODE_DRAG_VEHICLE;

   397

			if (ym <= 10) return MODE_SHOW_VEHICLE;

   398

			break;

   399

   400

		case VEH_AIRCRAFT:

   401

			if (xm >= 12) return MODE_DRAG_VEHICLE;

   402

			if (ym <= 12) return MODE_SHOW_VEHICLE;

   403

			break;

   404

   405

		default: NOT_REACHED();

   406

	}

   407

	return MODE_START_STOP;

   408

}

   409

   410

static void TrainDepotMoveVehicle(Vehicle *wagon, VehicleID sel, Vehicle *head)

   411

{

   412

	Vehicle *v;

   413

   414

	v = GetVehicle(sel);

   415

   416

	if (v == wagon) return;

   417

   418

	if (wagon == NULL) {

   419

		if (head != NULL) wagon = GetLastVehicleInChain(head);

   420

	} else  {

   421

		wagon = wagon->Previous();

   422

		if (wagon == NULL) return;

   423

	}

   424

   425

	if (wagon == v) return;

   426

   427

	DoCommandP(v->tile, v->index + ((wagon == NULL ? INVALID_VEHICLE : wagon->index) << 16), _ctrl_pressed ? 1 : 0, NULL, CMD_MOVE_RAIL_VEHICLE | CMD_MSG(STR_8837_CAN_T_MOVE_VEHICLE));

   428

}

   429

   430

static void DepotClick(Window *w, int x, int y)

   431

{

   432

	GetDepotVehiclePtData gdvp;

   433

	Vehicle *v = NULL;

   434

	DepotGUIAction mode = GetVehicleFromDepotWndPt(w, x, y, &v, &gdvp);

   435

   436

	/* share / copy orders */

   437

	if (_thd.place_mode != VHM_NONE && mode != MODE_ERROR) {

   438

		_place_clicked_vehicle = (WP(w, depot_d).type == VEH_TRAIN ? gdvp.head : v);

   439

		return;

   440

	}

   441

   442

	if (WP(w, depot_d).type == VEH_TRAIN) v = gdvp.wagon;

   443

   444

	switch (mode) {

   445

		case MODE_ERROR: // invalid

   446

			return;

   447

   448

		case MODE_DRAG_VEHICLE: { // start dragging of vehicle

   449

			VehicleID sel = WP(w, depot_d).sel;

   450

   451

			if (WP(w, depot_d).type == VEH_TRAIN && sel != INVALID_VEHICLE) {

   452

				WP(w, depot_d).sel = INVALID_VEHICLE;

   453

				TrainDepotMoveVehicle(v, sel, gdvp.head);

   454

			} else if (v != NULL) {

   455

				int image = v->GetImage(DIR_W);

   456

   457

				WP(w, depot_d).sel = v->index;

   458

				w->SetDirty();

   459

				SetObjectToPlaceWnd(image, GetVehiclePalette(v), VHM_DRAG, w);

   460

				_cursor.vehchain = _ctrl_pressed;

   461

			}

   462

			}

   463

			break;

   464

   465

		case MODE_SHOW_VEHICLE: // show info window

   466

			ShowVehicleViewWindow(v);

   467

			break;

   468

   469

		case MODE_START_STOP: { // click start/stop flag

   470

			uint command;

   471

   472

			switch (WP(w, depot_d).type) {

   473

				case VEH_TRAIN:    command = CMD_START_STOP_TRAIN | CMD_MSG(STR_883B_CAN_T_STOP_START_TRAIN);          break;

   474

				case VEH_ROAD:     command = CMD_START_STOP_ROADVEH | CMD_MSG(STR_9015_CAN_T_STOP_START_ROAD_VEHICLE); break;

   475

				case VEH_SHIP:     command = CMD_START_STOP_SHIP | CMD_MSG(STR_9818_CAN_T_STOP_START_SHIP);            break;

   476

				case VEH_AIRCRAFT: command = CMD_START_STOP_AIRCRAFT | CMD_MSG(STR_A016_CAN_T_STOP_START_AIRCRAFT);    break;

   477

				default: NOT_REACHED(); command = 0;

   478

			}

   479

			DoCommandP(v->tile, v->index, 0, NULL, command);

   480

			}

   481

			break;

   482

   483

		default: NOT_REACHED();

   484

	}

   485

}

   486

   487

/**

   488

 * Clones a vehicle

   489

 * @param *v is the original vehicle to clone

   490

 * @param *w is the window of the depot where the clone is build

   491

 */

   492

static void HandleCloneVehClick(const Vehicle *v, const Window *w)

   493

{

   494

	uint error_str;

   495

   496

	if (v == NULL) return;

   497

   498

	if (!v->IsPrimaryVehicle()) {

   499

		v = v->First();

   500

		/* Do nothing when clicking on a train in depot with no loc attached */