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

	/* Widgets are set up run-time */

    88

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

    89

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

    90

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

    91

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

    92

    93

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

    94

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

    95

    96

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

    97

    98

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

    99

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

   100

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

   101

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

   102

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

   103

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

   104

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

   105

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

   106

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

   107

	{   WIDGETS_END},

   108

};

   109

   110

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

   111

   112

static const WindowDesc _train_depot_desc = {

   113

	-1, -1, 361, 122,

   114

	WC_VEHICLE_DEPOT,0,

   115

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

   116

	_depot_widgets,

   117

	DepotWndProc

   118

};

   119

   120

static const WindowDesc _road_depot_desc = {

   121

	-1, -1, 315, 96,

   122

	WC_VEHICLE_DEPOT,0,

   123

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

   124

	_depot_widgets,

   125

	DepotWndProc

   126

};

   127

   128

static const WindowDesc _ship_depot_desc = {

   129

	-1, -1, 305, 98,

   130

	WC_VEHICLE_DEPOT,0,

   131

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

   132

	_depot_widgets,

   133

	DepotWndProc

   134

};

   135

   136

static const WindowDesc _aircraft_depot_desc = {

   137

	-1, -1, 331, 98,

   138

	WC_VEHICLE_DEPOT,0,

   139

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

   140

	_depot_widgets,

   141

	DepotWndProc

   142

};

   143

   144

extern int WagonLengthToPixels(int len);

   145

   146

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

   147

{

   148

	if (!success) return;

   149

	switch(GetVehicle(p1)->type) {

   150

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

   151

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

   152

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

   153

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

   154

	}

   155

}

   156

   157

static inline void ShowVehicleViewWindow(const Vehicle *v)

   158

{

   159

	switch (v->type) {

   160

		case VEH_Train:    ShowTrainViewWindow(v);    break;

   161

		case VEH_Road:     ShowRoadVehViewWindow(v);  break;

   162

		case VEH_Ship:     ShowShipViewWindow(v);     break;

   163

		case VEH_Aircraft: ShowAircraftViewWindow(v); break;

   164

		default: NOT_REACHED();

   165

	}

   166

}

   167

   168

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

   169

{

   170

	TileIndex tile = w->window_number;

   171

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

   172

   173

	switch (e->event) {

   174

		case WE_PAINT:

   175

			if (vehicle_type == VEH_Aircraft) {

   176

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

   177

			} else {

   178

				Depot *depot = GetDepotByTile(tile);

   179

				assert(depot != NULL);

   180

   181

				SetDParam(0, depot->town_index);

   182

			}

   183

			DrawWindowWidgets(w);

   184

   185

			DrawStringCentered(150, 25, STR_DEPOT_SELL_ALL_VEHICLE_CONFIRM, 0);

   186

			DrawStringCentered(150, 38, STR_ARE_YOU_SURE, 0);

   187

			break;

   188

   189

		case WE_CLICK:

   190

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

   191

				case 4:

   192

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

   193

					DeleteWindow(w);

   194

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

   195

					break;

   196

   197

				case 3:

   198

					DeleteWindow(w);

   199

					break;

   200

			}

   201

			break;

   202

	}

   203

}

   204

   205

static const Widget _depot_sell_all_widgets[] = {

   206

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

   207

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

   208

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

   209

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

   210

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

   211

	{   WIDGETS_END},

   212

};

   213

   214

static const WindowDesc _depot_sell_all_desc = {

   215

	WDP_CENTER, WDP_CENTER, 300, 72,

   216

	WC_DEPOT_SELL_ALL, WC_VEHICLE_DEPOT,

   217

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET,

   218

	_depot_sell_all_widgets,

   219

	DepotSellAllWndProc

   220

};

   221

   222

static void ShowDepotSellAllWindow(TileIndex tile, byte type)

   223

{

   224

	Window *w;

   225

   226

	_alloc_wnd_parent_num = tile;

   227

	w = AllocateWindowDescFront(&_depot_sell_all_desc, tile);

   228

   229

	if (w != NULL) {

   230

		w->caption_color = GetTileOwner(tile);

   231

		WP(w, depot_d).type = type;

   232

		switch (type) {

   233

			case VEH_Train:

   234

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

   235

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

   236

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

   237

				break;

   238

   239

			case VEH_Road:

   240

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

   241

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

   242

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

   243

				break;

   244

   245

			case VEH_Ship:

   246

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

   247

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

   248

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

   249

				break;

   250

   251

			case VEH_Aircraft:

   252

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

   253

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

   254

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

   255

				break;

   256

		}

   257

	}

   258

}

   259

   260

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

   261

 * @param *w Window to draw in

   262

 * @param *v Vehicle to draw

   263

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

   264

 * @param y Top of the box to draw in

   265

 */

   266

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

   267

{

   268

	byte diff_x = 0, diff_y = 0;

   269

   270

	switch (v->type) {

   271

		case VEH_Train:

   272

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

   273

   274

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

   275

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

   276

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

   277

			break;

   278

   279

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

   280

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

   281

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

   282

		default: NOT_REACHED();

   283

	}

   284

   285

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

   286

		/* VEH_Train and VEH_Road, which are low */

   287

		diff_x = 15;

   288

	} else {

   289

		/* VEH_Ship and VEH_Aircraft, which are tall */

   290

		diff_y = 12;

   291

	}

   292

   293

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

   294

   295

	SetDParam(0, v->unitnumber);

   296

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

   297

}

   298

   299

static void DrawDepotWindow(Window *w)

   300

{

   301

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

   302

	TileIndex tile = w->window_number;

   303

	int x, y, i, hnum, max;

   304

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

   305

   306

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

   307

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

   308

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

   309

   310

	/* setup disabled buttons */

   311

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

   312

		DEPOT_WIDGET_STOP_ALL,

   313

		DEPOT_WIDGET_START_ALL,

   314

		DEPOT_WIDGET_SELL,

   315

		DEPOT_WIDGET_SELL_CHAIN,

   316

		DEPOT_WIDGET_SELL_ALL,

   317

		DEPOT_WIDGET_BUILD,

   318

		DEPOT_WIDGET_CLONE,

   319

		DEPOT_WIDGET_AUTOREPLACE,

   320

		WIDGET_LIST_END);

   321

   322

	/* determine amount of items for scroller */

   323

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

   324

		hnum = 8;

   325

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

   326

			const Vehicle *v = vl[num];

   327

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

   328

		}

   329

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

   330

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

   331

		SetHScrollCount(w, WagonLengthToPixels(hnum));

   332

	} else {

   333

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

   334

	}

   335

   336

	/* locate the depot struct */

   337

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

   338

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

   339

	} else {

   340

		Depot *depot = GetDepotByTile(tile);

   341

		assert(depot != NULL);

   342

   343

		SetDParam(0, depot->town_index);

   344

	}

   345

   346

	DrawWindowWidgets(w);

   347

   348

	num = w->vscroll.pos * boxes_in_each_row;

   349

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

   350

   351

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

   352

		byte i;

   353

   354

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

   355

			/* Draw all vehicles in the current row */

   356

			const Vehicle *v = vl[num];

   357

			DrawVehicleInDepot(w, v, x, y);

   358

		}

   359

	}

   360

   361

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

   362

   363

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

   364

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

   365

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

   366

		const Vehicle *u;

   367

   368

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

   369

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

   370

   371

		/*Draw the train counter */

   372

		i = 0;

   373

		u = v;

   374

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

   375

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

   376

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

   377

	}

   378

}

   379

   380

typedef struct GetDepotVehiclePtData {

   381

	Vehicle *head;

   382

	Vehicle *wagon;

   383

} GetDepotVehiclePtData;

   384

   385

enum {

   386

	MODE_ERROR        =  1,

   387

	MODE_DRAG_VEHICLE =  0,

   388

	MODE_SHOW_VEHICLE = -1,

   389

	MODE_START_STOP   = -2,

   390

};

   391

   392

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

   393

{

   394

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

   395

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

   396

	int pos, skip = 0;

   397

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

   398

   399

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

   400

		xt = 0;

   401

		x -= 23;

   402

	} else {

   403

		xt = x / w->resize.step_width;

   404

		xm = x % w->resize.step_width;

   405

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

   406

   407

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

   408

	}

   409

   410

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

   411

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

   412

   413

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

   414

   415

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

   416

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

   417

			d->head  = NULL;

   418

			d->wagon = NULL;

   419

			return MODE_DRAG_VEHICLE;

   420

		} else {

   421

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

   422

		}

   423

	}

   424

   425

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

   426

		*veh = vl[pos];

   427

		skip = w->hscroll.pos;

   428

	} else {

   429

		vl = WP(w, depot_d).wagon_list;

   430

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

   431

		*veh = vl[pos];

   432

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

   433

		x -= _traininfo_vehicle_width;

   434

	}

   435

   436

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

   437

		case VEH_Train: {

   438

			Vehicle *v = *veh;

   439

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

   440

   441

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

   442

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

   443

   444

			skip = (skip * 8) / _traininfo_vehicle_width;

   445

			x = (x * 8) / _traininfo_vehicle_width;

   446

   447

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

   448

			x += skip;

   449

   450

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

   451

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

   452

   453

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

   454

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

   455

   456

			d->wagon = v;

   457

   458

			return MODE_DRAG_VEHICLE;

   459

			}

   460

			break;

   461

   462

		case VEH_Road:

   463

			if (xm >= 24) return MODE_DRAG_VEHICLE;

   464

			if (xm <= 16) return MODE_SHOW_VEHICLE;

   465

			break;

   466

   467

		case VEH_Ship:

   468

			if (xm >= 19) return MODE_DRAG_VEHICLE;

   469

			if (ym <= 10) return MODE_SHOW_VEHICLE;

   470

			break;

   471

   472

		case VEH_Aircraft:

   473

			if (xm >= 12) return MODE_DRAG_VEHICLE;

   474

			if (ym <= 12) return MODE_SHOW_VEHICLE;

   475

			break;

   476

   477

		default: NOT_REACHED();

   478

	}

   479

	return MODE_START_STOP;

   480

}

   481

   482

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

   483

{

   484

	Vehicle *v;

   485

   486

	v = GetVehicle(sel);

   487

   488

	if (v == wagon) return;

   489

   490

	if (wagon == NULL) {

   491

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

   492

	} else  {

   493

		wagon = GetPrevVehicleInChain(wagon);

   494

		if (wagon == NULL) return;

   495

	}

   496

   497

	if (wagon == v) return;

   498

   499

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

   500

}

   501

   502

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

   503

{

   504

	GetDepotVehiclePtData gdvp;

   505

	Vehicle *v = NULL;

   506

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