src/fios_gui.cpp

   1 /*
   2  * This file is part of OpenTTD.
   3  * 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.
   4  * 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.
   5  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
   6  */
   7
   8 /** @file fios_gui.cpp GUIs for loading/saving games, scenarios, heightmaps, ... */
   9
  10 #include "stdafx.h"
  11 #include "saveload/saveload.h"
  12 #include "error.h"
  13 #include "gui.h"
  14 #include "gfx_func.h"
  15 #include "command_func.h"
  16 #include "network/network.h"
  17 #include "network/network_content.h"
  18 #include "strings_func.h"
  19 #include "fileio_func.h"
  20 #include "fios.h"
  21 #include "window_func.h"
  22 #include "tilehighlight_func.h"
  23 #include "querystring_gui.h"
  24 #include "engine_func.h"
  25 #include "landscape_type.h"
  26 #include "genworld.h"
  27 #include "timer/timer_game_calendar.h"
  28 #include "core/geometry_func.hpp"
  29 #include "gamelog.h"
  30 #include "stringfilter_type.h"
  31 #include "misc_cmd.h"
  32 #include "gamelog_internal.h"
  33
  34 #include "widgets/fios_widget.h"
  35
  36 #include "table/sprites.h"
  37 #include "table/strings.h"
  38
  39 #include "safeguards.h"
  40
  41 LoadCheckData _load_check_data;    ///< Data loaded from save during SL_LOAD_CHECK.
  42
  43 static bool _fios_path_changed;
  44 static bool _savegame_sort_dirty;
  45
  46 /**
  47  * Reset read data.
  48  */
  49 void LoadCheckData::Clear()
  50 {
  51         this->checkable = false;
  52         this->error = INVALID_STRING_ID;
  53         this->error_msg.clear();
  54
  55         this->map_size_x = this->map_size_y = 256; // Default for old savegames which do not store mapsize.
  56         this->current_date = 0;
  57         this->settings = {};
  58
  59         companies.clear();
  60
  61         this->gamelog.Reset();
  62
  63         ClearGRFConfigList(&this->grfconfig);
  64 }
  65
  66 /** Load game/scenario with optional content download */
  67 static constexpr NWidgetPart _nested_load_dialog_widgets[] = {
  68         NWidget(NWID_HORIZONTAL),
  69                 NWidget(WWT_CLOSEBOX, COLOUR_GREY),
  70                 NWidget(WWT_CAPTION, COLOUR_GREY, WID_SL_CAPTION),
  71                 NWidget(WWT_DEFSIZEBOX, COLOUR_GREY),
  72         EndContainer(),
  73         /* Current directory and free space */
  74         NWidget(WWT_PANEL, COLOUR_GREY, WID_SL_BACKGROUND), SetFill(1, 0), SetResize(1, 0),
  75         EndContainer(),
  76
  77         NWidget(NWID_HORIZONTAL, NC_EQUALSIZE),
  78                 /* Left side : filter box and available files */
  79                 NWidget(NWID_VERTICAL),
  80                         /* Filter box with label */
  81                         NWidget(WWT_PANEL, COLOUR_GREY), SetFill(1, 1), SetResize(1, 1),
  82                                 NWidget(NWID_HORIZONTAL), SetPadding(WidgetDimensions::unscaled.framerect.top, 0, WidgetDimensions::unscaled.framerect.bottom, 0),
  83                                                 SetPIP(WidgetDimensions::unscaled.frametext.left, WidgetDimensions::unscaled.frametext.right, 0),
  84                                         NWidget(WWT_TEXT, COLOUR_GREY), SetFill(0, 1), SetDataTip(STR_SAVELOAD_FILTER_TITLE , STR_NULL),
  85                                         NWidget(WWT_EDITBOX, COLOUR_GREY, WID_SL_FILTER), SetFill(1, 0), SetResize(1, 0),
  86                                                         SetDataTip(STR_LIST_FILTER_OSKTITLE, STR_LIST_FILTER_TOOLTIP),
  87                                 EndContainer(),
  88                         EndContainer(),
  89                         /* Sort buttons */
  90                         NWidget(NWID_HORIZONTAL),
  91                                 NWidget(NWID_HORIZONTAL, NC_EQUALSIZE),
  92                                         NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_SL_SORT_BYNAME), SetDataTip(STR_SORT_BY_CAPTION_NAME, STR_TOOLTIP_SORT_ORDER), SetFill(1, 0), SetResize(1, 0),
  93                                         NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_SL_SORT_BYDATE), SetDataTip(STR_SORT_BY_CAPTION_DATE, STR_TOOLTIP_SORT_ORDER), SetFill(1, 0), SetResize(1, 0),
  94                                 EndContainer(),
  95                                 NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_SL_HOME_BUTTON), SetAspect(1), SetDataTip(SPR_HOUSE_ICON, STR_SAVELOAD_HOME_BUTTON),
  96                         EndContainer(),
  97                         /* Files */
  98                         NWidget(NWID_HORIZONTAL),
  99                                 NWidget(WWT_PANEL, COLOUR_GREY, WID_SL_FILE_BACKGROUND),
 100                                         NWidget(WWT_INSET, COLOUR_GREY, WID_SL_DRIVES_DIRECTORIES_LIST), SetFill(1, 1), SetPadding(2, 2, 2, 2),
 101                                                         SetDataTip(0x0, STR_SAVELOAD_LIST_TOOLTIP), SetResize(1, 10), SetScrollbar(WID_SL_SCROLLBAR),
 102                                         EndContainer(),
 103                                 EndContainer(),
 104                                 NWidget(NWID_VSCROLLBAR, COLOUR_GREY, WID_SL_SCROLLBAR),
 105                         EndContainer(),
 106                         /* Online Content button */
 107                         NWidget(NWID_SELECTION, INVALID_COLOUR, WID_SL_CONTENT_DOWNLOAD_SEL),
 108                                 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_SL_CONTENT_DOWNLOAD), SetResize(1, 0),
 109                                                 SetDataTip(STR_INTRO_ONLINE_CONTENT, STR_INTRO_TOOLTIP_ONLINE_CONTENT),
 110                         EndContainer(),
 111                 EndContainer(),
 112
 113                 /* Right side : game details */
 114                 NWidget(NWID_VERTICAL),
 115                         NWidget(WWT_PANEL, COLOUR_GREY, WID_SL_DETAILS), SetResize(1, 1), SetFill(1, 1),
 116                         EndContainer(),
 117                         NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_SL_MISSING_NEWGRFS), SetDataTip(STR_NEWGRF_SETTINGS_FIND_MISSING_CONTENT_BUTTON, STR_NEWGRF_SETTINGS_FIND_MISSING_CONTENT_TOOLTIP), SetFill(1, 0), SetResize(1, 0),
 118                         NWidget(NWID_HORIZONTAL),
 119                                 NWidget(NWID_HORIZONTAL, NC_EQUALSIZE),
 120                                         NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_SL_NEWGRF_INFO), SetDataTip(STR_INTRO_NEWGRF_SETTINGS, STR_NULL), SetFill(1, 0), SetResize(1, 0),
 121                                         NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_SL_LOAD_BUTTON), SetDataTip(STR_SAVELOAD_LOAD_BUTTON, STR_SAVELOAD_LOAD_TOOLTIP), SetFill(1, 0), SetResize(1, 0),
 122                                 EndContainer(),
 123                                 NWidget(WWT_RESIZEBOX, COLOUR_GREY),
 124                         EndContainer(),
 125                 EndContainer(),
 126         EndContainer(),
 127 };
 128
 129 /** Load heightmap with content download */
 130 static constexpr NWidgetPart _nested_load_heightmap_dialog_widgets[] = {
 131         NWidget(NWID_HORIZONTAL),
 132                 NWidget(WWT_CLOSEBOX, COLOUR_GREY),
 133                 NWidget(WWT_CAPTION, COLOUR_GREY, WID_SL_CAPTION),
 134                 NWidget(WWT_DEFSIZEBOX, COLOUR_GREY),
 135         EndContainer(),
 136         /* Current directory and free space */
 137         NWidget(WWT_PANEL, COLOUR_GREY, WID_SL_BACKGROUND), SetFill(1, 0), SetResize(1, 0),
 138         EndContainer(),
 139
 140         /* Filter box with label */
 141         NWidget(WWT_PANEL, COLOUR_GREY), SetFill(1, 1), SetResize(1, 1),
 142                 NWidget(NWID_HORIZONTAL), SetPadding(WidgetDimensions::unscaled.framerect.top, 0, WidgetDimensions::unscaled.framerect.bottom, 0),
 143                                 SetPIP(WidgetDimensions::unscaled.frametext.left, WidgetDimensions::unscaled.frametext.right, 0),
 144                         NWidget(WWT_TEXT, COLOUR_GREY), SetFill(0, 1), SetDataTip(STR_SAVELOAD_FILTER_TITLE , STR_NULL),
 145                         NWidget(WWT_EDITBOX, COLOUR_GREY, WID_SL_FILTER), SetFill(1, 0), SetResize(1, 0),
 146                                         SetDataTip(STR_LIST_FILTER_OSKTITLE, STR_LIST_FILTER_TOOLTIP),
 147                 EndContainer(),
 148         EndContainer(),
 149         /* Sort Buttons */
 150         NWidget(NWID_HORIZONTAL),
 151                 NWidget(NWID_HORIZONTAL, NC_EQUALSIZE),
 152                         NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_SL_SORT_BYNAME), SetDataTip(STR_SORT_BY_CAPTION_NAME, STR_TOOLTIP_SORT_ORDER), SetFill(1, 0), SetResize(1, 0),
 153                         NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_SL_SORT_BYDATE), SetDataTip(STR_SORT_BY_CAPTION_DATE, STR_TOOLTIP_SORT_ORDER), SetFill(1, 0), SetResize(1, 0),
 154                 EndContainer(),
 155                 NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_SL_HOME_BUTTON), SetAspect(1), SetDataTip(SPR_HOUSE_ICON, STR_SAVELOAD_HOME_BUTTON),
 156         EndContainer(),
 157         /* Files */
 158         NWidget(NWID_HORIZONTAL),
 159                 NWidget(WWT_PANEL, COLOUR_GREY, WID_SL_FILE_BACKGROUND),
 160                         NWidget(WWT_INSET, COLOUR_GREY, WID_SL_DRIVES_DIRECTORIES_LIST), SetFill(1, 1), SetPadding(2, 2, 2, 2),
 161                                         SetDataTip(0x0, STR_SAVELOAD_LIST_TOOLTIP), SetResize(1, 10), SetScrollbar(WID_SL_SCROLLBAR),
 162                         EndContainer(),
 163                 EndContainer(),
 164                 NWidget(NWID_VSCROLLBAR, COLOUR_GREY, WID_SL_SCROLLBAR),
 165         EndContainer(),
 166         /* Online Content and Load button */
 167         NWidget(NWID_HORIZONTAL, NC_EQUALSIZE),
 168                 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_SL_CONTENT_DOWNLOAD), SetResize(1, 0), SetFill(1, 0),
 169                                 SetDataTip(STR_INTRO_ONLINE_CONTENT, STR_INTRO_TOOLTIP_ONLINE_CONTENT),
 170                 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_SL_LOAD_BUTTON), SetResize(1, 0), SetFill(1, 0),
 171                                 SetDataTip(STR_SAVELOAD_LOAD_BUTTON, STR_SAVELOAD_LOAD_HEIGHTMAP_TOOLTIP),
 172                 NWidget(WWT_RESIZEBOX, COLOUR_GREY),
 173         EndContainer(),
 174 };
 175
 176 /** Load town data */
 177 static constexpr NWidgetPart _nested_load_town_data_dialog_widgets[] = {
 178         NWidget(NWID_HORIZONTAL),
 179                 NWidget(WWT_CLOSEBOX, COLOUR_GREY),
 180                 NWidget(WWT_CAPTION, COLOUR_GREY, WID_SL_CAPTION),
 181                 NWidget(WWT_DEFSIZEBOX, COLOUR_GREY),
 182         EndContainer(),
 183         /* Current directory and free space */
 184         NWidget(WWT_PANEL, COLOUR_GREY, WID_SL_BACKGROUND), SetFill(1, 0), SetResize(1, 0), EndContainer(),
 185
 186         /* Filter box with label */
 187         NWidget(WWT_PANEL, COLOUR_GREY), SetFill(1, 1), SetResize(1, 1),
 188                 NWidget(NWID_HORIZONTAL), SetPadding(WidgetDimensions::unscaled.framerect.top, 0, WidgetDimensions::unscaled.framerect.bottom, 0),
 189                                 SetPIP(WidgetDimensions::unscaled.frametext.left, WidgetDimensions::unscaled.frametext.right, 0),
 190                         NWidget(WWT_TEXT, COLOUR_GREY), SetFill(0, 1), SetDataTip(STR_SAVELOAD_FILTER_TITLE , STR_NULL),
 191                         NWidget(WWT_EDITBOX, COLOUR_GREY, WID_SL_FILTER), SetFill(1, 0), SetResize(1, 0), SetDataTip(STR_LIST_FILTER_OSKTITLE, STR_LIST_FILTER_TOOLTIP),
 192                 EndContainer(),
 193         EndContainer(),
 194         /* Sort Buttons */
 195         NWidget(NWID_HORIZONTAL),
 196                 NWidget(NWID_HORIZONTAL, NC_EQUALSIZE),
 197                         NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_SL_SORT_BYNAME), SetDataTip(STR_SORT_BY_CAPTION_NAME, STR_TOOLTIP_SORT_ORDER), SetFill(1, 0), SetResize(1, 0),
 198                         NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_SL_SORT_BYDATE), SetDataTip(STR_SORT_BY_CAPTION_DATE, STR_TOOLTIP_SORT_ORDER), SetFill(1, 0), SetResize(1, 0),
 199                 EndContainer(),
 200                 NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_SL_HOME_BUTTON), SetAspect(1), SetDataTip(SPR_HOUSE_ICON, STR_SAVELOAD_HOME_BUTTON),
 201         EndContainer(),
 202         /* Files */
 203         NWidget(NWID_HORIZONTAL),
 204                 NWidget(WWT_PANEL, COLOUR_GREY, WID_SL_FILE_BACKGROUND),
 205                         NWidget(WWT_INSET, COLOUR_GREY, WID_SL_DRIVES_DIRECTORIES_LIST), SetFill(1, 1), SetPadding(2, 2, 2, 2),
 206                                         SetDataTip(0x0, STR_SAVELOAD_LIST_TOOLTIP), SetResize(1, 10), SetScrollbar(WID_SL_SCROLLBAR), EndContainer(),
 207                 EndContainer(),
 208                 NWidget(NWID_VSCROLLBAR, COLOUR_GREY, WID_SL_SCROLLBAR),
 209         EndContainer(),
 210         /* Load button */
 211         NWidget(NWID_HORIZONTAL, NC_EQUALSIZE),
 212                 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_SL_LOAD_BUTTON), SetResize(1, 0), SetFill(1, 0),
 213                                 SetDataTip(STR_SAVELOAD_LOAD_BUTTON, STR_SAVELOAD_LOAD_TOWN_DATA_TOOLTIP),
 214                 NWidget(WWT_RESIZEBOX, COLOUR_GREY),
 215         EndContainer(),
 216 };
 217
 218 /** Save game/scenario */
 219 static constexpr NWidgetPart _nested_save_dialog_widgets[] = {
 220         NWidget(NWID_HORIZONTAL),
 221                 NWidget(WWT_CLOSEBOX, COLOUR_GREY),
 222                 NWidget(WWT_CAPTION, COLOUR_GREY, WID_SL_CAPTION),
 223                 NWidget(WWT_DEFSIZEBOX, COLOUR_GREY),
 224         EndContainer(),
 225         /* Current directory and free space */
 226         NWidget(WWT_PANEL, COLOUR_GREY, WID_SL_BACKGROUND), SetFill(1, 0), SetResize(1, 0),
 227         EndContainer(),
 228
 229         NWidget(NWID_HORIZONTAL, NC_EQUALSIZE),
 230                 /* Left side : filter box and available files */
 231                 NWidget(NWID_VERTICAL),
 232                         /* Filter box with label */
 233                         NWidget(WWT_PANEL, COLOUR_GREY), SetFill(1, 1), SetResize(1, 1),
 234                                 NWidget(NWID_HORIZONTAL), SetPadding(WidgetDimensions::unscaled.framerect.top, 0, WidgetDimensions::unscaled.framerect.bottom, 0),
 235                                                 SetPIP(WidgetDimensions::unscaled.frametext.left, WidgetDimensions::unscaled.frametext.right, 0),
 236                                         NWidget(WWT_TEXT, COLOUR_GREY), SetFill(0, 1), SetDataTip(STR_SAVELOAD_FILTER_TITLE , STR_NULL),
 237                                         NWidget(WWT_EDITBOX, COLOUR_GREY, WID_SL_FILTER), SetFill(1, 0), SetResize(1, 0),
 238                                                         SetDataTip(STR_LIST_FILTER_OSKTITLE, STR_LIST_FILTER_TOOLTIP),
 239                                 EndContainer(),
 240                         EndContainer(),
 241                         /* Sort buttons */
 242                         NWidget(NWID_HORIZONTAL),
 243                                 NWidget(NWID_HORIZONTAL, NC_EQUALSIZE),
 244                                         NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_SL_SORT_BYNAME), SetDataTip(STR_SORT_BY_CAPTION_NAME, STR_TOOLTIP_SORT_ORDER), SetFill(1, 0), SetResize(1, 0),
 245                                         NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_SL_SORT_BYDATE), SetDataTip(STR_SORT_BY_CAPTION_DATE, STR_TOOLTIP_SORT_ORDER), SetFill(1, 0), SetResize(1, 0),
 246                                 EndContainer(),
 247                                 NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_SL_HOME_BUTTON), SetAspect(1), SetDataTip(SPR_HOUSE_ICON, STR_SAVELOAD_HOME_BUTTON),
 248                         EndContainer(),
 249                         /* Files */
 250                         NWidget(NWID_HORIZONTAL),
 251                                 NWidget(WWT_PANEL, COLOUR_GREY, WID_SL_FILE_BACKGROUND),
 252                                         NWidget(WWT_INSET, COLOUR_GREY, WID_SL_DRIVES_DIRECTORIES_LIST), SetPadding(2, 2, 2, 2),
 253                                                         SetDataTip(0x0, STR_SAVELOAD_LIST_TOOLTIP), SetResize(1, 10), SetScrollbar(WID_SL_SCROLLBAR),
 254                                         EndContainer(),
 255                                 EndContainer(),
 256                                 NWidget(NWID_VSCROLLBAR, COLOUR_GREY, WID_SL_SCROLLBAR),
 257                         EndContainer(),
 258                         NWidget(WWT_PANEL, COLOUR_GREY),
 259                                 NWidget(WWT_EDITBOX, COLOUR_GREY, WID_SL_SAVE_OSK_TITLE), SetPadding(2, 2, 2, 2), SetFill(1, 0), SetResize(1, 0),
 260                                                 SetDataTip(STR_SAVELOAD_OSKTITLE, STR_SAVELOAD_EDITBOX_TOOLTIP),
 261                         EndContainer(),
 262                         /* Save/delete buttons */
 263                         NWidget(NWID_HORIZONTAL),
 264                                 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_SL_DELETE_SELECTION), SetDataTip(STR_SAVELOAD_DELETE_BUTTON, STR_SAVELOAD_DELETE_TOOLTIP), SetFill(1, 0), SetResize(1, 0),
 265                                 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_SL_SAVE_GAME),        SetDataTip(STR_SAVELOAD_SAVE_BUTTON, STR_SAVELOAD_SAVE_TOOLTIP),     SetFill(1, 0), SetResize(1, 0),
 266                         EndContainer(),
 267                 EndContainer(),
 268
 269                 /* Right side : game details */
 270                 NWidget(NWID_VERTICAL),
 271                         NWidget(WWT_PANEL, COLOUR_GREY, WID_SL_DETAILS), SetResize(1, 1), SetFill(1, 1),
 272                         EndContainer(),
 273                         NWidget(NWID_HORIZONTAL),
 274                                 NWidget(WWT_PANEL, COLOUR_GREY), SetResize(1, 0), SetFill(1, 1),
 275                                 EndContainer(),
 276                                 NWidget(WWT_RESIZEBOX, COLOUR_GREY),
 277                         EndContainer(),
 278                 EndContainer(),
 279         EndContainer(),
 280 };
 281
 282 /** Text colours of #DetailedFileType fios entries in the window. */
 283 static const TextColour _fios_colours[] = {
 284         TC_LIGHT_BROWN,  // DFT_OLD_GAME_FILE
 285         TC_ORANGE,       // DFT_GAME_FILE
 286         TC_YELLOW,       // DFT_HEIGHTMAP_BMP
 287         TC_ORANGE,       // DFT_HEIGHTMAP_PNG
 288         TC_LIGHT_BROWN,  // DFT_TOWN_DATA_JSON
 289         TC_LIGHT_BLUE,   // DFT_FIOS_DRIVE
 290         TC_DARK_GREEN,   // DFT_FIOS_PARENT
 291         TC_DARK_GREEN,   // DFT_FIOS_DIR
 292         TC_ORANGE,       // DFT_FIOS_DIRECT
 293 };
 294 /* This should align with the DetailedFileType enum defined in fileio_type.h */
 295 static_assert(std::size(_fios_colours) == DFT_END);
 296
 297 /**
 298  * Sort the collected list save games prior to displaying it in the save/load gui.
 299  * @param[in,out] file_list List of save game files found in the directory.
 300  */
 301 static void SortSaveGameList(FileList &file_list)
 302 {
 303         size_t sort_start = 0;
 304         size_t sort_end = 0;
 305
 306         /* Directories are always above the files (FIOS_TYPE_DIR)
 307          * Drives (A:\ (windows only) are always under the files (FIOS_TYPE_DRIVE)
 308          * Only sort savegames/scenarios, not directories
 309          */
 310         for (const auto &item : file_list) {
 311                 switch (item.type) {
 312                         case FIOS_TYPE_DIR:    sort_start++; break;
 313                         case FIOS_TYPE_PARENT: sort_start++; break;
 314                         case FIOS_TYPE_DRIVE:  sort_end++;   break;
 315                         default: break;
 316                 }
 317         }
 318
 319         std::sort(file_list.begin() + sort_start, file_list.end() - sort_end);
 320 }
 321
 322 struct SaveLoadWindow : public Window {
 323 private:
 324         static const uint EDITBOX_MAX_SIZE   =  50;
 325
 326         QueryString filename_editbox; ///< Filename editbox.
 327         AbstractFileType abstract_filetype; /// Type of file to select.
 328         SaveLoadOperation fop;        ///< File operation to perform.
 329         FileList fios_items;          ///< Save game list.
 330         FiosItem o_dir;               ///< Original dir (home dir for this browser)
 331         const FiosItem *selected;     ///< Selected game in #fios_items, or \c nullptr.
 332         const FiosItem *highlighted;  ///< Item in fios_items highlighted by mouse pointer, or \c nullptr.
 333         Scrollbar *vscroll;
 334
 335         StringFilter string_filter; ///< Filter for available games.
 336         QueryString filter_editbox; ///< Filter editbox;
 337         std::vector<FiosItem *> display_list; ///< Filtered display list
 338
 339         static void SaveGameConfirmationCallback(Window *, bool confirmed)
 340         {
 341                 /* File name has already been written to _file_to_saveload */
 342                 if (confirmed) _switch_mode = SM_SAVE_GAME;
 343         }
 344
 345         static void SaveHeightmapConfirmationCallback(Window *, bool confirmed)
 346         {
 347                 /* File name has already been written to _file_to_saveload */
 348                 if (confirmed) _switch_mode = SM_SAVE_HEIGHTMAP;
 349         }
 350
 351 public:
 352
 353         /** Generate a default save filename. */
 354         void GenerateFileName()
 355         {
 356                 this->filename_editbox.text.Assign(GenerateDefaultSaveName());
 357         }
 358
 359         SaveLoadWindow(WindowDesc &desc, AbstractFileType abstract_filetype, SaveLoadOperation fop)
 360                         : Window(desc), filename_editbox(64), abstract_filetype(abstract_filetype), fop(fop), filter_editbox(EDITBOX_MAX_SIZE)
 361         {
 362                 assert(this->fop == SLO_SAVE || this->fop == SLO_LOAD);
 363
 364                 /* For saving, construct an initial file name. */
 365                 if (this->fop == SLO_SAVE) {
 366                         switch (this->abstract_filetype) {
 367                                 case FT_SAVEGAME:
 368                                         this->GenerateFileName();
 369                                         break;
 370
 371                                 case FT_SCENARIO:
 372                                 case FT_HEIGHTMAP:
 373                                         this->filename_editbox.text.Assign("UNNAMED");
 374                                         break;
 375
 376                                 default:
 377                                         /* It's not currently possible to save town data. */
 378                                         NOT_REACHED();
 379                         }
 380                 }
 381                 this->querystrings[WID_SL_SAVE_OSK_TITLE] = &this->filename_editbox;
 382                 this->filename_editbox.ok_button = WID_SL_SAVE_GAME;
 383
 384                 this->CreateNestedTree();
 385                 if (this->fop == SLO_LOAD && this->abstract_filetype == FT_SAVEGAME) {
 386                         this->GetWidget<NWidgetStacked>(WID_SL_CONTENT_DOWNLOAD_SEL)->SetDisplayedPlane(SZSP_HORIZONTAL);
 387                 }
 388
 389                 /* Select caption string of the window. */
 390                 StringID caption_string;
 391                 switch (this->abstract_filetype) {
 392                         case FT_SAVEGAME:
 393                                 caption_string = (this->fop == SLO_SAVE) ? STR_SAVELOAD_SAVE_CAPTION : STR_SAVELOAD_LOAD_CAPTION;
 394                                 break;
 395
 396                         case FT_SCENARIO:
 397                                 caption_string = (this->fop == SLO_SAVE) ? STR_SAVELOAD_SAVE_SCENARIO : STR_SAVELOAD_LOAD_SCENARIO;
 398                                 break;
 399
 400                         case FT_HEIGHTMAP:
 401                                 caption_string = (this->fop == SLO_SAVE) ? STR_SAVELOAD_SAVE_HEIGHTMAP : STR_SAVELOAD_LOAD_HEIGHTMAP;
 402                                 break;
 403
 404                         case FT_TOWN_DATA:
 405                                 caption_string = STR_SAVELOAD_LOAD_TOWN_DATA; // It's not currently possible to save town data.
 406                                 break;
 407
 408                         default:
 409                                 NOT_REACHED();
 410                 }
 411                 this->GetWidget<NWidgetCore>(WID_SL_CAPTION)->widget_data = caption_string;
 412
 413                 this->vscroll = this->GetScrollbar(WID_SL_SCROLLBAR);
 414                 this->FinishInitNested(0);
 415
 416                 this->LowerWidget(WID_SL_DRIVES_DIRECTORIES_LIST);
 417                 this->querystrings[WID_SL_FILTER] = &this->filter_editbox;
 418                 this->filter_editbox.cancel_button = QueryString::ACTION_CLEAR;
 419
 420                 /* pause is only used in single-player, non-editor mode, non-menu mode. It
 421                  * will be unpaused in the WE_DESTROY event handler. */
 422                 if (_game_mode != GM_MENU && !_networking && _game_mode != GM_EDITOR) {
 423                         Command<CMD_PAUSE>::Post(PM_PAUSED_SAVELOAD, true);
 424                 }
 425                 SetObjectToPlace(SPR_CURSOR_ZZZ, PAL_NONE, HT_NONE, WC_MAIN_WINDOW, 0);
 426
 427                 this->OnInvalidateData(SLIWD_RESCAN_FILES);
 428
 429                 ResetObjectToPlace();
 430
 431                 /* Select the initial directory. */
 432                 o_dir.type = FIOS_TYPE_DIRECT;
 433                 switch (this->abstract_filetype) {
 434                         case FT_SAVEGAME:
 435                                 o_dir.name = FioFindDirectory(SAVE_DIR);
 436                                 break;
 437
 438                         case FT_SCENARIO:
 439                                 o_dir.name = FioFindDirectory(SCENARIO_DIR);
 440                                 break;
 441
 442                         case FT_HEIGHTMAP:
 443                         case FT_TOWN_DATA:
 444                                 o_dir.name = FioFindDirectory(HEIGHTMAP_DIR);
 445                                 break;
 446
 447                         default:
 448                                 o_dir.name = _personal_dir;
 449                 }
 450
 451                 switch (this->fop) {
 452                         case SLO_SAVE:
 453                                 /* Focus the edit box by default in the save window */
 454                                 this->SetFocusedWidget(WID_SL_SAVE_OSK_TITLE);
 455                                 break;
 456
 457                         default:
 458                                 this->SetFocusedWidget(WID_SL_FILTER);
 459                 }
 460         }
 461
 462         void Close([[maybe_unused]] int data = 0) override
 463         {
 464                 /* pause is only used in single-player, non-editor mode, non menu mode */
 465                 if (!_networking && _game_mode != GM_EDITOR && _game_mode != GM_MENU) {
 466                         Command<CMD_PAUSE>::Post(PM_PAUSED_SAVELOAD, false);
 467                 }
 468                 this->Window::Close();
 469         }
 470
 471         void DrawWidget(const Rect &r, WidgetID widget) const override
 472         {
 473                 switch (widget) {
 474                         case WID_SL_SORT_BYNAME:
 475                         case WID_SL_SORT_BYDATE:
 476                                 if (((_savegame_sort_order & SORT_BY_NAME) != 0) == (widget == WID_SL_SORT_BYNAME)) {
 477                                         this->DrawSortButtonState(widget, _savegame_sort_order & SORT_DESCENDING ? SBS_DOWN : SBS_UP);
 478                                 }
 479                                 break;
 480
 481                         case WID_SL_BACKGROUND: {
 482                                 static std::string path;
 483                                 static std::optional<uint64_t> free_space = std::nullopt;
 484
 485                                 if (_fios_path_changed) {
 486                                         path = FiosGetCurrentPath();
 487                                         free_space = FiosGetDiskFreeSpace(path);
 488                                         _fios_path_changed = false;
 489                                 }
 490
 491                                 Rect ir = r.Shrink(WidgetDimensions::scaled.framerect);
 492
 493                                 if (free_space.has_value()) SetDParam(0, free_space.value());
 494                                 DrawString(ir.left, ir.right, ir.top + GetCharacterHeight(FS_NORMAL), free_space.has_value() ? STR_SAVELOAD_BYTES_FREE : STR_ERROR_UNABLE_TO_READ_DRIVE);
 495                                 DrawString(ir.left, ir.right, ir.top, path, TC_BLACK);
 496                                 break;
 497                         }
 498
 499                         case WID_SL_DRIVES_DIRECTORIES_LIST: {
 500                                 const Rect br = r.Shrink(WidgetDimensions::scaled.bevel);
 501                                 GfxFillRect(br, PC_BLACK);
 502
 503                                 Rect tr = r.Shrink(WidgetDimensions::scaled.inset).WithHeight(this->resize.step_height);
 504                                 auto [first, last] = this->vscroll->GetVisibleRangeIterators(this->display_list);
 505                                 for (auto it = first; it != last; ++it) {
 506                                         const FiosItem *item = *it;
 507
 508                                         if (item == this->selected) {
 509                                                 GfxFillRect(br.left, tr.top, br.right, tr.bottom, PC_DARK_BLUE);
 510                                         } else if (item == this->highlighted) {
 511                                                 GfxFillRect(br.left, tr.top, br.right, tr.bottom, PC_VERY_DARK_BLUE);
 512                                         }
 513                                         DrawString(tr, item->title, _fios_colours[GetDetailedFileType(item->type)]);
 514                                         tr = tr.Translate(0, this->resize.step_height);
 515                                 }
 516                                 break;
 517                         }
 518
 519                         case WID_SL_DETAILS:
 520                                 this->DrawDetails(r);
 521                                 break;
 522                 }
 523         }
 524
 525         void DrawDetails(const Rect &r) const
 526         {
 527                 /* Header panel */
 528                 int HEADER_HEIGHT = GetCharacterHeight(FS_NORMAL) + WidgetDimensions::scaled.frametext.Vertical();
 529
 530                 Rect hr = r.WithHeight(HEADER_HEIGHT).Shrink(WidgetDimensions::scaled.frametext);
 531                 Rect tr = r.Shrink(WidgetDimensions::scaled.frametext);
 532                 tr.top += HEADER_HEIGHT;
 533
 534                 /* Create the nice grayish rectangle at the details top */
 535                 GfxFillRect(r.WithHeight(HEADER_HEIGHT).Shrink(WidgetDimensions::scaled.bevel.left, WidgetDimensions::scaled.bevel.top, WidgetDimensions::scaled.bevel.right, 0), PC_GREY);
 536                 DrawString(hr.left, hr.right, hr.top, STR_SAVELOAD_DETAIL_CAPTION, TC_FROMSTRING, SA_HOR_CENTER);
 537
 538                 if (this->selected == nullptr) return;
 539
 540                 /* Details panel */
 541                 tr.bottom -= GetCharacterHeight(FS_NORMAL) - 1;
 542                 if (tr.top > tr.bottom) return;
 543
 544                 if (!_load_check_data.checkable) {
 545                         /* Old savegame, no information available */
 546                         DrawString(tr, STR_SAVELOAD_DETAIL_NOT_AVAILABLE);
 547                         tr.top += GetCharacterHeight(FS_NORMAL);
 548                 } else if (_load_check_data.error != INVALID_STRING_ID) {
 549                         /* Incompatible / broken savegame */
 550                         SetDParamStr(0, _load_check_data.error_msg);
 551                         tr.top = DrawStringMultiLine(tr, _load_check_data.error, TC_RED);
 552                 } else {
 553                         /* Mapsize */
 554                         SetDParam(0, _load_check_data.map_size_x);
 555                         SetDParam(1, _load_check_data.map_size_y);
 556                         DrawString(tr, STR_NETWORK_SERVER_LIST_MAP_SIZE);
 557                         tr.top += GetCharacterHeight(FS_NORMAL);
 558                         if (tr.top > tr.bottom) return;
 559
 560                         /* Climate */
 561                         uint8_t landscape = _load_check_data.settings.game_creation.landscape;
 562                         if (landscape < NUM_LANDSCAPE) {
 563                                 SetDParam(0, STR_CLIMATE_TEMPERATE_LANDSCAPE + landscape);
 564                                 DrawString(tr, STR_NETWORK_SERVER_LIST_LANDSCAPE);
 565                                 tr.top += GetCharacterHeight(FS_NORMAL);
 566                         }
 567
 568                         tr.top += WidgetDimensions::scaled.vsep_normal;
 569                         if (tr.top > tr.bottom) return;
 570
 571                         /* Start date (if available) */
 572                         if (_load_check_data.settings.game_creation.starting_year != 0) {
 573                                 SetDParam(0, TimerGameCalendar::ConvertYMDToDate(_load_check_data.settings.game_creation.starting_year, 0, 1));
 574                                 DrawString(tr, STR_NETWORK_SERVER_LIST_START_DATE);
 575                                 tr.top += GetCharacterHeight(FS_NORMAL);
 576                         }
 577                         if (tr.top > tr.bottom) return;
 578
 579                         /* Hide current date for scenarios */
 580                         if (this->abstract_filetype != FT_SCENARIO) {
 581                                 /* Current date */
 582                                 SetDParam(0, _load_check_data.current_date);
 583                                 DrawString(tr, STR_NETWORK_SERVER_LIST_CURRENT_DATE);
 584                                 tr.top += GetCharacterHeight(FS_NORMAL);
 585                         }
 586
 587                         /* Hide the NewGRF stuff when saving. We also hide the button. */
 588                         if (this->fop == SLO_LOAD && (this->abstract_filetype == FT_SAVEGAME || this->abstract_filetype == FT_SCENARIO)) {
 589                                 tr.top += WidgetDimensions::scaled.vsep_normal;
 590                                 if (tr.top > tr.bottom) return;
 591
 592                                 /* NewGrf compatibility */
 593                                 SetDParam(0, _load_check_data.grfconfig == nullptr ? STR_NEWGRF_LIST_NONE :
 594                                                 STR_NEWGRF_LIST_ALL_FOUND + _load_check_data.grf_compatibility);
 595                                 DrawString(tr, STR_SAVELOAD_DETAIL_GRFSTATUS);
 596                                 tr.top += GetCharacterHeight(FS_NORMAL);
 597                         }
 598                         if (tr.top > tr.bottom) return;
 599
 600                         /* Hide the company stuff for scenarios */
 601                         if (this->abstract_filetype != FT_SCENARIO) {
 602                                 tr.top += WidgetDimensions::scaled.vsep_wide;
 603                                 if (tr.top > tr.bottom) return;
 604
 605                                 /* Companies / AIs */
 606                                 for (auto &pair : _load_check_data.companies) {
 607                                         SetDParam(0, pair.first + 1);
 608                                         const CompanyProperties &c = *pair.second;
 609                                         if (!c.name.empty()) {
 610                                                 SetDParam(1, STR_JUST_RAW_STRING);
 611                                                 SetDParamStr(2, c.name);
 612                                         } else {
 613                                                 SetDParam(1, c.name_1);
 614                                                 SetDParam(2, c.name_2);
 615                                         }
 616                                         DrawString(tr, STR_SAVELOAD_DETAIL_COMPANY_INDEX);
 617                                         tr.top += GetCharacterHeight(FS_NORMAL);
 618                                         if (tr.top > tr.bottom) break;
 619                                 }
 620                         }
 621                 }
 622         }
 623
 624         void UpdateWidgetSize(WidgetID widget, Dimension &size, [[maybe_unused]] const Dimension &padding, [[maybe_unused]] Dimension &fill, [[maybe_unused]] Dimension &resize) override
 625         {
 626                 switch (widget) {
 627                         case WID_SL_BACKGROUND:
 628                                 size.height = 2 * GetCharacterHeight(FS_NORMAL) + padding.height;
 629                                 break;
 630
 631                         case WID_SL_DRIVES_DIRECTORIES_LIST:
 632                                 resize.height = GetCharacterHeight(FS_NORMAL);
 633                                 size.height = resize.height * 10 + padding.height;
 634                                 break;
 635                         case WID_SL_SORT_BYNAME:
 636                         case WID_SL_SORT_BYDATE: {
 637                                 Dimension d = GetStringBoundingBox(this->GetWidget<NWidgetCore>(widget)->widget_data);
 638                                 d.width += padding.width + Window::SortButtonWidth() * 2; // Doubled since the string is centred and it also looks better.
 639                                 d.height += padding.height;
 640                                 size = maxdim(size, d);
 641                                 break;
 642                         }
 643                 }
 644         }
 645
 646         void OnPaint() override
 647         {
 648                 if (_savegame_sort_dirty) {
 649                         _savegame_sort_dirty = false;
 650                         SortSaveGameList(this->fios_items);
 651                         this->OnInvalidateData(SLIWD_FILTER_CHANGES);
 652                 }
 653
 654                 this->DrawWidgets();
 655         }
 656
 657         void OnClick([[maybe_unused]] Point pt, WidgetID widget, [[maybe_unused]] int click_count) override
 658         {
 659                 switch (widget) {
 660                         case WID_SL_SORT_BYNAME: // Sort save names by name
 661                                 _savegame_sort_order = (_savegame_sort_order == SORT_BY_NAME) ?
 662                                         SORT_BY_NAME | SORT_DESCENDING : SORT_BY_NAME;
 663                                 _savegame_sort_dirty = true;
 664                                 this->SetDirty();
 665                                 break;
 666
 667                         case WID_SL_SORT_BYDATE: // Sort save names by date
 668                                 _savegame_sort_order = (_savegame_sort_order == SORT_BY_DATE) ?
 669                                         SORT_BY_DATE | SORT_DESCENDING : SORT_BY_DATE;
 670                                 _savegame_sort_dirty = true;
 671                                 this->SetDirty();
 672                                 break;
 673
 674                         case WID_SL_HOME_BUTTON: // OpenTTD 'button', jumps to OpenTTD directory
 675                                 FiosBrowseTo(&o_dir);
 676                                 this->InvalidateData(SLIWD_RESCAN_FILES);
 677                                 break;
 678
 679                         case WID_SL_LOAD_BUTTON: {
 680                                 if (this->selected == nullptr || _load_check_data.HasErrors()) break;
 681
 682                                 _file_to_saveload.Set(*this->selected);
 683
 684                                 if (this->abstract_filetype == FT_HEIGHTMAP) {
 685                                         this->Close();
 686                                         ShowHeightmapLoad();
 687                                 } else if (this->abstract_filetype == FT_TOWN_DATA) {
 688                                         this->Close();
 689                                         LoadTownData();
 690                                 } else if (!_load_check_data.HasNewGrfs() || _load_check_data.grf_compatibility != GLC_NOT_FOUND || _settings_client.gui.UserIsAllowedToChangeNewGRFs()) {
 691                                         _switch_mode = (_game_mode == GM_EDITOR) ? SM_LOAD_SCENARIO : SM_LOAD_GAME;
 692                                         ClearErrorMessages();
 693                                         this->Close();
 694                                 }
 695                                 break;
 696                         }
 697
 698                         case WID_SL_NEWGRF_INFO:
 699                                 if (_load_check_data.HasNewGrfs()) {
 700                                         ShowNewGRFSettings(false, false, false, &_load_check_data.grfconfig);
 701                                 }
 702                                 break;
 703
 704                         case WID_SL_MISSING_NEWGRFS:
 705                                 if (!_network_available) {
 706                                         ShowErrorMessage(STR_NETWORK_ERROR_NOTAVAILABLE, INVALID_STRING_ID, WL_ERROR);
 707                                 } else if (_load_check_data.HasNewGrfs()) {
 708                                         ShowMissingContentWindow(_load_check_data.grfconfig);
 709                                 }
 710                                 break;
 711
 712                         case WID_SL_DRIVES_DIRECTORIES_LIST: { // Click the listbox
 713                                 auto it = this->vscroll->GetScrolledItemFromWidget(this->display_list, pt.y, this, WID_SL_DRIVES_DIRECTORIES_LIST, WidgetDimensions::scaled.inset.top);
 714                                 if (it == this->display_list.end()) return;
 715
 716                                 /* Get the corresponding non-filtered out item from the list */
 717                                 const FiosItem *file = *it;
 718
 719                                 if (FiosBrowseTo(file)) {
 720                                         /* Changed directory, need refresh. */
 721                                         this->InvalidateData(SLIWD_RESCAN_FILES);
 722                                         break;
 723                                 }
 724
 725                                 if (click_count == 1) {
 726                                         if (this->selected != file) {
 727                                                 this->selected = file;
 728                                                 _load_check_data.Clear();
 729
 730                                                 if (GetDetailedFileType(file->type) == DFT_GAME_FILE) {
 731                                                         /* Other detailed file types cannot be checked before. */
 732                                                         SaveOrLoad(file->name, SLO_CHECK, DFT_GAME_FILE, NO_DIRECTORY, false);
 733                                                 }
 734
 735                                                 this->InvalidateData(SLIWD_SELECTION_CHANGES);
 736                                         }
 737                                         if (this->fop == SLO_SAVE) {
 738                                                 /* Copy clicked name to editbox */
 739                                                 this->filename_editbox.text.Assign(file->title);
 740                                                 this->SetWidgetDirty(WID_SL_SAVE_OSK_TITLE);
 741                                         }
 742                                 } else if (!_load_check_data.HasErrors()) {
 743                                         this->selected = file;
 744                                         if (this->fop == SLO_LOAD) {
 745                                                 if (this->abstract_filetype == FT_SAVEGAME || this->abstract_filetype == FT_SCENARIO || this->abstract_filetype == FT_TOWN_DATA) {
 746                                                         this->OnClick(pt, WID_SL_LOAD_BUTTON, 1);
 747                                                 } else {
 748                                                         assert(this->abstract_filetype == FT_HEIGHTMAP);
 749                                                         _file_to_saveload.Set(*file);
 750
 751                                                         this->Close();
 752                                                         ShowHeightmapLoad();
 753                                                 }
 754                                         }
 755                                 }
 756                                 break;
 757                         }
 758
 759                         case WID_SL_CONTENT_DOWNLOAD:
 760                                 if (!_network_available) {
 761                                         ShowErrorMessage(STR_NETWORK_ERROR_NOTAVAILABLE, INVALID_STRING_ID, WL_ERROR);
 762                                 } else {
 763                                         assert(this->fop == SLO_LOAD);
 764                                         switch (this->abstract_filetype) {
 765                                                 default: NOT_REACHED();
 766                                                 case FT_SCENARIO:  ShowNetworkContentListWindow(nullptr, CONTENT_TYPE_SCENARIO);  break;
 767                                                 case FT_HEIGHTMAP: ShowNetworkContentListWindow(nullptr, CONTENT_TYPE_HEIGHTMAP); break;
 768                                         }
 769                                 }
 770                                 break;
 771
 772                         case WID_SL_DELETE_SELECTION: // Delete
 773                                 break;
 774
 775                         case WID_SL_SAVE_GAME: // Save game
 776                                 /* Note, this is also called via the OSK; and we need to lower the button. */
 777                                 this->HandleButtonClick(WID_SL_SAVE_GAME);
 778                                 break;
 779                 }
 780         }
 781
 782         void OnMouseOver([[maybe_unused]] Point pt, WidgetID widget) override
 783         {
 784                 if (widget == WID_SL_DRIVES_DIRECTORIES_LIST) {
 785                         auto it = this->vscroll->GetScrolledItemFromWidget(this->display_list, pt.y, this, WID_SL_DRIVES_DIRECTORIES_LIST, WidgetDimensions::scaled.inset.top);
 786                         if (it == this->display_list.end()) return;
 787
 788                         /* Get the corresponding non-filtered out item from the list */
 789                         const FiosItem *file = *it;
 790
 791                         if (file != this->highlighted) {
 792                                 this->highlighted = file;
 793                                 this->SetWidgetDirty(WID_SL_DRIVES_DIRECTORIES_LIST);
 794                         }
 795                 } else if (this->highlighted != nullptr) {
 796                         this->highlighted = nullptr;
 797                         this->SetWidgetDirty(WID_SL_DRIVES_DIRECTORIES_LIST);
 798                 }
 799         }
 800
 801         EventState OnKeyPress([[maybe_unused]] char32_t key, uint16_t keycode) override
 802         {
 803                 if (keycode == WKC_ESC) {
 804                         this->Close();
 805                         return ES_HANDLED;
 806                 }
 807
 808                 return ES_NOT_HANDLED;
 809         }
 810
 811         void OnTimeout() override
 812         {
 813                 /* Widgets WID_SL_DELETE_SELECTION and WID_SL_SAVE_GAME only exist when saving to a file. */
 814                 if (this->fop != SLO_SAVE) return;
 815
 816                 if (this->IsWidgetLowered(WID_SL_DELETE_SELECTION)) { // Delete button clicked
 817                         if (!FiosDelete(this->filename_editbox.text.buf)) {
 818                                 ShowErrorMessage(STR_ERROR_UNABLE_TO_DELETE_FILE, INVALID_STRING_ID, WL_ERROR);
 819                         } else {
 820                                 this->InvalidateData(SLIWD_RESCAN_FILES);
 821                                 /* Reset file name to current date on successful delete */
 822                                 if (this->abstract_filetype == FT_SAVEGAME) GenerateFileName();
 823                         }
 824                 } else if (this->IsWidgetLowered(WID_SL_SAVE_GAME)) { // Save button clicked
 825                         if (this->abstract_filetype == FT_SAVEGAME || this->abstract_filetype == FT_SCENARIO) {
 826                                 _file_to_saveload.name = FiosMakeSavegameName(this->filename_editbox.text.buf);
 827                                 if (FioCheckFileExists(_file_to_saveload.name, Subdirectory::SAVE_DIR)) {
 828                                         ShowQuery(STR_SAVELOAD_OVERWRITE_TITLE, STR_SAVELOAD_OVERWRITE_WARNING, this, SaveLoadWindow::SaveGameConfirmationCallback);
 829                                 } else {
 830                                         _switch_mode = SM_SAVE_GAME;
 831                                 }
 832                         } else {
 833                                 _file_to_saveload.name = FiosMakeHeightmapName(this->filename_editbox.text.buf);
 834                                 if (FioCheckFileExists(_file_to_saveload.name, Subdirectory::SAVE_DIR)) {
 835                                         ShowQuery(STR_SAVELOAD_OVERWRITE_TITLE, STR_SAVELOAD_OVERWRITE_WARNING, this, SaveLoadWindow::SaveHeightmapConfirmationCallback);
 836                                 } else {
 837                                         _switch_mode = SM_SAVE_HEIGHTMAP;
 838                                 }
 839                         }
 840
 841                         /* In the editor set up the vehicle engines correctly (date might have changed) */
 842                         if (_game_mode == GM_EDITOR) StartupEngines();
 843                 }
 844         }
 845
 846         void OnResize() override
 847         {
 848                 this->vscroll->SetCapacityFromWidget(this, WID_SL_DRIVES_DIRECTORIES_LIST);
 849         }
 850
 851         void BuildDisplayList()
 852         {
 853                 /* Filter changes */
 854                 this->display_list.clear();
 855                 this->display_list.reserve(this->fios_items.size());
 856
 857                 if (this->string_filter.IsEmpty()) {
 858                         /* We don't filter anything out if the filter editbox is empty */
 859                         for (auto &it : this->fios_items) {
 860                                 this->display_list.push_back(&it);
 861                         }
 862                 } else {
 863                         for (auto &it : this->fios_items) {
 864                                 this->string_filter.ResetState();
 865                                 this->string_filter.AddLine(it.title);
 866                                 /* We set the vector to show this fios element as filtered depending on the result of the filter */
 867                                 if (this->string_filter.GetState()) {
 868                                         this->display_list.push_back(&it);
 869                                 } else if (&it == this->selected) {
 870                                         /* The selected element has been filtered out */
 871                                         this->selected = nullptr;
 872                                         this->OnInvalidateData(SLIWD_SELECTION_CHANGES);
 873                                 }
 874                         }
 875                 }
 876
 877                 this->vscroll->SetCount(this->display_list.size());
 878         }
 879
 880         /**
 881          * Some data on this window has become invalid.
 882          * @param data Information about the changed data.
 883          * @param gui_scope Whether the call is done from GUI scope. You may not do everything when not in GUI scope. See #InvalidateWindowData() for details.
 884          */
 885         void OnInvalidateData(int data = 0, bool gui_scope = true) override
 886         {
 887                 switch (data) {
 888                         case SLIWD_RESCAN_FILES:
 889                                 /* Rescan files */
 890                                 this->selected = nullptr;
 891                                 _load_check_data.Clear();
 892                                 if (!gui_scope) break;
 893
 894                                 _fios_path_changed = true;
 895                                 this->fios_items.BuildFileList(this->abstract_filetype, this->fop, true);
 896                                 this->selected = nullptr;
 897                                 _load_check_data.Clear();
 898
 899                                 /* We reset the files filtered */
 900                                 this->OnInvalidateData(SLIWD_FILTER_CHANGES);
 901
 902                                 [[fallthrough]];
 903
 904                         case SLIWD_SELECTION_CHANGES:
 905                                 /* Selection changes */
 906                                 if (!gui_scope) break;
 907
 908                                 if (this->fop != SLO_LOAD) break;
 909
 910                                 switch (this->abstract_filetype) {
 911                                         case FT_HEIGHTMAP:
 912                                         case FT_TOWN_DATA:
 913                                                 this->SetWidgetDisabledState(WID_SL_LOAD_BUTTON, this->selected == nullptr || _load_check_data.HasErrors());
 914                                                 break;
 915
 916                                         case FT_SAVEGAME:
 917                                         case FT_SCENARIO: {
 918                                                 bool disabled = this->selected == nullptr || _load_check_data.HasErrors();
 919                                                 if (!_settings_client.gui.UserIsAllowedToChangeNewGRFs()) {
 920                                                         disabled |= _load_check_data.HasNewGrfs() && _load_check_data.grf_compatibility == GLC_NOT_FOUND;
 921                                                 }
 922                                                 this->SetWidgetDisabledState(WID_SL_LOAD_BUTTON, disabled);
 923                                                 this->SetWidgetDisabledState(WID_SL_NEWGRF_INFO, !_load_check_data.HasNewGrfs());
 924                                                 this->SetWidgetDisabledState(WID_SL_MISSING_NEWGRFS,
 925                                                                 !_load_check_data.HasNewGrfs() || _load_check_data.grf_compatibility == GLC_ALL_GOOD);
 926                                                 break;
 927                                         }
 928
 929                                         default:
 930                                                 NOT_REACHED();
 931                                 }
 932                                 break;
 933
 934                         case SLIWD_FILTER_CHANGES:
 935                                 this->BuildDisplayList();
 936                                 break;
 937                 }
 938         }
 939
 940         void OnEditboxChanged(WidgetID wid) override
 941         {
 942                 if (wid == WID_SL_FILTER) {
 943                         this->string_filter.SetFilterTerm(this->filter_editbox.text.buf);
 944                         this->InvalidateData(SLIWD_FILTER_CHANGES);
 945                 }
 946         }
 947 };
 948
 949 /** Load game/scenario */
 950 static WindowDesc _load_dialog_desc(
 951         WDP_CENTER, "load_game", 500, 294,
 952         WC_SAVELOAD, WC_NONE,
 953         0,
 954         _nested_load_dialog_widgets
 955 );
 956
 957 /** Load heightmap */
 958 static WindowDesc _load_heightmap_dialog_desc(
 959         WDP_CENTER, "load_heightmap", 257, 320,
 960         WC_SAVELOAD, WC_NONE,
 961         0,
 962         _nested_load_heightmap_dialog_widgets
 963 );
 964
 965 /** Load town data */
 966 static WindowDesc _load_town_data_dialog_desc(
 967         WDP_CENTER, "load_town_data", 257, 320,
 968         WC_SAVELOAD, WC_NONE,
 969         0,
 970         _nested_load_town_data_dialog_widgets
 971 );
 972
 973 /** Save game/scenario */
 974 static WindowDesc _save_dialog_desc(
 975         WDP_CENTER, "save_game", 500, 294,
 976         WC_SAVELOAD, WC_NONE,
 977         0,
 978         _nested_save_dialog_widgets
 979 );
 980
 981 /**
 982  * Launch save/load dialog in the given mode.
 983  * @param abstract_filetype Kind of file to handle.
 984  * @param fop File operation to perform (load or save).
 985  */
 986 void ShowSaveLoadDialog(AbstractFileType abstract_filetype, SaveLoadOperation fop)
 987 {
 988         CloseWindowById(WC_SAVELOAD, 0);
 989
 990         if (fop == SLO_SAVE) {
 991                 new SaveLoadWindow(_save_dialog_desc, abstract_filetype, fop);
 992         } else {
 993                 /* Dialogue for loading a file. */
 994                 switch (abstract_filetype) {
 995                         case FT_HEIGHTMAP:
 996                                 new SaveLoadWindow(_load_heightmap_dialog_desc, abstract_filetype, fop);
 997                                 break;
 998
 999                         case FT_TOWN_DATA:
1000                                 new SaveLoadWindow(_load_town_data_dialog_desc, abstract_filetype, fop);
1001                                 break;
1002
1003                         default:
1004                                 new SaveLoadWindow(_load_dialog_desc, abstract_filetype, fop);
1005                 }
1006         }
1007 }