3 /** @file depot_gui.cpp */

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

   109 	DepotWndProc

   110 	NULL

   117 	DepotWndProc

   118 	NULL

   125 	DepotWndProc

   126 	NULL

   133 	DepotWndProc

   134 	NULL

   660 	FOR_ALL_ENGINEIDS_OF_TYPE(engine, type) {

   206 	const Engine *e;

   207 	FOR_ALL_ENGINES_OF_TYPE(e, type) {

   208 		EngineID eid = e->index;

   665 			case VEH_SHIP:     GetShipSpriteSize(    engine, x, y); break;

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

   666 			case VEH_AIRCRAFT: GetAircraftSpriteSize(engine, x, y); break;

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

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

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

   243 const Sprite *GetAircraftSprite(EngineID engine);

   244 

   245 struct DepotWindow : Window {

   246 	VehicleID sel;

   247 	VehicleType type;

   248 	bool generate_list;

   249 	uint16 engine_list_length;

   250 	uint16 wagon_list_length;

   251 	uint16 engine_count;

   252 	uint16 wagon_count;

   253 	Vehicle **vehicle_list;

   254 	Vehicle **wagon_list;

   255 

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

   257 	{

   258 		this->sel = INVALID_VEHICLE;

   259 		this->vehicle_list  = NULL;

   260 		this->wagon_list    = NULL;

   261 		this->engine_count  = 0;

   262 		this->wagon_count   = 0;

   263 		this->generate_list = true;

   264 

   265 		this->FindWindowPlacementAndResize(desc);

   266 	}

   267 

   268 	~DepotWindow()

   269 	{

   270 		DeleteWindowById(WC_BUILD_VEHICLE, this->window_number);

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

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

   273 	}

   274 

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

   276 	* @param *w Window to draw in

   277 	* @param *v Vehicle to draw

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

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

   280 	*/

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

   282 	{

   283 		byte diff_x = 0, diff_y = 0;

   284 

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

   286 

   287 		switch (v->type) {

   288 			case VEH_TRAIN:

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

   290 

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

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

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

   294 				break;

   295 

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

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

   298 			case VEH_AIRCRAFT: {

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

   300 				DrawAircraftImage(v, x + 12,

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

   302 									this->sel);

   303 			} break;

   304 			default: NOT_REACHED();

   305 		}

   306 

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

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

   309 			diff_x = 15;

   310 		} else {

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

   312 			diff_y = 12;

   313 		}

   314 

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

   316 

   317 		SetDParam(0, v->unitnumber);

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

   319 	}

   320 

   321 	void DrawDepotWindow(Window *w)

   322 	{

   323 		Vehicle **vl = this->vehicle_list;

   324 		TileIndex tile = this->window_number;

   325 		int x, y, i, maxval;

   326 		uint16 hnum;

   327 		uint16 num = this->engine_count;

   328 

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

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

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

   332 

   333 		/* setup disabled buttons */

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

   335 			DEPOT_WIDGET_STOP_ALL,

   336 			DEPOT_WIDGET_START_ALL,

   337 			DEPOT_WIDGET_SELL,

   338 			DEPOT_WIDGET_SELL_CHAIN,

   339 			DEPOT_WIDGET_SELL_ALL,

   340 			DEPOT_WIDGET_BUILD,

   341 			DEPOT_WIDGET_CLONE,

   342 			DEPOT_WIDGET_AUTOREPLACE,

   343 			WIDGET_LIST_END);

   344 

   345 		/* determine amount of items for scroller */

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

   347 			hnum = 8;

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

   349 				const Vehicle *v = vl[num];

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

   351 			}

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

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

   354 			SetHScrollCount(w, WagonLengthToPixels(hnum));

   355 		} else {

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

   357 		}

   358 

   359 		/* locate the depot struct */

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

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

   362 		} else {

   363 			Depot *depot = GetDepotByTile(tile);

   364 			assert(depot != NULL);

   365 

   366 			SetDParam(0, depot->town_index);

   367 		}

   368 

   369 		w->DrawWidgets();

   370 

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

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

   373 

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

   375 			byte i;

   376 

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

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

   379 				const Vehicle *v = vl[num];

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

   381 			}

   382 		}

   383 

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

   385 

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

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

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

   389 			const Vehicle *u;

   390 

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

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

   393 

   394 			/*Draw the train counter */

   395 			i = 0;

   396 			u = v;

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

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

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

   400 		}

   401 	}

   402 

   403 	struct GetDepotVehiclePtData {

   404 		Vehicle *head;

   405 		Vehicle *wagon;

   406 	};

   407 

   408 	enum DepotGUIAction {

   409 		MODE_ERROR,

   410 		MODE_DRAG_VEHICLE,

   411 		MODE_SHOW_VEHICLE,

   412 		MODE_START_STOP,

   413 	};

   414 

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

   416 	{

   417 		Vehicle **vl = this->vehicle_list;

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

   419 		int pos, skip = 0;

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

   421 

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

   423 			xt = 0;

   424 			x -= 23;

   425 		} else {

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

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

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

   429 

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

   431 		}

   432 

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

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

   435 

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

   437 

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

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

   440 				d->head  = NULL;

   441 				d->wagon = NULL;

   442 				return MODE_DRAG_VEHICLE;

   443 			} else {

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

   445 			}

   446 		}

   447 

   448 		if (this->engine_count > pos) {

   449 			*veh = vl[pos];

   450 			skip = this->hscroll.pos;

   451 		} else {

   452 			vl = this->wagon_list;

   453 			pos -= this->engine_count;

   454 			*veh = vl[pos];

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

   456 			x -= _traininfo_vehicle_width;

   457 		}

   458 

   459 		switch (this->type) {

   460 			case VEH_TRAIN: {

   461 				Vehicle *v = *veh;

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

   463 

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

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

   466 

   467 				skip = (skip * 8) / _traininfo_vehicle_width;

   468 				x = (x * 8) / _traininfo_vehicle_width;

   469 

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

   471 				x += skip;

   472 

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

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

   475 

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

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

   478 

   479 				d->wagon = v;

   480 

   481 				return MODE_DRAG_VEHICLE;

   482 				}

   483 				break;

   484 

   485 			case VEH_ROAD:

   486 				if (xm >= 24) return MODE_DRAG_VEHICLE;

   487 				if (xm <= 16) return MODE_SHOW_VEHICLE;

   488 				break;

   489 

   490 			case VEH_SHIP:

   491 				if (xm >= 19) return MODE_DRAG_VEHICLE;

   492 				if (ym <= 10) return MODE_SHOW_VEHICLE;

   493 				break;

   494 

   495 			case VEH_AIRCRAFT:

   496 				if (xm >= 12) return MODE_DRAG_VEHICLE;

   497 				if (ym <= 12) return MODE_SHOW_VEHICLE;

   498 				break;

   499 

   500 			default: NOT_REACHED();

   501 		}

   502 		return MODE_START_STOP;

   503 	}

   504 

   505 	void DepotClick(int x, int y)

   506 	{

   507 		GetDepotVehiclePtData gdvp = { NULL, NULL };

   508 		Vehicle *v = NULL;

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

   510 

   511 		/* share / copy orders */

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

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

   514 			return;

   515 		}

   516 

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

   518 

   519 		switch (mode) {

   520 			case MODE_ERROR: // invalid

   521 				return;

   522 

   523 			case MODE_DRAG_VEHICLE: { // start dragging of vehicle

   524 				VehicleID sel = this->sel;

   525 

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

   527 					this->sel = INVALID_VEHICLE;

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

   529 				} else if (v != NULL) {

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

   531 

   532 					this->sel = v->index;

   533 					this->SetDirty();

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

   535 					_cursor.vehchain = _ctrl_pressed;

   536 				}

   537 			} break;

   538 

   539 			case MODE_SHOW_VEHICLE: // show info window

   540 				ShowVehicleViewWindow(v);

   541 				break;

   542 

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

   544 				uint command;

   545 

   546 				switch (this->type) {

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

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

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

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

   551 					default: NOT_REACHED(); command = 0;

   552 				}

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

   554 			} break;

   555 

   556 			default: NOT_REACHED();

   557 		}

   558 	}

   559 

   560 	/**

   561 	* Clones a vehicle

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

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

   564 	*/

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

   566 	{

   567 		uint error_str;

   568 

   569 		if (v == NULL) return;

   570 

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

   572 			v = v->First();

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

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

   575 		}

   576 

   577 		switch (v->type) {

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

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

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

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

   582 			default: return;

   583 		}

   584 

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

   586 

   587 		ResetObjectToPlace();

   588 	}

   589 

   590 	void ResizeDepotButtons(Window *w)

   591 	{

   592 		ResizeButtons(w, DEPOT_WIDGET_BUILD, DEPOT_WIDGET_LOCATION);

   593 

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

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

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

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

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

   599 		}

   600 	}

   601 

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

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

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

   605 	 */

   606 	void SetupStringsForDepotWindow(VehicleType type)

   607 	{

   608 		switch (type) {

   609 			default: NOT_REACHED();

   610 

   611 			case VEH_TRAIN:

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

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

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

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

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

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

   618 

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

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

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

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

   623 

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

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

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

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

   628 

   629 				/* Sprites */

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

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

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

   633 				break;

   634 

   635 			case VEH_ROAD:

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

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

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

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

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

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

   642 

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

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

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

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

   647 

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

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

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

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

   652 

   653 				/* Sprites */

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

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

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

   657 				break;

   658 

   659 			case VEH_SHIP:

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

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

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

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

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

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

   666 

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

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

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

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

   671 

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

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

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

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

   676 

   677 				/* Sprites */

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

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

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

   681 				break;

   682 

   683 			case VEH_AIRCRAFT:

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

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

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

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

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

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

   690 

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

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

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

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

   695 

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

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

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

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

   700 

   701 				/* Sprites */

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

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

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

   705 				break;

   706 		}

   707 	}

   708 

   709 	void CreateDepotListWindow(VehicleType type)

   710 	{

   711 		this->type = type;

   712 		_backup_orders_tile = 0;

   713 

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

   715 

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

   717 

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

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

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

   721 

   722 		/* Set the block size */

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

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

   725 

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

   727 		ResizeWindow(this,

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

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

   730 

   731 		if (type == VEH_TRAIN) {

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

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

   734 			ResizeWindow(this, 36, 12);

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

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

   737 		}

   738 

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

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

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

   742 

   743 		this->SetupStringsForDepotWindow(type);

   744 

   745 		this->widget[DEPOT_WIDGET_MATRIX].data =

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

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

   748 

   749 

   750 		this->SetWidgetsHiddenState(type != VEH_TRAIN,

   751 			DEPOT_WIDGET_H_SCROLL,

   752 			DEPOT_WIDGET_SELL_CHAIN,

   753 			WIDGET_LIST_END);

   754 

   755 		ResizeDepotButtons(this);

   756 	}

   757 

   758 	virtual void OnInvalidateData(int data)

   759 	{

   760 		this->generate_list = true;

   761 	}

   762 

   763 	virtual void OnPaint()

   764 	{

   765 		if (this->generate_list) {

   766 			/* Generate the vehicle list

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

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

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

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

   771 			this->generate_list = false;

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

   773 		}

   774 		DrawDepotWindow(this);

   775 	}

   776 

   777 	virtual void OnClick(Point pt, int widget)

   778 	{

   779 		switch (widget) {

   780 			case DEPOT_WIDGET_MATRIX: // List

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

   782 				break;

   783 

   784 			case DEPOT_WIDGET_BUILD: // Build vehicle

   785 				ResetObjectToPlace();

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

   787 				break;

   788 

   789 			case DEPOT_WIDGET_CLONE: // Clone button

   790 				this->InvalidateWidget(DEPOT_WIDGET_CLONE);

   791 				this->ToggleWidgetLoweredState(DEPOT_WIDGET_CLONE);

   792 

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

   794 					static const CursorID clone_icons[] = {

   795 						SPR_CURSOR_CLONE_TRAIN, SPR_CURSOR_CLONE_ROADVEH,

   796 						SPR_CURSOR_CLONE_SHIP, SPR_CURSOR_CLONE_AIRPLANE

   797 					};

   798 

   799 					_place_clicked_vehicle = NULL;

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

   801 				} else {

   802 					ResetObjectToPlace();

   803 				}

   804 					break;

   805 

   806 			case DEPOT_WIDGET_LOCATION: