1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "functions.h"

     6

#include "train.h"

     7

#include "roadveh.h"

     8

#include "ship.h"

     9

#include "aircraft.h"

    10

#include "table/strings.h"

    11

#include "table/sprites.h"

    12

#include "gui.h"

    13

#include "gfx.h"

    14

#include "vehicle.h"

    15

#include "viewport.h"

    16

#include "command.h"

    17

#include "depot.h"

    18

#include "vehicle_gui.h"

    19

#include "station_map.h"

    20

#include "newgrf_engine.h"

    21

    22

/*

    23

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

    24

 * 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.

    25

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

    26

 */

    27

    28

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

    29

enum DepotWindowWidgets {

    30

	DEPOT_WIDGET_CLOSEBOX = 0,

    31

	DEPOT_WIDGET_CAPTION,

    32

	DEPOT_WIDGET_STICKY,

    33

	DEPOT_WIDGET_SELL,

    34

	DEPOT_WIDGET_SELL_CHAIN,

    35

	DEPOT_WIDGET_SELL_ALL,

    36

	DEPOT_WIDGET_AUTOREPLACE,

    37

	DEPOT_WIDGET_MATRIX,

    38

	DEPOT_WIDGET_V_SCROLL, // Vertical scrollbar

    39

	DEPOT_WIDGET_H_SCROLL, // Horizontal scrollbar

    40

	DEPOT_WIDGET_BUILD,

    41

	DEPOT_WIDGET_CLONE,

    42

	DEPOT_WIDGET_LOCATION,

    43

	DEPOT_WIDGET_VEHICLE_LIST,

    44

	DEPOT_WIDGET_STOP_ALL,

    45

	DEPOT_WIDGET_START_ALL,

    46

	DEPOT_WIDGET_RESIZE,

    47

};

    48

    49

/* Widget array for all depot windows.

    50

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

    51

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

    52

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

    53

    54

/* 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[]

    55

 * 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

    56

 * 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.

    57

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

    58

 */

    59

static const Widget _depot_widgets[] = {

    60

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

    61

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

    62

	{  WWT_STICKYBOX,     RESIZE_LR,    14,   293,   304,     0,    13, 0x0,                 STR_STICKY_BUTTON},                // DEPOT_WIDGET_STICKY

    63

    64

	/* Widgets are set up run-time */

    65

	{     WWT_IMGBTN,    RESIZE_LRB,    14,   270,   292,    14,    37, 0x0,                 STR_NULL},                         // DEPOT_WIDGET_SELL

    66

	{     WWT_IMGBTN,   RESIZE_LRTB,    14,   270,   292,    14,    37, SPR_SELL_CHAIN_TRAIN,STR_DRAG_WHOLE_TRAIN_TO_SELL_TIP}, // DEPOT_WIDGET_SELL_CHAIN, trains only

    67

	{ WWT_PUSHIMGBTN,   RESIZE_LRTB,    14,   270,   292,    38,    60, 0x0,                 STR_NULL},                         // DEPOT_WIDGET_SELL_ALL

    68

	{ WWT_PUSHIMGBTN,   RESIZE_LRTB,    14,   270,   292,    61,    83, 0x0,                 STR_NULL},                         // DEPOT_WIDGET_AUTOREPLACE

    69

    70

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

    71

	{  WWT_SCROLLBAR,    RESIZE_LRB,    14,   293,   304,    14,    83, 0x0,                 STR_0190_SCROLL_BAR_SCROLLS_LIST}, // DEPOT_WIDGET_V_SCROLL

    72

    73

	{ WWT_HSCROLLBAR,    RESIZE_RTB,    14,     0,   269,    72,    83, 0x0,                 STR_HSCROLL_BAR_SCROLLS_LIST},     // DEPOT_WIDGET_H_SCROLL, trains only

    74

    75

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

    76

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

    77

	{ WWT_PUSHTXTBTN,     RESIZE_TB,    14,     0,    85,    84,    95, 0x0,                 STR_NULL},                         // DEPOT_WIDGET_BUILD

    78

	{    WWT_TEXTBTN,     RESIZE_TB,    14,    86,   170,    84,    95, 0x0,                 STR_NULL},                         // DEPOT_WIDGET_CLONE

    79

	{ WWT_PUSHTXTBTN,    RESIZE_RTB,    14,   171,   257,    84,    95, STR_00E4_LOCATION,   STR_NULL},                         // DEPOT_WIDGET_LOCATION

    80

	{ WWT_PUSHTXTBTN,   RESIZE_LRTB,    14,   258,   269,    84,    95, 0x0,                 STR_NULL},                         // DEPOT_WIDGET_VEHICLE_LIST

    81

	{ WWT_PUSHIMGBTN,   RESIZE_LRTB,    14,   270,   280,    84,    95, SPR_FLAG_VEH_STOPPED,STR_NULL},                         // DEPOT_WIDGET_STOP_ALL

    82

	{ WWT_PUSHIMGBTN,   RESIZE_LRTB,    14,   281,   292,    84,    95, SPR_FLAG_VEH_RUNNING,STR_NULL},                         // DEPOT_WIDGET_START_ALL

    83

	{  WWT_RESIZEBOX,   RESIZE_LRTB,    14,   293,   304,    84,    95, 0x0,                 STR_RESIZE_BUTTON},                // DEPOT_WIDGET_RESIZE

    84

	{   WIDGETS_END},

    85

};

    86

    87

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

    88

    89

static const WindowDesc _train_depot_desc = {

    90

	WDP_AUTO, WDP_AUTO, 305, 96,

    91

	WC_VEHICLE_DEPOT,0,

    92

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

    93

	_depot_widgets,

    94

	DepotWndProc

    95

};

    96

    97

static const WindowDesc _road_depot_desc = {

    98

	WDP_AUTO, WDP_AUTO, 305, 96,

    99

	WC_VEHICLE_DEPOT,0,

   100

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

   101

	_depot_widgets,

   102

	DepotWndProc

   103

};

   104

   105

static const WindowDesc _ship_depot_desc = {

   106

	WDP_AUTO, WDP_AUTO, 305, 96,

   107

	WC_VEHICLE_DEPOT,0,

   108

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

   109

	_depot_widgets,

   110

	DepotWndProc

   111

};

   112

   113

static const WindowDesc _aircraft_depot_desc = {

   114

	WDP_AUTO, WDP_AUTO, 305, 96,

   115

	WC_VEHICLE_DEPOT,0,

   116

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

   117

	_depot_widgets,

   118

	DepotWndProc

   119

};

   120

   121

extern int WagonLengthToPixels(int len);

   122

   123

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

   124

{

   125

	if (!success) return;

   126

	switch(GetVehicle(p1)->type) {

   127

		case VEH_Train:    CcCloneTrain(   true, tile, p1, p2); break;

   128

		case VEH_Road:     CcCloneRoadVeh( true, tile, p1, p2); break;

   129

		case VEH_Ship:     CcCloneShip(    true, tile, p1, p2); break;

   130

		case VEH_Aircraft: CcCloneAircraft(true, tile, p1, p2); break;

   131

	}

   132

}

   133

   134

static inline void ShowVehicleViewWindow(const Vehicle *v)

   135

{

   136

	switch (v->type) {

   137

		case VEH_Train:    ShowTrainViewWindow(v);    break;

   138

		case VEH_Road:     ShowRoadVehViewWindow(v);  break;

   139

		case VEH_Ship:     ShowShipViewWindow(v);     break;

   140

		case VEH_Aircraft: ShowAircraftViewWindow(v); break;

   141

		default: NOT_REACHED();

   142

	}

   143

}

   144

   145

static void DepotSellAllConfirmationCallback(Window *w, bool confirmed)

   146

{

   147

	if (confirmed) {

   148

		TileIndex tile = w->window_number;

   149

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

   150

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

   151

	}

   152

}

   153

   154

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

   155

 * @param *w Window to draw in

   156

 * @param *v Vehicle to draw

   157

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

   158

 * @param y Top of the box to draw in

   159

 */

   160

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

   161

{

   162

	byte diff_x = 0, diff_y = 0;

   163

   164

	switch (v->type) {

   165

		case VEH_Train:

   166

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

   167

   168

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

   169

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

   170

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

   171

			break;

   172

   173

		case VEH_Road:     DrawRoadVehImage( v, x + 24, y, WP(w, depot_d).sel); break;

   174

		case VEH_Ship:     DrawShipImage(    v, x + 19, y, WP(w, depot_d).sel); break;

   175

		case VEH_Aircraft: DrawAircraftImage(v, x + 12, y, WP(w, depot_d).sel); break;

   176

		default: NOT_REACHED();

   177

	}

   178

   179

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

   180

		/* VEH_Train and VEH_Road, which are low */

   181

		diff_x = 15;

   182

	} else {

   183

		/* VEH_Ship and VEH_Aircraft, which are tall */

   184

		diff_y = 12;

   185

	}

   186

   187

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

   188

   189

	SetDParam(0, v->unitnumber);

   190

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

   191

}

   192

   193

static void DrawDepotWindow(Window *w)

   194

{

   195

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

   196

	TileIndex tile = w->window_number;

   197

	int x, y, i, maxval;

   198

	uint16 hnum;

   199

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

   200

   201

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

   202

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

   203

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

   204

   205

	/* setup disabled buttons */

   206

	SetWindowWidgetsDisabledState(w, !IsTileOwner(tile, _local_player),

   207

		DEPOT_WIDGET_STOP_ALL,

   208

		DEPOT_WIDGET_START_ALL,

   209

		DEPOT_WIDGET_SELL,

   210

		DEPOT_WIDGET_SELL_CHAIN,

   211

		DEPOT_WIDGET_SELL_ALL,

   212

		DEPOT_WIDGET_BUILD,

   213

		DEPOT_WIDGET_CLONE,

   214

		DEPOT_WIDGET_AUTOREPLACE,

   215

		WIDGET_LIST_END);

   216

   217

	/* determine amount of items for scroller */

   218

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

   219

		hnum = 8;

   220

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

   221

			const Vehicle *v = vl[num];

   222

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

   223

		}

   224

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

   225

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

   226

		SetHScrollCount(w, WagonLengthToPixels(hnum));

   227

	} else {

   228

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

   229

	}

   230

   231

	/* locate the depot struct */

   232

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

   233

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

   234

	} else {

   235

		Depot *depot = GetDepotByTile(tile);

   236

		assert(depot != NULL);

   237

   238

		SetDParam(0, depot->town_index);

   239

	}

   240

   241

	DrawWindowWidgets(w);

   242

   243

	num = w->vscroll.pos * boxes_in_each_row;

   244

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

   245

   246

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

   247

		byte i;

   248

   249

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

   250

			/* Draw all vehicles in the current row */

   251

			const Vehicle *v = vl[num];

   252

			DrawVehicleInDepot(w, v, x, y);

   253

		}

   254

	}

   255

   256

	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));

   257

   258

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

   259

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

   260

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

   261

		const Vehicle *u;

   262

   263

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

   264

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

   265

   266

		/*Draw the train counter */

   267

		i = 0;

   268

		u = v;

   269

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

   270

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

   271

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

   272

	}

   273

}

   274

   275

typedef struct GetDepotVehiclePtData {

   276

	Vehicle *head;

   277

	Vehicle *wagon;

   278

} GetDepotVehiclePtData;

   279

   280

enum {

   281

	MODE_ERROR        =  1,

   282

	MODE_DRAG_VEHICLE =  0,

   283

	MODE_SHOW_VEHICLE = -1,

   284

	MODE_START_STOP   = -2,

   285

};

   286

   287

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

   288

{

   289

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

   290

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

   291

	int pos, skip = 0;

   292

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

   293

   294

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

   295

		xt = 0;

   296

		x -= 23;

   297

	} else {

   298

		xt = x / w->resize.step_width;

   299

		xm = x % w->resize.step_width;

   300

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

   301

   302

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

   303

	}

   304

   305

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

   306

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

   307

   308

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

   309

   310

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

   311

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

   312

			d->head  = NULL;

   313

			d->wagon = NULL;

   314

			return MODE_DRAG_VEHICLE;

   315

		} else {

   316

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

   317

		}

   318

	}

   319

   320

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

   321

		*veh = vl[pos];

   322

		skip = w->hscroll.pos;

   323

	} else {

   324

		vl = WP(w, depot_d).wagon_list;

   325

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

   326

		*veh = vl[pos];

   327

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

   328

		x -= _traininfo_vehicle_width;

   329

	}

   330

   331

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

   332

		case VEH_Train: {

   333

			Vehicle *v = *veh;

   334

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

   335

   336

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

   337

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

   338

   339

			skip = (skip * 8) / _traininfo_vehicle_width;

   340

			x = (x * 8) / _traininfo_vehicle_width;

   341

   342

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

   343

			x += skip;

   344

   345

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

   346

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

   347

   348

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

   349

			while (v != NULL && IsArticulatedPart(v)) v = GetPrevVehicleInChain(v);

   350

   351

			d->wagon = v;

   352

   353

			return MODE_DRAG_VEHICLE;

   354

			}

   355

			break;

   356

   357

		case VEH_Road:

   358

			if (xm >= 24) return MODE_DRAG_VEHICLE;

   359

			if (xm <= 16) return MODE_SHOW_VEHICLE;

   360

			break;

   361

   362

		case VEH_Ship:

   363

			if (xm >= 19) return MODE_DRAG_VEHICLE;

   364

			if (ym <= 10) return MODE_SHOW_VEHICLE;

   365

			break;

   366

   367

		case VEH_Aircraft:

   368

			if (xm >= 12) return MODE_DRAG_VEHICLE;

   369

			if (ym <= 12) return MODE_SHOW_VEHICLE;

   370

			break;

   371

   372

		default: NOT_REACHED();

   373

	}

   374

	return MODE_START_STOP;

   375

}

   376

   377

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

   378

{

   379

	Vehicle *v;

   380

   381

	v = GetVehicle(sel);

   382

   383

	if (v == wagon) return;

   384

   385

	if (wagon == NULL) {

   386

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

   387

	} else  {

   388

		wagon = GetPrevVehicleInChain(wagon);

   389

		if (wagon == NULL) return;

   390

	}

   391

   392

	if (wagon == v) return;

   393

   394

	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));

   395

}

   396

   397

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

   398

{

   399

	GetDepotVehiclePtData gdvp;

   400

	Vehicle *v = NULL;

   401

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

   402

   403

	/* share / copy orders */

   404

	if (_thd.place_mode && mode <= 0) {

   405

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

   406

		return;

   407

	}

   408

   409

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

   410

   411

	switch (mode) {

   412

		case MODE_ERROR: // invalid

   413

			return;

   414

   415

		case MODE_DRAG_VEHICLE: { // start dragging of vehicle

   416

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

   417

   418

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

   419

				WP(w,depot_d).sel = INVALID_VEHICLE;

   420

				TrainDepotMoveVehicle(v, sel, gdvp.head);

   421

			} else if (v != NULL) {

   422

				int image;

   423

   424

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

   425

					case VEH_Train:    image = GetTrainImage(v, DIR_W);    break;

   426

					case VEH_Road:     image = GetRoadVehImage(v, DIR_W);  break;

   427

					case VEH_Ship:     image = GetShipImage(v, DIR_W);     break;

   428

					case VEH_Aircraft: image = GetAircraftImage(v, DIR_W); break;

   429

					default: NOT_REACHED(); image = 0;

   430

				}

   431

   432

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

   433

				SetWindowDirty(w);

   434

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

   435

			}

   436

			}

   437

			break;

   438

   439

		case MODE_SHOW_VEHICLE: // show info window

   440

			ShowVehicleViewWindow(v);

   441

			break;

   442

   443

		case MODE_START_STOP: { // click start/stop flag

   444

			uint command;

   445

   446

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

   447

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

   448

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

   449

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

   450

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

   451

				default: NOT_REACHED(); command = 0;

   452

			}

   453

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

   454

			}

   455

			break;

   456

   457

		default: NOT_REACHED();

   458

	}

   459

}

   460

   461

/**

   462

 * Clones a vehicle

   463

 * @param *v is the original vehicle to clone

   464

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

   465

 */

   466

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

   467

{

   468

	uint error_str;

   469

   470

	if (v == NULL) return;

   471

   472

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

   473

		v = GetFirstVehicleInChain(v);

   474

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

   475

		if (!IsFrontEngine(v)) return;

   476

	}

   477

   478

	switch (v->type) {

   479

		case VEH_Train:    error_str = CMD_MSG(STR_882B_CAN_T_BUILD_RAILROAD_VEHICLE); break;

   480

		case VEH_Road:     error_str = CMD_MSG(STR_9009_CAN_T_BUILD_ROAD_VEHICLE);     break;

   481

		case VEH_Ship:     error_str = CMD_MSG(STR_980D_CAN_T_BUILD_SHIP);             break;

   482

		case VEH_Aircraft: error_str = CMD_MSG(STR_A008_CAN_T_BUILD_AIRCRAFT);         break;

   483

		default: return;

   484

	}

   485

   486

	DoCommandP(w->window_number, v->index, _ctrl_pressed ? 1 : 0, CcCloneVehicle, CMD_CLONE_VEHICLE | error_str);

   487

   488

	ResetObjectToPlace();

   489

}

   490

   491

static void ClonePlaceObj(const Window *w)

   492

{

   493

	const Vehicle *v = CheckMouseOverVehicle();

   494

   495

	if (v != NULL) HandleCloneVehClick(v, w);

   496

}

   497

   498

static void ResizeDepotButtons(Window *w)

   499

{

   500

	/* We got the widget moved around. Now we will make some widgets to fill the gap between some widgets in equal sizes */

   501

   502

	/* Make the buttons in the bottom equal in size */

   503

	w->widget[DEPOT_WIDGET_BUILD].right    = w->widget[DEPOT_WIDGET_LOCATION].right / 3;

   504

	w->widget[DEPOT_WIDGET_LOCATION].left  = w->widget[DEPOT_WIDGET_BUILD].right * 2;

   505

	w->widget[DEPOT_WIDGET_CLONE].left     = w->widget[DEPOT_WIDGET_BUILD].right + 1;

   506

	w->widget[DEPOT_WIDGET_CLONE].right    = w->widget[DEPOT_WIDGET_LOCATION].left - 1;

   507

   508

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

   509

		/* Divide the size of DEPOT_WIDGET_SELL into two equally big buttons so DEPOT_WIDGET_SELL and DEPOT_WIDGET_SELL_CHAIN will get the same size.

   510

		* This way it will stay the same even if DEPOT_WIDGET_SELL_CHAIN is resized for some reason                                                  */

   511

		w->widget[DEPOT_WIDGET_SELL_CHAIN].top    = ((w->widget[DEPOT_WIDGET_SELL_CHAIN].bottom - w->widget[DEPOT_WIDGET_SELL].top) / 2) + w->widget[DEPOT_WIDGET_SELL].top;

   512

		w->widget[DEPOT_WIDGET_SELL].bottom     = w->widget[DEPOT_WIDGET_SELL_CHAIN].top - 1;