station_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 <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
 */

 
#include "stdafx.h"
#include "debug.h"
#include "gui.h"
#include "querystring_gui.h"
#include "textbuf_gui.h"
#include "company_func.h"
#include "command_func.h"
#include "vehicle_gui.h"
#include "cargotype.h"
#include "station_gui.h"
#include "strings_func.h"
#include "string_func.h"
#include "window_func.h"
#include "viewport_func.h"
#include "dropdown_type.h"
#include "dropdown_func.h"
#include "station_base.h"
#include "waypoint_base.h"
#include "tilehighlight_func.h"
#include "company_base.h"
#include "sortlist_type.h"
#include "core/geometry_func.hpp"
#include "vehiclelist.h"
#include "sound_func.h"
#include "town.h"
#include "linkgraph/linkgraph.h"
#include "zoom_func.h"
#include "station_cmd.h"
 
#include "widgets/station_widget.h"
#include "widgets/misc_widget.h"
 
#include "table/strings.h"
 
#include "dropdown_common_type.h"
 
#include "safeguards.h"
 
struct StationTypeFilter
{
  using StationType = Station;
 
  static bool IsValidID(StationID id) { return Station::IsValidID(id); }
  static bool IsValidBaseStation(const BaseStation *st) { return Station::IsExpected(st); }
  static bool IsAcceptableWaypointTile(TileIndex) { return false; }
  static constexpr bool IsWaypoint() { return false; }
};
 
template <bool ROAD, TileType TILE_TYPE>
struct GenericWaypointTypeFilter
{
  using StationType = Waypoint;
 
  static bool IsValidID(StationID id) { return Waypoint::IsValidID(id) && HasBit(Waypoint::Get(id)->waypoint_flags, WPF_ROAD) == ROAD; }
  static bool IsValidBaseStation(const BaseStation *st) { return Waypoint::IsExpected(st) && HasBit(Waypoint::From(st)->waypoint_flags, WPF_ROAD) == ROAD; }
  static bool IsAcceptableWaypointTile(TileIndex tile) { return IsTileType(tile, TILE_TYPE); }
  static constexpr bool IsWaypoint() { return true; }
};
using RailWaypointTypeFilter = GenericWaypointTypeFilter<false, TileType::Railway>;
using RoadWaypointTypeFilter = GenericWaypointTypeFilter<true, TileType::Road>;

int DrawStationCoverageAreaText(const Rect &r, StationCoverageType sct, int rad, bool supplies)
{
  TileIndex tile = TileVirtXY(_thd.pos.x, _thd.pos.y);
  CargoTypes cargo_mask{};
  if (_thd.drawstyle == HT_RECT && tile < Map::Size()) {
    CargoArray cargoes;
    if (supplies) {
      cargoes = GetProductionAroundTiles(tile, _thd.size.x / TILE_SIZE, _thd.size.y / TILE_SIZE, rad);
    } else {
      cargoes = GetAcceptanceAroundTiles(tile, _thd.size.x / TILE_SIZE, _thd.size.y / TILE_SIZE, rad).first;
    }
 
    /* Convert cargo counts to a set of cargo bits, and draw the result. */
    for (CargoType cargo : EnumRange(NUM_CARGO)) {
      switch (sct) {
        case SCT_PASSENGERS_ONLY: if (!IsCargoInClass(cargo, CargoClass::Passengers)) continue; break;
        case SCT_NON_PASSENGERS_ONLY: if (IsCargoInClass(cargo, CargoClass::Passengers)) continue; break;
        case SCT_ALL: break;
        default: NOT_REACHED();
      }
      if (cargoes[cargo] >= (supplies ? 1U : 8U)) cargo_mask.Set(cargo);
    }
  }
  return DrawStringMultiLine(r, GetString(supplies ? STR_STATION_BUILD_SUPPLIES_CARGO : STR_STATION_BUILD_ACCEPTS_CARGO, cargo_mask));
}

template <typename T>
void FindStationsAroundSelection()
{
  /* With distant join we don't know which station will be selected, so don't show any */
  if (_ctrl_pressed) {
    SetViewportCatchmentSpecializedStation<typename T::StationType>(nullptr, true);
    return;
  }
 
  /* Tile area for TileHighlightData */
  TileArea location(TileVirtXY(_thd.pos.x, _thd.pos.y), _thd.size.x / TILE_SIZE - 1, _thd.size.y / TILE_SIZE - 1);
 
  /* If the current tile is already a station, then it must be the nearest station. */
  if (IsTileType(location.tile, TileType::Station) && GetTileOwner(location.tile) == _local_company) {
    typename T::StationType *st = T::StationType::GetByTile(location.tile);
    if (st != nullptr && T::IsValidBaseStation(st)) {
      SetViewportCatchmentSpecializedStation<typename T::StationType>(st, true);
      return;
    }
  }
 
  /* Extended area by one tile */
  uint x = TileX(location.tile);
  uint y = TileY(location.tile);
 
  /* Waypoints can only be built on existing rail/road tiles, so don't extend area if not highlighting a rail tile. */
  int max_c = T::IsWaypoint() && !T::IsAcceptableWaypointTile(location.tile) ? 0 : 1;
  TileArea ta(TileXY(std::max<int>(0, x - max_c), std::max<int>(0, y - max_c)), TileXY(std::min<int>(Map::MaxX(), x + location.w + max_c), std::min<int>(Map::MaxY(), y + location.h + max_c)));
 
  typename T::StationType *adjacent = nullptr;
 
  /* Direct loop instead of ForAllStationsAroundTiles as we are not interested in catchment area */
  for (TileIndex tile : ta) {
    if (IsTileType(tile, TileType::Station) && GetTileOwner(tile) == _local_company) {
      typename T::StationType *st = T::StationType::GetByTile(tile);
      if (st == nullptr || !T::IsValidBaseStation(st)) continue;
      if (adjacent != nullptr && st != adjacent) {
        /* Multiple nearby, distant join is required. */
        adjacent = nullptr;
        break;
      }
      adjacent = st;
    }
  }
  SetViewportCatchmentSpecializedStation<typename T::StationType>(adjacent, true);
}

void CheckRedrawStationCoverage(const Window *w)
{
  /* Test if ctrl state changed */
  static bool _last_ctrl_pressed;
  if (_ctrl_pressed != _last_ctrl_pressed) {
    _thd.dirty = 0xff;
    _last_ctrl_pressed = _ctrl_pressed;
  }
 
  if (_thd.dirty & 1) {
    _thd.dirty &= ~1;
    w->SetDirty();
 
    if (_settings_client.gui.station_show_coverage && _thd.drawstyle == HT_RECT) {
      FindStationsAroundSelection<StationTypeFilter>();
    }
  }
}
 
template <typename T>
void CheckRedrawWaypointCoverage()
{
  /* Test if ctrl state changed */
  static bool _last_ctrl_pressed;
  if (_ctrl_pressed != _last_ctrl_pressed) {
    _thd.dirty = 0xff;
    _last_ctrl_pressed = _ctrl_pressed;
  }
 
  if (_thd.dirty & 1) {
    _thd.dirty &= ~1;
 
    if (_thd.drawstyle == HT_RECT) {
      FindStationsAroundSelection<T>();
    }
  }
}
 
void CheckRedrawRailWaypointCoverage(const Window *)
{
  CheckRedrawWaypointCoverage<RailWaypointTypeFilter>();
}
 
void CheckRedrawRoadWaypointCoverage(const Window *)
{
  CheckRedrawWaypointCoverage<RoadWaypointTypeFilter>();
}

static void StationsWndShowStationRating(int left, int right, int y, CargoType cargo, uint amount, uint8_t rating)
{
  static const uint units_full  = 576; 
  static const uint rating_full = 224; 
 
  const CargoSpec *cs = CargoSpec::Get(cargo);
  if (!cs->IsValid()) return;
 
  int padding = ScaleGUITrad(1);
  int width = right - left;
  PixelColour colour = cs->rating_colour;
  TextColour tc = GetContrastColour(colour);
  uint w = std::min(amount + 5, units_full) * width / units_full;
 
  int height = GetCharacterHeight(FontSize::Small) + padding - 1;
 
  if (amount > 30) {
    /* Draw total cargo (limited) on station */
    GfxFillRect(left, y, left + w - 1, y + height, colour);
  } else {
    /* Draw a (scaled) one pixel-wide bar of additional cargo meter, useful
     * for stations with only a small amount (<=30) */
    uint rest = ScaleGUITrad(amount) / 5;
    if (rest != 0) {
      GfxFillRect(left, y + height - rest, left + padding - 1, y + height, colour);
    }
  }
 
  DrawString(left + padding, right, y, cs->abbrev, tc, {AlignmentH::Centre, AlignmentV::Middle}, false, FontSize::Small);
 
  /* Draw green/red ratings bar (fits under the waiting bar) */
  y += height + padding + 1;
  GfxFillRect(left + padding, y, right - padding - 1, y + padding - 1, PC_RED);
  w = std::min<uint>(rating, rating_full) * (width - padding - padding) / rating_full;
  if (w != 0) GfxFillRect(left + padding, y, left + w - 1, y + padding - 1, PC_GREEN);
}
 
typedef GUIList<const Station*, const CargoTypes &> GUIStationList;

class CompanyStationsWindow : public Window {
protected:
  struct FilterState {
    Listing last_sorting;
    StationFacilities facilities; 
    bool include_no_rating; 
    CargoTypes cargoes; 
  };
 
  static inline FilterState initial_state = {
    {false, 0},
    {StationFacility::Train, StationFacility::TruckStop, StationFacility::BusStop, StationFacility::Airport, StationFacility::Dock},
    true,
    ALL_CARGOTYPES,
  };

  static inline const StringID sorter_names[] = {
    STR_SORT_BY_NAME,
    STR_SORT_BY_FACILITY,
    STR_SORT_BY_WAITING_TOTAL,
    STR_SORT_BY_WAITING_AVAILABLE,
    STR_SORT_BY_RATING_MAX,
    STR_SORT_BY_RATING_MIN,
  };
  static const std::initializer_list<GUIStationList::SortFunction * const> sorter_funcs; 
 
  StringFilter string_filter{}; 
  QueryString name_editbox; 
 
  FilterState filter{};
  GUIStationList stations{filter.cargoes};
  Scrollbar *vscroll = nullptr;
  uint rating_width = 0;
  bool filter_expanded = false;
  std::array<uint16_t, NUM_CARGO> stations_per_cargo_type{}; 
  uint16_t stations_per_cargo_type_no_rating = 0; 

  void BuildStationsList(const Owner owner)
  {
    if (!this->stations.NeedRebuild()) return;
 
    Debug(misc, 3, "Building station list for company {}", owner);
 
    this->stations.clear();
    this->stations_per_cargo_type.fill(0);
    this->stations_per_cargo_type_no_rating = 0;
 
    for (const Station *st : Station::Iterate()) {
      if (this->filter.facilities.Any(st->facilities)) { // only stations with selected facilities
        if (st->owner == owner || (st->owner == OWNER_NONE && HasStationInUse(st->index, true, owner))) {
          this->string_filter.ResetState();
          this->string_filter.AddLine(st->GetCachedName());
          if (!this->string_filter.GetState()) continue;
 
          bool has_rating = false;
          /* Add to the station/cargo counts. */
          for (CargoType cargo : EnumRange(NUM_CARGO)) {
            if (st->goods[cargo].HasRating()) this->stations_per_cargo_type[cargo]++;
          }
          for (CargoType cargo : EnumRange(NUM_CARGO)) {
            if (st->goods[cargo].HasRating()) {
              has_rating = true;
              if (this->filter.cargoes.Test(cargo)) {
                this->stations.push_back(st);
                break;
              }
            }
          }
          /* Stations with no cargo rating. */
          if (!has_rating) {
            if (this->filter.include_no_rating) this->stations.push_back(st);
            this->stations_per_cargo_type_no_rating++;
          }
        }
      }
    }
 
    this->stations.RebuildDone();
 
    this->vscroll->SetCount(this->stations.size()); // Update the scrollbar
  }

  static bool StationNameSorter(const Station * const &a, const Station * const &b, [[maybe_unused]] const CargoTypes &filter)
  {
    int r = StrNaturalCompare(a->GetCachedName(), b->GetCachedName()); // Sort by name (natural sorting).
    if (r == 0) return a->index < b->index;
    return r < 0;
  }

  static bool StationTypeSorter(const Station * const &a, const Station * const &b, [[maybe_unused]] const CargoTypes &filter)
  {
    return a->facilities < b->facilities;
  }

  static bool StationWaitingTotalSorter(const Station * const &a, const Station * const &b, const CargoTypes &filter)
  {
    int diff = 0;
 
    for (CargoType cargo : filter) {
      diff += a->goods[cargo].TotalCount() - b->goods[cargo].TotalCount();
    }
 
    return diff < 0;
  }

  static bool StationWaitingAvailableSorter(const Station * const &a, const Station * const &b, const CargoTypes &filter)
  {
    int diff = 0;
 
    for (CargoType cargo : filter) {
      diff += a->goods[cargo].AvailableCount() - b->goods[cargo].AvailableCount();
    }
 
    return diff < 0;
  }

  static bool StationRatingMaxSorter(const Station * const &a, const Station * const &b, const CargoTypes &filter)
  {
    uint8_t maxr1 = 0;
    uint8_t maxr2 = 0;
 
    for (CargoType cargo : filter) {
      if (a->goods[cargo].HasRating()) maxr1 = std::max(maxr1, a->goods[cargo].rating);
      if (b->goods[cargo].HasRating()) maxr2 = std::max(maxr2, b->goods[cargo].rating);
    }
 
    return maxr1 < maxr2;
  }

  static bool StationRatingMinSorter(const Station * const &a, const Station * const &b, const CargoTypes &filter)
  {
    uint8_t minr1 = 255;
    uint8_t minr2 = 255;
 
    for (CargoType cargo : filter) {
      if (a->goods[cargo].HasRating()) minr1 = std::min(minr1, a->goods[cargo].rating);
      if (b->goods[cargo].HasRating()) minr2 = std::min(minr2, b->goods[cargo].rating);
    }
 
    return minr1 > minr2;
  }

  void SortStationsList()
  {
    if (!this->stations.Sort()) return;
 
    /* Set the modified widget dirty */
    this->SetWidgetDirty(WID_STL_LIST);
  }
 
public:
  CompanyStationsWindow(WindowDesc &desc, WindowNumber window_number) : Window(desc), name_editbox(MAX_LENGTH_STATION_NAME_CHARS * MAX_CHAR_LENGTH, MAX_LENGTH_STATION_NAME_CHARS)
  {
    /* Load initial filter state. */
    this->filter = CompanyStationsWindow::initial_state;
    if (this->filter.cargoes == ALL_CARGOTYPES) this->filter.cargoes = _cargo_mask;
 
    this->stations.SetListing(this->filter.last_sorting);
    this->stations.SetSortFuncs(CompanyStationsWindow::sorter_funcs);
    this->stations.ForceRebuild();
    this->stations.NeedResort();
    this->SortStationsList();
 
    this->CreateNestedTree();
    this->vscroll = this->GetScrollbar(WID_STL_SCROLLBAR);
    this->FinishInitNested(window_number);
    this->owner = this->window_number;
 
    this->querystrings[WID_STL_FILTER] = &this->name_editbox;
    this->name_editbox.cancel_button = QueryString::ACTION_CLEAR;
 
    if (this->filter.cargoes == ALL_CARGOTYPES) this->filter.cargoes = _cargo_mask;
 
    for (StationFacility facil : this->filter.facilities) {
      this->LowerWidget(WID_STL_TRAIN + to_underlying(facil));
    }
 
    this->GetWidget<NWidgetCore>(WID_STL_SORTDROPBTN)->SetString(CompanyStationsWindow::sorter_names[this->stations.SortType()]);
  }

  ~CompanyStationsWindow() override
  {
    /* Save filter state. */
    this->filter.last_sorting = this->stations.GetListing();
    CompanyStationsWindow::initial_state = this->filter;
  }
 
  void UpdateWidgetSize(WidgetID widget, Dimension &size, [[maybe_unused]] const Dimension &padding, [[maybe_unused]] Dimension &fill, [[maybe_unused]] Dimension &resize) override
  {
    switch (widget) {
      case WID_STL_SORTBY: {
        Dimension d = GetStringBoundingBox(this->GetWidget<NWidgetCore>(widget)->GetString());
        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_STL_SORTDROPBTN: {
        Dimension d = GetStringListBoundingBox(CompanyStationsWindow::sorter_names);
        d.width += padding.width;
        d.height += padding.height;
        size = maxdim(size, d);
        break;
      }
 
      case WID_STL_LIST:
        fill.height = resize.height = std::max(GetCharacterHeight(FontSize::Normal), GetCharacterHeight(FontSize::Small) + ScaleGUITrad(3));
        size.height = padding.height + 5 * resize.height;
 
        /* Determine appropriate width for mini station rating graph */
        this->rating_width = 0;
        for (const CargoSpec *cs : _sorted_standard_cargo_specs) {
          this->rating_width = std::max(this->rating_width, GetStringBoundingBox(cs->abbrev, FontSize::Small).width);
        }
        /* Approximately match original 16 pixel wide rating bars by multiplying string width by 1.6 */
        this->rating_width = this->rating_width * 16 / 10;
        break;
    }
  }
 
  void OnPaint() override
  {
    this->BuildStationsList(this->window_number);
    this->SortStationsList();
 
    this->DrawWidgets();
  }
 
  void DrawWidget(const Rect &r, WidgetID widget) const override
  {
    switch (widget) {
      case WID_STL_SORTBY:
        /* draw arrow pointing up/down for ascending/descending sorting */
        this->DrawSortButton(WID_STL_SORTBY, this->stations.IsDescSortOrder());
        break;
 
      case WID_STL_LIST: {
        bool rtl = _current_text_dir == TD_RTL;
        Rect tr = r.Shrink(WidgetDimensions::scaled.framerect);
        uint line_height = this->GetWidget<NWidgetBase>(widget)->resize_y;
        /* Spacing between station name and first rating graph. */
        int text_spacing = WidgetDimensions::scaled.hsep_wide;
        /* Spacing between additional rating graphs. */
        int rating_spacing = WidgetDimensions::scaled.hsep_normal;
 
        auto [first, last] = this->vscroll->GetVisibleRangeIterators(this->stations);
        for (auto it = first; it != last; ++it) {
          const Station *st = *it;
          assert(st->xy != INVALID_TILE);
 
          /* Do not do the complex check HasStationInUse here, it may be even false
           * when the order had been removed and the station list hasn't been removed yet */
          assert(st->owner == owner || st->owner == OWNER_NONE);
 
          int x = DrawString(tr.left, tr.right, tr.top + (line_height - GetCharacterHeight(FontSize::Normal)) / 2, GetString(STR_STATION_LIST_STATION, st->index, st->facilities));
          x += rtl ? -text_spacing : text_spacing;
 
          /* show cargo waiting and station ratings */
          for (const CargoSpec *cs : _sorted_standard_cargo_specs) {
            CargoType cargo_type = cs->Index();
            if (st->goods[cargo_type].HasRating()) {
              /* For RTL we work in exactly the opposite direction. So
               * decrement the space needed first, then draw to the left
               * instead of drawing to the left and then incrementing
               * the space. */
              if (rtl) {
                x -= rating_width + rating_spacing;
                if (x < tr.left) break;
              }
              StationsWndShowStationRating(x, x + rating_width, tr.top, cargo_type, st->goods[cargo_type].TotalCount(), st->goods[cargo_type].rating);
              if (!rtl) {
                x += rating_width + rating_spacing;
                if (x > tr.right) break;
              }
            }
          }
          tr.top += line_height;
        }
 
        if (this->vscroll->GetCount() == 0) { // company has no stations
          DrawString(tr.left, tr.right, tr.top + (line_height - GetCharacterHeight(FontSize::Normal)) / 2, STR_STATION_LIST_NONE);
          return;
        }
        break;
      }
    }
  }
 
  std::string GetWidgetString(WidgetID widget, StringID stringid) const override
  {
    if (widget == WID_STL_CAPTION) {
      return GetString(STR_STATION_LIST_CAPTION, this->window_number, this->vscroll->GetCount());
    }
 
    if (widget == WID_STL_CARGODROPDOWN) {
      if (this->filter.cargoes.None()) return GetString(this->filter.include_no_rating ? STR_STATION_LIST_CARGO_FILTER_ONLY_NO_RATING : STR_STATION_LIST_CARGO_FILTER_NO_CARGO_TYPES);
      if (this->filter.cargoes == _cargo_mask) return GetString(this->filter.include_no_rating ? STR_STATION_LIST_CARGO_FILTER_ALL_AND_NO_RATING : STR_CARGO_TYPE_FILTER_ALL);
      if (this->filter.cargoes.Count() == 1 && !this->filter.include_no_rating) return GetString(CargoSpec::Get(*this->filter.cargoes.begin())->name);
      return GetString(STR_STATION_LIST_CARGO_FILTER_MULTIPLE);
    }
 
    return this->Window::GetWidgetString(widget, stringid);
  }
 
  DropDownList BuildCargoDropDownList(bool expanded) const
  {
    /* Define a custom item consisting of check mark, count string, icon and name string. */
    using DropDownListCargoItem = DropDownCheck<DropDownString<DropDownListIconItem, FontSize::Small, true>>;
 
    DropDownList list;
    list.push_back(MakeDropDownListStringItem(STR_STATION_LIST_CARGO_FILTER_SELECT_ALL, CargoFilterCriteria::CF_SELECT_ALL));
    list.push_back(MakeDropDownListDividerItem());
 
    bool any_hidden = false;
 
    uint16_t count = this->stations_per_cargo_type_no_rating;
    if (count == 0 && !expanded) {
      any_hidden = true;
    } else {
      list.push_back(std::make_unique<DropDownString<DropDownListCheckedItem, FontSize::Small, true>>(fmt::format("{}", count), 0, this->filter.include_no_rating, GetString(STR_STATION_LIST_CARGO_FILTER_NO_RATING), CargoFilterCriteria::CF_NO_RATING, false, count == 0));
    }
 
    Dimension d = GetLargestCargoIconSize();
    for (const CargoSpec *cs : _sorted_cargo_specs) {
      count = this->stations_per_cargo_type[cs->Index()];
      if (count == 0 && !expanded) {
        any_hidden = true;
      } else {
        list.push_back(std::make_unique<DropDownListCargoItem>(this->filter.cargoes.Test(cs->Index()), fmt::format("{}", count), d, cs->GetCargoIcon(), PAL_NONE, GetString(cs->name), cs->Index(), false, count == 0));
      }
    }
 
    if (!expanded && any_hidden) {
      if (list.size() > 2) list.push_back(MakeDropDownListDividerItem());
      list.push_back(MakeDropDownListStringItem(STR_STATION_LIST_CARGO_FILTER_EXPAND, CargoFilterCriteria::CF_EXPAND_LIST));
    }
 
    return list;
  }
 
  void OnClick([[maybe_unused]] Point pt, WidgetID widget, [[maybe_unused]] int click_count) override
  {
    switch (widget) {
      case WID_STL_LIST: {
        auto it = this->vscroll->GetScrolledItemFromWidget(this->stations, pt.y, this, WID_STL_LIST, WidgetDimensions::scaled.framerect.top);
        if (it == this->stations.end()) return; // click out of list bound
 
        const Station *st = *it;
        /* do not check HasStationInUse - it is slow and may be invalid */
        assert(st->owner == this->window_number || st->owner == OWNER_NONE);
 
        if (_ctrl_pressed) {
          ShowExtraViewportWindow(st->xy);
        } else {
          ScrollMainWindowToTile(st->xy);
        }
        break;
      }
 
      case WID_STL_TRAIN:
      case WID_STL_TRUCK:
      case WID_STL_BUS:
      case WID_STL_AIRPLANE:
      case WID_STL_SHIP:
        if (_ctrl_pressed) {
          this->filter.facilities.Flip(static_cast<StationFacility>(widget - WID_STL_TRAIN));
          this->ToggleWidgetLoweredState(widget);
        } else {
          for (StationFacility facil : this->filter.facilities) {
            this->RaiseWidget(WID_STL_TRAIN + to_underlying(facil));
          }
          this->filter.facilities = static_cast<StationFacility>(widget - WID_STL_TRAIN);
          this->LowerWidget(widget);
        }
        this->stations.ForceRebuild();
        this->SetDirty();
        SndClickBeep();
        break;
 
      case WID_STL_FACILALL:
        for (WidgetID i = WID_STL_TRAIN; i <= WID_STL_SHIP; i++) {
          this->LowerWidget(i);
        }
 
        this->filter.facilities = {StationFacility::Train, StationFacility::TruckStop, StationFacility::BusStop, StationFacility::Airport, StationFacility::Dock};
        this->stations.ForceRebuild();
        this->SetDirty();
        break;
 
      case WID_STL_SORTBY: // flip sorting method asc/desc
        this->stations.ToggleSortOrder();
        this->SetDirty();
        break;
 
      case WID_STL_SORTDROPBTN: // select sorting criteria dropdown menu
        ShowDropDownMenu(this, CompanyStationsWindow::sorter_names, this->stations.SortType(), WID_STL_SORTDROPBTN, 0, 0);
        break;
 
      case WID_STL_CARGODROPDOWN: {
        static std::string cargo_filter;
        this->filter_expanded = false;
        ShowDropDownList(this, this->BuildCargoDropDownList(this->filter_expanded), -1, widget, 0, {DropDownOption::Persist, DropDownOption::Filterable}, &cargo_filter);
        break;
      }
    }
  }
 
  void OnDropdownSelect(WidgetID widget, int index, int) override
  {
    if (widget == WID_STL_SORTDROPBTN) {
      if (this->stations.SortType() != index) {
        this->stations.SetSortType(index);
 
        /* Display the current sort variant */
        this->GetWidget<NWidgetCore>(WID_STL_SORTDROPBTN)->SetString(CompanyStationsWindow::sorter_names[this->stations.SortType()]);
 
        this->SetDirty();
      }
    }
 
    if (widget == WID_STL_CARGODROPDOWN) {
      FilterState oldstate = this->filter;
 
      if (index >= 0 && index < NUM_CARGO) {
        if (_ctrl_pressed) {
          this->filter.cargoes.Flip(static_cast<CargoType>(index));
        } else {
          this->filter.cargoes = static_cast<CargoType>(index);
          this->filter.include_no_rating = false;
        }
      } else if (index == CargoFilterCriteria::CF_NO_RATING) {
        if (_ctrl_pressed) {
          this->filter.include_no_rating = !this->filter.include_no_rating;
        } else {
          this->filter.include_no_rating = true;
          this->filter.cargoes.Reset();
        }
      } else if (index == CargoFilterCriteria::CF_SELECT_ALL) {
        this->filter.cargoes = _cargo_mask;
        this->filter.include_no_rating = true;
      } else if (index == CargoFilterCriteria::CF_EXPAND_LIST) {
        this->filter_expanded = true;
        ReplaceDropDownList(this, this->BuildCargoDropDownList(this->filter_expanded));
        return;
      }
 
      if (oldstate.cargoes != this->filter.cargoes || oldstate.include_no_rating != this->filter.include_no_rating) {
        this->stations.ForceRebuild();
        this->SetDirty();
 
        /* Only refresh the list if it's changed. */
        if (_ctrl_pressed) ReplaceDropDownList(this, this->BuildCargoDropDownList(this->filter_expanded));
      }
 
      /* Always close the list if ctrl is not pressed. */
      if (!_ctrl_pressed) this->CloseChildWindows(WindowClass::DropdownMenu);
    }
  }
 
  void OnGameTick() override
  {
    if (this->stations.NeedResort()) {
      Debug(misc, 3, "Periodic rebuild station list company {}", static_cast<int>(this->window_number));
      this->SetDirty();
    }
  }
 
  void OnResize() override
  {
    this->vscroll->SetCapacityFromWidget(this, WID_STL_LIST, WidgetDimensions::scaled.framerect.Vertical());
  }
 
  void OnEditboxChanged(WidgetID wid) override
  {
    if (wid == WID_STL_FILTER) {
      this->string_filter.SetFilterTerm(this->name_editbox.text.GetText());
      this->InvalidateData(TDIWD_FORCE_REBUILD);
    }
  }

  void OnInvalidateData([[maybe_unused]] int data = 0, [[maybe_unused]] bool gui_scope = true) override
  {
    if (data == 0) {
      /* This needs to be done in command-scope to enforce rebuilding before resorting invalid data */
      this->stations.ForceRebuild();
    } else {
      this->stations.ForceResort();
    }
  }
};
 
/* Available station sorting functions */
const std::initializer_list<GUIStationList::SortFunction * const> CompanyStationsWindow::sorter_funcs = {
  &StationNameSorter,
  &StationTypeSorter,
  &StationWaitingTotalSorter,
  &StationWaitingAvailableSorter,
  &StationRatingMaxSorter,
  &StationRatingMinSorter
};
 
static constexpr std::initializer_list<NWidgetPart> _nested_company_stations_widgets = {
  NWidget(NWID_HORIZONTAL),
    NWidget(WWT_CLOSEBOX, Colours::Grey),
    NWidget(WWT_CAPTION, Colours::Grey, WID_STL_CAPTION),
    NWidget(WWT_SHADEBOX, Colours::Grey),
    NWidget(WWT_DEFSIZEBOX, Colours::Grey),
    NWidget(WWT_STICKYBOX, Colours::Grey),
  EndContainer(),
  NWidget(NWID_HORIZONTAL),
    NWidget(WWT_TEXTBTN, Colours::Grey, WID_STL_TRAIN), SetAspect(WidgetDimensions::ASPECT_VEHICLE_ICON), SetStringTip(STR_TRAIN, STR_STATION_LIST_USE_CTRL_TO_SELECT_MORE_TOOLTIP), SetFill(0, 1),
    NWidget(WWT_TEXTBTN, Colours::Grey, WID_STL_TRUCK), SetAspect(WidgetDimensions::ASPECT_VEHICLE_ICON), SetStringTip(STR_LORRY, STR_STATION_LIST_USE_CTRL_TO_SELECT_MORE_TOOLTIP), SetFill(0, 1),
    NWidget(WWT_TEXTBTN, Colours::Grey, WID_STL_BUS), SetAspect(WidgetDimensions::ASPECT_VEHICLE_ICON), SetStringTip(STR_BUS, STR_STATION_LIST_USE_CTRL_TO_SELECT_MORE_TOOLTIP), SetFill(0, 1),
    NWidget(WWT_TEXTBTN, Colours::Grey, WID_STL_SHIP), SetAspect(WidgetDimensions::ASPECT_VEHICLE_ICON), SetStringTip(STR_SHIP, STR_STATION_LIST_USE_CTRL_TO_SELECT_MORE_TOOLTIP), SetFill(0, 1),
    NWidget(WWT_TEXTBTN, Colours::Grey, WID_STL_AIRPLANE), SetAspect(WidgetDimensions::ASPECT_VEHICLE_ICON), SetStringTip(STR_PLANE, STR_STATION_LIST_USE_CTRL_TO_SELECT_MORE_TOOLTIP), SetFill(0, 1),
    NWidget(WWT_PUSHTXTBTN, Colours::Grey, WID_STL_FACILALL), SetAspect(WidgetDimensions::ASPECT_VEHICLE_ICON), SetStringTip(STR_ABBREV_ALL, STR_STATION_LIST_SELECT_ALL_FACILITIES_TOOLTIP), SetTextStyle(TextColour::Black, FontSize::Small), SetFill(0, 1),
    NWidget(WWT_PANEL, Colours::Grey), SetMinimalSize(5, 0), SetFill(0, 1), EndContainer(),
    NWidget(WWT_DROPDOWN, Colours::Grey, WID_STL_CARGODROPDOWN), SetFill(1, 0), SetToolTip(STR_STATION_LIST_USE_CTRL_TO_SELECT_MORE_TOOLTIP),
    NWidget(WWT_PANEL, Colours::Grey), SetResize(1, 0), SetFill(1, 1), EndContainer(),
  EndContainer(),
  NWidget(NWID_HORIZONTAL),
    NWidget(WWT_PUSHTXTBTN, Colours::Grey, WID_STL_SORTBY), SetMinimalSize(0, 12), SetStringTip(STR_BUTTON_SORT_BY, STR_TOOLTIP_SORT_ORDER),
    NWidget(WWT_DROPDOWN, Colours::Grey, WID_STL_SORTDROPBTN), SetMinimalSize(0, 12), SetStringTip(STR_SORT_BY_NAME, STR_TOOLTIP_SORT_CRITERIA), // widget_data gets overwritten.
    NWidget(WWT_EDITBOX, Colours::Grey, WID_STL_FILTER), SetFill(1, 0), SetResize(1, 0), SetStringTip(STR_LIST_FILTER_OSKTITLE, STR_LIST_FILTER_TOOLTIP),
  EndContainer(),
  NWidget(NWID_HORIZONTAL),
    NWidget(WWT_PANEL, Colours::Grey, WID_STL_LIST), SetMinimalSize(346, 125), SetResize(1, 10), SetToolTip(STR_STATION_LIST_TOOLTIP), SetScrollbar(WID_STL_SCROLLBAR), EndContainer(),
    NWidget(NWID_VERTICAL),
      NWidget(NWID_VSCROLLBAR, Colours::Grey, WID_STL_SCROLLBAR),
      NWidget(WWT_RESIZEBOX, Colours::Grey),
    EndContainer(),
  EndContainer(),
};

static WindowDesc _company_stations_desc(
  WindowPosition::Automatic, "list_stations", 358, 162,
  WindowClass::StationList, WindowClass::None,
  {},
  _nested_company_stations_widgets
);

void ShowCompanyStations(CompanyID company)
{
  if (!Company::IsValidID(company)) return;
 
  AllocateWindowDescFront<CompanyStationsWindow>(_company_stations_desc, company);
}
 
static constexpr std::initializer_list<NWidgetPart> _nested_station_view_widgets = {
  NWidget(NWID_HORIZONTAL),
    NWidget(WWT_CLOSEBOX, Colours::Grey),
    NWidget(WWT_PUSHIMGBTN, Colours::Grey, WID_SV_RENAME), SetAspect(WidgetDimensions::ASPECT_RENAME), SetSpriteTip(SPR_RENAME, STR_STATION_VIEW_EDIT_TOOLTIP),
    NWidget(WWT_CAPTION, Colours::Grey, WID_SV_CAPTION),
    NWidget(WWT_PUSHIMGBTN, Colours::Grey, WID_SV_LOCATION), SetAspect(WidgetDimensions::ASPECT_LOCATION), SetSpriteTip(SPR_GOTO_LOCATION, STR_STATION_VIEW_CENTER_TOOLTIP),
    NWidget(WWT_SHADEBOX, Colours::Grey),
    NWidget(WWT_DEFSIZEBOX, Colours::Grey),
    NWidget(WWT_STICKYBOX, Colours::Grey),
  EndContainer(),
  NWidget(NWID_HORIZONTAL),
    NWidget(WWT_TEXTBTN, Colours::Grey, WID_SV_GROUP), SetMinimalSize(81, 12), SetFill(1, 1), SetStringTip(STR_STATION_VIEW_GROUP),
    NWidget(WWT_DROPDOWN, Colours::Grey, WID_SV_GROUP_BY), SetMinimalSize(168, 12), SetResize(1, 0), SetFill(0, 1), SetToolTip(STR_TOOLTIP_GROUP_ORDER),
  EndContainer(),
  NWidget(NWID_HORIZONTAL),
    NWidget(WWT_PUSHTXTBTN, Colours::Grey, WID_SV_SORT_ORDER), SetMinimalSize(81, 12), SetFill(1, 1), SetStringTip(STR_BUTTON_SORT_BY, STR_TOOLTIP_SORT_ORDER),
    NWidget(WWT_DROPDOWN, Colours::Grey, WID_SV_SORT_BY), SetMinimalSize(168, 12), SetResize(1, 0), SetFill(0, 1), SetToolTip(STR_TOOLTIP_SORT_CRITERIA),
  EndContainer(),
  NWidget(NWID_HORIZONTAL),
    NWidget(WWT_PANEL, Colours::Grey, WID_SV_WAITING), SetMinimalSize(237, 44), SetResize(1, 10), SetScrollbar(WID_SV_SCROLLBAR), EndContainer(),
    NWidget(NWID_VSCROLLBAR, Colours::Grey, WID_SV_SCROLLBAR),
  EndContainer(),
  NWidget(WWT_PANEL, Colours::Grey, WID_SV_ACCEPT_RATING_LIST), SetMinimalSize(249, 23), SetResize(1, 0), EndContainer(),
  NWidget(NWID_HORIZONTAL, NWidContainerFlag::EqualSize),
    NWidget(WWT_PUSHTXTBTN, Colours::Grey, WID_SV_ACCEPTS_RATINGS), SetMinimalSize(46, 12), SetResize(1, 0), SetFill(1, 1),
        SetStringTip(STR_STATION_VIEW_RATINGS_BUTTON, STR_STATION_VIEW_RATINGS_TOOLTIP),
    NWidget(NWID_SELECTION, Colours::Invalid, WID_SV_CLOSE_AIRPORT_SEL),
      NWidget(WWT_TEXTBTN, Colours::Grey, WID_SV_CLOSE_AIRPORT), SetMinimalSize(45, 12), SetResize(1, 0), SetFill(1, 1),
          SetStringTip(STR_STATION_VIEW_CLOSE_AIRPORT, STR_STATION_VIEW_CLOSE_AIRPORT_TOOLTIP),
    EndContainer(),
    NWidget(WWT_TEXTBTN, Colours::Grey, WID_SV_CATCHMENT), SetMinimalSize(45, 12), SetResize(1, 0), SetFill(1, 1), SetStringTip(STR_BUTTON_CATCHMENT, STR_TOOLTIP_CATCHMENT),
    NWidget(WWT_PUSHTXTBTN, Colours::Grey, WID_SV_TRAINS), SetAspect(WidgetDimensions::ASPECT_VEHICLE_ICON), SetFill(0, 1), SetStringTip(STR_TRAIN, STR_STATION_VIEW_SCHEDULED_TRAINS_TOOLTIP),
    NWidget(WWT_PUSHTXTBTN, Colours::Grey, WID_SV_ROADVEHS), SetAspect(WidgetDimensions::ASPECT_VEHICLE_ICON), SetFill(0, 1), SetStringTip(STR_LORRY, STR_STATION_VIEW_SCHEDULED_ROAD_VEHICLES_TOOLTIP),
    NWidget(WWT_PUSHTXTBTN, Colours::Grey, WID_SV_SHIPS), SetAspect(WidgetDimensions::ASPECT_VEHICLE_ICON), SetFill(0, 1), SetStringTip(STR_SHIP, STR_STATION_VIEW_SCHEDULED_SHIPS_TOOLTIP),
    NWidget(WWT_PUSHTXTBTN, Colours::Grey, WID_SV_PLANES),  SetAspect(WidgetDimensions::ASPECT_VEHICLE_ICON), SetFill(0, 1), SetStringTip(STR_PLANE, STR_STATION_VIEW_SCHEDULED_AIRCRAFT_TOOLTIP),
    NWidget(WWT_RESIZEBOX, Colours::Grey),
  EndContainer(),
};
 
enum SortOrder : uint8_t {
  SO_DESCENDING,
  SO_ASCENDING
};
 
class CargoDataEntry;

enum class CargoSortType : uint8_t {
  AsGrouping,    
  Count,         
  StationString, 
  StationID,     
  CargoType,     
};
 
class CargoSorter {
public:
  using is_transparent = void;
  CargoSorter(CargoSortType t = CargoSortType::StationID, SortOrder o = SO_ASCENDING) : type(t), order(o) {}
  CargoSortType GetSortType() {return this->type;}
  bool operator()(const CargoDataEntry &cd1, const CargoDataEntry &cd2) const;
  bool operator()(const CargoDataEntry &cd1, const std::unique_ptr<CargoDataEntry> &cd2) const { return this->operator()(cd1, *cd2); }
  bool operator()(const std::unique_ptr<CargoDataEntry> &cd1, const CargoDataEntry &cd2) const { return this->operator()(*cd1, cd2); }
  bool operator()(const std::unique_ptr<CargoDataEntry> &cd1, const std::unique_ptr<CargoDataEntry> &cd2) const { return this->operator()(*cd1, *cd2); }
 
private:
  CargoSortType type;
  SortOrder order;
 
  template <class Tid>
  bool SortId(Tid st1, Tid st2) const;
  bool SortCount(const CargoDataEntry &cd1, const CargoDataEntry &cd2) const;
  bool SortStation(StationID st1, StationID st2) const;
};
 
typedef std::set<std::unique_ptr<CargoDataEntry>, CargoSorter> CargoDataSet;

class CargoDataEntry {
public:
  CargoDataEntry();
  ~CargoDataEntry();

  CargoDataEntry &InsertOrRetrieve(StationID station)
  {
    return this->InsertOrRetrieve<StationID>(station);
  }

  CargoDataEntry &InsertOrRetrieve(CargoType cargo)
  {
    return this->InsertOrRetrieve<CargoType>(cargo);
  }
 
  void Update(uint count);

  void Remove(StationID station)
  {
    CargoDataEntry t(station);
    this->Remove(t);
  }

  void Remove(CargoType cargo)
  {
    CargoDataEntry t(cargo);
    this->Remove(t);
  }

  CargoDataEntry *Retrieve(StationID station) const
  {
    CargoDataEntry t(station);
    return this->Retrieve(this->children->find(t));
  }

  CargoDataEntry *Retrieve(CargoType cargo) const
  {
    CargoDataEntry t(cargo);
    return this->Retrieve(this->children->find(t));
  }
 
  void Resort(CargoSortType type, SortOrder order);

  StationID GetStation() const { return this->station; }

  CargoType GetCargo() const { return this->cargo; }

  uint GetCount() const { return this->count; }

  CargoDataEntry *GetParent() const { return this->parent; }

  uint GetNumChildren() const { return this->num_children; }

  CargoDataSet::iterator Begin() const { return this->children->begin(); }

  CargoDataSet::iterator End() const { return this->children->end(); }

  bool HasTransfers() const { return this->transfers; }

  void SetTransfers(bool value) { this->transfers = value; }
 
  void Clear();
 
  CargoDataEntry(StationID station, uint count, CargoDataEntry *parent);
  CargoDataEntry(CargoType cargo, uint count, CargoDataEntry *parent);
  CargoDataEntry(StationID station);
  CargoDataEntry(CargoType cargo);
 
private:
  CargoDataEntry *Retrieve(CargoDataSet::iterator i) const;
 
  template <class Tid>
  CargoDataEntry &InsertOrRetrieve(Tid s);
 
  void Remove(CargoDataEntry &entry);
  void IncrementSize();
 
  CargoDataEntry *parent;   
  const union {
    StationID station;    
    struct {
      CargoType cargo;    
      bool transfers;   
    };
  };
  uint num_children;        
  uint count;               
  std::unique_ptr<CargoDataSet> children;   
};
 
CargoDataEntry::CargoDataEntry() :
  parent(nullptr),
  station(StationID::Invalid()),
  num_children(0),
  count(0),
  children(std::make_unique<CargoDataSet>(CargoSorter(CargoSortType::CargoType)))
{}
 
CargoDataEntry::CargoDataEntry(CargoType cargo, uint count, CargoDataEntry *parent) :
  parent(parent),
  cargo(cargo),
  num_children(0),
  count(count),
  children(std::make_unique<CargoDataSet>())
{}
 
CargoDataEntry::CargoDataEntry(StationID station, uint count, CargoDataEntry *parent) :
  parent(parent),
  station(station),
  num_children(0),
  count(count),
  children(std::make_unique<CargoDataSet>())
{}
 
CargoDataEntry::CargoDataEntry(StationID station) :
  parent(nullptr),
  station(station),
  num_children(0),
  count(0),
  children(nullptr)
{}
 
CargoDataEntry::CargoDataEntry(CargoType cargo) :
  parent(nullptr),
  cargo(cargo),
  num_children(0),
  count(0),
  children(nullptr)
{}

CargoDataEntry::~CargoDataEntry()
{
  this->Clear();
}

void CargoDataEntry::Clear()
{
  if (this->children != nullptr) this->children->clear();
  if (this->parent != nullptr) this->parent->count -= this->count;
  this->count = 0;
  this->num_children = 0;
}

void CargoDataEntry::Remove(CargoDataEntry &entry)
{
  CargoDataSet::iterator i = this->children->find(entry);
  if (i != this->children->end()) this->children->erase(i);
}

template <class Tid>
CargoDataEntry &CargoDataEntry::InsertOrRetrieve(Tid child_id)
{
  CargoDataEntry tmp(child_id);
  CargoDataSet::iterator i = this->children->find(tmp);
  if (i == this->children->end()) {
    IncrementSize();
    return **(this->children->insert(std::make_unique<CargoDataEntry>(child_id, 0, this)).first);
  } else {
    assert(this->children->value_comp().GetSortType() != CargoSortType::Count);
    return **i;
  }
}

void CargoDataEntry::Update(uint count)
{
  this->count += count;
  if (this->parent != nullptr) this->parent->Update(count);
}

void CargoDataEntry::IncrementSize()
{
   ++this->num_children;
   if (this->parent != nullptr) this->parent->IncrementSize();
}
 
void CargoDataEntry::Resort(CargoSortType type, SortOrder order)
{
  auto new_children = std::make_unique<CargoDataSet>(CargoSorter(type, order));
  new_children->merge(*this->children);
  this->children = std::move(new_children);
}
 
CargoDataEntry *CargoDataEntry::Retrieve(CargoDataSet::iterator i) const
{
  if (i == this->children->end()) {
    return nullptr;
  } else {
    assert(this->children->value_comp().GetSortType() != CargoSortType::Count);
    return i->get();
  }
}
 
bool CargoSorter::operator()(const CargoDataEntry &cd1, const CargoDataEntry &cd2) const
{
  switch (this->type) {
    case CargoSortType::StationID:
      return this->SortId<StationID>(cd1.GetStation(), cd2.GetStation());
    case CargoSortType::CargoType:
      return this->SortId<CargoType>(cd1.GetCargo(), cd2.GetCargo());
    case CargoSortType::Count:
      return this->SortCount(cd1, cd2);
    case CargoSortType::StationString:
      return this->SortStation(cd1.GetStation(), cd2.GetStation());
    default:
      NOT_REACHED();
  }
}
 
template <class Tid>
bool CargoSorter::SortId(Tid st1, Tid st2) const
{
  return (this->order == SO_ASCENDING) ? st1 < st2 : st2 < st1;
}
 
bool CargoSorter::SortCount(const CargoDataEntry &cd1, const CargoDataEntry &cd2) const
{
  uint c1 = cd1.GetCount();
  uint c2 = cd2.GetCount();
  if (c1 == c2) {
    return this->SortStation(cd1.GetStation(), cd2.GetStation());
  } else if (this->order == SO_ASCENDING) {
    return c1 < c2;
  } else {
    return c2 < c1;
  }
}
 
bool CargoSorter::SortStation(StationID st1, StationID st2) const
{
  if (!Station::IsValidID(st1)) {
    return Station::IsValidID(st2) ? this->order == SO_ASCENDING : this->SortId(st1, st2);
  } else if (!Station::IsValidID(st2)) {
    return order == SO_DESCENDING;
  }
 
  int res = StrNaturalCompare(Station::Get(st1)->GetCachedName(), Station::Get(st2)->GetCachedName()); // Sort by name (natural sorting).
  if (res == 0) {
    return this->SortId(st1, st2);
  } else {
    return (this->order == SO_ASCENDING) ? res < 0 : res > 0;
  }
}

struct StationViewWindow : public Window {
  struct RowDisplay {
    RowDisplay(CargoDataEntry *f, StationID n) : filter(f), next_station(n) {}
    RowDisplay(CargoDataEntry *f, CargoType n) : filter(f), next_cargo(n) {}

    CargoDataEntry *filter;
    union {
      StationID next_station;

      CargoType next_cargo;
    };
  };
 
  typedef std::vector<RowDisplay> CargoDataVector;
 
  static const int NUM_COLUMNS = 4; 

  enum Invalidation : uint16_t {
    INV_FLOWS = 0x100, 
    INV_CARGO = 0x200  
  };

  enum Grouping : uint8_t {
    GR_SOURCE,      
    GR_NEXT,        
    GR_DESTINATION, 
    GR_CARGO,       
  };

  enum Mode : uint8_t {
    MODE_WAITING, 
    MODE_PLANNED  
  };
 
  uint expand_shrink_width = 0; 
  int rating_lines = RATING_LINES; 
  int accepts_lines = ACCEPTS_LINES; 
  int line_height = 0; 
  Dimension cargo_icon_size{}; 
  Scrollbar *vscroll = nullptr;
 
  /* Height of the #WID_SV_ACCEPT_RATING_LIST widget for different views. */
  static constexpr uint RATING_LINES = 13; 
  static constexpr uint ACCEPTS_LINES = 3; 

  static inline const StringID sort_names[] = {
    STR_STATION_VIEW_WAITING_STATION,
    STR_STATION_VIEW_WAITING_AMOUNT,
    STR_STATION_VIEW_PLANNED_STATION,
    STR_STATION_VIEW_PLANNED_AMOUNT,
  };

  static inline const StringID group_names[] = {
    STR_STATION_VIEW_GROUP_S_V_D,
    STR_STATION_VIEW_GROUP_S_D_V,
    STR_STATION_VIEW_GROUP_V_S_D,
    STR_STATION_VIEW_GROUP_V_D_S,
    STR_STATION_VIEW_GROUP_D_S_V,
    STR_STATION_VIEW_GROUP_D_V_S,
  };

  std::array<CargoSortType, NUM_COLUMNS> sortings{};

  std::array<SortOrder, NUM_COLUMNS> sort_orders{};
 
  int scroll_to_row = INT_MAX; 
  int grouping_index = 0; 
  Mode current_mode{}; 
  std::array<Grouping, NUM_COLUMNS> groupings; 
 
  CargoDataEntry expanded_rows{}; 
  CargoDataEntry cached_destinations{}; 
  CargoDataVector displayed_rows{}; 
 
  StationViewWindow(WindowDesc &desc, WindowNumber window_number) : Window(desc)
  {
    this->CreateNestedTree();
    this->GetWidget<NWidgetStacked>(WID_SV_CLOSE_AIRPORT_SEL)->SetDisplayedPlane(Station::Get(window_number)->facilities.Test(StationFacility::Airport) ? 0 : SZSP_NONE);
    this->vscroll = this->GetScrollbar(WID_SV_SCROLLBAR);
    /* Nested widget tree creation is done in two steps to ensure that this->GetWidget<NWidgetCore>(WID_SV_ACCEPTS_RATINGS) exists in UpdateWidgetSize(). */
    this->FinishInitNested(window_number);
 
    this->groupings[0] = GR_CARGO;
    this->sortings[0] = CargoSortType::AsGrouping;
    this->SelectGroupBy(_settings_client.gui.station_gui_group_order);
    this->SelectSortBy(_settings_client.gui.station_gui_sort_by);
    this->sort_orders[0] = SO_ASCENDING;
    this->SelectSortOrder((SortOrder)_settings_client.gui.station_gui_sort_order);
    this->owner = Station::Get(window_number)->owner;
  }
 
  void OnInit() override
  {
    this->cargo_icon_size = GetLargestCargoIconSize();
    this->line_height = std::max<int>(GetCharacterHeight(FontSize::Normal), this->cargo_icon_size.height);
    this->expand_shrink_width = std::max(GetCharacterWidth(FontSize::Normal, '-'), GetCharacterWidth(FontSize::Normal, '+'));
  }
 
  void Close([[maybe_unused]] int data = 0) override
  {
    CloseWindowById(WindowClass::TrainList, VehicleListIdentifier(VehicleListType::Station, VehicleType::Train, this->owner, this->window_number).ToWindowNumber(), false);
    CloseWindowById(WindowClass::RoadVehicleList, VehicleListIdentifier(VehicleListType::Station, VehicleType::Road, this->owner, this->window_number).ToWindowNumber(), false);
    CloseWindowById(WindowClass::ShipList, VehicleListIdentifier(VehicleListType::Station, VehicleType::Ship, this->owner, this->window_number).ToWindowNumber(), false);
    CloseWindowById(WindowClass::AircraftList, VehicleListIdentifier(VehicleListType::Station, VehicleType::Aircraft, this->owner, this->window_number).ToWindowNumber(), false);
 
    SetViewportCatchmentStation(Station::Get(this->window_number), false);
    this->Window::Close();
  }

  void ShowCargo(CargoDataEntry *data, CargoType cargo, StationID source, StationID next, StationID dest, uint count)
  {
    if (count == 0) return;
    bool auto_distributed = _settings_game.linkgraph.GetDistributionType(cargo) != DistributionType::Manual;
    const CargoDataEntry *expand = &this->expanded_rows;
    for (int i = 0; i < NUM_COLUMNS && expand != nullptr; ++i) {
      switch (groupings[i]) {
        case GR_CARGO:
          assert(i == 0);
          data = &data->InsertOrRetrieve(cargo);
          data->SetTransfers(source != this->window_number);
          expand = expand->Retrieve(cargo);
          break;
        case GR_SOURCE:
          if (auto_distributed || source != this->window_number) {
            data = &data->InsertOrRetrieve(source);
            expand = expand->Retrieve(source);
          }
          break;
        case GR_NEXT:
          if (auto_distributed) {
            data = &data->InsertOrRetrieve(next);
            expand = expand->Retrieve(next);
          }
          break;
        case GR_DESTINATION:
          if (auto_distributed) {
            data = &data->InsertOrRetrieve(dest);
            expand = expand->Retrieve(dest);
          }
          break;
      }
    }
    data->Update(count);
  }
 
  void UpdateWidgetSize(WidgetID widget, Dimension &size, [[maybe_unused]] const Dimension &padding, [[maybe_unused]] Dimension &fill, [[maybe_unused]] Dimension &resize) override
  {
    switch (widget) {
      case WID_SV_WAITING:
        fill.height = resize.height = this->line_height;
        size.height = 4 * resize.height + padding.height;
        break;
 
      case WID_SV_ACCEPT_RATING_LIST:
        size.height = ((this->GetWidget<NWidgetCore>(WID_SV_ACCEPTS_RATINGS)->GetString() == STR_STATION_VIEW_RATINGS_BUTTON) ? this->accepts_lines : this->rating_lines) * GetCharacterHeight(FontSize::Normal) + padding.height;
        break;
    }
  }
 
  void OnPaint() override
  {
    const Station *st = Station::Get(this->window_number);
    CargoDataEntry cargo;
    BuildCargoList(&cargo, st);
 
    this->vscroll->SetCount(cargo.GetNumChildren()); // update scrollbar
 
    /* disable some buttons */
    this->SetWidgetDisabledState(WID_SV_RENAME,   st->owner != _local_company);
    this->SetWidgetDisabledState(WID_SV_TRAINS,   !st->facilities.Test(StationFacility::Train));
    this->SetWidgetDisabledState(WID_SV_ROADVEHS, !st->facilities.Test(StationFacility::TruckStop) && !st->facilities.Test(StationFacility::BusStop));
    this->SetWidgetDisabledState(WID_SV_SHIPS,    !st->facilities.Test(StationFacility::Dock));
    this->SetWidgetDisabledState(WID_SV_PLANES,   !st->facilities.Test(StationFacility::Airport));
    this->SetWidgetDisabledState(WID_SV_CLOSE_AIRPORT, !st->facilities.Test(StationFacility::Airport) || st->owner != _local_company || st->owner == OWNER_NONE); // Also consider SE, where _local_company == OWNER_NONE
    this->SetWidgetLoweredState(WID_SV_CLOSE_AIRPORT, st->facilities.Test(StationFacility::Airport) && st->airport.blocks.Test(AirportBlock::AirportClosed));
 
    extern const Station *_viewport_highlight_station;
    this->SetWidgetDisabledState(WID_SV_CATCHMENT, st->facilities.None());
    this->SetWidgetLoweredState(WID_SV_CATCHMENT, _viewport_highlight_station == st);
 
    this->DrawWidgets();
 
    if (!this->IsShaded()) {
      /* Draw 'accepted cargo' or 'cargo ratings'. */
      const NWidgetBase *wid = this->GetWidget<NWidgetBase>(WID_SV_ACCEPT_RATING_LIST);
      const Rect r = wid->GetCurrentRect();
      if (this->GetWidget<NWidgetCore>(WID_SV_ACCEPTS_RATINGS)->GetString() == STR_STATION_VIEW_RATINGS_BUTTON) {
        int lines = this->DrawAcceptedCargo(r);
        if (lines > this->accepts_lines) { // Resize the widget, and perform re-initialization of the window.
          this->accepts_lines = lines;
          this->ReInit();
          return;
        }
      } else {
        int lines = this->DrawCargoRatings(r);
        if (lines > this->rating_lines) { // Resize the widget, and perform re-initialization of the window.
          this->rating_lines = lines;
          this->ReInit();
          return;
        }
      }
 
      /* Draw arrow pointing up/down for ascending/descending sorting */
      this->DrawSortButton(WID_SV_SORT_ORDER, sort_orders[1] != SO_ASCENDING);
 
      int pos = this->vscroll->GetPosition();
 
      int maxrows = this->vscroll->GetCapacity();
 
      displayed_rows.clear();
 
      /* Draw waiting cargo. */
      NWidgetBase *nwi = this->GetWidget<NWidgetBase>(WID_SV_WAITING);
      Rect waiting_rect = nwi->GetCurrentRect().Shrink(WidgetDimensions::scaled.framerect);
      this->DrawEntries(cargo, waiting_rect, pos, maxrows, 0);
      scroll_to_row = INT_MAX;
    }
  }
 
  std::string GetWidgetString(WidgetID widget, StringID stringid) const override
  {
    if (widget == WID_SV_CAPTION) {
      const Station *st = Station::Get(this->window_number);
      return GetString(STR_STATION_VIEW_CAPTION, st->index, st->facilities);
    }
 
    return this->Window::GetWidgetString(widget, stringid);
  }

  void RecalcDestinations(CargoType cargo)
  {
    const Station *st = Station::Get(this->window_number);
    CargoDataEntry &entry = cached_destinations.InsertOrRetrieve(cargo);
    entry.Clear();
 
    if (!st->goods[cargo].HasData()) return;
 
    for (const auto &it : st->goods[cargo].GetData().flows) {
      StationID from = it.first;
      CargoDataEntry &source_entry = entry.InsertOrRetrieve(from);
      uint32_t prev_count = 0;
      for (const auto &flow_it : *it.second.GetShares()) {
        StationID via = flow_it.second;
        CargoDataEntry &via_entry = source_entry.InsertOrRetrieve(via);
        if (via == this->window_number) {
          via_entry.InsertOrRetrieve(via).Update(flow_it.first - prev_count);
        } else {
          EstimateDestinations(cargo, from, via, flow_it.first - prev_count, via_entry);
        }
        prev_count = flow_it.first;
      }
    }
  }

  void EstimateDestinations(CargoType cargo, StationID source, StationID next, uint count, CargoDataEntry &dest)
  {
    if (Station::IsValidID(next) && Station::IsValidID(source)) {
      GoodsEntry &ge = Station::Get(next)->goods[cargo];
      if (!ge.HasData()) return;
 
      CargoDataEntry tmp;
      const FlowStatMap &flowmap = ge.GetData().flows;
      FlowStatMap::const_iterator map_it = flowmap.find(source);
      if (map_it != flowmap.end()) {
        const FlowStat::SharesMap *shares = map_it->second.GetShares();
        uint32_t prev_count = 0;
        for (FlowStat::SharesMap::const_iterator i = shares->begin(); i != shares->end(); ++i) {
          tmp.InsertOrRetrieve(i->second).Update(i->first - prev_count);
          prev_count = i->first;
        }
      }
 
      if (tmp.GetCount() == 0) {
        dest.InsertOrRetrieve(StationID::Invalid()).Update(count);
      } else {
        uint sum_estimated = 0;
        while (sum_estimated < count) {
          for (CargoDataSet::iterator i = tmp.Begin(); i != tmp.End() && sum_estimated < count; ++i) {
            CargoDataEntry &child = **i;
            uint estimate = DivideApprox(child.GetCount() * count, tmp.GetCount());
            if (estimate == 0) estimate = 1;
 
            sum_estimated += estimate;
            if (sum_estimated > count) {
              estimate -= sum_estimated - count;
              sum_estimated = count;
            }
 
            if (estimate > 0) {
              if (child.GetStation() == next) {
                dest.InsertOrRetrieve(next).Update(estimate);
              } else {
                EstimateDestinations(cargo, source, child.GetStation(), estimate, dest);
              }
            }
          }
 
        }
      }
    } else {
      dest.InsertOrRetrieve(StationID::Invalid()).Update(count);
    }
  }

  void BuildFlowList(CargoType cargo, const FlowStatMap &flows, CargoDataEntry *entry)
  {
    const CargoDataEntry *source_dest = this->cached_destinations.Retrieve(cargo);
    for (FlowStatMap::const_iterator it = flows.begin(); it != flows.end(); ++it) {
      StationID from = it->first;
      const CargoDataEntry *source_entry = source_dest->Retrieve(from);
      const FlowStat::SharesMap *shares = it->second.GetShares();
      for (FlowStat::SharesMap::const_iterator flow_it = shares->begin(); flow_it != shares->end(); ++flow_it) {
        const CargoDataEntry *via_entry = source_entry->Retrieve(flow_it->second);
        for (CargoDataSet::iterator dest_it = via_entry->Begin(); dest_it != via_entry->End(); ++dest_it) {
          CargoDataEntry &dest_entry = **dest_it;
          ShowCargo(entry, cargo, from, flow_it->second, dest_entry.GetStation(), dest_entry.GetCount());
        }
      }
    }
  }

  void BuildCargoList(CargoType cargo, const StationCargoList &packets, CargoDataEntry *entry)
  {
    const CargoDataEntry *source_dest = this->cached_destinations.Retrieve(cargo);
    for (StationCargoList::ConstIterator it = packets.Packets()->begin(); it != packets.Packets()->end(); it++) {
      const CargoPacket *cp = *it;
      StationID next = it.GetKey();
 
      const CargoDataEntry *source_entry = source_dest->Retrieve(cp->GetFirstStation());
      if (source_entry == nullptr) {
        this->ShowCargo(entry, cargo, cp->GetFirstStation(), next, StationID::Invalid(), cp->Count());
        continue;
      }
 
      const CargoDataEntry *via_entry = source_entry->Retrieve(next);
      if (via_entry == nullptr) {
        this->ShowCargo(entry, cargo, cp->GetFirstStation(), next, StationID::Invalid(), cp->Count());
        continue;
      }
 
      uint remaining = cp->Count();
      for (CargoDataSet::iterator dest_it = via_entry->Begin(); dest_it != via_entry->End();) {
        CargoDataEntry &dest_entry = **dest_it;
 
        /* Advance iterator here instead of in the for statement to test whether this is the last entry */
        ++dest_it;
 
        uint val;
        if (dest_it == via_entry->End()) {
          /* Allocate all remaining waiting cargo to the last destination to avoid
           * waiting cargo being "lost", and the displayed total waiting cargo
           * not matching GoodsEntry::TotalCount() */
          val = remaining;
        } else {
          val = std::min<uint>(remaining, DivideApprox(cp->Count() * dest_entry.GetCount(), via_entry->GetCount()));
          remaining -= val;
        }
        this->ShowCargo(entry, cargo, cp->GetFirstStation(), next, dest_entry.GetStation(), val);
      }
    }
    this->ShowCargo(entry, cargo, NEW_STATION, NEW_STATION, NEW_STATION, packets.ReservedCount());
  }

  void BuildCargoList(CargoDataEntry *entry, const Station *st)
  {
    for (CargoType cargo : EnumRange(NUM_CARGO)) {
 
      if (this->cached_destinations.Retrieve(cargo) == nullptr) {
        this->RecalcDestinations(cargo);
      }
 
      const GoodsEntry &ge = st->goods[cargo];
      if (!ge.HasData()) continue;
 
      if (this->current_mode == MODE_WAITING) {
        this->BuildCargoList(cargo, ge.GetData().cargo, entry);
      } else {
        this->BuildFlowList(cargo, ge.GetData().flows, entry);
      }
    }
  }

  void SetDisplayedRow(const CargoDataEntry &entry)
  {
    std::list<StationID> stations;
    const CargoDataEntry *parent = entry.GetParent();
    if (parent->GetParent() == nullptr) {
      this->displayed_rows.push_back(RowDisplay(&this->expanded_rows, entry.GetCargo()));
      return;
    }
 
    StationID next = entry.GetStation();
    while (parent->GetParent()->GetParent() != nullptr) {
      stations.push_back(parent->GetStation());
      parent = parent->GetParent();
    }
 
    CargoType cargo = parent->GetCargo();
    CargoDataEntry *filter = this->expanded_rows.Retrieve(cargo);
    while (!stations.empty()) {
      filter = filter->Retrieve(stations.back());
      stations.pop_back();
    }
 
    this->displayed_rows.push_back(RowDisplay(filter, next));
  }

  StringID GetEntryString(StationID station, StringID here, StringID other_station, StringID any) const
  {
    if (station == this->window_number) {
      return here;
    } else if (station == StationID::Invalid()) {
      return any;
    } else if (station == NEW_STATION) {
      return STR_STATION_VIEW_RESERVED;
    } else {
      return other_station;
    }
  }
 
  StringID GetGroupingString(Grouping grouping, StationID station) const
  {
    switch (grouping) {
      case GR_SOURCE: return this->GetEntryString(station, STR_STATION_VIEW_FROM_HERE, STR_STATION_VIEW_FROM, STR_STATION_VIEW_FROM_ANY);
      case GR_NEXT: return this->GetEntryString(station, STR_STATION_VIEW_VIA_HERE, STR_STATION_VIEW_VIA, STR_STATION_VIEW_VIA_ANY);
      case GR_DESTINATION: return this->GetEntryString(station, STR_STATION_VIEW_TO_HERE, STR_STATION_VIEW_TO, STR_STATION_VIEW_TO_ANY);
      default: NOT_REACHED();
    }
  }

  StringID SearchNonStop(CargoDataEntry &cd, StationID station, int column)
  {
    assert(column < NUM_COLUMNS);
    CargoDataEntry *parent = cd.GetParent();
    for (int i = column - 1; i > 0; --i) {
      if (this->groupings[i] == GR_DESTINATION) {
        if (parent->GetStation() == station) {
          return STR_STATION_VIEW_NONSTOP;
        } else {
          return STR_STATION_VIEW_VIA;
        }
      }
      parent = parent->GetParent();
    }
 
    if (column < NUM_COLUMNS - 1 && this->groupings[column + 1] == GR_DESTINATION) {
      CargoDataSet::iterator begin = cd.Begin();
      CargoDataSet::iterator end = cd.End();
      if (begin != end && ++(cd.Begin()) == end && (*(begin))->GetStation() == station) {
        return STR_STATION_VIEW_NONSTOP;
      } else {
        return STR_STATION_VIEW_VIA;
      }
    }
 
    return STR_STATION_VIEW_VIA;
  }

  void DrawCargoIcons(CargoType cargo, uint waiting, const Rect &r) const
  {
    int width = ScaleSpriteTrad(10);
    uint num = std::min<uint>((waiting + (width / 2)) / width, r.Width() / width); // maximum is width / 10 icons so it won't overflow
    if (num == 0) return;
 
    SpriteID sprite = CargoSpec::Get(cargo)->GetCargoIcon();
 
    int x = _current_text_dir == TD_RTL ? r.left : r.right - num * width;
    int y = CentreBounds(r.top, r.bottom, this->cargo_icon_size.height);
    do {
      DrawSprite(sprite, PAL_NONE, x, y);
      x += width;
    } while (--num);
  }

  int DrawEntries(CargoDataEntry &entry, const Rect &r, int pos, int maxrows, int column, CargoType cargo = INVALID_CARGO)
  {
    assert(column < NUM_COLUMNS);
    if (this->sortings[column] == CargoSortType::AsGrouping) {
      if (this->groupings[column] != GR_CARGO) {
        entry.Resort(CargoSortType::StationString, this->sort_orders[column]);
      }
    } else {
      entry.Resort(CargoSortType::Count, this->sort_orders[column]);
    }
    int text_y_offset = (this->line_height - GetCharacterHeight(FontSize::Normal)) / 2;
    for (CargoDataSet::iterator i = entry.Begin(); i != entry.End(); ++i) {
      CargoDataEntry &cd = **i;
 
      Grouping grouping = this->groupings[column];
      if (grouping == GR_CARGO) cargo = cd.GetCargo();
      bool auto_distributed = _settings_game.linkgraph.GetDistributionType(cargo) != DistributionType::Manual;
 
      if (pos > -maxrows && pos <= 0) {
        StringID str = STR_EMPTY;
        StationID station = StationID::Invalid();
        int y = r.top - pos * this->line_height;
        if (this->groupings[column] == GR_CARGO) {
          str = STR_STATION_VIEW_WAITING_CARGO;
          this->DrawCargoIcons(cd.GetCargo(), cd.GetCount(), Rect(r.left + this->expand_shrink_width, y, r.right - this->expand_shrink_width, y + this->line_height - 1));
        } else {
          if (!auto_distributed) grouping = GR_SOURCE;
          station = cd.GetStation();
          str = this->GetGroupingString(grouping, station);
          if (grouping == GR_NEXT && str == STR_STATION_VIEW_VIA) str = this->SearchNonStop(cd, station, column);
 
          if (pos == -this->scroll_to_row && Station::IsValidID(station)) {
            ScrollMainWindowToTile(Station::Get(station)->xy);
          }
        }
 
        bool rtl = _current_text_dir == TD_RTL;
        Rect text = r.Indent(column * WidgetDimensions::scaled.hsep_indent, rtl).Indent(this->expand_shrink_width, !rtl);
        Rect shrink = r.WithWidth(this->expand_shrink_width, !rtl);
 
        DrawString(text.left, text.right, y + text_y_offset, GetString(str, cargo, cd.GetCount(), station));
 
        if (column < NUM_COLUMNS - 1) {
          std::string_view sym;
          if (cd.GetNumChildren() > 0) {
            sym = "-";
          } else if (auto_distributed && str != STR_STATION_VIEW_RESERVED) {
            sym = "+";
          } else {
            /* Only draw '+' if there is something to be shown. */
            const GoodsEntry &ge = Station::Get(this->window_number)->goods[cargo];
            if (ge.HasData()) {
              const StationCargoList &cargo_list = ge.GetData().cargo;
              if (grouping == GR_CARGO && (cargo_list.ReservedCount() > 0 || cd.HasTransfers())) {
                sym = "+";
              }
            }
          }
          if (!sym.empty()) DrawString(shrink.left, shrink.right, y + text_y_offset, sym, TextColour::Yellow);
        }
        this->SetDisplayedRow(cd);
      }
      --pos;
      if ((auto_distributed || column == 0) && column < NUM_COLUMNS - 1) {
        pos = this->DrawEntries(cd, r, pos, maxrows, column + 1, cargo);
      }
    }
    return pos;
  }

  int DrawAcceptedCargo(const Rect &r) const
  {
    const Station *st = Station::Get(this->window_number);
    Rect tr = r.Shrink(WidgetDimensions::scaled.framerect);
 
    int bottom = DrawStringMultiLine(tr.left, tr.right, tr.top, INT32_MAX, GetString(STR_STATION_VIEW_ACCEPTS_CARGO, GetAcceptanceMask(st)));
    return CeilDiv(bottom - r.top - WidgetDimensions::scaled.framerect.top, GetCharacterHeight(FontSize::Normal));
  }

  int DrawCargoRatings(const Rect &r) const
  {
    const Station *st = Station::Get(this->window_number);
    bool rtl = _current_text_dir == TD_RTL;
    Rect tr = r.Shrink(WidgetDimensions::scaled.framerect);
 
    if (st->town->exclusive_counter > 0) {
      tr.top = DrawStringMultiLine(tr, GetString(st->town->exclusivity == st->owner ? STR_STATION_VIEW_EXCLUSIVE_RIGHTS_SELF : STR_STATION_VIEW_EXCLUSIVE_RIGHTS_COMPANY, st->town->exclusivity));
      tr.top += WidgetDimensions::scaled.vsep_wide;
    }
 
    DrawString(tr, TimerGameEconomy::UsingWallclockUnits() ? STR_STATION_VIEW_SUPPLY_RATINGS_TITLE_MINUTE : STR_STATION_VIEW_SUPPLY_RATINGS_TITLE_MONTH);
    tr.top += GetCharacterHeight(FontSize::Normal);
 
    for (const CargoSpec *cs : _sorted_standard_cargo_specs) {
      const GoodsEntry *ge = &st->goods[cs->Index()];
      if (!ge->HasRating()) continue;
 
      const LinkGraph *lg = LinkGraph::GetIfValid(ge->link_graph);
      DrawString(tr.Indent(WidgetDimensions::scaled.hsep_indent, rtl),
        GetString(STR_STATION_VIEW_CARGO_SUPPLY_RATING,
          cs->name,
          lg != nullptr ? lg->Monthly((*lg)[ge->node].supply) : 0,
          STR_CARGO_RATING_APPALLING + (ge->rating >> 5),
          ToPercent8(ge->rating)));
      tr.top += GetCharacterHeight(FontSize::Normal);
    }
    return CeilDiv(tr.top - r.top - WidgetDimensions::scaled.framerect.top, GetCharacterHeight(FontSize::Normal));
  }

  template <class Tid>
  void HandleCargoWaitingClick(CargoDataEntry *filter, Tid next)
  {
    if (filter->Retrieve(next) != nullptr) {
      filter->Remove(next);
    } else {
      filter->InsertOrRetrieve(next);
    }
  }

  void HandleCargoWaitingClick(int row)
  {
    if (row < 0 || (uint)row >= this->displayed_rows.size()) return;
    if (_ctrl_pressed) {
      this->scroll_to_row = row;
    } else {
      RowDisplay &display = this->displayed_rows[row];
      if (display.filter == &this->expanded_rows) {
        this->HandleCargoWaitingClick<CargoType>(display.filter, display.next_cargo);
      } else {
        this->HandleCargoWaitingClick<StationID>(display.filter, display.next_station);
      }
    }
    this->SetWidgetDirty(WID_SV_WAITING);
    this->SetWidgetDirty(WID_SV_SCROLLBAR);
  }
 
  void OnClick([[maybe_unused]] Point pt, WidgetID widget, [[maybe_unused]] int click_count) override
  {
    Window *w = FindWindowByClass(WindowClass::QueryString);
 
    switch (widget) {
      case WID_SV_WAITING:
        this->HandleCargoWaitingClick(this->vscroll->GetScrolledRowFromWidget(pt.y, this, WID_SV_WAITING, WidgetDimensions::scaled.framerect.top) - this->vscroll->GetPosition());
        break;
 
      case WID_SV_CATCHMENT:
        SetViewportCatchmentStation(Station::Get(this->window_number), !this->IsWidgetLowered(WID_SV_CATCHMENT));
 
        if (w != nullptr && this->IsWidgetLowered(WID_SV_CATCHMENT)) {
          if (w->parent->window_class == WindowClass::StationView && w->IsWidgetLowered(WID_QS_MOVE)) SetViewportStationRect(Station::Get(w->parent->window_number), true);
          if (w->parent->window_class == WindowClass::WaypointView && w->IsWidgetLowered(WID_QS_MOVE)) SetViewportWaypointRect(Waypoint::Get(w->parent->window_number), true);
        }
        break;
 
      case WID_SV_LOCATION:
        if (_ctrl_pressed) {
          ShowExtraViewportWindow(Station::Get(this->window_number)->xy);
        } else {
          ScrollMainWindowToTile(Station::Get(this->window_number)->xy);
        }
        break;
 
      case WID_SV_ACCEPTS_RATINGS: {
        /* Swap between 'accepts' and 'ratings' view. */
        int height_change;
        NWidgetCore *nwi = this->GetWidget<NWidgetCore>(WID_SV_ACCEPTS_RATINGS);
        if (this->GetWidget<NWidgetCore>(WID_SV_ACCEPTS_RATINGS)->GetString() == STR_STATION_VIEW_RATINGS_BUTTON) {
          nwi->SetStringTip(STR_STATION_VIEW_ACCEPTS_BUTTON, STR_STATION_VIEW_ACCEPTS_TOOLTIP); // Switch to accepts view.
          height_change = this->rating_lines - this->accepts_lines;
        } else {
          nwi->SetStringTip(STR_STATION_VIEW_RATINGS_BUTTON, STR_STATION_VIEW_RATINGS_TOOLTIP); // Switch to ratings view.
          height_change = this->accepts_lines - this->rating_lines;
        }
        this->ReInit(0, height_change * GetCharacterHeight(FontSize::Normal));
        break;
      }
 
      case WID_SV_RENAME:
        ShowQueryString(GetString(STR_STATION_NAME, this->window_number), STR_STATION_VIEW_EDIT_STATION_SIGN, MAX_LENGTH_STATION_NAME_CHARS,
            this, CS_ALPHANUMERAL, {QueryStringFlag::EnableDefault, QueryStringFlag::LengthIsInChars, QueryStringFlag::EnableMove});
        break;
 
      case WID_SV_CLOSE_AIRPORT:
        Command<Commands::OpenCloseAirport>::Post(this->window_number);
        break;
 
      case WID_SV_TRAINS:   // Show list of scheduled trains to this station
      case WID_SV_ROADVEHS: // Show list of scheduled road-vehicles to this station
      case WID_SV_SHIPS:    // Show list of scheduled ships to this station
      case WID_SV_PLANES: { // Show list of scheduled aircraft to this station
        Owner owner = Station::Get(this->window_number)->owner;
        ShowVehicleListWindow(owner, (VehicleType)(widget - WID_SV_TRAINS), static_cast<StationID>(this->window_number));
        break;
      }
 
      case WID_SV_SORT_BY: {
        /* The initial selection is composed of current mode and
         * sorting criteria for columns 1, 2, and 3. Column 0 is always
         * sorted by cargo type. The others can theoretically be sorted
         * by different things but there is no UI for that. */
        ShowDropDownMenu(this, StationViewWindow::sort_names,
            this->current_mode * 2 + (this->sortings[1] == CargoSortType::Count ? 1 : 0),
            WID_SV_SORT_BY, 0, 0);
        break;
      }
 
      case WID_SV_GROUP_BY: {
        ShowDropDownMenu(this, StationViewWindow::group_names, this->grouping_index, WID_SV_GROUP_BY, 0, 0);
        break;
      }
 
      case WID_SV_SORT_ORDER: { // flip sorting method asc/desc
        this->SelectSortOrder(this->sort_orders[1] == SO_ASCENDING ? SO_DESCENDING : SO_ASCENDING);
        this->SetTimeout();
        this->LowerWidget(WID_SV_SORT_ORDER);
        break;
      }
    }
  }

  void SelectSortOrder(SortOrder order)
  {
    this->sort_orders[1] = this->sort_orders[2] = this->sort_orders[3] = order;
    _settings_client.gui.station_gui_sort_order = this->sort_orders[1];
    this->SetDirty();
  }

  void SelectSortBy(int index)
  {
    _settings_client.gui.station_gui_sort_by = index;
    switch (StationViewWindow::sort_names[index]) {
      case STR_STATION_VIEW_WAITING_STATION:
        this->current_mode = MODE_WAITING;
        this->sortings[1] = this->sortings[2] = this->sortings[3] = CargoSortType::AsGrouping;
        break;
      case STR_STATION_VIEW_WAITING_AMOUNT:
        this->current_mode = MODE_WAITING;
        this->sortings[1] = this->sortings[2] = this->sortings[3] = CargoSortType::Count;
        break;
      case STR_STATION_VIEW_PLANNED_STATION:
        this->current_mode = MODE_PLANNED;
        this->sortings[1] = this->sortings[2] = this->sortings[3] = CargoSortType::AsGrouping;
        break;
      case STR_STATION_VIEW_PLANNED_AMOUNT:
        this->current_mode = MODE_PLANNED;
        this->sortings[1] = this->sortings[2] = this->sortings[3] = CargoSortType::Count;
        break;
      default:
        NOT_REACHED();
    }
    /* Display the current sort variant */
    this->GetWidget<NWidgetCore>(WID_SV_SORT_BY)->SetString(StationViewWindow::sort_names[index]);
    this->SetDirty();
  }

  void SelectGroupBy(int index)
  {
    this->grouping_index = index;
    _settings_client.gui.station_gui_group_order = index;
    this->GetWidget<NWidgetCore>(WID_SV_GROUP_BY)->SetString(StationViewWindow::group_names[index]);
    switch (StationViewWindow::group_names[index]) {
      case STR_STATION_VIEW_GROUP_S_V_D:
        this->groupings[1] = GR_SOURCE;
        this->groupings[2] = GR_NEXT;
        this->groupings[3] = GR_DESTINATION;
        break;
      case STR_STATION_VIEW_GROUP_S_D_V:
        this->groupings[1] = GR_SOURCE;
        this->groupings[2] = GR_DESTINATION;
        this->groupings[3] = GR_NEXT;
        break;
      case STR_STATION_VIEW_GROUP_V_S_D:
        this->groupings[1] = GR_NEXT;
        this->groupings[2] = GR_SOURCE;
        this->groupings[3] = GR_DESTINATION;
        break;
      case STR_STATION_VIEW_GROUP_V_D_S:
        this->groupings[1] = GR_NEXT;
        this->groupings[2] = GR_DESTINATION;
        this->groupings[3] = GR_SOURCE;
        break;
      case STR_STATION_VIEW_GROUP_D_S_V:
        this->groupings[1] = GR_DESTINATION;
        this->groupings[2] = GR_SOURCE;
        this->groupings[3] = GR_NEXT;
        break;
      case STR_STATION_VIEW_GROUP_D_V_S:
        this->groupings[1] = GR_DESTINATION;
        this->groupings[2] = GR_NEXT;
        this->groupings[3] = GR_SOURCE;
        break;
    }
    this->SetDirty();
  }
 
  void OnDropdownSelect(WidgetID widget, int index, int) override
  {
    if (widget == WID_SV_SORT_BY) {
      this->SelectSortBy(index);
    } else {
      this->SelectGroupBy(index);
    }
  }
 
  void OnQueryTextFinished(std::optional<std::string> str) override
  {
    if (!str.has_value()) return;
 
    Command<Commands::RenameStation>::Post(STR_ERROR_CAN_T_RENAME_STATION, this->window_number, *str);
  }
 
  void OnResize() override
  {
    this->vscroll->SetCapacityFromWidget(this, WID_SV_WAITING, WidgetDimensions::scaled.framerect.Vertical());
  }

  void OnInvalidateData([[maybe_unused]] int data = 0, [[maybe_unused]] bool gui_scope = true) override
  {
    if (gui_scope) {
      if (data >= 0 && data < NUM_CARGO) {
        this->cached_destinations.Remove((CargoType)data);
      } else {
        this->ReInit();
      }
    }
  }
};

static WindowDesc _station_view_desc(
  WindowPosition::Automatic, "view_station", 249, 117,
  WindowClass::StationView, WindowClass::None,
  {},
  _nested_station_view_widgets
);

void ShowStationViewWindow(StationID station)
{
  AllocateWindowDescFront<StationViewWindow>(_station_view_desc, station);
}

struct TileAndStation {
  TileIndex tile;    
  StationID station; 
};
 
static std::vector<TileAndStation> _deleted_stations_nearby;
static std::vector<StationID> _stations_nearby_list;

template <class T>
static void AddNearbyStation(TileIndex tile, TileArea *ctx)
{
  /* First check if there were deleted stations here */
  for (auto it = _deleted_stations_nearby.begin(); it != _deleted_stations_nearby.end(); /* nothing */) {
    if (it->tile == tile) {
      _stations_nearby_list.push_back(it->station);
      it = _deleted_stations_nearby.erase(it);
    } else {
      ++it;
    }
  }
 
  /* Check if own station and if we stay within station spread */
  if (!IsTileType(tile, TileType::Station)) return;
 
  StationID sid = GetStationIndex(tile);
 
  /* This station is (likely) a waypoint */
  if (!T::IsValidID(sid)) return;
 
  BaseStation *st = BaseStation::Get(sid);
  if (st->owner != _local_company || std::ranges::find(_stations_nearby_list, sid) != _stations_nearby_list.end()) return;
 
  if (st->rect.BeforeAddRect(ctx->tile, ctx->w, ctx->h, StationRect::ADD_TEST).Succeeded()) {
    _stations_nearby_list.push_back(sid);
  }
}

template <class T>
static void FindStationsNearby(TileArea ta, bool distant_join)
{
  TileArea ctx = ta;
 
  _stations_nearby_list.clear();
  _stations_nearby_list.push_back(NEW_STATION);
  _deleted_stations_nearby.clear();
 
  /* Look for deleted stations */
  for (const BaseStation *st : BaseStation::Iterate()) {
    if (T::IsValidBaseStation(st) && !st->IsInUse() && st->owner == _local_company) {
      /* Include only within station spread (yes, it is strictly less than) */
      if (std::max(DistanceMax(ta.tile, st->xy), DistanceMax(TileAddXY(ta.tile, ta.w - 1, ta.h - 1), st->xy)) < _settings_game.station.station_spread) {
        _deleted_stations_nearby.emplace_back(st->xy, st->index);
 
        /* Add the station when it's within where we're going to build */
        if (IsInsideBS(TileX(st->xy), TileX(ctx.tile), ctx.w) &&
            IsInsideBS(TileY(st->xy), TileY(ctx.tile), ctx.h)) {
          AddNearbyStation<T>(st->xy, &ctx);
        }
      }
    }
  }
 
  /* Add stations that are within station tile area. Stations do not have to occupy all tiles */
  for (auto t : ta) {
    AddNearbyStation<T>(t, &ctx);
  }
 
  /* Only search tiles where we have a chance to stay within the station spread.
   * The complete check needs to be done in the callback as we don't know the
   * extent of the found station, yet. */
  if (distant_join && std::min(ta.w, ta.h) >= _settings_game.station.station_spread) return;
  uint max_dist = distant_join ? _settings_game.station.station_spread - std::min(ta.w, ta.h) : 1;
 
  for (auto tile : SpiralTileSequence(TileAddByDir(ctx.tile, Direction::N), max_dist, ta.w, ta.h)) {
    AddNearbyStation<T>(tile, &ctx);
  }
}
 
static constexpr std::initializer_list<NWidgetPart> _nested_select_station_widgets = {
  NWidget(NWID_HORIZONTAL),
    NWidget(WWT_CLOSEBOX, Colours::DarkGreen),
    NWidget(WWT_CAPTION, Colours::DarkGreen, WID_JS_CAPTION), SetStringTip(STR_JOIN_STATION_CAPTION, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
    NWidget(WWT_DEFSIZEBOX, Colours::DarkGreen),
  EndContainer(),
  NWidget(NWID_HORIZONTAL),
    NWidget(WWT_PANEL, Colours::DarkGreen, WID_JS_PANEL), SetResize(1, 0), SetScrollbar(WID_JS_SCROLLBAR), EndContainer(),
    NWidget(NWID_VERTICAL),
      NWidget(NWID_VSCROLLBAR, Colours::DarkGreen, WID_JS_SCROLLBAR),
      NWidget(WWT_RESIZEBOX, Colours::DarkGreen),
    EndContainer(),
  EndContainer(),
};

template <class T>
struct SelectStationWindow : Window {
  StationPickerCmdProc select_station_proc{};
  TileArea area{}; 
  Scrollbar *vscroll = nullptr;
 
  SelectStationWindow(WindowDesc &desc, TileArea ta, StationPickerCmdProc&& proc) :
    Window(desc),
    select_station_proc(std::move(proc)),
    area(ta)
  {
    this->CreateNestedTree();
    this->vscroll = this->GetScrollbar(WID_JS_SCROLLBAR);
    this->GetWidget<NWidgetCore>(WID_JS_CAPTION)->SetString(T::IsWaypoint() ? STR_JOIN_WAYPOINT_CAPTION : STR_JOIN_STATION_CAPTION);
    this->FinishInitNested(0);
    this->OnInvalidateData(0);
 
    _thd.freeze = true;
  }
 
  void Close([[maybe_unused]] int data = 0) override
  {
    SetViewportCatchmentSpecializedStation<typename T::StationType>(nullptr, true);
 
    _thd.freeze = false;
    this->Window::Close();
  }
 
  void UpdateWidgetSize(WidgetID widget, Dimension &size, [[maybe_unused]] const Dimension &padding, [[maybe_unused]] Dimension &fill, [[maybe_unused]] Dimension &resize) override
  {
    if (widget != WID_JS_PANEL) return;
 
    /* Determine the widest string */
    Dimension d = GetStringBoundingBox(T::IsWaypoint() ? STR_JOIN_WAYPOINT_CREATE_SPLIT_WAYPOINT : STR_JOIN_STATION_CREATE_SPLIT_STATION);
    for (const auto &station : _stations_nearby_list) {
      if (station == NEW_STATION) continue;
      const BaseStation *st = BaseStation::Get(station);
      d = maxdim(d, GetStringBoundingBox(T::IsWaypoint()
        ? GetString(STR_STATION_LIST_WAYPOINT, st->index)
        : GetString(STR_STATION_LIST_STATION, st->index, st->facilities)));
    }
 
    fill.height = resize.height = d.height;
    d.height *= 5;
    d.width += padding.width;
    d.height += padding.height;
    size = d;
  }
 
  void DrawWidget(const Rect &r, WidgetID widget) const override
  {
    if (widget != WID_JS_PANEL) return;
 
    Rect tr = r.Shrink(WidgetDimensions::scaled.framerect);
    auto [first, last] = this->vscroll->GetVisibleRangeIterators(_stations_nearby_list);
    for (auto it = first; it != last; ++it, tr.top += this->resize.step_height) {
      if (*it == NEW_STATION) {
        DrawString(tr, T::IsWaypoint() ? STR_JOIN_WAYPOINT_CREATE_SPLIT_WAYPOINT : STR_JOIN_STATION_CREATE_SPLIT_STATION);
      } else {
        const BaseStation *st = BaseStation::Get(*it);
        DrawString(tr, T::IsWaypoint()
          ? GetString(STR_STATION_LIST_WAYPOINT, st->index)
          : GetString(STR_STATION_LIST_STATION, st->index, st->facilities));
      }
    }
 
  }
 
  void OnClick([[maybe_unused]] Point pt, WidgetID widget, [[maybe_unused]] int click_count) override
  {
    if (widget != WID_JS_PANEL) return;
 
    auto it = this->vscroll->GetScrolledItemFromWidget(_stations_nearby_list, pt.y, this, WID_JS_PANEL, WidgetDimensions::scaled.framerect.top);
    if (it == _stations_nearby_list.end()) return;
 
    /* Execute stored Command */
    this->select_station_proc(false, *it);
 
    /* Close Window; this might cause double frees! */
    CloseWindowById(WindowClass::JoinStation, 0);
  }
 
  void OnRealtimeTick([[maybe_unused]] uint delta_ms) override
  {
    if (_thd.dirty & 2) {
      _thd.dirty &= ~2;
      this->SetDirty();
    }
  }
 
  void OnResize() override
  {
    this->vscroll->SetCapacityFromWidget(this, WID_JS_PANEL, WidgetDimensions::scaled.framerect.Vertical());
  }

  void OnInvalidateData([[maybe_unused]] int data = 0, [[maybe_unused]] bool gui_scope = true) override
  {
    if (!gui_scope) return;
    FindStationsNearby<T>(this->area, true);
    this->vscroll->SetCount(_stations_nearby_list.size());
    this->SetDirty();
  }
 
  void OnMouseOver([[maybe_unused]] Point pt, WidgetID widget) override
  {
    if (widget != WID_JS_PANEL) {
      SetViewportCatchmentSpecializedStation<typename T::StationType>(nullptr, true);
      return;
    }
 
    /* Show coverage area of station under cursor */
    auto it = this->vscroll->GetScrolledItemFromWidget(_stations_nearby_list, pt.y, this, WID_JS_PANEL, WidgetDimensions::scaled.framerect.top);
    const typename T::StationType *st = it == _stations_nearby_list.end() || *it == NEW_STATION ? nullptr : T::StationType::Get(*it);
    SetViewportCatchmentSpecializedStation<typename T::StationType>(st, true);
  }
};

static WindowDesc _select_station_desc(
  WindowPosition::Automatic, "build_station_join", 200, 180,
  WindowClass::JoinStation, WindowClass::None,
  WindowDefaultFlag::Construction,
  _nested_select_station_widgets
);
 

static bool StationJoinerNeeded(const StationPickerCmdProc &proc)
{
  /* Only show selection if distant join is enabled in the settings */
  if (!_settings_game.station.distant_join_stations) return false;
 
  /* If a window is already opened and we didn't ctrl-click,
   * return true (i.e. just flash the old window) */
  Window *selection_window = FindWindowById(WindowClass::JoinStation, 0);
  if (selection_window != nullptr) {
    /* Abort current distant-join and start new one */
    selection_window->Close();
    UpdateTileSelection();
  }
 
  /* only show the popup, if we press ctrl */
  if (!_ctrl_pressed) return false;
 
  /* Now check if we could build there */
  return proc(true, StationID::Invalid());
}

template <class T>
void ShowSelectBaseStationIfNeeded(TileArea ta, StationPickerCmdProc&& proc)
{
  if (StationJoinerNeeded(proc)) {
    if (!_settings_client.gui.persistent_buildingtools) ResetObjectToPlace();
    FindStationsNearby<T>(ta, false);
    new SelectStationWindow<T>(_select_station_desc, ta, std::move(proc));
  } else {
    proc(false, StationID::Invalid());
  }
}

void ShowSelectStationIfNeeded(TileArea ta, StationPickerCmdProc proc)
{
  ShowSelectBaseStationIfNeeded<StationTypeFilter>(ta, std::move(proc));
}

void ShowSelectRailWaypointIfNeeded(TileArea ta, StationPickerCmdProc proc)
{
  ShowSelectBaseStationIfNeeded<RailWaypointTypeFilter>(ta, std::move(proc));
}

void ShowSelectRoadWaypointIfNeeded(TileArea ta, StationPickerCmdProc proc)
{
  ShowSelectBaseStationIfNeeded<RoadWaypointTypeFilter>(ta, std::move(proc));
}