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