1

/* $Id$ */

     2

     3

/** @file depot_gui.cpp The GUI for depots. */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "train.h"

     8

#include "roadveh.h"

     9

#include "ship.h"

    10

#include "aircraft.h"

    11

#include "gui.h"

    12

#include "textbuf_gui.h"

    13

#include "viewport_func.h"

    14

#include "gfx_func.h"

    15

#include "command_func.h"

    16

#include "depot_base.h"

    17

#include "vehicle_gui.h"

    18

#include "station_map.h"

    19

#include "newgrf_engine.h"

    20

#include "spritecache.h"

    21

#include "strings_func.h"

    22

#include "window_func.h"

    23

#include "vehicle_func.h"

    24

#include "company_func.h"

    25

#include "order_func.h"

    26

#include "depot_base.h"

    27

#include "tilehighlight_func.h"

    28

#include "window_gui.h"

    29

#include "vehiclelist.h"

    30

    31

#include "table/strings.h"

    32

#include "table/sprites.h"

    33

    34

/*

    35

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

    36

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

    37

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

    38

 */

    39

    40

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

    41

enum DepotWindowWidgets {

    42

	DEPOT_WIDGET_CLOSEBOX = 0,

    43

	DEPOT_WIDGET_CAPTION,

    44

	DEPOT_WIDGET_STICKY,

    45

	DEPOT_WIDGET_SELL,

    46

	DEPOT_WIDGET_SELL_CHAIN,

    47

	DEPOT_WIDGET_SELL_ALL,

    48

	DEPOT_WIDGET_AUTOREPLACE,

    49

	DEPOT_WIDGET_MATRIX,

    50

	DEPOT_WIDGET_V_SCROLL, ///< Vertical scrollbar

    51

	DEPOT_WIDGET_H_SCROLL, ///< Horizontal scrollbar

    52

	DEPOT_WIDGET_BUILD,

    53

	DEPOT_WIDGET_CLONE,

    54

	DEPOT_WIDGET_LOCATION,

    55

	DEPOT_WIDGET_VEHICLE_LIST,

    56

	DEPOT_WIDGET_STOP_ALL,

    57

	DEPOT_WIDGET_START_ALL,

    58

	DEPOT_WIDGET_RESIZE,

    59

};

    60

    61

/* Widget array for all depot windows.

    62

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

    63

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

    64

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

    65

    66

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

    67

 * 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

    68

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

    69

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

    70

 */

    71

    72

/*

    73

 * Some of the widgets are placed outside the window (negative coordinates).

    74

 * The reason is that they are placed relatively to the matrix and the matrix is just one pixel (in 0, 14).

    75

 * The matrix and the rest of the window will be resized when the size of the boxes is set and then all the widgets will be inside the window.

    76

 */

    77

static const Widget _depot_widgets[] = {

    78

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

    79

	{    WWT_CAPTION,  RESIZE_RIGHT,  COLOUR_GREY,    11,    23,     0,    13, 0x0,                 STR_018C_WINDOW_TITLE_DRAG_THIS},  // DEPOT_WIDGET_CAPTION

    80

	{  WWT_STICKYBOX,     RESIZE_LR,  COLOUR_GREY,    24,    35,     0,    13, 0x0,                 STR_STICKY_BUTTON},                // DEPOT_WIDGET_STICKY

    81

    82

	/* Widgets are set up run-time */

    83

	{     WWT_IMGBTN,    RESIZE_LRB,  COLOUR_GREY,     1,    23,    14,   -32, 0x0,                 STR_NULL},                         // DEPOT_WIDGET_SELL

    84

	{     WWT_IMGBTN,   RESIZE_LRTB,  COLOUR_GREY,     1,    23,   -55,   -32, SPR_SELL_CHAIN_TRAIN,STR_DRAG_WHOLE_TRAIN_TO_SELL_TIP}, // DEPOT_WIDGET_SELL_CHAIN, trains only

    85

	{ WWT_PUSHIMGBTN,   RESIZE_LRTB,  COLOUR_GREY,     1,    23,   -31,    -9, 0x0,                 STR_NULL},                         // DEPOT_WIDGET_SELL_ALL

    86

	{ WWT_PUSHIMGBTN,   RESIZE_LRTB,  COLOUR_GREY,     1,    23,    -8,    14, 0x0,                 STR_NULL},                         // DEPOT_WIDGET_AUTOREPLACE

    87

    88

	{     WWT_MATRIX,     RESIZE_RB,  COLOUR_GREY,     0,     0,    14,    14, 0x0,                 STR_NULL},                         // DEPOT_WIDGET_MATRIX

    89

	{  WWT_SCROLLBAR,    RESIZE_LRB,  COLOUR_GREY,    24,    35,    14,    14, 0x0,                 STR_0190_SCROLL_BAR_SCROLLS_LIST}, // DEPOT_WIDGET_V_SCROLL

    90

    91

	{ WWT_HSCROLLBAR,    RESIZE_RTB,  COLOUR_GREY,     0,     0,     3,    14, 0x0,                 STR_HSCROLL_BAR_SCROLLS_LIST},     // DEPOT_WIDGET_H_SCROLL, trains only

    92

    93

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

    94

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

    95

	{ WWT_PUSHTXTBTN,     RESIZE_TB,  COLOUR_GREY,     0,     0,    15,    26, 0x0,                 STR_NULL},                         // DEPOT_WIDGET_BUILD

    96

	{    WWT_TEXTBTN,     RESIZE_TB,  COLOUR_GREY,     0,     0,    15,    26, 0x0,                 STR_NULL},                         // DEPOT_WIDGET_CLONE

    97

	{ WWT_PUSHTXTBTN,    RESIZE_RTB,  COLOUR_GREY,     0,   -12,    15,    26, STR_00E4_LOCATION,   STR_NULL},                         // DEPOT_WIDGET_LOCATION

    98

	{ WWT_PUSHTXTBTN,   RESIZE_LRTB,  COLOUR_GREY,   -11,     0,    15,    26, 0x0,                 STR_NULL},                         // DEPOT_WIDGET_VEHICLE_LIST

    99

	{ WWT_PUSHIMGBTN,   RESIZE_LRTB,  COLOUR_GREY,     1,    11,    15,    26, SPR_FLAG_VEH_STOPPED,STR_NULL},                         // DEPOT_WIDGET_STOP_ALL

   100

	{ WWT_PUSHIMGBTN,   RESIZE_LRTB,  COLOUR_GREY,    12,    23,    15,    26, SPR_FLAG_VEH_RUNNING,STR_NULL},                         // DEPOT_WIDGET_START_ALL

   101

	{  WWT_RESIZEBOX,   RESIZE_LRTB,  COLOUR_GREY,    24,    35,    15,    26, 0x0,                 STR_RESIZE_BUTTON},                // DEPOT_WIDGET_RESIZE

   102

	{   WIDGETS_END},

   103

};

   104

   105

   106

static const WindowDesc _train_depot_desc = {

   107

	WDP_AUTO, WDP_AUTO, 36, 27, 36, 27,

   108

	WC_VEHICLE_DEPOT, WC_NONE,

   109

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

   110

	_depot_widgets,

   111

};

   112

   113

static const WindowDesc _road_depot_desc = {

   114

	WDP_AUTO, WDP_AUTO, 36, 27, 36, 27,

   115

	WC_VEHICLE_DEPOT, WC_NONE,

   116

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

   117

	_depot_widgets,

   118

};

   119

   120

static const WindowDesc _ship_depot_desc = {

   121

	WDP_AUTO, WDP_AUTO, 36, 27, 36, 27,

   122

	WC_VEHICLE_DEPOT, WC_NONE,

   123

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

   124

	_depot_widgets,

   125

};

   126

   127

static const WindowDesc _aircraft_depot_desc = {

   128

	WDP_AUTO, WDP_AUTO, 36, 27, 36, 27,

   129

	WC_VEHICLE_DEPOT, WC_NONE,

   130

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

   131

	_depot_widgets,

   132

};

   133

   134

extern int WagonLengthToPixels(int len);

   135

extern void DepotSortList(VehicleList *list);

   136

   137

/**

   138

 * This is the Callback method after the cloning attempt of a vehicle

   139

 * @param success indicates completion (or not) of the operation

   140

 * @param tile unused

   141

 * @param p1 unused

   142

 * @param p2 unused

   143

 */

   144

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

   145

{

   146

	if (!success) return;

   147

   148

	const Vehicle *v = GetVehicle(_new_vehicle_id);

   149

   150

	ShowVehicleViewWindow(v);

   151

}

   152

   153

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

   154

{

   155

	const Vehicle *v = GetVehicle(sel);

   156

   157

	if (v == wagon) return;

   158

   159

	if (wagon == NULL) {

   160

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

   161

	} else  {

   162

		wagon = wagon->Previous();

   163

		if (wagon == NULL) return;

   164

	}

   165

   166

	if (wagon == v) return;

   167

   168

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

   169

}

   170

   171

/* Array to hold the block sizes

   172

 * First part is the vehicle type, while the last is 0 = x, 1 = y */

   173

uint _block_sizes[4][2];

   174

   175

/* Array to hold the default resize capacities

   176

* First part is the vehicle type, while the last is 0 = x, 1 = y */

   177

const uint _resize_cap[][2] = {

   178

/* VEH_TRAIN */    {6, 10 * 29},

   179

/* VEH_ROAD */     {5, 5},

   180

/* VEH_SHIP */     {3, 3},

   181

/* VEH_AIRCRAFT */ {3, 4},

   182

};

   183

   184

static void ResizeDefaultWindowSizeForTrains()

   185

{

   186

	_block_sizes[VEH_TRAIN][0] = 1;

   187

	_block_sizes[VEH_TRAIN][1] = GetVehicleListHeight(VEH_TRAIN);

   188

}

   189

   190

static void ResizeDefaultWindowSizeForRoadVehicles()

   191

{

   192

	_block_sizes[VEH_ROAD][0] = 56;

   193

	_block_sizes[VEH_ROAD][1] = GetVehicleListHeight(VEH_ROAD);

   194

}

   195

   196

static void ResizeDefaultWindowSize(VehicleType type)

   197

{

   198

	uint max_width  = 0;

   199

	uint max_height = 0;

   200

   201

	const Engine *e;

   202

	FOR_ALL_ENGINES_OF_TYPE(e, type) {

   203

		EngineID eid = e->index;

   204

		uint x, y;

   205

   206

		switch (type) {

   207

			default: NOT_REACHED();

   208

			case VEH_SHIP:     GetShipSpriteSize(    eid, x, y); break;

   209

			case VEH_AIRCRAFT: GetAircraftSpriteSize(eid, x, y); break;

   210

		}

   211

		if (x > max_width)  max_width  = x;

   212

		if (y > max_height) max_height = y;

   213

	}

   214

   215

	switch (type) {

   216

		default: NOT_REACHED();

   217

		case VEH_SHIP:

   218

			_block_sizes[VEH_SHIP][0] = max(90U, max_width + 20); // we need 20 pixels from the right edge to the sprite

   219

			break;

   220

		case VEH_AIRCRAFT:

   221

			_block_sizes[VEH_AIRCRAFT][0] = max(74U, max_width);

   222

			break;

   223

	}

   224

	_block_sizes[type][1] = max(GetVehicleListHeight(type), max_height);

   225

}

   226

   227

/* Set the size of the blocks in the window so we can be sure that they are big enough for the vehicle sprites in the current game

   228

 * We will only need to call this once for each game */

   229

void InitDepotWindowBlockSizes()

   230

{

   231

	ResizeDefaultWindowSizeForTrains();

   232

	ResizeDefaultWindowSizeForRoadVehicles();

   233

	ResizeDefaultWindowSize(VEH_SHIP);

   234

	ResizeDefaultWindowSize(VEH_AIRCRAFT);

   235

}

   236

   237

static void DepotSellAllConfirmationCallback(Window *w, bool confirmed);

   238

const Sprite *GetAircraftSprite(EngineID engine);

   239

   240

struct DepotWindow : Window {

   241

	VehicleID sel;

   242

	VehicleType type;

   243

	bool generate_list;

   244

	VehicleList vehicle_list;

   245

	VehicleList wagon_list;

   246

   247

	DepotWindow(const WindowDesc *desc, WindowNumber window_number) : Window(desc, window_number)

   248

	{

   249

		this->sel = INVALID_VEHICLE;

   250

		this->generate_list = true;

   251

   252

		this->FindWindowPlacementAndResize(desc);

   253

	}

   254

   255

	~DepotWindow()

   256

	{

   257

		DeleteWindowById(WC_BUILD_VEHICLE, this->window_number);

   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

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

   267

	{

   268

		byte diff_x = 0, diff_y = 0;

   269

   270

		int sprite_y = y + this->resize.step_height - GetVehicleListHeight(v->type);

   271

   272

		switch (v->type) {

   273

			case VEH_TRAIN:

   274

				DrawTrainImage(v, x + 21, sprite_y, this->sel, this->hscroll.cap + 4, this->hscroll.pos);

   275

   276

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

   277

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

   278

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

   279

				break;

   280

   281

			case VEH_ROAD:     DrawRoadVehImage( v, x + 24, sprite_y, this->sel, 1); break;

   282

			case VEH_SHIP:     DrawShipImage(    v, x + 19, sprite_y - 1, this->sel); break;

   283

			case VEH_AIRCRAFT: {

   284

				const Sprite *spr = GetSprite(v->GetImage(DIR_W), ST_NORMAL);

   285

				DrawAircraftImage(v, x + 12,

   286

									y + max(spr->height + spr->y_offs - 14, 0), // tall sprites needs an y offset

   287

									this->sel);

   288

			} break;

   289

			default: NOT_REACHED();

   290

		}

   291

   292

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

   293

			/* VEH_TRAIN and VEH_ROAD, which are low */

   294

			diff_x = 15;

   295

		} else {

   296

			/* VEH_SHIP and VEH_AIRCRAFT, which are tall */

   297

			diff_y = 12;

   298

		}

   299

   300

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

   301

   302

		SetDParam(0, v->unitnumber);

   303

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

   304

	}

   305

   306

	void DrawDepotWindow(Window *w)

   307

	{

   308

		TileIndex tile = this->window_number;

   309

		int x, y, i, maxval;

   310

		uint16 hnum;

   311

   312

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

   313

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

   314

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

   315

   316

		/* setup disabled buttons */

   317

		this->SetWidgetsDisabledState(!IsTileOwner(tile, _local_company),

   318

			DEPOT_WIDGET_STOP_ALL,

   319

			DEPOT_WIDGET_START_ALL,

   320

			DEPOT_WIDGET_SELL,

   321

			DEPOT_WIDGET_SELL_CHAIN,

   322

			DEPOT_WIDGET_SELL_ALL,

   323

			DEPOT_WIDGET_BUILD,

   324

			DEPOT_WIDGET_CLONE,

   325

			DEPOT_WIDGET_AUTOREPLACE,

   326

			WIDGET_LIST_END);

   327

   328

		/* determine amount of items for scroller */

   329

		if (this->type == VEH_TRAIN) {

   330

			hnum = 8;

   331

			for (uint num = 0; num < this->vehicle_list.Length(); num++) {

   332

				const Vehicle *v = this->vehicle_list[num];

   333

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

   334

			}

   335

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

   336

			SetVScrollCount(w, this->vehicle_list.Length() + this->wagon_list.Length() + 1);

   337

			SetHScrollCount(w, WagonLengthToPixels(hnum));

   338

		} else {

   339

			SetVScrollCount(w, (this->vehicle_list.Length() + this->hscroll.cap - 1) / this->hscroll.cap);

   340

		}

   341

   342

		/* locate the depot struct */

   343

		if (this->type == VEH_AIRCRAFT) {

   344

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

   345

		} else {

   346

			Depot *depot = GetDepotByTile(tile);

   347

			assert(depot != NULL);

   348

   349

			SetDParam(0, depot->town_index);

   350

		}

   351

   352

		w->DrawWidgets();

   353

   354

		uint16 num = this->vscroll.pos * boxes_in_each_row;

   355

		maxval = min(this->vehicle_list.Length(), num + (rows_in_display * boxes_in_each_row));

   356

   357

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

   358

			byte i;

   359

   360

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

   361

				/* Draw all vehicles in the current row */

   362

				const Vehicle *v = this->vehicle_list[num];

   363

				DrawVehicleInDepot(w, v, x, y);

   364

			}

   365

		}

   366

   367

		maxval = min(this->vehicle_list.Length() + this->wagon_list.Length(), (this->vscroll.pos * boxes_in_each_row) + (rows_in_display * boxes_in_each_row));

   368

   369

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

   370

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

   371

			const Vehicle *v = this->wagon_list[num - this->vehicle_list.Length()];

   372

			const Vehicle *u;

   373

   374

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

   375

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

   376

   377

			/*Draw the train counter */

   378

			i = 0;

   379

			u = v;

   380

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

   381

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

   382

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

   383

		}

   384

	}

   385

   386

	struct GetDepotVehiclePtData {

   387

		const Vehicle *head;

   388

		const Vehicle *wagon;

   389

	};

   390

   391

	enum DepotGUIAction {

   392

		MODE_ERROR,

   393

		MODE_DRAG_VEHICLE,

   394

		MODE_SHOW_VEHICLE,

   395

		MODE_START_STOP,

   396

	};

   397

   398

	DepotGUIAction GetVehicleFromDepotWndPt(int x, int y, const Vehicle **veh, GetDepotVehiclePtData *d) const

   399

	{

   400

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

   401

		int pos, skip = 0;

   402

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

   403

   404

		if (this->type == VEH_TRAIN) {

   405

			xt = 0;

   406

			x -= 23;

   407

		} else {

   408

			xt = x / this->resize.step_width;

   409

			xm = x % this->resize.step_width;

   410

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

   411

   412

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

   413

		}

   414

   415

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

   416

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

   417

   418

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

   419

   420

		if ((int)(this->vehicle_list.Length() + this->wagon_list.Length()) <= pos) {

   421

			if (this->type == VEH_TRAIN) {

   422

				d->head  = NULL;

   423

				d->wagon = NULL;

   424

				return MODE_DRAG_VEHICLE;

   425

			} else {

   426

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

   427

			}

   428

		}

   429

   430

		if ((int)this->vehicle_list.Length() > pos) {

   431

			*veh = this->vehicle_list[pos];

   432

			skip = this->hscroll.pos;

   433

		} else {

   434

			pos -= this->vehicle_list.Length();

   435

			*veh = this->wagon_list[pos];

   436

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

   437

			x -= _traininfo_vehicle_width;

   438

		}

   439

   440

		switch (this->type) {

   441

			case VEH_TRAIN: {

   442

				const Vehicle *v = *veh;

   443

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

   444

   445

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

   446

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

   447

   448

				skip = (skip * 8) / _traininfo_vehicle_width;

   449

				x = (x * 8) / _traininfo_vehicle_width;

   450

   451

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

   452

				x += skip;

   453

   454

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

   455

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

   456

   457

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

   458

				while (v != NULL && IsArticulatedPart(v)) v = v->Previous();

   459

   460

				d->wagon = v;

   461

   462

				return MODE_DRAG_VEHICLE;

   463

				}

   464

				break;

   465

   466

			case VEH_ROAD:

   467

				if (xm >= 24) return MODE_DRAG_VEHICLE;

   468

				if (xm <= 16) return MODE_SHOW_VEHICLE;

   469

				break;

   470

   471

			case VEH_SHIP:

   472

				if (xm >= 19) return MODE_DRAG_VEHICLE;

   473

				if (ym <= 10) return MODE_SHOW_VEHICLE;

   474

				break;

   475

   476

			case VEH_AIRCRAFT:

   477

				if (xm >= 12) return MODE_DRAG_VEHICLE;

   478

				if (ym <= 12) return MODE_SHOW_VEHICLE;

   479

				break;

   480

   481

			default: NOT_REACHED();

   482

		}

   483

		return MODE_START_STOP;

   484

	}

   485

   486

	void DepotClick(int x, int y)

   487

	{

   488

		GetDepotVehiclePtData gdvp = { NULL, NULL };

   489

		const Vehicle *v = NULL;

   490

		DepotGUIAction mode = this->GetVehicleFromDepotWndPt(x, y, &v, &gdvp);

   491