src/vehicle_gui.cpp

   1 /* $Id$ */
   2
   3 /*
   4  * This file is part of OpenTTD.
   5  * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
   6  * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   7  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
   8  */
   9
  10 /** @file vehicle_gui.cpp The base GUI for all vehicles. */
  11
  12 #include "stdafx.h"
  13 #include "debug.h"
  14 #include "company_func.h"
  15 #include "gui.h"
  16 #include "textbuf_gui.h"
  17 #include "command_func.h"
  18 #include "vehicle_gui_base.h"
  19 #include "viewport_func.h"
  20 #include "newgrf_text.h"
  21 #include "newgrf_debug.h"
  22 #include "roadveh.h"
  23 #include "train.h"
  24 #include "aircraft.h"
  25 #include "depot_map.h"
  26 #include "group_gui.h"
  27 #include "strings_func.h"
  28 #include "vehicle_func.h"
  29 #include "autoreplace_gui.h"
  30 #include "string_func.h"
  31 #include "widgets/dropdown_func.h"
  32 #include "timetable.h"
  33 #include "articulated_vehicles.h"
  34 #include "spritecache.h"
  35 #include "core/geometry_func.hpp"
  36 #include "company_base.h"
  37 #include "engine_func.h"
  38 #include "station_base.h"
  39 #include "tilehighlight_func.h"
  40 #include "zoom_func.h"
  41
  42 #include "safeguards.h"
  43
  44
  45 Sorting _sorting;
  46
  47 static GUIVehicleList::SortFunction VehicleNumberSorter;
  48 static GUIVehicleList::SortFunction VehicleNameSorter;
  49 static GUIVehicleList::SortFunction VehicleAgeSorter;
  50 static GUIVehicleList::SortFunction VehicleProfitThisYearSorter;
  51 static GUIVehicleList::SortFunction VehicleProfitLastYearSorter;
  52 static GUIVehicleList::SortFunction VehicleCargoSorter;
  53 static GUIVehicleList::SortFunction VehicleReliabilitySorter;
  54 static GUIVehicleList::SortFunction VehicleMaxSpeedSorter;
  55 static GUIVehicleList::SortFunction VehicleModelSorter;
  56 static GUIVehicleList::SortFunction VehicleValueSorter;
  57 static GUIVehicleList::SortFunction VehicleLengthSorter;
  58 static GUIVehicleList::SortFunction VehicleTimeToLiveSorter;
  59 static GUIVehicleList::SortFunction VehicleTimetableDelaySorter;
  60
  61 GUIVehicleList::SortFunction * const BaseVehicleListWindow::vehicle_sorter_funcs[] = {
  62         &VehicleNumberSorter,
  63         &VehicleNameSorter,
  64         &VehicleAgeSorter,
  65         &VehicleProfitThisYearSorter,
  66         &VehicleProfitLastYearSorter,
  67         &VehicleCargoSorter,
  68         &VehicleReliabilitySorter,
  69         &VehicleMaxSpeedSorter,
  70         &VehicleModelSorter,
  71         &VehicleValueSorter,
  72         &VehicleLengthSorter,
  73         &VehicleTimeToLiveSorter,
  74         &VehicleTimetableDelaySorter,
  75 };
  76
  77 const StringID BaseVehicleListWindow::vehicle_sorter_names[] = {
  78         STR_SORT_BY_NUMBER,
  79         STR_SORT_BY_NAME,
  80         STR_SORT_BY_AGE,
  81         STR_SORT_BY_PROFIT_THIS_YEAR,
  82         STR_SORT_BY_PROFIT_LAST_YEAR,
  83         STR_SORT_BY_TOTAL_CAPACITY_PER_CARGOTYPE,
  84         STR_SORT_BY_RELIABILITY,
  85         STR_SORT_BY_MAX_SPEED,
  86         STR_SORT_BY_MODEL,
  87         STR_SORT_BY_VALUE,
  88         STR_SORT_BY_LENGTH,
  89         STR_SORT_BY_LIFE_TIME,
  90         STR_SORT_BY_TIMETABLE_DELAY,
  91         INVALID_STRING_ID
  92 };
  93
  94 const StringID BaseVehicleListWindow::vehicle_depot_name[] = {
  95         STR_VEHICLE_LIST_SEND_TRAIN_TO_DEPOT,
  96         STR_VEHICLE_LIST_SEND_ROAD_VEHICLE_TO_DEPOT,
  97         STR_VEHICLE_LIST_SEND_SHIP_TO_DEPOT,
  98         STR_VEHICLE_LIST_SEND_AIRCRAFT_TO_HANGAR
  99 };
 100
 101 /**
 102  * Get the number of digits the biggest unit number of a set of vehicles has.
 103  * @param vehicles The list of vehicles.
 104  * @return The number of digits to allocate space for.
 105  */
 106 uint GetUnitNumberDigits(VehicleList &vehicles)
 107 {
 108         uint unitnumber = 0;
 109         for (const Vehicle **v = vehicles.Begin(); v != vehicles.End(); v++) {
 110                 unitnumber = max<uint>(unitnumber, (*v)->unitnumber);
 111         }
 112
 113         if (unitnumber >= 10000) return 5;
 114         if (unitnumber >=  1000) return 4;
 115         if (unitnumber >=   100) return 3;
 116
 117         /*
 118          * When the smallest unit number is less than 10, it is
 119          * quite likely that it will expand to become more than
 120          * 10 quite soon.
 121          */
 122         return 2;
 123 }
 124
 125 void BaseVehicleListWindow::BuildVehicleList()
 126 {
 127         if (!this->vehicles.NeedRebuild()) return;
 128
 129         DEBUG(misc, 3, "Building vehicle list type %d for company %d given index %d", this->vli.type, this->vli.company, this->vli.index);
 130
 131         GenerateVehicleSortList(&this->vehicles, this->vli);
 132
 133         this->unitnumber_digits = GetUnitNumberDigits(this->vehicles);
 134
 135         this->vehicles.RebuildDone();
 136         this->vscroll->SetCount(this->vehicles.Length());
 137 }
 138
 139 /**
 140  * Compute the size for the Action dropdown.
 141  * @param show_autoreplace If true include the autoreplace item.
 142  * @param show_group If true include group-related stuff.
 143  * @return Required size.
 144  */
 145 Dimension BaseVehicleListWindow::GetActionDropdownSize(bool show_autoreplace, bool show_group)
 146 {
 147         Dimension d = {0, 0};
 148
 149         if (show_autoreplace) d = maxdim(d, GetStringBoundingBox(STR_VEHICLE_LIST_REPLACE_VEHICLES));
 150         d = maxdim(d, GetStringBoundingBox(STR_VEHICLE_LIST_SEND_FOR_SERVICING));
 151         d = maxdim(d, GetStringBoundingBox(this->vehicle_depot_name[this->vli.vtype]));
 152
 153         if (show_group) {
 154                 d = maxdim(d, GetStringBoundingBox(STR_GROUP_ADD_SHARED_VEHICLE));
 155                 d = maxdim(d, GetStringBoundingBox(STR_GROUP_REMOVE_ALL_VEHICLES));
 156         }
 157
 158         return d;
 159 }
 160
 161 /**
 162  * Display the Action dropdown window.
 163  * @param show_autoreplace If true include the autoreplace item.
 164  * @param show_group If true include group-related stuff.
 165  * @return Itemlist for dropdown
 166  */
 167 DropDownList *BaseVehicleListWindow::BuildActionDropdownList(bool show_autoreplace, bool show_group)
 168 {
 169         DropDownList *list = new DropDownList();
 170
 171         if (show_autoreplace) *list->Append() = new DropDownListStringItem(STR_VEHICLE_LIST_REPLACE_VEHICLES, ADI_REPLACE, false);
 172         *list->Append() = new DropDownListStringItem(STR_VEHICLE_LIST_SEND_FOR_SERVICING, ADI_SERVICE, false);
 173         *list->Append() = new DropDownListStringItem(this->vehicle_depot_name[this->vli.vtype], ADI_DEPOT, false);
 174
 175         if (show_group) {
 176                 *list->Append() = new DropDownListStringItem(STR_GROUP_ADD_SHARED_VEHICLE, ADI_ADD_SHARED, false);
 177                 *list->Append() = new DropDownListStringItem(STR_GROUP_REMOVE_ALL_VEHICLES, ADI_REMOVE_ALL, false);
 178         }
 179
 180         return list;
 181 }
 182
 183 /* cached values for VehicleNameSorter to spare many GetString() calls */
 184 static const Vehicle *_last_vehicle[2] = { NULL, NULL };
 185
 186 void BaseVehicleListWindow::SortVehicleList()
 187 {
 188         if (this->vehicles.Sort()) return;
 189
 190         /* invalidate cached values for name sorter - vehicle names could change */
 191         _last_vehicle[0] = _last_vehicle[1] = NULL;
 192 }
 193
 194 void DepotSortList(VehicleList *list)
 195 {
 196         if (list->Length() < 2) return;
 197         QSortT(list->Begin(), list->Length(), &VehicleNumberSorter);
 198 }
 199
 200 /** draw the vehicle profit button in the vehicle list window. */
 201 static void DrawVehicleProfitButton(const Vehicle *v, int x, int y)
 202 {
 203         SpriteID spr;
 204
 205         /* draw profit-based coloured icons */
 206         if (v->age <= VEHICLE_PROFIT_MIN_AGE) {
 207                 spr = SPR_PROFIT_NA;
 208         } else if (v->GetDisplayProfitLastYear() < 0) {
 209                 spr = SPR_PROFIT_NEGATIVE;
 210         } else if (v->GetDisplayProfitLastYear() < VEHICLE_PROFIT_THRESHOLD) {
 211                 spr = SPR_PROFIT_SOME;
 212         } else {
 213                 spr = SPR_PROFIT_LOT;
 214         }
 215         DrawSprite(spr, PAL_NONE, x, y);
 216 }
 217
 218 /** Maximum number of refit cycles we try, to prevent infinite loops. And we store only a byte anyway */
 219 static const uint MAX_REFIT_CYCLE = 256;
 220
 221 /**
 222  * Get the best fitting subtype when 'cloning'/'replacing' \a v_from with \a v_for.
 223  * All articulated parts of both vehicles are tested to find a possibly shared subtype.
 224  * For \a v_for only vehicle refittable to \a dest_cargo_type are considered.
 225  * @param v_from the vehicle to match the subtype from
 226  * @param v_for  the vehicle to get the subtype for
 227  * @param dest_cargo_type Destination cargo type.
 228  * @return the best sub type
 229  */
 230 byte GetBestFittingSubType(Vehicle *v_from, Vehicle *v_for, CargoID dest_cargo_type)
 231 {
 232         v_from = v_from->GetFirstEnginePart();
 233         v_for = v_for->GetFirstEnginePart();
 234
 235         /* Create a list of subtypes used by the various parts of v_for */
 236         static SmallVector<StringID, 4> subtypes;
 237         subtypes.Clear();
 238         for (; v_from != NULL; v_from = v_from->HasArticulatedPart() ? v_from->GetNextArticulatedPart() : NULL) {
 239                 const Engine *e_from = v_from->GetEngine();
 240                 if (!e_from->CanCarryCargo() || !HasBit(e_from->info.callback_mask, CBM_VEHICLE_CARGO_SUFFIX)) continue;
 241                 subtypes.Include(GetCargoSubtypeText(v_from));
 242         }
 243
 244         byte ret_refit_cyc = 0;
 245         bool success = false;
 246         if (subtypes.Length() > 0) {
 247                 /* Check whether any articulated part is refittable to 'dest_cargo_type' with a subtype listed in 'subtypes' */
 248                 for (Vehicle *v = v_for; v != NULL; v = v->HasArticulatedPart() ? v->GetNextArticulatedPart() : NULL) {
 249                         const Engine *e = v->GetEngine();
 250                         if (!e->CanCarryCargo() || !HasBit(e->info.callback_mask, CBM_VEHICLE_CARGO_SUFFIX)) continue;
 251                         if (!HasBit(e->info.refit_mask, dest_cargo_type) && v->cargo_type != dest_cargo_type) continue;
 252
 253                         CargoID old_cargo_type = v->cargo_type;
 254                         byte old_cargo_subtype = v->cargo_subtype;
 255
 256                         /* Set the 'destination' cargo */
 257                         v->cargo_type = dest_cargo_type;
 258
 259                         /* Cycle through the refits */
 260                         for (uint refit_cyc = 0; refit_cyc < MAX_REFIT_CYCLE; refit_cyc++) {
 261                                 v->cargo_subtype = refit_cyc;
 262
 263                                 /* Make sure we don't pick up anything cached. */
 264                                 v->First()->InvalidateNewGRFCache();
 265                                 v->InvalidateNewGRFCache();
 266
 267                                 StringID subtype = GetCargoSubtypeText(v);
 268                                 if (subtype == STR_EMPTY) break;
 269
 270                                 if (!subtypes.Contains(subtype)) continue;
 271
 272                                 /* We found something matching. */
 273                                 ret_refit_cyc = refit_cyc;
 274                                 success = true;
 275                                 break;
 276                         }
 277
 278                         /* Reset the vehicle's cargo type */
 279                         v->cargo_type    = old_cargo_type;
 280                         v->cargo_subtype = old_cargo_subtype;
 281
 282                         /* Make sure we don't taint the vehicle. */
 283                         v->First()->InvalidateNewGRFCache();
 284                         v->InvalidateNewGRFCache();
 285
 286                         if (success) break;
 287                 }
 288         }
 289
 290         return ret_refit_cyc;
 291 }
 292
 293 /** Option to refit a vehicle chain */
 294 struct RefitOption {
 295         CargoID cargo;    ///< Cargo to refit to
 296         byte subtype;     ///< Subcargo to use
 297         StringID string;  ///< GRF-local String to display for the cargo
 298
 299         /**
 300          * Inequality operator for #RefitOption.
 301          * @param other Compare to this #RefitOption.
 302          * @return True if both #RefitOption are different.
 303          */
 304         inline bool operator != (const RefitOption &other) const
 305         {
 306                 return other.cargo != this->cargo || other.string != this->string;
 307         }
 308
 309         /**
 310          * Equality operator for #RefitOption.
 311          * @param other Compare to this #RefitOption.
 312          * @return True if both #RefitOption are equal.
 313          */
 314         inline bool operator == (const RefitOption &other) const
 315         {
 316                 return other.cargo == this->cargo && other.string == this->string;
 317         }
 318 };
 319
 320 typedef SmallVector<RefitOption, 32> SubtypeList; ///< List of refit subtypes associated to a cargo.
 321
 322 /**
 323  * Draw the list of available refit options for a consist and highlight the selected refit option (if any).
 324  * @param list  List of subtype options for each (sorted) cargo.
 325  * @param sel   Selected refit cargo-type in the window
 326  * @param pos   Position of the selected item in caller widow
 327  * @param rows  Number of rows(capacity) in caller window
 328  * @param delta Step height in caller window
 329  * @param r     Rectangle of the matrix widget.
 330  */
 331 static void DrawVehicleRefitWindow(const SubtypeList list[NUM_CARGO], const int sel[2], uint pos, uint rows, uint delta, const Rect &r)
 332 {
 333         uint y = r.top + WD_MATRIX_TOP;
 334         uint current = 0;
 335
 336         bool rtl = _current_text_dir == TD_RTL;
 337         uint iconwidth = max(GetSpriteSize(SPR_CIRCLE_FOLDED).width, GetSpriteSize(SPR_CIRCLE_UNFOLDED).width);
 338         uint iconheight = GetSpriteSize(SPR_CIRCLE_FOLDED).height;
 339         int linecolour = _colour_gradient[COLOUR_ORANGE][4];
 340
 341         int iconleft   = rtl ? r.right - WD_MATRIX_RIGHT - iconwidth     : r.left + WD_MATRIX_LEFT;
 342         int iconcenter = rtl ? r.right - WD_MATRIX_RIGHT - iconwidth / 2 : r.left + WD_MATRIX_LEFT + iconwidth / 2;
 343         int iconinner  = rtl ? r.right - WD_MATRIX_RIGHT - iconwidth     : r.left + WD_MATRIX_LEFT + iconwidth;
 344
 345         int textleft   = r.left  + WD_MATRIX_LEFT  + (rtl ? 0 : iconwidth + 4);
 346         int textright  = r.right - WD_MATRIX_RIGHT - (rtl ? iconwidth + 4 : 0);
 347
 348         /* Draw the list of subtypes for each cargo, and find the selected refit option (by its position). */
 349         for (uint i = 0; current < pos + rows && i < NUM_CARGO; i++) {
 350                 for (uint j = 0; current < pos + rows && j < list[i].Length(); j++) {
 351                         const RefitOption &refit = list[i][j];
 352
 353                         /* Hide subtypes if sel[0] does not match */
 354                         if (sel[0] != (int)i && refit.subtype != 0xFF) continue;
 355
 356                         /* Refit options with a position smaller than pos don't have to be drawn. */
 357                         if (current < pos) {
 358                                 current++;
 359                                 continue;
 360                         }
 361
 362                         if (list[i].Length() > 1) {
 363                                 if (refit.subtype != 0xFF) {
 364                                         /* Draw tree lines */
 365                                         int ycenter = y + FONT_HEIGHT_NORMAL / 2;
 366                                         GfxDrawLine(iconcenter, y - WD_MATRIX_TOP, iconcenter, j == list[i].Length() - 1 ? ycenter : y - WD_MATRIX_TOP + delta - 1, linecolour);
 367                                         GfxDrawLine(iconcenter, ycenter, iconinner, ycenter, linecolour);
 368                                 } else {
 369                                         /* Draw expand/collapse icon */
 370                                         DrawSprite(sel[0] == (int)i ? SPR_CIRCLE_UNFOLDED : SPR_CIRCLE_FOLDED, PAL_NONE, iconleft, y + (FONT_HEIGHT_NORMAL - iconheight) / 2);
 371                                 }
 372                         }
 373
 374                         TextColour colour = (sel[0] == (int)i && (uint)sel[1] == j) ? TC_WHITE : TC_BLACK;
 375                         /* Get the cargo name. */
 376                         SetDParam(0, CargoSpec::Get(refit.cargo)->name);
 377                         SetDParam(1, refit.string);
 378                         DrawString(textleft, textright, y, STR_JUST_STRING_STRING, colour);
 379
 380                         y += delta;
 381                         current++;
 382                 }
 383         }
 384 }
 385
 386 /** Refit cargo window. */
 387 struct RefitWindow : public Window {
 388         int sel[2];                  ///< Index in refit options, sel[0] == -1 if nothing is selected.
 389         RefitOption *cargo;          ///< Refit option selected by #sel.
 390         SubtypeList list[NUM_CARGO]; ///< List of refit subtypes available for each sorted cargo.
 391         VehicleOrderID order;        ///< If not #INVALID_VEH_ORDER_ID, selection is part of a refit order (rather than execute directly).
 392         uint information_width;      ///< Width required for correctly displaying all cargoes in the information panel.
 393         Scrollbar *vscroll;          ///< The main scrollbar.
 394         Scrollbar *hscroll;          ///< Only used for long vehicles.
 395         int vehicle_width;           ///< Width of the vehicle being drawn.
 396         int sprite_left;             ///< Left position of the vehicle sprite.
 397         int sprite_right;            ///< Right position of the vehicle sprite.
 398         uint vehicle_margin;         ///< Margin to use while selecting vehicles when the vehicle image is centered.
 399         int click_x;                 ///< Position of the first click while dragging.
 400         VehicleID selected_vehicle;  ///< First vehicle in the current selection.
 401         uint8 num_vehicles;          ///< Number of selected vehicles.
 402         bool auto_refit;             ///< Select cargo for auto-refitting.
 403
 404         /**
 405          * Collects all (cargo, subcargo) refit options of a vehicle chain.
 406          */
 407         void BuildRefitList()
 408         {
 409                 for (uint i = 0; i < NUM_CARGO; i++) this->list[i].Clear();
 410                 Vehicle *v = Vehicle::Get(this->window_number);
 411
 412                 /* Check only the selected vehicles. */
 413                 VehicleSet vehicles_to_refit;
 414                 GetVehicleSet(vehicles_to_refit, Vehicle::Get(this->selected_vehicle), this->num_vehicles);
 415
 416                 do {
 417                         if (v->type == VEH_TRAIN && !vehicles_to_refit.Contains(v->index)) continue;
 418                         const Engine *e = v->GetEngine();
 419                         uint32 cmask = e->info.refit_mask;
 420                         byte callback_mask = e->info.callback_mask;
 421
 422                         /* Skip this engine if it does not carry anything */
 423                         if (!e->CanCarryCargo()) continue;
 424                         /* Skip this engine if we build the list for auto-refitting and engine doesn't allow it. */
 425                         if (this->auto_refit && !HasBit(e->info.misc_flags, EF_AUTO_REFIT)) continue;
 426
 427                         /* Loop through all cargoes in the refit mask */
 428                         int current_index = 0;
 429                         const CargoSpec *cs;
 430                         FOR_ALL_SORTED_CARGOSPECS(cs) {
 431                                 CargoID cid = cs->Index();
 432                                 /* Skip cargo type if it's not listed */
 433                                 if (!HasBit(cmask, cid)) {
 434                                         current_index++;
 435                                         continue;
 436                                 }
 437
 438                                 bool first_vehicle = this->list[current_index].Length() == 0;
 439                                 if (first_vehicle) {
 440                                         /* Keeping the current subtype is always an option. It also serves as the option in case of no subtypes */
 441                                         RefitOption *option = this->list[current_index].Append();
 442                                         option->cargo   = cid;
 443                                         option->subtype = 0xFF;
 444                                         option->string  = STR_EMPTY;
 445                                 }
 446
 447                                 /* Check the vehicle's callback mask for cargo suffixes.
 448                                  * This is not supported for ordered refits, since subtypes only have a meaning
 449                                  * for a specific vehicle at a specific point in time, which conflicts with shared orders,
 450                                  * autoreplace, autorenew, clone, order restoration, ... */
 451                                 if (this->order == INVALID_VEH_ORDER_ID && HasBit(callback_mask, CBM_VEHICLE_CARGO_SUFFIX)) {
 452                                         /* Make a note of the original cargo type. It has to be
 453                                          * changed to test the cargo & subtype... */
 454                                         CargoID temp_cargo = v->cargo_type;
 455                                         byte temp_subtype  = v->cargo_subtype;
 456
 457                                         v->cargo_type = cid;
 458
 459                                         for (uint refit_cyc = 0; refit_cyc < MAX_REFIT_CYCLE; refit_cyc++) {
 460                                                 v->cargo_subtype = refit_cyc;
 461
 462                                                 /* Make sure we don't pick up anything cached. */
 463                                                 v->First()->InvalidateNewGRFCache();
 464                                                 v->InvalidateNewGRFCache();
 465
 466                                                 StringID subtype = GetCargoSubtypeText(v);
 467
 468                                                 if (first_vehicle) {
 469                                                         /* Append new subtype (don't add duplicates though) */
 470                                                         if (subtype == STR_EMPTY) break;
 471
 472                                                         RefitOption option;
 473                                                         option.cargo   = cid;
 474                                                         option.subtype = refit_cyc;
 475                                                         option.string  = subtype;
 476                                                         this->list[current_index].Include(option);
 477                                                 } else {
 478                                                         /* Intersect the subtypes of earlier vehicles with the subtypes of this vehicle */
 479                                                         if (subtype == STR_EMPTY) {
 480                                                                 /* No more subtypes for this vehicle, delete all subtypes >= refit_cyc */
 481                                                                 SubtypeList &l = this->list[current_index];
 482                                                                 /* 0xFF item is in front, other subtypes are sorted. So just truncate the list in the right spot */
 483                                                                 for (uint i = 1; i < l.Length(); i++) {
 484                                                                         if (l[i].subtype >= refit_cyc) {
 485                                                                                 l.Resize(i);
 486                                                                                 break;
 487                                                                         }
 488                                                                 }
 489                                                                 break;
 490                                                         } else {
 491                                                                 /* Check whether the subtype matches with the subtype of earlier vehicles. */
 492                                                                 uint pos = 1;
 493                                                                 SubtypeList &l = this->list[current_index];
 494                                                                 while (pos < l.Length() && l[pos].subtype != refit_cyc) pos++;
 495                                                                 if (pos < l.Length() && l[pos].string != subtype) {
 496                                                                         /* String mismatch, remove item keeping the order */
 497                                                                         l.ErasePreservingOrder(pos);
 498                                                                 }
 499                                                         }
 500                                                 }
 501                                         }
 502
 503                                         /* Reset the vehicle's cargo type */
 504                                         v->cargo_type    = temp_cargo;
 505                                         v->cargo_subtype = temp_subtype;
 506
 507                                         /* And make sure we haven't tainted the cache */
 508                                         v->First()->InvalidateNewGRFCache();
 509                                         v->InvalidateNewGRFCache();
 510                                 }
 511                                 current_index++;
 512                         }
 513                 } while (v->IsGroundVehicle() && (v = v->Next()) != NULL);
 514         }
 515
 516         /**
 517          * Refresh scrollbar after selection changed
 518          */
 519         void RefreshScrollbar()
 520         {
 521                 uint scroll_row = 0;
 522                 uint row = 0;
 523
 524                 for (uint i = 0; i < NUM_CARGO; i++) {
 525                         for (uint j = 0; j < this->list[i].Length(); j++) {
 526                                 const RefitOption &refit = this->list[i][j];
 527
 528                                 /* Hide subtypes if sel[0] does not match */
 529                                 if (this->sel[0] != (int)i && refit.subtype != 0xFF) continue;
 530
 531                                 if (this->sel[0] == (int)i && (uint)this->sel[1] == j) scroll_row = row;
 532
 533                                 row++;
 534                         }
 535                 }
 536
 537                 this->vscroll->SetCount(row);
 538                 if (scroll_row < row) this->vscroll->ScrollTowards(scroll_row);
 539         }
 540
 541         /**
 542          * Select a row.
 543          * @param click_row Clicked row
 544          */
 545         void SetSelection(uint click_row)
 546         {
 547                 uint row = 0;
 548
 549                 for (uint i = 0; i < NUM_CARGO; i++) {
 550                         for (uint j = 0; j < this->list[i].Length(); j++) {
 551                                 const RefitOption &refit = this->list[i][j];
 552
 553                                 /* Hide subtypes if sel[0] does not match */
 554                                 if (this->sel[0] != (int)i && refit.subtype != 0xFF) continue;
 555
 556                                 if (row == click_row) {
 557                                         this->sel[0] = i;
 558                                         this->sel[1] = j;
 559                                         return;
 560                                 }
 561
 562                                 row++;
 563                         }
 564                 }
 565
 566                 this->sel[0] = -1;
 567                 this->sel[1] = 0;
 568         }
 569
 570         /**
 571          * Gets the #RefitOption placed in the selected index.
 572          * @return Pointer to the #RefitOption currently in use.
 573          */
 574         RefitOption *GetRefitOption()
 575         {
 576                 if (this->sel[0] < 0) return NULL;
 577
 578                 SubtypeList &l = this->list[this->sel[0]];
 579                 if ((uint)this->sel[1] >= l.Length()) return NULL;
 580
 581                 return &l[this->sel[1]];
 582         }
 583
 584         RefitWindow(WindowDesc *desc, const Vehicle *v, VehicleOrderID order, bool auto_refit) : Window(desc)
 585         {
 586                 this->sel[0] = -1;
 587                 this->sel[1] = 0;
 588                 this->auto_refit = auto_refit;
 589                 this->order = order;
 590                 this->CreateNestedTree();
 591
 592                 this->vscroll = this->GetScrollbar(WID_VR_SCROLLBAR);
 593                 this->hscroll = (v->IsGroundVehicle() ? this->GetScrollbar(WID_VR_HSCROLLBAR) : NULL);
 594                 this->GetWidget<NWidgetCore>(WID_VR_SELECT_HEADER)->tool_tip = STR_REFIT_TRAIN_LIST_TOOLTIP + v->type;
 595                 this->GetWidget<NWidgetCore>(WID_VR_MATRIX)->tool_tip        = STR_REFIT_TRAIN_LIST_TOOLTIP + v->type;
 596                 NWidgetCore *nwi = this->GetWidget<NWidgetCore>(WID_VR_REFIT);
 597                 nwi->widget_data = STR_REFIT_TRAIN_REFIT_BUTTON + v->type;
 598                 nwi->tool_tip    = STR_REFIT_TRAIN_REFIT_TOOLTIP + v->type;
 599                 this->GetWidget<NWidgetStacked>(WID_VR_SHOW_HSCROLLBAR)->SetDisplayedPlane(v->IsGroundVehicle() ? 0 : SZSP_HORIZONTAL);
 600                 this->GetWidget<NWidgetCore>(WID_VR_VEHICLE_PANEL_DISPLAY)->tool_tip = (v->type == VEH_TRAIN) ? STR_REFIT_SELECT_VEHICLES_TOOLTIP : STR_NULL;
 601
 602                 this->FinishInitNested(v->index);
 603                 this->owner = v->owner;
 604
 605                 this->SetWidgetDisabledState(WID_VR_REFIT, this->sel[0] < 0);
 606         }
 607
 608         virtual void OnInit()
 609         {
 610                 if (this->cargo != NULL) {
 611                         /* Store the RefitOption currently in use. */
 612                         RefitOption current_refit_option = *(this->cargo);
 613
 614                         /* Rebuild the refit list */
 615                         this->BuildRefitList();
 616                         this->sel[0] = -1;
 617                         this->sel[1] = 0;
 618                         this->cargo = NULL;
 619                         for (uint i = 0; this->cargo == NULL && i < NUM_CARGO; i++) {
 620                                 for (uint j = 0; j < list[i].Length(); j++) {
 621                                         if (list[i][j] == current_refit_option) {
 622                                                 this->sel[0] = i;
 623                                                 this->sel[1] = j;
 624                                                 this->cargo = &list[i][j];
 625                                                 break;
 626                                         }
 627                                 }
 628                         }
 629
 630                         this->SetWidgetDisabledState(WID_VR_REFIT, this->sel[0] < 0);
 631                         this->RefreshScrollbar();
 632                 } else {
 633                         /* Rebuild the refit list */
 634                         this->OnInvalidateData(VIWD_CONSIST_CHANGED);
 635                 }
 636         }
 637
 638         virtual void OnPaint()
 639         {
 640                 /* Determine amount of items for scroller. */
 641                 if (this->hscroll != NULL) this->hscroll->SetCount(this->vehicle_width);
 642
 643                 /* Calculate sprite position. */
 644                 NWidgetCore *vehicle_panel_display = this->GetWidget<NWidgetCore>(WID_VR_VEHICLE_PANEL_DISPLAY);
 645                 int sprite_width = max(0, ((int)vehicle_panel_display->current_x - this->vehicle_width) / 2);
 646                 this->sprite_left = vehicle_panel_display->pos_x;
 647                 this->sprite_right = vehicle_panel_display->pos_x + vehicle_panel_display->current_x - 1;
 648                 if (_current_text_dir == TD_RTL) {
 649                         this->sprite_right -= sprite_width;
 650                         this->vehicle_margin = vehicle_panel_display->current_x - sprite_right;
 651                 } else {
 652                         this->sprite_left += sprite_width;
 653                         this->vehicle_margin = sprite_left;
 654                 }
 655
 656                 this->DrawWidgets();
 657         }
 658
 659         virtual void UpdateWidgetSize(int widget, Dimension *size, const Dimension &padding, Dimension *fill, Dimension *resize)
 660         {
 661                 switch (widget) {
 662                         case WID_VR_MATRIX:
 663                                 resize->height = WD_MATRIX_TOP + FONT_HEIGHT_NORMAL + WD_MATRIX_BOTTOM;
 664                                 size->height = resize->height * 8;
 665                                 break;
 666
 667                         case WID_VR_VEHICLE_PANEL_DISPLAY:
 668                                 size->height = ScaleGUITrad(GetVehicleHeight(Vehicle::Get(this->window_number)->type));
 669                                 break;
 670
 671                         case WID_VR_INFO:
 672                                 size->width = WD_FRAMERECT_LEFT + this->information_width + WD_FRAMERECT_RIGHT;
 673                                 break;
 674                 }
 675         }
 676
 677         virtual void SetStringParameters(int widget) const
 678         {
 679                 if (widget == WID_VR_CAPTION) SetDParam(0, Vehicle::Get(this->window_number)->index);
 680         }
 681
 682         /**
 683          * Gets the #StringID to use for displaying capacity.
 684          * @param Cargo and cargo subtype to check for capacity.
 685          * @return INVALID_STRING_ID if there is no capacity. StringID to use in any other case.
 686          * @post String parameters have been set.
 687          */
 688         StringID GetCapacityString(RefitOption *option) const
 689         {
 690                 assert(_current_company == _local_company);
 691                 Vehicle *v = Vehicle::Get(this->window_number);
 692                 CommandCost cost = DoCommand(v->tile, this->selected_vehicle, option->cargo | (int)this->auto_refit << 6 | option->subtype << 8 |
 693                                 this->num_vehicles << 16, DC_QUERY_COST, GetCmdRefitVeh(v->type));
 694
 695                 if (cost.Failed()) return INVALID_STRING_ID;
 696
 697                 SetDParam(0, option->cargo);
 698                 SetDParam(1, _returned_refit_capacity);
 699
 700                 Money money = cost.GetCost();
 701                 if (_returned_mail_refit_capacity > 0) {
 702                         SetDParam(2, CT_MAIL);
 703                         SetDParam(3, _returned_mail_refit_capacity);
 704                         if (this->order != INVALID_VEH_ORDER_ID) {
 705                                 /* No predictable cost */
 706                                 return STR_PURCHASE_INFO_AIRCRAFT_CAPACITY;
 707                         } else if (money <= 0) {
 708                                 SetDParam(4, -money);
 709                                 return STR_REFIT_NEW_CAPACITY_INCOME_FROM_AIRCRAFT_REFIT;
 710                         } else {
 711                                 SetDParam(4, money);
 712                                 return STR_REFIT_NEW_CAPACITY_COST_OF_AIRCRAFT_REFIT;
 713                         }
 714                 } else {
 715                         if (this->order != INVALID_VEH_ORDER_ID) {
 716                                 /* No predictable cost */
 717                                 SetDParam(2, STR_EMPTY);
 718                                 return STR_PURCHASE_INFO_CAPACITY;
 719                         } else if (money <= 0) {
 720                                 SetDParam(2, -money);
 721                                 return STR_REFIT_NEW_CAPACITY_INCOME_FROM_REFIT;
 722                         } else {
 723                                 SetDParam(2, money);
 724                                 return STR_REFIT_NEW_CAPACITY_COST_OF_REFIT;
 725                         }
 726                 }
 727         }
 728
 729         virtual void DrawWidget(const Rect &r, int widget) const
 730         {
 731                 switch (widget) {
 732                         case WID_VR_VEHICLE_PANEL_DISPLAY: {
 733                                 Vehicle *v = Vehicle::Get(this->window_number);
 734                                 DrawVehicleImage(v, this->sprite_left + WD_FRAMERECT_LEFT, this->sprite_right - WD_FRAMERECT_RIGHT,
 735                                         r.top + WD_FRAMERECT_TOP, INVALID_VEHICLE, EIT_IN_DETAILS, this->hscroll != NULL ? this->hscroll->GetPosition() : 0);
 736
 737                                 /* Highlight selected vehicles. */
 738                                 if (this->order != INVALID_VEH_ORDER_ID) break;
 739                                 int x = 0;
 740                                 switch (v->type) {
 741                                         case VEH_TRAIN: {
 742                                                 VehicleSet vehicles_to_refit;
 743                                                 GetVehicleSet(vehicles_to_refit, Vehicle::Get(this->selected_vehicle), this->num_vehicles);
 744
 745                                                 int left = INT32_MIN;
 746                                                 int width = 0;
 747
 748                                                 for (Train *u = Train::From(v); u != NULL; u = u->Next()) {
 749                                                         /* Start checking. */
 750                                                         if (vehicles_to_refit.Contains(u->index) && left == INT32_MIN) {
 751                                                                 left = x - this->hscroll->GetPosition() + r.left + this->vehicle_margin;
 752                                                                 width = 0;
 753                                                         }
 754
 755                                                         /* Draw a selection. */
 756                                                         if ((!vehicles_to_refit.Contains(u->index) || u->Next() == NULL) && left != INT32_MIN) {
 757                                                                 if (u->Next() == NULL && vehicles_to_refit.Contains(u->index)) {
 758                                                                         int current_width = u->GetDisplayImageWidth();
 759                                                                         width += current_width;
 760                                                                         x += current_width;
 761                                                                 }
 762
 763                                                                 int right = Clamp(left + width, 0, r.right);
 764                                                                 left = max(0, left);
 765
 766                                                                 if (_current_text_dir == TD_RTL) {
 767                                                                         right = this->GetWidget<NWidgetCore>(WID_VR_VEHICLE_PANEL_DISPLAY)->current_x - left;
 768                                                                         left = right - width;
 769                                                                 }
 770
 771                                                                 if (left != right) {
 772                                                                         DrawFrameRect(left, r.top + WD_FRAMERECT_TOP, right, r.top + WD_FRAMERECT_TOP + ScaleGUITrad(14) - 1, COLOUR_WHITE, FR_BORDERONLY);
 773                                                                 }
 774
 775                                                                 left = INT32_MIN;
 776                                                         }
 777
 778                                                         int current_width = u->GetDisplayImageWidth();
 779                                                         width += current_width;
 780                                                         x += current_width;
 781                                                 }
 782                                                 break;
 783                                         }
 784
 785                                         default: break;
 786                                 }
 787                                 break;
 788                         }
 789
 790                         case WID_VR_MATRIX:
 791                                 DrawVehicleRefitWindow(this->list, this->sel, this->vscroll->GetPosition(), this->vscroll->GetCapacity(), this->resize.step_height, r);
 792                                 break;
 793
 794                         case WID_VR_INFO:
 795                                 if (this->cargo != NULL) {
 796                                         StringID string = this->GetCapacityString(this->cargo);
 797                                         if (string != INVALID_STRING_ID) {
 798                                                 DrawStringMultiLine(r.left + WD_FRAMERECT_LEFT, r.right - WD_FRAMERECT_RIGHT,
 799                                                                 r.top + WD_FRAMERECT_TOP, r.bottom - WD_FRAMERECT_BOTTOM, string);
 800                                         }
 801                                 }
 802                                 break;
 803                 }
 804         }
 805
 806         /**
 807          * Some data on this window has become invalid.
 808          * @param data Information about the changed data.
 809          * @param gui_scope Whether the call is done from GUI scope. You may not do everything when not in GUI scope. See #InvalidateWindowData() for details.
 810          */
 811         virtual void OnInvalidateData(int data = 0, bool gui_scope = true)
 812         {
 813                 switch (data) {
 814                         case VIWD_AUTOREPLACE: // Autoreplace replaced the vehicle; selected_vehicle became invalid.
 815                         case VIWD_CONSIST_CHANGED: { // The consist has changed; rebuild the entire list.
 816                                 /* Clear the selection. */
 817                                 Vehicle *v = Vehicle::Get(this->window_number);
 818                                 this->selected_vehicle = v->index;
 819                                 this->num_vehicles = UINT8_MAX;
 820                         }
 821                         FALLTHROUGH;
 822
 823                         case 2: { // The vehicle selection has changed; rebuild the entire list.
 824                                 if (!gui_scope) break;
 825                                 this->BuildRefitList();
 826
 827                                 /* The vehicle width has changed too. */
 828                                 this->vehicle_width = GetVehicleWidth(Vehicle::Get(this->window_number), EIT_IN_DETAILS);
 829                                 uint max_width = 0;
 830
 831                                 /* Check the width of all cargo information strings. */
 832                                 for (uint i = 0; i < NUM_CARGO; i++) {
 833                                         for (uint j = 0; j < this->list[i].Length(); j++) {
 834                                                 StringID string = this->GetCapacityString(&list[i][j]);
 835                                                 if (string != INVALID_STRING_ID) {
 836                                                         Dimension dim = GetStringBoundingBox(string);
 837                                                         max_width = max(dim.width, max_width);
 838                                                 }
 839                                         }
 840                                 }
 841
 842                                 if (this->information_width < max_width) {
 843                                         this->information_width = max_width;
 844                                         this->ReInit();
 845                                 }
 846                         }
 847                         FALLTHROUGH;
 848
 849                         case 1: // A new cargo has been selected.
 850                                 if (!gui_scope) break;
 851                                 this->cargo = GetRefitOption();
 852                                 this->RefreshScrollbar();
 853                                 break;
 854                 }
 855         }
 856
 857         int GetClickPosition(int click_x)
 858         {
 859                 const NWidgetCore *matrix_widget = this->GetWidget<NWidgetCore>(WID_VR_VEHICLE_PANEL_DISPLAY);
 860                 if (_current_text_dir == TD_RTL) click_x = matrix_widget->current_x - click_x;
 861                 click_x -= this->vehicle_margin;
 862                 if (this->hscroll != NULL) click_x += this->hscroll->GetPosition();
 863
 864                 return click_x;
 865         }
 866
 867         void SetSelectedVehicles(int drag_x)
 868         {
 869                 drag_x = GetClickPosition(drag_x);
 870
 871                 int left_x  = min(this->click_x, drag_x);
 872                 int right_x = max(this->click_x, drag_x);
 873                 this->num_vehicles = 0;
 874
 875                 Vehicle *v = Vehicle::Get(this->window_number);
 876                 /* Find the vehicle part that was clicked. */
 877                 switch (v->type) {
 878                         case VEH_TRAIN: {
 879                                 /* Don't select anything if we are not clicking in the vehicle. */
 880                                 if (left_x >= 0) {
 881                                         const Train *u = Train::From(v);
 882                                         bool start_counting = false;
 883                                         for (; u != NULL; u = u->Next()) {
 884                                                 int current_width = u->GetDisplayImageWidth();
 885                                                 left_x  -= current_width;
 886                                                 right_x -= current_width;
 887
 888                                                 if (left_x < 0 && !start_counting) {
 889                                                         this->selected_vehicle = u->index;
 890                                                         start_counting = true;
 891
 892                                                         /* Count the first vehicle, even if articulated part */
 893                                                         this->num_vehicles++;
 894                                                 } else if (start_counting && !u->IsArticulatedPart()) {
 895                                                         /* Do not count articulated parts */
 896                                                         this->num_vehicles++;
 897                                                 }
 898
 899                                                 if (right_x < 0) break;
 900                                         }
 901                                 }
 902
 903                                 /* If the selection is not correct, clear it. */
 904                                 if (this->num_vehicles != 0) {
 905                                         if (_ctrl_pressed) this->num_vehicles = UINT8_MAX;
 906                                         break;
 907                                 }
 908                         }
 909                         FALLTHROUGH;
 910
 911                         default:
 912                                 /* Clear the selection. */
 913                                 this->selected_vehicle = v->index;
 914                                 this->num_vehicles = UINT8_MAX;
 915                                 break;
 916                 }
 917         }
 918
 919         virtual void OnClick(Point pt, int widget, int click_count)
 920         {
 921                 switch (widget) {
 922                         case WID_VR_VEHICLE_PANEL_DISPLAY: { // Vehicle image.
 923                                 if (this->order != INVALID_VEH_ORDER_ID) break;
 924                                 NWidgetBase *nwi = this->GetWidget<NWidgetBase>(WID_VR_VEHICLE_PANEL_DISPLAY);
 925                                 this->click_x = GetClickPosition(pt.x - nwi->pos_x);
 926                                 this->SetSelectedVehicles(pt.x - nwi->pos_x);
 927                                 this->SetWidgetDirty(WID_VR_VEHICLE_PANEL_DISPLAY);
 928                                 if (!_ctrl_pressed) {
 929                                         SetObjectToPlaceWnd(SPR_CURSOR_MOUSE, PAL_NONE, HT_DRAG, this);
 930                                 } else {
 931                                         /* The vehicle selection has changed. */
 932                                         this->InvalidateData(2);
 933                                 }
 934                                 break;
 935                         }
 936
 937                         case WID_VR_MATRIX: { // listbox
 938                                 this->SetSelection(this->vscroll->GetScrolledRowFromWidget(pt.y, this, WID_VR_MATRIX));
 939                                 this->SetWidgetDisabledState(WID_VR_REFIT, this->sel[0] < 0);
 940                                 this->InvalidateData(1);
 941
 942                                 if (click_count == 1) break;
 943                         }
 944                         FALLTHROUGH;
 945
 946                         case WID_VR_REFIT: // refit button
 947                                 if (this->cargo != NULL) {
 948                                         const Vehicle *v = Vehicle::Get(this->window_number);
 949
 950                                         if (this->order == INVALID_VEH_ORDER_ID) {
 951                                                 bool delete_window = this->selected_vehicle == v->index && this->num_vehicles == UINT8_MAX;
 952                                                 if (DoCommandP(v->tile, this->selected_vehicle, this->cargo->cargo | this->cargo->subtype << 8 | this->num_vehicles << 16, GetCmdRefitVeh(v)) && delete_window) delete this;
 953                                         } else {
 954                                                 if (DoCommandP(v->tile, v->index, this->cargo->cargo | this->order << 16, CMD_ORDER_REFIT)) delete this;
 955                                         }
 956                                 }
 957                                 break;
 958                 }
 959         }
 960
 961         virtual void OnMouseDrag(Point pt, int widget)
 962         {
 963                 switch (widget) {
 964                         case WID_VR_VEHICLE_PANEL_DISPLAY: { // Vehicle image.
 965                                 if (this->order != INVALID_VEH_ORDER_ID) break;
 966                                 NWidgetBase *nwi = this->GetWidget<NWidgetBase>(WID_VR_VEHICLE_PANEL_DISPLAY);
 967                                 this->SetSelectedVehicles(pt.x - nwi->pos_x);
 968                                 this->SetWidgetDirty(WID_VR_VEHICLE_PANEL_DISPLAY);
 969                                 break;
 970                         }
 971                 }
 972         }
 973
 974         virtual void OnDragDrop(Point pt, int widget)
 975         {
 976                 switch (widget) {
 977                         case WID_VR_VEHICLE_PANEL_DISPLAY: { // Vehicle image.
 978                                 if (this->order != INVALID_VEH_ORDER_ID) break;
 979                                 NWidgetBase *nwi = this->GetWidget<NWidgetBase>(WID_VR_VEHICLE_PANEL_DISPLAY);
 980                                 this->SetSelectedVehicles(pt.x - nwi->pos_x);
 981                                 this->InvalidateData(2);
 982                                 break;
 983                         }
 984                 }
 985         }
 986
 987         virtual void OnResize()
 988         {
 989                 this->vehicle_width = GetVehicleWidth(Vehicle::Get(this->window_number), EIT_IN_DETAILS);
 990                 this->vscroll->SetCapacityFromWidget(this, WID_VR_MATRIX);
 991                 if (this->hscroll != NULL) this->hscroll->SetCapacityFromWidget(this, WID_VR_VEHICLE_PANEL_DISPLAY);
 992         }
 993 };
 994
 995 static const NWidgetPart _nested_vehicle_refit_widgets[] = {
 996         NWidget(NWID_HORIZONTAL),
 997                 NWidget(WWT_CLOSEBOX, COLOUR_GREY),
 998                 NWidget(WWT_CAPTION, COLOUR_GREY, WID_VR_CAPTION), SetDataTip(STR_REFIT_CAPTION, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
 999                 NWidget(WWT_DEFSIZEBOX, COLOUR_GREY),
1000         EndContainer(),
1001         /* Vehicle display + scrollbar. */
1002         NWidget(NWID_VERTICAL),
1003                 NWidget(WWT_PANEL, COLOUR_GREY, WID_VR_VEHICLE_PANEL_DISPLAY), SetMinimalSize(228, 14), SetResize(1, 0), SetScrollbar(WID_VR_HSCROLLBAR), EndContainer(),
1004                 NWidget(NWID_SELECTION, INVALID_COLOUR, WID_VR_SHOW_HSCROLLBAR),
1005                         NWidget(NWID_HSCROLLBAR, COLOUR_GREY, WID_VR_HSCROLLBAR),
1006                 EndContainer(),
1007         EndContainer(),
1008         NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_VR_SELECT_HEADER), SetDataTip(STR_REFIT_TITLE, STR_NULL), SetResize(1, 0),
1009         /* Matrix + scrollbar. */
1010         NWidget(NWID_HORIZONTAL),
1011                 NWidget(WWT_MATRIX, COLOUR_GREY, WID_VR_MATRIX), SetMinimalSize(228, 112), SetResize(1, 14), SetFill(1, 1), SetMatrixDataTip(1, 0, STR_NULL), SetScrollbar(WID_VR_SCROLLBAR),
1012                 NWidget(NWID_VSCROLLBAR, COLOUR_GREY, WID_VR_SCROLLBAR),
1013         EndContainer(),
1014         NWidget(WWT_PANEL, COLOUR_GREY, WID_VR_INFO), SetMinimalTextLines(2, WD_FRAMERECT_TOP + WD_FRAMERECT_BOTTOM), SetResize(1, 0), EndContainer(),
1015         NWidget(NWID_HORIZONTAL),
1016                 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_VR_REFIT), SetFill(1, 0), SetResize(1, 0),
1017                 NWidget(WWT_RESIZEBOX, COLOUR_GREY),
1018         EndContainer(),
1019 };
1020
1021 static WindowDesc _vehicle_refit_desc(
1022         WDP_AUTO, "view_vehicle_refit", 240, 174,
1023         WC_VEHICLE_REFIT, WC_VEHICLE_VIEW,
1024         WDF_CONSTRUCTION,
1025         _nested_vehicle_refit_widgets, lengthof(_nested_vehicle_refit_widgets)
1026 );
1027
1028 /**
1029  * Show the refit window for a vehicle
1030  * @param *v The vehicle to show the refit window for
1031  * @param order of the vehicle to assign refit to, or INVALID_VEH_ORDER_ID to refit the vehicle now
1032  * @param parent the parent window of the refit window
1033  * @param auto_refit Choose cargo for auto-refitting
1034  */
1035 void ShowVehicleRefitWindow(const Vehicle *v, VehicleOrderID order, Window *parent, bool auto_refit)
1036 {
1037         DeleteWindowById(WC_VEHICLE_REFIT, v->index);
1038         RefitWindow *w = new RefitWindow(&_vehicle_refit_desc, v, order, auto_refit);
1039         w->parent = parent;
1040 }
1041
1042 /** Display list of cargo types of the engine, for the purchase information window */
1043 uint ShowRefitOptionsList(int left, int right, int y, EngineID engine)
1044 {
1045         /* List of cargo types of this engine */
1046         uint32 cmask = GetUnionOfArticulatedRefitMasks(engine, false);
1047         /* List of cargo types available in this climate */
1048         uint32 lmask = _cargo_mask;
1049
1050         /* Draw nothing if the engine is not refittable */
1051         if (HasAtMostOneBit(cmask)) return y;
1052
1053         if (cmask == lmask) {
1054                 /* Engine can be refitted to all types in this climate */
1055                 SetDParam(0, STR_PURCHASE_INFO_ALL_TYPES);
1056         } else {
1057                 /* Check if we are able to refit to more cargo types and unable to. If
1058                  * so, invert the cargo types to list those that we can't refit to. */
1059                 if (CountBits(cmask ^ lmask) < CountBits(cmask) && CountBits(cmask ^ lmask) <= 7) {
1060                         cmask ^= lmask;
1061                         SetDParam(0, STR_PURCHASE_INFO_ALL_BUT);
1062                 } else {
1063                         SetDParam(0, STR_JUST_CARGO_LIST);
1064                 }
1065                 SetDParam(1, cmask);
1066         }
1067
1068         return DrawStringMultiLine(left, right, y, INT32_MAX, STR_PURCHASE_INFO_REFITTABLE_TO);
1069 }
1070
1071 /** Get the cargo subtype text from NewGRF for the vehicle details window. */
1072 StringID GetCargoSubtypeText(const Vehicle *v)
1073 {
1074         if (HasBit(EngInfo(v->engine_type)->callback_mask, CBM_VEHICLE_CARGO_SUFFIX)) {
1075                 uint16 cb = GetVehicleCallback(CBID_VEHICLE_CARGO_SUFFIX, 0, 0, v->engine_type, v);
1076                 if (cb != CALLBACK_FAILED) {
1077                         if (cb > 0x400) ErrorUnknownCallbackResult(v->GetGRFID(), CBID_VEHICLE_CARGO_SUFFIX, cb);
1078                         if (cb >= 0x400 || (v->GetGRF()->grf_version < 8 && cb == 0xFF)) cb = CALLBACK_FAILED;
1079                 }
1080                 if (cb != CALLBACK_FAILED) {
1081                         return GetGRFStringID(v->GetGRFID(), 0xD000 + cb);
1082                 }
1083         }
1084         return STR_EMPTY;
1085 }
1086
1087 /** Sort vehicles by their number */
1088 static int CDECL VehicleNumberSorter(const Vehicle * const *a, const Vehicle * const *b)
1089 {
1090         return (*a)->unitnumber - (*b)->unitnumber;
1091 }
1092
1093 /** Sort vehicles by their name */
1094 static int CDECL VehicleNameSorter(const Vehicle * const *a, const Vehicle * const *b)
1095 {
1096         static char last_name[2][64];
1097
1098         if (*a != _last_vehicle[0]) {
1099                 _last_vehicle[0] = *a;
1100                 SetDParam(0, (*a)->index);
1101                 GetString(last_name[0], STR_VEHICLE_NAME, lastof(last_name[0]));
1102         }
1103
1104         if (*b != _last_vehicle[1]) {
1105                 _last_vehicle[1] = *b;
1106                 SetDParam(0, (*b)->index);
1107                 GetString(last_name[1], STR_VEHICLE_NAME, lastof(last_name[1]));
1108         }
1109
1110         int r = strnatcmp(last_name[0], last_name[1]); // Sort by name (natural sorting).
1111         return (r != 0) ? r : VehicleNumberSorter(a, b);
1112 }
1113
1114 /** Sort vehicles by their age */
1115 static int CDECL VehicleAgeSorter(const Vehicle * const *a, const Vehicle * const *b)
1116 {
1117         int r = (*a)->age - (*b)->age;
1118         return (r != 0) ? r : VehicleNumberSorter(a, b);
1119 }
1120
1121 /** Sort vehicles by this year profit */
1122 static int CDECL VehicleProfitThisYearSorter(const Vehicle * const *a, const Vehicle * const *b)
1123 {
1124         int r = ClampToI32((*a)->GetDisplayProfitThisYear() - (*b)->GetDisplayProfitThisYear());
1125         return (r != 0) ? r : VehicleNumberSorter(a, b);
1126 }
1127
1128 /** Sort vehicles by last year profit */
1129 static int CDECL VehicleProfitLastYearSorter(const Vehicle * const *a, const Vehicle * const *b)
1130 {
1131         int r = ClampToI32((*a)->GetDisplayProfitLastYear() - (*b)->GetDisplayProfitLastYear());
1132         return (r != 0) ? r : VehicleNumberSorter(a, b);
1133 }
1134
1135 /** Sort vehicles by their cargo */
1136 static int CDECL VehicleCargoSorter(const Vehicle * const *a, const Vehicle * const *b)
1137 {
1138         const Vehicle *v;
1139         CargoArray diff;
1140
1141         /* Append the cargo of the connected waggons */
1142         for (v = *a; v != NULL; v = v->Next()) diff[v->cargo_type] += v->cargo_cap;
1143         for (v = *b; v != NULL; v = v->Next()) diff[v->cargo_type] -= v->cargo_cap;
1144
1145         int r = 0;
1146         for (CargoID i = 0; i < NUM_CARGO; i++) {
1147                 r = diff[i];
1148                 if (r != 0) break;
1149         }
1150
1151         return (r != 0) ? r : VehicleNumberSorter(a, b);
1152 }
1153
1154 /** Sort vehicles by their reliability */
1155 static int CDECL VehicleReliabilitySorter(const Vehicle * const *a, const Vehicle * const *b)
1156 {
1157         int r = (*a)->reliability - (*b)->reliability;
1158         return (r != 0) ? r : VehicleNumberSorter(a, b);
1159 }
1160
1161 /** Sort vehicles by their max speed */
1162 static int CDECL VehicleMaxSpeedSorter(const Vehicle * const *a, const Vehicle * const *b)
1163 {
1164         int r = (*a)->vcache.cached_max_speed - (*b)->vcache.cached_max_speed;
1165         return (r != 0) ? r : VehicleNumberSorter(a, b);
1166 }
1167
1168 /** Sort vehicles by model */
1169 static int CDECL VehicleModelSorter(const Vehicle * const *a, const Vehicle * const *b)
1170 {
1171         int r = (*a)->engine_type - (*b)->engine_type;
1172         return (r != 0) ? r : VehicleNumberSorter(a, b);
1173 }
1174
1175 /** Sort vehicles by their value */
1176 static int CDECL VehicleValueSorter(const Vehicle * const *a, const Vehicle * const *b)
1177 {
1178         const Vehicle *u;
1179         Money diff = 0;
1180
1181         for (u = *a; u != NULL; u = u->Next()) diff += u->value;
1182         for (u = *b; u != NULL; u = u->Next()) diff -= u->value;
1183
1184         int r = ClampToI32(diff);
1185         return (r != 0) ? r : VehicleNumberSorter(a, b);
1186 }
1187
1188 /** Sort vehicles by their length */
1189 static int CDECL VehicleLengthSorter(const Vehicle * const *a, const Vehicle * const *b)
1190 {
1191         int r = (*a)->GetGroundVehicleCache()->cached_total_length - (*b)->GetGroundVehicleCache()->cached_total_length;
1192         return (r != 0) ? r : VehicleNumberSorter(a, b);
1193 }
1194
1195 /** Sort vehicles by the time they can still live */
1196 static int CDECL VehicleTimeToLiveSorter(const Vehicle * const *a, const Vehicle * const *b)
1197 {
1198         int r = ClampToI32(((*a)->max_age - (*a)->age) - ((*b)->max_age - (*b)->age));
1199         return (r != 0) ? r : VehicleNumberSorter(a, b);
1200 }
1201
1202 /** Sort vehicles by the timetable delay */
1203 static int CDECL VehicleTimetableDelaySorter(const Vehicle * const *a, const Vehicle * const *b)
1204 {
1205         int r = (*a)->lateness_counter - (*b)->lateness_counter;
1206         return (r != 0) ? r : VehicleNumberSorter(a, b);
1207 }
1208
1209 void InitializeGUI()
1210 {
1211         MemSetT(&_sorting, 0);
1212 }
1213
1214 /**
1215  * Assign a vehicle window a new vehicle
1216  * @param window_class WindowClass to search for
1217  * @param from_index the old vehicle ID
1218  * @param to_index the new vehicle ID
1219  */
1220 static inline void ChangeVehicleWindow(WindowClass window_class, VehicleID from_index, VehicleID to_index)
1221 {
1222         Window *w = FindWindowById(window_class, from_index);
1223         if (w != NULL) {
1224                 /* Update window_number */
1225                 w->window_number = to_index;
1226                 if (w->viewport != NULL) w->viewport->follow_vehicle = to_index;
1227
1228                 /* Update vehicle drag data */
1229                 if (_thd.window_class == window_class && _thd.window_number == (WindowNumber)from_index) {
1230                         _thd.window_number = to_index;
1231                 }
1232
1233                 /* Notify the window. */
1234                 w->InvalidateData(VIWD_AUTOREPLACE, false);
1235         }
1236 }
1237
1238 /**
1239  * Report a change in vehicle IDs (due to autoreplace) to affected vehicle windows.
1240  * @param from_index the old vehicle ID
1241  * @param to_index the new vehicle ID
1242  */
1243 void ChangeVehicleViewWindow(VehicleID from_index, VehicleID to_index)
1244 {
1245         ChangeVehicleWindow(WC_VEHICLE_VIEW,      from_index, to_index);
1246         ChangeVehicleWindow(WC_VEHICLE_ORDERS,    from_index, to_index);
1247         ChangeVehicleWindow(WC_VEHICLE_REFIT,     from_index, to_index);
1248         ChangeVehicleWindow(WC_VEHICLE_DETAILS,   from_index, to_index);
1249         ChangeVehicleWindow(WC_VEHICLE_TIMETABLE, from_index, to_index);
1250 }
1251
1252 static const NWidgetPart _nested_vehicle_list[] = {
1253         NWidget(NWID_HORIZONTAL),
1254                 NWidget(WWT_CLOSEBOX, COLOUR_GREY),
1255                 NWidget(WWT_CAPTION, COLOUR_GREY, WID_VL_CAPTION),
1256                 NWidget(WWT_SHADEBOX, COLOUR_GREY),
1257                 NWidget(WWT_DEFSIZEBOX, COLOUR_GREY),
1258                 NWidget(WWT_STICKYBOX, COLOUR_GREY),
1259         EndContainer(),
1260
1261         NWidget(NWID_HORIZONTAL),
1262                 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_VL_SORT_ORDER), SetMinimalSize(81, 12), SetFill(0, 1), SetDataTip(STR_BUTTON_SORT_BY, STR_TOOLTIP_SORT_ORDER),
1263                 NWidget(WWT_DROPDOWN, COLOUR_GREY, WID_VL_SORT_BY_PULLDOWN), SetMinimalSize(167, 12), SetFill(0, 1), SetDataTip(0x0, STR_TOOLTIP_SORT_CRITERIA),
1264                 NWidget(WWT_PANEL, COLOUR_GREY), SetMinimalSize(12, 12), SetFill(1, 1), SetResize(1, 0),
1265                 EndContainer(),
1266         EndContainer(),
1267
1268         NWidget(NWID_HORIZONTAL),
1269                 NWidget(WWT_MATRIX, COLOUR_GREY, WID_VL_LIST), SetMinimalSize(248, 0), SetFill(1, 0), SetResize(1, 1), SetMatrixDataTip(1, 0, STR_NULL), SetScrollbar(WID_VL_SCROLLBAR),
1270                 NWidget(NWID_VSCROLLBAR, COLOUR_GREY, WID_VL_SCROLLBAR),
1271         EndContainer(),
1272
1273         NWidget(NWID_HORIZONTAL),
1274                 NWidget(NWID_SELECTION, INVALID_COLOUR, WID_VL_HIDE_BUTTONS),
1275                         NWidget(NWID_HORIZONTAL),
1276                                 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_VL_AVAILABLE_VEHICLES), SetMinimalSize(106, 12), SetFill(0, 1),
1277                                                                 SetDataTip(STR_BLACK_STRING, STR_VEHICLE_LIST_AVAILABLE_ENGINES_TOOLTIP),
1278                                 NWidget(WWT_PANEL, COLOUR_GREY), SetMinimalSize(0, 12), SetResize(1, 0), SetFill(1, 1), EndContainer(),
1279                                 NWidget(WWT_DROPDOWN, COLOUR_GREY, WID_VL_MANAGE_VEHICLES_DROPDOWN), SetMinimalSize(118, 12), SetFill(0, 1),
1280                                                                 SetDataTip(STR_VEHICLE_LIST_MANAGE_LIST, STR_VEHICLE_LIST_MANAGE_LIST_TOOLTIP),
1281                                 NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_VL_STOP_ALL), SetMinimalSize(12, 12), SetFill(0, 1),
1282                                                                 SetDataTip(SPR_FLAG_VEH_STOPPED, STR_VEHICLE_LIST_MASS_STOP_LIST_TOOLTIP),
1283                                 NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_VL_START_ALL), SetMinimalSize(12, 12), SetFill(0, 1),
1284                                                                 SetDataTip(SPR_FLAG_VEH_RUNNING, STR_VEHICLE_LIST_MASS_START_LIST_TOOLTIP),
1285                         EndContainer(),
1286                         /* Widget to be shown for other companies hiding the previous 5 widgets. */
1287                         NWidget(WWT_PANEL, COLOUR_GREY), SetFill(1, 1), SetResize(1, 0), EndContainer(),
1288                 EndContainer(),
1289                 NWidget(WWT_RESIZEBOX, COLOUR_GREY),
1290         EndContainer(),
1291 };
1292
1293 static void DrawSmallOrderList(const Vehicle *v, int left, int right, int y, VehicleOrderID start = 0)
1294 {
1295         const Order *order = v->GetOrder(start);
1296         if (order == NULL) return;
1297
1298         bool rtl = _current_text_dir == TD_RTL;
1299         int l_offset = rtl ? 0 : ScaleGUITrad(6);
1300         int r_offset = rtl ? ScaleGUITrad(6) : 0;
1301         int i = 0;
1302         VehicleOrderID oid = start;
1303
1304         do {
1305                 if (oid == v->cur_real_order_index) DrawString(left, right, y, STR_TINY_RIGHT_ARROW, TC_BLACK);
1306
1307                 if (order->IsType(OT_GOTO_STATION)) {
1308                         SetDParam(0, order->GetDestination());
1309                         DrawString(left + l_offset, right - r_offset, y, STR_TINY_BLACK_STATION);
1310
1311                         y += FONT_HEIGHT_SMALL;
1312                         if (++i == 4) break;
1313                 }
1314
1315                 oid++;
1316                 order = order->next;
1317                 if (order == NULL) {
1318                         order = v->orders.list->GetFirstOrder();
1319                         oid = 0;
1320                 }
1321         } while (oid != start);
1322 }
1323
1324 /**
1325  * Draws an image of a vehicle chain
1326  * @param v         Front vehicle
1327  * @param left      The minimum horizontal position
1328  * @param right     The maximum horizontal position
1329  * @param y         Vertical position to draw at
1330  * @param selection Selected vehicle to draw a frame around
1331  * @param skip      Number of pixels to skip at the front (for scrolling)
1332  */
1333 void DrawVehicleImage(const Vehicle *v, int left, int right, int y, VehicleID selection, EngineImageType image_type, int skip)
1334 {
1335         switch (v->type) {
1336                 case VEH_TRAIN:    DrawTrainImage(Train::From(v), left, right, y, selection, image_type, skip); break;
1337                 case VEH_ROAD:     DrawRoadVehImage(v, left, right, y, selection, image_type, skip);  break;
1338                 case VEH_SHIP:     DrawShipImage(v, left, right, y, selection, image_type);     break;
1339                 case VEH_AIRCRAFT: DrawAircraftImage(v, left, right, y, selection, image_type); break;
1340                 default: NOT_REACHED();
1341         }
1342 }
1343
1344 /**
1345  * Get the height of a vehicle in the vehicle list GUIs.
1346  * @param type    the vehicle type to look at
1347  * @param divisor the resulting height must be dividable by this
1348  * @return the height
1349  */
1350 uint GetVehicleListHeight(VehicleType type, uint divisor)
1351 {
1352         /* Name + vehicle + profit */
1353         uint base = ScaleGUITrad(GetVehicleHeight(type)) + 2 * FONT_HEIGHT_SMALL;
1354         /* Drawing of the 4 small orders + profit*/
1355         if (type >= VEH_SHIP) base = max(base, 5U * FONT_HEIGHT_SMALL);
1356
1357         if (divisor == 1) return base;
1358
1359         /* Make sure the height is dividable by divisor */
1360         uint rem = base % divisor;
1361         return base + (rem == 0 ? 0 : divisor - rem);
1362 }
1363
1364 /**
1365  * Draw all the vehicle list items.
1366  * @param selected_vehicle The vehicle that is to be highlighted.
1367  * @param line_height      Height of a single item line.
1368  * @param r                Rectangle with edge positions of the matrix widget.
1369  */
1370 void BaseVehicleListWindow::DrawVehicleListItems(VehicleID selected_vehicle, int line_height, const Rect &r) const
1371 {
1372         int left = r.left + WD_MATRIX_LEFT;
1373         int right = r.right - WD_MATRIX_RIGHT;
1374         int width = right - left;
1375         bool rtl = _current_text_dir == TD_RTL;
1376
1377         int text_offset = max<int>(GetSpriteSize(SPR_PROFIT_LOT).width, GetDigitWidth() * this->unitnumber_digits) + WD_FRAMERECT_RIGHT;
1378         int text_left  = left  + (rtl ?           0 : text_offset);
1379         int text_right = right - (rtl ? text_offset :           0);
1380
1381         bool show_orderlist = this->vli.vtype >= VEH_SHIP;
1382         int orderlist_left  = left  + (rtl ? 0 : max(ScaleGUITrad(100) + text_offset, width / 2));
1383         int orderlist_right = right - (rtl ? max(ScaleGUITrad(100) + text_offset, width / 2) : 0);
1384
1385         int image_left  = (rtl && show_orderlist) ? orderlist_right : text_left;
1386         int image_right = (!rtl && show_orderlist) ? orderlist_left : text_right;
1387
1388         int vehicle_button_x = rtl ? right - GetSpriteSize(SPR_PROFIT_LOT).width : left;
1389
1390         int y = r.top;
1391         uint max = min(this->vscroll->GetPosition() + this->vscroll->GetCapacity(), this->vehicles.Length());
1392         for (uint i = this->vscroll->GetPosition(); i < max; ++i) {
1393                 const Vehicle *v = this->vehicles[i];
1394                 StringID str;
1395
1396                 SetDParam(0, v->GetDisplayProfitThisYear());
1397                 SetDParam(1, v->GetDisplayProfitLastYear());
1398
1399                 DrawVehicleImage(v, image_left, image_right, y + FONT_HEIGHT_SMALL - 1, selected_vehicle, EIT_IN_LIST, 0);
1400                 DrawString(text_left, text_right, y + line_height - FONT_HEIGHT_SMALL - WD_FRAMERECT_BOTTOM - 1, STR_VEHICLE_LIST_PROFIT_THIS_YEAR_LAST_YEAR);
1401
1402                 if (v->name != NULL) {
1403                         /* The vehicle got a name so we will print it */
1404                         SetDParam(0, v->index);
1405                         DrawString(text_left, text_right, y, STR_TINY_BLACK_VEHICLE);
1406                 } else if (v->group_id != DEFAULT_GROUP) {
1407                         /* The vehicle has no name, but is member of a group, so print group name */
1408                         SetDParam(0, v->group_id);
1409                         DrawString(text_left, text_right, y, STR_TINY_GROUP, TC_BLACK);
1410                 }
1411
1412                 if (show_orderlist) DrawSmallOrderList(v, orderlist_left, orderlist_right, y, v->cur_real_order_index);
1413
1414                 if (v->IsChainInDepot()) {
1415                         str = STR_BLUE_COMMA;
1416                 } else {
1417                         str = (v->age > v->max_age - DAYS_IN_LEAP_YEAR) ? STR_RED_COMMA : STR_BLACK_COMMA;
1418                 }
1419
1420                 SetDParam(0, v->unitnumber);
1421                 DrawString(left, right, y + 2, str);
1422
1423                 DrawVehicleProfitButton(v, vehicle_button_x, y + FONT_HEIGHT_NORMAL + 3);
1424
1425                 y += line_height;
1426         }
1427 }
1428
1429 /**
1430  * Window for the (old) vehicle listing.
1431  *
1432  * bitmask for w->window_number
1433  * 0-7 CompanyID (owner)
1434  * 8-10 window type (use flags in vehicle_gui.h)
1435  * 11-15 vehicle type (using VEH_, but can be compressed to fewer bytes if needed)
1436  * 16-31 StationID or OrderID depending on window type (bit 8-10)
1437  */
1438 struct VehicleListWindow : public BaseVehicleListWindow {
1439 private:
1440         /** Enumeration of planes of the button row at the bottom. */
1441         enum ButtonPlanes {
1442                 BP_SHOW_BUTTONS, ///< Show the buttons.
1443                 BP_HIDE_BUTTONS, ///< Show the empty panel.
1444         };
1445
1446 public:
1447         VehicleListWindow(WindowDesc *desc, WindowNumber window_number) : BaseVehicleListWindow(desc, window_number)
1448         {
1449                 /* Set up sorting. Make the window-specific _sorting variable
1450                  * point to the correct global _sorting struct so we are freed
1451                  * from having conditionals during window operation */
1452                 switch (this->vli.vtype) {
1453                         case VEH_TRAIN:    this->sorting = &_sorting.train; break;
1454                         case VEH_ROAD:     this->sorting = &_sorting.roadveh; break;
1455                         case VEH_SHIP:     this->sorting = &_sorting.ship; break;
1456                         case VEH_AIRCRAFT: this->sorting = &_sorting.aircraft; break;
1457                         default: NOT_REACHED();
1458                 }
1459
1460                 this->CreateNestedTree();
1461
1462                 this->vscroll = this->GetScrollbar(WID_VL_SCROLLBAR);
1463
1464                 this->vehicles.SetListing(*this->sorting);
1465                 this->vehicles.ForceRebuild();
1466                 this->vehicles.NeedResort();
1467                 this->BuildVehicleList();
1468                 this->SortVehicleList();
1469
1470                 /* Set up the window widgets */
1471                 this->GetWidget<NWidgetCore>(WID_VL_LIST)->tool_tip = STR_VEHICLE_LIST_TRAIN_LIST_TOOLTIP + this->vli.vtype;
1472
1473                 if (this->vli.type == VL_SHARED_ORDERS) {
1474                         this->GetWidget<NWidgetCore>(WID_VL_CAPTION)->widget_data = STR_VEHICLE_LIST_SHARED_ORDERS_LIST_CAPTION;
1475                 } else {
1476                         this->GetWidget<NWidgetCore>(WID_VL_CAPTION)->widget_data = STR_VEHICLE_LIST_TRAIN_CAPTION + this->vli.vtype;
1477                 }
1478
1479                 this->FinishInitNested(window_number);
1480                 if (this->vli.company != OWNER_NONE) this->owner = this->vli.company;
1481         }
1482
1483         ~VehicleListWindow()
1484         {
1485                 *this->sorting = this->vehicles.GetListing();
1486         }
1487
1488         virtual void UpdateWidgetSize(int widget, Dimension *size, const Dimension &padding, Dimension *fill, Dimension *resize)
1489         {
1490                 switch (widget) {
1491                         case WID_VL_LIST:
1492                                 resize->height = GetVehicleListHeight(this->vli.vtype, 1);
1493
1494                                 switch (this->vli.vtype) {
1495                                         case VEH_TRAIN:
1496                                         case VEH_ROAD:
1497                                                 size->height = 6 * resize->height;
1498                                                 break;
1499                                         case VEH_SHIP:
1500                                         case VEH_AIRCRAFT:
1501                                                 size->height = 4 * resize->height;
1502                                                 break;
1503                                         default: NOT_REACHED();
1504                                 }
1505                                 break;
1506
1507                         case WID_VL_SORT_ORDER: {
1508                                 Dimension d = GetStringBoundingBox(this->GetWidget<NWidgetCore>(widget)->widget_data);
1509                                 d.width += padding.width + Window::SortButtonWidth() * 2; // Doubled since the string is centred and it also looks better.
1510                                 d.height += padding.height;
1511                                 *size = maxdim(*size, d);
1512                                 break;
1513                         }
1514
1515                         case WID_VL_MANAGE_VEHICLES_DROPDOWN: {
1516                                 Dimension d = this->GetActionDropdownSize(this->vli.type == VL_STANDARD, false);
1517                                 d.height += padding.height;
1518                                 d.width  += padding.width;
1519                                 *size = maxdim(*size, d);
1520                                 break;
1521                         }
1522                 }
1523         }
1524
1525         virtual void SetStringParameters(int widget) const
1526         {
1527                 switch (widget) {
1528                         case WID_VL_AVAILABLE_VEHICLES:
1529                                 SetDParam(0, STR_VEHICLE_LIST_AVAILABLE_TRAINS + this->vli.vtype);
1530                                 break;
1531
1532                         case WID_VL_CAPTION: {
1533                                 switch (this->vli.type) {
1534                                         case VL_SHARED_ORDERS: // Shared Orders
1535                                                 if (this->vehicles.Length() == 0) {
1536                                                         /* We can't open this window without vehicles using this order
1537                                                          * and we should close the window when deleting the order. */
1538                                                         NOT_REACHED();
1539                                                 }
1540                                                 SetDParam(0, this->vscroll->GetCount());
1541                                                 break;
1542
1543                                         case VL_STANDARD: // Company Name
1544                                                 SetDParam(0, STR_COMPANY_NAME);
1545                                                 SetDParam(1, this->vli.index);
1546                                                 SetDParam(3, this->vscroll->GetCount());
1547                                                 break;
1548
1549                                         case VL_STATION_LIST: // Station/Waypoint Name
1550                                                 SetDParam(0, Station::IsExpected(BaseStation::Get(this->vli.index)) ? STR_STATION_NAME : STR_WAYPOINT_NAME);
1551                                                 SetDParam(1, this->vli.index);
1552                                                 SetDParam(3, this->vscroll->GetCount());
1553                                                 break;
1554
1555                                         case VL_DEPOT_LIST:
1556                                                 SetDParam(0, STR_DEPOT_CAPTION);
1557                                                 SetDParam(1, this->vli.vtype);
1558                                                 SetDParam(2, this->vli.index);
1559                                                 SetDParam(3, this->vscroll->GetCount());
1560                                                 break;
1561                                         default: NOT_REACHED();
1562                                 }
1563                                 break;
1564                         }
1565                 }
1566         }
1567
1568         virtual void DrawWidget(const Rect &r, int widget) const
1569         {
1570                 switch (widget) {
1571                         case WID_VL_SORT_ORDER:
1572                                 /* draw arrow pointing up/down for ascending/descending sorting */
1573                                 this->DrawSortButtonState(widget, this->vehicles.IsDescSortOrder() ? SBS_DOWN : SBS_UP);
1574                                 break;
1575
1576                         case WID_VL_LIST:
1577                                 this->DrawVehicleListItems(INVALID_VEHICLE, this->resize.step_height, r);
1578                                 break;
1579                 }
1580         }
1581
1582         virtual void OnPaint()
1583         {
1584                 this->BuildVehicleList();
1585                 this->SortVehicleList();
1586
1587                 if (this->vehicles.Length() == 0 && this->IsWidgetLowered(WID_VL_MANAGE_VEHICLES_DROPDOWN)) {
1588                         HideDropDownMenu(this);
1589                 }
1590
1591                 /* Hide the widgets that we will not use in this window
1592                  * Some windows contains actions only fit for the owner */
1593                 int plane_to_show = (this->owner == _local_company) ? BP_SHOW_BUTTONS : BP_HIDE_BUTTONS;
1594                 NWidgetStacked *nwi = this->GetWidget<NWidgetStacked>(WID_VL_HIDE_BUTTONS);
1595                 if (plane_to_show != nwi->shown_plane) {
1596                         nwi->SetDisplayedPlane(plane_to_show);
1597                         nwi->SetDirty(this);
1598                 }
1599                 if (this->owner == _local_company) {
1600                         this->SetWidgetDisabledState(WID_VL_AVAILABLE_VEHICLES, this->vli.type != VL_STANDARD);
1601                         this->SetWidgetsDisabledState(this->vehicles.Length() == 0,
1602                                 WID_VL_MANAGE_VEHICLES_DROPDOWN,
1603                                 WID_VL_STOP_ALL,
1604                                 WID_VL_START_ALL,
1605                                 WIDGET_LIST_END);
1606                 }
1607
1608                 /* Set text of sort by dropdown widget. */
1609                 this->GetWidget<NWidgetCore>(WID_VL_SORT_BY_PULLDOWN)->widget_data = this->vehicle_sorter_names[this->vehicles.SortType()];
1610
1611                 this->DrawWidgets();
1612         }
1613
1614         virtual void OnClick(Point pt, int widget, int click_count)
1615         {
1616                 switch (widget) {
1617                         case WID_VL_SORT_ORDER: // Flip sorting method ascending/descending
1618                                 this->vehicles.ToggleSortOrder();
1619                                 this->SetDirty();
1620                                 break;
1621
1622                         case WID_VL_SORT_BY_PULLDOWN:// Select sorting criteria dropdown menu
1623                                 ShowDropDownMenu(this, this->vehicle_sorter_names, this->vehicles.SortType(), WID_VL_SORT_BY_PULLDOWN, 0,
1624                                                 (this->vli.vtype == VEH_TRAIN || this->vli.vtype == VEH_ROAD) ? 0 : (1 << 10));
1625                                 return;
1626
1627                         case WID_VL_LIST: { // Matrix to show vehicles
1628                                 uint id_v = this->vscroll->GetScrolledRowFromWidget(pt.y, this, WID_VL_LIST);
1629                                 if (id_v >= this->vehicles.Length()) return; // click out of list bound
1630
1631                                 const Vehicle *v = this->vehicles[id_v];
1632                                 if (!VehicleClicked(v)) ShowVehicleViewWindow(v);
1633                                 break;
1634                         }
1635
1636                         case WID_VL_AVAILABLE_VEHICLES:
1637                                 ShowBuildVehicleWindow(INVALID_TILE, this->vli.vtype);
1638                                 break;
1639
1640                         case WID_VL_MANAGE_VEHICLES_DROPDOWN: {
1641                                 DropDownList *list = this->BuildActionDropdownList(VehicleListIdentifier::UnPack(this->window_number).type == VL_STANDARD, false);
1642                                 ShowDropDownList(this, list, 0, WID_VL_MANAGE_VEHICLES_DROPDOWN);
1643                                 break;
1644                         }
1645
1646                         case WID_VL_STOP_ALL:
1647                         case WID_VL_START_ALL:
1648                                 DoCommandP(0, (1 << 1) | (widget == WID_VL_START_ALL ? (1 << 0) : 0), this->window_number, CMD_MASS_START_STOP);
1649                                 break;
1650                 }
1651         }
1652
1653         virtual void OnDropdownSelect(int widget, int index)
1654         {
1655                 switch (widget) {
1656                         case WID_VL_SORT_BY_PULLDOWN:
1657                                 this->vehicles.SetSortType(index);
1658                                 break;
1659                         case WID_VL_MANAGE_VEHICLES_DROPDOWN:
1660                                 assert(this->vehicles.Length() != 0);
1661
1662                                 switch (index) {
1663                                         case ADI_REPLACE: // Replace window
1664                                                 ShowReplaceGroupVehicleWindow(ALL_GROUP, this->vli.vtype);
1665                                                 break;
1666                                         case ADI_SERVICE: // Send for servicing
1667                                         case ADI_DEPOT: // Send to Depots
1668                                                 DoCommandP(0, DEPOT_MASS_SEND | (index == ADI_SERVICE ? DEPOT_SERVICE : (DepotCommand)0), this->window_number, GetCmdSendToDepot(this->vli.vtype));
1669                                                 break;
1670
1671                                         default: NOT_REACHED();
1672                                 }
1673                                 break;
1674                         default: NOT_REACHED();
1675                 }
1676                 this->SetDirty();
1677         }
1678
1679         virtual void OnTick()
1680         {
1681                 if (_pause_mode != PM_UNPAUSED) return;
1682                 if (this->vehicles.NeedResort()) {
1683                         StationID station = (this->vli.type == VL_STATION_LIST) ? this->vli.index : INVALID_STATION;
1684
1685                         DEBUG(misc, 3, "Periodic resort %d list company %d at station %d", this->vli.vtype, this->owner, station);
1686                         this->SetDirty();
1687                 }
1688         }
1689
1690         virtual void OnResize()
1691         {
1692                 this->vscroll->SetCapacityFromWidget(this, WID_VL_LIST);
1693         }
1694
1695         /**
1696          * Some data on this window has become invalid.
1697          * @param data Information about the changed data.
1698          * @param gui_scope Whether the call is done from GUI scope. You may not do everything when not in GUI scope. See #InvalidateWindowData() for details.
1699          */
1700         virtual void OnInvalidateData(int data = 0, bool gui_scope = true)
1701         {
1702                 if (!gui_scope && HasBit(data, 31) && this->vli.type == VL_SHARED_ORDERS) {
1703                         /* Needs to be done in command-scope, so everything stays valid */
1704                         this->vli.index = GB(data, 0, 20);
1705                         this->window_number = this->vli.Pack();
1706                         this->vehicles.ForceRebuild();
1707                         return;
1708                 }
1709
1710                 if (data == 0) {
1711                         /* This needs to be done in command-scope to enforce rebuilding before resorting invalid data */
1712                         this->vehicles.ForceRebuild();
1713                 } else {
1714                         this->vehicles.ForceResort();
1715                 }
1716         }
1717 };
1718
1719 static WindowDesc _vehicle_list_other_desc(
1720         WDP_AUTO, "list_vehicles", 260, 246,
1721         WC_INVALID, WC_NONE,
1722         0,
1723         _nested_vehicle_list, lengthof(_nested_vehicle_list)
1724 );
1725
1726 static WindowDesc _vehicle_list_train_desc(
1727         WDP_AUTO, "list_vehicles_train", 325, 246,
1728         WC_TRAINS_LIST, WC_NONE,
1729         0,
1730         _nested_vehicle_list, lengthof(_nested_vehicle_list)
1731 );
1732
1733 static void ShowVehicleListWindowLocal(CompanyID company, VehicleListType vlt, VehicleType vehicle_type, uint32 unique_number)
1734 {
1735         if (!Company::IsValidID(company) && company != OWNER_NONE) return;
1736
1737         WindowNumber num = VehicleListIdentifier(vlt, vehicle_type, company, unique_number).Pack();
1738         if (vehicle_type == VEH_TRAIN) {
1739                 AllocateWindowDescFront<VehicleListWindow>(&_vehicle_list_train_desc, num);
1740         } else {
1741                 _vehicle_list_other_desc.cls = GetWindowClassForVehicleType(vehicle_type);
1742                 AllocateWindowDescFront<VehicleListWindow>(&_vehicle_list_other_desc, num);
1743         }
1744 }
1745
1746 void ShowVehicleListWindow(CompanyID company, VehicleType vehicle_type)
1747 {
1748         /* If _settings_client.gui.advanced_vehicle_list > 1, display the Advanced list
1749          * if _settings_client.gui.advanced_vehicle_list == 1, display Advanced list only for local company
1750          * if _ctrl_pressed, do the opposite action (Advanced list x Normal list)
1751          */
1752
1753         if ((_settings_client.gui.advanced_vehicle_list > (uint)(company != _local_company)) != _ctrl_pressed) {
1754                 ShowCompanyGroup(company, vehicle_type);
1755         } else {
1756                 ShowVehicleListWindowLocal(company, VL_STANDARD, vehicle_type, company);
1757         }
1758 }
1759
1760 void ShowVehicleListWindow(const Vehicle *v)
1761 {
1762         ShowVehicleListWindowLocal(v->owner, VL_SHARED_ORDERS, v->type, v->FirstShared()->index);
1763 }
1764
1765 void ShowVehicleListWindow(CompanyID company, VehicleType vehicle_type, StationID station)
1766 {
1767         ShowVehicleListWindowLocal(company, VL_STATION_LIST, vehicle_type, station);
1768 }
1769
1770 void ShowVehicleListWindow(CompanyID company, VehicleType vehicle_type, TileIndex depot_tile)
1771 {
1772         uint16 depot_airport_index;
1773
1774         if (vehicle_type == VEH_AIRCRAFT) {
1775                 depot_airport_index = GetStationIndex(depot_tile);
1776         } else {
1777                 depot_airport_index = GetDepotIndex(depot_tile);
1778         }
1779         ShowVehicleListWindowLocal(company, VL_DEPOT_LIST, vehicle_type, depot_airport_index);
1780 }
1781
1782
1783 /* Unified vehicle GUI - Vehicle Details Window */
1784
1785 assert_compile(WID_VD_DETAILS_CARGO_CARRIED    == WID_VD_DETAILS_CARGO_CARRIED + TDW_TAB_CARGO   );
1786 assert_compile(WID_VD_DETAILS_TRAIN_VEHICLES   == WID_VD_DETAILS_CARGO_CARRIED + TDW_TAB_INFO    );
1787 assert_compile(WID_VD_DETAILS_CAPACITY_OF_EACH == WID_VD_DETAILS_CARGO_CARRIED + TDW_TAB_CAPACITY);
1788 assert_compile(WID_VD_DETAILS_TOTAL_CARGO      == WID_VD_DETAILS_CARGO_CARRIED + TDW_TAB_TOTALS  );
1789
1790 /** Vehicle details widgets (other than train). */
1791 static const NWidgetPart _nested_nontrain_vehicle_details_widgets[] = {
1792         NWidget(NWID_HORIZONTAL),
1793                 NWidget(WWT_CLOSEBOX, COLOUR_GREY),
1794                 NWidget(WWT_CAPTION, COLOUR_GREY, WID_VD_CAPTION), SetDataTip(STR_VEHICLE_DETAILS_CAPTION, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
1795                 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_VD_RENAME_VEHICLE), SetMinimalSize(40, 0), SetMinimalTextLines(1, WD_FRAMERECT_TOP + WD_FRAMERECT_BOTTOM + 2), SetDataTip(STR_VEHICLE_NAME_BUTTON, STR_NULL /* filled in later */),
1796                 NWidget(WWT_SHADEBOX, COLOUR_GREY),
1797                 NWidget(WWT_DEFSIZEBOX, COLOUR_GREY),
1798                 NWidget(WWT_STICKYBOX, COLOUR_GREY),
1799         EndContainer(),
1800         NWidget(WWT_PANEL, COLOUR_GREY, WID_VD_TOP_DETAILS), SetMinimalSize(405, 42), SetResize(1, 0), EndContainer(),
1801         NWidget(WWT_PANEL, COLOUR_GREY, WID_VD_MIDDLE_DETAILS), SetMinimalSize(405, 45), SetResize(1, 0), EndContainer(),
1802         NWidget(NWID_HORIZONTAL),
1803                 NWidget(WWT_PUSHARROWBTN, COLOUR_GREY, WID_VD_DECREASE_SERVICING_INTERVAL), SetFill(0, 1),
1804                                 SetDataTip(AWV_DECREASE, STR_VEHICLE_DETAILS_DECREASE_SERVICING_INTERVAL_TOOLTIP),
1805                 NWidget(WWT_PUSHARROWBTN, COLOUR_GREY, WID_VD_INCREASE_SERVICING_INTERVAL), SetFill(0, 1),
1806                                 SetDataTip(AWV_INCREASE, STR_VEHICLE_DETAILS_INCREASE_SERVICING_INTERVAL_TOOLTIP),
1807                 NWidget(WWT_DROPDOWN, COLOUR_GREY, WID_VD_SERVICE_INTERVAL_DROPDOWN), SetFill(0, 1),
1808                                 SetDataTip(STR_EMPTY, STR_SERVICE_INTERVAL_DROPDOWN_TOOLTIP),
1809                 NWidget(WWT_PANEL, COLOUR_GREY, WID_VD_SERVICING_INTERVAL), SetFill(1, 1), SetResize(1, 0), EndContainer(),
1810                 NWidget(WWT_RESIZEBOX, COLOUR_GREY),
1811         EndContainer(),
1812 };
1813
1814 /** Train details widgets. */
1815 static const NWidgetPart _nested_train_vehicle_details_widgets[] = {
1816         NWidget(NWID_HORIZONTAL),
1817                 NWidget(WWT_CLOSEBOX, COLOUR_GREY),
1818                 NWidget(WWT_CAPTION, COLOUR_GREY, WID_VD_CAPTION), SetDataTip(STR_VEHICLE_DETAILS_CAPTION, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
1819                 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_VD_RENAME_VEHICLE), SetMinimalSize(40, 0), SetMinimalTextLines(1, WD_FRAMERECT_TOP + WD_FRAMERECT_BOTTOM + 2), SetDataTip(STR_VEHICLE_NAME_BUTTON, STR_NULL /* filled in later */),
1820                 NWidget(WWT_SHADEBOX, COLOUR_GREY),
1821                 NWidget(WWT_DEFSIZEBOX, COLOUR_GREY),
1822                 NWidget(WWT_STICKYBOX, COLOUR_GREY),
1823         EndContainer(),
1824         NWidget(WWT_PANEL, COLOUR_GREY, WID_VD_TOP_DETAILS), SetResize(1, 0), SetMinimalSize(405, 42), EndContainer(),
1825         NWidget(NWID_HORIZONTAL),
1826                 NWidget(WWT_MATRIX, COLOUR_GREY, WID_VD_MATRIX), SetResize(1, 1), SetMinimalSize(393, 45), SetMatrixDataTip(1, 0, STR_NULL), SetFill(1, 0), SetScrollbar(WID_VD_SCROLLBAR),
1827                 NWidget(NWID_VSCROLLBAR, COLOUR_GREY, WID_VD_SCROLLBAR),
1828         EndContainer(),
1829         NWidget(NWID_HORIZONTAL),
1830                 NWidget(WWT_PUSHARROWBTN, COLOUR_GREY, WID_VD_DECREASE_SERVICING_INTERVAL), SetFill(0, 1),
1831                                 SetDataTip(AWV_DECREASE, STR_VEHICLE_DETAILS_DECREASE_SERVICING_INTERVAL_TOOLTIP),
1832                 NWidget(WWT_PUSHARROWBTN, COLOUR_GREY, WID_VD_INCREASE_SERVICING_INTERVAL), SetFill(0, 1),
1833                                 SetDataTip(AWV_INCREASE, STR_VEHICLE_DETAILS_INCREASE_SERVICING_INTERVAL_TOOLTIP),
1834                 NWidget(WWT_DROPDOWN, COLOUR_GREY, WID_VD_SERVICE_INTERVAL_DROPDOWN), SetFill(0, 1),
1835                                 SetDataTip(STR_EMPTY, STR_SERVICE_INTERVAL_DROPDOWN_TOOLTIP),
1836                 NWidget(WWT_PANEL, COLOUR_GREY, WID_VD_SERVICING_INTERVAL), SetFill(1, 1), SetResize(1, 0), EndContainer(),
1837         EndContainer(),
1838         NWidget(NWID_HORIZONTAL),
1839                 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_VD_DETAILS_CARGO_CARRIED), SetMinimalSize(96, 12),
1840                                 SetDataTip(STR_VEHICLE_DETAIL_TAB_CARGO, STR_VEHICLE_DETAILS_TRAIN_CARGO_TOOLTIP), SetFill(1, 0), SetResize(1, 0),
1841                 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_VD_DETAILS_TRAIN_VEHICLES), SetMinimalSize(99, 12),
1842                                 SetDataTip(STR_VEHICLE_DETAIL_TAB_INFORMATION, STR_VEHICLE_DETAILS_TRAIN_INFORMATION_TOOLTIP), SetFill(1, 0), SetResize(1, 0),
1843                 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_VD_DETAILS_CAPACITY_OF_EACH), SetMinimalSize(99, 12),
1844                                 SetDataTip(STR_VEHICLE_DETAIL_TAB_CAPACITIES, STR_VEHICLE_DETAILS_TRAIN_CAPACITIES_TOOLTIP), SetFill(1, 0), SetResize(1, 0),
1845                 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_VD_DETAILS_TOTAL_CARGO), SetMinimalSize(99, 12),
1846                                 SetDataTip(STR_VEHICLE_DETAIL_TAB_TOTAL_CARGO, STR_VEHICLE_DETAILS_TRAIN_TOTAL_CARGO_TOOLTIP), SetFill(1, 0), SetResize(1, 0),
1847                 NWidget(WWT_RESIZEBOX, COLOUR_GREY),
1848         EndContainer(),
1849 };
1850
1851
1852 extern int GetTrainDetailsWndVScroll(VehicleID veh_id, TrainDetailsWindowTabs det_tab);
1853 extern void DrawTrainDetails(const Train *v, int left, int right, int y, int vscroll_pos, uint16 vscroll_cap, TrainDetailsWindowTabs det_tab);
1854 extern void DrawRoadVehDetails(const Vehicle *v, int left, int right, int y);
1855 extern void DrawShipDetails(const Vehicle *v, int left, int right, int y);
1856 extern void DrawAircraftDetails(const Aircraft *v, int left, int right, int y);
1857
1858 static StringID _service_interval_dropdown[] = {
1859         STR_VEHICLE_DETAILS_DEFAULT,
1860         STR_VEHICLE_DETAILS_DAYS,
1861         STR_VEHICLE_DETAILS_PERCENT,
1862         INVALID_STRING_ID,
1863 };
1864
1865 /** Class for managing the vehicle details window. */
1866 struct VehicleDetailsWindow : Window {
1867         TrainDetailsWindowTabs tab; ///< For train vehicles: which tab is displayed.
1868         Scrollbar *vscroll;
1869
1870         /** Initialize a newly created vehicle details window */
1871         VehicleDetailsWindow(WindowDesc *desc, WindowNumber window_number) : Window(desc)
1872         {
1873                 const Vehicle *v = Vehicle::Get(window_number);
1874
1875                 this->CreateNestedTree();
1876                 this->vscroll = (v->type == VEH_TRAIN ? this->GetScrollbar(WID_VD_SCROLLBAR) : NULL);
1877                 this->FinishInitNested(window_number);
1878
1879                 this->GetWidget<NWidgetCore>(WID_VD_RENAME_VEHICLE)->tool_tip = STR_VEHICLE_DETAILS_TRAIN_RENAME + v->type;
1880
1881                 this->owner = v->owner;
1882                 this->tab = TDW_TAB_CARGO;
1883         }
1884
1885         /**
1886          * Some data on this window has become invalid.
1887          * @param data Information about the changed data.
1888          * @param gui_scope Whether the call is done from GUI scope. You may not do everything when not in GUI scope. See #InvalidateWindowData() for details.
1889          */
1890         virtual void OnInvalidateData(int data = 0, bool gui_scope = true)
1891         {
1892                 if (data == VIWD_AUTOREPLACE) {
1893                         /* Autoreplace replaced the vehicle.
1894                          * Nothing to do for this window. */
1895                         return;
1896                 }
1897                 if (!gui_scope) return;
1898                 const Vehicle *v = Vehicle::Get(this->window_number);
1899                 if (v->type == VEH_ROAD) {
1900                         const NWidgetBase *nwid_info = this->GetWidget<NWidgetBase>(WID_VD_MIDDLE_DETAILS);
1901                         uint aimed_height = this->GetRoadVehDetailsHeight(v);
1902                         /* If the number of articulated parts changes, the size of the window must change too. */
1903                         if (aimed_height != nwid_info->current_y) {
1904                                 this->ReInit();
1905                         }
1906                 }
1907         }
1908
1909         /**
1910          * Gets the desired height for the road vehicle details panel.
1911          * @param v Road vehicle being shown.
1912          * @return Desired height in pixels.
1913          */
1914         uint GetRoadVehDetailsHeight(const Vehicle *v)
1915         {
1916                 uint desired_height;
1917                 if (v->HasArticulatedPart()) {
1918                         /* An articulated RV has its text drawn under the sprite instead of after it, hence 15 pixels extra. */
1919                         desired_height = WD_FRAMERECT_TOP + ScaleGUITrad(15) + 3 * FONT_HEIGHT_NORMAL + 2 + WD_FRAMERECT_BOTTOM;
1920                         /* Add space for the cargo amount for each part. */
1921                         for (const Vehicle *u = v; u != NULL; u = u->Next()) {
1922                                 if (u->cargo_cap != 0) desired_height += FONT_HEIGHT_NORMAL + 1;
1923                         }
1924                 } else {
1925                         desired_height = WD_FRAMERECT_TOP + 4 * FONT_HEIGHT_NORMAL + 3 + WD_FRAMERECT_BOTTOM;
1926                 }
1927                 return desired_height;
1928         }
1929
1930         virtual void UpdateWidgetSize(int widget, Dimension *size, const Dimension &padding, Dimension *fill, Dimension *resize)
1931         {
1932                 switch (widget) {
1933                         case WID_VD_TOP_DETAILS: {
1934                                 Dimension dim = { 0, 0 };
1935                                 size->height = WD_FRAMERECT_TOP + 4 * FONT_HEIGHT_NORMAL + WD_FRAMERECT_BOTTOM;
1936
1937                                 for (uint i = 0; i < 4; i++) SetDParamMaxValue(i, INT16_MAX);
1938                                 static const StringID info_strings[] = {
1939                                         STR_VEHICLE_INFO_MAX_SPEED,
1940                                         STR_VEHICLE_INFO_WEIGHT_POWER_MAX_SPEED,
1941                                         STR_VEHICLE_INFO_WEIGHT_POWER_MAX_SPEED_MAX_TE,
1942                                         STR_VEHICLE_INFO_PROFIT_THIS_YEAR_LAST_YEAR,
1943                                         STR_VEHICLE_INFO_RELIABILITY_BREAKDOWNS
1944                                 };
1945                                 for (uint i = 0; i < lengthof(info_strings); i++) {
1946                                         dim = maxdim(dim, GetStringBoundingBox(info_strings[i]));
1947                                 }
1948                                 SetDParam(0, STR_VEHICLE_INFO_AGE);
1949                                 dim = maxdim(dim, GetStringBoundingBox(STR_VEHICLE_INFO_AGE_RUNNING_COST_YR));
1950                                 size->width = dim.width + WD_FRAMERECT_LEFT + WD_FRAMERECT_RIGHT;
1951                                 break;
1952                         }
1953
1954                         case WID_VD_MIDDLE_DETAILS: {
1955                                 const Vehicle *v = Vehicle::Get(this->window_number);
1956                                 switch (v->type) {
1957                                         case VEH_ROAD:
1958                                                 size->height = this->GetRoadVehDetailsHeight(v);
1959                                                 break;
1960
1961                                         case VEH_SHIP:
1962                                                 size->height = WD_FRAMERECT_TOP + 4 * FONT_HEIGHT_NORMAL + 3 + WD_FRAMERECT_BOTTOM;
1963                                                 break;
1964
1965                                         case VEH_AIRCRAFT:
1966                                                 size->height = WD_FRAMERECT_TOP + 5 * FONT_HEIGHT_NORMAL + 4 + WD_FRAMERECT_BOTTOM;
1967                                                 break;
1968
1969                                         default:
1970                                                 NOT_REACHED(); // Train uses WID_VD_MATRIX instead.
1971                                 }
1972                                 break;
1973                         }
1974
1975                         case WID_VD_MATRIX:
1976                                 resize->height = max(ScaleGUITrad(14), WD_MATRIX_TOP + FONT_HEIGHT_NORMAL + WD_MATRIX_BOTTOM);
1977                                 size->height = 4 * resize->height;
1978                                 break;
1979
1980                         case WID_VD_SERVICE_INTERVAL_DROPDOWN: {
1981                                 StringID *strs = _service_interval_dropdown;
1982                                 while (*strs != INVALID_STRING_ID) {
1983                                         *size = maxdim(*size, GetStringBoundingBox(*strs++));
1984                                 }
1985                                 size->width += padding.width;
1986                                 size->height = FONT_HEIGHT_NORMAL + WD_DROPDOWNTEXT_TOP + WD_DROPDOWNTEXT_BOTTOM;
1987                                 break;
1988                         }
1989
1990                         case WID_VD_SERVICING_INTERVAL:
1991                                 SetDParamMaxValue(0, MAX_SERVINT_DAYS); // Roughly the maximum interval
1992                                 SetDParamMaxValue(1, MAX_YEAR * DAYS_IN_YEAR); // Roughly the maximum year
1993                                 size->width = max(GetStringBoundingBox(STR_VEHICLE_DETAILS_SERVICING_INTERVAL_PERCENT).width, GetStringBoundingBox(STR_VEHICLE_DETAILS_SERVICING_INTERVAL_DAYS).width) + WD_FRAMERECT_LEFT + WD_FRAMERECT_RIGHT;
1994                                 size->height = WD_FRAMERECT_TOP + FONT_HEIGHT_NORMAL + WD_FRAMERECT_BOTTOM;
1995                                 break;
1996                 }
1997         }
1998
1999         /** Checks whether service interval is enabled for the vehicle. */
2000         static bool IsVehicleServiceIntervalEnabled(const VehicleType vehicle_type, CompanyID company_id)
2001         {
2002                 const VehicleDefaultSettings *vds = &Company::Get(company_id)->settings.vehicle;
2003                 switch (vehicle_type) {
2004                         default: NOT_REACHED();
2005                         case VEH_TRAIN:    return vds->servint_trains   != 0;
2006                         case VEH_ROAD:     return vds->servint_roadveh  != 0;
2007                         case VEH_SHIP:     return vds->servint_ships    != 0;
2008                         case VEH_AIRCRAFT: return vds->servint_aircraft != 0;
2009                 }
2010         }
2011
2012         /**
2013          * Draw the details for the given vehicle at the position of the Details windows
2014          *
2015          * @param v     current vehicle
2016          * @param left  The left most coordinate to draw
2017          * @param right The right most coordinate to draw
2018          * @param y     The y coordinate
2019          * @param vscroll_pos Position of scrollbar (train only)
2020          * @param vscroll_cap Number of lines currently displayed (train only)
2021          * @param det_tab Selected details tab (train only)
2022          */
2023         static void DrawVehicleDetails(const Vehicle *v, int left, int right, int y, int vscroll_pos, uint vscroll_cap, TrainDetailsWindowTabs det_tab)
2024         {
2025                 switch (v->type) {
2026                         case VEH_TRAIN:    DrawTrainDetails(Train::From(v), left, right, y, vscroll_pos, vscroll_cap, det_tab);  break;
2027                         case VEH_ROAD:     DrawRoadVehDetails(v, left, right, y);  break;
2028                         case VEH_SHIP:     DrawShipDetails(v, left, right, y);     break;
2029                         case VEH_AIRCRAFT: DrawAircraftDetails(Aircraft::From(v), left, right, y); break;
2030                         default: NOT_REACHED();
2031                 }
2032         }
2033
2034         virtual void SetStringParameters(int widget) const
2035         {
2036                 if (widget == WID_VD_CAPTION) SetDParam(0, Vehicle::Get(this->window_number)->index);
2037         }
2038
2039         virtual void DrawWidget(const Rect &r, int widget) const
2040         {
2041                 const Vehicle *v = Vehicle::Get(this->window_number);
2042
2043                 switch (widget) {
2044                         case WID_VD_TOP_DETAILS: {
2045                                 int y = r.top + WD_FRAMERECT_TOP;
2046
2047                                 /* Draw running cost */
2048                                 SetDParam(1, v->age / DAYS_IN_LEAP_YEAR);
2049                                 SetDParam(0, (v->age + DAYS_IN_YEAR < v->max_age) ? STR_VEHICLE_INFO_AGE : STR_VEHICLE_INFO_AGE_RED);
2050                                 SetDParam(2, v->max_age / DAYS_IN_LEAP_YEAR);
2051                                 SetDParam(3, v->GetDisplayRunningCost());
2052                                 DrawString(r.left + WD_FRAMERECT_LEFT, r.right - WD_FRAMERECT_RIGHT, y, STR_VEHICLE_INFO_AGE_RUNNING_COST_YR);
2053                                 y += FONT_HEIGHT_NORMAL;
2054
2055                                 /* Draw max speed */
2056                                 StringID string;
2057                                 if (v->type == VEH_TRAIN ||
2058                                                 (v->type == VEH_ROAD && _settings_game.vehicle.roadveh_acceleration_model != AM_ORIGINAL)) {
2059                                         const GroundVehicleCache *gcache = v->GetGroundVehicleCache();
2060                                         SetDParam(2, v->GetDisplayMaxSpeed());
2061                                         SetDParam(1, gcache->cached_power);
2062                                         SetDParam(0, gcache->cached_weight);
2063                                         SetDParam(3, gcache->cached_max_te / 1000);
2064                                         if (v->type == VEH_TRAIN && (_settings_game.vehicle.train_acceleration_model == AM_ORIGINAL ||
2065                                                         GetRailTypeInfo(Train::From(v)->railtype)->acceleration_type == 2)) {
2066                                                 string = STR_VEHICLE_INFO_WEIGHT_POWER_MAX_SPEED;
2067                                         } else {
2068                                                 string = STR_VEHICLE_INFO_WEIGHT_POWER_MAX_SPEED_MAX_TE;
2069                                         }
2070                                 } else {
2071                                         SetDParam(0, v->GetDisplayMaxSpeed());
2072                                         if (v->type == VEH_AIRCRAFT) {
2073                                                 SetDParam(1, v->GetEngine()->GetAircraftTypeText());
2074                                                 if (Aircraft::From(v)->GetRange() > 0) {
2075                                                         SetDParam(2, Aircraft::From(v)->GetRange());
2076                                                         string = STR_VEHICLE_INFO_MAX_SPEED_TYPE_RANGE;
2077                                                 } else {
2078                                                         string = STR_VEHICLE_INFO_MAX_SPEED_TYPE;
2079                                                 }
2080                                         } else {
2081                                                 string = STR_VEHICLE_INFO_MAX_SPEED;
2082                                         }
2083                                 }
2084                                 DrawString(r.left + WD_FRAMERECT_LEFT, r.right - WD_FRAMERECT_RIGHT, y, string);
2085                                 y += FONT_HEIGHT_NORMAL;
2086
2087                                 /* Draw profit */
2088                                 SetDParam(0, v->GetDisplayProfitThisYear());
2089                                 SetDParam(1, v->GetDisplayProfitLastYear());
2090                                 DrawString(r.left + WD_FRAMERECT_LEFT, r.right - WD_FRAMERECT_RIGHT, y, STR_VEHICLE_INFO_PROFIT_THIS_YEAR_LAST_YEAR);
2091                                 y += FONT_HEIGHT_NORMAL;
2092
2093                                 /* Draw breakdown & reliability */
2094                                 SetDParam(0, ToPercent16(v->reliability));
2095                                 SetDParam(1, v->breakdowns_since_last_service);
2096                                 DrawString(r.left + WD_FRAMERECT_LEFT, r.right - WD_FRAMERECT_RIGHT, y, STR_VEHICLE_INFO_RELIABILITY_BREAKDOWNS);
2097                                 break;
2098                         }
2099
2100                         case WID_VD_MATRIX:
2101                                 /* For trains only. */
2102                                 DrawVehicleDetails(v, r.left + WD_MATRIX_LEFT, r.right - WD_MATRIX_RIGHT, r.top + WD_MATRIX_TOP, this->vscroll->GetPosition(), this->vscroll->GetCapacity(), this->tab);
2103                                 break;
2104
2105                         case WID_VD_MIDDLE_DETAILS: {
2106                                 /* For other vehicles, at the place of the matrix. */
2107                                 bool rtl = _current_text_dir == TD_RTL;
2108                                 uint sprite_width = GetSingleVehicleWidth(v, EIT_IN_DETAILS) + WD_FRAMERECT_LEFT + WD_FRAMERECT_RIGHT;
2109
2110                                 uint text_left  = r.left  + (rtl ? 0 : sprite_width);
2111                                 uint text_right = r.right - (rtl ? sprite_width : 0);
2112
2113                                 /* Articulated road vehicles use a complete line. */
2114                                 if (v->type == VEH_ROAD && v->HasArticulatedPart()) {
2115                                         DrawVehicleImage(v, r.left + WD_FRAMERECT_LEFT, r.right - WD_FRAMERECT_RIGHT, r.top + WD_FRAMERECT_TOP, INVALID_VEHICLE, EIT_IN_DETAILS, 0);
2116                                 } else {
2117                                         uint sprite_left  = rtl ? text_right : r.left;
2118                                         uint sprite_right = rtl ? r.right : text_left;
2119
2120                                         DrawVehicleImage(v, sprite_left + WD_FRAMERECT_LEFT, sprite_right - WD_FRAMERECT_RIGHT, r.top + WD_FRAMERECT_TOP, INVALID_VEHICLE, EIT_IN_DETAILS, 0);
2121                                 }
2122                                 DrawVehicleDetails(v, text_left + WD_FRAMERECT_LEFT, text_right - WD_FRAMERECT_RIGHT, r.top + WD_FRAMERECT_TOP, 0, 0, this->tab);
2123                                 break;
2124                         }
2125
2126                         case WID_VD_SERVICING_INTERVAL:
2127                                 /* Draw service interval text */
2128                                 SetDParam(0, v->GetServiceInterval());
2129                                 SetDParam(1, v->date_of_last_service);
2130                                 DrawString(r.left + WD_FRAMERECT_LEFT, r.right - WD_FRAMERECT_RIGHT, r.top + (r.bottom - r.top + 1 - FONT_HEIGHT_NORMAL) / 2,
2131                                                 v->ServiceIntervalIsPercent() ? STR_VEHICLE_DETAILS_SERVICING_INTERVAL_PERCENT : STR_VEHICLE_DETAILS_SERVICING_INTERVAL_DAYS);
2132                                 break;
2133                 }
2134         }
2135
2136         /** Repaint vehicle details window. */
2137         virtual void OnPaint()
2138         {
2139                 const Vehicle *v = Vehicle::Get(this->window_number);
2140
2141                 this->SetWidgetDisabledState(WID_VD_RENAME_VEHICLE, v->owner != _local_company);
2142
2143                 if (v->type == VEH_TRAIN) {
2144                         this->DisableWidget(this->tab + WID_VD_DETAILS_CARGO_CARRIED);
2145                         this->vscroll->SetCount(GetTrainDetailsWndVScroll(v->index, this->tab));
2146                 }
2147
2148                 /* Disable service-scroller when interval is set to disabled */
2149                 this->SetWidgetsDisabledState(!IsVehicleServiceIntervalEnabled(v->type, v->owner),
2150                         WID_VD_INCREASE_SERVICING_INTERVAL,
2151                         WID_VD_DECREASE_SERVICING_INTERVAL,
2152                         WIDGET_LIST_END);
2153
2154                 StringID str = v->ServiceIntervalIsCustom() ?
2155                         (v->ServiceIntervalIsPercent() ? STR_VEHICLE_DETAILS_PERCENT : STR_VEHICLE_DETAILS_DAYS) :
2156                         STR_VEHICLE_DETAILS_DEFAULT;
2157                 this->GetWidget<NWidgetCore>(WID_VD_SERVICE_INTERVAL_DROPDOWN)->widget_data = str;
2158
2159                 this->DrawWidgets();
2160         }
2161
2162         virtual void OnClick(Point pt, int widget, int click_count)
2163         {
2164                 switch (widget) {
2165                         case WID_VD_RENAME_VEHICLE: { // rename
2166                                 const Vehicle *v = Vehicle::Get(this->window_number);
2167                                 SetDParam(0, v->index);
2168                                 ShowQueryString(STR_VEHICLE_NAME, STR_QUERY_RENAME_TRAIN_CAPTION + v->type,
2169                                                 MAX_LENGTH_VEHICLE_NAME_CHARS, this, CS_ALPHANUMERAL, QSF_ENABLE_DEFAULT | QSF_LEN_IN_CHARS);
2170                                 break;
2171                         }
2172
2173                         case WID_VD_INCREASE_SERVICING_INTERVAL:   // increase int
2174                         case WID_VD_DECREASE_SERVICING_INTERVAL: { // decrease int
2175                                 int mod = _ctrl_pressed ? 5 : 10;
2176                                 const Vehicle *v = Vehicle::Get(this->window_number);
2177
2178                                 mod = (widget == WID_VD_DECREASE_SERVICING_INTERVAL) ? -mod : mod;
2179                                 mod = GetServiceIntervalClamped(mod + v->GetServiceInterval(), v->ServiceIntervalIsPercent());
2180                                 if (mod == v->GetServiceInterval()) return;
2181
2182                                 DoCommandP(v->tile, v->index, mod | (1 << 16) | (v->ServiceIntervalIsPercent() << 17), CMD_CHANGE_SERVICE_INT | CMD_MSG(STR_ERROR_CAN_T_CHANGE_SERVICING));
2183                                 break;
2184                         }
2185
2186                         case WID_VD_SERVICE_INTERVAL_DROPDOWN: {
2187                                 const Vehicle *v = Vehicle::Get(this->window_number);
2188                                 ShowDropDownMenu(this, _service_interval_dropdown, v->ServiceIntervalIsCustom() ? (v->ServiceIntervalIsPercent() ? 2 : 1) : 0, widget, 0, 0);
2189                                 break;
2190                         }
2191
2192                         case WID_VD_DETAILS_CARGO_CARRIED:
2193                         case WID_VD_DETAILS_TRAIN_VEHICLES:
2194                         case WID_VD_DETAILS_CAPACITY_OF_EACH:
2195                         case WID_VD_DETAILS_TOTAL_CARGO:
2196                                 this->SetWidgetsDisabledState(false,
2197                                         WID_VD_DETAILS_CARGO_CARRIED,
2198                                         WID_VD_DETAILS_TRAIN_VEHICLES,
2199                                         WID_VD_DETAILS_CAPACITY_OF_EACH,
2200                                         WID_VD_DETAILS_TOTAL_CARGO,
2201                                         widget,
2202                                         WIDGET_LIST_END);
2203
2204                                 this->tab = (TrainDetailsWindowTabs)(widget - WID_VD_DETAILS_CARGO_CARRIED);
2205                                 this->SetDirty();
2206                                 break;
2207                 }
2208         }
2209
2210         virtual void OnDropdownSelect(int widget, int index)
2211         {
2212                 switch (widget) {
2213                         case WID_VD_SERVICE_INTERVAL_DROPDOWN: {
2214                                 const Vehicle *v = Vehicle::Get(this->window_number);
2215                                 bool iscustom = index != 0;
2216                                 bool ispercent = iscustom ? (index == 2) : Company::Get(v->owner)->settings.vehicle.servint_ispercent;
2217                                 uint16 interval = GetServiceIntervalClamped(v->GetServiceInterval(), ispercent);
2218                                 DoCommandP(v->tile, v->index, interval | (iscustom << 16) | (ispercent << 17), CMD_CHANGE_SERVICE_INT | CMD_MSG(STR_ERROR_CAN_T_CHANGE_SERVICING));
2219                                 break;
2220                         }
2221                 }
2222         }
2223
2224         virtual void OnQueryTextFinished(char *str)
2225         {
2226                 if (str == NULL) return;
2227
2228                 DoCommandP(0, this->window_number, 0, CMD_RENAME_VEHICLE | CMD_MSG(STR_ERROR_CAN_T_RENAME_TRAIN + Vehicle::Get(this->window_number)->type), NULL, str);
2229         }
2230
2231         virtual void OnResize()
2232         {
2233                 NWidgetCore *nwi = this->GetWidget<NWidgetCore>(WID_VD_MATRIX);
2234                 if (nwi != NULL) {
2235                         this->vscroll->SetCapacityFromWidget(this, WID_VD_MATRIX);
2236                 }
2237         }
2238 };
2239
2240 /** Vehicle details window descriptor. */
2241 static WindowDesc _train_vehicle_details_desc(
2242         WDP_AUTO, "view_vehicle_details_train", 405, 178,
2243         WC_VEHICLE_DETAILS, WC_VEHICLE_VIEW,
2244         0,
2245         _nested_train_vehicle_details_widgets, lengthof(_nested_train_vehicle_details_widgets)
2246 );
2247
2248 /** Vehicle details window descriptor for other vehicles than a train. */
2249 static WindowDesc _nontrain_vehicle_details_desc(
2250         WDP_AUTO, "view_vehicle_details", 405, 113,
2251         WC_VEHICLE_DETAILS, WC_VEHICLE_VIEW,
2252         0,
2253         _nested_nontrain_vehicle_details_widgets, lengthof(_nested_nontrain_vehicle_details_widgets)
2254 );
2255
2256 /** Shows the vehicle details window of the given vehicle. */
2257 static void ShowVehicleDetailsWindow(const Vehicle *v)
2258 {
2259         DeleteWindowById(WC_VEHICLE_ORDERS, v->index, false);
2260         DeleteWindowById(WC_VEHICLE_TIMETABLE, v->index, false);
2261         AllocateWindowDescFront<VehicleDetailsWindow>((v->type == VEH_TRAIN) ? &_train_vehicle_details_desc : &_nontrain_vehicle_details_desc, v->index);
2262 }
2263
2264
2265 /* Unified vehicle GUI - Vehicle View Window */
2266
2267 /** Vehicle view widgets. */
2268 static const NWidgetPart _nested_vehicle_view_widgets[] = {
2269         NWidget(NWID_HORIZONTAL),
2270                 NWidget(WWT_CLOSEBOX, COLOUR_GREY),
2271                 NWidget(WWT_CAPTION, COLOUR_GREY, WID_VV_CAPTION), SetDataTip(STR_VEHICLE_VIEW_CAPTION, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
2272                 NWidget(WWT_DEBUGBOX, COLOUR_GREY),
2273                 NWidget(WWT_SHADEBOX, COLOUR_GREY),
2274                 NWidget(WWT_DEFSIZEBOX, COLOUR_GREY),
2275                 NWidget(WWT_STICKYBOX, COLOUR_GREY),
2276         EndContainer(),
2277         NWidget(NWID_HORIZONTAL),
2278                 NWidget(WWT_PANEL, COLOUR_GREY),
2279                         NWidget(WWT_INSET, COLOUR_GREY), SetPadding(2, 2, 2, 2),
2280                                 NWidget(NWID_VIEWPORT, INVALID_COLOUR, WID_VV_VIEWPORT), SetMinimalSize(226, 84), SetResize(1, 1), SetPadding(1, 1, 1, 1),
2281                         EndContainer(),
2282                 EndContainer(),
2283                 NWidget(NWID_VERTICAL),
2284                         NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_VV_CENTER_MAIN_VIEW), SetMinimalSize(18, 18), SetDataTip(SPR_CENTRE_VIEW_VEHICLE, 0x0 /* filled later */),
2285                         NWidget(NWID_SELECTION, INVALID_COLOUR, WID_VV_SELECT_DEPOT_CLONE),
2286                                 NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_VV_GOTO_DEPOT), SetMinimalSize(18, 18), SetDataTip(0x0 /* filled later */, 0x0 /* filled later */),
2287                                 NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_VV_CLONE), SetMinimalSize(18, 18), SetDataTip(0x0 /* filled later */, 0x0 /* filled later */),
2288                         EndContainer(),
2289                         /* For trains only, 'ignore signal' button. */
2290                         NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_VV_FORCE_PROCEED), SetMinimalSize(18, 18),
2291                                                                                         SetDataTip(SPR_IGNORE_SIGNALS, STR_VEHICLE_VIEW_TRAIN_IGNORE_SIGNAL_TOOLTIP),
2292                         NWidget(NWID_SELECTION, INVALID_COLOUR, WID_VV_SELECT_REFIT_TURN),
2293                                 NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_VV_REFIT), SetMinimalSize(18, 18), SetDataTip(SPR_REFIT_VEHICLE, 0x0 /* filled later */),
2294                                 NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_VV_TURN_AROUND), SetMinimalSize(18, 18),
2295                                                                                                 SetDataTip(SPR_FORCE_VEHICLE_TURN, STR_VEHICLE_VIEW_ROAD_VEHICLE_REVERSE_TOOLTIP),
2296                         EndContainer(),
2297                         NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_VV_SHOW_ORDERS), SetMinimalSize(18, 18), SetDataTip(SPR_SHOW_ORDERS, 0x0 /* filled later */),
2298                         NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_VV_SHOW_DETAILS), SetMinimalSize(18, 18), SetDataTip(SPR_SHOW_VEHICLE_DETAILS, 0x0 /* filled later */),
2299                         NWidget(WWT_PANEL, COLOUR_GREY), SetMinimalSize(18, 0), SetResize(0, 1), EndContainer(),
2300                 EndContainer(),
2301         EndContainer(),
2302         NWidget(NWID_HORIZONTAL),
2303                 NWidget(WWT_PUSHBTN, COLOUR_GREY, WID_VV_START_STOP), SetMinimalTextLines(1, WD_FRAMERECT_TOP + WD_FRAMERECT_BOTTOM + 2), SetResize(1, 0), SetFill(1, 0),
2304                 NWidget(WWT_RESIZEBOX, COLOUR_GREY),
2305         EndContainer(),
2306 };
2307
2308 /** Vehicle view window descriptor for all vehicles but trains. */
2309 static WindowDesc _vehicle_view_desc(
2310         WDP_AUTO, "view_vehicle", 250, 116,
2311         WC_VEHICLE_VIEW, WC_NONE,
2312         0,
2313         _nested_vehicle_view_widgets, lengthof(_nested_vehicle_view_widgets)
2314 );
2315
2316 /**
2317  * Vehicle view window descriptor for trains. Only minimum_height and
2318  *  default_height are different for train view.
2319  */
2320 static WindowDesc _train_view_desc(
2321         WDP_AUTO, "view_vehicle_train", 250, 134,
2322         WC_VEHICLE_VIEW, WC_NONE,
2323         0,
2324         _nested_vehicle_view_widgets, lengthof(_nested_vehicle_view_widgets)
2325 );
2326
2327
2328 /* Just to make sure, nobody has changed the vehicle type constants, as we are
2329          using them for array indexing in a number of places here. */
2330 assert_compile(VEH_TRAIN == 0);
2331 assert_compile(VEH_ROAD == 1);
2332 assert_compile(VEH_SHIP == 2);
2333 assert_compile(VEH_AIRCRAFT == 3);
2334
2335 /** Zoom levels for vehicle views indexed by vehicle type. */
2336 static const ZoomLevel _vehicle_view_zoom_levels[] = {
2337         ZOOM_LVL_TRAIN,
2338         ZOOM_LVL_ROADVEH,
2339         ZOOM_LVL_SHIP,
2340         ZOOM_LVL_AIRCRAFT,
2341 };
2342
2343 /* Constants for geometry of vehicle view viewport */
2344 static const int VV_INITIAL_VIEWPORT_WIDTH = 226;
2345 static const int VV_INITIAL_VIEWPORT_HEIGHT = 84;
2346 static const int VV_INITIAL_VIEWPORT_HEIGHT_TRAIN = 102;
2347
2348 /** Command indices for the _vehicle_command_translation_table. */
2349 enum VehicleCommandTranslation {
2350         VCT_CMD_START_STOP = 0,
2351         VCT_CMD_CLONE_VEH,
2352         VCT_CMD_TURN_AROUND,
2353 };
2354
2355 /** Command codes for the shared buttons indexed by VehicleCommandTranslation and vehicle type. */
2356 static const uint32 _vehicle_command_translation_table[][4] = {
2357         { // VCT_CMD_START_STOP
2358                 CMD_START_STOP_VEHICLE | CMD_MSG(STR_ERROR_CAN_T_STOP_START_TRAIN),
2359                 CMD_START_STOP_VEHICLE | CMD_MSG(STR_ERROR_CAN_T_STOP_START_ROAD_VEHICLE),
2360                 CMD_START_STOP_VEHICLE | CMD_MSG(STR_ERROR_CAN_T_STOP_START_SHIP),
2361                 CMD_START_STOP_VEHICLE | CMD_MSG(STR_ERROR_CAN_T_STOP_START_AIRCRAFT)
2362         },
2363         { // VCT_CMD_CLONE_VEH
2364                 CMD_CLONE_VEHICLE | CMD_MSG(STR_ERROR_CAN_T_BUY_TRAIN),
2365                 CMD_CLONE_VEHICLE | CMD_MSG(STR_ERROR_CAN_T_BUY_ROAD_VEHICLE),
2366                 CMD_CLONE_VEHICLE | CMD_MSG(STR_ERROR_CAN_T_BUY_SHIP),
2367                 CMD_CLONE_VEHICLE | CMD_MSG(STR_ERROR_CAN_T_BUY_AIRCRAFT)
2368         },
2369         { // VCT_CMD_TURN_AROUND
2370                 CMD_REVERSE_TRAIN_DIRECTION | CMD_MSG(STR_ERROR_CAN_T_REVERSE_DIRECTION_TRAIN),
2371                 CMD_TURN_ROADVEH            | CMD_MSG(STR_ERROR_CAN_T_MAKE_ROAD_VEHICLE_TURN),
2372                 0xffffffff, // invalid for ships
2373                 0xffffffff  // invalid for aircrafts
2374         },
2375 };
2376
2377 /**
2378  * This is the Callback method after attempting to start/stop a vehicle
2379  * @param result the result of the start/stop command
2380  * @param tile unused
2381  * @param p1 vehicle ID
2382  * @param p2 unused
2383  */
2384 void CcStartStopVehicle(const CommandCost &result, TileIndex tile, uint32 p1, uint32 p2)
2385 {
2386         if (result.Failed()) return;
2387
2388         const Vehicle *v = Vehicle::GetIfValid(p1);
2389         if (v == NULL || !v->IsPrimaryVehicle() || v->owner != _local_company) return;
2390
2391         StringID msg = (v->vehstatus & VS_STOPPED) ? STR_VEHICLE_COMMAND_STOPPED : STR_VEHICLE_COMMAND_STARTED;
2392         Point pt = RemapCoords(v->x_pos, v->y_pos, v->z_pos);
2393         AddTextEffect(msg, pt.x, pt.y, DAY_TICKS, TE_RISING);
2394 }
2395
2396 /**
2397  * Executes #CMD_START_STOP_VEHICLE for given vehicle.
2398  * @param v Vehicle to start/stop
2399  * @param texteffect Should a texteffect be shown?
2400  */
2401 void StartStopVehicle(const Vehicle *v, bool texteffect)
2402 {
2403         assert(v->IsPrimaryVehicle());
2404         DoCommandP(v->tile, v->index, 0, _vehicle_command_translation_table[VCT_CMD_START_STOP][v->type], texteffect ? CcStartStopVehicle : NULL);
2405 }
2406
2407 /** Checks whether the vehicle may be refitted at the moment.*/
2408 static bool IsVehicleRefitable(const Vehicle *v)
2409 {
2410         if (!v->IsStoppedInDepot()) return false;
2411
2412         do {
2413                 if (IsEngineRefittable(v->engine_type)) return true;
2414         } while (v->IsGroundVehicle() && (v = v->Next()) != NULL);
2415
2416         return false;
2417 }
2418
2419 /** Window manager class for viewing a vehicle. */
2420 struct VehicleViewWindow : Window {
2421 private:
2422         /** Display planes available in the vehicle view window. */
2423         enum PlaneSelections {
2424                 SEL_DC_GOTO_DEPOT,  ///< Display 'goto depot' button in #WID_VV_SELECT_DEPOT_CLONE stacked widget.
2425                 SEL_DC_CLONE,       ///< Display 'clone vehicle' button in #WID_VV_SELECT_DEPOT_CLONE stacked widget.
2426
2427                 SEL_RT_REFIT,       ///< Display 'refit' button in #WID_VV_SELECT_REFIT_TURN stacked widget.
2428                 SEL_RT_TURN_AROUND, ///< Display 'turn around' button in #WID_VV_SELECT_REFIT_TURN stacked widget.
2429
2430                 SEL_DC_BASEPLANE = SEL_DC_GOTO_DEPOT, ///< First plane of the #WID_VV_SELECT_DEPOT_CLONE stacked widget.
2431                 SEL_RT_BASEPLANE = SEL_RT_REFIT,      ///< First plane of the #WID_VV_SELECT_REFIT_TURN stacked widget.
2432         };
2433
2434         /**
2435          * Display a plane in the window.
2436          * @param plane Plane to show.
2437          */
2438         void SelectPlane(PlaneSelections plane)
2439         {
2440                 switch (plane) {
2441                         case SEL_DC_GOTO_DEPOT:
2442                         case SEL_DC_CLONE:
2443                                 this->GetWidget<NWidgetStacked>(WID_VV_SELECT_DEPOT_CLONE)->SetDisplayedPlane(plane - SEL_DC_BASEPLANE);
2444                                 break;
2445
2446                         case SEL_RT_REFIT:
2447                         case SEL_RT_TURN_AROUND:
2448                                 this->GetWidget<NWidgetStacked>(WID_VV_SELECT_REFIT_TURN)->SetDisplayedPlane(plane - SEL_RT_BASEPLANE);
2449                                 break;
2450
2451                         default:
2452                                 NOT_REACHED();
2453                 }
2454         }
2455
2456 public:
2457         VehicleViewWindow(WindowDesc *desc, WindowNumber window_number) : Window(desc)
2458         {
2459                 this->flags |= WF_DISABLE_VP_SCROLL;
2460                 this->CreateNestedTree();
2461
2462                 /* Sprites for the 'send to depot' button indexed by vehicle type. */
2463                 static const SpriteID vehicle_view_goto_depot_sprites[] = {
2464                         SPR_SEND_TRAIN_TODEPOT,
2465                         SPR_SEND_ROADVEH_TODEPOT,
2466                         SPR_SEND_SHIP_TODEPOT,
2467                         SPR_SEND_AIRCRAFT_TODEPOT,
2468                 };
2469                 const Vehicle *v = Vehicle::Get(window_number);
2470                 this->GetWidget<NWidgetCore>(WID_VV_GOTO_DEPOT)->widget_data = vehicle_view_goto_depot_sprites[v->type];
2471
2472                 /* Sprites for the 'clone vehicle' button indexed by vehicle type. */
2473                 static const SpriteID vehicle_view_clone_sprites[] = {
2474                         SPR_CLONE_TRAIN,
2475                         SPR_CLONE_ROADVEH,
2476                         SPR_CLONE_SHIP,
2477                         SPR_CLONE_AIRCRAFT,
2478                 };
2479                 this->GetWidget<NWidgetCore>(WID_VV_CLONE)->widget_data = vehicle_view_clone_sprites[v->type];
2480
2481                 switch (v->type) {
2482                         case VEH_TRAIN:
2483                                 this->GetWidget<NWidgetCore>(WID_VV_TURN_AROUND)->tool_tip = STR_VEHICLE_VIEW_TRAIN_REVERSE_TOOLTIP;
2484                                 break;
2485
2486                         case VEH_ROAD:
2487                                 break;
2488
2489                         case VEH_SHIP:
2490                         case VEH_AIRCRAFT:
2491                                 this->SelectPlane(SEL_RT_REFIT);
2492                                 break;
2493
2494                         default: NOT_REACHED();
2495                 }
2496                 this->FinishInitNested(window_number);
2497                 this->owner = v->owner;
2498                 this->GetWidget<NWidgetViewport>(WID_VV_VIEWPORT)->InitializeViewport(this, this->window_number | (1 << 31), _vehicle_view_zoom_levels[v->type]);
2499
2500                 this->GetWidget<NWidgetCore>(WID_VV_START_STOP)->tool_tip       = STR_VEHICLE_VIEW_TRAIN_STATE_START_STOP_TOOLTIP + v->type;
2501                 this->GetWidget<NWidgetCore>(WID_VV_CENTER_MAIN_VIEW)->tool_tip = STR_VEHICLE_VIEW_TRAIN_LOCATION_TOOLTIP + v->type;
2502                 this->GetWidget<NWidgetCore>(WID_VV_REFIT)->tool_tip            = STR_VEHICLE_VIEW_TRAIN_REFIT_TOOLTIP + v->type;
2503                 this->GetWidget<NWidgetCore>(WID_VV_GOTO_DEPOT)->tool_tip       = STR_VEHICLE_VIEW_TRAIN_SEND_TO_DEPOT_TOOLTIP + v->type;
2504                 this->GetWidget<NWidgetCore>(WID_VV_SHOW_ORDERS)->tool_tip      = STR_VEHICLE_VIEW_TRAIN_ORDERS_TOOLTIP + v->type;
2505                 this->GetWidget<NWidgetCore>(WID_VV_SHOW_DETAILS)->tool_tip     = STR_VEHICLE_VIEW_TRAIN_SHOW_DETAILS_TOOLTIP + v->type;
2506                 this->GetWidget<NWidgetCore>(WID_VV_CLONE)->tool_tip            = STR_VEHICLE_VIEW_CLONE_TRAIN_INFO + v->type;
2507         }
2508
2509         ~VehicleViewWindow()
2510         {
2511                 DeleteWindowById(WC_VEHICLE_ORDERS, this->window_number, false);
2512                 DeleteWindowById(WC_VEHICLE_REFIT, this->window_number, false);
2513                 DeleteWindowById(WC_VEHICLE_DETAILS, this->window_number, false);
2514                 DeleteWindowById(WC_VEHICLE_TIMETABLE, this->window_number, false);
2515         }
2516
2517         virtual void UpdateWidgetSize(int widget, Dimension *size, const Dimension &padding, Dimension *fill, Dimension *resize)
2518         {
2519                 const Vehicle *v = Vehicle::Get(this->window_number);
2520                 switch (widget) {
2521                         case WID_VV_START_STOP:
2522                                 size->height = max(size->height, max(GetSpriteSize(SPR_FLAG_VEH_STOPPED).height, GetSpriteSize(SPR_FLAG_VEH_RUNNING).height) + WD_IMGBTN_TOP + WD_IMGBTN_BOTTOM);
2523                                 break;
2524
2525                         case WID_VV_FORCE_PROCEED:
2526                                 if (v->type != VEH_TRAIN) {
2527                                         size->height = 0;
2528                                         size->width = 0;
2529                                 }
2530                                 break;
2531
2532                         case WID_VV_VIEWPORT:
2533                                 size->width = VV_INITIAL_VIEWPORT_WIDTH;
2534                                 size->height = (v->type == VEH_TRAIN) ? VV_INITIAL_VIEWPORT_HEIGHT_TRAIN : VV_INITIAL_VIEWPORT_HEIGHT;
2535                                 break;
2536                 }
2537         }
2538
2539         virtual void OnPaint()
2540         {
2541                 const Vehicle *v = Vehicle::Get(this->window_number);
2542                 bool is_localcompany = v->owner == _local_company;
2543                 bool refitable_and_stopped_in_depot = IsVehicleRefitable(v);
2544
2545                 this->SetWidgetDisabledState(WID_VV_GOTO_DEPOT, !is_localcompany);
2546                 this->SetWidgetDisabledState(WID_VV_REFIT, !refitable_and_stopped_in_depot || !is_localcompany);
2547                 this->SetWidgetDisabledState(WID_VV_CLONE, !is_localcompany);
2548
2549                 if (v->type == VEH_TRAIN) {
2550                         this->SetWidgetLoweredState(WID_VV_FORCE_PROCEED, Train::From(v)->force_proceed == TFP_SIGNAL);
2551                         this->SetWidgetDisabledState(WID_VV_FORCE_PROCEED, !is_localcompany);
2552                         this->SetWidgetDisabledState(WID_VV_TURN_AROUND, !is_localcompany);
2553                 }
2554
2555                 this->DrawWidgets();
2556         }
2557
2558         virtual void SetStringParameters(int widget) const
2559         {
2560                 if (widget != WID_VV_CAPTION) return;
2561
2562                 const Vehicle *v = Vehicle::Get(this->window_number);
2563                 SetDParam(0, v->index);
2564         }
2565
2566         virtual void DrawWidget(const Rect &r, int widget) const
2567         {
2568                 if (widget != WID_VV_START_STOP) return;
2569
2570                 const Vehicle *v = Vehicle::Get(this->window_number);
2571                 StringID str;
2572                 if (v->vehstatus & VS_CRASHED) {
2573                         str = STR_VEHICLE_STATUS_CRASHED;
2574                 } else if (v->type != VEH_AIRCRAFT && v->breakdown_ctr == 1) { // check for aircraft necessary?
2575                         str = STR_VEHICLE_STATUS_BROKEN_DOWN;
2576                 } else if (v->vehstatus & VS_STOPPED) {
2577                         if (v->type == VEH_TRAIN) {
2578                                 if (v->cur_speed == 0) {
2579                                         if (Train::From(v)->gcache.cached_power == 0) {
2580                                                 str = STR_VEHICLE_STATUS_TRAIN_NO_POWER;
2581                                         } else {
2582                                                 str = STR_VEHICLE_STATUS_STOPPED;
2583                                         }
2584                                 } else {
2585                                         SetDParam(0, v->GetDisplaySpeed());
2586                                         str = STR_VEHICLE_STATUS_TRAIN_STOPPING_VEL;
2587                                 }
2588                         } else { // no train
2589                                 str = STR_VEHICLE_STATUS_STOPPED;
2590                         }
2591                 } else if (v->type == VEH_TRAIN && HasBit(Train::From(v)->flags, VRF_TRAIN_STUCK) && !v->current_order.IsType(OT_LOADING)) {
2592                         str = STR_VEHICLE_STATUS_TRAIN_STUCK;
2593                 } else if (v->type == VEH_AIRCRAFT && HasBit(Aircraft::From(v)->flags, VAF_DEST_TOO_FAR) && !v->current_order.IsType(OT_LOADING)) {
2594                         str = STR_VEHICLE_STATUS_AIRCRAFT_TOO_FAR;
2595                 } else { // vehicle is in a "normal" state, show current order
2596                         switch (v->current_order.GetType()) {
2597                                 case OT_GOTO_STATION: {
2598                                         SetDParam(0, v->current_order.GetDestination());
2599                                         SetDParam(1, v->GetDisplaySpeed());
2600                                         str = STR_VEHICLE_STATUS_HEADING_FOR_STATION_VEL;
2601                                         break;
2602                                 }
2603
2604                                 case OT_GOTO_DEPOT: {
2605                                         SetDParam(0, v->type);
2606                                         SetDParam(1, v->current_order.GetDestination());
2607                                         SetDParam(2, v->GetDisplaySpeed());
2608                                         if (v->current_order.GetDepotActionType() & ODATFB_NEAREST_DEPOT) {
2609                                                 /* This case *only* happens when multiple nearest depot orders
2610                                                  * follow each other (including an order list only one order: a
2611                                                  * nearest depot order) and there are no reachable depots.
2612                                                  * It is primarily to guard for the case that there is no
2613                                                  * depot with index 0, which would be used as fallback for
2614                                                  * evaluating the string in the status bar. */
2615                                                 str = STR_EMPTY;
2616                                         } else if (v->current_order.GetDepotActionType() & ODATFB_HALT) {
2617                                                 str = STR_VEHICLE_STATUS_HEADING_FOR_DEPOT_VEL;
2618                                         } else {
2619                                                 str = STR_VEHICLE_STATUS_HEADING_FOR_DEPOT_SERVICE_VEL;
2620                                         }
2621                                         break;
2622                                 }
2623
2624                                 case OT_LOADING:
2625                                         str = STR_VEHICLE_STATUS_LOADING_UNLOADING;
2626                                         break;
2627
2628                                 case OT_GOTO_WAYPOINT: {
2629                                         assert(v->type == VEH_TRAIN || v->type == VEH_SHIP);
2630                                         SetDParam(0, v->current_order.GetDestination());
2631                                         str = STR_VEHICLE_STATUS_HEADING_FOR_WAYPOINT_VEL;
2632                                         SetDParam(1, v->GetDisplaySpeed());
2633                                         break;
2634                                 }
2635
2636                                 case OT_LEAVESTATION:
2637                                         if (v->type != VEH_AIRCRAFT) {
2638                                                 str = STR_VEHICLE_STATUS_LEAVING;
2639                                                 break;
2640                                         }
2641                                         FALLTHROUGH;
2642                                 default:
2643                                         if (v->GetNumManualOrders() == 0) {
2644                                                 str = STR_VEHICLE_STATUS_NO_ORDERS_VEL;
2645                                                 SetDParam(0, v->GetDisplaySpeed());
2646                                         } else {
2647                                                 str = STR_EMPTY;
2648                                         }
2649                                         break;
2650                         }
2651                 }
2652
2653                 /* Draw the flag plus orders. */
2654                 bool rtl = (_current_text_dir == TD_RTL);
2655                 uint text_offset = max(GetSpriteSize(SPR_FLAG_VEH_STOPPED).width, GetSpriteSize(SPR_FLAG_VEH_RUNNING).width) + WD_IMGBTN_LEFT + WD_IMGBTN_RIGHT;
2656                 int text_left = r.left + (rtl ? (uint)WD_FRAMERECT_LEFT : text_offset);
2657                 int text_right = r.right - (rtl ? text_offset : (uint)WD_FRAMERECT_RIGHT);
2658                 int image_left = (rtl ? text_right + 1 : r.left) + WD_IMGBTN_LEFT;
2659                 int image = ((v->vehstatus & VS_STOPPED) != 0) ? SPR_FLAG_VEH_STOPPED : SPR_FLAG_VEH_RUNNING;
2660                 int lowered = this->IsWidgetLowered(WID_VV_START_STOP) ? 1 : 0;
2661                 DrawSprite(image, PAL_NONE, image_left + lowered, r.top + WD_IMGBTN_TOP + lowered);
2662                 DrawString(text_left + lowered, text_right + lowered, r.top + WD_FRAMERECT_TOP + lowered, str, TC_FROMSTRING, SA_HOR_CENTER);
2663         }
2664
2665         virtual void OnClick(Point pt, int widget, int click_count)
2666         {
2667                 const Vehicle *v = Vehicle::Get(this->window_number);
2668
2669                 switch (widget) {
2670                         case WID_VV_START_STOP: // start stop
2671                                 if (_ctrl_pressed) {
2672                                         /* Scroll to current order destination */
2673                                         TileIndex tile = v->current_order.GetLocation(v);
2674                                         if (tile != INVALID_TILE) ScrollMainWindowToTile(tile);
2675                                 } else {
2676                                         /* Start/Stop */
2677                                         StartStopVehicle(v, false);
2678                                 }
2679                                 break;
2680                         case WID_VV_CENTER_MAIN_VIEW: {// center main view
2681                                 const Window *mainwindow = FindWindowById(WC_MAIN_WINDOW, 0);
2682                                 /* code to allow the main window to 'follow' the vehicle if the ctrl key is pressed */
2683                                 if (_ctrl_pressed && mainwindow->viewport->zoom <= ZOOM_LVL_OUT_4X) {
2684                                         mainwindow->viewport->follow_vehicle = v->index;
2685                                 } else {
2686                                         ScrollMainWindowTo(v->x_pos, v->y_pos, v->z_pos);
2687                                 }
2688                                 break;
2689                         }
2690
2691                         case WID_VV_GOTO_DEPOT: // goto hangar
2692                                 DoCommandP(v->tile, v->index | (_ctrl_pressed ? DEPOT_SERVICE : 0U), 0, GetCmdSendToDepot(v));
2693                                 break;
2694                         case WID_VV_REFIT: // refit
2695                                 ShowVehicleRefitWindow(v, INVALID_VEH_ORDER_ID, this);
2696                                 break;
2697                         case WID_VV_SHOW_ORDERS: // show orders
2698                                 if (_ctrl_pressed) {
2699                                         ShowTimetableWindow(v);
2700                                 } else {
2701                                         ShowOrdersWindow(v);
2702                                 }
2703                                 break;
2704                         case WID_VV_SHOW_DETAILS: // show details
2705                                 ShowVehicleDetailsWindow(v);
2706                                 break;
2707                         case WID_VV_CLONE: // clone vehicle
2708                                 /* Suppress the vehicle GUI when share-cloning.
2709                                  * There is no point to it except for starting the vehicle.
2710                                  * For starting the vehicle the player has to open the depot GUI, which is
2711                                  * most likely already open, but is also visible in the vehicle viewport. */
2712                                 DoCommandP(v->tile, v->index, _ctrl_pressed ? 1 : 0,
2713                                                                                 _vehicle_command_translation_table[VCT_CMD_CLONE_VEH][v->type],
2714                                                                                 _ctrl_pressed ? NULL : CcCloneVehicle);
2715                                 break;
2716                         case WID_VV_TURN_AROUND: // turn around
2717                                 assert(v->IsGroundVehicle());
2718                                 DoCommandP(v->tile, v->index, 0,
2719                                                                                 _vehicle_command_translation_table[VCT_CMD_TURN_AROUND][v->type]);
2720                                 break;
2721                         case WID_VV_FORCE_PROCEED: // force proceed
2722                                 assert(v->type == VEH_TRAIN);
2723                                 DoCommandP(v->tile, v->index, 0, CMD_FORCE_TRAIN_PROCEED | CMD_MSG(STR_ERROR_CAN_T_MAKE_TRAIN_PASS_SIGNAL));
2724                                 break;
2725                 }
2726         }
2727
2728         virtual void OnResize()
2729         {
2730                 if (this->viewport != NULL) {
2731                         NWidgetViewport *nvp = this->GetWidget<NWidgetViewport>(WID_VV_VIEWPORT);
2732                         nvp->UpdateViewportCoordinates(this);
2733                 }
2734         }
2735
2736         virtual void OnTick()
2737         {
2738                 const Vehicle *v = Vehicle::Get(this->window_number);
2739                 bool veh_stopped = v->IsStoppedInDepot();
2740
2741                 /* Widget WID_VV_GOTO_DEPOT must be hidden if the vehicle is already stopped in depot.
2742                  * Widget WID_VV_CLONE_VEH should then be shown, since cloning is allowed only while in depot and stopped.
2743                  */
2744                 PlaneSelections plane = veh_stopped ? SEL_DC_CLONE : SEL_DC_GOTO_DEPOT;
2745                 NWidgetStacked *nwi = this->GetWidget<NWidgetStacked>(WID_VV_SELECT_DEPOT_CLONE); // Selection widget 'send to depot' / 'clone'.
2746                 if (nwi->shown_plane + SEL_DC_BASEPLANE != plane) {
2747                         this->SelectPlane(plane);
2748                         this->SetWidgetDirty(WID_VV_SELECT_DEPOT_CLONE);
2749                 }
2750                 /* The same system applies to widget WID_VV_REFIT_VEH and VVW_WIDGET_TURN_AROUND.*/
2751                 if (v->IsGroundVehicle()) {
2752                         PlaneSelections plane = veh_stopped ? SEL_RT_REFIT : SEL_RT_TURN_AROUND;
2753                         NWidgetStacked *nwi = this->GetWidget<NWidgetStacked>(WID_VV_SELECT_REFIT_TURN);
2754                         if (nwi->shown_plane + SEL_RT_BASEPLANE != plane) {
2755                                 this->SelectPlane(plane);
2756                                 this->SetWidgetDirty(WID_VV_SELECT_REFIT_TURN);
2757                         }
2758                 }
2759         }
2760
2761         /**
2762          * Some data on this window has become invalid.
2763          * @param data Information about the changed data.
2764          * @param gui_scope Whether the call is done from GUI scope. You may not do everything when not in GUI scope. See #InvalidateWindowData() for details.
2765          */
2766         virtual void OnInvalidateData(int data = 0, bool gui_scope = true)
2767         {
2768                 if (data == VIWD_AUTOREPLACE) {
2769                         /* Autoreplace replaced the vehicle.
2770                          * Nothing to do for this window. */
2771                         return;
2772                 }
2773         }
2774
2775         virtual bool IsNewGRFInspectable() const
2776         {
2777                 return ::IsNewGRFInspectable(GetGrfSpecFeature(Vehicle::Get(this->window_number)->type), this->window_number);
2778         }
2779
2780         virtual void ShowNewGRFInspectWindow() const
2781         {
2782                 ::ShowNewGRFInspectWindow(GetGrfSpecFeature(Vehicle::Get(this->window_number)->type), this->window_number);
2783         }
2784 };
2785
2786
2787 /** Shows the vehicle view window of the given vehicle. */
2788 void ShowVehicleViewWindow(const Vehicle *v)
2789 {
2790         AllocateWindowDescFront<VehicleViewWindow>((v->type == VEH_TRAIN) ? &_train_view_desc : &_vehicle_view_desc, v->index);
2791 }
2792
2793 /**
2794  * Dispatch a "vehicle selected" event if any window waits for it.
2795  * @param v selected vehicle;
2796  * @return did any window accept vehicle selection?
2797  */
2798 bool VehicleClicked(const Vehicle *v)
2799 {
2800         assert(v != NULL);
2801         if (!(_thd.place_mode & HT_VEHICLE)) return false;
2802
2803         v = v->First();
2804         if (!v->IsPrimaryVehicle()) return false;
2805
2806         return _thd.GetCallbackWnd()->OnVehicleSelect(v);
2807 }
2808
2809 void StopGlobalFollowVehicle(const Vehicle *v)
2810 {
2811         Window *w = FindWindowById(WC_MAIN_WINDOW, 0);
2812         if (w != NULL && w->viewport->follow_vehicle == v->index) {
2813                 ScrollMainWindowTo(v->x_pos, v->y_pos, v->z_pos, true); // lock the main view on the vehicle's last position
2814                 w->viewport->follow_vehicle = INVALID_VEHICLE;
2815         }
2816 }
2817
2818
2819 /**
2820  * This is the Callback method after the construction attempt of a primary vehicle
2821  * @param result indicates completion (or not) of the operation
2822  * @param tile unused
2823  * @param p1 unused
2824  * @param p2 unused
2825  */
2826 void CcBuildPrimaryVehicle(const CommandCost &result, TileIndex tile, uint32 p1, uint32 p2)
2827 {
2828         if (result.Failed()) return;
2829
2830         const Vehicle *v = Vehicle::Get(_new_vehicle_id);
2831         ShowVehicleViewWindow(v);
2832 }
2833
2834 /**
2835  * Get the width of a vehicle (part) in pixels.
2836  * @param v Vehicle to get the width for.
2837  * @return Width of the vehicle.
2838  */
2839 int GetSingleVehicleWidth(const Vehicle *v, EngineImageType image_type)
2840 {
2841         switch (v->type) {
2842                 case VEH_TRAIN:
2843                         return Train::From(v)->GetDisplayImageWidth();
2844
2845                 case VEH_ROAD:
2846                         return RoadVehicle::From(v)->GetDisplayImageWidth();
2847
2848                 default:
2849                         bool rtl = _current_text_dir == TD_RTL;
2850                         VehicleSpriteSeq seq;
2851                         v->GetImage(rtl ? DIR_E : DIR_W, image_type, &seq);
2852                         Rect rec;
2853                         seq.GetBounds(&rec);
2854                         return UnScaleGUI(rec.right - rec.left + 1);
2855         }
2856 }
2857
2858 /**
2859  * Get the width of a vehicle (including all parts of the consist) in pixels.
2860  * @param v Vehicle to get the width for.
2861  * @return Width of the vehicle.
2862  */
2863 int GetVehicleWidth(const Vehicle *v, EngineImageType image_type)
2864 {
2865         if (v->type == VEH_TRAIN || v->type == VEH_ROAD) {
2866                 int vehicle_width = 0;
2867                 for (const Vehicle *u = v; u != NULL; u = u->Next()) {
2868                         vehicle_width += GetSingleVehicleWidth(u, image_type);
2869                 }
2870                 return vehicle_width;
2871         } else {
2872                 return GetSingleVehicleWidth(v, image_type);
2873         }
2874 }
2875
2876 /**
2877  * Set the mouse cursor to look like a vehicle.
2878  * @param v Vehicle
2879  * @param image_type Type of vehicle image to use.
2880  */
2881 void SetMouseCursorVehicle(const Vehicle *v, EngineImageType image_type)
2882 {
2883         bool rtl = _current_text_dir == TD_RTL;
2884
2885         _cursor.sprite_count = 0;
2886         int total_width = 0;
2887         for (; v != NULL; v = v->HasArticulatedPart() ? v->GetNextArticulatedPart() : NULL) {
2888                 if (total_width >= 2 * (int)VEHICLEINFO_FULL_VEHICLE_WIDTH) break;
2889
2890                 PaletteID pal = (v->vehstatus & VS_CRASHED) ? PALETTE_CRASH : GetVehiclePalette(v);
2891                 VehicleSpriteSeq seq;
2892                 v->GetImage(rtl ? DIR_E : DIR_W, image_type, &seq);
2893
2894                 if (_cursor.sprite_count + seq.count > lengthof(_cursor.sprite_seq)) break;
2895
2896                 for (uint i = 0; i < seq.count; ++i) {
2897                         PaletteID pal2 = (v->vehstatus & VS_CRASHED) || !seq.seq[i].pal ? pal : seq.seq[i].pal;
2898                         _cursor.sprite_seq[_cursor.sprite_count].sprite = seq.seq[i].sprite;
2899                         _cursor.sprite_seq[_cursor.sprite_count].pal = pal2;
2900                         _cursor.sprite_pos[_cursor.sprite_count].x = rtl ? -total_width : total_width;
2901                         _cursor.sprite_pos[_cursor.sprite_count].y = 0;
2902                         _cursor.sprite_count++;
2903                 }
2904
2905                 total_width += GetSingleVehicleWidth(v, image_type);
2906         }
2907
2908         int offs = ((int)VEHICLEINFO_FULL_VEHICLE_WIDTH - total_width) / 2;
2909         if (rtl) offs = -offs;
2910         for (uint i = 0; i < _cursor.sprite_count; ++i) {
2911                 _cursor.sprite_pos[i].x += offs;
2912         }
2913
2914         UpdateCursorSize();
2915 }