1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "functions.h"

     6

#include "ship.h"

     7

#include "table/strings.h"

     8

#include "table/sprites.h"

     9

#include "gui.h"

    10

#include "gfx.h"

    11

#include "vehicle.h"

    12

#include "viewport.h"

    13

#include "command.h"

    14

#include "depot.h"

    15

#include "vehicle_gui.h"

    16

#include "station_map.h"

    17

#include "newgrf_engine.h"

    18

#include "train.h"

    19

    20

enum {

    21

	WIDGET_DEPOT_MOVE_NONE   = 0 << 0,

    22

	WIDGET_DEPOT_MOVE_RIGHT  = 1 << 0,

    23

	WIDGET_DEPOT_MOVE_LEFT   = 1 << 1,

    24

	WIDGET_DEPOT_MOVE_TOP    = 1 << 2,

    25

	WIDGET_DEPOT_MOVE_BOTTOM = 1 << 3,

    26

    27

	DEPOT_MOVE_NONE               = WIDGET_DEPOT_MOVE_NONE,

    28

	DEPOT_STRETCH_RIGHT           = WIDGET_DEPOT_MOVE_RIGHT,

    29

	DEPOT_MOVE_RIGHT              = WIDGET_DEPOT_MOVE_RIGHT | WIDGET_DEPOT_MOVE_LEFT,

    30

	DEPOT_STRETCH_DOWN            = WIDGET_DEPOT_MOVE_BOTTOM,

    31

	DEPOT_MOVE_DOWN               = WIDGET_DEPOT_MOVE_BOTTOM | WIDGET_DEPOT_MOVE_TOP,

    32

	DEPOT_STRETCH_DOWN_RIGHT      = DEPOT_STRETCH_DOWN | DEPOT_STRETCH_RIGHT,

    33

	DEPOT_MOVE_DOWN_RIGHT         = DEPOT_MOVE_RIGHT | DEPOT_MOVE_DOWN,

    34

	DEPOT_MOVE_RIGHT_STRETCH_DOWN = DEPOT_MOVE_RIGHT | DEPOT_STRETCH_DOWN,

    35

};

    36

    37

/*

    38

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

    39

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

    40

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

    41

 */

    42

    43

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

    44

typedef enum DepotWindowWidgets {

    45

	DEPOT_WIDGET_CLOSEBOX = 0,

    46

	DEPOT_WIDGET_CAPTION,

    47

	DEPOT_WIDGET_STICKY,

    48

	DEPOT_WIDGET_STOP_ALL,

    49

	DEPOT_WIDGET_START_ALL,

    50

	DEPOT_WIDGET_SELL,

    51

	DEPOT_WIDGET_SELL_ALL,

    52

	DEPOT_WIDGET_MATRIX,

    53

	DEPOT_WIDGET_V_SCROLL, // Vertical scrollbar

    54

	DEPOT_WIDGET_H_SCROLL, // Horizontal scrollbar

    55

	DEPOT_WIDGET_BUILD,

    56

	DEPOT_WIDGET_CLONE,

    57

	DEPOT_WIDGET_LOCATION,

    58

	DEPOT_WIDGET_RESIZE,

    60

} DepotWindowWidget;

    61

    62

/* Define how to move each widget. The order is important */

    63

static const byte widget_moves[] = {

    64

	DEPOT_MOVE_NONE,               // DEPOT_WIDGET_CLOSEBOX

    65

	DEPOT_STRETCH_RIGHT,           // DEPOT_WIDGET_CAPTION

    66

	DEPOT_MOVE_RIGHT,              // DEPOT_WIDGET_STICKY

    67

	DEPOT_MOVE_RIGHT,              // DEPOT_WIDGET_STOP_ALL

    68

	DEPOT_MOVE_RIGHT,              // DEPOT_WIDGET_START_ALL

    69

	DEPOT_MOVE_RIGHT,              // DEPOT_WIDGET_SELL

    70

	DEPOT_MOVE_NONE,               // DEPOT_WIDGET_SELL_ALL

    71

	DEPOT_STRETCH_DOWN_RIGHT,      // DEPOT_WIDGET_MATRIX

    72

	DEPOT_MOVE_RIGHT_STRETCH_DOWN, // DEPOT_WIDGET_V_SCROLL

    73

	DEPOT_MOVE_NONE,               // DEPOT_WIDGET_H_SCROLL

    74

	DEPOT_MOVE_DOWN,               // DEPOT_WIDGET_BUILD

    75

	DEPOT_MOVE_DOWN,               // DEPOT_WIDGET_CLONE

    76

	DEPOT_MOVE_DOWN,               // DEPOT_WIDGET_LOCATION

    77

	DEPOT_MOVE_DOWN_RIGHT,         // DEPOT_WIDGET_RESIZE

    78

};

    79

    80

/* Widget array for all depot windows.

    81

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

    82

 * and use w->hidden_state in ShowDepotWindow() to remove it in the windows where it should not be

    83

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

    84

    85

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

    86

 * 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

    87

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

    88

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

    89

 */

    90

static const Widget _depot_widgets[] = {

    91

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

    92

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

    93

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

    94

    95

	{ WWT_PUSHIMGBTN,     RESIZE_LR,    14,   270,   280,    14,    25, SPR_FLAG_VEH_STOPPED,STR_MASS_STOP_DEPOT_TOOLTIP},      // DEPOT_WIDGET_STOP_ALL

    96

	{ WWT_PUSHIMGBTN,     RESIZE_LR,    14,   281,   292,    14,    25, SPR_FLAG_VEH_RUNNING,STR_MASS_START_DEPOT_TOOLTIP},     // DEPOT_WIDGET_START_ALL

    97

	{     WWT_IMGBTN,    RESIZE_LRB,    14,   270,   292,    26,    61, 0x2A9,               STR_NULL},                         // DEPOT_WIDGET_SELL

    98

	{      WWT_PANEL,   RESIZE_LRTB,    14,   326,   348,     0,     0, 0x2BF,               STR_DRAG_WHOLE_TRAIN_TO_SELL_TIP}, // DEPOT_WIDGET_SELL_ALL, trains only

    99

   100

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

   101

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

   102

   103

	{ WWT_HSCROLLBAR,    RESIZE_RTB,    14,     0,   325,    98,   109, 0x0,                 STR_HSCROLL_BAR_SCROLLS_LIST},     // DEPOT_WIDGET_H_SCROLL, trains only

   104

   105

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

   106

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

   107

	{ WWT_PUSHTXTBTN,     RESIZE_TB,    14,     0,    96,    62,    73, 0x0,                 STR_NULL},                         // DEPOT_WIDGET_BUILD

   108

	{WWT_NODISTXTBTN,     RESIZE_TB,    14,    97,   194,    62,    73, 0x0,                 STR_NULL},                         // DEPOT_WIDGET_CLONE

   109

	{ WWT_PUSHTXTBTN,     RESIZE_TB,    14,   195,   292,    62,    73, STR_00E4_LOCATION,   STR_NULL},                         // DEPOT_WIDGET_LOCATION

   110

	{  WWT_RESIZEBOX,   RESIZE_LRTB,    14,   293,   304,    62,    73, 0x0,                 STR_RESIZE_BUTTON},                // DEPOT_WIDGET_RESIZE

   111

	{   WIDGETS_END},

   112

};

   113

   114

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

   115

   116

static const WindowDesc _train_depot_desc = {

   117

	-1, -1, 361, 122,

   118

	WC_VEHICLE_DEPOT,0,

   119

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

   120

	_depot_widgets,

   121

	DepotWndProc

   122

};

   123

   124

static const WindowDesc _road_depot_desc = {

   125

	-1, -1, 315, 68,

   126

	WC_VEHICLE_DEPOT,0,

   127

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

   128

	_depot_widgets,

   129

	DepotWndProc

   130

};

   131

   132

static const WindowDesc _ship_depot_desc = {

   133

	-1, -1, 305, 74,

   134

	WC_VEHICLE_DEPOT,0,

   135

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

   136

	_depot_widgets,

   137

	DepotWndProc

   138

};

   139

   140

static const WindowDesc _aircraft_depot_desc = {

   141

	-1, -1, 331, 74,

   142

	WC_VEHICLE_DEPOT,0,

   143

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

   144

	_depot_widgets,

   145

	DepotWndProc

   146

};

   147

   148

extern int WagonLengthToPixels(int len);

   149

   150

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

   151

{

   152

	if (!success) return;

   153

	CcCloneShip(true, tile, p1, p2);

   154

}

   155

   156

static inline void ShowVehicleViewWindow(const Vehicle *v)

   157

{

   158

	switch (v->type) {

   159

		case VEH_Train:    ShowTrainViewWindow(v);    break;

   160

		case VEH_Road:     ShowRoadVehViewWindow(v);  break;

   161

		case VEH_Ship:     ShowShipViewWindow(v);     break;

   162

		case VEH_Aircraft: ShowAircraftViewWindow(v); break;

   163

		default: NOT_REACHED();

   164

	}

   165

}

   166

   167

static void DrawDepotWindow(Window *w)

   168

{

   169

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

   170

	TileIndex tile;

   171

	int x, y, i, hnum, max;

   172

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

   173

   174

	tile = w->window_number;

   175

   176

	/* setup disabled buttons */

   177

	w->disabled_state =

   178

		IsTileOwner(tile, _local_player) ? 0 : ( (1 << DEPOT_WIDGET_STOP_ALL) | (1 << DEPOT_WIDGET_START_ALL) |

   179

		(1 << DEPOT_WIDGET_SELL) | (1 << DEPOT_WIDGET_SELL_ALL) | (1 << DEPOT_WIDGET_BUILD) | (1 << DEPOT_WIDGET_CLONE));

   180

   181

	/* determine amount of items for scroller */

   182

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

   183

		hnum = 8;

   184

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

   185

			const Vehicle *v = vl[num];

   186

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

   187

		}

   188

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

   189

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

   190

		SetHScrollCount(w, WagonLengthToPixels(hnum));

   191

	} else {

   192

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

   193

	}

   194

   195

	/* locate the depot struct */

   196

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

   197

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

   198

	} else {

   199

		Depot *depot = GetDepotByTile(tile);

   200

		assert(depot != NULL);

   201

   202

		SetDParam(0, depot->town_index);

   203

	}

   204

   205

	DrawWindowWidgets(w);

   206

   207

	x = 2;

   208

	y = 15;

   209

	num = w->vscroll.pos * w->hscroll.cap;

   210

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

   211

		max = min(WP(w, depot_d).engine_count, w->vscroll.pos + w->vscroll.cap);

   212

		num = w->vscroll.pos;

   213

	} else {

   214

		max = min(WP(w, depot_d).engine_count, num + (w->vscroll.cap * w->hscroll.cap));

   215

		num = w->vscroll.pos * w->hscroll.cap;

   216

	}

   217

   218

	for (; num < max; num++) {

   219

		const Vehicle *v = vl[num];

   220

		byte diff_x = 0, diff_y = 0;

   221

   222

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

   223

			case VEH_Train:

   224

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

   225

   226

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

   227

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

   228

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

   229

				break;

   230

   231

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

   232

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

   233

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

   234

			default: NOT_REACHED();

   235

		}

   236

   237

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

   238

			/* VEH_Train and VEH_Road, which are low */

   239

			diff_x = 15;

   240

		} else {

   241

			/* VEH_Ship and VEH_Aircraft, which are tall */

   242

			diff_y = 12;

   243

		}

   244

   245

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

   246

   247

		SetDParam(0, v->unitnumber);

   248

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

   249

   250

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

   251

			y += w->resize.step_height;

   252

		} else {

   253

			if ((x += w->resize.step_width) == 2 + (int)w->resize.step_width * w->hscroll.cap) {

   254

				x = 2;

   255

				y += w->resize.step_height;

   256

			}

   257

		}

   258

	}

   259

   260

	max = min(WP(w, depot_d).engine_count + WP(w, depot_d).wagon_count, w->vscroll.pos + w->vscroll.cap);

   261

   262

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

   263

	for (; num < max; num++) {

   264

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

   265

		const Vehicle *u;

   266

   267

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

   268

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

   269

   270

		/*Draw the train counter */

   271

		i = 0;

   272

		u = v;

   273

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

   274

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

   275

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

   276

		y += 14;

   277

	}

   278

}

   279

   280

typedef struct GetDepotVehiclePtData {

   281

	Vehicle *head;

   282

	Vehicle *wagon;

   283

} GetDepotVehiclePtData;

   284

   285

enum {

   286

	MODE_ERROR        =  1,

   287

	MODE_DRAG_VEHICLE =  0,

   288

	MODE_SHOW_VEHICLE = -1,

   289

	MODE_START_STOP   = -2,

   290

};

   291

   292

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

   293

{

   294

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

   295

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

   296

	int pos, skip = 0;

   297

   298

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

   299

		xt = 0;

   300

		x -= 23;

   301

	} else {

   302

		xt = x / w->resize.step_width;

   303

		xm = x % w->resize.step_width;

   304

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

   305

   306

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

   307

	}

   308

   309

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

   310

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

   311

   312

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

   313

   314

	if (WP(w, depot_d).type == VEH_Train) pos = row + w->vscroll.pos;

   315

   316

	if (WP(w, depot_d).engine_count + WP(w, depot_d).wagon_count <= pos) return MODE_ERROR; // empty block, so no vehicle is selected

   317

   318

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

   319

		*veh = vl[pos];

   320

		skip = w->hscroll.pos;

   321

	} else {

   322

		vl = WP(w, depot_d).wagon_list;

   323

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

   324

		*veh = vl[pos];

   325

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

   326

		x -= _traininfo_vehicle_width;

   327

	}

   328

   329

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

   330

		case VEH_Train: {

   331

			Vehicle *v = *veh;

   332

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

   333

   334

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

   335

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

   336

   337

			skip = (skip * 8) / _traininfo_vehicle_width;

   338

			x = (x * 8) / _traininfo_vehicle_width;

   339

   340

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

   341

			x += skip;

   342

   343

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

   344

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

   345

   346

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

   347

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

   348

   349

			d->wagon = v;

   350

   351

			return MODE_DRAG_VEHICLE;

   352

			}

   353

			break;

   354

   355

		case VEH_Road:

   356

			if (xm >= 24) return MODE_DRAG_VEHICLE;

   357

			if (xm <= 16) return MODE_SHOW_VEHICLE;

   358

			break;

   359

   360

		case VEH_Ship:

   361

			if (xm >= 19) return MODE_DRAG_VEHICLE;

   362

			if (ym <= 10) return MODE_SHOW_VEHICLE;

   363

			break;

   364

   365

		case VEH_Aircraft:

   366

			if (xm >= 12) return MODE_DRAG_VEHICLE;

   367

			if (ym <= 12) return MODE_SHOW_VEHICLE;

   368

			break;

   369

   370

		default: NOT_REACHED();

   371

	}

   372

	return MODE_START_STOP;

   373

}

   374

   375

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

   376

{

   377

	Vehicle *v;

   378

   379

	v = GetVehicle(sel);

   380

   381

	if (v == wagon) return;

   382

   383

	if (wagon == NULL) {

   384

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

   385

	} else  {

   386

		wagon = GetPrevVehicleInChain(wagon);

   387

		if (wagon == NULL) return;

   388

	}

   389

   390

	if (wagon == v) return;

   391

   392

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

   393

}

   394

   395

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

   396

{

   397

	GetDepotVehiclePtData gdvp;

   398

	Vehicle *v = NULL;

   399

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

   400

   401

	/* share / copy orders */

   402

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

   403

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

   404

		return;

   405

	}

   406

   407

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

   408

   409

	switch (mode) {

   410

		case MODE_ERROR: // invalid

   411

			return;

   412

   413

		case MODE_DRAG_VEHICLE: { // start dragging of vehicle

   414

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

   415

   416

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

   417

				WP(w,depot_d).sel = INVALID_VEHICLE;

   418

				TrainDepotMoveVehicle(v, sel, gdvp.head);

   419

			} else if (v != NULL) {

   420

				int image;

   421

   422

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

   423

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

   424

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

   425

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

   426

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

   427

					default: NOT_REACHED(); image = 0;

   428

				}

   429

   430

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

   431

				SetWindowDirty(w);

   432

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

   433

			}

   434

			}

   435

			break;

   436

   437

		case MODE_SHOW_VEHICLE: // show info window

   438

			ShowVehicleViewWindow(v);

   439

			break;

   440

   441

		case MODE_START_STOP: { // click start/stop flag

   442

			uint command;

   443

   444

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

   445

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

   446

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

   447

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

   448

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

   449

				default: NOT_REACHED(); command = 0;

   450

			}

   451

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

   452

			}

   453

			break;

   454

   455

		default: NOT_REACHED();

   456

	}

   457

}

   458

   459

/**

   460

 * Clones a vehicle

   461

 * @param *v is the original vehicle to clone

   462

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

   463

 */

   464

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

   465

{

   466

	uint error_str;

   467

   468

	if (v == NULL) return;

   469

   470

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

   471

		v = GetFirstVehicleInChain(v);

   472

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

   473

		if (!IsFrontEngine(v)) return;

   474

	}

   475

   476

	switch (v->type) {

   477

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

   478

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

   479

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

   480

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

   481

		default: return;

   482

	}

   483

   484

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

   485

   486

	ResetObjectToPlace();

   487

}

   488

   489

static void ClonePlaceObj(const Window *w)

   490

{

   491

	const Vehicle *v = CheckMouseOverVehicle();

   492

   493

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

   494

}

   495

   496

static void ResizeDepotButtons(Window *w)

   497

{

   498

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

   499

   500

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

   501

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

   502

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

   503

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

   504

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

   505

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

   506

   507

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

   508

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

   509

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

   510

		w->widget[DEPOT_WIDGET_SELL_ALL].bottom = w->widget[DEPOT_WIDGET_RESIZE].top - 1;

   511

		w->widget[DEPOT_WIDGET_SELL_ALL].top    = ((w->widget[DEPOT_WIDGET_SELL_ALL].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_ALL].top - 1;

   513

	}

   514

}

   515

   516

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

   517

{

   518

	switch (e->event) {

   519

		case WE_CREATE:

   520

			WP(w, depot_d).vehicle_list = NULL;

   521

			WP(w, depot_d).wagon_list   = NULL;

   522

			WP(w, depot_d).engine_count = 0;