build_vehicle_gui.cpp

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * 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.
 * 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.
 * 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/>.
 */
 
#include "stdafx.h"
#include "engine_base.h"
#include "engine_func.h"
#include "station_base.h"
#include "network/network.h"
#include "articulated_vehicles.h"
#include "textbuf_gui.h"
#include "command_func.h"
#include "company_func.h"
#include "vehicle_gui.h"
#include "newgrf_engine.h"
#include "newgrf_text.h"
#include "group.h"
#include "string_func.h"
#include "strings_func.h"
#include "window_func.h"
#include "timer/timer_game_calendar.h"
#include "vehicle_func.h"
#include "widgets/dropdown_func.h"
#include "engine_gui.h"
#include "cargotype.h"
#include "core/geometry_func.hpp"
#include "autoreplace_func.h"
#include "engine_cmd.h"
#include "train_cmd.h"
#include "vehicle_cmd.h"
#include "zoom_func.h"
#include "querystring_gui.h"
#include "stringfilter_type.h"
#include "hotkeys.h"
 
#include "widgets/build_vehicle_widget.h"
 
#include "table/strings.h"
 
#include "safeguards.h"
 
uint GetEngineListHeight(VehicleType type)
{
  return std::max<uint>(GetCharacterHeight(FS_NORMAL) + WidgetDimensions::scaled.matrix.Vertical(), GetVehicleImageCellSize(type, EIT_PURCHASE).height);
}
 
static constexpr NWidgetPart _nested_build_vehicle_widgets[] = {
  NWidget(NWID_HORIZONTAL),
    NWidget(WWT_CLOSEBOX, COLOUR_GREY),
    NWidget(WWT_CAPTION, COLOUR_GREY, WID_BV_CAPTION), SetDataTip(STR_JUST_STRING, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS), SetTextStyle(TC_WHITE),
    NWidget(WWT_SHADEBOX, COLOUR_GREY),
    NWidget(WWT_DEFSIZEBOX, COLOUR_GREY),
    NWidget(WWT_STICKYBOX, COLOUR_GREY),
  EndContainer(),
  NWidget(NWID_VERTICAL),
    NWidget(NWID_HORIZONTAL),
      NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_BV_SORT_ASCENDING_DESCENDING), SetDataTip(STR_BUTTON_SORT_BY, STR_TOOLTIP_SORT_ORDER),
      NWidget(WWT_DROPDOWN, COLOUR_GREY, WID_BV_SORT_DROPDOWN), SetResize(1, 0), SetFill(1, 0), SetDataTip(STR_JUST_STRING, STR_TOOLTIP_SORT_CRITERIA),
    EndContainer(),
    NWidget(NWID_HORIZONTAL),
      NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_BV_SHOW_HIDDEN_ENGINES),
      NWidget(WWT_DROPDOWN, COLOUR_GREY, WID_BV_CARGO_FILTER_DROPDOWN), SetResize(1, 0), SetFill(1, 0), SetDataTip(STR_JUST_STRING, STR_TOOLTIP_FILTER_CRITERIA),
    EndContainer(),
    NWidget(WWT_PANEL, COLOUR_GREY),
      NWidget(WWT_EDITBOX, COLOUR_GREY, WID_BV_FILTER), SetResize(1, 0), SetFill(1, 0), SetPadding(2), SetDataTip(STR_LIST_FILTER_OSKTITLE, STR_LIST_FILTER_TOOLTIP),
    EndContainer(),
  EndContainer(),
  /* Vehicle list. */
  NWidget(NWID_HORIZONTAL),
    NWidget(WWT_MATRIX, COLOUR_GREY, WID_BV_LIST), SetResize(1, 1), SetFill(1, 0), SetMatrixDataTip(1, 0, STR_NULL), SetScrollbar(WID_BV_SCROLLBAR),
    NWidget(NWID_VSCROLLBAR, COLOUR_GREY, WID_BV_SCROLLBAR),
  EndContainer(),
  /* Panel with details. */
  NWidget(WWT_PANEL, COLOUR_GREY, WID_BV_PANEL), SetMinimalSize(240, 122), SetResize(1, 0), EndContainer(),
  /* Build/rename buttons, resize button. */
  NWidget(NWID_HORIZONTAL),
    NWidget(NWID_SELECTION, INVALID_COLOUR, WID_BV_BUILD_SEL),
      NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_BV_BUILD), SetResize(1, 0), SetFill(1, 0),
    EndContainer(),
    NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_BV_SHOW_HIDE), SetResize(1, 0), SetFill(1, 0), SetDataTip(STR_JUST_STRING, STR_NULL),
    NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_BV_RENAME), SetResize(1, 0), SetFill(1, 0),
    NWidget(WWT_RESIZEBOX, COLOUR_GREY),
  EndContainer(),
};
 
 
bool _engine_sort_direction; 
byte _engine_sort_last_criteria[]       = {0, 0, 0, 0};                 
bool _engine_sort_last_order[]          = {false, false, false, false}; 
bool _engine_sort_show_hidden_engines[] = {false, false, false, false}; 
static CargoID _engine_sort_last_cargo_criteria[] = {CargoFilterCriteria::CF_ANY, CargoFilterCriteria::CF_ANY, CargoFilterCriteria::CF_ANY, CargoFilterCriteria::CF_ANY}; 
 
static bool EngineNumberSorter(const GUIEngineListItem &a, const GUIEngineListItem &b)
{
  int r = Engine::Get(a.engine_id)->list_position - Engine::Get(b.engine_id)->list_position;
 
  return _engine_sort_direction ? r > 0 : r < 0;
}
 
static bool EngineIntroDateSorter(const GUIEngineListItem &a, const GUIEngineListItem &b)
{
  const auto va = Engine::Get(a.engine_id)->intro_date;
  const auto vb = Engine::Get(b.engine_id)->intro_date;
  const auto r = va - vb;
 
  /* Use EngineID to sort instead since we want consistent sorting */
  if (r == 0) return EngineNumberSorter(a, b);
  return _engine_sort_direction ? r > 0 : r < 0;
}
 
/* cached values for EngineNameSorter to spare many GetString() calls */
static EngineID _last_engine[2] = { INVALID_ENGINE, INVALID_ENGINE };
 
static bool EngineNameSorter(const GUIEngineListItem &a, const GUIEngineListItem &b)
{
  static std::string last_name[2] = { {}, {} };
 
  if (a.engine_id != _last_engine[0]) {
    _last_engine[0] = a.engine_id;
    SetDParam(0, PackEngineNameDParam(a.engine_id, EngineNameContext::PurchaseList));
    last_name[0] = GetString(STR_ENGINE_NAME);
  }
 
  if (b.engine_id != _last_engine[1]) {
    _last_engine[1] = b.engine_id;
    SetDParam(0, PackEngineNameDParam(b.engine_id, EngineNameContext::PurchaseList));
    last_name[1] = GetString(STR_ENGINE_NAME);
  }
 
  int r = StrNaturalCompare(last_name[0], last_name[1]); // Sort by name (natural sorting).
 
  /* Use EngineID to sort instead since we want consistent sorting */
  if (r == 0) return EngineNumberSorter(a, b);
  return _engine_sort_direction ? r > 0 : r < 0;
}
 
static bool EngineReliabilitySorter(const GUIEngineListItem &a, const GUIEngineListItem &b)
{
  const int va = Engine::Get(a.engine_id)->reliability;
  const int vb = Engine::Get(b.engine_id)->reliability;
  const int r = va - vb;
 
  /* Use EngineID to sort instead since we want consistent sorting */
  if (r == 0) return EngineNumberSorter(a, b);
  return _engine_sort_direction ? r > 0 : r < 0;
}
 
static bool EngineCostSorter(const GUIEngineListItem &a, const GUIEngineListItem &b)
{
  Money va = Engine::Get(a.engine_id)->GetCost();
  Money vb = Engine::Get(b.engine_id)->GetCost();
  int r = ClampTo<int32_t>(va - vb);
 
  /* Use EngineID to sort instead since we want consistent sorting */
  if (r == 0) return EngineNumberSorter(a, b);
  return _engine_sort_direction ? r > 0 : r < 0;
}
 
static bool EngineSpeedSorter(const GUIEngineListItem &a, const GUIEngineListItem &b)
{
  int va = Engine::Get(a.engine_id)->GetDisplayMaxSpeed();
  int vb = Engine::Get(b.engine_id)->GetDisplayMaxSpeed();
  int r = va - vb;
 
  /* Use EngineID to sort instead since we want consistent sorting */
  if (r == 0) return EngineNumberSorter(a, b);
  return _engine_sort_direction ? r > 0 : r < 0;
}
 
static bool EnginePowerSorter(const GUIEngineListItem &a, const GUIEngineListItem &b)
{
  int va = Engine::Get(a.engine_id)->GetPower();
  int vb = Engine::Get(b.engine_id)->GetPower();
  int r = va - vb;
 
  /* Use EngineID to sort instead since we want consistent sorting */
  if (r == 0) return EngineNumberSorter(a, b);
  return _engine_sort_direction ? r > 0 : r < 0;
}
 
static bool EngineTractiveEffortSorter(const GUIEngineListItem &a, const GUIEngineListItem &b)
{
  int va = Engine::Get(a.engine_id)->GetDisplayMaxTractiveEffort();
  int vb = Engine::Get(b.engine_id)->GetDisplayMaxTractiveEffort();
  int r = va - vb;
 
  /* Use EngineID to sort instead since we want consistent sorting */
  if (r == 0) return EngineNumberSorter(a, b);
  return _engine_sort_direction ? r > 0 : r < 0;
}
 
static bool EngineRunningCostSorter(const GUIEngineListItem &a, const GUIEngineListItem &b)
{
  Money va = Engine::Get(a.engine_id)->GetRunningCost();
  Money vb = Engine::Get(b.engine_id)->GetRunningCost();
  int r = ClampTo<int32_t>(va - vb);
 
  /* Use EngineID to sort instead since we want consistent sorting */
  if (r == 0) return EngineNumberSorter(a, b);
  return _engine_sort_direction ? r > 0 : r < 0;
}
 
static bool EnginePowerVsRunningCostSorter(const GUIEngineListItem &a, const GUIEngineListItem &b)
{
  const Engine *e_a = Engine::Get(a.engine_id);
  const Engine *e_b = Engine::Get(b.engine_id);
  uint p_a = e_a->GetPower();
  uint p_b = e_b->GetPower();
  Money r_a = e_a->GetRunningCost();
  Money r_b = e_b->GetRunningCost();
  /* Check if running cost is zero in one or both engines.
   * If only one of them is zero then that one has higher value,
   * else if both have zero cost then compare powers. */
  if (r_a == 0) {
    if (r_b == 0) {
      /* If it is ambiguous which to return go with their ID */
      if (p_a == p_b) return EngineNumberSorter(a, b);
      return _engine_sort_direction != (p_a < p_b);
    }
    return !_engine_sort_direction;
  }
  if (r_b == 0) return _engine_sort_direction;
  /* Using double for more precision when comparing close values.
   * This shouldn't have any major effects in performance nor in keeping
   * the game in sync between players since it's used in GUI only in client side */
  double v_a = (double)p_a / (double)r_a;
  double v_b = (double)p_b / (double)r_b;
  /* Use EngineID to sort if both have same power/running cost,
   * since we want consistent sorting.
   * Also if both have no power then sort with reverse of running cost to simulate
   * previous sorting behaviour for wagons. */
  if (v_a == 0 && v_b == 0) return EngineRunningCostSorter(b, a);
  if (v_a == v_b)  return EngineNumberSorter(a, b);
  return _engine_sort_direction != (v_a < v_b);
}
 
/* Train sorting functions */
 
static bool TrainEngineCapacitySorter(const GUIEngineListItem &a, const GUIEngineListItem &b)
{
  const RailVehicleInfo *rvi_a = RailVehInfo(a.engine_id);
  const RailVehicleInfo *rvi_b = RailVehInfo(b.engine_id);
 
  int va = GetTotalCapacityOfArticulatedParts(a.engine_id) * (rvi_a->railveh_type == RAILVEH_MULTIHEAD ? 2 : 1);
  int vb = GetTotalCapacityOfArticulatedParts(b.engine_id) * (rvi_b->railveh_type == RAILVEH_MULTIHEAD ? 2 : 1);
  int r = va - vb;
 
  /* Use EngineID to sort instead since we want consistent sorting */
  if (r == 0) return EngineNumberSorter(a, b);
  return _engine_sort_direction ? r > 0 : r < 0;
}
 
static bool TrainEnginesThenWagonsSorter(const GUIEngineListItem &a, const GUIEngineListItem &b)
{
  int val_a = (RailVehInfo(a.engine_id)->railveh_type == RAILVEH_WAGON ? 1 : 0);
  int val_b = (RailVehInfo(b.engine_id)->railveh_type == RAILVEH_WAGON ? 1 : 0);
  int r = val_a - val_b;
 
  /* Use EngineID to sort instead since we want consistent sorting */
  if (r == 0) return EngineNumberSorter(a, b);
  return _engine_sort_direction ? r > 0 : r < 0;
}
 
/* Road vehicle sorting functions */
 
static bool RoadVehEngineCapacitySorter(const GUIEngineListItem &a, const GUIEngineListItem &b)
{
  int va = GetTotalCapacityOfArticulatedParts(a.engine_id);
  int vb = GetTotalCapacityOfArticulatedParts(b.engine_id);
  int r = va - vb;
 
  /* Use EngineID to sort instead since we want consistent sorting */
  if (r == 0) return EngineNumberSorter(a, b);
  return _engine_sort_direction ? r > 0 : r < 0;
}
 
/* Ship vehicle sorting functions */
 
static bool ShipEngineCapacitySorter(const GUIEngineListItem &a, const GUIEngineListItem &b)
{
  const Engine *e_a = Engine::Get(a.engine_id);
  const Engine *e_b = Engine::Get(b.engine_id);
 
  int va = e_a->GetDisplayDefaultCapacity();
  int vb = e_b->GetDisplayDefaultCapacity();
  int r = va - vb;
 
  /* Use EngineID to sort instead since we want consistent sorting */
  if (r == 0) return EngineNumberSorter(a, b);
  return _engine_sort_direction ? r > 0 : r < 0;
}
 
/* Aircraft sorting functions */
 
static bool AircraftEngineCargoSorter(const GUIEngineListItem &a, const GUIEngineListItem &b)
{
  const Engine *e_a = Engine::Get(a.engine_id);
  const Engine *e_b = Engine::Get(b.engine_id);
 
  uint16_t mail_a, mail_b;
  int va = e_a->GetDisplayDefaultCapacity(&mail_a);
  int vb = e_b->GetDisplayDefaultCapacity(&mail_b);
  int r = va - vb;
 
  if (r == 0) {
    /* The planes have the same passenger capacity. Check mail capacity instead */
    r = mail_a - mail_b;
 
    if (r == 0) {
      /* Use EngineID to sort instead since we want consistent sorting */
      return EngineNumberSorter(a, b);
    }
  }
  return _engine_sort_direction ? r > 0 : r < 0;
}
 
static bool AircraftRangeSorter(const GUIEngineListItem &a, const GUIEngineListItem &b)
{
  uint16_t r_a = Engine::Get(a.engine_id)->GetRange();
  uint16_t r_b = Engine::Get(b.engine_id)->GetRange();
 
  int r = r_a - r_b;
 
  /* Use EngineID to sort instead since we want consistent sorting */
  if (r == 0) return EngineNumberSorter(a, b);
  return _engine_sort_direction ? r > 0 : r < 0;
}
 
EngList_SortTypeFunction * const _engine_sort_functions[][11] = {{
  /* Trains */
  &EngineNumberSorter,
  &EngineCostSorter,
  &EngineSpeedSorter,
  &EnginePowerSorter,
  &EngineTractiveEffortSorter,
  &EngineIntroDateSorter,
  &EngineNameSorter,
  &EngineRunningCostSorter,
  &EnginePowerVsRunningCostSorter,
  &EngineReliabilitySorter,
  &TrainEngineCapacitySorter,
}, {
  /* Road vehicles */
  &EngineNumberSorter,
  &EngineCostSorter,
  &EngineSpeedSorter,
  &EnginePowerSorter,
  &EngineTractiveEffortSorter,
  &EngineIntroDateSorter,
  &EngineNameSorter,
  &EngineRunningCostSorter,
  &EnginePowerVsRunningCostSorter,
  &EngineReliabilitySorter,
  &RoadVehEngineCapacitySorter,
}, {
  /* Ships */
  &EngineNumberSorter,
  &EngineCostSorter,
  &EngineSpeedSorter,
  &EngineIntroDateSorter,
  &EngineNameSorter,
  &EngineRunningCostSorter,
  &EngineReliabilitySorter,
  &ShipEngineCapacitySorter,
}, {
  /* Aircraft */
  &EngineNumberSorter,
  &EngineCostSorter,
  &EngineSpeedSorter,
  &EngineIntroDateSorter,
  &EngineNameSorter,
  &EngineRunningCostSorter,
  &EngineReliabilitySorter,
  &AircraftEngineCargoSorter,
  &AircraftRangeSorter,
}};
 
const StringID _engine_sort_listing[][12] = {{
  /* Trains */
  STR_SORT_BY_ENGINE_ID,
  STR_SORT_BY_COST,
  STR_SORT_BY_MAX_SPEED,
  STR_SORT_BY_POWER,
  STR_SORT_BY_TRACTIVE_EFFORT,
  STR_SORT_BY_INTRO_DATE,
  STR_SORT_BY_NAME,
  STR_SORT_BY_RUNNING_COST,
  STR_SORT_BY_POWER_VS_RUNNING_COST,
  STR_SORT_BY_RELIABILITY,
  STR_SORT_BY_CARGO_CAPACITY,
  INVALID_STRING_ID
}, {
  /* Road vehicles */
  STR_SORT_BY_ENGINE_ID,
  STR_SORT_BY_COST,
  STR_SORT_BY_MAX_SPEED,
  STR_SORT_BY_POWER,
  STR_SORT_BY_TRACTIVE_EFFORT,
  STR_SORT_BY_INTRO_DATE,
  STR_SORT_BY_NAME,
  STR_SORT_BY_RUNNING_COST,
  STR_SORT_BY_POWER_VS_RUNNING_COST,
  STR_SORT_BY_RELIABILITY,
  STR_SORT_BY_CARGO_CAPACITY,
  INVALID_STRING_ID
}, {
  /* Ships */
  STR_SORT_BY_ENGINE_ID,
  STR_SORT_BY_COST,
  STR_SORT_BY_MAX_SPEED,
  STR_SORT_BY_INTRO_DATE,
  STR_SORT_BY_NAME,
  STR_SORT_BY_RUNNING_COST,
  STR_SORT_BY_RELIABILITY,
  STR_SORT_BY_CARGO_CAPACITY,
  INVALID_STRING_ID
}, {
  /* Aircraft */
  STR_SORT_BY_ENGINE_ID,
  STR_SORT_BY_COST,
  STR_SORT_BY_MAX_SPEED,
  STR_SORT_BY_INTRO_DATE,
  STR_SORT_BY_NAME,
  STR_SORT_BY_RUNNING_COST,
  STR_SORT_BY_RELIABILITY,
  STR_SORT_BY_CARGO_CAPACITY,
  STR_SORT_BY_RANGE,
  INVALID_STRING_ID
}};
 
static bool CDECL CargoAndEngineFilter(const GUIEngineListItem *item, const CargoID cid)
{
  if (cid == CargoFilterCriteria::CF_ANY) {
    return true;
  } else if (cid == CargoFilterCriteria::CF_ENGINES) {
    return Engine::Get(item->engine_id)->GetPower() != 0;
  } else {
    CargoTypes refit_mask = GetUnionOfArticulatedRefitMasks(item->engine_id, true) & _standard_cargo_mask;
    return (cid == CargoFilterCriteria::CF_NONE ? refit_mask == 0 : HasBit(refit_mask, cid));
  }
}
 
static GUIEngineList::FilterFunction * const _filter_funcs[] = {
  &CargoAndEngineFilter,
};
 
static uint GetCargoWeight(const CargoArray &cap, VehicleType vtype)
{
  uint weight = 0;
  for (CargoID c = 0; c < NUM_CARGO; c++) {
    if (cap[c] != 0) {
      if (vtype == VEH_TRAIN) {
        weight += CargoSpec::Get(c)->WeightOfNUnitsInTrain(cap[c]);
      } else {
        weight += CargoSpec::Get(c)->WeightOfNUnits(cap[c]);
      }
    }
  }
  return weight;
}
 
static int DrawCargoCapacityInfo(int left, int right, int y, TestedEngineDetails &te, bool refittable)
{
  for (const CargoSpec *cs : _sorted_cargo_specs) {
    CargoID cid = cs->Index();
    if (te.all_capacities[cid] == 0) continue;
 
    SetDParam(0, cid);
    SetDParam(1, te.all_capacities[cid]);
    SetDParam(2, refittable ? STR_PURCHASE_INFO_REFITTABLE : STR_EMPTY);
    DrawString(left, right, y, STR_PURCHASE_INFO_CAPACITY);
    y += GetCharacterHeight(FS_NORMAL);
  }
 
  return y;
}
 
/* Draw rail wagon specific details */
static int DrawRailWagonPurchaseInfo(int left, int right, int y, EngineID engine_number, const RailVehicleInfo *rvi, TestedEngineDetails &te)
{
  const Engine *e = Engine::Get(engine_number);
 
  /* Purchase cost */
  if (te.cost != 0) {
    SetDParam(0, e->GetCost() + te.cost);
    SetDParam(1, te.cost);
    DrawString(left, right, y, STR_PURCHASE_INFO_COST_REFIT);
  } else {
    SetDParam(0, e->GetCost());
    DrawString(left, right, y, STR_PURCHASE_INFO_COST);
  }
  y += GetCharacterHeight(FS_NORMAL);
 
  /* Wagon weight - (including cargo) */
  uint weight = e->GetDisplayWeight();
  SetDParam(0, weight);
  SetDParam(1, GetCargoWeight(te.all_capacities, VEH_TRAIN) + weight);
  DrawString(left, right, y, STR_PURCHASE_INFO_WEIGHT_CWEIGHT);
  y += GetCharacterHeight(FS_NORMAL);
 
  /* Wagon speed limit, displayed if above zero */
  if (_settings_game.vehicle.wagon_speed_limits) {
    uint max_speed = e->GetDisplayMaxSpeed();
    if (max_speed > 0) {
      SetDParam(0, PackVelocity(max_speed, e->type));
      DrawString(left, right, y, STR_PURCHASE_INFO_SPEED);
      y += GetCharacterHeight(FS_NORMAL);
    }
  }
 
  /* Running cost */
  if (rvi->running_cost_class != INVALID_PRICE) {
    SetDParam(0, e->GetRunningCost());
    DrawString(left, right, y, TimerGameEconomy::UsingWallclockUnits() ? STR_PURCHASE_INFO_RUNNINGCOST_PERIOD : STR_PURCHASE_INFO_RUNNINGCOST_YEAR);
    y += GetCharacterHeight(FS_NORMAL);
  }
 
  return y;
}
 
/* Draw locomotive specific details */
static int DrawRailEnginePurchaseInfo(int left, int right, int y, EngineID engine_number, const RailVehicleInfo *rvi, TestedEngineDetails &te)
{
  const Engine *e = Engine::Get(engine_number);
 
  /* Purchase Cost - Engine weight */
  if (te.cost != 0) {
    SetDParam(0, e->GetCost() + te.cost);
    SetDParam(1, te.cost);
    SetDParam(2, e->GetDisplayWeight());
    DrawString(left, right, y, STR_PURCHASE_INFO_COST_REFIT_WEIGHT);
  } else {
    SetDParam(0, e->GetCost());
    SetDParam(1, e->GetDisplayWeight());
    DrawString(left, right, y, STR_PURCHASE_INFO_COST_WEIGHT);
  }
  y += GetCharacterHeight(FS_NORMAL);
 
  /* Max speed - Engine power */
  SetDParam(0, PackVelocity(e->GetDisplayMaxSpeed(), e->type));
  SetDParam(1, e->GetPower());
  DrawString(left, right, y, STR_PURCHASE_INFO_SPEED_POWER);
  y += GetCharacterHeight(FS_NORMAL);
 
  /* Max tractive effort - not applicable if old acceleration or maglev */
  if (_settings_game.vehicle.train_acceleration_model != AM_ORIGINAL && GetRailTypeInfo(rvi->railtype)->acceleration_type != 2) {
    SetDParam(0, e->GetDisplayMaxTractiveEffort());
    DrawString(left, right, y, STR_PURCHASE_INFO_MAX_TE);
    y += GetCharacterHeight(FS_NORMAL);
  }
 
  /* Running cost */
  if (rvi->running_cost_class != INVALID_PRICE) {
    SetDParam(0, e->GetRunningCost());
    DrawString(left, right, y, TimerGameEconomy::UsingWallclockUnits() ? STR_PURCHASE_INFO_RUNNINGCOST_PERIOD : STR_PURCHASE_INFO_RUNNINGCOST_YEAR);
    y += GetCharacterHeight(FS_NORMAL);
  }
 
  /* Powered wagons power - Powered wagons extra weight */
  if (rvi->pow_wag_power != 0) {
    SetDParam(0, rvi->pow_wag_power);
    SetDParam(1, rvi->pow_wag_weight);
    DrawString(left, right, y, STR_PURCHASE_INFO_PWAGPOWER_PWAGWEIGHT);
    y += GetCharacterHeight(FS_NORMAL);
  }
 
  return y;
}
 
/* Draw road vehicle specific details */
static int DrawRoadVehPurchaseInfo(int left, int right, int y, EngineID engine_number, TestedEngineDetails &te)
{
  const Engine *e = Engine::Get(engine_number);
 
  if (_settings_game.vehicle.roadveh_acceleration_model != AM_ORIGINAL) {
    /* Purchase Cost */
    if (te.cost != 0) {
      SetDParam(0, e->GetCost() + te.cost);
      SetDParam(1, te.cost);
      DrawString(left, right, y, STR_PURCHASE_INFO_COST_REFIT);
    } else {
      SetDParam(0, e->GetCost());
      DrawString(left, right, y, STR_PURCHASE_INFO_COST);
    }
    y += GetCharacterHeight(FS_NORMAL);
 
    /* Road vehicle weight - (including cargo) */
    int16_t weight = e->GetDisplayWeight();
    SetDParam(0, weight);
    SetDParam(1, GetCargoWeight(te.all_capacities, VEH_ROAD) + weight);
    DrawString(left, right, y, STR_PURCHASE_INFO_WEIGHT_CWEIGHT);
    y += GetCharacterHeight(FS_NORMAL);
 
    /* Max speed - Engine power */
    SetDParam(0, PackVelocity(e->GetDisplayMaxSpeed(), e->type));
    SetDParam(1, e->GetPower());
    DrawString(left, right, y, STR_PURCHASE_INFO_SPEED_POWER);
    y += GetCharacterHeight(FS_NORMAL);
 
    /* Max tractive effort */
    SetDParam(0, e->GetDisplayMaxTractiveEffort());
    DrawString(left, right, y, STR_PURCHASE_INFO_MAX_TE);
    y += GetCharacterHeight(FS_NORMAL);
  } else {
    /* Purchase cost - Max speed */
    if (te.cost != 0) {
      SetDParam(0, e->GetCost() + te.cost);
      SetDParam(1, te.cost);
      SetDParam(2, PackVelocity(e->GetDisplayMaxSpeed(), e->type));
      DrawString(left, right, y, STR_PURCHASE_INFO_COST_REFIT_SPEED);
    } else {
      SetDParam(0, e->GetCost());
      SetDParam(1, PackVelocity(e->GetDisplayMaxSpeed(), e->type));
      DrawString(left, right, y, STR_PURCHASE_INFO_COST_SPEED);
    }
    y += GetCharacterHeight(FS_NORMAL);
  }
 
  /* Running cost */
  SetDParam(0, e->GetRunningCost());
  DrawString(left, right, y, TimerGameEconomy::UsingWallclockUnits() ? STR_PURCHASE_INFO_RUNNINGCOST_PERIOD : STR_PURCHASE_INFO_RUNNINGCOST_YEAR);
  y += GetCharacterHeight(FS_NORMAL);
 
  return y;
}
 
/* Draw ship specific details */
static int DrawShipPurchaseInfo(int left, int right, int y, EngineID engine_number, bool refittable, TestedEngineDetails &te)
{
  const Engine *e = Engine::Get(engine_number);
 
  /* Purchase cost - Max speed */
  uint raw_speed = e->GetDisplayMaxSpeed();
  uint ocean_speed = e->u.ship.ApplyWaterClassSpeedFrac(raw_speed, true);
  uint canal_speed = e->u.ship.ApplyWaterClassSpeedFrac(raw_speed, false);
 
  if (ocean_speed == canal_speed) {
    if (te.cost != 0) {
      SetDParam(0, e->GetCost() + te.cost);
      SetDParam(1, te.cost);
      SetDParam(2, PackVelocity(ocean_speed, e->type));
      DrawString(left, right, y, STR_PURCHASE_INFO_COST_REFIT_SPEED);
    } else {
      SetDParam(0, e->GetCost());
      SetDParam(1, PackVelocity(ocean_speed, e->type));
      DrawString(left, right, y, STR_PURCHASE_INFO_COST_SPEED);
    }
    y += GetCharacterHeight(FS_NORMAL);
  } else {
    if (te.cost != 0) {
      SetDParam(0, e->GetCost() + te.cost);
      SetDParam(1, te.cost);
      DrawString(left, right, y, STR_PURCHASE_INFO_COST_REFIT);
    } else {
      SetDParam(0, e->GetCost());
      DrawString(left, right, y, STR_PURCHASE_INFO_COST);
    }
    y += GetCharacterHeight(FS_NORMAL);
 
    SetDParam(0, PackVelocity(ocean_speed, e->type));
    DrawString(left, right, y, STR_PURCHASE_INFO_SPEED_OCEAN);
    y += GetCharacterHeight(FS_NORMAL);
 
    SetDParam(0, PackVelocity(canal_speed, e->type));
    DrawString(left, right, y, STR_PURCHASE_INFO_SPEED_CANAL);
    y += GetCharacterHeight(FS_NORMAL);
  }
 
  /* Cargo type + capacity */
  SetDParam(0, te.cargo);
  SetDParam(1, te.capacity);
  SetDParam(2, refittable ? STR_PURCHASE_INFO_REFITTABLE : STR_EMPTY);
  DrawString(left, right, y, STR_PURCHASE_INFO_CAPACITY);
  y += GetCharacterHeight(FS_NORMAL);
 
  /* Running cost */
  SetDParam(0, e->GetRunningCost());
  DrawString(left, right, y, TimerGameEconomy::UsingWallclockUnits() ? STR_PURCHASE_INFO_RUNNINGCOST_PERIOD : STR_PURCHASE_INFO_RUNNINGCOST_YEAR);
  y += GetCharacterHeight(FS_NORMAL);
 
  return y;
}
 
static int DrawAircraftPurchaseInfo(int left, int right, int y, EngineID engine_number, bool refittable, TestedEngineDetails &te)
{
  const Engine *e = Engine::Get(engine_number);
 
  /* Purchase cost - Max speed */
  if (te.cost != 0) {
    SetDParam(0, e->GetCost() + te.cost);
    SetDParam(1, te.cost);
    SetDParam(2, PackVelocity(e->GetDisplayMaxSpeed(), e->type));
    DrawString(left, right, y, STR_PURCHASE_INFO_COST_REFIT_SPEED);
  } else {
    SetDParam(0, e->GetCost());
    SetDParam(1, PackVelocity(e->GetDisplayMaxSpeed(), e->type));
    DrawString(left, right, y, STR_PURCHASE_INFO_COST_SPEED);
  }
  y += GetCharacterHeight(FS_NORMAL);
 
  /* Cargo capacity */
  if (te.mail_capacity > 0) {
    SetDParam(0, te.cargo);
    SetDParam(1, te.capacity);
    SetDParam(2, CT_MAIL);
    SetDParam(3, te.mail_capacity);
    DrawString(left, right, y, STR_PURCHASE_INFO_AIRCRAFT_CAPACITY);
  } else {
    /* Note, if the default capacity is selected by the refit capacity
     * callback, then the capacity shown is likely to be incorrect. */
    SetDParam(0, te.cargo);
    SetDParam(1, te.capacity);
    SetDParam(2, refittable ? STR_PURCHASE_INFO_REFITTABLE : STR_EMPTY);
    DrawString(left, right, y, STR_PURCHASE_INFO_CAPACITY);
  }
  y += GetCharacterHeight(FS_NORMAL);
 
  /* Running cost */
  SetDParam(0, e->GetRunningCost());
  DrawString(left, right, y, TimerGameEconomy::UsingWallclockUnits() ? STR_PURCHASE_INFO_RUNNINGCOST_PERIOD : STR_PURCHASE_INFO_RUNNINGCOST_YEAR);
  y += GetCharacterHeight(FS_NORMAL);
 
  /* Aircraft type */
  SetDParam(0, e->GetAircraftTypeText());
  DrawString(left, right, y, STR_PURCHASE_INFO_AIRCRAFT_TYPE);
  y += GetCharacterHeight(FS_NORMAL);
 
  /* Aircraft range, if available. */
  uint16_t range = e->GetRange();
  if (range != 0) {
    SetDParam(0, range);
    DrawString(left, right, y, STR_PURCHASE_INFO_AIRCRAFT_RANGE);
    y += GetCharacterHeight(FS_NORMAL);
  }
 
  return y;
}
 
 
static std::optional<std::string> GetNewGRFAdditionalText(EngineID engine)
{
  uint16_t callback = GetVehicleCallback(CBID_VEHICLE_ADDITIONAL_TEXT, 0, 0, engine, nullptr);
  if (callback == CALLBACK_FAILED || callback == 0x400) return std::nullopt;
  const GRFFile *grffile = Engine::Get(engine)->GetGRF();
  assert(grffile != nullptr);
  if (callback > 0x400) {
    ErrorUnknownCallbackResult(grffile->grfid, CBID_VEHICLE_ADDITIONAL_TEXT, callback);
    return std::nullopt;
  }
 
  StartTextRefStackUsage(grffile, 6);
  std::string result = GetString(GetGRFStringID(grffile->grfid, 0xD000 + callback));
  StopTextRefStackUsage();
  return result;
}
 
static uint ShowAdditionalText(int left, int right, int y, EngineID engine)
{
  auto text = GetNewGRFAdditionalText(engine);
  if (!text) return y;
  return DrawStringMultiLine(left, right, y, INT32_MAX, *text, TC_BLACK);
}
 
void TestedEngineDetails::FillDefaultCapacities(const Engine *e)
{
  this->cargo = e->GetDefaultCargoType();
  if (e->type == VEH_TRAIN || e->type == VEH_ROAD) {
    this->all_capacities = GetCapacityOfArticulatedParts(e->index);
    this->capacity = this->all_capacities[this->cargo];
    this->mail_capacity = 0;
  } else {
    this->capacity = e->GetDisplayDefaultCapacity(&this->mail_capacity);
    this->all_capacities[this->cargo] = this->capacity;
    this->all_capacities[CT_MAIL] = this->mail_capacity;
  }
  if (this->all_capacities.GetCount() == 0) this->cargo = INVALID_CARGO;
}
 
int DrawVehiclePurchaseInfo(int left, int right, int y, EngineID engine_number, TestedEngineDetails &te)
{
  const Engine *e = Engine::Get(engine_number);
  TimerGameCalendar::YearMonthDay ymd = TimerGameCalendar::ConvertDateToYMD(e->intro_date);
  bool refittable = IsArticulatedVehicleRefittable(engine_number);
  bool articulated_cargo = false;
 
  switch (e->type) {
    default: NOT_REACHED();
    case VEH_TRAIN:
      if (e->u.rail.railveh_type == RAILVEH_WAGON) {
        y = DrawRailWagonPurchaseInfo(left, right, y, engine_number, &e->u.rail, te);
      } else {
        y = DrawRailEnginePurchaseInfo(left, right, y, engine_number, &e->u.rail, te);
      }
      articulated_cargo = true;
      break;
 
    case VEH_ROAD:
      y = DrawRoadVehPurchaseInfo(left, right, y, engine_number, te);
      articulated_cargo = true;
      break;
 
    case VEH_SHIP:
      y = DrawShipPurchaseInfo(left, right, y, engine_number, refittable, te);
      break;
 
    case VEH_AIRCRAFT:
      y = DrawAircraftPurchaseInfo(left, right, y, engine_number, refittable, te);
      break;
  }
 
  if (articulated_cargo) {
    /* Cargo type + capacity, or N/A */
    int new_y = DrawCargoCapacityInfo(left, right, y, te, refittable);
 
    if (new_y == y) {
      SetDParam(0, INVALID_CARGO);
      SetDParam(2, STR_EMPTY);
      DrawString(left, right, y, STR_PURCHASE_INFO_CAPACITY);
      y += GetCharacterHeight(FS_NORMAL);
    } else {
      y = new_y;
    }
  }
 
  /* Draw details that apply to all types except rail wagons. */
  if (e->type != VEH_TRAIN || e->u.rail.railveh_type != RAILVEH_WAGON) {
    /* Design date - Life length */
    SetDParam(0, ymd.year);
    SetDParam(1, TimerGameCalendar::DateToYear(e->GetLifeLengthInDays()));
    DrawString(left, right, y, STR_PURCHASE_INFO_DESIGNED_LIFE);
    y += GetCharacterHeight(FS_NORMAL);
 
    /* Reliability */
    SetDParam(0, ToPercent16(e->reliability));
    DrawString(left, right, y, STR_PURCHASE_INFO_RELIABILITY);
    y += GetCharacterHeight(FS_NORMAL);
  }
 
  if (refittable) y = ShowRefitOptionsList(left, right, y, engine_number);
 
  /* Additional text from NewGRF */
  y = ShowAdditionalText(left, right, y, engine_number);
 
  /* The NewGRF's name which the vehicle comes from */
  const GRFConfig *config = GetGRFConfig(e->GetGRFID());
  if (_settings_client.gui.show_newgrf_name && config != nullptr)
  {
    DrawString(left, right, y, config->GetName(), TC_BLACK);
    y += GetCharacterHeight(FS_NORMAL);
  }
 
  return y;
}
 
void DrawEngineList(VehicleType type, const Rect &r, const GUIEngineList &eng_list, uint16_t min, uint16_t max, EngineID selected_id, bool show_count, GroupID selected_group)
{
  static const int sprite_y_offsets[] = { -1, -1, -2, -2 };
 
  /* Obligatory sanity checks! */
  assert(max <= eng_list.size());
 
  bool rtl = _current_text_dir == TD_RTL;
  int step_size = GetEngineListHeight(type);
  int sprite_left  = GetVehicleImageCellSize(type, EIT_PURCHASE).extend_left;
  int sprite_right = GetVehicleImageCellSize(type, EIT_PURCHASE).extend_right;
  int sprite_width = sprite_left + sprite_right;
  int circle_width = std::max(GetScaledSpriteSize(SPR_CIRCLE_FOLDED).width, GetScaledSpriteSize(SPR_CIRCLE_UNFOLDED).width);
  int linecolour = _colour_gradient[COLOUR_ORANGE][4];
 
  Rect ir      = r.WithHeight(step_size).Shrink(WidgetDimensions::scaled.matrix);
  int sprite_y_offset = ScaleSpriteTrad(sprite_y_offsets[type]) + ir.Height() / 2;
 
  Dimension replace_icon = {0, 0};
  int count_width = 0;
  if (show_count) {
    replace_icon = GetSpriteSize(SPR_GROUP_REPLACE_ACTIVE);
 
    uint biggest_num_engines = 0;
    for (auto i = min; i < max; i++) {
      const auto &item = eng_list[i];
      const uint num_engines = GetGroupNumEngines(_local_company, selected_group, item.engine_id);
      biggest_num_engines = std::max(biggest_num_engines, num_engines);
    }
 
    SetDParam(0, biggest_num_engines);
    count_width = GetStringBoundingBox(STR_JUST_COMMA, FS_SMALL).width;
  }
 
  Rect tr = ir.Indent(circle_width + WidgetDimensions::scaled.hsep_normal + sprite_width + WidgetDimensions::scaled.hsep_wide, rtl); // Name position
  Rect cr = tr.Indent(replace_icon.width + WidgetDimensions::scaled.hsep_wide, !rtl).WithWidth(count_width, !rtl);  // Count position
  Rect rr = tr.WithWidth(replace_icon.width, !rtl);                                                                 // Replace icon position
  if (show_count) tr = tr.Indent(count_width + WidgetDimensions::scaled.hsep_normal + replace_icon.width + WidgetDimensions::scaled.hsep_wide, !rtl);
 
  int normal_text_y_offset = (ir.Height() - GetCharacterHeight(FS_NORMAL)) / 2;
  int small_text_y_offset  = ir.Height() - GetCharacterHeight(FS_SMALL);
  int replace_icon_y_offset = (ir.Height() - replace_icon.height) / 2;
 
  int y = ir.top;
  for (; min < max; min++, y += step_size) {
    const auto &item = eng_list[min];
    uint indent       = item.indent * WidgetDimensions::scaled.hsep_indent;
    bool has_variants = (item.flags & EngineDisplayFlags::HasVariants) != EngineDisplayFlags::None;
    bool is_folded    = (item.flags & EngineDisplayFlags::IsFolded)    != EngineDisplayFlags::None;
    bool shaded       = (item.flags & EngineDisplayFlags::Shaded)      != EngineDisplayFlags::None;
    /* Note: num_engines is only used in the autoreplace GUI, so it is correct to use _local_company here. */
    const uint num_engines = GetGroupNumEngines(_local_company, selected_group, item.engine_id);
 
    const Engine *e = Engine::Get(item.engine_id);
    bool hidden = HasBit(e->company_hidden, _local_company);
    StringID str = hidden ? STR_HIDDEN_ENGINE_NAME : STR_ENGINE_NAME;
    TextColour tc = (item.engine_id == selected_id) ? TC_WHITE : ((hidden | shaded) ? (TC_GREY | TC_FORCED | TC_NO_SHADE) : TC_BLACK);
 
    if (show_count) {
      /* relies on show_count to find 'Vehicle in use' panel of autoreplace window */
      SetDParam(0, PackEngineNameDParam(item.engine_id, EngineNameContext::AutoreplaceVehicleInUse, item.indent));
    } else {
      SetDParam(0, PackEngineNameDParam(item.engine_id, EngineNameContext::PurchaseList, item.indent));
    }
    Rect itr = tr.Indent(indent, rtl);
    DrawString(itr.left, itr.right, y + normal_text_y_offset, str, tc);
    int sprite_x = ir.Indent(indent + circle_width + WidgetDimensions::scaled.hsep_normal, rtl).WithWidth(sprite_width, rtl).left + sprite_left;
    DrawVehicleEngine(r.left, r.right, sprite_x, y + sprite_y_offset, item.engine_id, (show_count && num_engines == 0) ? PALETTE_CRASH : GetEnginePalette(item.engine_id, _local_company), EIT_PURCHASE);
    if (show_count) {
      SetDParam(0, num_engines);
      DrawString(cr.left, cr.right, y + small_text_y_offset, STR_JUST_COMMA, TC_BLACK, SA_RIGHT | SA_FORCE, false, FS_SMALL);
      if (EngineHasReplacementForCompany(Company::Get(_local_company), item.engine_id, selected_group)) DrawSprite(SPR_GROUP_REPLACE_ACTIVE, num_engines == 0 ? PALETTE_CRASH : PAL_NONE, rr.left, y + replace_icon_y_offset);
    }
    if (has_variants) {
      Rect fr = ir.Indent(indent, rtl).WithWidth(circle_width, rtl);
      DrawSpriteIgnorePadding(is_folded ? SPR_CIRCLE_FOLDED : SPR_CIRCLE_UNFOLDED, PAL_NONE, {fr.left, y, fr.right, y + ir.Height() - 1}, SA_CENTER);
    }
    if (indent > 0) {
      /* Draw tree lines */
      Rect fr = ir.Indent(indent - WidgetDimensions::scaled.hsep_indent, rtl).WithWidth(circle_width, rtl);
      int ycenter = y + normal_text_y_offset + GetCharacterHeight(FS_NORMAL) / 2;
      bool continues = (min + 1U) < eng_list.size() && eng_list[min + 1].indent == item.indent;
      GfxDrawLine(fr.left + circle_width / 2, y - WidgetDimensions::scaled.matrix.top, fr.left + circle_width / 2, continues ? y - WidgetDimensions::scaled.matrix.top + step_size - 1 : ycenter, linecolour, WidgetDimensions::scaled.fullbevel.top);
      GfxDrawLine(fr.left + circle_width / 2, ycenter, fr.right, ycenter, linecolour, WidgetDimensions::scaled.fullbevel.top);
    }
  }
}
 
void DisplayVehicleSortDropDown(Window *w, VehicleType vehicle_type, int selected, WidgetID button)
{
  uint32_t hidden_mask = 0;
  /* Disable sorting by power or tractive effort when the original acceleration model for road vehicles is being used. */
  if (vehicle_type == VEH_ROAD && _settings_game.vehicle.roadveh_acceleration_model == AM_ORIGINAL) {
    SetBit(hidden_mask, 3); // power
    SetBit(hidden_mask, 4); // tractive effort
    SetBit(hidden_mask, 8); // power by running costs
  }
  /* Disable sorting by tractive effort when the original acceleration model for trains is being used. */
  if (vehicle_type == VEH_TRAIN && _settings_game.vehicle.train_acceleration_model == AM_ORIGINAL) {
    SetBit(hidden_mask, 4); // tractive effort
  }
  ShowDropDownMenu(w, _engine_sort_listing[vehicle_type], selected, button, 0, hidden_mask);
}
 
enum BuildVehicleHotkeys {
  BVHK_FOCUS_FILTER_BOX, 
};
 
struct BuildVehicleWindow : Window {
  VehicleType vehicle_type;                   
  union {
    RailType railtype;   
    RoadType roadtype;   
  } filter;                                   
  bool descending_sort_order;                 
  byte sort_criteria;                         
  bool show_hidden_engines;                   
  bool listview_mode;                         
  EngineID sel_engine;                        
  EngineID rename_engine;                     
  GUIEngineList eng_list;
  CargoID cargo_filter_criteria;              
  int details_height;                         
  Scrollbar *vscroll;
  TestedEngineDetails te;                     
 
  StringFilter string_filter;                 
  QueryString vehicle_editbox;                
 
  void SetBuyVehicleText()
  {
    NWidgetCore *widget = this->GetWidget<NWidgetCore>(WID_BV_BUILD);
 
    bool refit = this->sel_engine != INVALID_ENGINE && this->cargo_filter_criteria != CargoFilterCriteria::CF_ANY && this->cargo_filter_criteria != CargoFilterCriteria::CF_NONE && this->cargo_filter_criteria != CargoFilterCriteria::CF_ENGINES;
    if (refit) refit = Engine::Get(this->sel_engine)->GetDefaultCargoType() != this->cargo_filter_criteria;
 
    if (refit) {
      widget->widget_data = STR_BUY_VEHICLE_TRAIN_BUY_REFIT_VEHICLE_BUTTON + this->vehicle_type;
      widget->tool_tip    = STR_BUY_VEHICLE_TRAIN_BUY_REFIT_VEHICLE_TOOLTIP + this->vehicle_type;
    } else {
      widget->widget_data = STR_BUY_VEHICLE_TRAIN_BUY_VEHICLE_BUTTON + this->vehicle_type;
      widget->tool_tip    = STR_BUY_VEHICLE_TRAIN_BUY_VEHICLE_TOOLTIP + this->vehicle_type;
    }
  }
 
  void AddChildren(const GUIEngineList &source, EngineID parent, int indent)
  {
    for (const auto &item : source) {
      if (item.variant_id != parent || item.engine_id == parent) continue;
 
      const Engine *e = Engine::Get(item.engine_id);
      EngineDisplayFlags flags = item.flags;
      if (e->display_last_variant != INVALID_ENGINE) flags &= ~EngineDisplayFlags::Shaded;
      this->eng_list.emplace_back(e->display_last_variant == INVALID_ENGINE ? item.engine_id : e->display_last_variant, item.engine_id, flags, indent);
 
      /* Add variants if not folded */
      if ((item.flags & (EngineDisplayFlags::HasVariants | EngineDisplayFlags::IsFolded)) == EngineDisplayFlags::HasVariants) {
        /* Add this engine again as a child */
        if ((item.flags & EngineDisplayFlags::Shaded) == EngineDisplayFlags::None) {
          this->eng_list.emplace_back(item.engine_id, item.engine_id, EngineDisplayFlags::None, indent + 1);
        }
        AddChildren(source, item.engine_id, indent + 1);
      }
    }
  }
 
  BuildVehicleWindow(WindowDesc *desc, TileIndex tile, VehicleType type) : Window(desc), vehicle_editbox(MAX_LENGTH_VEHICLE_NAME_CHARS * MAX_CHAR_LENGTH, MAX_LENGTH_VEHICLE_NAME_CHARS)
  {
    this->vehicle_type = type;
    this->listview_mode = tile == INVALID_TILE;
    this->window_number = this->listview_mode ? (int)type : tile.base();
 
    this->sel_engine = INVALID_ENGINE;
 
    this->sort_criteria         = _engine_sort_last_criteria[type];
    this->descending_sort_order = _engine_sort_last_order[type];
    this->show_hidden_engines   = _engine_sort_show_hidden_engines[type];
 
    this->UpdateFilterByTile();
 
    this->CreateNestedTree();
 
    this->vscroll = this->GetScrollbar(WID_BV_SCROLLBAR);
 
    /* If we are just viewing the list of vehicles, we do not need the Build button.
     * So we just hide it, and enlarge the Rename button by the now vacant place. */
    if (this->listview_mode) this->GetWidget<NWidgetStacked>(WID_BV_BUILD_SEL)->SetDisplayedPlane(SZSP_NONE);
 
    NWidgetCore *widget = this->GetWidget<NWidgetCore>(WID_BV_LIST);
    widget->tool_tip = STR_BUY_VEHICLE_TRAIN_LIST_TOOLTIP + type;
 
    widget = this->GetWidget<NWidgetCore>(WID_BV_SHOW_HIDE);
    widget->tool_tip = STR_BUY_VEHICLE_TRAIN_HIDE_SHOW_TOGGLE_TOOLTIP + type;
 
    widget = this->GetWidget<NWidgetCore>(WID_BV_RENAME);
    widget->widget_data = STR_BUY_VEHICLE_TRAIN_RENAME_BUTTON + type;
    widget->tool_tip    = STR_BUY_VEHICLE_TRAIN_RENAME_TOOLTIP + type;
 
    widget = this->GetWidget<NWidgetCore>(WID_BV_SHOW_HIDDEN_ENGINES);
    widget->widget_data = STR_SHOW_HIDDEN_ENGINES_VEHICLE_TRAIN + type;
    widget->tool_tip    = STR_SHOW_HIDDEN_ENGINES_VEHICLE_TRAIN_TOOLTIP + type;
    widget->SetLowered(this->show_hidden_engines);
 
    this->details_height = ((this->vehicle_type == VEH_TRAIN) ? 10 : 9);
 
    if (tile == INVALID_TILE) {
      this->FinishInitNested(type);
    } else {
      this->FinishInitNested(tile);
    }
 
    this->querystrings[WID_BV_FILTER] = &this->vehicle_editbox;
    this->vehicle_editbox.cancel_button = QueryString::ACTION_CLEAR;
 
    this->owner = (tile != INVALID_TILE) ? GetTileOwner(tile) : _local_company;
 
    this->eng_list.ForceRebuild();
    this->GenerateBuildList(); // generate the list, since we need it in the next line
 
    /* Select the first unshaded engine in the list as default when opening the window */
    EngineID engine = INVALID_ENGINE;
    auto it = std::find_if(this->eng_list.begin(), this->eng_list.end(), [&](GUIEngineListItem &item){ return (item.flags & EngineDisplayFlags::Shaded) == EngineDisplayFlags::None; });
    if (it != this->eng_list.end()) engine = it->engine_id;
    this->SelectEngine(engine);
  }
 
  void UpdateFilterByTile()
  {
    switch (this->vehicle_type) {
      default: NOT_REACHED();
      case VEH_TRAIN:
        if (this->listview_mode) {
          this->filter.railtype = INVALID_RAILTYPE;
        } else {
          this->filter.railtype = GetRailType(this->window_number);
        }
        break;
 
      case VEH_ROAD:
        if (this->listview_mode) {
          this->filter.roadtype = INVALID_ROADTYPE;
        } else {
          this->filter.roadtype = GetRoadTypeRoad(this->window_number);
          if (this->filter.roadtype == INVALID_ROADTYPE) {
            this->filter.roadtype = GetRoadTypeTram(this->window_number);
          }
        }
        break;
 
      case VEH_SHIP:
      case VEH_AIRCRAFT:
        break;
    }
  }
 
  StringID GetCargoFilterLabel(CargoID cid) const
  {
    switch (cid) {
      case CargoFilterCriteria::CF_ANY: return STR_PURCHASE_INFO_ALL_TYPES;
      case CargoFilterCriteria::CF_ENGINES: return STR_PURCHASE_INFO_ENGINES_ONLY;
      case CargoFilterCriteria::CF_NONE: return STR_PURCHASE_INFO_NONE;
      default: return CargoSpec::Get(cid)->name;
    }
  }
 
  void SetCargoFilterArray()
  {
    /* Set the last cargo filter criteria. */
    this->cargo_filter_criteria = _engine_sort_last_cargo_criteria[this->vehicle_type];
    if (this->cargo_filter_criteria < NUM_CARGO && !HasBit(_standard_cargo_mask, this->cargo_filter_criteria)) this->cargo_filter_criteria = CargoFilterCriteria::CF_ANY;
 
    this->eng_list.SetFilterFuncs(_filter_funcs);
    this->eng_list.SetFilterState(this->cargo_filter_criteria != CargoFilterCriteria::CF_ANY);
  }
 
  void SelectEngine(EngineID engine)
  {
    CargoID cargo = this->cargo_filter_criteria;
    if (cargo == CargoFilterCriteria::CF_ANY || cargo == CargoFilterCriteria::CF_ENGINES || cargo == CargoFilterCriteria::CF_NONE) cargo = INVALID_CARGO;
 
    this->sel_engine = engine;
    this->SetBuyVehicleText();
 
    if (this->sel_engine == INVALID_ENGINE) return;
 
    const Engine *e = Engine::Get(this->sel_engine);
 
    if (!this->listview_mode) {
      /* Query for cost and refitted capacity */
      auto [ret, veh_id, refit_capacity, refit_mail, cargo_capacities] = Command<CMD_BUILD_VEHICLE>::Do(DC_QUERY_COST, this->window_number, this->sel_engine, true, cargo, INVALID_CLIENT_ID);
      if (ret.Succeeded()) {
        this->te.cost          = ret.GetCost() - e->GetCost();
        this->te.capacity      = refit_capacity;
        this->te.mail_capacity = refit_mail;
        this->te.cargo         = !IsValidCargoID(cargo) ? e->GetDefaultCargoType() : cargo;
        this->te.all_capacities = cargo_capacities;
        return;
      }
    }
 
    /* Purchase test was not possible or failed, fill in the defaults instead. */
    this->te.cost     = 0;
    this->te.FillDefaultCapacities(e);
  }
 
  void OnInit() override
  {
    this->SetCargoFilterArray();
  }
 
  void FilterEngineList()
  {
    this->eng_list.Filter(this->cargo_filter_criteria);
    if (0 == this->eng_list.size()) { // no engine passed through the filter, invalidate the previously selected engine
      this->SelectEngine(INVALID_ENGINE);
    } else if (std::find(this->eng_list.begin(), this->eng_list.end(), this->sel_engine) == this->eng_list.end()) { // previously selected engine didn't pass the filter, select the first engine of the list
      this->SelectEngine(this->eng_list[0].engine_id);
    }
  }
 
  bool FilterSingleEngine(EngineID eid)
  {
    GUIEngineListItem item = {eid, eid, EngineDisplayFlags::None, 0};
    return CargoAndEngineFilter(&item, this->cargo_filter_criteria);
  }
 
  bool FilterByText(const Engine *e)
  {
    /* Do not filter if the filter text box is empty */
    if (this->string_filter.IsEmpty()) return true;
 
    /* Filter engine name */
    this->string_filter.ResetState();
    SetDParam(0, PackEngineNameDParam(e->index, EngineNameContext::PurchaseList));
    this->string_filter.AddLine(GetString(STR_ENGINE_NAME));
 
    /* Filter NewGRF extra text */
    auto text = GetNewGRFAdditionalText(e->index);
    if (text) this->string_filter.AddLine(*text);
 
    return this->string_filter.GetState();
  }
 
  /* Figure out what train EngineIDs to put in the list */
  void GenerateBuildTrainList(GUIEngineList &list)
  {
    std::vector<EngineID> variants;
    EngineID sel_id = INVALID_ENGINE;
    size_t num_engines = 0;
 
    list.clear();
 
    /* Make list of all available train engines and wagons.
     * Also check to see if the previously selected engine is still available,
     * and if not, reset selection to INVALID_ENGINE. This could be the case
     * when engines become obsolete and are removed */
    for (const Engine *e : Engine::IterateType(VEH_TRAIN)) {
      if (!this->show_hidden_engines && e->IsVariantHidden(_local_company)) continue;
      EngineID eid = e->index;
      const RailVehicleInfo *rvi = &e->u.rail;
 
      if (this->filter.railtype != INVALID_RAILTYPE && !HasPowerOnRail(rvi->railtype, this->filter.railtype)) continue;
      if (!IsEngineBuildable(eid, VEH_TRAIN, _local_company)) continue;
 
      /* Filter now! So num_engines and num_wagons is valid */
      if (!FilterSingleEngine(eid)) continue;
 
      /* Filter by name or NewGRF extra text */
      if (!FilterByText(e)) continue;
 
      list.emplace_back(eid, e->info.variant_id, e->display_flags, 0);
 
      if (rvi->railveh_type != RAILVEH_WAGON) num_engines++;
 
      /* Add all parent variants of this engine to the variant list */
      EngineID parent = e->info.variant_id;
      while (parent != INVALID_ENGINE) {
        variants.push_back(parent);
        parent = Engine::Get(parent)->info.variant_id;
      }
 
      if (eid == this->sel_engine) sel_id = eid;
    }
 
    /* ensure primary engine of variant group is in list */
    for (const auto &variant : variants) {
      if (std::find(list.begin(), list.end(), variant) == list.end()) {
        const Engine *e = Engine::Get(variant);
        list.emplace_back(variant, e->info.variant_id, e->display_flags | EngineDisplayFlags::Shaded, 0);
        if (e->u.rail.railveh_type != RAILVEH_WAGON) num_engines++;
      }
    }
 
    this->SelectEngine(sel_id);
 
    /* invalidate cached values for name sorter - engine names could change */
    _last_engine[0] = _last_engine[1] = INVALID_ENGINE;
 
    /* make engines first, and then wagons, sorted by selected sort_criteria */
    _engine_sort_direction = false;
    EngList_Sort(list, TrainEnginesThenWagonsSorter);
 
    /* and then sort engines */
    _engine_sort_direction = this->descending_sort_order;
    EngList_SortPartial(list, _engine_sort_functions[0][this->sort_criteria], 0, num_engines);
 
    /* and finally sort wagons */
    EngList_SortPartial(list, _engine_sort_functions[0][this->sort_criteria], num_engines, list.size() - num_engines);
  }
 
  /* Figure out what road vehicle EngineIDs to put in the list */
  void GenerateBuildRoadVehList()
  {
    EngineID sel_id = INVALID_ENGINE;
 
    this->eng_list.clear();
 
    for (const Engine *e : Engine::IterateType(VEH_ROAD)) {
      if (!this->show_hidden_engines && e->IsVariantHidden(_local_company)) continue;
      EngineID eid = e->index;
      if (!IsEngineBuildable(eid, VEH_ROAD, _local_company)) continue;
      if (this->filter.roadtype != INVALID_ROADTYPE && !HasPowerOnRoad(e->u.road.roadtype, this->filter.roadtype)) continue;
 
      /* Filter by name or NewGRF extra text */
      if (!FilterByText(e)) continue;
 
      this->eng_list.emplace_back(eid, e->info.variant_id, e->display_flags, 0);
 
      if (eid == this->sel_engine) sel_id = eid;
    }
    this->SelectEngine(sel_id);
  }
 
  /* Figure out what ship EngineIDs to put in the list */
  void GenerateBuildShipList()
  {
    EngineID sel_id = INVALID_ENGINE;
    this->eng_list.clear();
 
    for (const Engine *e : Engine::IterateType(VEH_SHIP)) {
      if (!this->show_hidden_engines && e->IsVariantHidden(_local_company)) continue;
      EngineID eid = e->index;
      if (!IsEngineBuildable(eid, VEH_SHIP, _local_company)) continue;
 
      /* Filter by name or NewGRF extra text */
      if (!FilterByText(e)) continue;
 
      this->eng_list.emplace_back(eid, e->info.variant_id, e->display_flags, 0);
 
      if (eid == this->sel_engine) sel_id = eid;
    }
    this->SelectEngine(sel_id);
  }
 
  /* Figure out what aircraft EngineIDs to put in the list */
  void GenerateBuildAircraftList()
  {
    EngineID sel_id = INVALID_ENGINE;
 
    this->eng_list.clear();
 
    const Station *st = this->listview_mode ? nullptr : Station::GetByTile(this->window_number);
 
    /* Make list of all available planes.
     * Also check to see if the previously selected plane is still available,
     * and if not, reset selection to INVALID_ENGINE. This could be the case
     * when planes become obsolete and are removed */
    for (const Engine *e : Engine::IterateType(VEH_AIRCRAFT)) {
      if (!this->show_hidden_engines && e->IsVariantHidden(_local_company)) continue;
      EngineID eid = e->index;
      if (!IsEngineBuildable(eid, VEH_AIRCRAFT, _local_company)) continue;
      /* First VEH_END window_numbers are fake to allow a window open for all different types at once */
      if (!this->listview_mode && !CanVehicleUseStation(eid, st)) continue;
 
      /* Filter by name or NewGRF extra text */
      if (!FilterByText(e)) continue;
 
      this->eng_list.emplace_back(eid, e->info.variant_id, e->display_flags, 0);
 
      if (eid == this->sel_engine) sel_id = eid;
    }
 
    this->SelectEngine(sel_id);
  }
 
  /* Generate the list of vehicles */
  void GenerateBuildList()
  {
    if (!this->eng_list.NeedRebuild()) return;
 
    /* Update filter type in case the road/railtype of the depot got converted */
    this->UpdateFilterByTile();
 
    this->eng_list.clear();
 
    GUIEngineList list;
 
    switch (this->vehicle_type) {
      default: NOT_REACHED();
      case VEH_TRAIN:
        this->GenerateBuildTrainList(list);
        AddChildren(list, INVALID_ENGINE, 0);
        this->eng_list.shrink_to_fit();
        this->eng_list.RebuildDone();
        return;
      case VEH_ROAD:
        this->GenerateBuildRoadVehList();
        break;
      case VEH_SHIP:
        this->GenerateBuildShipList();
        break;
      case VEH_AIRCRAFT:
        this->GenerateBuildAircraftList();
        break;
    }
 
    this->FilterEngineList();
 
    /* ensure primary engine of variant group is in list after filtering */
    std::vector<EngineID> variants;
    for (const auto &item : this->eng_list) {
      EngineID parent = item.variant_id;
      while (parent != INVALID_ENGINE) {
        variants.push_back(parent);
        parent = Engine::Get(parent)->info.variant_id;
      }
    }
 
    for (const auto &variant : variants) {
      if (std::find(this->eng_list.begin(), this->eng_list.end(), variant) == this->eng_list.end()) {
        const Engine *e = Engine::Get(variant);
        this->eng_list.emplace_back(variant, e->info.variant_id, e->display_flags | EngineDisplayFlags::Shaded, 0);
      }
    }
 
    _engine_sort_direction = this->descending_sort_order;
    EngList_Sort(this->eng_list, _engine_sort_functions[this->vehicle_type][this->sort_criteria]);
 
    this->eng_list.swap(list);
    AddChildren(list, INVALID_ENGINE, 0);
    this->eng_list.shrink_to_fit();
    this->eng_list.RebuildDone();
  }
 
  DropDownList BuildCargoDropDownList() const
  {
    DropDownList list;
 
    /* Add item for disabling filtering. */
    list.push_back(std::make_unique<DropDownListStringItem>(this->GetCargoFilterLabel(CargoFilterCriteria::CF_ANY), CargoFilterCriteria::CF_ANY, false));
    /* Specific filters for trains. */
    if (this->vehicle_type == VEH_TRAIN) {
      /* Add item for locomotives only in case of trains. */
      list.push_back(std::make_unique<DropDownListStringItem>(this->GetCargoFilterLabel(CargoFilterCriteria::CF_ENGINES), CargoFilterCriteria::CF_ENGINES, false));
      /* Add item for vehicles not carrying anything, e.g. train engines.
       * This could also be useful for eyecandy vehicles of other types, but is likely too confusing for joe, */
      list.push_back(std::make_unique<DropDownListStringItem>(this->GetCargoFilterLabel(CargoFilterCriteria::CF_NONE), CargoFilterCriteria::CF_NONE, false));
    }
 
    /* Add cargos */
    Dimension d = GetLargestCargoIconSize();
    for (const CargoSpec *cs : _sorted_standard_cargo_specs) {
      list.push_back(std::make_unique<DropDownListIconItem>(d, cs->GetCargoIcon(), PAL_NONE, cs->name, cs->Index(), false));
    }
 
    return list;
  }
 
  void OnClick([[maybe_unused]] Point pt, WidgetID widget, [[maybe_unused]] int click_count) override
  {
    switch (widget) {
      case WID_BV_SORT_ASCENDING_DESCENDING:
        this->descending_sort_order ^= true;
        _engine_sort_last_order[this->vehicle_type] = this->descending_sort_order;
        this->eng_list.ForceRebuild();
        this->SetDirty();
        break;
 
      case WID_BV_SHOW_HIDDEN_ENGINES:
        this->show_hidden_engines ^= true;
        _engine_sort_show_hidden_engines[this->vehicle_type] = this->show_hidden_engines;
        this->eng_list.ForceRebuild();
        this->SetWidgetLoweredState(widget, this->show_hidden_engines);
        this->SetDirty();
        break;
 
      case WID_BV_LIST: {
        EngineID e = INVALID_ENGINE;
        const auto it = this->vscroll->GetScrolledItemFromWidget(this->eng_list, pt.y, this, WID_BV_LIST);
        if (it != this->eng_list.end()) {
          const auto &item = *it;
          const Rect r = this->GetWidget<NWidgetBase>(widget)->GetCurrentRect().Shrink(WidgetDimensions::scaled.matrix).WithWidth(WidgetDimensions::scaled.hsep_indent * (item.indent + 1), _current_text_dir == TD_RTL);
          if ((item.flags & EngineDisplayFlags::HasVariants) != EngineDisplayFlags::None && IsInsideMM(r.left, r.right, pt.x)) {
            /* toggle folded flag on engine */
            assert(item.variant_id != INVALID_ENGINE);
            Engine *engine = Engine::Get(item.variant_id);
            engine->display_flags ^= EngineDisplayFlags::IsFolded;
 
            InvalidateWindowData(WC_REPLACE_VEHICLE, this->vehicle_type, 0); // Update the autoreplace window
            InvalidateWindowClassesData(WC_BUILD_VEHICLE); // The build windows needs updating as well
            return;
          }
          if ((item.flags & EngineDisplayFlags::Shaded) == EngineDisplayFlags::None) e = item.engine_id;
        }
        this->SelectEngine(e);
        this->SetDirty();
        if (_ctrl_pressed) {
          this->OnClick(pt, WID_BV_SHOW_HIDE, 1);
        } else if (click_count > 1 && !this->listview_mode) {
          this->OnClick(pt, WID_BV_BUILD, 1);
        }
        break;
      }
 
      case WID_BV_SORT_DROPDOWN: // Select sorting criteria dropdown menu
        DisplayVehicleSortDropDown(this, this->vehicle_type, this->sort_criteria, WID_BV_SORT_DROPDOWN);
        break;
 
      case WID_BV_CARGO_FILTER_DROPDOWN: // Select cargo filtering criteria dropdown menu
        ShowDropDownList(this, this->BuildCargoDropDownList(), this->cargo_filter_criteria, widget);
        break;
 
      case WID_BV_SHOW_HIDE: {
        const Engine *e = (this->sel_engine == INVALID_ENGINE) ? nullptr : Engine::Get(this->sel_engine);
        if (e != nullptr) {
          Command<CMD_SET_VEHICLE_VISIBILITY>::Post(this->sel_engine, !e->IsHidden(_current_company));
        }
        break;
      }
 
      case WID_BV_BUILD: {
        EngineID sel_eng = this->sel_engine;
        if (sel_eng != INVALID_ENGINE) {
          CargoID cargo = this->cargo_filter_criteria;
          if (cargo == CargoFilterCriteria::CF_ANY || cargo == CargoFilterCriteria::CF_ENGINES || cargo == CargoFilterCriteria::CF_NONE) cargo = INVALID_CARGO;
          if (this->vehicle_type == VEH_TRAIN && RailVehInfo(sel_eng)->railveh_type == RAILVEH_WAGON) {
            Command<CMD_BUILD_VEHICLE>::Post(GetCmdBuildVehMsg(this->vehicle_type), CcBuildWagon, this->window_number, sel_eng, true, cargo, INVALID_CLIENT_ID);
          } else {
            Command<CMD_BUILD_VEHICLE>::Post(GetCmdBuildVehMsg(this->vehicle_type), CcBuildPrimaryVehicle, this->window_number, sel_eng, true, cargo, INVALID_CLIENT_ID);
          }
 
          /* Update last used variant in hierarchy and refresh if necessary. */
          bool refresh = false;
          EngineID parent = sel_eng;
          while (parent != INVALID_ENGINE) {
            Engine *e = Engine::Get(parent);
            refresh |= (e->display_last_variant != sel_eng);
            e->display_last_variant = sel_eng;
            parent = e->info.variant_id;
          }
          if (refresh) {
            InvalidateWindowData(WC_REPLACE_VEHICLE, this->vehicle_type, 0); // Update the autoreplace window
            InvalidateWindowClassesData(WC_BUILD_VEHICLE); // The build windows needs updating as well
            return;
          }
        }
        break;
      }
 
      case WID_BV_RENAME: {
        EngineID sel_eng = this->sel_engine;
        if (sel_eng != INVALID_ENGINE) {
          this->rename_engine = sel_eng;
          SetDParam(0, PackEngineNameDParam(sel_eng, EngineNameContext::Generic));
          ShowQueryString(STR_ENGINE_NAME, STR_QUERY_RENAME_TRAIN_TYPE_CAPTION + this->vehicle_type, MAX_LENGTH_ENGINE_NAME_CHARS, this, CS_ALPHANUMERAL, QSF_ENABLE_DEFAULT | QSF_LEN_IN_CHARS);
        }
        break;
      }
    }
  }
 
  void OnInvalidateData([[maybe_unused]] int data = 0, [[maybe_unused]] bool gui_scope = true) override
  {
    if (!gui_scope) return;
    /* When switching to original acceleration model for road vehicles, clear the selected sort criteria if it is not available now. */
    if (this->vehicle_type == VEH_ROAD &&
        _settings_game.vehicle.roadveh_acceleration_model == AM_ORIGINAL &&
        this->sort_criteria > 7) {
      this->sort_criteria = 0;
      _engine_sort_last_criteria[VEH_ROAD] = 0;
    }
    this->eng_list.ForceRebuild();
  }
 
  void SetStringParameters(WidgetID widget) const override
  {
    switch (widget) {
      case WID_BV_CAPTION:
        if (this->vehicle_type == VEH_TRAIN && !this->listview_mode) {
          const RailTypeInfo *rti = GetRailTypeInfo(this->filter.railtype);
          SetDParam(0, rti->strings.build_caption);
        } else if (this->vehicle_type == VEH_ROAD && !this->listview_mode) {
          const RoadTypeInfo *rti = GetRoadTypeInfo(this->filter.roadtype);
          SetDParam(0, rti->strings.build_caption);
        } else {
          SetDParam(0, (this->listview_mode ? STR_VEHICLE_LIST_AVAILABLE_TRAINS : STR_BUY_VEHICLE_TRAIN_ALL_CAPTION) + this->vehicle_type);
        }
        break;
 
      case WID_BV_SORT_DROPDOWN:
        SetDParam(0, _engine_sort_listing[this->vehicle_type][this->sort_criteria]);
        break;
 
      case WID_BV_CARGO_FILTER_DROPDOWN:
        SetDParam(0, this->GetCargoFilterLabel(this->cargo_filter_criteria));
        break;
 
      case WID_BV_SHOW_HIDE: {
        const Engine *e = (this->sel_engine == INVALID_ENGINE) ? nullptr : Engine::Get(this->sel_engine);
        if (e != nullptr && e->IsHidden(_local_company)) {
          SetDParam(0, STR_BUY_VEHICLE_TRAIN_SHOW_TOGGLE_BUTTON + this->vehicle_type);
        } else {
          SetDParam(0, STR_BUY_VEHICLE_TRAIN_HIDE_TOGGLE_BUTTON + this->vehicle_type);
        }
        break;
      }
    }
  }
 
  void UpdateWidgetSize(WidgetID widget, Dimension *size, [[maybe_unused]] const Dimension &padding, [[maybe_unused]] Dimension *fill, [[maybe_unused]] Dimension *resize) override
  {
    switch (widget) {
      case WID_BV_LIST:
        resize->height = GetEngineListHeight(this->vehicle_type);
        size->height = 3 * resize->height;
        size->width = std::max(size->width, GetVehicleImageCellSize(this->vehicle_type, EIT_PURCHASE).extend_left + GetVehicleImageCellSize(this->vehicle_type, EIT_PURCHASE).extend_right + 165) + padding.width;
        break;
 
      case WID_BV_PANEL:
        size->height = GetCharacterHeight(FS_NORMAL) * this->details_height + padding.height;
        break;
 
      case WID_BV_SORT_ASCENDING_DESCENDING: {
        Dimension d = GetStringBoundingBox(this->GetWidget<NWidgetCore>(widget)->widget_data);
        d.width += padding.width + Window::SortButtonWidth() * 2; // Doubled since the string is centred and it also looks better.
        d.height += padding.height;
        *size = maxdim(*size, d);
        break;
      }
 
      case WID_BV_CARGO_FILTER_DROPDOWN:
        size->width = std::max(size->width, GetDropDownListDimension(this->BuildCargoDropDownList()).width + padding.width);
        break;
 
      case WID_BV_BUILD:
        *size = GetStringBoundingBox(STR_BUY_VEHICLE_TRAIN_BUY_VEHICLE_BUTTON + this->vehicle_type);
        *size = maxdim(*size, GetStringBoundingBox(STR_BUY_VEHICLE_TRAIN_BUY_REFIT_VEHICLE_BUTTON + this->vehicle_type));
        size->width += padding.width;
        size->height += padding.height;
        break;
 
      case WID_BV_SHOW_HIDE:
        *size = GetStringBoundingBox(STR_BUY_VEHICLE_TRAIN_HIDE_TOGGLE_BUTTON + this->vehicle_type);
        *size = maxdim(*size, GetStringBoundingBox(STR_BUY_VEHICLE_TRAIN_SHOW_TOGGLE_BUTTON + this->vehicle_type));
        size->width += padding.width;
        size->height += padding.height;
        break;
    }
  }
 
  void DrawWidget(const Rect &r, WidgetID widget) const override
  {
    switch (widget) {
      case WID_BV_LIST:
        DrawEngineList(
          this->vehicle_type,
          r,
          this->eng_list,
          this->vscroll->GetPosition(),
          static_cast<uint16_t>(std::min<size_t>(this->vscroll->GetPosition() + this->vscroll->GetCapacity(), this->eng_list.size())),
          this->sel_engine,
          false,
          DEFAULT_GROUP
        );
        break;
 
      case WID_BV_SORT_ASCENDING_DESCENDING:
        this->DrawSortButtonState(WID_BV_SORT_ASCENDING_DESCENDING, this->descending_sort_order ? SBS_DOWN : SBS_UP);
        break;
    }
  }
 
  void OnPaint() override
  {
    this->GenerateBuildList();
    this->vscroll->SetCount(this->eng_list.size());
 
    this->SetWidgetsDisabledState(this->sel_engine == INVALID_ENGINE, WID_BV_SHOW_HIDE, WID_BV_BUILD);
 
    /* Disable renaming engines in network games if you are not the server. */
    this->SetWidgetDisabledState(WID_BV_RENAME, this->sel_engine == INVALID_ENGINE || (_networking && !_network_server));
 
    this->DrawWidgets();
 
    if (!this->IsShaded()) {
      int needed_height = this->details_height;
      /* Draw details panels. */
      if (this->sel_engine != INVALID_ENGINE) {
        const Rect r = this->GetWidget<NWidgetBase>(WID_BV_PANEL)->GetCurrentRect().Shrink(WidgetDimensions::scaled.frametext, WidgetDimensions::scaled.framerect);
        int text_end = DrawVehiclePurchaseInfo(r.left, r.right, r.top, this->sel_engine, this->te);
        needed_height = std::max(needed_height, (text_end - r.top) / GetCharacterHeight(FS_NORMAL));
      }
      if (needed_height != this->details_height) { // Details window are not high enough, enlarge them.
        int resize = needed_height - this->details_height;
        this->details_height = needed_height;
        this->ReInit(0, resize * GetCharacterHeight(FS_NORMAL));
        return;
      }
    }
  }
 
  void OnQueryTextFinished(char *str) override
  {
    if (str == nullptr) return;
 
    Command<CMD_RENAME_ENGINE>::Post(STR_ERROR_CAN_T_RENAME_TRAIN_TYPE + this->vehicle_type, this->rename_engine, str);
  }
 
  void OnDropdownSelect(WidgetID widget, int index) override
  {
    switch (widget) {
      case WID_BV_SORT_DROPDOWN:
        if (this->sort_criteria != index) {
          this->sort_criteria = index;
          _engine_sort_last_criteria[this->vehicle_type] = this->sort_criteria;
          this->eng_list.ForceRebuild();
        }
        break;
 
      case WID_BV_CARGO_FILTER_DROPDOWN: // Select a cargo filter criteria
        if (this->cargo_filter_criteria != index) {
          this->cargo_filter_criteria = index;
          _engine_sort_last_cargo_criteria[this->vehicle_type] = this->cargo_filter_criteria;
          /* deactivate filter if criteria is 'Show All', activate it otherwise */
          this->eng_list.SetFilterState(this->cargo_filter_criteria != CargoFilterCriteria::CF_ANY);
          this->eng_list.ForceRebuild();
          this->SelectEngine(this->sel_engine);
        }
        break;
    }
    this->SetDirty();
  }
 
  void OnResize() override
  {
    this->vscroll->SetCapacityFromWidget(this, WID_BV_LIST);
  }
 
  void OnEditboxChanged(WidgetID wid) override
  {
    if (wid == WID_BV_FILTER) {
      this->string_filter.SetFilterTerm(this->vehicle_editbox.text.buf);
      this->InvalidateData();
    }
  }
 
  EventState OnHotkey(int hotkey) override
  {
    switch (hotkey) {
      case BVHK_FOCUS_FILTER_BOX:
        this->SetFocusedWidget(WID_BV_FILTER);
        SetFocusedWindow(this); // The user has asked to give focus to the text box, so make sure this window is focused.
        return ES_HANDLED;
 
      default:
        return ES_NOT_HANDLED;
    }
 
    return ES_HANDLED;
  }
 
  static inline HotkeyList hotkeys{"buildvehicle", {
    Hotkey('F', "focus_filter_box", BVHK_FOCUS_FILTER_BOX),
  }};
};
 
static WindowDesc _build_vehicle_desc(__FILE__, __LINE__,
  WDP_AUTO, "build_vehicle", 240, 268,
  WC_BUILD_VEHICLE, WC_NONE,
  WDF_CONSTRUCTION,
  std::begin(_nested_build_vehicle_widgets), std::end(_nested_build_vehicle_widgets),
  &BuildVehicleWindow::hotkeys
);
 
void ShowBuildVehicleWindow(TileIndex tile, VehicleType type)
{
  /* We want to be able to open both Available Train as Available Ships,
   *  so if tile == INVALID_TILE (Available XXX Window), use 'type' as unique number.
   *  As it always is a low value, it won't collide with any real tile
   *  number. */
  uint num = (tile == INVALID_TILE) ? (int)type : tile.base();
 
  assert(IsCompanyBuildableVehicleType(type));
 
  CloseWindowById(WC_BUILD_VEHICLE, num);
 
  new BuildVehicleWindow(&_build_vehicle_desc, tile, type);
}