124 	DepotWndProc

   109 	NULL

   132 	DepotWndProc

   117 	NULL

   140 	DepotWndProc

   125 	NULL

   148 	DepotWndProc

   133 	NULL

   710 static void CreateDepotListWindow(Window *w, VehicleType type)

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

   242 const Sprite *GetAircraftSprite(EngineID engine);

   243 

   244 struct DepotWindow : Window {

   245 	VehicleID sel;

   246 	VehicleType type;

   247 	bool generate_list;

   248 	uint16 engine_list_length;

   249 	uint16 wagon_list_length;

   250 	uint16 engine_count;

   251 	uint16 wagon_count;

   252 	Vehicle **vehicle_list;

   253 	Vehicle **wagon_list;

   254 

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

   256 	{

   257 		this->sel = INVALID_VEHICLE;

   258 		this->vehicle_list  = NULL;

   259 		this->wagon_list    = NULL;

   260 		this->engine_count  = 0;

   261 		this->wagon_count   = 0;

   262 		this->generate_list = true;

   263 

   264 		this->FindWindowPlacementAndResize(desc);

   265 	}

   266 

   267 	~DepotWindow()

   268 	{

   269 		DeleteWindowById(WC_BUILD_VEHICLE, this->window_number);

   270 		free((void*)this->vehicle_list);

   271 		free((void*)this->wagon_list);

   272 	}

   273 

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

   275 	* @param *w Window to draw in

   276 	* @param *v Vehicle to draw

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

   278 	* @param y Top of the box to draw in

   279 	*/

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

   281 	{

   282 		byte diff_x = 0, diff_y = 0;

   283 

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

   285 

   286 		switch (v->type) {

   287 			case VEH_TRAIN:

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

   289 

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

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

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

   293 				break;

   294 

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

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

   297 			case VEH_AIRCRAFT: {

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

   299 				DrawAircraftImage(v, x + 12,

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

   301 									this->sel);

   302 			} break;

   303 			default: NOT_REACHED();

   304 		}

   305 

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

   307 			/* VEH_TRAIN and VEH_ROAD, which are low */

   308 			diff_x = 15;

   309 		} else {

   310 			/* VEH_SHIP and VEH_AIRCRAFT, which are tall */

   311 			diff_y = 12;

   312 		}

   313 

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

   315 

   316 		SetDParam(0, v->unitnumber);

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

   318 	}

   319 

   320 	void DrawDepotWindow(Window *w)

   321 	{

   322 		Vehicle **vl = this->vehicle_list;

   323 		TileIndex tile = this->window_number;

   324 		int x, y, i, maxval;

   325 		uint16 hnum;

   326 		uint16 num = this->engine_count;

   327 

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

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

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

   331 

   332 		/* setup disabled buttons */

   333 		this->SetWidgetsDisabledState(!IsTileOwner(tile, _local_player),

   334 			DEPOT_WIDGET_STOP_ALL,

   335 			DEPOT_WIDGET_START_ALL,

   336 			DEPOT_WIDGET_SELL,

   337 			DEPOT_WIDGET_SELL_CHAIN,

   338 			DEPOT_WIDGET_SELL_ALL,

   339 			DEPOT_WIDGET_BUILD,

   340 			DEPOT_WIDGET_CLONE,

   341 			DEPOT_WIDGET_AUTOREPLACE,

   342 			WIDGET_LIST_END);

   343 

   344 		/* determine amount of items for scroller */

   345 		if (this->type == VEH_TRAIN) {

   346 			hnum = 8;

   347 			for (num = 0; num < this->engine_count; num++) {

   348 				const Vehicle *v = vl[num];

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

   350 			}

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

   352 			SetVScrollCount(w, this->engine_count + this->wagon_count + 1);

   353 			SetHScrollCount(w, WagonLengthToPixels(hnum));

   354 		} else {

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

   356 		}

   357 

   358 		/* locate the depot struct */

   359 		if (this->type == VEH_AIRCRAFT) {

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

   361 		} else {

   362 			Depot *depot = GetDepotByTile(tile);

   363 			assert(depot != NULL);

   364 

   365 			SetDParam(0, depot->town_index);

   366 		}

   367 

   368 		DrawWindowWidgets(w);

   369 

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

   371 		maxval = min(this->engine_count, num + (rows_in_display * boxes_in_each_row));

   372 

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

   374 			byte i;

   375 

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

   377 				/* Draw all vehicles in the current row */

   378 				const Vehicle *v = vl[num];

   379 				DrawVehicleInDepot(w, v, x, y);

   380 			}

   381 		}

   382 

   383 		maxval = min(this->engine_count + this->wagon_count, (this->vscroll.pos * boxes_in_each_row) + (rows_in_display * boxes_in_each_row));

   384 

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

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

   387 			const Vehicle *v = this->wagon_list[num - this->engine_count];

   388 			const Vehicle *u;

   389 

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

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

   392 

   393 			/*Draw the train counter */

   394 			i = 0;

   395 			u = v;

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

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

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

   399 		}

   400 	}

   401 

   402 	struct GetDepotVehiclePtData {

   403 		Vehicle *head;

   404 		Vehicle *wagon;

   405 	};

   406 

   407 	enum DepotGUIAction {

   408 		MODE_ERROR,

   409 		MODE_DRAG_VEHICLE,

   410 		MODE_SHOW_VEHICLE,

   411 		MODE_START_STOP,

   412 	};

   413 

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

   415 	{

   416 		Vehicle **vl = this->vehicle_list;

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

   418 		int pos, skip = 0;

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

   420 

   421 		if (this->type == VEH_TRAIN) {

   422 			xt = 0;

   423 			x -= 23;

   424 		} else {

   425 			xt = x / this->resize.step_width;

   426 			xm = x % this->resize.step_width;

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

   428 

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

   430 		}

   431 

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

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

   434 

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

   436 

   437 		if (this->engine_count + this->wagon_count <= pos) {

   438 			if (this->type == VEH_TRAIN) {

   439 				d->head  = NULL;

   440 				d->wagon = NULL;

   441 				return MODE_DRAG_VEHICLE;

   442 			} else {

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

   444 			}

   445 		}

   446 

   447 		if (this->engine_count > pos) {

   448 			*veh = vl[pos];

   449 			skip = this->hscroll.pos;

   450 		} else {

   451 			vl = this->wagon_list;

   452 			pos -= this->engine_count;

   453 			*veh = vl[pos];

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

   455 			x -= _traininfo_vehicle_width;

   456 		}

   457 

   458 		switch (this->type) {

   459 			case VEH_TRAIN: {

   460 				Vehicle *v = *veh;

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

   462 

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

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

   465 

   466 				skip = (skip * 8) / _traininfo_vehicle_width;

   467 				x = (x * 8) / _traininfo_vehicle_width;

   468 

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

   470 				x += skip;

   471 

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

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

   474 

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

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

   477 

   478 				d->wagon = v;

   479 

   480 				return MODE_DRAG_VEHICLE;

   481 				}

   482 				break;

   483 

   484 			case VEH_ROAD:

   485 				if (xm >= 24) return MODE_DRAG_VEHICLE;

   486 				if (xm <= 16) return MODE_SHOW_VEHICLE;

   487 				break;

   488 

   489 			case VEH_SHIP:

   490 				if (xm >= 19) return MODE_DRAG_VEHICLE;

   491 				if (ym <= 10) return MODE_SHOW_VEHICLE;

   492 				break;

   493 

   494 			case VEH_AIRCRAFT:

   495 				if (xm >= 12) return MODE_DRAG_VEHICLE;

   496 				if (ym <= 12) return MODE_SHOW_VEHICLE;

   497 				break;

   498 

   499 			default: NOT_REACHED();

   500 		}

   501 		return MODE_START_STOP;

   502 	}

   503 

   504 	void DepotClick(int x, int y)

   505 	{

   506 		GetDepotVehiclePtData gdvp;

   507 		Vehicle *v = NULL;

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

   509 

   510 		/* share / copy orders */

   511 		if (_thd.place_mode != VHM_NONE && mode != MODE_ERROR) {

   512 			_place_clicked_vehicle = (this->type == VEH_TRAIN ? gdvp.head : v);

   513 			return;

   514 		}

   515 

   516 		if (this->type == VEH_TRAIN) v = gdvp.wagon;

   517 

   518 		switch (mode) {

   519 			case MODE_ERROR: // invalid

   520 				return;

   521 

   522 			case MODE_DRAG_VEHICLE: { // start dragging of vehicle

   523 				VehicleID sel = this->sel;

   524 

   525 				if (this->type == VEH_TRAIN && sel != INVALID_VEHICLE) {

   526 					this->sel = INVALID_VEHICLE;

   527 					TrainDepotMoveVehicle(v, sel, gdvp.head);

   528 				} else if (v != NULL) {

   529 					int image = v->GetImage(DIR_W);

   530 

   531 					this->sel = v->index;

   532 					this->SetDirty();

   533 					SetObjectToPlaceWnd(image, GetVehiclePalette(v), VHM_DRAG, this);

   534 					_cursor.vehchain = _ctrl_pressed;

   535 				}

   536 			} break;

   537 

   538 			case MODE_SHOW_VEHICLE: // show info window

   539 				ShowVehicleViewWindow(v);

   540 				break;

   541 

   542 			case MODE_START_STOP: { // click start/stop flag

   543 				uint command;

   544 

   545 				switch (this->type) {

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

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

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

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

   550 					default: NOT_REACHED(); command = 0;

   551 				}

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

   553 			} break;

   554 

   555 			default: NOT_REACHED();

   556 		}

   557 	}

   558 

   559 	/**

   560 	* Clones a vehicle

   561 	* @param *v is the original vehicle to clone

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

   563 	*/

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

   565 	{

   566 		uint error_str;

   567 

   568 		if (v == NULL) return;

   569 

   570 		if (!v->IsPrimaryVehicle()) {

   571 			v = v->First();

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

   573 			if (v->type == VEH_TRAIN && !IsFrontEngine(v)) return;

   574 		}

   575 

   576 		switch (v->type) {

   577 			case VEH_TRAIN:    error_str = CMD_MSG(STR_882B_CAN_T_BUILD_RAILROAD_VEHICLE); break;

   578 			case VEH_ROAD:     error_str = CMD_MSG(STR_9009_CAN_T_BUILD_ROAD_VEHICLE);     break;

   579 			case VEH_SHIP:     error_str = CMD_MSG(STR_980D_CAN_T_BUILD_SHIP);             break;

   580 			case VEH_AIRCRAFT: error_str = CMD_MSG(STR_A008_CAN_T_BUILD_AIRCRAFT);         break;

   581 			default: return;

   582 		}

   583 

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

   585 

   586 		ResetObjectToPlace();

   587 	}

   588 

   589 	void ResizeDepotButtons(Window *w)

   590 	{

   591 		ResizeButtons(w, DEPOT_WIDGET_BUILD, DEPOT_WIDGET_LOCATION);

   592 

   593 		if (this->type == VEH_TRAIN) {

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

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

   596 			this->widget[DEPOT_WIDGET_SELL_CHAIN].top    = ((this->widget[DEPOT_WIDGET_SELL_CHAIN].bottom - this->widget[DEPOT_WIDGET_SELL].top) / 2) + this->widget[DEPOT_WIDGET_SELL].top;

   597 			this->widget[DEPOT_WIDGET_SELL].bottom     = this->widget[DEPOT_WIDGET_SELL_CHAIN].top - 1;

   598 		}

   599 	}

   600 

   601 	/* Function to set up vehicle specific sprites and strings

   602 	 * Only use this if it's the same widget, that's used for more than one vehicle type and it needs different text/sprites

   603 	 * Vehicle specific text/sprites, that's in a widget, that's only shown for one vehicle type (like sell whole train) is set in the widget array

   604 	 */

   605 	void SetupStringsForDepotWindow(VehicleType type)

   606 	{

   607 		switch (type) {

   608 			default: NOT_REACHED();

   609 

   610 			case VEH_TRAIN:

   611 				this->widget[DEPOT_WIDGET_CAPTION].data      = STR_8800_TRAIN_DEPOT;

   612 				this->widget[DEPOT_WIDGET_STOP_ALL].tooltips = STR_MASS_STOP_DEPOT_TRAIN_TIP;

   613 				this->widget[DEPOT_WIDGET_START_ALL].tooltips= STR_MASS_START_DEPOT_TRAIN_TIP;

   614 				this->widget[DEPOT_WIDGET_SELL].tooltips     = STR_8841_DRAG_TRAIN_VEHICLE_TO_HERE;

   615 				this->widget[DEPOT_WIDGET_SELL_ALL].tooltips = STR_DEPOT_SELL_ALL_BUTTON_TRAIN_TIP;

   616 				this->widget[DEPOT_WIDGET_MATRIX].tooltips   = STR_883F_TRAINS_CLICK_ON_TRAIN_FOR;

   617 

   618 				this->widget[DEPOT_WIDGET_BUILD].data        = STR_8815_NEW_VEHICLES;

   619 				this->widget[DEPOT_WIDGET_BUILD].tooltips    = STR_8840_BUILD_NEW_TRAIN_VEHICLE;

   620 				this->widget[DEPOT_WIDGET_CLONE].data        = STR_CLONE_TRAIN;

   621 				this->widget[DEPOT_WIDGET_CLONE].tooltips    = STR_CLONE_TRAIN_DEPOT_INFO;

   622 

   623 				this->widget[DEPOT_WIDGET_LOCATION].tooltips = STR_8842_CENTER_MAIN_VIEW_ON_TRAIN;

   624 				this->widget[DEPOT_WIDGET_VEHICLE_LIST].data = STR_TRAIN;

   625 				this->widget[DEPOT_WIDGET_VEHICLE_LIST].tooltips = STR_DEPOT_VEHICLE_ORDER_LIST_TRAIN_TIP;

   626 				this->widget[DEPOT_WIDGET_AUTOREPLACE].tooltips = STR_DEPOT_AUTOREPLACE_TRAIN_TIP;

   627 

   628 				/* Sprites */

   629 				this->widget[DEPOT_WIDGET_SELL].data        = SPR_SELL_TRAIN;

   630 				this->widget[DEPOT_WIDGET_SELL_ALL].data    = SPR_SELL_ALL_TRAIN;

   631 				this->widget[DEPOT_WIDGET_AUTOREPLACE].data = SPR_REPLACE_TRAIN;

   632 				break;

   633 

   634 			case VEH_ROAD:

   635 				this->widget[DEPOT_WIDGET_CAPTION].data      = STR_9003_ROAD_VEHICLE_DEPOT;

   636 				this->widget[DEPOT_WIDGET_STOP_ALL].tooltips = STR_MASS_STOP_DEPOT_ROADVEH_TIP;

   637 				this->widget[DEPOT_WIDGET_START_ALL].tooltips= STR_MASS_START_DEPOT_ROADVEH_TIP;

   638 				this->widget[DEPOT_WIDGET_SELL].tooltips     = STR_9024_DRAG_ROAD_VEHICLE_TO_HERE;

   639 				this->widget[DEPOT_WIDGET_SELL_ALL].tooltips = STR_DEPOT_SELL_ALL_BUTTON_ROADVEH_TIP;

   640 				this->widget[DEPOT_WIDGET_MATRIX].tooltips   = STR_9022_VEHICLES_CLICK_ON_VEHICLE;

   641 

   642 				this->widget[DEPOT_WIDGET_BUILD].data        = STR_9004_NEW_VEHICLES;

   643 				this->widget[DEPOT_WIDGET_BUILD].tooltips    = STR_9023_BUILD_NEW_ROAD_VEHICLE;

   644 				this->widget[DEPOT_WIDGET_CLONE].data        = STR_CLONE_ROAD_VEHICLE;

   645 				this->widget[DEPOT_WIDGET_CLONE].tooltips    = STR_CLONE_ROAD_VEHICLE_DEPOT_INFO;

   646 

   647 				this->widget[DEPOT_WIDGET_LOCATION].tooltips = STR_9025_CENTER_MAIN_VIEW_ON_ROAD;

   648 				this->widget[DEPOT_WIDGET_VEHICLE_LIST].data = STR_LORRY;

   649 				this->widget[DEPOT_WIDGET_VEHICLE_LIST].tooltips = STR_DEPOT_VEHICLE_ORDER_LIST_ROADVEH_TIP;

   650 				this->widget[DEPOT_WIDGET_AUTOREPLACE].tooltips = STR_DEPOT_AUTOREPLACE_ROADVEH_TIP;

   651 

   652 				/* Sprites */

   653 				this->widget[DEPOT_WIDGET_SELL].data        = SPR_SELL_ROADVEH;

   654 				this->widget[DEPOT_WIDGET_SELL_ALL].data    = SPR_SELL_ALL_ROADVEH;

   655 				this->widget[DEPOT_WIDGET_AUTOREPLACE].data = SPR_REPLACE_ROADVEH;

   656 				break;

   657 

   658 			case VEH_SHIP:

   659 				this->widget[DEPOT_WIDGET_CAPTION].data      = STR_9803_SHIP_DEPOT;

   660 				this->widget[DEPOT_WIDGET_STOP_ALL].tooltips = STR_MASS_STOP_DEPOT_SHIP_TIP;

   661 				this->widget[DEPOT_WIDGET_START_ALL].tooltips= STR_MASS_START_DEPOT_SHIP_TIP;

   662 				this->widget[DEPOT_WIDGET_SELL].tooltips     = STR_9821_DRAG_SHIP_TO_HERE_TO_SELL;

   663 				this->widget[DEPOT_WIDGET_SELL_ALL].tooltips = STR_DEPOT_SELL_ALL_BUTTON_SHIP_TIP;

   664 				this->widget[DEPOT_WIDGET_MATRIX].tooltips   = STR_981F_SHIPS_CLICK_ON_SHIP_FOR;

   665 

   666 				this->widget[DEPOT_WIDGET_BUILD].data        = STR_9804_NEW_SHIPS;

   667 				this->widget[DEPOT_WIDGET_BUILD].tooltips    = STR_9820_BUILD_NEW_SHIP;

   668 				this->widget[DEPOT_WIDGET_CLONE].data        = STR_CLONE_SHIP;

   669 				this->widget[DEPOT_WIDGET_CLONE].tooltips    = STR_CLONE_SHIP_DEPOT_INFO;

   670 

   671 				this->widget[DEPOT_WIDGET_LOCATION].tooltips = STR_9822_CENTER_MAIN_VIEW_ON_SHIP;

   672 				this->widget[DEPOT_WIDGET_VEHICLE_LIST].data = STR_SHIP;

   673 				this->widget[DEPOT_WIDGET_VEHICLE_LIST].tooltips = STR_DEPOT_VEHICLE_ORDER_LIST_SHIP_TIP;

   674 				this->widget[DEPOT_WIDGET_AUTOREPLACE].tooltips = STR_DEPOT_AUTOREPLACE_SHIP_TIP;

   675 

   676 				/* Sprites */

   677 				this->widget[DEPOT_WIDGET_SELL].data        = SPR_SELL_SHIP;

   678 				this->widget[DEPOT_WIDGET_SELL_ALL].data    = SPR_SELL_ALL_SHIP;

   679 				this->widget[DEPOT_WIDGET_AUTOREPLACE].data = SPR_REPLACE_SHIP;

   680 				break;

   681 

   682 			case VEH_AIRCRAFT:

   683 				this->widget[DEPOT_WIDGET_CAPTION].data      = STR_A002_AIRCRAFT_HANGAR;

   684 				this->widget[DEPOT_WIDGET_STOP_ALL].tooltips = STR_MASS_STOP_HANGAR_TIP;

   685 				this->widget[DEPOT_WIDGET_START_ALL].tooltips= STR_MASS_START_HANGAR_TIP;

   686 				this->widget[DEPOT_WIDGET_SELL].tooltips     = STR_A023_DRAG_AIRCRAFT_TO_HERE_TO;

   687 				this->widget[DEPOT_WIDGET_SELL_ALL].tooltips = STR_DEPOT_SELL_ALL_BUTTON_AIRCRAFT_TIP;

   688 				this->widget[DEPOT_WIDGET_MATRIX].tooltips   = STR_A021_AIRCRAFT_CLICK_ON_AIRCRAFT;

   689 

   690 				this->widget[DEPOT_WIDGET_BUILD].data        = STR_A003_NEW_AIRCRAFT;

   691 				this->widget[DEPOT_WIDGET_BUILD].tooltips    = STR_A022_BUILD_NEW_AIRCRAFT;

   692 				this->widget[DEPOT_WIDGET_CLONE].data        = STR_CLONE_AIRCRAFT;

   693 				this->widget[DEPOT_WIDGET_CLONE].tooltips    = STR_CLONE_AIRCRAFT_INFO_HANGAR_WINDOW;

   694 

   695 				this->widget[DEPOT_WIDGET_LOCATION].tooltips = STR_A024_CENTER_MAIN_VIEW_ON_HANGAR;

   696 				this->widget[DEPOT_WIDGET_VEHICLE_LIST].data = STR_PLANE;

   697 				this->widget[DEPOT_WIDGET_VEHICLE_LIST].tooltips = STR_DEPOT_VEHICLE_ORDER_LIST_AIRCRAFT_TIP;

   698 				this->widget[DEPOT_WIDGET_AUTOREPLACE].tooltips = STR_DEPOT_AUTOREPLACE_AIRCRAFT_TIP;

   699 

   700 				/* Sprites */

   701 				this->widget[DEPOT_WIDGET_SELL].data        = SPR_SELL_AIRCRAFT;

   702 				this->widget[DEPOT_WIDGET_SELL_ALL].data    = SPR_SELL_ALL_AIRCRAFT;

   703 				this->widget[DEPOT_WIDGET_AUTOREPLACE].data = SPR_REPLACE_AIRCRAFT;

   704 				break;

   705 		}

   706 	}

   707 

   708 	void CreateDepotListWindow(VehicleType type)

   709 	{

   710 		this->type = type;

   711 		_backup_orders_tile = 0;

   712 

   713 		assert(IsPlayerBuildableVehicleType(type)); // ensure that we make the call with a valid type

   714 

   715 		/* Resize the window according to the vehicle type */

   716 

   717 		/* Set the number of blocks in each direction */

   718 		this->vscroll.cap = _resize_cap[type][0];

   719 		this->hscroll.cap = _resize_cap[type][1];

   720 

   721 		/* Set the block size */

   722 		this->resize.step_width  = _block_sizes[type][0];

   723 		this->resize.step_height = _block_sizes[type][1];

   724 

   725 		/* Enlarge the window to fit with the selected number of blocks of the selected size */

   726 		ResizeWindow(this,

   727 					_block_sizes[type][0] * this->hscroll.cap,

   728 					_block_sizes[type][1] * this->vscroll.cap);

   729 

   730 		if (type == VEH_TRAIN) {

   731 			/* Make space for the horizontal scrollbar vertically, and the unit

   732 			 * number, flag, and length counter horizontally. */

   733 			ResizeWindow(this, 36, 12);

   734 			/* substract the newly added space from the matrix since it was meant for the scrollbar */

   735 			this->widget[DEPOT_WIDGET_MATRIX].bottom -= 12;

   736 		}

   737 

   738 		/* Set the minimum window size to the current window size */

   739 		this->resize.width  = this->width;

   740 		this->resize.height = this->height;

   741 

   742 		this->SetupStringsForDepotWindow(type);

   743 

   744 		this->widget[DEPOT_WIDGET_MATRIX].data =

   745 			(this->vscroll.cap * 0x100) // number of rows to draw on the background

   746 			+ (type == VEH_TRAIN ? 1 : this->hscroll.cap); // number of boxes in each row. Trains always have just one

   747 

   748 

   749 		this->SetWidgetsHiddenState(type != VEH_TRAIN,

   750 			DEPOT_WIDGET_H_SCROLL,

   751 			DEPOT_WIDGET_SELL_CHAIN,

   752 			WIDGET_LIST_END);

   753 

   754 		ResizeDepotButtons(this);

   755 	}

   756 

   757 	virtual void OnInvalidateData(int data)

   758 	{

   759 		this->generate_list = true;

   760 	}

   761 

   762 	virtual void OnPaint()

   763 	{

   764 		if (this->generate_list) {

   765 			/* Generate the vehicle list

   766 			 * It's ok to use the wagon pointers for non-trains as they will be ignored */

   767 			BuildDepotVehicleList(this->type, this->window_number,

   768 				&this->vehicle_list, &this->engine_list_length, &this->engine_count,

   769 				&this->wagon_list,   &this->wagon_list_length,  &this->wagon_count);

   770 			this->generate_list = false;

   771 			DepotSortList(this->vehicle_list, this->engine_count);

   772 		}

   773 		DrawDepotWindow(this);

   774 	}

   775 

   776 	virtual void OnClick(Point pt, int widget)

   777 	{

   778 		switch (widget) {

   779 			case DEPOT_WIDGET_MATRIX: // List

   780 				this->DepotClick(pt.x, pt.y);

   781 				break;

   782 

   783 			case DEPOT_WIDGET_BUILD: // Build vehicle

   784 				ResetObjectToPlace();

   785 				ShowBuildVehicleWindow(this->window_number, this->type);

   786 				break;

   787 

   788 			case DEPOT_WIDGET_CLONE: // Clone button

   789 				this->InvalidateWidget(DEPOT_WIDGET_CLONE);

   790 				this->ToggleWidgetLoweredState(DEPOT_WIDGET_CLONE);

   791 

   792 				if (this->IsWidgetLowered(DEPOT_WIDGET_CLONE)) {

   793 					static const CursorID clone_icons[] = {

   794 						SPR_CURSOR_CLONE_TRAIN, SPR_CURSOR_CLONE_ROADVEH,

   795 						SPR_CURSOR_CLONE_SHIP, SPR_CURSOR_CLONE_AIRPLANE

   796 					};

   797 

   798 					_place_clicked_vehicle = NULL;

   799 					SetObjectToPlaceWnd(clone_icons[this->type], PAL_NONE, VHM_RECT, this);

   800 				} else {

   801 					ResetObjectToPlace();

   802 				}

   803 					break;

   804 

   805 			case DEPOT_WIDGET_LOCATION:

   806 				if (_ctrl_pressed) {

   807 					ShowExtraViewPortWindow(this->window_number);

   808 				} else {

   809 					ScrollMainWindowToTile(this->window_number);

   810 				}

   811 				break;

   812 

   813 			case DEPOT_WIDGET_STOP_ALL:

   814 			case DEPOT_WIDGET_START_ALL:

   815 				DoCommandP(this->window_number, 0, this->type | (widget == DEPOT_WIDGET_START_ALL ? (1 << 5) : 0), NULL, CMD_MASS_START_STOP);

   816 				break;

   817 

   818 			case DEPOT_WIDGET_SELL_ALL:

   819 				/* Only open the confimation window if there are anything to sell */

   820 				if (this->engine_count != 0 || this->wagon_count != 0) {

   821 					static const StringID confirm_captions[] = {

   822 						STR_8800_TRAIN_DEPOT,

   823 						STR_9003_ROAD_VEHICLE_DEPOT,

   824 						STR_9803_SHIP_DEPOT,

   825 						STR_A002_AIRCRAFT_HANGAR

   826 					};

   827 					TileIndex tile = this->window_number;

   828 					byte vehtype = this->type;

   829 

   830 					SetDParam(0, (vehtype == VEH_AIRCRAFT) ? GetStationIndex(tile) : GetDepotByTile(tile)->town_index);

   831 					ShowQuery(

   832 						confirm_captions[vehtype],

   833 						STR_DEPOT_SELL_CONFIRMATION_TEXT,

   834 						this,

   835 						DepotSellAllConfirmationCallback

   836 					);