road_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 "gui.h"
#include "window_gui.h"
#include "station_gui.h"
#include "terraform_gui.h"
#include "viewport_func.h"
#include "command_func.h"
#include "road_cmd.h"
#include "station_func.h"
#include "waypoint_func.h"
#include "window_func.h"
#include "vehicle_func.h"
#include "sound_func.h"
#include "company_func.h"
#include "tunnelbridge.h"
#include "tunnelbridge_map.h"
#include "tilehighlight_func.h"
#include "company_base.h"
#include "hotkeys.h"
#include "road_gui.h"
#include "toolbar_gui.h"
#include "zoom_func.h"
#include "dropdown_type.h"
#include "dropdown_func.h"
#include "engine_base.h"
#include "station_base.h"
#include "waypoint_base.h"
#include "strings_func.h"
#include "core/geometry_func.hpp"
#include "station_cmd.h"
#include "waypoint_cmd.h"
#include "road_cmd.h"
#include "tunnelbridge_cmd.h"
#include "newgrf_badge_gui.h"
#include "newgrf_roadstop.h"
#include "picker_gui.h"
#include "timer/timer.h"
#include "timer/timer_game_calendar.h"
 
#include "widgets/road_widget.h"
 
#include "table/strings.h"
 
#include "safeguards.h"
 
static void ShowRVStationPicker(Window *parent, RoadStopType rs);
static void ShowRoadDepotPicker(Window *parent);
static void ShowBuildRoadWaypointPicker(Window *parent);
 
static bool _remove_button_clicked;
static bool _one_way_button_clicked;
 
static Axis _place_road_dir;
static bool _place_road_start_half_x;
static bool _place_road_start_half_y;
static bool _place_road_end_half;
 
static RoadType _cur_roadtype;
 
static DiagDirection _road_depot_orientation;
 
struct RoadWaypointPickerSelection {
  RoadStopClassID sel_class; 
  uint16_t sel_type; 
};
static RoadWaypointPickerSelection _waypoint_gui; 
 
struct RoadStopPickerSelection {
  RoadStopClassID sel_class; 
  uint16_t sel_type; 
  DiagDirection orientation; 
};
static RoadStopPickerSelection _roadstop_gui;
 
static bool IsRoadStopEverAvailable(const RoadStopSpec *spec, StationType type)
{
  if (spec == nullptr) return true;
 
  if (spec->flags.Test(RoadStopSpecFlag::RoadOnly) && !RoadTypeIsRoad(_cur_roadtype)) return false;
  if (spec->flags.Test(RoadStopSpecFlag::TramOnly) && !RoadTypeIsTram(_cur_roadtype)) return false;
 
  switch (spec->stop_type) {
    case ROADSTOPTYPE_ALL: return true;
    case ROADSTOPTYPE_PASSENGER: return type == StationType::Bus;
    case ROADSTOPTYPE_FREIGHT: return type == StationType::Truck;
    default: NOT_REACHED();
  }
}

static bool IsRoadStopAvailable(const RoadStopSpec *spec, StationType type)
{
  if (spec == nullptr) return true;
  if (!IsRoadStopEverAvailable(spec, type)) return false;
 
  if (!spec->callback_mask.Test(RoadStopCallbackMask::Avail)) return true;
 
  uint16_t cb_res = GetRoadStopCallback(CBID_STATION_AVAILABILITY, 0, 0, spec, nullptr, INVALID_TILE, _cur_roadtype, type, 0);
  if (cb_res == CALLBACK_FAILED) return true;
 
  return Convert8bitBooleanCallback(spec->grf_prop.grffile, CBID_STATION_AVAILABILITY, cb_res);
}
 
void CcPlaySound_CONSTRUCTION_OTHER(Commands, const CommandCost &result, TileIndex tile)
{
  if (result.Succeeded() && _settings_client.sound.confirm) SndPlayTileFx(SND_1F_CONSTRUCTION_OTHER, tile);
}

static void PlaceRoad_Bridge(TileIndex tile, Window *w)
{
  if (IsBridgeTile(tile)) {
    TileIndex other_tile = GetOtherTunnelBridgeEnd(tile);
    Point pt = {0, 0};
    w->OnPlaceMouseUp(VPM_X_OR_Y, DDSP_BUILD_BRIDGE, pt, other_tile, tile);
  } else {
    VpStartPlaceSizing(tile, VPM_X_OR_Y, DDSP_BUILD_BRIDGE);
  }
}

void CcBuildRoadTunnel(Commands, const CommandCost &result, TileIndex start_tile)
{
  if (result.Succeeded()) {
    if (_settings_client.sound.confirm) SndPlayTileFx(SND_1F_CONSTRUCTION_OTHER, start_tile);
    if (!_settings_client.gui.persistent_buildingtools) ResetObjectToPlace();
 
    DiagDirection start_direction = ReverseDiagDir(GetTunnelBridgeDirection(start_tile));
    ConnectRoadToStructure(start_tile, start_direction);
 
    TileIndex end_tile = GetOtherTunnelBridgeEnd(start_tile);
    DiagDirection end_direction = ReverseDiagDir(GetTunnelBridgeDirection(end_tile));
    ConnectRoadToStructure(end_tile, end_direction);
  } else {
    SetRedErrorSquare(_build_tunnel_endtile);
  }
}

void ConnectRoadToStructure(TileIndex tile, DiagDirection direction)
{
  tile += TileOffsByDiagDir(direction);
  /* if there is a roadpiece just outside of the station entrance, build a connecting route */
  if (IsNormalRoadTile(tile)) {
    if (GetRoadBits(tile, GetRoadTramType(_cur_roadtype)).Any()) {
      Command<Commands::BuildRoad>::Post(tile, DiagDirToRoadBits(ReverseDiagDir(direction)), _cur_roadtype, {}, TownID::Invalid());
    }
  }
}
 
void CcRoadDepot(Commands, const CommandCost &result, TileIndex tile, RoadType, DiagDirection dir)
{
  if (result.Failed()) return;
 
  if (_settings_client.sound.confirm) SndPlayTileFx(SND_1F_CONSTRUCTION_OTHER, tile);
  if (!_settings_client.gui.persistent_buildingtools) ResetObjectToPlace();
  ConnectRoadToStructure(tile, dir);
}

void CcRoadStop(Commands, const CommandCost &result, TileIndex tile, uint8_t width, uint8_t length, RoadStopType, bool is_drive_through,
    DiagDirection dir, RoadType, RoadStopClassID spec_class, uint16_t spec_index, StationID, bool)
{
  if (result.Failed()) return;
 
  if (_settings_client.sound.confirm) SndPlayTileFx(SND_1F_CONSTRUCTION_OTHER, tile);
  if (!_settings_client.gui.persistent_buildingtools) ResetObjectToPlace();
 
  bool connect_to_road = true;
  if (spec_class.base() < RoadStopClass::GetClassCount() && spec_index < RoadStopClass::Get(spec_class)->GetSpecCount()) {
    const RoadStopSpec *roadstopspec = RoadStopClass::Get(spec_class)->GetSpec(spec_index);
    if (roadstopspec != nullptr && roadstopspec->flags.Test(RoadStopSpecFlag::NoAutoRoadConnection)) connect_to_road = false;
  }
 
  if (connect_to_road) {
    TileArea roadstop_area(tile, width, length);
    for (TileIndex cur_tile : roadstop_area) {
      ConnectRoadToStructure(cur_tile, dir);
      /* For a drive-through road stop build connecting road for other entrance. */
      if (is_drive_through) ConnectRoadToStructure(cur_tile, ReverseDiagDir(dir));
    }
  }
}

static void PlaceRoadStop(TileIndex start_tile, TileIndex end_tile, RoadStopType stop_type, bool adjacent, RoadType rt, StringID err_msg)
{
  TileArea ta(start_tile, end_tile);
  DiagDirection ddir = _roadstop_gui.orientation;
  bool drive_through = ddir >= DiagDirection::End;
  if (drive_through) ddir = ddir - DiagDirection::End; // Adjust picker result to actual direction.
  RoadStopClassID spec_class = _roadstop_gui.sel_class;
  uint16_t spec_index = _roadstop_gui.sel_type;
 
  auto proc = [=](bool test, StationID to_join) -> bool {
    if (test) {
      return Command<Commands::BuildRoadStop>::Do(CommandFlagsToDCFlags(GetCommandFlags<Commands::BuildRoadStop>()), ta.tile, ta.w, ta.h, stop_type, drive_through,
          ddir, rt, spec_class, spec_index, StationID::Invalid(), adjacent).Succeeded();
    } else {
      return Command<Commands::BuildRoadStop>::Post(err_msg, CcRoadStop, ta.tile, ta.w, ta.h, stop_type, drive_through,
          ddir, rt, spec_class, spec_index, to_join, adjacent);
    }
  };
 
  ShowSelectStationIfNeeded(ta, proc);
}

static void PlaceRoad_Waypoint(TileIndex tile)
{
  if (_remove_button_clicked) {
    VpStartPlaceSizing(tile, VPM_X_AND_Y, DDSP_REMOVE_ROAD_WAYPOINT);
    return;
  }
 
  Axis axis = GetAxisForNewRoadWaypoint(tile);
  if (IsValidAxis(axis)) {
    /* Valid tile for waypoints */
    VpStartPlaceSizing(tile, axis == Axis::X ? VPM_X_LIMITED : VPM_Y_LIMITED, DDSP_BUILD_ROAD_WAYPOINT);
    VpSetPlaceSizingLimit(_settings_game.station.station_spread);
  } else {
    /* Tile where we can't build road waypoints. This is always going to fail,
     * but provides the user with a proper error message. */
    Command<Commands::BuildRoadWaypoint>::Post(STR_ERROR_CAN_T_BUILD_ROAD_WAYPOINT, tile, Axis::X, 1, 1, ROADSTOP_CLASS_WAYP, 0, StationID::Invalid(), false);
  }
}

static void PlaceRoad_BusStation(TileIndex tile)
{
  if (_remove_button_clicked) {
    VpStartPlaceSizing(tile, VPM_X_AND_Y, DDSP_REMOVE_BUSSTOP);
  } else {
    if (_roadstop_gui.orientation < DiagDirection::End) { // Not a drive-through stop.
      VpStartPlaceSizing(tile, (DiagDirToAxis(_roadstop_gui.orientation) == Axis::X) ? VPM_X_LIMITED : VPM_Y_LIMITED, DDSP_BUILD_BUSSTOP);
    } else {
      VpStartPlaceSizing(tile, VPM_X_AND_Y_LIMITED, DDSP_BUILD_BUSSTOP);
    }
    VpSetPlaceSizingLimit(_settings_game.station.station_spread);
  }
}

static void PlaceRoad_TruckStation(TileIndex tile)
{
  if (_remove_button_clicked) {
    VpStartPlaceSizing(tile, VPM_X_AND_Y, DDSP_REMOVE_TRUCKSTOP);
  } else {
    if (_roadstop_gui.orientation < DiagDirection::End) { // Not a drive-through stop.
      VpStartPlaceSizing(tile, (DiagDirToAxis(_roadstop_gui.orientation) == Axis::X) ? VPM_X_LIMITED : VPM_Y_LIMITED, DDSP_BUILD_TRUCKSTOP);
    } else {
      VpStartPlaceSizing(tile, VPM_X_AND_Y_LIMITED, DDSP_BUILD_TRUCKSTOP);
    }
    VpSetPlaceSizingLimit(_settings_game.station.station_spread);
  }
}
 
typedef void OnButtonClick(Window *w);

static void ToggleRoadButton_Remove(Window *w)
{
  w->ToggleWidgetLoweredState(WID_ROT_REMOVE);
  w->SetWidgetDirty(WID_ROT_REMOVE);
  _remove_button_clicked = w->IsWidgetLowered(WID_ROT_REMOVE);
  SetSelectionRed(_remove_button_clicked);
}

static bool RoadToolbar_CtrlChanged(Window *w)
{
  if (w->IsWidgetDisabled(WID_ROT_REMOVE)) return false;
 
  /* allow ctrl to switch remove mode only for these widgets */
  for (WidgetID i = WID_ROT_ROAD_X; i <= WID_ROT_AUTOROAD; i++) {
    if (w->IsWidgetLowered(i)) {
      ToggleRoadButton_Remove(w);
      return true;
    }
  }
 
  return false;
}

struct BuildRoadToolbarWindow : Window {
  RoadType roadtype = INVALID_ROADTYPE; 
  WidgetID last_started_action = INVALID_WIDGET; 
 
  BuildRoadToolbarWindow(WindowDesc &desc, WindowNumber window_number) : Window(desc), roadtype(_cur_roadtype)
  {
    this->CreateNestedTree();
    this->FinishInitNested(window_number);
    this->SetWidgetDisabledState(WID_ROT_REMOVE, true);
 
    if (RoadTypeIsRoad(this->roadtype)) {
      this->SetWidgetDisabledState(WID_ROT_ONE_WAY, true);
    }
 
    this->OnInvalidateData();
 
    if (_settings_client.gui.link_terraform_toolbar) ShowTerraformToolbar(this);
  }
 
  void Close([[maybe_unused]] int data = 0) override
  {
    if (_game_mode == GameMode::Normal && (this->IsWidgetLowered(WID_ROT_BUS_STATION) || this->IsWidgetLowered(WID_ROT_TRUCK_STATION))) SetViewportCatchmentStation(nullptr, true);
    if (_settings_client.gui.link_terraform_toolbar) CloseWindowById(WindowClass::ScenarioGenerateLandscape, 0, false);
    this->Window::Close();
  }

  void OnInvalidateData([[maybe_unused]] int data = 0, [[maybe_unused]] bool gui_scope = true) override
  {
    if (!gui_scope) return;
 
    if (_cur_roadtype != this->roadtype) {
      bool close_build_station = this->ModifyRoadType(_cur_roadtype);
 
      /* Update cursor and all sub windows. */
      if (_thd.GetCallbackWnd() == this) SetCursor(this->GetCursorForWidget(this->last_started_action), PAL_NONE);
      for (WindowClass cls : {WindowClass::BuildBusStation, WindowClass::BuildTruckStation, WindowClass::BuildWaypoint, WindowClass::BuildDepot}) {
        SetWindowDirty(cls, TransportType::Road);
      }
 
      if (close_build_station) {
        CloseWindowById(WindowClass::BuildBusStation, TransportType::Road);
        CloseWindowById(WindowClass::BuildTruckStation, TransportType::Road);
      }
    }
 
    if (!ValParamRoadType(this->roadtype)) {
      /* Close toolbar if road type is not available. */
      this->Close();
      return;
    }
 
    RoadTramType rtt = GetRoadTramType(this->roadtype);
 
    bool can_build = CanBuildVehicleInfrastructure(VehicleType::Road, rtt);
    this->SetWidgetsDisabledState(!can_build,
      WID_ROT_DEPOT,
      WID_ROT_BUILD_WAYPOINT,
      WID_ROT_BUS_STATION,
      WID_ROT_TRUCK_STATION);
    if (!can_build) {
      CloseWindowById(WindowClass::BuildBusStation, TransportType::Road);
      CloseWindowById(WindowClass::BuildTruckStation, TransportType::Road);
      CloseWindowById(WindowClass::BuildDepot, TransportType::Road);
      CloseWindowById(WindowClass::BuildWaypoint, TransportType::Road);
    }
 
    if (_game_mode != GameMode::Editor) {
      if (!can_build) {
        /* Show in the tooltip why this button is disabled. */
        this->GetWidget<NWidgetCore>(WID_ROT_DEPOT)->SetToolTip(STR_TOOLBAR_DISABLED_NO_VEHICLE_AVAILABLE);
        this->GetWidget<NWidgetCore>(WID_ROT_BUILD_WAYPOINT)->SetToolTip(STR_TOOLBAR_DISABLED_NO_VEHICLE_AVAILABLE);
        this->GetWidget<NWidgetCore>(WID_ROT_BUS_STATION)->SetToolTip(STR_TOOLBAR_DISABLED_NO_VEHICLE_AVAILABLE);
        this->GetWidget<NWidgetCore>(WID_ROT_TRUCK_STATION)->SetToolTip(STR_TOOLBAR_DISABLED_NO_VEHICLE_AVAILABLE);
      } else {
        this->GetWidget<NWidgetCore>(WID_ROT_DEPOT)->SetToolTip(rtt == RoadTramType::Road ? STR_ROAD_TOOLBAR_TOOLTIP_BUILD_ROAD_VEHICLE_DEPOT : STR_ROAD_TOOLBAR_TOOLTIP_BUILD_TRAM_VEHICLE_DEPOT);
        this->GetWidget<NWidgetCore>(WID_ROT_BUILD_WAYPOINT)->SetToolTip(rtt == RoadTramType::Road ? STR_ROAD_TOOLBAR_TOOLTIP_CONVERT_ROAD_TO_WAYPOINT : STR_ROAD_TOOLBAR_TOOLTIP_CONVERT_TRAM_TO_WAYPOINT);
        this->GetWidget<NWidgetCore>(WID_ROT_BUS_STATION)->SetToolTip(rtt == RoadTramType::Road ? STR_ROAD_TOOLBAR_TOOLTIP_BUILD_BUS_STATION : STR_ROAD_TOOLBAR_TOOLTIP_BUILD_PASSENGER_TRAM_STATION);
        this->GetWidget<NWidgetCore>(WID_ROT_TRUCK_STATION)->SetToolTip(rtt == RoadTramType::Road ? STR_ROAD_TOOLBAR_TOOLTIP_BUILD_TRUCK_LOADING_BAY : STR_ROAD_TOOLBAR_TOOLTIP_BUILD_CARGO_TRAM_STATION);
      }
    }
  }
 
  void OnInit() override
  {
    /* Configure the road toolbar for the roadtype. */
    const RoadTypeInfo *rti = GetRoadTypeInfo(this->roadtype);
    this->GetWidget<NWidgetCore>(WID_ROT_ROAD_X)->SetSprite(rti->gui_sprites.build_x_road);
    this->GetWidget<NWidgetCore>(WID_ROT_ROAD_Y)->SetSprite(rti->gui_sprites.build_y_road);
    this->GetWidget<NWidgetCore>(WID_ROT_AUTOROAD)->SetSprite(rti->gui_sprites.auto_road);
    if (_game_mode != GameMode::Editor) {
      this->GetWidget<NWidgetCore>(WID_ROT_DEPOT)->SetSprite(rti->gui_sprites.build_depot);
    }
    this->GetWidget<NWidgetCore>(WID_ROT_CONVERT_ROAD)->SetSprite(rti->gui_sprites.convert_road);
    this->GetWidget<NWidgetCore>(WID_ROT_BUILD_TUNNEL)->SetSprite(rti->gui_sprites.build_tunnel);
  }

  bool ModifyRoadType(RoadType roadtype)
  {
    bool result = RoadTypeIsRoad(this->roadtype) != RoadTypeIsRoad(roadtype);
 
    this->roadtype = roadtype;
    this->ReInit();
    return result;
  }
 
  std::string GetWidgetString(WidgetID widget, StringID stringid) const override
  {
    if (widget == WID_ROT_CAPTION) {
      const RoadTypeInfo *rti = GetRoadTypeInfo(this->roadtype);
      if (rti->max_speed > 0) {
        return GetString(STR_TOOLBAR_ROADTYPE_VELOCITY, rti->strings.toolbar_caption, PackVelocity(rti->max_speed / 2, VehicleType::Road));
      }
      return GetString(rti->strings.toolbar_caption);
 
    }
 
    return this->Window::GetWidgetString(widget, stringid);
  }

  void UpdateOptionWidgetStatus(RoadToolbarWidgets clicked_widget)
  {
    /* The remove and the one way button state is driven
     * by the other buttons so they don't act on themselves.
     * Both are only valid if they are able to apply as options. */
    switch (clicked_widget) {
      case WID_ROT_REMOVE:
        if (RoadTypeIsRoad(this->roadtype)) {
          this->RaiseWidget(WID_ROT_ONE_WAY);
          this->SetWidgetDirty(WID_ROT_ONE_WAY);
        }
 
        break;
 
      case WID_ROT_ONE_WAY:
        this->RaiseWidget(WID_ROT_REMOVE);
        this->SetWidgetDirty(WID_ROT_REMOVE);
        break;
 
      case WID_ROT_BUS_STATION:
      case WID_ROT_TRUCK_STATION:
      case WID_ROT_BUILD_WAYPOINT:
        if (RoadTypeIsRoad(this->roadtype)) this->DisableWidget(WID_ROT_ONE_WAY);
        this->SetWidgetDisabledState(WID_ROT_REMOVE, !this->IsWidgetLowered(clicked_widget));
        break;
 
      case WID_ROT_ROAD_X:
      case WID_ROT_ROAD_Y:
      case WID_ROT_AUTOROAD:
        this->SetWidgetDisabledState(WID_ROT_REMOVE, !this->IsWidgetLowered(clicked_widget));
        if (RoadTypeIsRoad(this->roadtype)) {
          this->SetWidgetDisabledState(WID_ROT_ONE_WAY, !this->IsWidgetLowered(clicked_widget));
        }
        break;
 
      default:
        /* When any other buttons than road/station, raise and
         * disable the removal button */
        this->SetWidgetDisabledState(WID_ROT_REMOVE, true);
        this->SetWidgetLoweredState(WID_ROT_REMOVE, false);
 
        if (RoadTypeIsRoad(this->roadtype)) {
          this->SetWidgetDisabledState(WID_ROT_ONE_WAY, true);
          this->SetWidgetLoweredState(WID_ROT_ONE_WAY, false);
        }
 
        break;
    }
  }

  CursorID GetCursorForWidget(WidgetID widget)
  {
    switch (widget) {
      case WID_ROT_ROAD_X: return GetRoadTypeInfo(this->roadtype)->cursor.road_nwse;
      case WID_ROT_ROAD_Y: return GetRoadTypeInfo(this->roadtype)->cursor.road_swne;
      case WID_ROT_AUTOROAD: return GetRoadTypeInfo(this->roadtype)->cursor.autoroad;
      case WID_ROT_DEMOLISH: return ANIMCURSOR_DEMOLISH;
      case WID_ROT_DEPOT: return GetRoadTypeInfo(this->roadtype)->cursor.depot;
      case WID_ROT_BUILD_WAYPOINT: return SPR_CURSOR_WAYPOINT;
      case WID_ROT_BUS_STATION: return SPR_CURSOR_BUS_STATION;
      case WID_ROT_TRUCK_STATION: return SPR_CURSOR_TRUCK_STATION;
      case WID_ROT_BUILD_BRIDGE: return SPR_CURSOR_BRIDGE;
      case WID_ROT_BUILD_TUNNEL: return GetRoadTypeInfo(this->roadtype)->cursor.tunnel;
      case WID_ROT_CONVERT_ROAD: return GetRoadTypeInfo(this->roadtype)->cursor.convert_road;
      default: NOT_REACHED();
    }
  }

  HighLightStyle GetHighLightStyleForWidget(WidgetID widget)
  {
    switch (widget) {
      case WID_ROT_ROAD_X: return HT_RECT;
      case WID_ROT_ROAD_Y: return HT_RECT;
      case WID_ROT_AUTOROAD: return HT_RECT;
      case WID_ROT_DEMOLISH: return HT_RECT | HT_DIAGONAL;
      case WID_ROT_DEPOT: return HT_RECT;
      case WID_ROT_BUILD_WAYPOINT: return HT_RECT;
      case WID_ROT_BUS_STATION: return HT_RECT;
      case WID_ROT_TRUCK_STATION: return HT_RECT;
      case WID_ROT_BUILD_BRIDGE: return HT_RECT;
      case WID_ROT_BUILD_TUNNEL: return HT_SPECIAL;
      case WID_ROT_CONVERT_ROAD: return HT_RECT | HT_DIAGONAL;
      default: NOT_REACHED();
    }
  }
 
  void OnClick([[maybe_unused]] Point pt, WidgetID widget, [[maybe_unused]] int click_count) override
  {
    bool started;
    _remove_button_clicked = false;
    _one_way_button_clicked = false;
 
    if (widget != WID_ROT_ONE_WAY && widget != WID_ROT_REMOVE) {
      started = HandlePlacePushButton(this, widget, this->GetCursorForWidget(widget), this->GetHighLightStyleForWidget(widget));
      this->last_started_action = widget;
    }
 
    switch (widget) {
      case WID_ROT_DEPOT:
        if (started) {
          ShowRoadDepotPicker(this);
        }
        break;
 
      case WID_ROT_BUILD_WAYPOINT:
        if (started) {
          ShowBuildRoadWaypointPicker(this);
        }
        break;
 
      case WID_ROT_BUS_STATION:
        if (started) {
          ShowRVStationPicker(this, RoadStopType::Bus);
        }
        break;
 
      case WID_ROT_TRUCK_STATION:
        if (started) {
          ShowRVStationPicker(this, RoadStopType::Truck);
        }
        break;
 
      case WID_ROT_ONE_WAY:
        if (this->IsWidgetDisabled(WID_ROT_ONE_WAY)) return;
        this->SetDirty();
        this->ToggleWidgetLoweredState(WID_ROT_ONE_WAY);
        SetSelectionRed(false);
        break;
 
      case WID_ROT_REMOVE:
        if (this->IsWidgetDisabled(WID_ROT_REMOVE)) return;
 
        CloseWindowById(WindowClass::JoinStation, 0);
        ToggleRoadButton_Remove(this);
        SndClickBeep();
        break;
    }
    this->UpdateOptionWidgetStatus(static_cast<RoadToolbarWidgets>(widget));
    if (_ctrl_pressed) RoadToolbar_CtrlChanged(this);
  }

  EventState ChangeRoadTypeOnHotkey(int hotkey)
  {
    auto [index, step] = GetListIndexStep(SpecialListHotkeys(hotkey), _sorted_roadtypes, this->roadtype);
 
    while (RoadTypeIsRoad(_sorted_roadtypes[index]) != RoadTypeIsRoad(this->roadtype) || !HasRoadTypeAvail(_local_company, _sorted_roadtypes[index])) {
      index = (index + step) % _sorted_roadtypes.size();
    }
 
    _cur_roadtype = _sorted_roadtypes[index];
    if (RoadTypeIsRoad(_cur_roadtype)) {
      _last_built_roadtype = _cur_roadtype;
    } else {
      _last_built_tramtype = _cur_roadtype;
    }
    this->ModifyRoadType(_cur_roadtype);
 
    if (_thd.GetCallbackWnd() == this) SetCursor(this->GetCursorForWidget(this->last_started_action), PAL_NONE);
    for (WindowClass cls : {WindowClass::BuildBusStation, WindowClass::BuildTruckStation, WindowClass::BuildWaypoint, WindowClass::BuildDepot}) {
      SetWindowDirty(cls, TransportType::Road);
    }
 
    return EventState::Handled;
  }
 
  EventState OnHotkey(int hotkey) override
  {
    if (IsSpecialHotkey(hotkey)) return this->ChangeRoadTypeOnHotkey(hotkey);
    MarkTileDirtyByTile(TileVirtXY(_thd.pos.x, _thd.pos.y)); // redraw tile selection
    return Window::OnHotkey(hotkey);
  }
 
  void OnPlaceObject([[maybe_unused]] Point pt, TileIndex tile) override
  {
    _remove_button_clicked = this->IsWidgetLowered(WID_ROT_REMOVE);
    _one_way_button_clicked = RoadTypeIsRoad(this->roadtype) ? this->IsWidgetLowered(WID_ROT_ONE_WAY) : false;
    switch (this->last_started_action) {
      case WID_ROT_ROAD_X:
        _place_road_dir = Axis::X;
        _place_road_start_half_x = _tile_fract_coords.x >= 8;
        VpStartPlaceSizing(tile, VPM_FIX_Y, DDSP_PLACE_ROAD_X_DIR);
        break;
 
      case WID_ROT_ROAD_Y:
        _place_road_dir = Axis::Y;
        _place_road_start_half_y = _tile_fract_coords.y >= 8;
        VpStartPlaceSizing(tile, VPM_FIX_X, DDSP_PLACE_ROAD_Y_DIR);
        break;
 
      case WID_ROT_AUTOROAD:
        _place_road_dir = Axis::Invalid;
        _place_road_start_half_x = _tile_fract_coords.x >= 8;
        _place_road_start_half_y = _tile_fract_coords.y >= 8;
        VpStartPlaceSizing(tile, VPM_X_OR_Y, DDSP_PLACE_AUTOROAD);
        break;
 
      case WID_ROT_DEMOLISH:
        PlaceProc_DemolishArea(tile);
        break;
 
      case WID_ROT_DEPOT:
        Command<Commands::BuildRoadDepot>::Post(GetRoadTypeInfo(this->roadtype)->strings.err_depot, CcRoadDepot,
            tile, _cur_roadtype, _road_depot_orientation);
        break;
 
      case WID_ROT_BUILD_WAYPOINT:
        PlaceRoad_Waypoint(tile);
        break;
 
      case WID_ROT_BUS_STATION:
        PlaceRoad_BusStation(tile);
        break;
 
      case WID_ROT_TRUCK_STATION:
        PlaceRoad_TruckStation(tile);
        break;
 
      case WID_ROT_BUILD_BRIDGE:
        PlaceRoad_Bridge(tile, this);
        break;
 
      case WID_ROT_BUILD_TUNNEL:
        Command<Commands::BuildTunnel>::Post(STR_ERROR_CAN_T_BUILD_TUNNEL_HERE, CcBuildRoadTunnel,
            tile, TransportType::Road, INVALID_RAILTYPE, _cur_roadtype);
        break;
 
      case WID_ROT_CONVERT_ROAD:
        VpStartPlaceSizing(tile, VPM_X_AND_Y, DDSP_CONVERT_ROAD);
        break;
 
      default: NOT_REACHED();
    }
  }
 
  void OnPlaceObjectAbort() override
  {
    if (_game_mode != GameMode::Editor && (this->IsWidgetLowered(WID_ROT_BUS_STATION) || this->IsWidgetLowered(WID_ROT_TRUCK_STATION))) SetViewportCatchmentStation(nullptr, true);
 
    this->RaiseButtons();
    this->SetWidgetDisabledState(WID_ROT_REMOVE, true);
    this->SetWidgetDirty(WID_ROT_REMOVE);
 
    if (RoadTypeIsRoad(this->roadtype)) {
      this->SetWidgetDisabledState(WID_ROT_ONE_WAY, true);
      this->SetWidgetDirty(WID_ROT_ONE_WAY);
    }
 
    CloseWindowById(WindowClass::BuildBusStation, TransportType::Road);
    CloseWindowById(WindowClass::BuildTruckStation, TransportType::Road);
    CloseWindowById(WindowClass::BuildDepot, TransportType::Road);
    CloseWindowById(WindowClass::BuildWaypoint, TransportType::Road);
    CloseWindowById(WindowClass::JoinStation, 0);
    CloseWindowByClass(WindowClass::BuildBridge);
  }
 
  void OnPlaceDrag(ViewportPlaceMethod select_method, [[maybe_unused]] ViewportDragDropSelectionProcess select_proc, [[maybe_unused]] Point pt) override
  {
    /* Here we update the end tile flags
     * of the road placement actions.
     * At first we reset the end halfroad
     * bits and if needed we set them again. */
    switch (select_proc) {
      case DDSP_PLACE_ROAD_X_DIR:
        _place_road_end_half = pt.x & 8;
        break;
 
      case DDSP_PLACE_ROAD_Y_DIR:
        _place_road_end_half = pt.y & 8;
        break;
 
      case DDSP_PLACE_AUTOROAD:
        /* For autoroad we need to update the
         * direction of the road */
        if (_thd.size.x > _thd.size.y || (_thd.size.x == _thd.size.y &&
            ( (_tile_fract_coords.x < _tile_fract_coords.y && (_tile_fract_coords.x + _tile_fract_coords.y) < 16) ||
            (_tile_fract_coords.x > _tile_fract_coords.y && (_tile_fract_coords.x + _tile_fract_coords.y) > 16) ))) {
          /* Set dir = X */
          _place_road_dir = Axis::X;
          _place_road_end_half = pt.x & 8;
        } else {
          /* Set dir = Y */
          _place_road_dir = Axis::Y;
          _place_road_end_half = pt.y & 8;
        }
 
        break;
 
      default:
        break;
    }
 
    VpSelectTilesWithMethod(pt.x, pt.y, select_method);
  }
 
  Point OnInitialPosition(int16_t sm_width, [[maybe_unused]] int16_t sm_height, [[maybe_unused]] int window_number) override
  {
    return AlignInitialConstructionToolbar(sm_width);
  }
 
  void OnPlaceMouseUp([[maybe_unused]] ViewportPlaceMethod select_method, ViewportDragDropSelectionProcess select_proc, [[maybe_unused]] Point pt, TileIndex start_tile, TileIndex end_tile) override
  {
    if (pt.x != -1) {
      switch (select_proc) {
        default: NOT_REACHED();
        case DDSP_BUILD_BRIDGE:
          if (!_settings_client.gui.persistent_buildingtools) ResetObjectToPlace();
          ShowBuildBridgeWindow(start_tile, end_tile, TransportType::Road, INVALID_RAILTYPE, _cur_roadtype);
          break;
 
        case DDSP_DEMOLISH_AREA:
          GUIPlaceProcDragXY(select_proc, start_tile, end_tile);
          break;
 
        case DDSP_PLACE_ROAD_X_DIR:
        case DDSP_PLACE_ROAD_Y_DIR:
        case DDSP_PLACE_AUTOROAD: {
          bool start_half = _place_road_dir == Axis::Y ? _place_road_start_half_y : _place_road_start_half_x;
 
          if (_remove_button_clicked) {
            Command<Commands::RemoveRoadLong>::Post(GetRoadTypeInfo(this->roadtype)->strings.err_remove_road, CcPlaySound_CONSTRUCTION_OTHER,
                end_tile, start_tile, _cur_roadtype, _place_road_dir, start_half, _place_road_end_half);
          } else {
            Command<Commands::BuildRoadLong>::Post(GetRoadTypeInfo(this->roadtype)->strings.err_build_road, CcPlaySound_CONSTRUCTION_OTHER,
                end_tile, start_tile, _cur_roadtype, _place_road_dir, _one_way_button_clicked ? DisallowedRoadDirection::Northbound : DisallowedRoadDirections{}, start_half, _place_road_end_half, false);
          }
          break;
        }
 
        case DDSP_BUILD_ROAD_WAYPOINT:
        case DDSP_REMOVE_ROAD_WAYPOINT:
          if (this->IsWidgetLowered(WID_ROT_BUILD_WAYPOINT)) {
            if (_remove_button_clicked) {
              Command<Commands::RemoveFromRoadWaypoint>::Post(STR_ERROR_CAN_T_REMOVE_ROAD_WAYPOINT, CcPlaySound_CONSTRUCTION_OTHER, end_tile, start_tile);
            } else {
              TileArea ta(start_tile, end_tile);
              Axis axis = select_method == VPM_X_LIMITED ? Axis::X : Axis::Y;
              bool adjacent = _ctrl_pressed;
 
              auto proc = [=](bool test, StationID to_join) -> bool {
                if (test) {
                  return Command<Commands::BuildRoadWaypoint>::Do(CommandFlagsToDCFlags(GetCommandFlags<Commands::BuildRoadWaypoint>()), ta.tile, axis, ta.w, ta.h, _waypoint_gui.sel_class, _waypoint_gui.sel_type, StationID::Invalid(), adjacent).Succeeded();
                } else {
                  return Command<Commands::BuildRoadWaypoint>::Post(STR_ERROR_CAN_T_BUILD_ROAD_WAYPOINT, CcPlaySound_CONSTRUCTION_OTHER, ta.tile, axis, ta.w, ta.h, _waypoint_gui.sel_class, _waypoint_gui.sel_type, to_join, adjacent);
                }
              };
 
              ShowSelectRoadWaypointIfNeeded(ta, proc);
            }
          }
          break;
 
        case DDSP_BUILD_BUSSTOP:
        case DDSP_REMOVE_BUSSTOP:
          if (this->IsWidgetLowered(WID_ROT_BUS_STATION) && GetIfClassHasNewStopsByType(RoadStopClass::Get(_roadstop_gui.sel_class), RoadStopType::Bus, _cur_roadtype)) {
            if (_remove_button_clicked) {
              TileArea ta(start_tile, end_tile);
              StringID str = GetRoadTypeInfo(this->roadtype)->strings.err_remove_station[RoadStopType::Bus];
              Command<Commands::RemoveRoadStop>::Post(str, CcPlaySound_CONSTRUCTION_OTHER, ta.tile, ta.w, ta.h, RoadStopType::Bus, _ctrl_pressed);
            } else {
              StringID str = GetRoadTypeInfo(this->roadtype)->strings.err_build_station[RoadStopType::Bus];
              PlaceRoadStop(start_tile, end_tile, RoadStopType::Bus, _ctrl_pressed, _cur_roadtype, str);
            }
          }
          break;
 
        case DDSP_BUILD_TRUCKSTOP:
        case DDSP_REMOVE_TRUCKSTOP:
          if (this->IsWidgetLowered(WID_ROT_TRUCK_STATION) && GetIfClassHasNewStopsByType(RoadStopClass::Get(_roadstop_gui.sel_class), RoadStopType::Truck, _cur_roadtype)) {
            if (_remove_button_clicked) {
              TileArea ta(start_tile, end_tile);
              StringID str = GetRoadTypeInfo(this->roadtype)->strings.err_remove_station[RoadStopType::Truck];
              Command<Commands::RemoveRoadStop>::Post(str, CcPlaySound_CONSTRUCTION_OTHER, ta.tile, ta.w, ta.h, RoadStopType::Truck, _ctrl_pressed);
            } else {
              StringID str = GetRoadTypeInfo(this->roadtype)->strings.err_build_station[RoadStopType::Truck];
              PlaceRoadStop(start_tile, end_tile, RoadStopType::Truck, _ctrl_pressed, _cur_roadtype, str);
            }
          }
          break;
 
        case DDSP_CONVERT_ROAD:
          Command<Commands::ConvertRoad>::Post(GetRoadTypeInfo(this->roadtype)->strings.err_convert_road, CcPlaySound_CONSTRUCTION_OTHER, end_tile, start_tile, _cur_roadtype, _ctrl_pressed);
          break;
      }
    }
  }
 
  void OnPlacePresize([[maybe_unused]] Point pt, TileIndex tile) override
  {
    Command<Commands::BuildTunnel>::Do(DoCommandFlag::Auto, tile, TransportType::Road, INVALID_RAILTYPE, _cur_roadtype);
    VpSetPresizeRange(tile, _build_tunnel_endtile == INVALID_TILE ? tile : _build_tunnel_endtile);
  }
 
  EventState OnCTRLStateChange() override
  {
    if (RoadToolbar_CtrlChanged(this)) return EventState::Handled;
    return EventState::NotHandled;
  }
 
  void OnRealtimeTick([[maybe_unused]] uint delta_ms) override
  {
    if (_game_mode == GameMode::Normal && this->IsWidgetLowered(WID_ROT_BUILD_WAYPOINT)) CheckRedrawRoadWaypointCoverage(this);
  }

  static EventState RoadTramToolbarGlobalHotkeys(int hotkey, RoadType last_build, RoadTramType rtt)
  {
    Window *w = nullptr;
    switch (_game_mode) {
      case GameMode::Normal:
        w = ShowBuildRoadToolbar(last_build);
        break;
 
      case GameMode::Editor:
        if (!GetRoadTypes(true).Any(GetMaskForRoadTramType(rtt))) return EventState::NotHandled;
        w = ShowBuildRoadScenToolbar(last_build);
        break;
 
      default:
        break;
    }
 
    if (w == nullptr) return EventState::NotHandled;
    return w->OnHotkey(hotkey);
  }
 
  static EventState RoadToolbarGlobalHotkeys(int hotkey)
  {
    return RoadTramToolbarGlobalHotkeys(hotkey, _last_built_roadtype, RoadTramType::Road);
  }
 
  static EventState TramToolbarGlobalHotkeys(int hotkey)
  {
    return RoadTramToolbarGlobalHotkeys(hotkey, _last_built_tramtype, RoadTramType::Tram);
  }
 
  static inline HotkeyList road_hotkeys{"roadtoolbar", {
    Hotkey('1', "build_x", WID_ROT_ROAD_X),
    Hotkey('2', "build_y", WID_ROT_ROAD_Y),
    Hotkey('3', "autoroad", WID_ROT_AUTOROAD),
    Hotkey('4', "demolish", WID_ROT_DEMOLISH),
    Hotkey('5', "depot", WID_ROT_DEPOT),
    Hotkey('6', "bus_station", WID_ROT_BUS_STATION),
    Hotkey('7', "truck_station", WID_ROT_TRUCK_STATION),
    Hotkey('8', "oneway", WID_ROT_ONE_WAY),
    Hotkey('9', "waypoint", WID_ROT_BUILD_WAYPOINT),
    Hotkey('B', "bridge", WID_ROT_BUILD_BRIDGE),
    Hotkey('T', "tunnel", WID_ROT_BUILD_TUNNEL),
    Hotkey('R', "remove", WID_ROT_REMOVE),
    Hotkey('C', "convert", WID_ROT_CONVERT_ROAD),
    Hotkey(WKC_L_BRACKET, "prev_roadtype", to_underlying(SpecialListHotkeys::PreviousItem)),
    Hotkey(WKC_R_BRACKET, "next_roadtype", to_underlying(SpecialListHotkeys::NextItem)),
    Hotkey(WKC_L_BRACKET | WKC_CTRL, "first_roadtype", to_underlying(SpecialListHotkeys::FirstItem)),
    Hotkey(WKC_R_BRACKET | WKC_CTRL, "last_roadtype", to_underlying(SpecialListHotkeys::LastItem)),
  }, RoadToolbarGlobalHotkeys};
 
  static inline HotkeyList tram_hotkeys{"tramtoolbar", {
    Hotkey('1', "build_x", WID_ROT_ROAD_X),
    Hotkey('2', "build_y", WID_ROT_ROAD_Y),
    Hotkey('3', "autoroad", WID_ROT_AUTOROAD),
    Hotkey('4', "demolish", WID_ROT_DEMOLISH),
    Hotkey('5', "depot", WID_ROT_DEPOT),
    Hotkey('6', "bus_station", WID_ROT_BUS_STATION),
    Hotkey('7', "truck_station", WID_ROT_TRUCK_STATION),
    Hotkey('9', "waypoint", WID_ROT_BUILD_WAYPOINT),
    Hotkey('B', "bridge", WID_ROT_BUILD_BRIDGE),
    Hotkey('T', "tunnel", WID_ROT_BUILD_TUNNEL),
    Hotkey('R', "remove", WID_ROT_REMOVE),
    Hotkey('C', "convert", WID_ROT_CONVERT_ROAD),
    Hotkey(WKC_L_BRACKET, "prev_tramtype", to_underlying(SpecialListHotkeys::PreviousItem)),
    Hotkey(WKC_R_BRACKET, "next_tramtype", to_underlying(SpecialListHotkeys::NextItem)),
    Hotkey(WKC_L_BRACKET | WKC_CTRL, "first_tramtype", to_underlying(SpecialListHotkeys::FirstItem)),
    Hotkey(WKC_R_BRACKET | WKC_CTRL, "last_tramtype", to_underlying(SpecialListHotkeys::LastItem)),
  }, TramToolbarGlobalHotkeys};
};
 
static constexpr std::initializer_list<NWidgetPart> _nested_build_road_widgets = {
  NWidget(NWID_HORIZONTAL),
    NWidget(WWT_CLOSEBOX, Colours::DarkGreen),
    NWidget(WWT_CAPTION, Colours::DarkGreen, WID_ROT_CAPTION), SetTextStyle(TextColour::White),
    NWidget(WWT_STICKYBOX, Colours::DarkGreen),
  EndContainer(),
  NWidget(NWID_HORIZONTAL),
    NWidget(WWT_IMGBTN, Colours::DarkGreen, WID_ROT_ROAD_X),
            SetFill(0, 1), SetToolbarMinimalSize(1), SetSpriteTip(SPR_IMG_ROAD_X_DIR, STR_ROAD_TOOLBAR_TOOLTIP_BUILD_ROAD_SECTION),
    NWidget(WWT_IMGBTN, Colours::DarkGreen, WID_ROT_ROAD_Y),
            SetFill(0, 1), SetToolbarMinimalSize(1), SetSpriteTip(SPR_IMG_ROAD_Y_DIR, STR_ROAD_TOOLBAR_TOOLTIP_BUILD_ROAD_SECTION),
    NWidget(WWT_IMGBTN, Colours::DarkGreen, WID_ROT_AUTOROAD),
            SetFill(0, 1), SetToolbarMinimalSize(1), SetSpriteTip(SPR_IMG_AUTOROAD, STR_ROAD_TOOLBAR_TOOLTIP_BUILD_AUTOROAD),
    NWidget(WWT_IMGBTN, Colours::DarkGreen, WID_ROT_DEMOLISH),
            SetFill(0, 1), SetToolbarMinimalSize(1), SetSpriteTip(SPR_IMG_DYNAMITE, STR_TOOLTIP_DEMOLISH_BUILDINGS_ETC),
    NWidget(WWT_IMGBTN, Colours::DarkGreen, WID_ROT_DEPOT),
            SetFill(0, 1), SetToolbarMinimalSize(1), SetSpriteTip(SPR_IMG_ROAD_DEPOT, STR_ROAD_TOOLBAR_TOOLTIP_BUILD_ROAD_VEHICLE_DEPOT),
    NWidget(WWT_IMGBTN, Colours::DarkGreen, WID_ROT_BUILD_WAYPOINT),
            SetFill(0, 1), SetToolbarMinimalSize(1), SetSpriteTip(SPR_IMG_WAYPOINT, STR_ROAD_TOOLBAR_TOOLTIP_CONVERT_ROAD_TO_WAYPOINT),
    NWidget(WWT_IMGBTN, Colours::DarkGreen, WID_ROT_BUS_STATION),
            SetFill(0, 1), SetToolbarMinimalSize(1), SetSpriteTip(SPR_IMG_BUS_STATION, STR_ROAD_TOOLBAR_TOOLTIP_BUILD_BUS_STATION),
    NWidget(WWT_IMGBTN, Colours::DarkGreen, WID_ROT_TRUCK_STATION),
            SetFill(0, 1), SetToolbarMinimalSize(1), SetSpriteTip(SPR_IMG_TRUCK_BAY, STR_ROAD_TOOLBAR_TOOLTIP_BUILD_TRUCK_LOADING_BAY),
 
    NWidget(WWT_PANEL, Colours::DarkGreen), SetFill(1, 1), EndContainer(),
 
    NWidget(WWT_IMGBTN, Colours::DarkGreen, WID_ROT_ONE_WAY),
            SetFill(0, 1), SetToolbarMinimalSize(1), SetSpriteTip(SPR_IMG_ROAD_ONE_WAY, STR_ROAD_TOOLBAR_TOOLTIP_TOGGLE_ONE_WAY_ROAD),
    NWidget(WWT_IMGBTN, Colours::DarkGreen, WID_ROT_BUILD_BRIDGE),
            SetFill(0, 1), SetToolbarMinimalSize(2), SetSpriteTip(SPR_IMG_BRIDGE, STR_ROAD_TOOLBAR_TOOLTIP_BUILD_ROAD_BRIDGE),
    NWidget(WWT_IMGBTN, Colours::DarkGreen, WID_ROT_BUILD_TUNNEL),
            SetFill(0, 1), SetToolbarMinimalSize(1), SetSpriteTip(SPR_IMG_ROAD_TUNNEL, STR_ROAD_TOOLBAR_TOOLTIP_BUILD_ROAD_TUNNEL),
    NWidget(WWT_IMGBTN, Colours::DarkGreen, WID_ROT_REMOVE),
            SetFill(0, 1), SetToolbarMinimalSize(1), SetSpriteTip(SPR_IMG_REMOVE, STR_ROAD_TOOLBAR_TOOLTIP_TOGGLE_BUILD_REMOVE_FOR_ROAD),
    NWidget(WWT_IMGBTN, Colours::DarkGreen, WID_ROT_CONVERT_ROAD),
            SetFill(0, 1), SetToolbarMinimalSize(1), SetSpriteTip(SPR_IMG_CONVERT_ROAD, STR_ROAD_TOOLBAR_TOOLTIP_CONVERT_ROAD),
  EndContainer(),
};

static WindowDesc _build_road_desc(
  WindowPosition::Manual, "toolbar_road", 0, 0,
  WindowClass::BuildToolbar, WindowClass::None,
  WindowDefaultFlag::Construction,
  _nested_build_road_widgets,
  &BuildRoadToolbarWindow::road_hotkeys
);
 
static constexpr std::initializer_list<NWidgetPart> _nested_build_tramway_widgets = {
  NWidget(NWID_HORIZONTAL),
    NWidget(WWT_CLOSEBOX, Colours::DarkGreen),
    NWidget(WWT_CAPTION, Colours::DarkGreen, WID_ROT_CAPTION), SetTextStyle(TextColour::White),
    NWidget(WWT_STICKYBOX, Colours::DarkGreen),
  EndContainer(),
  NWidget(NWID_HORIZONTAL),
    NWidget(WWT_IMGBTN, Colours::DarkGreen, WID_ROT_ROAD_X),
            SetFill(0, 1), SetToolbarMinimalSize(1), SetSpriteTip(SPR_IMG_TRAMWAY_X_DIR, STR_ROAD_TOOLBAR_TOOLTIP_BUILD_TRAMWAY_SECTION),
    NWidget(WWT_IMGBTN, Colours::DarkGreen, WID_ROT_ROAD_Y),
            SetFill(0, 1), SetToolbarMinimalSize(1), SetSpriteTip(SPR_IMG_TRAMWAY_Y_DIR, STR_ROAD_TOOLBAR_TOOLTIP_BUILD_TRAMWAY_SECTION),
    NWidget(WWT_IMGBTN, Colours::DarkGreen, WID_ROT_AUTOROAD),
            SetFill(0, 1), SetToolbarMinimalSize(1), SetSpriteTip(SPR_IMG_AUTOTRAM, STR_ROAD_TOOLBAR_TOOLTIP_BUILD_AUTOTRAM),
    NWidget(WWT_IMGBTN, Colours::DarkGreen, WID_ROT_DEMOLISH),
            SetFill(0, 1), SetToolbarMinimalSize(1), SetSpriteTip(SPR_IMG_DYNAMITE, STR_TOOLTIP_DEMOLISH_BUILDINGS_ETC),
    NWidget(WWT_IMGBTN, Colours::DarkGreen, WID_ROT_DEPOT),
            SetFill(0, 1), SetToolbarMinimalSize(1), SetSpriteTip(SPR_IMG_ROAD_DEPOT, STR_ROAD_TOOLBAR_TOOLTIP_BUILD_TRAM_VEHICLE_DEPOT),
    NWidget(WWT_IMGBTN, Colours::DarkGreen, WID_ROT_BUILD_WAYPOINT),
            SetFill(0, 1), SetToolbarMinimalSize(1), SetSpriteTip(SPR_IMG_WAYPOINT, STR_ROAD_TOOLBAR_TOOLTIP_CONVERT_TRAM_TO_WAYPOINT),
    NWidget(WWT_IMGBTN, Colours::DarkGreen, WID_ROT_BUS_STATION),
            SetFill(0, 1), SetToolbarMinimalSize(1), SetSpriteTip(SPR_IMG_BUS_STATION, STR_ROAD_TOOLBAR_TOOLTIP_BUILD_PASSENGER_TRAM_STATION),
    NWidget(WWT_IMGBTN, Colours::DarkGreen, WID_ROT_TRUCK_STATION),
            SetFill(0, 1), SetToolbarMinimalSize(1), SetSpriteTip(SPR_IMG_TRUCK_BAY, STR_ROAD_TOOLBAR_TOOLTIP_BUILD_CARGO_TRAM_STATION),
 
    NWidget(WWT_PANEL, Colours::DarkGreen), SetFill(1, 1), EndContainer(),
 
    NWidget(WWT_IMGBTN, Colours::DarkGreen, WID_ROT_BUILD_BRIDGE),
            SetFill(0, 1), SetToolbarMinimalSize(2), SetSpriteTip(SPR_IMG_BRIDGE, STR_ROAD_TOOLBAR_TOOLTIP_BUILD_TRAMWAY_BRIDGE),
    NWidget(WWT_IMGBTN, Colours::DarkGreen, WID_ROT_BUILD_TUNNEL),
            SetFill(0, 1), SetToolbarMinimalSize(1), SetSpriteTip(SPR_IMG_ROAD_TUNNEL, STR_ROAD_TOOLBAR_TOOLTIP_BUILD_TRAMWAY_TUNNEL),
    NWidget(WWT_IMGBTN, Colours::DarkGreen, WID_ROT_REMOVE),
            SetFill(0, 1), SetToolbarMinimalSize(1), SetSpriteTip(SPR_IMG_REMOVE, STR_ROAD_TOOLBAR_TOOLTIP_TOGGLE_BUILD_REMOVE_FOR_TRAMWAYS),
    NWidget(WWT_IMGBTN, Colours::DarkGreen, WID_ROT_CONVERT_ROAD),
            SetFill(0, 1), SetToolbarMinimalSize(1), SetSpriteTip(SPR_IMG_CONVERT_ROAD, STR_ROAD_TOOLBAR_TOOLTIP_CONVERT_TRAM),
  EndContainer(),
};

static WindowDesc _build_tramway_desc(
  WindowPosition::Manual, "toolbar_tramway", 0, 0,
  WindowClass::BuildToolbar, WindowClass::None,
  WindowDefaultFlag::Construction,
  _nested_build_tramway_widgets,
  &BuildRoadToolbarWindow::tram_hotkeys
);

Window *ShowBuildRoadToolbar(RoadType roadtype)
{
  if (!Company::IsValidID(_local_company)) return nullptr;
  if (!ValParamRoadType(roadtype)) return nullptr;
 
  if (GetRoadTramType(roadtype) == GetRoadTramType(_cur_roadtype)) {
    Window *w = BringWindowToFrontById(WindowClass::BuildToolbar, TransportType::Road);
 
    if (w != nullptr) {
      _cur_roadtype = roadtype;
      w->OnInvalidateData();
      return w;
    }
  }
 
  _cur_roadtype = roadtype;
  CloseWindowByClass(WindowClass::BuildToolbar);
  return AllocateWindowDescFront<BuildRoadToolbarWindow>(RoadTypeIsRoad(_cur_roadtype) ? _build_road_desc : _build_tramway_desc, TransportType::Road);
}
 
static constexpr std::initializer_list<NWidgetPart> _nested_build_road_scen_widgets = {
  NWidget(NWID_HORIZONTAL),
    NWidget(WWT_CLOSEBOX, Colours::DarkGreen),
    NWidget(WWT_CAPTION, Colours::DarkGreen, WID_ROT_CAPTION), SetTextStyle(TextColour::White),
    NWidget(WWT_STICKYBOX, Colours::DarkGreen),
  EndContainer(),
  NWidget(NWID_HORIZONTAL),
    NWidget(WWT_IMGBTN, Colours::DarkGreen, WID_ROT_ROAD_X),
            SetFill(0, 1), SetToolbarMinimalSize(1), SetSpriteTip(SPR_IMG_ROAD_X_DIR, STR_ROAD_TOOLBAR_TOOLTIP_BUILD_ROAD_SECTION),
    NWidget(WWT_IMGBTN, Colours::DarkGreen, WID_ROT_ROAD_Y),
            SetFill(0, 1), SetToolbarMinimalSize(1), SetSpriteTip(SPR_IMG_ROAD_Y_DIR, STR_ROAD_TOOLBAR_TOOLTIP_BUILD_ROAD_SECTION),
    NWidget(WWT_IMGBTN, Colours::DarkGreen, WID_ROT_AUTOROAD),
            SetFill(0, 1), SetToolbarMinimalSize(1), SetSpriteTip(SPR_IMG_AUTOROAD, STR_ROAD_TOOLBAR_TOOLTIP_BUILD_AUTOROAD),
    NWidget(WWT_IMGBTN, Colours::DarkGreen, WID_ROT_DEMOLISH),
            SetFill(0, 1), SetToolbarMinimalSize(1), SetSpriteTip(SPR_IMG_DYNAMITE, STR_TOOLTIP_DEMOLISH_BUILDINGS_ETC),
 
    NWidget(WWT_PANEL, Colours::DarkGreen), SetFill(1, 1), EndContainer(),
 
    NWidget(WWT_IMGBTN, Colours::DarkGreen, WID_ROT_ONE_WAY),
            SetFill(0, 1), SetToolbarMinimalSize(1), SetSpriteTip(SPR_IMG_ROAD_ONE_WAY, STR_ROAD_TOOLBAR_TOOLTIP_TOGGLE_ONE_WAY_ROAD),
    NWidget(WWT_IMGBTN, Colours::DarkGreen, WID_ROT_BUILD_BRIDGE),
            SetFill(0, 1), SetToolbarMinimalSize(2), SetSpriteTip(SPR_IMG_BRIDGE, STR_ROAD_TOOLBAR_TOOLTIP_BUILD_ROAD_BRIDGE),
    NWidget(WWT_IMGBTN, Colours::DarkGreen, WID_ROT_BUILD_TUNNEL),
            SetFill(0, 1), SetToolbarMinimalSize(1), SetSpriteTip(SPR_IMG_ROAD_TUNNEL, STR_ROAD_TOOLBAR_TOOLTIP_BUILD_ROAD_TUNNEL),
    NWidget(WWT_IMGBTN, Colours::DarkGreen, WID_ROT_REMOVE),
            SetFill(0, 1), SetToolbarMinimalSize(1), SetSpriteTip(SPR_IMG_REMOVE, STR_ROAD_TOOLBAR_TOOLTIP_TOGGLE_BUILD_REMOVE_FOR_ROAD),
    NWidget(WWT_IMGBTN, Colours::DarkGreen, WID_ROT_CONVERT_ROAD),
            SetFill(0, 1), SetToolbarMinimalSize(1), SetSpriteTip(SPR_IMG_CONVERT_ROAD, STR_ROAD_TOOLBAR_TOOLTIP_CONVERT_ROAD),
  EndContainer(),
};

static WindowDesc _build_road_scen_desc(
  WindowPosition::Automatic, "toolbar_road_scen", 0, 0,
  WindowClass::ScenarioBuildToolbar, WindowClass::None,
  WindowDefaultFlag::Construction,
  _nested_build_road_scen_widgets,
  &BuildRoadToolbarWindow::road_hotkeys
);
 
static constexpr std::initializer_list<NWidgetPart> _nested_build_tramway_scen_widgets = {
  NWidget(NWID_HORIZONTAL),
    NWidget(WWT_CLOSEBOX, Colours::DarkGreen),
    NWidget(WWT_CAPTION, Colours::DarkGreen, WID_ROT_CAPTION), SetTextStyle(TextColour::White),
    NWidget(WWT_STICKYBOX, Colours::DarkGreen),
  EndContainer(),
  NWidget(NWID_HORIZONTAL),
    NWidget(WWT_IMGBTN, Colours::DarkGreen, WID_ROT_ROAD_X),
            SetFill(0, 1), SetToolbarMinimalSize(1), SetSpriteTip(SPR_IMG_TRAMWAY_X_DIR, STR_ROAD_TOOLBAR_TOOLTIP_BUILD_TRAMWAY_SECTION),
    NWidget(WWT_IMGBTN, Colours::DarkGreen, WID_ROT_ROAD_Y),
            SetFill(0, 1), SetToolbarMinimalSize(1), SetSpriteTip(SPR_IMG_TRAMWAY_Y_DIR, STR_ROAD_TOOLBAR_TOOLTIP_BUILD_TRAMWAY_SECTION),
    NWidget(WWT_IMGBTN, Colours::DarkGreen, WID_ROT_AUTOROAD),
            SetFill(0, 1), SetToolbarMinimalSize(1), SetSpriteTip(SPR_IMG_AUTOTRAM, STR_ROAD_TOOLBAR_TOOLTIP_BUILD_AUTOTRAM),
    NWidget(WWT_IMGBTN, Colours::DarkGreen, WID_ROT_DEMOLISH),
            SetFill(0, 1), SetToolbarMinimalSize(1), SetSpriteTip(SPR_IMG_DYNAMITE, STR_TOOLTIP_DEMOLISH_BUILDINGS_ETC),
 
    NWidget(WWT_PANEL, Colours::DarkGreen), SetFill(1, 1), EndContainer(),
 
    NWidget(WWT_IMGBTN, Colours::DarkGreen, WID_ROT_BUILD_BRIDGE),
            SetFill(0, 1), SetToolbarMinimalSize(2), SetSpriteTip(SPR_IMG_BRIDGE, STR_ROAD_TOOLBAR_TOOLTIP_BUILD_TRAMWAY_BRIDGE),
    NWidget(WWT_IMGBTN, Colours::DarkGreen, WID_ROT_BUILD_TUNNEL),
            SetFill(0, 1), SetToolbarMinimalSize(1), SetSpriteTip(SPR_IMG_ROAD_TUNNEL, STR_ROAD_TOOLBAR_TOOLTIP_BUILD_TRAMWAY_TUNNEL),
    NWidget(WWT_IMGBTN, Colours::DarkGreen, WID_ROT_REMOVE),
            SetFill(0, 1), SetToolbarMinimalSize(1), SetSpriteTip(SPR_IMG_REMOVE, STR_ROAD_TOOLBAR_TOOLTIP_TOGGLE_BUILD_REMOVE_FOR_TRAMWAYS),
    NWidget(WWT_IMGBTN, Colours::DarkGreen, WID_ROT_CONVERT_ROAD),
            SetFill(0, 1), SetToolbarMinimalSize(1), SetSpriteTip(SPR_IMG_CONVERT_ROAD, STR_ROAD_TOOLBAR_TOOLTIP_CONVERT_TRAM),
  EndContainer(),
};

static WindowDesc _build_tramway_scen_desc(
  WindowPosition::Automatic, "toolbar_tram_scen", 0, 0,
  WindowClass::ScenarioBuildToolbar, WindowClass::None,
  WindowDefaultFlag::Construction,
  _nested_build_tramway_scen_widgets,
  &BuildRoadToolbarWindow::tram_hotkeys
);

Window *ShowBuildRoadScenToolbar(RoadType roadtype)
{
  CloseWindowById(WindowClass::ScenarioBuildToolbar, TransportType::Road);
  _cur_roadtype = roadtype;
 
  return AllocateWindowDescFront<BuildRoadToolbarWindow>(RoadTypeIsRoad(_cur_roadtype) ? _build_road_scen_desc : _build_tramway_scen_desc, TransportType::Road);
}
 
struct BuildRoadDepotWindow : public PickerWindowBase {
  BuildRoadDepotWindow(WindowDesc &desc, Window *parent) : PickerWindowBase(desc, parent)
  {
    this->CreateNestedTree();
 
    this->LowerWidget(WID_BROD_DEPOT_NE + _road_depot_orientation);
    if (RoadTypeIsTram(_cur_roadtype)) {
      this->GetWidget<NWidgetCore>(WID_BROD_CAPTION)->SetString(STR_BUILD_DEPOT_TRAM_ORIENTATION_CAPTION);
      for (WidgetID i = WID_BROD_DEPOT_NE; i <= WID_BROD_DEPOT_NW; i++) {
        this->GetWidget<NWidgetCore>(i)->SetToolTip(STR_BUILD_DEPOT_TRAM_ORIENTATION_SELECT_TOOLTIP);
      }
    }
 
    this->FinishInitNested(TransportType::Road);
  }
 
  void UpdateWidgetSize(WidgetID widget, Dimension &size, [[maybe_unused]] const Dimension &padding, [[maybe_unused]] Dimension &fill, [[maybe_unused]] Dimension &resize) override
  {
    if (!IsInsideMM(widget, WID_BROD_DEPOT_NE, WID_BROD_DEPOT_NW + 1)) return;
 
    size.width  = ScaleGUITrad(64) + WidgetDimensions::scaled.fullbevel.Horizontal();
    size.height = ScaleGUITrad(48) + WidgetDimensions::scaled.fullbevel.Vertical();
  }
 
  void DrawWidget(const Rect &r, WidgetID widget) const override
  {
    if (!IsInsideMM(widget, WID_BROD_DEPOT_NE, WID_BROD_DEPOT_NW + 1)) return;
 
    DrawPixelInfo tmp_dpi;
    Rect ir = r.Shrink(WidgetDimensions::scaled.bevel);
    if (FillDrawPixelInfo(&tmp_dpi, ir)) {
      AutoRestoreBackup dpi_backup(_cur_dpi, &tmp_dpi);
      int x = (ir.Width()  - ScaleSpriteTrad(64)) / 2 + ScaleSpriteTrad(31);
      int y = (ir.Height() + ScaleSpriteTrad(48)) / 2 - ScaleSpriteTrad(31);
      DrawRoadDepotSprite(x, y, static_cast<DiagDirection>(widget - WID_BROD_DEPOT_NE + to_underlying(DiagDirection::NE)), _cur_roadtype);
    }
  }
 
  void OnClick([[maybe_unused]] Point pt, WidgetID widget, [[maybe_unused]] int click_count) override
  {
    switch (widget) {
      case WID_BROD_DEPOT_NW:
      case WID_BROD_DEPOT_NE:
      case WID_BROD_DEPOT_SW:
      case WID_BROD_DEPOT_SE:
        this->RaiseWidget(WID_BROD_DEPOT_NE + _road_depot_orientation);
        _road_depot_orientation = (DiagDirection)(widget - WID_BROD_DEPOT_NE);
        this->LowerWidget(WID_BROD_DEPOT_NE + _road_depot_orientation);
        SndClickBeep();
        this->SetDirty();
        break;
 
      default:
        break;
    }
  }
};
 
static constexpr std::initializer_list<NWidgetPart> _nested_build_road_depot_widgets = {
  NWidget(NWID_HORIZONTAL),
    NWidget(WWT_CLOSEBOX, Colours::DarkGreen),
    NWidget(WWT_CAPTION, Colours::DarkGreen, WID_BROD_CAPTION), SetStringTip(STR_BUILD_DEPOT_ROAD_ORIENTATION_CAPTION, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
  EndContainer(),
  NWidget(WWT_PANEL, Colours::DarkGreen),
    NWidget(NWID_HORIZONTAL_LTR), SetPIP(0, WidgetDimensions::unscaled.hsep_normal, 0), SetPIPRatio(1, 0, 1), SetPadding(WidgetDimensions::unscaled.picker),
      NWidget(NWID_VERTICAL), SetPIP(0, WidgetDimensions::unscaled.vsep_normal, 0),
        NWidget(WWT_TEXTBTN, Colours::Grey, WID_BROD_DEPOT_NW), SetFill(0, 0), SetToolTip(STR_BUILD_DEPOT_ROAD_ORIENTATION_SELECT_TOOLTIP),
        NWidget(WWT_TEXTBTN, Colours::Grey, WID_BROD_DEPOT_SW), SetFill(0, 0), SetToolTip(STR_BUILD_DEPOT_ROAD_ORIENTATION_SELECT_TOOLTIP),
      EndContainer(),
      NWidget(NWID_VERTICAL), SetPIP(0, WidgetDimensions::unscaled.vsep_normal, 0),
        NWidget(WWT_TEXTBTN, Colours::Grey, WID_BROD_DEPOT_NE), SetFill(0, 0), SetToolTip(STR_BUILD_DEPOT_ROAD_ORIENTATION_SELECT_TOOLTIP),
        NWidget(WWT_TEXTBTN, Colours::Grey, WID_BROD_DEPOT_SE), SetFill(0, 0), SetToolTip(STR_BUILD_DEPOT_ROAD_ORIENTATION_SELECT_TOOLTIP),
      EndContainer(),
    EndContainer(),
  EndContainer(),
};

static WindowDesc _build_road_depot_desc(
  WindowPosition::Automatic, {}, 0, 0,
  WindowClass::BuildDepot, WindowClass::BuildToolbar,
  WindowDefaultFlag::Construction,
  _nested_build_road_depot_widgets
);
 
static void ShowRoadDepotPicker(Window *parent)
{
  new BuildRoadDepotWindow(_build_road_depot_desc, parent);
}
 
template <RoadStopType roadstoptype>
class RoadStopPickerCallbacks : public PickerCallbacksNewGRFClass<RoadStopClass> {
public:
  RoadStopPickerCallbacks(const std::string &ini_group) : PickerCallbacksNewGRFClass<RoadStopClass>(ini_group) {}
 
  GrfSpecFeature GetFeature() const override { return GrfSpecFeature::RoadStops; }
 
  StringID GetClassTooltip() const override;
  StringID GetTypeTooltip() const override;
  StringID GetCollectionTooltip() const override;
 
  bool IsActive() const override
  {
    for (const auto &cls : RoadStopClass::Classes()) {
      if (IsWaypointClass(cls)) continue;
      for (const auto *spec : cls.Specs()) {
        if (spec == nullptr) continue;
        if (roadstoptype == RoadStopType::Truck && spec->stop_type != ROADSTOPTYPE_FREIGHT && spec->stop_type != ROADSTOPTYPE_ALL) continue;
        if (roadstoptype == RoadStopType::Bus && spec->stop_type != ROADSTOPTYPE_PASSENGER && spec->stop_type != ROADSTOPTYPE_ALL) continue;
        return true;
      }
    }
    return false;
  }
 
  static bool IsClassChoice(const RoadStopClass &cls)
  {
    return !IsWaypointClass(cls) && GetIfClassHasNewStopsByType(&cls, roadstoptype, _cur_roadtype);
  }
 
  bool HasClassChoice() const override
  {
    return std::ranges::count_if(RoadStopClass::Classes(), IsClassChoice);
  }
 
  int GetSelectedClass() const override { return _roadstop_gui.sel_class.base(); }
  void SetSelectedClass(int id) const override { _roadstop_gui.sel_class = this->GetClassIndex(id); }
 
  StringID GetClassName(int id) const override
  {
    const auto *rsc = this->GetClass(id);
    if (!IsClassChoice(*rsc)) return INVALID_STRING_ID;
    return rsc->name;
  }
 
  int GetSelectedType() const override { return _roadstop_gui.sel_type; }
  void SetSelectedType(int id) const override { _roadstop_gui.sel_type = id; }
 
  StringID GetTypeName(int cls_id, int id) const override
  {
    const auto *spec = this->GetSpec(cls_id, id);
    if (!IsRoadStopEverAvailable(spec, roadstoptype == RoadStopType::Bus ? StationType::Bus : StationType::Truck)) return INVALID_STRING_ID;
    return (spec == nullptr) ? STR_STATION_CLASS_DFLT_ROADSTOP : spec->name;
  }
 
  std::span<const BadgeID> GetTypeBadges(int cls_id, int id) const override
  {
    const auto *spec = this->GetSpec(cls_id, id);
    if (!IsRoadStopEverAvailable(spec, roadstoptype == RoadStopType::Bus ? StationType::Bus : StationType::Truck)) return {};
    if (spec == nullptr) return {};
    return spec->badges;
  }
 
  bool IsTypeAvailable(int cls_id, int id) const override
  {
    const auto *spec = this->GetSpec(cls_id, id);
    return IsRoadStopAvailable(spec, roadstoptype == RoadStopType::Bus ? StationType::Bus : StationType::Truck);
  }
 
  void DrawType(int x, int y, int cls_id, int id) const override
  {
    const auto *spec = this->GetSpec(cls_id, id);
    if (spec == nullptr) {
      StationPickerDrawSprite(x, y, roadstoptype == RoadStopType::Bus ? StationType::Bus : StationType::Truck, INVALID_RAILTYPE, _cur_roadtype, to_underlying(_roadstop_gui.orientation));
    } else {
      DiagDirection orientation = _roadstop_gui.orientation;
      if (orientation < DiagDirection::End && spec->flags.Test(RoadStopSpecFlag::DriveThroughOnly)) orientation = DiagDirection::End;
      DrawRoadStopTile(x, y, _cur_roadtype, spec, roadstoptype == RoadStopType::Bus ? StationType::Bus : StationType::Truck, to_underlying(orientation));
    }
  }
 
  void FillUsedItems(std::set<PickerItem> &items) override
  {
    for (const Station *st : Station::Iterate()) {
      if (st->owner != _local_company) continue;
      if (roadstoptype == RoadStopType::Truck && !st->facilities.Test(StationFacility::TruckStop)) continue;
      if (roadstoptype == RoadStopType::Bus && !st->facilities.Test(StationFacility::BusStop)) continue;
      items.insert({GrfID{}, 0, ROADSTOP_CLASS_DFLT.base(), 0}); // We would need to scan the map to find out if default is used.
      for (const auto &sm : st->roadstop_speclist) {
        if (sm.spec == nullptr) continue;
        if (roadstoptype == RoadStopType::Truck && sm.spec->stop_type != ROADSTOPTYPE_FREIGHT && sm.spec->stop_type != ROADSTOPTYPE_ALL) continue;
        if (roadstoptype == RoadStopType::Bus && sm.spec->stop_type != ROADSTOPTYPE_PASSENGER && sm.spec->stop_type != ROADSTOPTYPE_ALL) continue;
        items.insert({sm.grfid, sm.localidx, sm.spec->class_index.base(), sm.spec->index});
      }
    }
  }
};
 
template <> StringID RoadStopPickerCallbacks<RoadStopType::Bus>::GetClassTooltip() const { return STR_PICKER_ROADSTOP_BUS_CLASS_TOOLTIP; }
template <> StringID RoadStopPickerCallbacks<RoadStopType::Bus>::GetTypeTooltip() const { return STR_PICKER_ROADSTOP_BUS_TYPE_TOOLTIP; }
template <> StringID RoadStopPickerCallbacks<RoadStopType::Bus>::GetCollectionTooltip() const { return STR_PICKER_ROADSTOP_BUS_COLLECTION_TOOLTIP; }
 
template <> StringID RoadStopPickerCallbacks<RoadStopType::Truck>::GetClassTooltip() const { return STR_PICKER_ROADSTOP_TRUCK_CLASS_TOOLTIP; }
template <> StringID RoadStopPickerCallbacks<RoadStopType::Truck>::GetTypeTooltip() const { return STR_PICKER_ROADSTOP_TRUCK_TYPE_TOOLTIP; }
template <> StringID RoadStopPickerCallbacks<RoadStopType::Truck>::GetCollectionTooltip() const { return STR_PICKER_ROADSTOP_TRUCK_COLLECTION_TOOLTIP; }
 
static RoadStopPickerCallbacks<RoadStopType::Bus> _bus_callback_instance("fav_passenger_roadstops");
static RoadStopPickerCallbacks<RoadStopType::Truck> _truck_callback_instance("fav_freight_roadstops");
 
static PickerCallbacks &GetRoadStopPickerCallbacks(RoadStopType rs)
{
  return rs == RoadStopType::Bus ? static_cast<PickerCallbacks &>(_bus_callback_instance) : static_cast<PickerCallbacks &>(_truck_callback_instance);
}
 
struct BuildRoadStationWindow : public PickerWindow {
private:
  uint coverage_height = 0; 
 
  void CheckOrientationValid()
  {
    const RoadStopSpec *spec = RoadStopClass::Get(_roadstop_gui.sel_class)->GetSpec(_roadstop_gui.sel_type);
 
    /* Raise and lower to ensure the correct widget is lowered after changing displayed orientation plane. */
    if (RoadTypeIsRoad(_cur_roadtype)) {
      this->RaiseWidget(WID_BROS_STATION_NE + _roadstop_gui.orientation);
      this->GetWidget<NWidgetStacked>(WID_BROS_AVAILABLE_ORIENTATIONS)->SetDisplayedPlane((spec != nullptr && spec->flags.Test(RoadStopSpecFlag::DriveThroughOnly)) ? 1 : 0);
      this->LowerWidget(WID_BROS_STATION_NE + _roadstop_gui.orientation);
    }
 
    if (_roadstop_gui.orientation >= DiagDirection::End) return;
 
    if (spec != nullptr && spec->flags.Test(RoadStopSpecFlag::DriveThroughOnly)) {
      this->RaiseWidget(WID_BROS_STATION_NE + _roadstop_gui.orientation);
      _roadstop_gui.orientation = DiagDirection::End;
      this->LowerWidget(WID_BROS_STATION_NE + _roadstop_gui.orientation);
      this->SetDirty();
      CloseWindowById(WindowClass::JoinStation, 0);
    }
  }
 
public:
  BuildRoadStationWindow(WindowDesc &desc, Window *parent, RoadStopType rs) : PickerWindow(desc, parent, TransportType::Road, GetRoadStopPickerCallbacks(rs))
  {
    this->coverage_height = 2 * GetCharacterHeight(FontSize::Normal) + WidgetDimensions::scaled.vsep_normal;
 
    /* Trams don't have non-drivethrough stations */
    if (RoadTypeIsTram(_cur_roadtype) && _roadstop_gui.orientation < DiagDirection::End) {
      _roadstop_gui.orientation = DiagDirection::End;
    }
    this->ConstructWindow();
 
    const RoadTypeInfo *rti = GetRoadTypeInfo(_cur_roadtype);
    this->GetWidget<NWidgetCore>(WID_BROS_CAPTION)->SetString(rti->strings.picker_title[rs]);
 
    for (WidgetID i = RoadTypeIsTram(_cur_roadtype) ? WID_BROS_STATION_X : WID_BROS_STATION_NE; i < WID_BROS_LT_OFF; i++) {
      this->GetWidget<NWidgetCore>(i)->SetToolTip(rti->strings.picker_tooltip[rs]);
    }
 
    this->LowerWidget(WID_BROS_STATION_NE + _roadstop_gui.orientation);
    this->LowerWidget(WID_BROS_LT_OFF + _settings_client.gui.station_show_coverage);
 
    this->window_class = (rs == RoadStopType::Bus) ? WindowClass::BuildBusStation : WindowClass::BuildTruckStation;
  }
 
  void Close([[maybe_unused]] int data = 0) override
  {
    CloseWindowById(WindowClass::JoinStation, 0);
    this->PickerWindow::Close();
  }
 
  void OnInvalidateData([[maybe_unused]] int data = 0, [[maybe_unused]] bool gui_scope = true) override
  {
    this->PickerWindow::OnInvalidateData(data, gui_scope);
 
    if (gui_scope) {
      this->CheckOrientationValid();
    }
  }
 
  void OnPaint() override
  {
    const RoadStopSpec *spec = RoadStopClass::Get(_roadstop_gui.sel_class)->GetSpec(_roadstop_gui.sel_type);
 
    this->DrawWidgets();
 
    int rad = _settings_game.station.modified_catchment ? ((this->window_class == WindowClass::BuildBusStation) ? CA_BUS : CA_TRUCK) : CA_UNMODIFIED;
    if (_settings_client.gui.station_show_coverage) {
      SetTileSelectBigSize(-rad, -rad, 2 * rad, 2 * rad);
    } else {
      SetTileSelectSize(1, 1);
    }
 
    if (this->IsShaded()) return;
 
    /* 'Accepts' and 'Supplies' texts. */
    StationCoverageType sct = (this->window_class == WindowClass::BuildBusStation) ? SCT_PASSENGERS_ONLY : SCT_NON_PASSENGERS_ONLY;
    Rect r = this->GetWidget<NWidgetBase>(WID_BROS_ACCEPTANCE)->GetCurrentRect();
    const int bottom = r.bottom;
    r.bottom = INT_MAX; // Allow overflow as we want to know the required height.
    if (spec != nullptr) r.top = DrawBadgeNameList(r, spec->badges, GrfSpecFeature::RoadStops);
    r.top = DrawStationCoverageAreaText(r, sct, rad, false) + WidgetDimensions::scaled.vsep_normal;
    r.top = DrawStationCoverageAreaText(r, sct, rad, true);
    /* Resize background if the window is too small.
     * Never make the window smaller to avoid oscillating if the size change affects the acceptance.
     * (This is the case, if making the window bigger moves the mouse into the window.) */
    if (r.top > bottom) {
      this->coverage_height += r.top - bottom;
      this->ReInit();
    }
  }
 
  void UpdateWidgetSize(WidgetID widget, Dimension &size, [[maybe_unused]] const Dimension &padding, [[maybe_unused]] Dimension &fill, [[maybe_unused]] Dimension &resize) override
  {
    switch (widget) {
      case WID_BROS_STATION_NE:
      case WID_BROS_STATION_SE:
      case WID_BROS_STATION_SW:
      case WID_BROS_STATION_NW:
      case WID_BROS_STATION_X:
      case WID_BROS_STATION_Y:
        size.width  = ScaleGUITrad(PREVIEW_WIDTH) + WidgetDimensions::scaled.fullbevel.Horizontal();
        size.height = ScaleGUITrad(PREVIEW_HEIGHT) + WidgetDimensions::scaled.fullbevel.Vertical();
        break;
 
      case WID_BROS_ACCEPTANCE:
        size.height = this->coverage_height;
        break;
 
      default:
        this->PickerWindow::UpdateWidgetSize(widget, size, padding, fill, resize);
        break;
    }
  }

  StationType GetRoadStationTypeByWindowClass(WindowClass window_class) const
  {
    switch (window_class) {
      case WindowClass::BuildBusStation: return StationType::Bus;
      case WindowClass::BuildTruckStation: return StationType::Truck;
      default: NOT_REACHED();
    }
  }
 
  void DrawWidget(const Rect &r, WidgetID widget) const override
  {
    switch (widget) {
      case WID_BROS_STATION_NE:
      case WID_BROS_STATION_SE:
      case WID_BROS_STATION_SW:
      case WID_BROS_STATION_NW:
      case WID_BROS_STATION_X:
      case WID_BROS_STATION_Y: {
        StationType st = GetRoadStationTypeByWindowClass(this->window_class);
        const RoadStopSpec *spec = RoadStopClass::Get(_roadstop_gui.sel_class)->GetSpec(_roadstop_gui.sel_type);
        DrawPixelInfo tmp_dpi;
        Rect ir = r.Shrink(WidgetDimensions::scaled.bevel);
        if (FillDrawPixelInfo(&tmp_dpi, ir)) {
          AutoRestoreBackup dpi_backup(_cur_dpi, &tmp_dpi);
          int x = (ir.Width()  - ScaleSpriteTrad(PREVIEW_WIDTH)) / 2 + ScaleSpriteTrad(PREVIEW_LEFT);
          int y = (ir.Height() + ScaleSpriteTrad(PREVIEW_HEIGHT)) / 2 - ScaleSpriteTrad(PREVIEW_BOTTOM);
          if (spec == nullptr) {
            StationPickerDrawSprite(x, y, st, INVALID_RAILTYPE, _cur_roadtype, widget - WID_BROS_STATION_NE);
          } else {
            DrawRoadStopTile(x, y, _cur_roadtype, spec, st, widget - WID_BROS_STATION_NE);
          }
        }
        break;
      }
 
      default:
        this->PickerWindow::DrawWidget(r, widget);
        break;
    }
  }
 
  void OnClick([[maybe_unused]] Point pt, WidgetID widget, [[maybe_unused]] int click_count) override
  {
    switch (widget) {
      case WID_BROS_STATION_NE:
      case WID_BROS_STATION_SE:
      case WID_BROS_STATION_SW:
      case WID_BROS_STATION_NW:
      case WID_BROS_STATION_X:
      case WID_BROS_STATION_Y:
        if (widget < WID_BROS_STATION_X) {
          const RoadStopSpec *spec = RoadStopClass::Get(_roadstop_gui.sel_class)->GetSpec(_roadstop_gui.sel_type);
          if (spec != nullptr && spec->flags.Test(RoadStopSpecFlag::DriveThroughOnly)) return;
        }
        this->RaiseWidget(WID_BROS_STATION_NE + _roadstop_gui.orientation);
        _roadstop_gui.orientation = (DiagDirection)(widget - WID_BROS_STATION_NE);
        this->LowerWidget(WID_BROS_STATION_NE + _roadstop_gui.orientation);
        SndClickBeep();
        this->SetDirty();
        CloseWindowById(WindowClass::JoinStation, 0);
        break;
 
      case WID_BROS_LT_OFF:
      case WID_BROS_LT_ON:
        this->RaiseWidget(_settings_client.gui.station_show_coverage + WID_BROS_LT_OFF);
        _settings_client.gui.station_show_coverage = (widget != WID_BROS_LT_OFF);
        this->LowerWidget(_settings_client.gui.station_show_coverage + WID_BROS_LT_OFF);
        SndClickBeep();
        this->SetDirty();
        SetViewportCatchmentStation(nullptr, true);
        break;
 
      default:
        this->PickerWindow::OnClick(pt, widget, click_count);
        break;
    }
  }
 
  void OnRealtimeTick([[maybe_unused]] uint delta_ms) override
  {
    CheckRedrawStationCoverage(this);
  }
 
  static inline HotkeyList road_hotkeys{"buildroadstop", {
    Hotkey('F', "focus_filter_box", PCWHK_FOCUS_FILTER_BOX),
  }};
 
  static inline HotkeyList tram_hotkeys{"buildtramstop", {
    Hotkey('F', "focus_filter_box", PCWHK_FOCUS_FILTER_BOX),
  }};
};

static constexpr std::initializer_list<NWidgetPart> _nested_road_station_picker_widgets = {
  NWidget(NWID_HORIZONTAL),
    NWidget(WWT_CLOSEBOX, Colours::DarkGreen),
    NWidget(WWT_CAPTION,  Colours::DarkGreen, WID_BROS_CAPTION),
    NWidget(WWT_SHADEBOX, Colours::DarkGreen),
    NWidget(WWT_DEFSIZEBOX, Colours::DarkGreen),
  EndContainer(),
  NWidget(NWID_HORIZONTAL),
    NWidget(NWID_VERTICAL),
      NWidgetFunction(MakePickerClassWidgets),
      NWidget(WWT_PANEL, Colours::DarkGreen),
        NWidget(NWID_VERTICAL), SetPIP(0, WidgetDimensions::unscaled.vsep_picker, 0), SetPadding(WidgetDimensions::unscaled.picker),
          NWidget(NWID_SELECTION, Colours::Invalid, WID_BROS_AVAILABLE_ORIENTATIONS),
            /* 6-orientation plane. */
            NWidget(NWID_VERTICAL), SetPIP(0, WidgetDimensions::unscaled.vsep_normal, 0),
              NWidget(NWID_HORIZONTAL), SetPIP(0, WidgetDimensions::unscaled.hsep_normal, 0), SetPIPRatio(1, 0, 1),
                NWidget(NWID_HORIZONTAL_LTR), SetPIP(0, WidgetDimensions::unscaled.hsep_normal, 0),
                  NWidget(WWT_PANEL, Colours::Grey, WID_BROS_STATION_NW), SetFill(0, 0), EndContainer(),
                  NWidget(WWT_PANEL, Colours::Grey, WID_BROS_STATION_NE), SetFill(0, 0), EndContainer(),
                EndContainer(),
                NWidget(WWT_PANEL, Colours::Grey, WID_BROS_STATION_X), SetFill(0, 0), EndContainer(),
              EndContainer(),
              NWidget(NWID_HORIZONTAL), SetPIP(0, WidgetDimensions::unscaled.hsep_normal, 0), SetPIPRatio(1, 0, 1),
                NWidget(NWID_HORIZONTAL_LTR), SetPIP(0, WidgetDimensions::unscaled.hsep_normal, 0),
                  NWidget(WWT_PANEL, Colours::Grey, WID_BROS_STATION_SW), SetFill(0, 0), EndContainer(),
                  NWidget(WWT_PANEL, Colours::Grey, WID_BROS_STATION_SE), SetFill(0, 0), EndContainer(),
                EndContainer(),
                NWidget(WWT_PANEL, Colours::Grey, WID_BROS_STATION_Y), SetFill(0, 0), EndContainer(),
              EndContainer(),
            EndContainer(),
            /* 2-orientation plane. */
            NWidget(NWID_VERTICAL), SetPIPRatio(0, 0, 1),
              NWidget(NWID_HORIZONTAL_LTR), SetPIP(0, WidgetDimensions::unscaled.hsep_normal, 0), SetPIPRatio(1, 0, 1),
                NWidget(WWT_PANEL, Colours::Grey, WID_BROS_STATION_X), SetFill(0, 0), EndContainer(),
                NWidget(WWT_PANEL, Colours::Grey, WID_BROS_STATION_Y), SetFill(0, 0), EndContainer(),
              EndContainer(),
            EndContainer(),
          EndContainer(),
          NWidget(WWT_LABEL, Colours::Invalid), SetStringTip(STR_STATION_BUILD_COVERAGE_AREA_TITLE), SetFill(1, 0),
          NWidget(NWID_HORIZONTAL), SetPIPRatio(1, 0, 1),
            NWidget(WWT_TEXTBTN, Colours::Grey, WID_BROS_LT_OFF), SetMinimalSize(60, 12),
                SetStringTip(STR_STATION_BUILD_COVERAGE_OFF, STR_STATION_BUILD_COVERAGE_AREA_OFF_TOOLTIP),
            NWidget(WWT_TEXTBTN, Colours::Grey, WID_BROS_LT_ON), SetMinimalSize(60, 12),
                SetStringTip(STR_STATION_BUILD_COVERAGE_ON, STR_STATION_BUILD_COVERAGE_AREA_ON_TOOLTIP),
          EndContainer(),
          NWidget(WWT_EMPTY, Colours::Invalid, WID_BROS_ACCEPTANCE), SetFill(1, 1), SetResize(1, 0), SetMinimalTextLines(2, 0),
        EndContainer(),
      EndContainer(),
    EndContainer(),
    NWidgetFunction(MakePickerTypeWidgets),
  EndContainer(),
};

static WindowDesc _road_station_picker_desc(
  WindowPosition::Automatic, "build_station_road", 0, 0,
  WindowClass::BuildBusStation, WindowClass::BuildToolbar,
  WindowDefaultFlag::Construction,
  _nested_road_station_picker_widgets,
  &BuildRoadStationWindow::road_hotkeys
);

static constexpr std::initializer_list<NWidgetPart> _nested_tram_station_picker_widgets = {
  NWidget(NWID_HORIZONTAL),
    NWidget(WWT_CLOSEBOX, Colours::DarkGreen),
    NWidget(WWT_CAPTION,  Colours::DarkGreen, WID_BROS_CAPTION),
    NWidget(WWT_SHADEBOX, Colours::DarkGreen),
    NWidget(WWT_DEFSIZEBOX, Colours::DarkGreen),
  EndContainer(),
  NWidget(NWID_HORIZONTAL),
    NWidget(NWID_VERTICAL),
      NWidgetFunction(MakePickerClassWidgets),
      NWidget(WWT_PANEL, Colours::DarkGreen),
        NWidget(NWID_VERTICAL), SetPIP(0, WidgetDimensions::unscaled.vsep_picker, 0), SetPadding(WidgetDimensions::unscaled.picker),
          NWidget(NWID_HORIZONTAL_LTR), SetPIP(0, WidgetDimensions::unscaled.hsep_normal, 0), SetPIPRatio(1, 0, 1),
            NWidget(WWT_PANEL, Colours::Grey, WID_BROS_STATION_X), SetFill(0, 0), EndContainer(),
            NWidget(WWT_PANEL, Colours::Grey, WID_BROS_STATION_Y), SetFill(0, 0), EndContainer(),
          EndContainer(),
          NWidget(WWT_LABEL, Colours::Invalid), SetStringTip(STR_STATION_BUILD_COVERAGE_AREA_TITLE), SetFill(1, 0),
          NWidget(NWID_HORIZONTAL), SetPIPRatio(1, 0, 1),
            NWidget(WWT_TEXTBTN, Colours::Grey, WID_BROS_LT_OFF), SetMinimalSize(60, 12),
                SetStringTip(STR_STATION_BUILD_COVERAGE_OFF, STR_STATION_BUILD_COVERAGE_AREA_OFF_TOOLTIP),
            NWidget(WWT_TEXTBTN, Colours::Grey, WID_BROS_LT_ON), SetMinimalSize(60, 12),
                SetStringTip(STR_STATION_BUILD_COVERAGE_ON, STR_STATION_BUILD_COVERAGE_AREA_ON_TOOLTIP),
          EndContainer(),
          NWidget(WWT_EMPTY, Colours::Invalid, WID_BROS_ACCEPTANCE), SetFill(1, 1), SetResize(1, 0), SetMinimalTextLines(2, 0),
        EndContainer(),
      EndContainer(),
    EndContainer(),
    NWidgetFunction(MakePickerTypeWidgets),
  EndContainer(),
};

static WindowDesc _tram_station_picker_desc(
  WindowPosition::Automatic, "build_station_tram", 0, 0,
  WindowClass::BuildBusStation, WindowClass::BuildToolbar,
  WindowDefaultFlag::Construction,
  _nested_tram_station_picker_widgets,
  &BuildRoadStationWindow::tram_hotkeys
);
 
static void ShowRVStationPicker(Window *parent, RoadStopType rs)
{
  new BuildRoadStationWindow(RoadTypeIsRoad(_cur_roadtype) ? _road_station_picker_desc : _tram_station_picker_desc, parent, rs);
}
 
class RoadWaypointPickerCallbacks : public PickerCallbacksNewGRFClass<RoadStopClass> {
public:
  RoadWaypointPickerCallbacks() : PickerCallbacksNewGRFClass<RoadStopClass>("fav_road_waypoints") {}
 
  GrfSpecFeature GetFeature() const override { return GrfSpecFeature::RoadStops; }
 
  StringID GetClassTooltip() const override { return STR_PICKER_WAYPOINT_CLASS_TOOLTIP; }
  StringID GetTypeTooltip() const override { return STR_PICKER_WAYPOINT_TYPE_TOOLTIP; }
  StringID GetCollectionTooltip() const override { return STR_PICKER_WAYPOINT_COLLECTION_TOOLTIP; }
 
  bool IsActive() const override
  {
    for (const auto &cls : RoadStopClass::Classes()) {
      if (!IsWaypointClass(cls)) continue;
      for (const auto *spec : cls.Specs()) {
        if (spec != nullptr) return true;
      }
    }
    return false;
  }
 
  bool HasClassChoice() const override
  {
    return std::ranges::count_if(RoadStopClass::Classes(), [](const auto &cls) { return IsWaypointClass(cls); }) > 1;
  }
 
  void Close(int) override { ResetObjectToPlace(); }
  int GetSelectedClass() const override { return _waypoint_gui.sel_class.base(); }
  void SetSelectedClass(int id) const override { _waypoint_gui.sel_class = this->GetClassIndex(id); }
 
  StringID GetClassName(int id) const override
  {
    const auto *sc = GetClass(id);
    if (!IsWaypointClass(*sc)) return INVALID_STRING_ID;
    return sc->name;
  }
 
  int GetSelectedType() const override { return _waypoint_gui.sel_type; }
  void SetSelectedType(int id) const override { _waypoint_gui.sel_type = id; }
 
  StringID GetTypeName(int cls_id, int id) const override
  {
    const auto *spec = this->GetSpec(cls_id, id);
    return (spec == nullptr) ? STR_STATION_CLASS_WAYP_WAYPOINT : spec->name;
  }
 
  std::span<const BadgeID> GetTypeBadges(int cls_id, int id) const override
  {
    const auto *spec = this->GetSpec(cls_id, id);
    if (spec == nullptr) return {};
    return spec->badges;
  }
 
  bool IsTypeAvailable(int cls_id, int id) const override
  {
    return IsRoadStopAvailable(this->GetSpec(cls_id, id), StationType::RoadWaypoint);
  }
 
  void DrawType(int x, int y, int cls_id, int id) const override
  {
    const auto *spec = this->GetSpec(cls_id, id);
    if (spec == nullptr) {
      StationPickerDrawSprite(x, y, StationType::RoadWaypoint, INVALID_RAILTYPE, _cur_roadtype, RSV_DRIVE_THROUGH_X);
    } else {
      DrawRoadStopTile(x, y, _cur_roadtype, spec, StationType::RoadWaypoint, RSV_DRIVE_THROUGH_X);
    }
  }
 
  void FillUsedItems(std::set<PickerItem> &items) override
  {
    for (const Waypoint *wp : Waypoint::Iterate()) {
      if (wp->owner != _local_company || !HasBit(wp->waypoint_flags, WPF_ROAD)) continue;
      items.insert({GrfID{}, 0, ROADSTOP_CLASS_WAYP.base(), 0}); // We would need to scan the map to find out if default is used.
      for (const auto &sm : wp->roadstop_speclist) {
        if (sm.spec == nullptr) continue;
        items.insert({sm.grfid, sm.localidx, sm.spec->class_index.base(), sm.spec->index});
      }
    }
  }
 
  static RoadWaypointPickerCallbacks instance;
};
/* static */ RoadWaypointPickerCallbacks RoadWaypointPickerCallbacks::instance;
 
struct BuildRoadWaypointWindow : public PickerWindow {
  BuildRoadWaypointWindow(WindowDesc &desc, Window *parent) : PickerWindow(desc, parent, TransportType::Road, RoadWaypointPickerCallbacks::instance)
  {
    this->ConstructWindow();
  }
 
  static inline HotkeyList hotkeys{"buildroadwaypoint", {
    Hotkey('F', "focus_filter_box", PCWHK_FOCUS_FILTER_BOX),
  }};
};

static constexpr std::initializer_list<NWidgetPart> _nested_build_road_waypoint_widgets = {
  NWidget(NWID_HORIZONTAL),
    NWidget(WWT_CLOSEBOX, Colours::DarkGreen),
    NWidget(WWT_CAPTION, Colours::DarkGreen), SetStringTip(STR_WAYPOINT_CAPTION, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
    NWidget(WWT_SHADEBOX, Colours::DarkGreen),
    NWidget(WWT_DEFSIZEBOX, Colours::DarkGreen),
  EndContainer(),
  NWidget(NWID_HORIZONTAL),
    NWidgetFunction(MakePickerClassWidgets),
    NWidgetFunction(MakePickerTypeWidgets),
  EndContainer(),
};

static WindowDesc _build_road_waypoint_desc(
  WindowPosition::Automatic, "build_road_waypoint", 0, 0,
  WindowClass::BuildWaypoint, WindowClass::BuildToolbar,
  WindowDefaultFlag::Construction,
  _nested_build_road_waypoint_widgets,
  &BuildRoadWaypointWindow::hotkeys
);
 
static void ShowBuildRoadWaypointPicker(Window *parent)
{
  if (!RoadWaypointPickerCallbacks::instance.IsActive()) return;
  new BuildRoadWaypointWindow(_build_road_waypoint_desc, parent);
}
 
void InitializeRoadGui()
{
  _road_depot_orientation = DiagDirection::NW;
  _roadstop_gui.orientation = DiagDirection::NW;
  _waypoint_gui.sel_class = ROADSTOP_CLASS_WAYP;
  _waypoint_gui.sel_type = 0;
}
 
DropDownList GetRoadTypeDropDownList(RoadTramTypes rtts, bool for_replacement, bool all_option)
{
  RoadTypes used_roadtypes;
  RoadTypes avail_roadtypes;
 
  const Company *c = Company::Get(_local_company);
 
  /* Find the used roadtypes. */
  if (for_replacement) {
    avail_roadtypes = GetCompanyRoadTypes(c->index, false);
    used_roadtypes  = GetRoadTypes(false);
  } else {
    avail_roadtypes = c->avail_roadtypes;
    used_roadtypes  = GetRoadTypes(true);
  }
 
  /* Filter listed road types */
  if (!rtts.Test(RoadTramType::Road)) used_roadtypes.Reset(GetMaskForRoadTramType(RoadTramType::Road));
  if (!rtts.Test(RoadTramType::Tram)) used_roadtypes.Reset(GetMaskForRoadTramType(RoadTramType::Tram));
 
  DropDownList list;
 
  if (all_option) {
    list.push_back(MakeDropDownListStringItem(STR_REPLACE_ALL_ROADTYPE, INVALID_ROADTYPE));
  }
 
  Dimension d = { 0, 0 };
  /* Get largest icon size, to ensure text is aligned on each menu item. */
  if (!for_replacement) {
    used_roadtypes.Reset(_roadtypes_hidden_mask);
    for (const auto &rt : _sorted_roadtypes) {
      if (!used_roadtypes.Test(rt)) continue;
      const RoadTypeInfo *rti = GetRoadTypeInfo(rt);
      d = maxdim(d, GetSpriteSize(rti->gui_sprites.build_x_road));
    }
  }
 
  /* Shared list so that each item can take ownership. */
  auto badge_class_list = std::make_shared<GUIBadgeClasses>(GrfSpecFeature::RoadTypes);
 
  for (const auto &rt : _sorted_roadtypes) {
    /* If it's not used ever, don't show it to the user. */
    if (!used_roadtypes.Test(rt)) continue;
 
    const RoadTypeInfo *rti = GetRoadTypeInfo(rt);
 
    if (for_replacement) {
      list.push_back(MakeDropDownListBadgeItem(badge_class_list, rti->badges, GrfSpecFeature::RoadTypes, rti->introduction_date, GetString(rti->strings.replace_text), rt, !avail_roadtypes.Test(rt)));
    } else {
      std::string str = rti->max_speed > 0
        ? GetString(STR_TOOLBAR_ROADTYPE_VELOCITY, rti->strings.menu_text, rti->max_speed / 2)
        : GetString(rti->strings.menu_text);
      list.push_back(MakeDropDownListBadgeIconItem(badge_class_list, rti->badges, GrfSpecFeature::RoadTypes, rti->introduction_date, RoadBuildCost(rt), d, rti->gui_sprites.build_x_road, PAL_NONE, std::move(str), rt, !avail_roadtypes.Test(rt)));
    }
  }
 
  if (list.empty()) {
    /* Empty dropdowns are not allowed */
    list.push_back(MakeDropDownListStringItem(STR_NONE, INVALID_ROADTYPE, true));
  }
 
  return list;
}
 
DropDownList GetScenRoadTypeDropDownList(RoadTramTypes rtts)
{
  RoadTypes avail_roadtypes = GetRoadTypes(false);
  avail_roadtypes = AddDateIntroducedRoadTypes(avail_roadtypes, TimerGameCalendar::date);
  RoadTypes used_roadtypes = GetRoadTypes(true);
 
  /* Filter listed road types */
  used_roadtypes.Reset(_roadtypes_hidden_mask);
  if (!rtts.Test(RoadTramType::Road)) used_roadtypes.Reset(GetMaskForRoadTramType(RoadTramType::Road));
  if (!rtts.Test(RoadTramType::Tram)) used_roadtypes.Reset(GetMaskForRoadTramType(RoadTramType::Tram));
 
  DropDownList list;
 
  /* If it's not used ever, don't show it to the user. */
  Dimension d = { 0, 0 };
  for (const auto &rt : _sorted_roadtypes) {
    if (!used_roadtypes.Test(rt)) continue;
    const RoadTypeInfo *rti = GetRoadTypeInfo(rt);
    d = maxdim(d, GetSpriteSize(rti->gui_sprites.build_x_road));
  }
 
  /* Shared list so that each item can take ownership. */
  auto badge_class_list = std::make_shared<GUIBadgeClasses>(GrfSpecFeature::RoadTypes);
 
  for (const auto &rt : _sorted_roadtypes) {
    if (!used_roadtypes.Test(rt)) continue;
 
    const RoadTypeInfo *rti = GetRoadTypeInfo(rt);
 
    std::string str = rti->max_speed > 0
      ? GetString(STR_TOOLBAR_ROADTYPE_VELOCITY, rti->strings.menu_text, rti->max_speed / 2)
      : GetString(rti->strings.menu_text);
    list.push_back(MakeDropDownListBadgeIconItem(badge_class_list, rti->badges, GrfSpecFeature::RoadTypes, rti->introduction_date, RoadBuildCost(rt), d, rti->gui_sprites.build_x_road, PAL_NONE, std::move(str), rt, !avail_roadtypes.Test(rt)));
  }
 
  if (list.empty()) {
    /* Empty dropdowns are not allowed */
    list.push_back(MakeDropDownListStringItem(STR_NONE, -1, true));
  }
 
  return list;
}

static RoadType GetDefaultRoadType(RoadTramType rtt)
{
  const auto find_available = [rtt]<typename It>(It begin, It end) {
    const RoadTypes mask = GetMaskForRoadTramType(rtt);
    auto it = std::find_if(begin, end, [&](RoadType r) {
      return HasRoadTypeAvail(_local_company, r) && mask.Test(r);
    });
    return it != end ? *it : ROADTYPE_BEGIN;
  };
 
  switch (_settings_client.gui.default_rail_road_type) {
    case DefaultRailRoadType::MostUsed: {
      const Company *c = Company::Get(_local_company);
      std::array<uint, ROADTYPE_END> count{};
      for (RoadType rt : GetMaskForRoadTramType(rtt)) {
        count[rt] = c->infrastructure.road[rt];
      }
      auto best = static_cast<RoadType>(std::distance(std::begin(count), std::ranges::max_element(count)));
      if (c->infrastructure.road[best] > 0) return best;
 
      /* No tile of this kind has been built yet, fall through to first available. */
      [[fallthrough]];
    }
    case DefaultRailRoadType::FirstAvailable:
      return find_available(_sorted_roadtypes.begin(), _sorted_roadtypes.end());
    case DefaultRailRoadType::LastAvailable:
      return find_available(_sorted_roadtypes.rbegin(), _sorted_roadtypes.rend());
    default:
      NOT_REACHED();
  }
}

void SetDefaultRoadGui()
{
  if (_local_company == COMPANY_SPECTATOR || !Company::IsValidID(_local_company)) return;
 
  _last_built_roadtype = GetDefaultRoadType(RoadTramType::Road);
  _last_built_tramtype = GetDefaultRoadType(RoadTramType::Tram);
}