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

#include "resize_window_widgets.h"

    22

    23

/*

    24

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

    25

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

    26

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

    27

 */

    28

    29

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

    30

typedef enum DepotWindowWidgets {

    31

	DEPOT_WIDGET_CLOSEBOX = 0,

    32

	DEPOT_WIDGET_CAPTION,

    33

	DEPOT_WIDGET_STICKY,

    34

	DEPOT_WIDGET_SELL,

    35

	DEPOT_WIDGET_SELL_CHAIN,

    36

	DEPOT_WIDGET_SELL_ALL,

    37

	DEPOT_WIDGET_AUTOREPLACE,

    38

	DEPOT_WIDGET_MATRIX,

    39

	DEPOT_WIDGET_V_SCROLL, // Vertical scrollbar

    40

	DEPOT_WIDGET_H_SCROLL, // Horizontal scrollbar

    41

	DEPOT_WIDGET_BUILD,

    42

	DEPOT_WIDGET_CLONE,

    43

	DEPOT_WIDGET_LOCATION,

    44

	DEPOT_WIDGET_VEHICLE_LIST,

    45

	DEPOT_WIDGET_STOP_ALL,

    46

	DEPOT_WIDGET_START_ALL,

    47

	DEPOT_WIDGET_RESIZE,

    48

	DEPOT_WIDGET_LAST, // used to assert if DepotWindowWidgets and widget_moves got different lengths. Due to this usage, it needs to be last

    49

} DepotWindowWidget;

    50

    51

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

    52

static const byte widget_moves[] = {

    53

	WIDGET_MOVE_NONE,               // DEPOT_WIDGET_CLOSEBOX

    54

	WIDGET_STRETCH_RIGHT,           // DEPOT_WIDGET_CAPTION

    55

	WIDGET_MOVE_RIGHT,              // DEPOT_WIDGET_STICKY

    56

	WIDGET_MOVE_RIGHT_STRETCH_DOWN, // DEPOT_WIDGET_SELL

    57

	WIDGET_MOVE_NONE,               // DEPOT_WIDGET_SELL_CHAIN

    58

	WIDGET_MOVE_DOWN_RIGHT,         // DEPOT_WIDGET_SELL_ALL

    59

	WIDGET_MOVE_DOWN_RIGHT,         // DEPOT_WIDGET_AUTOREPLACE

    60

	WIDGET_STRETCH_DOWN_RIGHT,      // DEPOT_WIDGET_MATRIX

    61

	WIDGET_MOVE_RIGHT_STRETCH_DOWN, // DEPOT_WIDGET_V_SCROLL

    62

	WIDGET_MOVE_NONE,               // DEPOT_WIDGET_H_SCROLL

    63

	WIDGET_MOVE_DOWN,               // DEPOT_WIDGET_BUILD

    64

	WIDGET_MOVE_DOWN,               // DEPOT_WIDGET_CLONE

    65

	WIDGET_MOVE_DOWN,               // DEPOT_WIDGET_LOCATION

    66

	WIDGET_MOVE_DOWN_RIGHT,         // DEPOT_WIDGET_VEHICLE_LIST

    67

	WIDGET_MOVE_DOWN_RIGHT,         // DEPOT_WIDGET_STOP_ALL

    68

	WIDGET_MOVE_DOWN_RIGHT,         // DEPOT_WIDGET_START_ALL

    69

	WIDGET_MOVE_DOWN_RIGHT,         // DEPOT_WIDGET_RESIZE

    70

};

    71

    72

/* Widget array for all depot windows.

    73

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

    74

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

    75

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

    76

    77

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

    78

 * 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

    79

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

    80

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

    81

 */

    82

static const Widget _depot_widgets[] = {

    83

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

    84

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

    85

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

    86

    87

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

    88

	{      WWT_PANEL,   RESIZE_LRTB,    14,   326,   348,     0,     0, SPR_SELL_CHAIN_TRAIN,STR_DRAG_WHOLE_TRAIN_TO_SELL_TIP}, // DEPOT_WIDGET_SELL_CHAIN, trains only

    89

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

    90

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

    91

    92

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

    93

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

    94

    95

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

    96

    97

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

    98

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

    99

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

   100

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

   101

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

   102

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

   103

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

   104

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

   105

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

   106

	{   WIDGETS_END},

   107

};

   108

   109

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

   110

   111

static const WindowDesc _train_depot_desc = {

   112

	-1, -1, 361, 122,

   113

	WC_VEHICLE_DEPOT,0,

   114

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

   115

	_depot_widgets,

   116

	DepotWndProc

   117

};

   118

   119

static const WindowDesc _road_depot_desc = {

   120

	-1, -1, 315, 96,

   121

	WC_VEHICLE_DEPOT,0,

   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 _ship_depot_desc = {

   128

	-1, -1, 305, 98,

   129

	WC_VEHICLE_DEPOT,0,

   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 _aircraft_depot_desc = {

   136

	-1, -1, 331, 98,

   137

	WC_VEHICLE_DEPOT,0,

   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

extern int WagonLengthToPixels(int len);

   144

   145

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

   146

{

   147

	if (!success) return;

   148

	switch(GetVehicle(p1)->type) {

   149

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

   150

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

   151

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

   152

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

   153

	}

   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 DepotSellAllWndProc(Window *w, WindowEvent *e)

   168

{

   169

	TileIndex tile = w->window_number;

   170

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

   171

   172

	switch (e->event) {

   173

		case WE_PAINT:

   174

			if (vehicle_type == VEH_Aircraft) {

   175

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

   176

			} else {

   177

				Depot *depot = GetDepotByTile(tile);

   178

				assert(depot != NULL);

   179

   180

				SetDParam(0, depot->town_index);

   181

			}

   182

			DrawWindowWidgets(w);

   183

   184

			DrawStringCentered(150, 25, STR_DEPOT_SELL_ALL_VEHICLE_CONFIRM, 0);

   185

			DrawStringCentered(150, 38, STR_ARE_YOU_SURE, 0);

   186

			break;

   187

   188

		case WE_CLICK:

   189

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

   190

				case 4:

   191

					/* Weird issue here. If We execute the DoCommandP first, then the window is not closed */

   192

					DeleteWindow(w);

   193

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

   194

					break;

   195

   196

				case 3:

   197

					DeleteWindow(w);

   198

					break;

   199

			}

   200

			break;

   201

	}

   202

}

   203

   204

static const Widget _depot_sell_all_widgets[] = {

   205

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

   206

	{    WWT_CAPTION,   RESIZE_NONE,    14,    11,   299,     0,    13, 0x0,             STR_018C_WINDOW_TITLE_DRAG_THIS},

   207

	{      WWT_PANEL,   RESIZE_NONE,    14,     0,   299,    14,    71, 0x0,             STR_NULL},

   208

	{ WWT_PUSHTXTBTN,   RESIZE_NONE,    14,    85,   144,    52,    63, STR_012E_CANCEL, STR_NULL},

   209

	{ WWT_PUSHTXTBTN,   RESIZE_NONE,    14,   155,   214,    52,    63, STR_SELL,        STR_NULL},

   210

	{   WIDGETS_END},

   211

};

   212

   213

static const WindowDesc _depot_sell_all_desc = {

   214

	WDP_CENTER, WDP_CENTER, 300, 72,

   215

	WC_DEPOT_SELL_ALL, WC_VEHICLE_DEPOT,

   216

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET,

   217

	_depot_sell_all_widgets,

   218

	DepotSellAllWndProc

   219

};

   220

   221

static void ShowDepotSellAllWindow(TileIndex tile, byte type)

   222

{

   223

	Window *w;

   224

   225

	_alloc_wnd_parent_num = tile;

   226

	w = AllocateWindowDescFront(&_depot_sell_all_desc, tile);

   227

   228

	if (w != NULL) {

   229

		w->caption_color = GetTileOwner(tile);

   230

		WP(w, depot_d).type = type;

   231

		switch (type) {

   232

			case VEH_Train:

   233

				w->widget[1].data     = STR_8800_TRAIN_DEPOT;

   234

				w->widget[3].tooltips = STR_DEPOT_SELL_ALL_CANCEL_TRAIN_TIP;

   235

				w->widget[4].tooltips = STR_DEPOT_SELL_ALL_TRAIN_TIP;

   236

				break;

   237

   238

			case VEH_Road:

   239

				w->widget[1].data     = STR_9003_ROAD_VEHICLE_DEPOT;

   240

				w->widget[3].tooltips = STR_DEPOT_SELL_ALL_CANCEL_ROADVEH_TIP;

   241

				w->widget[4].tooltips = STR_DEPOT_SELL_ALL_ROADVEH_TIP;

   242

				break;

   243

   244

			case VEH_Ship:

   245

				w->widget[1].data     = STR_9803_SHIP_DEPOT;

   246

				w->widget[3].tooltips = STR_DEPOT_SELL_ALL_CANCEL_SHIP_TIP;

   247

				w->widget[4].tooltips = STR_DEPOT_SELL_ALL_SHIP_TIP;

   248

				break;

   249

   250

			case VEH_Aircraft:

   251

				w->widget[1].data     = STR_A002_AIRCRAFT_HANGAR;

   252

				w->widget[3].tooltips = STR_DEPOT_SELL_ALL_CANCEL_AIRCRAFT_TIP;

   253

				w->widget[4].tooltips = STR_DEPOT_SELL_ALL_AIRCRAFT_TIP;

   254

				break;

   255

		}

   256

	}

   257

}

   258

   259

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

   260

 * @param *w Window to draw in

   261

 * @param *v Vehicle to draw

   262

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

   263

 * @param y Top of the box to draw in

   264

 */

   265

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

   266

{

   267

	byte diff_x = 0, diff_y = 0;

   268

   269

	switch (v->type) {

   270

		case VEH_Train:

   271

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

   272

   273

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

   274

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

   275

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

   276

			break;

   277

   278

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

   279

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

   280

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

   281

		default: NOT_REACHED();

   282

	}

   283

   284

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

   285

		/* VEH_Train and VEH_Road, which are low */

   286

		diff_x = 15;

   287

	} else {

   288

		/* VEH_Ship and VEH_Aircraft, which are tall */

   289

		diff_y = 12;

   290

	}

   291

   292

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

   293

   294

	SetDParam(0, v->unitnumber);

   295

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

   296

}

   297

   298

static void DrawDepotWindow(Window *w)

   299

{

   300

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

   301

	TileIndex tile = w->window_number;

   302

	int x, y, i, hnum, max;

   303

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

   304

   305

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

   306

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

   307

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

   308

   309

	/* setup disabled buttons */

   310

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

   311

		DEPOT_WIDGET_STOP_ALL,

   312

		DEPOT_WIDGET_START_ALL,

   313

		DEPOT_WIDGET_SELL,

   314

		DEPOT_WIDGET_SELL_CHAIN,

   315

		DEPOT_WIDGET_SELL_ALL,

   316

		DEPOT_WIDGET_BUILD,

   317

		DEPOT_WIDGET_CLONE,

   318

		DEPOT_WIDGET_AUTOREPLACE,

   319

		WIDGET_LIST_END);

   320

   321

	/* determine amount of items for scroller */

   322

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

   323

		hnum = 8;

   324

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

   325

			const Vehicle *v = vl[num];

   326

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

   327

		}

   328

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

   329

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

   330

		SetHScrollCount(w, WagonLengthToPixels(hnum));

   331

	} else {

   332

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

   333

	}

   334

   335

	/* locate the depot struct */

   336

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

   337

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

   338

	} else {

   339

		Depot *depot = GetDepotByTile(tile);

   340

		assert(depot != NULL);

   341

   342

		SetDParam(0, depot->town_index);

   343

	}

   344

   345

	DrawWindowWidgets(w);

   346

   347

	num = w->vscroll.pos * boxes_in_each_row;

   348

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

   349

   350

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

   351

		byte i;

   352

   353

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

   354

			/* Draw all vehicles in the current row */

   355

			const Vehicle *v = vl[num];

   356

			DrawVehicleInDepot(w, v, x, y);

   357

		}

   358

	}

   359

   360

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

   361

   362

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

   363

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

   364

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

   365

		const Vehicle *u;

   366

   367

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

   368

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

   369

   370

		/*Draw the train counter */

   371

		i = 0;

   372

		u = v;

   373

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

   374

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

   375

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

   376

	}

   377

}

   378

   379

typedef struct GetDepotVehiclePtData {

   380

	Vehicle *head;

   381

	Vehicle *wagon;

   382

} GetDepotVehiclePtData;

   383

   384

enum {

   385

	MODE_ERROR        =  1,

   386

	MODE_DRAG_VEHICLE =  0,

   387

	MODE_SHOW_VEHICLE = -1,

   388

	MODE_START_STOP   = -2,

   389

};

   390

   391

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

   392

{

   393

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

   394

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

   395

	int pos, skip = 0;

   396

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

   397

   398

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

   399

		xt = 0;

   400

		x -= 23;

   401

	} else {

   402

		xt = x / w->resize.step_width;

   403

		xm = x % w->resize.step_width;

   404

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

   405

   406

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

   407

	}

   408

   409

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

   410

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

   411

   412

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

   413

   414

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

   415

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

   416

			d->head  = NULL;

   417

			d->wagon = NULL;

   418

			return MODE_DRAG_VEHICLE;

   419

		} else {

   420

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

   421

		}

   422

	}

   423

   424

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

   425

		*veh = vl[pos];

   426

		skip = w->hscroll.pos;

   427

	} else {

   428

		vl = WP(w, depot_d).wagon_list;

   429

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

   430

		*veh = vl[pos];

   431

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

   432

		x -= _traininfo_vehicle_width;

   433

	}

   434

   435

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

   436

		case VEH_Train: {

   437

			Vehicle *v = *veh;

   438

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

   439

   440

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

   441

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

   442

   443

			skip = (skip * 8) / _traininfo_vehicle_width;

   444

			x = (x * 8) / _traininfo_vehicle_width;

   445

   446

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

   447

			x += skip;

   448

   449

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

   450

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

   451

   452

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

   453

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

   454

   455

			d->wagon = v;

   456

   457

			return MODE_DRAG_VEHICLE;

   458

			}

   459

			break;

   460

   461

		case VEH_Road:

   462

			if (xm >= 24) return MODE_DRAG_VEHICLE;

   463

			if (xm <= 16) return MODE_SHOW_VEHICLE;

   464

			break;

   465

   466

		case VEH_Ship:

   467

			if (xm >= 19) return MODE_DRAG_VEHICLE;

   468

			if (ym <= 10) return MODE_SHOW_VEHICLE;

   469

			break;

   470

   471

		case VEH_Aircraft:

   472

			if (xm >= 12) return MODE_DRAG_VEHICLE;

   473

			if (ym <= 12) return MODE_SHOW_VEHICLE;

   474

			break;

   475

   476

		default: NOT_REACHED();

   477

	}

   478

	return MODE_START_STOP;

   479

}

   480

   481

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

   482

{

   483

	Vehicle *v;

   484

   485

	v = GetVehicle(sel);

   486

   487

	if (v == wagon) return;

   488

   489

	if (wagon == NULL) {

   490

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

   491

	} else  {

   492

		wagon = GetPrevVehicleInChain(wagon);

   493

		if (wagon == NULL) return;

   494

	}

   495

   496

	if (wagon == v) return;

   497

   498

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

   499

}

   500

   501

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

   502

{

   503

	GetDepotVehiclePtData gdvp;

   504

	Vehicle *v = NULL;

   505

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

   506