fios_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 "saveload/saveload_func.h"
#include "error.h"
#include "gui.h"
#include "gfx_func.h"
#include "command_func.h"
#include "network/network.h"
#include "network/network_content.h"
#include "strings_func.h"
#include "string_func.h"
#include "fileio_func.h"
#include "fios.h"
#include "window_func.h"
#include "tilehighlight_func.h"
#include "querystring_gui.h"
#include "engine_func.h"
#include "landscape_type.h"
#include "genworld.h"
#include "timer/timer_game_calendar.h"
#include "core/geometry_func.hpp"
#include "gamelog.h"
#include "stringfilter_type.h"
#include "misc_cmd.h"
#include "gamelog_internal.h"
 
#include "widgets/fios_widget.h"
 
#include "table/sprites.h"
#include "table/strings.h"
 
#include "safeguards.h"
 
LoadCheckData _load_check_data;    
 
static bool _fios_path_changed;
static bool _savegame_sort_dirty;

enum class SavegameSorter : uint8_t {
  Date, 
  Name, 
};
 
static SavegameSorter _savegame_sorter = SavegameSorter::Date; 
static bool _savegame_sorter_ascending = false; 

bool FiosItemSorter(const FiosItem &a, const FiosItem &b)
{
  switch (_savegame_sorter) {
    case SavegameSorter::Date:
      return _savegame_sorter_ascending ? FiosItemModificationDateSorter(a, b) : FiosItemModificationDateSorter(b, a);
    case SavegameSorter::Name:
      return _savegame_sorter_ascending ? FiosItemNameSorter(a, b) : FiosItemNameSorter(b, a);
    default:
      NOT_REACHED();
  }
}

void LoadCheckData::Clear()
{
  this->checkable = false;
  this->error = INVALID_STRING_ID;
  this->error_msg.clear();
 
  this->map_size_x = this->map_size_y = 256; // Default for old savegames which do not store mapsize.
  this->current_date = CalendarTime::MIN_DATE;
  this->landscape = {};
  this->starting_year = {};
 
  companies.clear();
 
  this->gamelog.Reset();
 
  ClearGRFConfigList(this->grfconfig);
}

static constexpr std::initializer_list<NWidgetPart> _nested_load_dialog_widgets = {
  NWidget(NWID_HORIZONTAL),
    NWidget(WWT_CLOSEBOX, Colours::Grey),
    NWidget(WWT_CAPTION, Colours::Grey, WID_SL_CAPTION),
    NWidget(WWT_DEFSIZEBOX, Colours::Grey),
  EndContainer(),
  /* Current directory and free space */
  NWidget(WWT_PANEL, Colours::Grey, WID_SL_BACKGROUND), SetFill(1, 0), SetResize(1, 0),
  EndContainer(),
 
  NWidget(NWID_HORIZONTAL, NWidContainerFlag::EqualSize),
    /* Left side : filter box and available files */
    NWidget(NWID_VERTICAL),
      /* Filter box with label */
      NWidget(WWT_PANEL, Colours::Grey), SetFill(1, 1), SetResize(1, 1),
        NWidget(NWID_HORIZONTAL), SetPadding(WidgetDimensions::unscaled.framerect.top, 0, WidgetDimensions::unscaled.framerect.bottom, 0),
            SetPIP(WidgetDimensions::unscaled.frametext.left, WidgetDimensions::unscaled.frametext.right, 0),
          NWidget(WWT_TEXT, Colours::Invalid), SetFill(0, 1), SetStringTip(STR_SAVELOAD_FILTER_TITLE),
          NWidget(WWT_EDITBOX, Colours::Grey, WID_SL_FILTER), SetFill(1, 0), SetResize(1, 0),
              SetStringTip(STR_LIST_FILTER_OSKTITLE, STR_LIST_FILTER_TOOLTIP),
        EndContainer(),
      EndContainer(),
      /* Sort buttons */
      NWidget(NWID_HORIZONTAL),
        NWidget(NWID_HORIZONTAL, NWidContainerFlag::EqualSize),
          NWidget(WWT_PUSHTXTBTN, Colours::Grey, WID_SL_SORT_BYNAME), SetStringTip(STR_SORT_BY_CAPTION_NAME, STR_TOOLTIP_SORT_ORDER), SetFill(1, 0), SetResize(1, 0),
          NWidget(WWT_PUSHTXTBTN, Colours::Grey, WID_SL_SORT_BYDATE), SetStringTip(STR_SORT_BY_CAPTION_DATE, STR_TOOLTIP_SORT_ORDER), SetFill(1, 0), SetResize(1, 0),
        EndContainer(),
        NWidget(WWT_PUSHIMGBTN, Colours::Grey, WID_SL_HOME_BUTTON), SetAspect(1), SetSpriteTip(SPR_HOUSE_ICON, STR_SAVELOAD_HOME_BUTTON_TOOLTIP),
      EndContainer(),
      /* Files */
      NWidget(NWID_HORIZONTAL),
        NWidget(WWT_PANEL, Colours::Grey, WID_SL_FILE_BACKGROUND),
          NWidget(WWT_INSET, Colours::Grey, WID_SL_DRIVES_DIRECTORIES_LIST), SetFill(1, 1), SetPadding(2, 2, 2, 2),
              SetToolTip(STR_SAVELOAD_LIST_TOOLTIP), SetResize(1, 10), SetScrollbar(WID_SL_SCROLLBAR),
          EndContainer(),
        EndContainer(),
        NWidget(NWID_VSCROLLBAR, Colours::Grey, WID_SL_SCROLLBAR),
      EndContainer(),
      /* Online Content button */
      NWidget(NWID_SELECTION, Colours::Invalid, WID_SL_CONTENT_DOWNLOAD_SEL),
        NWidget(WWT_PUSHTXTBTN, Colours::Grey, WID_SL_CONTENT_DOWNLOAD), SetResize(1, 0),
            SetStringTip(STR_INTRO_ONLINE_CONTENT, STR_INTRO_TOOLTIP_ONLINE_CONTENT),
      EndContainer(),
    EndContainer(),
 
    /* Right side : game details */
    NWidget(NWID_VERTICAL),
      NWidget(WWT_PANEL, Colours::Grey, WID_SL_DETAILS), SetResize(1, 1), SetFill(1, 1),
      EndContainer(),
      NWidget(WWT_PUSHTXTBTN, Colours::Grey, WID_SL_MISSING_NEWGRFS), SetStringTip(STR_NEWGRF_SETTINGS_FIND_MISSING_CONTENT_BUTTON, STR_NEWGRF_SETTINGS_FIND_MISSING_CONTENT_TOOLTIP), SetFill(1, 0), SetResize(1, 0),
      NWidget(NWID_HORIZONTAL),
        NWidget(NWID_HORIZONTAL, NWidContainerFlag::EqualSize),
          NWidget(WWT_PUSHTXTBTN, Colours::Grey, WID_SL_NEWGRF_INFO), SetStringTip(STR_MAPGEN_NEWGRF_SETTINGS, STR_MAPGEN_NEWGRF_SETTINGS_TOOLTIP), SetFill(1, 0), SetResize(1, 0),
          NWidget(WWT_PUSHTXTBTN, Colours::Grey, WID_SL_LOAD_BUTTON), SetStringTip(STR_SAVELOAD_LOAD_BUTTON, STR_SAVELOAD_LOAD_TOOLTIP), SetFill(1, 0), SetResize(1, 0),
        EndContainer(),
        NWidget(WWT_RESIZEBOX, Colours::Grey),
      EndContainer(),
    EndContainer(),
  EndContainer(),
};

static constexpr std::initializer_list<NWidgetPart> _nested_load_heightmap_dialog_widgets = {
  NWidget(NWID_HORIZONTAL),
    NWidget(WWT_CLOSEBOX, Colours::Grey),
    NWidget(WWT_CAPTION, Colours::Grey, WID_SL_CAPTION),
    NWidget(WWT_DEFSIZEBOX, Colours::Grey),
  EndContainer(),
  /* Current directory and free space */
  NWidget(WWT_PANEL, Colours::Grey, WID_SL_BACKGROUND), SetFill(1, 0), SetResize(1, 0),
  EndContainer(),
 
  /* Filter box with label */
  NWidget(WWT_PANEL, Colours::Grey), SetFill(1, 1), SetResize(1, 1),
    NWidget(NWID_HORIZONTAL), SetPadding(WidgetDimensions::unscaled.framerect.top, 0, WidgetDimensions::unscaled.framerect.bottom, 0),
        SetPIP(WidgetDimensions::unscaled.frametext.left, WidgetDimensions::unscaled.frametext.right, 0),
      NWidget(WWT_TEXT, Colours::Invalid), SetFill(0, 1), SetStringTip(STR_SAVELOAD_FILTER_TITLE),
      NWidget(WWT_EDITBOX, Colours::Grey, WID_SL_FILTER), SetFill(1, 0), SetResize(1, 0),
          SetStringTip(STR_LIST_FILTER_OSKTITLE, STR_LIST_FILTER_TOOLTIP),
    EndContainer(),
  EndContainer(),
  /* Sort Buttons */
  NWidget(NWID_HORIZONTAL),
    NWidget(NWID_HORIZONTAL, NWidContainerFlag::EqualSize),
      NWidget(WWT_PUSHTXTBTN, Colours::Grey, WID_SL_SORT_BYNAME), SetStringTip(STR_SORT_BY_CAPTION_NAME, STR_TOOLTIP_SORT_ORDER), SetFill(1, 0), SetResize(1, 0),
      NWidget(WWT_PUSHTXTBTN, Colours::Grey, WID_SL_SORT_BYDATE), SetStringTip(STR_SORT_BY_CAPTION_DATE, STR_TOOLTIP_SORT_ORDER), SetFill(1, 0), SetResize(1, 0),
    EndContainer(),
    NWidget(WWT_PUSHIMGBTN, Colours::Grey, WID_SL_HOME_BUTTON), SetAspect(1), SetSpriteTip(SPR_HOUSE_ICON, STR_SAVELOAD_HOME_BUTTON_TOOLTIP),
  EndContainer(),
  /* Files */
  NWidget(NWID_HORIZONTAL),
    NWidget(WWT_PANEL, Colours::Grey, WID_SL_FILE_BACKGROUND),
      NWidget(WWT_INSET, Colours::Grey, WID_SL_DRIVES_DIRECTORIES_LIST), SetFill(1, 1), SetPadding(2, 2, 2, 2),
          SetToolTip(STR_SAVELOAD_LIST_TOOLTIP), SetResize(1, 10), SetScrollbar(WID_SL_SCROLLBAR),
      EndContainer(),
    EndContainer(),
    NWidget(NWID_VSCROLLBAR, Colours::Grey, WID_SL_SCROLLBAR),
  EndContainer(),
  /* Online Content and Load button */
  NWidget(NWID_HORIZONTAL, NWidContainerFlag::EqualSize),
    NWidget(WWT_PUSHTXTBTN, Colours::Grey, WID_SL_CONTENT_DOWNLOAD), SetResize(1, 0), SetFill(1, 0),
        SetStringTip(STR_INTRO_ONLINE_CONTENT, STR_INTRO_TOOLTIP_ONLINE_CONTENT),
    NWidget(WWT_PUSHTXTBTN, Colours::Grey, WID_SL_LOAD_BUTTON), SetResize(1, 0), SetFill(1, 0),
        SetStringTip(STR_SAVELOAD_LOAD_BUTTON, STR_SAVELOAD_LOAD_HEIGHTMAP_TOOLTIP),
    NWidget(WWT_RESIZEBOX, Colours::Grey),
  EndContainer(),
};

static constexpr std::initializer_list<NWidgetPart> _nested_load_town_data_dialog_widgets = {
  NWidget(NWID_HORIZONTAL),
    NWidget(WWT_CLOSEBOX, Colours::Grey),
    NWidget(WWT_CAPTION, Colours::Grey, WID_SL_CAPTION),
    NWidget(WWT_DEFSIZEBOX, Colours::Grey),
  EndContainer(),
  /* Current directory and free space */
  NWidget(WWT_PANEL, Colours::Grey, WID_SL_BACKGROUND), SetFill(1, 0), SetResize(1, 0), EndContainer(),
 
  /* Filter box with label */
  NWidget(WWT_PANEL, Colours::Grey), SetFill(1, 1), SetResize(1, 1),
    NWidget(NWID_HORIZONTAL), SetPadding(WidgetDimensions::unscaled.framerect.top, 0, WidgetDimensions::unscaled.framerect.bottom, 0),
        SetPIP(WidgetDimensions::unscaled.frametext.left, WidgetDimensions::unscaled.frametext.right, 0),
      NWidget(WWT_TEXT, Colours::Invalid), SetFill(0, 1), SetStringTip(STR_SAVELOAD_FILTER_TITLE),
      NWidget(WWT_EDITBOX, Colours::Grey, WID_SL_FILTER), SetFill(1, 0), SetResize(1, 0), SetStringTip(STR_LIST_FILTER_OSKTITLE, STR_LIST_FILTER_TOOLTIP),
    EndContainer(),
  EndContainer(),
  /* Sort Buttons */
  NWidget(NWID_HORIZONTAL),
    NWidget(NWID_HORIZONTAL, NWidContainerFlag::EqualSize),
      NWidget(WWT_PUSHTXTBTN, Colours::Grey, WID_SL_SORT_BYNAME), SetStringTip(STR_SORT_BY_CAPTION_NAME, STR_TOOLTIP_SORT_ORDER), SetFill(1, 0), SetResize(1, 0),
      NWidget(WWT_PUSHTXTBTN, Colours::Grey, WID_SL_SORT_BYDATE), SetStringTip(STR_SORT_BY_CAPTION_DATE, STR_TOOLTIP_SORT_ORDER), SetFill(1, 0), SetResize(1, 0),
    EndContainer(),
    NWidget(WWT_PUSHIMGBTN, Colours::Grey, WID_SL_HOME_BUTTON), SetAspect(1), SetSpriteTip(SPR_HOUSE_ICON, STR_SAVELOAD_HOME_BUTTON_TOOLTIP),
  EndContainer(),
  /* Files */
  NWidget(NWID_HORIZONTAL),
    NWidget(WWT_PANEL, Colours::Grey, WID_SL_FILE_BACKGROUND),
      NWidget(WWT_INSET, Colours::Grey, WID_SL_DRIVES_DIRECTORIES_LIST), SetFill(1, 1), SetPadding(2, 2, 2, 2),
          SetToolTip(STR_SAVELOAD_LIST_TOOLTIP), SetResize(1, 10), SetScrollbar(WID_SL_SCROLLBAR), EndContainer(),
    EndContainer(),
    NWidget(NWID_VSCROLLBAR, Colours::Grey, WID_SL_SCROLLBAR),
  EndContainer(),
  /* Load button */
  NWidget(NWID_HORIZONTAL, NWidContainerFlag::EqualSize),
    NWidget(WWT_PUSHTXTBTN, Colours::Grey, WID_SL_LOAD_BUTTON), SetResize(1, 0), SetFill(1, 0),
        SetStringTip(STR_SAVELOAD_LOAD_BUTTON, STR_SAVELOAD_LOAD_TOWN_DATA_TOOLTIP),
    NWidget(WWT_RESIZEBOX, Colours::Grey),
  EndContainer(),
};

static constexpr std::initializer_list<NWidgetPart> _nested_save_dialog_widgets = {
  NWidget(NWID_HORIZONTAL),
    NWidget(WWT_CLOSEBOX, Colours::Grey),
    NWidget(WWT_CAPTION, Colours::Grey, WID_SL_CAPTION),
    NWidget(WWT_DEFSIZEBOX, Colours::Grey),
  EndContainer(),
  /* Current directory and free space */
  NWidget(WWT_PANEL, Colours::Grey, WID_SL_BACKGROUND), SetFill(1, 0), SetResize(1, 0),
  EndContainer(),
 
  NWidget(NWID_HORIZONTAL, NWidContainerFlag::EqualSize),
    /* Left side : filter box and available files */
    NWidget(NWID_VERTICAL),
      /* Filter box with label */
      NWidget(WWT_PANEL, Colours::Grey), SetFill(1, 1), SetResize(1, 1),
        NWidget(NWID_HORIZONTAL), SetPadding(WidgetDimensions::unscaled.framerect.top, 0, WidgetDimensions::unscaled.framerect.bottom, 0),
            SetPIP(WidgetDimensions::unscaled.frametext.left, WidgetDimensions::unscaled.frametext.right, 0),
          NWidget(WWT_TEXT, Colours::Invalid), SetFill(0, 1), SetStringTip(STR_SAVELOAD_FILTER_TITLE),
          NWidget(WWT_EDITBOX, Colours::Grey, WID_SL_FILTER), SetFill(1, 0), SetResize(1, 0),
              SetStringTip(STR_LIST_FILTER_OSKTITLE, STR_LIST_FILTER_TOOLTIP),
        EndContainer(),
      EndContainer(),
      /* Sort buttons */
      NWidget(NWID_HORIZONTAL),
        NWidget(NWID_HORIZONTAL, NWidContainerFlag::EqualSize),
          NWidget(WWT_PUSHTXTBTN, Colours::Grey, WID_SL_SORT_BYNAME), SetStringTip(STR_SORT_BY_CAPTION_NAME, STR_TOOLTIP_SORT_ORDER), SetFill(1, 0), SetResize(1, 0),
          NWidget(WWT_PUSHTXTBTN, Colours::Grey, WID_SL_SORT_BYDATE), SetStringTip(STR_SORT_BY_CAPTION_DATE, STR_TOOLTIP_SORT_ORDER), SetFill(1, 0), SetResize(1, 0),
        EndContainer(),
        NWidget(WWT_PUSHIMGBTN, Colours::Grey, WID_SL_HOME_BUTTON), SetAspect(1), SetSpriteTip(SPR_HOUSE_ICON, STR_SAVELOAD_HOME_BUTTON_TOOLTIP),
      EndContainer(),
      /* Files */
      NWidget(NWID_HORIZONTAL),
        NWidget(WWT_PANEL, Colours::Grey, WID_SL_FILE_BACKGROUND),
          NWidget(WWT_INSET, Colours::Grey, WID_SL_DRIVES_DIRECTORIES_LIST), SetPadding(2, 2, 2, 2),
              SetToolTip(STR_SAVELOAD_LIST_TOOLTIP), SetResize(1, 10), SetScrollbar(WID_SL_SCROLLBAR),
          EndContainer(),
        EndContainer(),
        NWidget(NWID_VSCROLLBAR, Colours::Grey, WID_SL_SCROLLBAR),
      EndContainer(),
      NWidget(WWT_PANEL, Colours::Grey),
        NWidget(WWT_EDITBOX, Colours::Grey, WID_SL_SAVE_OSK_TITLE), SetPadding(2, 2, 2, 2), SetFill(1, 0), SetResize(1, 0),
            SetStringTip(STR_SAVELOAD_OSKTITLE, STR_SAVELOAD_EDITBOX_TOOLTIP),
      EndContainer(),
      /* New directory/delete/save buttons */
      NWidget(NWID_HORIZONTAL, NWidContainerFlag::EqualSize),
        NWidget(WWT_PUSHTXTBTN, Colours::Grey, WID_SL_NEW_DIRECTORY), SetStringTip(STR_SAVELOAD_NEW_DIRECTORY_BUTTON, STR_SAVELOAD_NEW_DIRECTORY_TOOLTIP), SetFill(1, 0), SetResize(1, 0),
        NWidget(WWT_PUSHTXTBTN, Colours::Grey, WID_SL_DELETE_SELECTION), SetStringTip(STR_SAVELOAD_DELETE_BUTTON, STR_SAVELOAD_DELETE_TOOLTIP), SetFill(1, 0), SetResize(1, 0),
        NWidget(WWT_PUSHTXTBTN, Colours::Grey, WID_SL_SAVE_GAME),        SetStringTip(STR_SAVELOAD_SAVE_BUTTON, STR_SAVELOAD_SAVE_TOOLTIP),     SetFill(1, 0), SetResize(1, 0),
      EndContainer(),
    EndContainer(),
 
    /* Right side : game details */
    NWidget(NWID_VERTICAL),
      NWidget(WWT_PANEL, Colours::Grey, WID_SL_DETAILS), SetResize(1, 1), SetFill(1, 1),
      EndContainer(),
      NWidget(NWID_HORIZONTAL),
        NWidget(WWT_PANEL, Colours::Grey), SetResize(1, 0), SetFill(1, 1),
        EndContainer(),
        NWidget(WWT_RESIZEBOX, Colours::Grey),
      EndContainer(),
    EndContainer(),
  EndContainer(),
};

static const EnumIndexArray<ExtendedTextColour, DetailedFileType, DetailedFileType::End> _fios_colours = {
  TextColour::LightBrown, // DetailedFileType::OldGameFile
  TextColour::Orange, // DetailedFileType::GameFile
  TextColour::Yellow, // DetailedFileType::HeightmapBmp
  TextColour::Orange, // DetailedFileType::HeightmapPng
  TextColour::LightBrown, // DetailedFileType::TownDataJson
  TextColour::LightBlue, // DetailedFileType::FiosDrive
  TextColour::DarkGreen, // DetailedFileType::FiosParent
  TextColour::DarkGreen, // DetailedFileType::FiosDirectory
  TextColour::Orange, // DetailedFileType::FiosDirect
};

static void SortSaveGameList(FileList &file_list)
{
  size_t sort_start = 0;
  size_t sort_end = 0;
 
  /* Directories are always above the files (FIOS_TYPE_DIR)
   * Drives (A:\ (windows only) are always under the files (FIOS_TYPE_DRIVE)
   * Only sort savegames/scenarios, not directories
   */
  for (const auto &item : file_list) {
    switch (item.type.detailed) {
      case DetailedFileType::FiosDirectory: sort_start++; break;
      case DetailedFileType::FiosParent: sort_start++; break;
      case DetailedFileType::FiosDrive: sort_end++; break;
      default: break;
    }
  }
 
  std::sort(file_list.begin() + sort_start, file_list.end() - sort_end, FiosItemSorter);
}
 
struct SaveLoadWindow : public Window {
private:
  static const uint EDITBOX_MAX_SIZE   =  50;
  static const uint MAX_DIRECTORY_NAME_CHARS = 64; 
 
  QueryString filename_editbox; 
  AbstractFileType abstract_filetype{}; 
  SaveLoadOperation fop{}; 
  FileList fios_items{}; 
  FiosItem o_dir{}; 
  const FiosItem *selected = nullptr; 
  const FiosItem *highlighted = nullptr; 
  Scrollbar *vscroll = nullptr;
 
  StringFilter string_filter{}; 
  QueryString filter_editbox; 
  std::vector<FiosItem *> display_list{}; 
 
  static void SaveGameConfirmationCallback(Window *, bool confirmed)
  {
    /* File name has already been written to _file_to_saveload */
    if (confirmed) _switch_mode = SwitchMode::SaveGame;
  }
 
  static void SaveHeightmapConfirmationCallback(Window *, bool confirmed)
  {
    /* File name has already been written to _file_to_saveload */
    if (confirmed) _switch_mode = SwitchMode::SaveHeightmap;
  }
 
  static void DeleteFileConfirmationCallback(Window *window, bool confirmed)
  {
    auto *save_load_window = static_cast<SaveLoadWindow*>(window);
 
    assert(save_load_window->selected != nullptr);
 
    if (confirmed) {
      if (!FioRemove(save_load_window->selected->name)) {
        ShowErrorMessage(GetEncodedString(STR_ERROR_UNABLE_TO_DELETE_FILE), {}, WarningLevel::Error);
      } else {
        save_load_window->InvalidateData(SLIWD_RESCAN_FILES);
        /* Reset file name to current date on successful delete */
        if (save_load_window->abstract_filetype == AbstractFileType::Savegame) save_load_window->GenerateFileName();
      }
    }
  }

  static std::optional<StringID> GetDirectoryNameError(const std::string &name)
  {
    assert(!name.empty());
 
    /* Reject path and drive separators, which would turn the name into a path. */
    if (name.find_first_of("/\\:") != std::string::npos) return STR_ERROR_DIRECTORY_ILLEGAL_NAME;
    /* Reject a leading dot. This covers the current and parent directory entries and hidden names the list would never show. */
    if (name.front() == '.') return STR_ERROR_DIRECTORY_LEADING_DOT;
 
    return std::nullopt;
  }

  void ShowNewDirectoryQuery(std::string_view initial_name = {})
  {
    /* An unchanged name would otherwise be treated as cancel, so the AcceptUnchanged flag lets the pre-filled name be resubmitted to try again. */
    ShowQueryString(
        initial_name,
        STR_SAVELOAD_NEW_DIRECTORY_QUERY_CAPTION,
        MAX_DIRECTORY_NAME_CHARS,
        this,
        CS_ALPHANUMERAL,
        {QueryStringFlag::LengthIsInChars, QueryStringFlag::AcceptUnchanged});
  }

  void HandleNewDirectoryRequest(const std::string &query_text)
  {
    /* CS_ALPHANUMERAL allows spaces, so trim them before validating. */
    const std::string name{StrTrimView(query_text, " ")};
 
    /* An empty name is treated as a cancel, the same as other query dialogs. */
    if (name.empty()) return;
 
    if (auto error = GetDirectoryNameError(name); error.has_value()) {
      this->ShowNewDirectoryQuery(name);
      ShowErrorMessage(GetEncodedString(STR_ERROR_CANNOT_CREATE_DIRECTORY), GetEncodedString(*error), WarningLevel::Error);
      return;
    }
 
    switch (FiosCreateDirectory(name)) {
      case DirectoryCreateResult::Success:
        this->InvalidateData(SLIWD_RESCAN_FILES);
        break;
      case DirectoryCreateResult::AlreadyExists:
        this->ShowNewDirectoryQuery(name);
        ShowErrorMessage(GetEncodedString(STR_ERROR_CANNOT_CREATE_DIRECTORY), GetEncodedString(STR_ERROR_DIRECTORY_NAME_IN_USE), WarningLevel::Error);
        break;
      case DirectoryCreateResult::PermissionDenied:
        ShowErrorMessage(GetEncodedString(STR_ERROR_CANNOT_CREATE_DIRECTORY), GetEncodedString(STR_ERROR_DIRECTORY_PERMISSION_DENIED), WarningLevel::Error);
        break;
      case DirectoryCreateResult::OtherError:
        ShowErrorMessage(GetEncodedString(STR_ERROR_CANNOT_CREATE_DIRECTORY), {}, WarningLevel::Error);
        break;
    }
  }
 
public:

  void GenerateFileName()
  {
    this->filename_editbox.text.Assign(GenerateDefaultSaveName());
  }
 
  SaveLoadWindow(WindowDesc &desc, AbstractFileType abstract_filetype, SaveLoadOperation fop)
      : Window(desc), filename_editbox(64), abstract_filetype(abstract_filetype), fop(fop), filter_editbox(EDITBOX_MAX_SIZE)
  {
    assert(this->fop == SaveLoadOperation::Save || this->fop == SaveLoadOperation::Load);
 
    /* For saving, construct an initial file name. */
    if (this->fop == SaveLoadOperation::Save) {
      switch (this->abstract_filetype) {
        case AbstractFileType::Savegame:
          this->GenerateFileName();
          break;
 
        case AbstractFileType::Scenario:
        case AbstractFileType::Heightmap:
          this->filename_editbox.text.Assign("UNNAMED");
          break;
 
        default:
          /* It's not currently possible to save town data. */
          NOT_REACHED();
      }
    }
    this->querystrings[WID_SL_SAVE_OSK_TITLE] = &this->filename_editbox;
    this->filename_editbox.ok_button = WID_SL_SAVE_GAME;
 
    this->CreateNestedTree();
    if (this->fop == SaveLoadOperation::Load && this->abstract_filetype == AbstractFileType::Savegame) {
      this->GetWidget<NWidgetStacked>(WID_SL_CONTENT_DOWNLOAD_SEL)->SetDisplayedPlane(SZSP_HORIZONTAL);
    }
 
    /* Select caption string of the window. */
    StringID caption_string;
    switch (this->abstract_filetype) {
      case AbstractFileType::Savegame:
        caption_string = (this->fop == SaveLoadOperation::Save) ? STR_SAVELOAD_SAVE_CAPTION : STR_SAVELOAD_LOAD_CAPTION;
        break;
 
      case AbstractFileType::Scenario:
        caption_string = (this->fop == SaveLoadOperation::Save) ? STR_SAVELOAD_SAVE_SCENARIO : STR_SAVELOAD_LOAD_SCENARIO;
        break;
 
      case AbstractFileType::Heightmap:
        caption_string = (this->fop == SaveLoadOperation::Save) ? STR_SAVELOAD_SAVE_HEIGHTMAP : STR_SAVELOAD_LOAD_HEIGHTMAP;
        break;
 
      case AbstractFileType::TownData:
        caption_string = STR_SAVELOAD_LOAD_TOWN_DATA; // It's not currently possible to save town data.
        break;
 
      default:
        NOT_REACHED();
    }
    this->GetWidget<NWidgetCore>(WID_SL_CAPTION)->SetString(caption_string);
 
    this->vscroll = this->GetScrollbar(WID_SL_SCROLLBAR);
    this->FinishInitNested(0);
 
    this->LowerWidget(WID_SL_DRIVES_DIRECTORIES_LIST);
    this->querystrings[WID_SL_FILTER] = &this->filter_editbox;
    this->filter_editbox.cancel_button = QueryString::ACTION_CLEAR;
 
    /* pause is only used in single-player, non-editor mode, non-menu mode. It
     * will be unpaused in the WE_DESTROY event handler. */
    if (_game_mode != GameMode::Menu && !_networking && _game_mode != GameMode::Editor) {
      Command<Commands::Pause>::Post(PauseMode::SaveLoad, true);
    }
    SetObjectToPlace(SPR_CURSOR_ZZZ, PAL_NONE, HT_NONE, WindowClass::MainWindow, 0);
 
    this->OnInvalidateData(SLIWD_RESCAN_FILES);
 
    ResetObjectToPlace();
 
    /* Select the initial directory. */
    o_dir.type = FIOS_TYPE_DIRECT;
    switch (this->abstract_filetype) {
      case AbstractFileType::Savegame:
        o_dir.name = FioFindDirectory(Subdirectory::Save);
        break;
 
      case AbstractFileType::Scenario:
        o_dir.name = FioFindDirectory(Subdirectory::Scenario);
        break;
 
      case AbstractFileType::Heightmap:
      case AbstractFileType::TownData:
        o_dir.name = FioFindDirectory(Subdirectory::Heightmap);
        break;
 
      default:
        o_dir.name = _personal_dir;
    }
 
    switch (this->fop) {
      case SaveLoadOperation::Save:
        /* Focus the edit box by default in the save window */
        this->SetFocusedWidget(WID_SL_SAVE_OSK_TITLE);
        break;
 
      default:
        this->SetFocusedWidget(WID_SL_FILTER);
    }
  }
 
  void Close([[maybe_unused]] int data = 0) override
  {
    /* pause is only used in single-player, non-editor mode, non menu mode */
    if (!_networking && _game_mode != GameMode::Editor && _game_mode != GameMode::Menu) {
      Command<Commands::Pause>::Post(PauseMode::SaveLoad, false);
    }
    this->Window::Close();
  }
 
  void DrawWidget(const Rect &r, WidgetID widget) const override
  {
    switch (widget) {
      case WID_SL_SORT_BYNAME:
      case WID_SL_SORT_BYDATE:
        if ((_savegame_sorter == SavegameSorter::Name) == (widget == WID_SL_SORT_BYNAME)) {
          this->DrawSortButton(widget, !_savegame_sorter_ascending);
        }
        break;
 
      case WID_SL_BACKGROUND: {
        static std::string path;
        static std::optional<uint64_t> free_space = std::nullopt;
 
        if (_fios_path_changed) {
          path = FiosGetCurrentPath();
          free_space = FiosGetDiskFreeSpace(path);
          _fios_path_changed = false;
        }
 
        Rect ir = r.Shrink(WidgetDimensions::scaled.framerect);
 
        if (free_space.has_value()) {
          DrawString(ir.left, ir.right, ir.top + GetCharacterHeight(FontSize::Normal), GetString(STR_SAVELOAD_BYTES_FREE, free_space.value()));
        } else {
          DrawString(ir.left, ir.right, ir.top + GetCharacterHeight(FontSize::Normal), STR_ERROR_UNABLE_TO_READ_DRIVE);
        }
        DrawString(ir.left, ir.right, ir.top, path, TextColour::Black);
        break;
      }
 
      case WID_SL_DRIVES_DIRECTORIES_LIST: {
        const Rect br = r.Shrink(WidgetDimensions::scaled.bevel);
        GfxFillRect(br, PC_BLACK);
 
        Rect tr = r.Shrink(WidgetDimensions::scaled.inset).WithHeight(this->resize.step_height);
        auto [first, last] = this->vscroll->GetVisibleRangeIterators(this->display_list);
        for (auto it = first; it != last; ++it) {
          const FiosItem *item = *it;
 
          if (item == this->selected) {
            GfxFillRect(br.WithY(tr), PC_DARK_BLUE);
          } else if (item == this->highlighted) {
            GfxFillRect(br.WithY(tr), PC_VERY_DARK_BLUE);
          }
          DrawString(tr, item->title.GetDecodedString(), _fios_colours[item->type.detailed]);
          tr = tr.Translate(0, this->resize.step_height);
        }
        break;
      }
 
      case WID_SL_DETAILS:
        this->DrawDetails(r);
        break;
    }
  }
 
  void DrawDetails(const Rect &r) const
  {
    /* Header panel */
    int HEADER_HEIGHT = GetCharacterHeight(FontSize::Normal) + WidgetDimensions::scaled.frametext.Vertical();
 
    Rect hr = r.WithHeight(HEADER_HEIGHT).Shrink(WidgetDimensions::scaled.frametext);
    Rect tr = r.Shrink(WidgetDimensions::scaled.frametext);
    tr.top += HEADER_HEIGHT;
 
    /* Create the nice lighter rectangle at the details top */
    GfxFillRect(r.WithHeight(HEADER_HEIGHT).Shrink(WidgetDimensions::scaled.bevel.left, WidgetDimensions::scaled.bevel.top, WidgetDimensions::scaled.bevel.right, 0), GetColourGradient(Colours::Grey, Shade::Lightest));
    DrawString(hr.left, hr.right, hr.top, STR_SAVELOAD_DETAIL_CAPTION, TextColour::FromString, AlignmentH::Centre);
 
    if (this->selected == nullptr) return;
 
    /* Details panel */
    tr.bottom -= GetCharacterHeight(FontSize::Normal) - 1;
    if (tr.top > tr.bottom) return;
 
    if (!_load_check_data.checkable) {
      /* Old savegame, no information available */
      DrawString(tr, STR_SAVELOAD_DETAIL_NOT_AVAILABLE);
      tr.top += GetCharacterHeight(FontSize::Normal);
    } else if (_load_check_data.error != INVALID_STRING_ID) {
      /* Incompatible / broken savegame */
      tr.top = DrawStringMultiLine(tr, GetString(_load_check_data.error, _load_check_data.error_msg), TextColour::Red);
    } else {
      /* Mapsize */
      DrawString(tr, GetString(STR_NETWORK_SERVER_LIST_MAP_SIZE, _load_check_data.map_size_x, _load_check_data.map_size_y));
      tr.top += GetCharacterHeight(FontSize::Normal);
      if (tr.top > tr.bottom) return;
 
      /* Climate */
      if (to_underlying(_load_check_data.landscape) < NUM_LANDSCAPE) {
        DrawString(tr, GetString(STR_NETWORK_SERVER_LIST_LANDSCAPE, STR_CLIMATE_TEMPERATE_LANDSCAPE + to_underlying(_load_check_data.landscape)));
        tr.top += GetCharacterHeight(FontSize::Normal);
      }
 
      tr.top += WidgetDimensions::scaled.vsep_normal;
      if (tr.top > tr.bottom) return;
 
      /* Start date (if available) */
      if (_load_check_data.starting_year != 0) {
        DrawString(tr, GetString(STR_NETWORK_SERVER_LIST_START_DATE, TimerGameCalendar::ConvertYMDToDate(_load_check_data.starting_year, 0, 1)));
        tr.top += GetCharacterHeight(FontSize::Normal);
      }
      if (tr.top > tr.bottom) return;
 
      /* Hide current date for scenarios */
      if (this->abstract_filetype != AbstractFileType::Scenario) {
        /* Current date */
        DrawString(tr, GetString(STR_NETWORK_SERVER_LIST_CURRENT_DATE, _load_check_data.current_date));
        tr.top += GetCharacterHeight(FontSize::Normal);
      }
 
      /* Hide the NewGRF stuff when saving. We also hide the button. */
      if (this->fop == SaveLoadOperation::Load && (this->abstract_filetype == AbstractFileType::Savegame || this->abstract_filetype == AbstractFileType::Scenario)) {
        tr.top += WidgetDimensions::scaled.vsep_normal;
        if (tr.top > tr.bottom) return;
 
        /* NewGrf compatibility */
        DrawString(tr, GetString(STR_SAVELOAD_DETAIL_GRFSTATUS, _load_check_data.grfconfig.empty() ? STR_NEWGRF_LIST_NONE : STR_NEWGRF_LIST_ALL_FOUND + to_underlying(_load_check_data.grf_compatibility)));
        tr.top += GetCharacterHeight(FontSize::Normal);
      }
      if (tr.top > tr.bottom) return;
 
      /* Hide the company stuff for scenarios */
      if (this->abstract_filetype != AbstractFileType::Scenario) {
        tr.top += WidgetDimensions::scaled.vsep_wide;
        if (tr.top > tr.bottom) return;
 
        /* Companies / AIs */
        for (auto &pair : _load_check_data.companies) {
          const CompanyProperties &c = *pair.second;
          if (c.name.empty()) {
            AutoRestoreBackup landscape_backup(_settings_game.game_creation.landscape, _load_check_data.landscape);
            DrawString(tr, GetString(STR_SAVELOAD_DETAIL_COMPANY_INDEX, pair.first + 1, c.name_1, c.name_2));
          } else {
            DrawString(tr, GetString(STR_SAVELOAD_DETAIL_COMPANY_INDEX, pair.first + 1, STR_JUST_RAW_STRING, c.name));
          }
 
          tr.top += GetCharacterHeight(FontSize::Normal);
          if (tr.top > tr.bottom) break;
        }
      }
    }
  }
 
  void UpdateWidgetSize(WidgetID widget, Dimension &size, [[maybe_unused]] const Dimension &padding, [[maybe_unused]] Dimension &fill, [[maybe_unused]] Dimension &resize) override
  {
    switch (widget) {
      case WID_SL_BACKGROUND:
        size.height = 2 * GetCharacterHeight(FontSize::Normal) + padding.height;
        break;
 
      case WID_SL_DRIVES_DIRECTORIES_LIST:
        fill.height = resize.height = GetCharacterHeight(FontSize::Normal);
        size.height = resize.height * 10 + padding.height;
        break;
      case WID_SL_SORT_BYNAME:
      case WID_SL_SORT_BYDATE: {
        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;
      }
    }
  }
 
  void OnPaint() override
  {
    if (_savegame_sort_dirty) {
      _savegame_sort_dirty = false;
      SortSaveGameList(this->fios_items);
      this->OnInvalidateData(SLIWD_FILTER_CHANGES);
    }
 
    this->DrawWidgets();
  }
 
  void OnClick([[maybe_unused]] Point pt, WidgetID widget, [[maybe_unused]] int click_count) override
  {
    switch (widget) {
      case WID_SL_SORT_BYNAME: // Sort save games by name
        _savegame_sorter_ascending = _savegame_sorter != SavegameSorter::Name || !_savegame_sorter_ascending;
        _savegame_sorter = SavegameSorter::Name;
        _savegame_sort_dirty = true;
        this->SetDirty();
        break;
 
      case WID_SL_SORT_BYDATE: // Sort save games by date
        _savegame_sorter_ascending = _savegame_sorter != SavegameSorter::Date || !_savegame_sorter_ascending;
        _savegame_sorter = SavegameSorter::Date;
        _savegame_sort_dirty = true;
        this->SetDirty();
        break;
 
      case WID_SL_HOME_BUTTON: // OpenTTD 'button', jumps to OpenTTD directory
        FiosBrowseTo(&o_dir);
        this->InvalidateData(SLIWD_RESCAN_FILES);
        break;
 
      case WID_SL_LOAD_BUTTON: {
        if (this->selected == nullptr || _load_check_data.HasErrors()) break;
 
        _file_to_saveload.Set(*this->selected);
 
        if (this->abstract_filetype == AbstractFileType::Heightmap) {
          this->Close();
          ShowHeightmapLoad();
        } else if (this->abstract_filetype == AbstractFileType::TownData) {
          this->Close();
          LoadTownData();
        } else if (!_load_check_data.HasNewGrfs() || _load_check_data.grf_compatibility != GRFListCompatibility::NotFound || _settings_client.gui.UserIsAllowedToChangeNewGRFs()) {
          _switch_mode = (_game_mode == GameMode::Editor) ? SwitchMode::LoadScenario : SwitchMode::LoadGame;
          ClearErrorMessages();
          this->Close();
        }
        break;
      }
 
      case WID_SL_NEWGRF_INFO:
        if (_load_check_data.HasNewGrfs()) {
          ShowNewGRFSettings(false, false, false, _load_check_data.grfconfig);
        }
        break;
 
      case WID_SL_MISSING_NEWGRFS:
        if (!_network_available) {
          ShowErrorMessage(GetEncodedString(STR_NETWORK_ERROR_NOTAVAILABLE), {}, WarningLevel::Error);
        } else if (_load_check_data.HasNewGrfs()) {
          ShowMissingContentWindow(_load_check_data.grfconfig);
        }
        break;
 
      case WID_SL_DRIVES_DIRECTORIES_LIST: { // Click the listbox
        auto it = this->vscroll->GetScrolledItemFromWidget(this->display_list, pt.y, this, WID_SL_DRIVES_DIRECTORIES_LIST, WidgetDimensions::scaled.inset.top);
        if (it == this->display_list.end()) return;
 
        /* Get the corresponding non-filtered out item from the list */
        const FiosItem *file = *it;
 
        if (FiosBrowseTo(file)) {
          /* Changed directory, need refresh. */
          this->InvalidateData(SLIWD_RESCAN_FILES);
          break;
        }
 
        if (click_count == 1) {
          if (this->selected != file) {
            this->selected = file;
            _load_check_data.Clear();
 
            if (file->type.detailed == DetailedFileType::GameFile) {
              /* Other detailed file types cannot be checked before. */
              SaveOrLoad(file->name, SaveLoadOperation::Check, DetailedFileType::GameFile, Subdirectory::None, false);
            }
 
            this->InvalidateData(SLIWD_SELECTION_CHANGES);
          }
          if (this->fop == SaveLoadOperation::Save) {
            /* Copy clicked name to editbox */
            this->filename_editbox.text.Assign(file->title.GetDecodedString());
            this->SetWidgetDirty(WID_SL_SAVE_OSK_TITLE);
          }
        } else if (!_load_check_data.HasErrors()) {
          this->selected = file;
          if (this->fop == SaveLoadOperation::Load) {
            if (this->abstract_filetype == AbstractFileType::Savegame || this->abstract_filetype == AbstractFileType::Scenario || this->abstract_filetype == AbstractFileType::TownData) {
              this->OnClick(pt, WID_SL_LOAD_BUTTON, 1);
            } else {
              assert(this->abstract_filetype == AbstractFileType::Heightmap);
              _file_to_saveload.Set(*file);
 
              this->Close();
              ShowHeightmapLoad();
            }
          }
        }
        break;
      }
 
      case WID_SL_CONTENT_DOWNLOAD:
        if (!_network_available) {
          ShowErrorMessage(GetEncodedString(STR_NETWORK_ERROR_NOTAVAILABLE), {}, WarningLevel::Error);
        } else {
          assert(this->fop == SaveLoadOperation::Load);
          switch (this->abstract_filetype) {
            default: NOT_REACHED();
            case AbstractFileType::Scenario: ShowNetworkContentListWindow(nullptr, ContentType::Scenario); break;
            case AbstractFileType::Heightmap: ShowNetworkContentListWindow(nullptr, ContentType::Heightmap); break;
          }
        }
        break;
 
      case WID_SL_DELETE_SELECTION: // Delete
        break;
 
      case WID_SL_SAVE_GAME: // Save game
        /* Note, this is also called via the OSK; and we need to lower the button. */
        this->HandleButtonClick(WID_SL_SAVE_GAME);
        break;
 
      case WID_SL_NEW_DIRECTORY: // Create directory
        this->ShowNewDirectoryQuery();
        break;
    }
  }
 
  void OnMouseOver([[maybe_unused]] Point pt, WidgetID widget) override
  {
    if (widget == WID_SL_DRIVES_DIRECTORIES_LIST) {
      auto it = this->vscroll->GetScrolledItemFromWidget(this->display_list, pt.y, this, WID_SL_DRIVES_DIRECTORIES_LIST, WidgetDimensions::scaled.inset.top);
      if (it == this->display_list.end()) return;
 
      /* Get the corresponding non-filtered out item from the list */
      const FiosItem *file = *it;
 
      if (file != this->highlighted) {
        this->highlighted = file;
        this->SetWidgetDirty(WID_SL_DRIVES_DIRECTORIES_LIST);
      }
    } else if (this->highlighted != nullptr) {
      this->highlighted = nullptr;
      this->SetWidgetDirty(WID_SL_DRIVES_DIRECTORIES_LIST);
    }
  }
 
  EventState OnKeyPress([[maybe_unused]] char32_t key, uint16_t keycode) override
  {
    if (keycode == WKC_ESC) {
      this->Close();
      return EventState::Handled;
    }
 
    return EventState::NotHandled;
  }
 
  void OnTimeout() override
  {
    /* Widgets WID_SL_DELETE_SELECTION and WID_SL_SAVE_GAME only exist when saving to a file. */
    if (this->fop != SaveLoadOperation::Save) return;
 
    if (this->IsWidgetLowered(WID_SL_DELETE_SELECTION)) { // Delete button clicked
      ShowQuery(GetEncodedString(STR_SAVELOAD_DELETE_TITLE), GetEncodedString(STR_SAVELOAD_DELETE_WARNING),
          this, SaveLoadWindow::DeleteFileConfirmationCallback);
    } else if (this->IsWidgetLowered(WID_SL_SAVE_GAME)) { // Save button clicked
      if (this->abstract_filetype == AbstractFileType::Savegame || this->abstract_filetype == AbstractFileType::Scenario) {
        _file_to_saveload.name = FiosMakeSavegameName(this->filename_editbox.text.GetText());
        if (FioCheckFileExists(_file_to_saveload.name, Subdirectory::Save)) {
          ShowQuery(GetEncodedString(STR_SAVELOAD_OVERWRITE_TITLE), GetEncodedString(STR_SAVELOAD_OVERWRITE_WARNING),
              this, SaveLoadWindow::SaveGameConfirmationCallback);
        } else {
          _switch_mode = SwitchMode::SaveGame;
        }
      } else {
        _file_to_saveload.name = FiosMakeHeightmapName(this->filename_editbox.text.GetText());
        if (FioCheckFileExists(_file_to_saveload.name, Subdirectory::Save)) {
          ShowQuery(GetEncodedString(STR_SAVELOAD_OVERWRITE_TITLE), GetEncodedString(STR_SAVELOAD_OVERWRITE_WARNING),
              this, SaveLoadWindow::SaveHeightmapConfirmationCallback);
        } else {
          _switch_mode = SwitchMode::SaveHeightmap;
        }
      }
 
      /* In the editor set up the vehicle engines correctly (date might have changed) */
      if (_game_mode == GameMode::Editor) StartupEngines();
    }
  }
 
  void OnResize() override
  {
    this->vscroll->SetCapacityFromWidget(this, WID_SL_DRIVES_DIRECTORIES_LIST);
  }
 
  void BuildDisplayList()
  {
    /* Filter changes */
    this->display_list.clear();
    this->display_list.reserve(this->fios_items.size());
 
    if (this->string_filter.IsEmpty()) {
      /* We don't filter anything out if the filter editbox is empty */
      for (auto &it : this->fios_items) {
        this->display_list.push_back(&it);
      }
    } else {
      for (auto &it : this->fios_items) {
        this->string_filter.ResetState();
        this->string_filter.AddLine(it.title.GetDecodedString());
        /* We set the vector to show this fios element as filtered depending on the result of the filter */
        if (this->string_filter.GetState()) {
          this->display_list.push_back(&it);
        } else if (&it == this->selected) {
          /* The selected element has been filtered out */
          this->selected = nullptr;
          this->OnInvalidateData(SLIWD_SELECTION_CHANGES);
        }
      }
    }
 
    this->vscroll->SetCount(this->display_list.size());
  }

  void OnInvalidateData(int data = 0, bool gui_scope = true) override
  {
    switch (data) {
      case SLIWD_RESCAN_FILES:
        /* Rescan files */
        this->selected = nullptr;
        _load_check_data.Clear();
        if (!gui_scope) break;
 
        _fios_path_changed = true;
        this->fios_items.BuildFileList(this->abstract_filetype, this->fop, true);
        this->selected = nullptr;
        _load_check_data.Clear();
 
        /* We reset the files filtered */
        this->OnInvalidateData(SLIWD_FILTER_CHANGES);
 
        [[fallthrough]];
 
      case SLIWD_SELECTION_CHANGES:
        /* Selection changes */
        if (!gui_scope) break;
 
        if (this->fop == SaveLoadOperation::Save) this->SetWidgetDisabledState(WID_SL_DELETE_SELECTION, this->selected == nullptr);
 
        if (this->fop != SaveLoadOperation::Load) break;
 
        switch (this->abstract_filetype) {
          case AbstractFileType::Heightmap:
          case AbstractFileType::TownData:
            this->SetWidgetDisabledState(WID_SL_LOAD_BUTTON, this->selected == nullptr || _load_check_data.HasErrors());
            break;
 
          case AbstractFileType::Savegame:
          case AbstractFileType::Scenario: {
            bool disabled = this->selected == nullptr || _load_check_data.HasErrors();
            if (!_settings_client.gui.UserIsAllowedToChangeNewGRFs()) {
              disabled |= _load_check_data.HasNewGrfs() && _load_check_data.grf_compatibility == GRFListCompatibility::NotFound;
            }
            this->SetWidgetDisabledState(WID_SL_LOAD_BUTTON, disabled);
            this->SetWidgetDisabledState(WID_SL_NEWGRF_INFO, !_load_check_data.HasNewGrfs());
            this->SetWidgetDisabledState(WID_SL_MISSING_NEWGRFS,
                !_load_check_data.HasNewGrfs() || _load_check_data.grf_compatibility == GRFListCompatibility::AllGood);
            break;
          }
 
          default:
            NOT_REACHED();
        }
        break;
 
      case SLIWD_FILTER_CHANGES:
        this->BuildDisplayList();
        break;
    }
  }
 
  void OnEditboxChanged(WidgetID wid) override
  {
    if (wid == WID_SL_FILTER) {
      this->string_filter.SetFilterTerm(this->filter_editbox.text.GetText());
      this->InvalidateData(SLIWD_FILTER_CHANGES);
    }
 
    if (wid == WID_SL_SAVE_OSK_TITLE) {
      this->selected = nullptr;
      this->InvalidateData(SLIWD_SELECTION_CHANGES);
    }
  }
 
  void OnQueryTextFinished(std::optional<std::string> str) override
  {
    if (str.has_value()) this->HandleNewDirectoryRequest(*str);
  }
};

static WindowDesc _load_dialog_desc(
  WindowPosition::Center, "load_game", 500, 294,
  WindowClass::SaveLoad, WindowClass::None,
  {},
  _nested_load_dialog_widgets
);

static WindowDesc _load_heightmap_dialog_desc(
  WindowPosition::Center, "load_heightmap", 257, 320,
  WindowClass::SaveLoad, WindowClass::None,
  {},
  _nested_load_heightmap_dialog_widgets
);

static WindowDesc _load_town_data_dialog_desc(
  WindowPosition::Center, "load_town_data", 257, 320,
  WindowClass::SaveLoad, WindowClass::None,
  {},
  _nested_load_town_data_dialog_widgets
);

static WindowDesc _save_dialog_desc(
  WindowPosition::Center, "save_game", 500, 294,
  WindowClass::SaveLoad, WindowClass::None,
  {},
  _nested_save_dialog_widgets
);

void ShowSaveLoadDialog(AbstractFileType abstract_filetype, SaveLoadOperation fop)
{
  CloseWindowById(WindowClass::SaveLoad, 0);
 
  if (fop == SaveLoadOperation::Save) {
    new SaveLoadWindow(_save_dialog_desc, abstract_filetype, fop);
  } else {
    /* Dialogue for loading a file. */
    switch (abstract_filetype) {
      case AbstractFileType::Heightmap:
        new SaveLoadWindow(_load_heightmap_dialog_desc, abstract_filetype, fop);
        break;
 
      case AbstractFileType::TownData:
        new SaveLoadWindow(_load_town_data_dialog_desc, abstract_filetype, fop);
        break;
 
      default:
        new SaveLoadWindow(_load_dialog_desc, abstract_filetype, fop);
    }
  }
}