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

enum {

    23

	WIDGET_DEPOT_MOVE_NONE   = 0 << 0,

    24

	WIDGET_DEPOT_MOVE_RIGHT  = 1 << 0,

    25

	WIDGET_DEPOT_MOVE_LEFT   = 1 << 1,

    26

	WIDGET_DEPOT_MOVE_TOP    = 1 << 2,

    27

	WIDGET_DEPOT_MOVE_BOTTOM = 1 << 3,

    28

    29

	DEPOT_MOVE_NONE               = WIDGET_DEPOT_MOVE_NONE,

    30

	DEPOT_STRETCH_RIGHT           = WIDGET_DEPOT_MOVE_RIGHT,

    31

	DEPOT_MOVE_RIGHT              = WIDGET_DEPOT_MOVE_RIGHT | WIDGET_DEPOT_MOVE_LEFT,

    32

	DEPOT_STRETCH_DOWN            = WIDGET_DEPOT_MOVE_BOTTOM,

    33

	DEPOT_MOVE_DOWN               = WIDGET_DEPOT_MOVE_BOTTOM | WIDGET_DEPOT_MOVE_TOP,

    34

	DEPOT_STRETCH_DOWN_RIGHT      = DEPOT_STRETCH_DOWN | DEPOT_STRETCH_RIGHT,

    35

	DEPOT_MOVE_DOWN_RIGHT         = DEPOT_MOVE_RIGHT | DEPOT_MOVE_DOWN,

    36

	DEPOT_MOVE_RIGHT_STRETCH_DOWN = DEPOT_MOVE_RIGHT | DEPOT_STRETCH_DOWN,

    37

};

    38

    39

/*

    40

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

    41

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

    42

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

    43

 */

    44

    45

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

    46

typedef enum DepotWindowWidgets {

    47

	DEPOT_WIDGET_CLOSEBOX = 0,

    48

	DEPOT_WIDGET_CAPTION,

    49

	DEPOT_WIDGET_STICKY,

    50

	DEPOT_WIDGET_STOP_ALL,

    51

	DEPOT_WIDGET_START_ALL,

    52

	DEPOT_WIDGET_SELL,

    53

	DEPOT_WIDGET_SELL_CHAIN,

    54

	DEPOT_WIDGET_SELL_ALL,

    55

	DEPOT_WIDGET_MATRIX,

    56

	DEPOT_WIDGET_V_SCROLL, // Vertical scrollbar

    57

	DEPOT_WIDGET_H_SCROLL, // Horizontal scrollbar

    58

	DEPOT_WIDGET_BUILD,

    59

	DEPOT_WIDGET_CLONE,

    60

	DEPOT_WIDGET_LOCATION,

    61

	DEPOT_WIDGET_AUTOREPLACE,

    62

	DEPOT_WIDGET_RESIZE,

    63

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

    64

} DepotWindowWidget;

    65

    66

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

    67

static const byte widget_moves[] = {

    68

	DEPOT_MOVE_NONE,               // DEPOT_WIDGET_CLOSEBOX

    69

	DEPOT_STRETCH_RIGHT,           // DEPOT_WIDGET_CAPTION

    70

	DEPOT_MOVE_RIGHT,              // DEPOT_WIDGET_STICKY

    71

	DEPOT_MOVE_RIGHT,              // DEPOT_WIDGET_STOP_ALL

    72

	DEPOT_MOVE_RIGHT,              // DEPOT_WIDGET_START_ALL

    73

	DEPOT_MOVE_RIGHT,              // DEPOT_WIDGET_SELL

    74

	DEPOT_MOVE_NONE,               // DEPOT_WIDGET_SELL_CHAIN

    75

	DEPOT_MOVE_DOWN_RIGHT,         // DEPOT_WIDGET_SELL_ALL

    76

	DEPOT_STRETCH_DOWN_RIGHT,      // DEPOT_WIDGET_MATRIX

    77

	DEPOT_MOVE_RIGHT_STRETCH_DOWN, // DEPOT_WIDGET_V_SCROLL

    78

	DEPOT_MOVE_NONE,               // DEPOT_WIDGET_H_SCROLL

    79

	DEPOT_MOVE_DOWN,               // DEPOT_WIDGET_BUILD

    80

	DEPOT_MOVE_DOWN,               // DEPOT_WIDGET_CLONE

    81

	DEPOT_MOVE_DOWN,               // DEPOT_WIDGET_LOCATION

    82

	DEPOT_MOVE_DOWN_RIGHT,         // DEPOT_WIDGET_AUTOREPLACE

    83

	DEPOT_MOVE_DOWN_RIGHT,         // DEPOT_WIDGET_RESIZE

    84

};

    85

    86

/* Widget array for all depot windows.

    87

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

    88

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

    89

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

    90

    91

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

    92

 * 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

    93

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

    94

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

    95

 */

    96

static const Widget _depot_widgets[] = {

    97

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

    98

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

    99

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

   100

   101

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

   102

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

   103

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

   104

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

   105

	{ WWT_PUSHIMGBTN,   RESIZE_LRTB,    14,   270,   292,    61,    83, 0x0,                 STR_DEPOT_SELL_ALL_BUTTON_TIP},    // DEPOT_WIDGET_SELL_ALL

   106

   107

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

   108

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

   109

   110

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

   111

   112

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

   113

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

   114

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

   115

	{WWT_NODISTXTBTN,     RESIZE_TB,    14,    97,   194,    84,    95, 0x0,                 STR_NULL},                         // DEPOT_WIDGET_CLONE

   116

	{ WWT_PUSHTXTBTN,     RESIZE_TB,    14,   195,   292,    84,    95, STR_00E4_LOCATION,   STR_NULL},                         // DEPOT_WIDGET_LOCATION

   117

	{ WWT_PUSHIMGBTN,   RESIZE_LRTB,    14,   281,   292,    84,    95, 0x0,                 STR_DEPOT_AUTOREPLACE_TIP},        // DEPOT_WIDGET_AUTOREPLACE

   118

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

   119

	{   WIDGETS_END},

   120

};

   121

   122

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

   123

   124

static const WindowDesc _train_depot_desc = {

   125

	-1, -1, 361, 122,

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

   133

	-1, -1, 315, 82,

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

   141

	-1, -1, 305, 96,

   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

static const WindowDesc _aircraft_depot_desc = {

   149

	-1, -1, 331, 96,

   150

	WC_VEHICLE_DEPOT,0,

   151

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

   152

	_depot_widgets,

   153

	DepotWndProc

   154

};

   155

   156

extern int WagonLengthToPixels(int len);

   157

   158

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

   159

{

   160

	if (!success) return;

   161

	switch(GetVehicle(p1)->type) {

   162

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

   163

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

   164

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

   165

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

   166

	}

   167

}

   168

   169

static inline void ShowVehicleViewWindow(const Vehicle *v)

   170

{

   171

	switch (v->type) {

   172

		case VEH_Train:    ShowTrainViewWindow(v);    break;

   173

		case VEH_Road:     ShowRoadVehViewWindow(v);  break;

   174

		case VEH_Ship:     ShowShipViewWindow(v);     break;

   175

		case VEH_Aircraft: ShowAircraftViewWindow(v); break;

   176

		default: NOT_REACHED();

   177

	}

   178

}

   179

   180

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

   181

{

   182

	switch (e->event) {

   183

		case WE_PAINT:

   184

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

   185

				SetDParam(0, GetStationIndex(w->window_number)); // Airport name

   186

			} else {

   187

				Depot *depot = GetDepotByTile(w->window_number);

   188

				assert(depot != NULL);

   189

   190

				SetDParam(0, depot->town_index);

   191

			}

   192

			DrawWindowWidgets(w);

   193

   194

			DrawStringCentered(150, 25, STR_DEPOT_SELL_ALL_VEHICLE_CONFIRM, 0);

   195

			DrawStringCentered(150, 38, STR_ARE_YOU_SURE, 0);

   196

			break;

   197

   198

		case WE_CLICK:

   199

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

   200

				case 4:

   201

					DoCommandP(w->window_number, WP(w, depot_d).type, 0, NULL, CMD_DEPOT_SELL_ALL_VEHICLES);

   202

					/* Fallthought */

   203

				case 3:

   204

					DeleteWindow(w);

   205

					break;

   206

			}

   207

			break;

   208

	}

   209

}

   210

   211

static const Widget _depot_sell_all_widgets[] = {

   212

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

   213

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

   214

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

   215

	{ WWT_PUSHTXTBTN,   RESIZE_NONE,     5,    85,   144,    52,    63, STR_012E_CANCEL, STR_DEPOT_SELL_ALL_CANCEL_TIP},

   216

	{ WWT_PUSHTXTBTN,   RESIZE_NONE,     4,   155,   214,    52,    63, STR_SELL,        STR_DEPOT_SELL_ALL_TIP},

   217

	{   WIDGETS_END},

   218

};

   219

   220

static const WindowDesc _depot_sell_all_desc = {

   221

	WDP_CENTER, WDP_CENTER, 300, 72,

   222

	WC_DEPOT_SELL_ALL,0,

   223

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET,

   224

	_depot_sell_all_widgets,

   225

	DepotSellAllWndProc

   226

};

   227

   228

static void ShowDepotSellAllWindow(TileIndex tile, byte type)

   229

{

   230

	Window *w;

   231

   232

	w = AllocateWindowDescFront(&_depot_sell_all_desc, tile);

   233

   234

	if (w != NULL) {

   235

		WP(w, depot_d).type = type;

   236

		switch (type) {

   237

			case VEH_Train:	   w->widget[1].data = STR_8800_TRAIN_DEPOT;        break;

   238

			case VEH_Road:     w->widget[1].data = STR_9003_ROAD_VEHICLE_DEPOT; break;

   239

			case VEH_Ship:     w->widget[1].data = STR_9803_SHIP_DEPOT;         break;

   240

			case VEH_Aircraft:

   241

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

   242

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

   243

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

   244

				break;

   245

		}

   246

	}

   247

}

   248

   249

static void DrawDepotWindow(Window *w)

   250

{

   251

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

   252

	TileIndex tile;

   253

	int x, y, i, hnum, max;

   254

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

   255

   256

	tile = w->window_number;

   257

   258

	/* setup disabled buttons */

   259

	w->disabled_state =

   260

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

   261

			(1 << DEPOT_WIDGET_SELL) | (1 << DEPOT_WIDGET_SELL_CHAIN) | (1 << DEPOT_WIDGET_SELL_ALL) |

   262

			(1 << DEPOT_WIDGET_BUILD) | (1 << DEPOT_WIDGET_CLONE) | (1 << DEPOT_WIDGET_AUTOREPLACE));

   263

   264

	/* determine amount of items for scroller */

   265

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

   266

		hnum = 8;

   267

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

   268

			const Vehicle *v = vl[num];

   269

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

   270

		}

   271

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

   272

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

   273

		SetHScrollCount(w, WagonLengthToPixels(hnum));

   274

	} else {

   275

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

   276

	}

   277

   278

	/* locate the depot struct */

   279

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

   280

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

   281

	} else {

   282

		Depot *depot = GetDepotByTile(tile);

   283

		assert(depot != NULL);

   284

   285

		SetDParam(0, depot->town_index);

   286

	}

   287

   288

	DrawWindowWidgets(w);

   289

   290

	x = 2;

   291

	y = 15;

   292

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

   293

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

   294

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

   295

		num = w->vscroll.pos;

   296

	} else {

   297

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

   298

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

   299

	}

   300

   301

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

   302

		const Vehicle *v = vl[num];

   303

		byte diff_x = 0, diff_y = 0;

   304

   305

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

   306

			case VEH_Train:

   307

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

   308

   309

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

   310

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

   311

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

   312

				break;

   313

   314

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

   315

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

   316

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

   317

			default: NOT_REACHED();

   318

		}

   319

   320

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

   321

			/* VEH_Train and VEH_Road, which are low */

   322

			diff_x = 15;

   323

		} else {

   324

			/* VEH_Ship and VEH_Aircraft, which are tall */

   325

			diff_y = 12;

   326

		}

   327

   328

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

   329

   330

		SetDParam(0, v->unitnumber);

   331

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

   332

   333

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

   334

			y += w->resize.step_height;

   335

		} else {

   336

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

   337

				x = 2;

   338

				y += w->resize.step_height;

   339

			}

   340

		}

   341

	}

   342

   343

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

   344

   345

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

   346

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

   347

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

   348

		const Vehicle *u;

   349

   350

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

   351

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

   352

   353

		/*Draw the train counter */

   354

		i = 0;

   355

		u = v;

   356

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

   357

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

   358

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

   359

		y += 14;

   360

	}

   361

}

   362

   363

typedef struct GetDepotVehiclePtData {

   364

	Vehicle *head;

   365

	Vehicle *wagon;

   366

} GetDepotVehiclePtData;

   367

   368

enum {

   369

	MODE_ERROR        =  1,

   370

	MODE_DRAG_VEHICLE =  0,

   371

	MODE_SHOW_VEHICLE = -1,

   372

	MODE_START_STOP   = -2,

   373

};

   374

   375

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

   376

{

   377

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

   378

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

   379

	int pos, skip = 0;

   380

   381

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

   382

		xt = 0;

   383

		x -= 23;

   384

	} else {

   385

		xt = x / w->resize.step_width;

   386

		xm = x % w->resize.step_width;

   387

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

   388

   389

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

   390

	}

   391

   392

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

   393

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

   394

   395

	pos = (row + w->vscroll.pos) * (WP(w, depot_d).type == VEH_Train ? 1 : w->hscroll.cap) + xt;

   396

   397

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

   398

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

   399

			d->head  = NULL;

   400

			d->wagon = NULL;

   401

			return MODE_DRAG_VEHICLE;

   402

		} else {

   403

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

   404

		}

   405

	}

   406

   407

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

   408

		*veh = vl[pos];

   409

		skip = w->hscroll.pos;

   410

	} else {

   411

		vl = WP(w, depot_d).wagon_list;

   412

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

   413

		*veh = vl[pos];

   414

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

   415

		x -= _traininfo_vehicle_width;

   416

	}

   417

   418

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

   419

		case VEH_Train: {

   420

			Vehicle *v = *veh;

   421

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

   422

   423

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

   424

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

   425

   426

			skip = (skip * 8) / _traininfo_vehicle_width;

   427

			x = (x * 8) / _traininfo_vehicle_width;

   428

   429

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

   430

			x += skip;

   431

   432

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

   433

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

   434

   435

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

   436

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

   437

   438

			d->wagon = v;

   439

   440

			return MODE_DRAG_VEHICLE;

   441

			}

   442

			break;

   443

   444

		case VEH_Road:

   445

			if (xm >= 24) return MODE_DRAG_VEHICLE;

   446

			if (xm <= 16) return MODE_SHOW_VEHICLE;

   447

			break;

   448

   449

		case VEH_Ship:

   450

			if (xm >= 19) return MODE_DRAG_VEHICLE;

   451

			if (ym <= 10) return MODE_SHOW_VEHICLE;

   452

			break;

   453

   454

		case VEH_Aircraft:

   455

			if (xm >= 12) return MODE_DRAG_VEHICLE;

   456

			if (ym <= 12) return MODE_SHOW_VEHICLE;

   457

			break;

   458

   459

		default: NOT_REACHED();

   460

	}

   461

	return MODE_START_STOP;

   462

}

   463

   464

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

   465

{

   466

	Vehicle *v;

   467

   468

	v = GetVehicle(sel);

   469

   470

	if (v == wagon) return;

   471

   472

	if (wagon == NULL) {

   473

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

   474

	} else  {

   475

		wagon = GetPrevVehicleInChain(wagon);

   476

		if (wagon == NULL) return;

   477

	}

   478

   479

	if (wagon == v) return;

   480

   481

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

   482

}

   483

   484

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

   485

{

   486

	GetDepotVehiclePtData gdvp;

   487

	Vehicle *v = NULL;

   488

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

   489

   490

	/* share / copy orders */

   491

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

   492

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

   493

		return;

   494

	}

   495

   496

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

   497

   498

	switch (mode) {

   499

		case MODE_ERROR: // invalid

   500

			return;

   501

   502

		case MODE_DRAG_VEHICLE: { // start dragging of vehicle

   503

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

   504

   505

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

   506

				WP(w,depot_d).sel = INVALID_VEHICLE;

   507

				TrainDepotMoveVehicle(v, sel, gdvp.head);

   508

			} else if (v != NULL) {

   509

				int image;

   510

   511

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

   512

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

   513

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

   514

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