src/settings_gui.cpp

   1 /* $Id$ */
   2
   3 /*
   4  * This file is part of OpenTTD.
   5  * 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.
   6  * 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.
   7  * 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/>.
   8  */
   9
  10 /** @file settings_gui.cpp GUI for settings. */
  11
  12 #include "stdafx.h"
  13 #include "currency.h"
  14 #include "error.h"
  15 #include "settings_gui.h"
  16 #include "textbuf_gui.h"
  17 #include "command_func.h"
  18 #include "network/network.h"
  19 #include "town.h"
  20 #include "settings_internal.h"
  21 #include "newgrf_townname.h"
  22 #include "strings_func.h"
  23 #include "window_func.h"
  24 #include "string_func.h"
  25 #include "widgets/dropdown_type.h"
  26 #include "widgets/dropdown_func.h"
  27 #include "highscore.h"
  28 #include "base_media_base.h"
  29 #include "company_base.h"
  30 #include "company_func.h"
  31 #include "viewport_func.h"
  32 #include "core/geometry_func.hpp"
  33 #include "ai/ai.hpp"
  34 #include "blitter/factory.hpp"
  35 #include "language.h"
  36 #include "textfile_gui.h"
  37 #include "stringfilter_type.h"
  38 #include "querystring_gui.h"
  39
  40 #include <vector>
  41
  42 #include "safeguards.h"
  43
  44
  45 static const StringID _driveside_dropdown[] = {
  46         STR_GAME_OPTIONS_ROAD_VEHICLES_DROPDOWN_LEFT,
  47         STR_GAME_OPTIONS_ROAD_VEHICLES_DROPDOWN_RIGHT,
  48         INVALID_STRING_ID
  49 };
  50
  51 static const StringID _autosave_dropdown[] = {
  52         STR_GAME_OPTIONS_AUTOSAVE_DROPDOWN_OFF,
  53         STR_GAME_OPTIONS_AUTOSAVE_DROPDOWN_EVERY_1_MONTH,
  54         STR_GAME_OPTIONS_AUTOSAVE_DROPDOWN_EVERY_3_MONTHS,
  55         STR_GAME_OPTIONS_AUTOSAVE_DROPDOWN_EVERY_6_MONTHS,
  56         STR_GAME_OPTIONS_AUTOSAVE_DROPDOWN_EVERY_12_MONTHS,
  57         INVALID_STRING_ID,
  58 };
  59
  60 static const StringID _gui_zoom_dropdown[] = {
  61         STR_GAME_OPTIONS_GUI_ZOOM_DROPDOWN_NORMAL,
  62         STR_GAME_OPTIONS_GUI_ZOOM_DROPDOWN_2X_ZOOM,
  63         STR_GAME_OPTIONS_GUI_ZOOM_DROPDOWN_4X_ZOOM,
  64         INVALID_STRING_ID,
  65 };
  66
  67 int _nb_orig_names = SPECSTR_TOWNNAME_LAST - SPECSTR_TOWNNAME_START + 1; ///< Number of original town names.
  68 static StringID *_grf_names = NULL; ///< Pointer to town names defined by NewGRFs.
  69 static int _nb_grf_names = 0;       ///< Number of town names defined by NewGRFs.
  70
  71 static Dimension _circle_size; ///< Dimension of the circle +/- icon. This is here as not all users are within the class of the settings window.
  72
  73 static const void *ResolveVariableAddress(const GameSettings *settings_ptr, const SettingDesc *sd);
  74
  75 /** Allocate memory for the NewGRF town names. */
  76 void InitGRFTownGeneratorNames()
  77 {
  78         free(_grf_names);
  79         _grf_names = GetGRFTownNameList();
  80         _nb_grf_names = 0;
  81         for (StringID *s = _grf_names; *s != INVALID_STRING_ID; s++) _nb_grf_names++;
  82 }
  83
  84 /**
  85  * Get a town name.
  86  * @param town_name Number of the wanted town name.
  87  * @return Name of the town as string ID.
  88  */
  89 static inline StringID TownName(int town_name)
  90 {
  91         if (town_name < _nb_orig_names) return STR_GAME_OPTIONS_TOWN_NAME_ORIGINAL_ENGLISH + town_name;
  92         town_name -= _nb_orig_names;
  93         if (town_name < _nb_grf_names) return _grf_names[town_name];
  94         return STR_UNDEFINED;
  95 }
  96
  97 /**
  98  * Get index of the current screen resolution.
  99  * @return Index of the current screen resolution if it is a known resolution, #_num_resolutions otherwise.
 100  */
 101 static int GetCurRes()
 102 {
 103         int i;
 104
 105         for (i = 0; i != _num_resolutions; i++) {
 106                 if ((int)_resolutions[i].width == _screen.width &&
 107                                 (int)_resolutions[i].height == _screen.height) {
 108                         break;
 109                 }
 110         }
 111         return i;
 112 }
 113
 114 static void ShowCustCurrency();
 115
 116 template <class T>
 117 static DropDownList *BuiltSetDropDownList(int *selected_index)
 118 {
 119         int n = T::GetNumSets();
 120         *selected_index = T::GetIndexOfUsedSet();
 121
 122         DropDownList *list = new DropDownList();
 123         for (int i = 0; i < n; i++) {
 124                 *list->Append() = new DropDownListCharStringItem(T::GetSet(i)->name, i, (_game_mode == GM_MENU) ? false : (*selected_index != i));
 125         }
 126
 127         return list;
 128 }
 129
 130 /** Window for displaying the textfile of a BaseSet. */
 131 template <class TBaseSet>
 132 struct BaseSetTextfileWindow : public TextfileWindow {
 133         const TBaseSet* baseset; ///< View the textfile of this BaseSet.
 134         StringID content_type;   ///< STR_CONTENT_TYPE_xxx for title.
 135
 136         BaseSetTextfileWindow(TextfileType file_type, const TBaseSet* baseset, StringID content_type) : TextfileWindow(file_type), baseset(baseset), content_type(content_type)
 137         {
 138                 const char *textfile = this->baseset->GetTextfile(file_type);
 139                 this->LoadTextfile(textfile, BASESET_DIR);
 140         }
 141
 142         /* virtual */ void SetStringParameters(int widget) const
 143         {
 144                 if (widget == WID_TF_CAPTION) {
 145                         SetDParam(0, content_type);
 146                         SetDParamStr(1, this->baseset->name);
 147                 }
 148         }
 149 };
 150
 151 /**
 152  * Open the BaseSet version of the textfile window.
 153  * @param file_type The type of textfile to display.
 154  * @param baseset The BaseSet to use.
 155  * @param content_type STR_CONTENT_TYPE_xxx for title.
 156  */
 157 template <class TBaseSet>
 158 void ShowBaseSetTextfileWindow(TextfileType file_type, const TBaseSet* baseset, StringID content_type)
 159 {
 160         DeleteWindowByClass(WC_TEXTFILE);
 161         new BaseSetTextfileWindow<TBaseSet>(file_type, baseset, content_type);
 162 }
 163
 164 struct GameOptionsWindow : Window {
 165         GameSettings *opt;
 166         bool reload;
 167
 168         GameOptionsWindow(WindowDesc *desc) : Window(desc)
 169         {
 170                 this->opt = &GetGameSettings();
 171                 this->reload = false;
 172
 173                 this->InitNested(WN_GAME_OPTIONS_GAME_OPTIONS);
 174                 this->OnInvalidateData(0);
 175         }
 176
 177         ~GameOptionsWindow()
 178         {
 179                 DeleteWindowById(WC_CUSTOM_CURRENCY, 0);
 180                 if (this->reload) _switch_mode = SM_MENU;
 181         }
 182
 183         /**
 184          * Build the dropdown list for a specific widget.
 185          * @param widget         Widget to build list for
 186          * @param selected_index Currently selected item
 187          * @return the built dropdown list, or NULL if the widget has no dropdown menu.
 188          */
 189         DropDownList *BuildDropDownList(int widget, int *selected_index) const
 190         {
 191                 DropDownList *list = NULL;
 192                 switch (widget) {
 193                         case WID_GO_CURRENCY_DROPDOWN: { // Setup currencies dropdown
 194                                 list = new DropDownList();
 195                                 *selected_index = this->opt->locale.currency;
 196                                 StringID *items = BuildCurrencyDropdown();
 197                                 uint64 disabled = _game_mode == GM_MENU ? 0LL : ~GetMaskOfAllowedCurrencies();
 198
 199                                 /* Add non-custom currencies; sorted naturally */
 200                                 for (uint i = 0; i < CURRENCY_END; items++, i++) {
 201                                         if (i == CURRENCY_CUSTOM) continue;
 202                                         *list->Append() = new DropDownListStringItem(*items, i, HasBit(disabled, i));
 203                                 }
 204                                 QSortT(list->Begin(), list->Length(), DropDownListStringItem::NatSortFunc);
 205
 206                                 /* Append custom currency at the end */
 207                                 *list->Append() = new DropDownListItem(-1, false); // separator line
 208                                 *list->Append() = new DropDownListStringItem(STR_GAME_OPTIONS_CURRENCY_CUSTOM, CURRENCY_CUSTOM, HasBit(disabled, CURRENCY_CUSTOM));
 209                                 break;
 210                         }
 211
 212                         case WID_GO_ROADSIDE_DROPDOWN: { // Setup road-side dropdown
 213                                 list = new DropDownList();
 214                                 *selected_index = this->opt->vehicle.road_side;
 215                                 const StringID *items = _driveside_dropdown;
 216                                 uint disabled = 0;
 217
 218                                 /* You can only change the drive side if you are in the menu or ingame with
 219                                  * no vehicles present. In a networking game only the server can change it */
 220                                 extern bool RoadVehiclesAreBuilt();
 221                                 if ((_game_mode != GM_MENU && RoadVehiclesAreBuilt()) || (_networking && !_network_server)) {
 222                                         disabled = ~(1 << this->opt->vehicle.road_side); // disable the other value
 223                                 }
 224
 225                                 for (uint i = 0; *items != INVALID_STRING_ID; items++, i++) {
 226                                         *list->Append() = new DropDownListStringItem(*items, i, HasBit(disabled, i));
 227                                 }
 228                                 break;
 229                         }
 230
 231                         case WID_GO_TOWNNAME_DROPDOWN: { // Setup townname dropdown
 232                                 list = new DropDownList();
 233                                 *selected_index = this->opt->game_creation.town_name;
 234
 235                                 int enabled_item = (_game_mode == GM_MENU || Town::GetNumItems() == 0) ? -1 : *selected_index;
 236
 237                                 /* Add and sort newgrf townnames generators */
 238                                 for (int i = 0; i < _nb_grf_names; i++) {
 239                                         int result = _nb_orig_names + i;
 240                                         *list->Append() = new DropDownListStringItem(_grf_names[i], result, enabled_item != result && enabled_item >= 0);
 241                                 }
 242                                 QSortT(list->Begin(), list->Length(), DropDownListStringItem::NatSortFunc);
 243
 244                                 int newgrf_size = list->Length();
 245                                 /* Insert newgrf_names at the top of the list */
 246                                 if (newgrf_size > 0) {
 247                                         *list->Append() = new DropDownListItem(-1, false); // separator line
 248                                         newgrf_size++;
 249                                 }
 250
 251                                 /* Add and sort original townnames generators */
 252                                 for (int i = 0; i < _nb_orig_names; i++) {
 253                                         *list->Append() = new DropDownListStringItem(STR_GAME_OPTIONS_TOWN_NAME_ORIGINAL_ENGLISH + i, i, enabled_item != i && enabled_item >= 0);
 254                                 }
 255                                 QSortT(list->Begin() + newgrf_size, list->Length() - newgrf_size, DropDownListStringItem::NatSortFunc);
 256                                 break;
 257                         }
 258
 259                         case WID_GO_AUTOSAVE_DROPDOWN: { // Setup autosave dropdown
 260                                 list = new DropDownList();
 261                                 *selected_index = _settings_client.gui.autosave;
 262                                 const StringID *items = _autosave_dropdown;
 263                                 for (uint i = 0; *items != INVALID_STRING_ID; items++, i++) {
 264                                         *list->Append() = new DropDownListStringItem(*items, i, false);
 265                                 }
 266                                 break;
 267                         }
 268
 269                         case WID_GO_LANG_DROPDOWN: { // Setup interface language dropdown
 270                                 list = new DropDownList();
 271                                 for (uint i = 0; i < _languages.Length(); i++) {
 272                                         if (&_languages[i] == _current_language) *selected_index = i;
 273                                         *list->Append() = new DropDownListStringItem(SPECSTR_LANGUAGE_START + i, i, false);
 274                                 }
 275                                 QSortT(list->Begin(), list->Length(), DropDownListStringItem::NatSortFunc);
 276                                 break;
 277                         }
 278
 279                         case WID_GO_RESOLUTION_DROPDOWN: // Setup resolution dropdown
 280                                 if (_num_resolutions == 0) break;
 281
 282                                 list = new DropDownList();
 283                                 *selected_index = GetCurRes();
 284                                 for (int i = 0; i < _num_resolutions; i++) {
 285                                         *list->Append() = new DropDownListStringItem(SPECSTR_RESOLUTION_START + i, i, false);
 286                                 }
 287                                 break;
 288
 289                         case WID_GO_GUI_ZOOM_DROPDOWN: {
 290                                 list = new DropDownList();
 291                                 *selected_index = ZOOM_LVL_OUT_4X - _gui_zoom;
 292                                 const StringID *items = _gui_zoom_dropdown;
 293                                 for (int i = 0; *items != INVALID_STRING_ID; items++, i++) {
 294                                         *list->Append() = new DropDownListStringItem(*items, i, _settings_client.gui.zoom_min > ZOOM_LVL_OUT_4X - i);
 295                                 }
 296                                 break;
 297                         }
 298
 299                         case WID_GO_BASE_GRF_DROPDOWN:
 300                                 list = BuiltSetDropDownList<BaseGraphics>(selected_index);
 301                                 break;
 302
 303                         case WID_GO_BASE_SFX_DROPDOWN:
 304                                 list = BuiltSetDropDownList<BaseSounds>(selected_index);
 305                                 break;
 306
 307                         case WID_GO_BASE_MUSIC_DROPDOWN:
 308                                 list = BuiltSetDropDownList<BaseMusic>(selected_index);
 309                                 break;
 310
 311                         default:
 312                                 return NULL;
 313                 }
 314
 315                 return list;
 316         }
 317
 318         virtual void SetStringParameters(int widget) const
 319         {
 320                 switch (widget) {
 321                         case WID_GO_CURRENCY_DROPDOWN:   SetDParam(0, _currency_specs[this->opt->locale.currency].name); break;
 322                         case WID_GO_ROADSIDE_DROPDOWN:   SetDParam(0, STR_GAME_OPTIONS_ROAD_VEHICLES_DROPDOWN_LEFT + this->opt->vehicle.road_side); break;
 323                         case WID_GO_TOWNNAME_DROPDOWN:   SetDParam(0, TownName(this->opt->game_creation.town_name)); break;
 324                         case WID_GO_AUTOSAVE_DROPDOWN:   SetDParam(0, _autosave_dropdown[_settings_client.gui.autosave]); break;
 325                         case WID_GO_LANG_DROPDOWN:       SetDParamStr(0, _current_language->own_name); break;
 326                         case WID_GO_RESOLUTION_DROPDOWN: SetDParam(0, GetCurRes() == _num_resolutions ? STR_GAME_OPTIONS_RESOLUTION_OTHER : SPECSTR_RESOLUTION_START + GetCurRes()); break;
 327                         case WID_GO_GUI_ZOOM_DROPDOWN:   SetDParam(0, _gui_zoom_dropdown[ZOOM_LVL_OUT_4X - _gui_zoom]); break;
 328                         case WID_GO_BASE_GRF_DROPDOWN:   SetDParamStr(0, BaseGraphics::GetUsedSet()->name); break;
 329                         case WID_GO_BASE_GRF_STATUS:     SetDParam(0, BaseGraphics::GetUsedSet()->GetNumInvalid()); break;
 330                         case WID_GO_BASE_SFX_DROPDOWN:   SetDParamStr(0, BaseSounds::GetUsedSet()->name); break;
 331                         case WID_GO_BASE_MUSIC_DROPDOWN: SetDParamStr(0, BaseMusic::GetUsedSet()->name); break;
 332                         case WID_GO_BASE_MUSIC_STATUS:   SetDParam(0, BaseMusic::GetUsedSet()->GetNumInvalid()); break;
 333                 }
 334         }
 335
 336         virtual void DrawWidget(const Rect &r, int widget) const
 337         {
 338                 switch (widget) {
 339                         case WID_GO_BASE_GRF_DESCRIPTION:
 340                                 SetDParamStr(0, BaseGraphics::GetUsedSet()->GetDescription(GetCurrentLanguageIsoCode()));
 341                                 DrawStringMultiLine(r.left, r.right, r.top, UINT16_MAX, STR_BLACK_RAW_STRING);
 342                                 break;
 343
 344                         case WID_GO_BASE_SFX_DESCRIPTION:
 345                                 SetDParamStr(0, BaseSounds::GetUsedSet()->GetDescription(GetCurrentLanguageIsoCode()));
 346                                 DrawStringMultiLine(r.left, r.right, r.top, UINT16_MAX, STR_BLACK_RAW_STRING);
 347                                 break;
 348
 349                         case WID_GO_BASE_MUSIC_DESCRIPTION:
 350                                 SetDParamStr(0, BaseMusic::GetUsedSet()->GetDescription(GetCurrentLanguageIsoCode()));
 351                                 DrawStringMultiLine(r.left, r.right, r.top, UINT16_MAX, STR_BLACK_RAW_STRING);
 352                                 break;
 353                 }
 354         }
 355
 356         virtual void UpdateWidgetSize(int widget, Dimension *size, const Dimension &padding, Dimension *fill, Dimension *resize)
 357         {
 358                 switch (widget) {
 359                         case WID_GO_BASE_GRF_DESCRIPTION:
 360                                 /* Find the biggest description for the default size. */
 361                                 for (int i = 0; i < BaseGraphics::GetNumSets(); i++) {
 362                                         SetDParamStr(0, BaseGraphics::GetSet(i)->GetDescription(GetCurrentLanguageIsoCode()));
 363                                         size->height = max(size->height, (uint)GetStringHeight(STR_BLACK_RAW_STRING, size->width));
 364                                 }
 365                                 break;
 366
 367                         case WID_GO_BASE_GRF_STATUS:
 368                                 /* Find the biggest description for the default size. */
 369                                 for (int i = 0; i < BaseGraphics::GetNumSets(); i++) {
 370                                         uint invalid_files = BaseGraphics::GetSet(i)->GetNumInvalid();
 371                                         if (invalid_files == 0) continue;
 372
 373                                         SetDParam(0, invalid_files);
 374                                         *size = maxdim(*size, GetStringBoundingBox(STR_GAME_OPTIONS_BASE_GRF_STATUS));
 375                                 }
 376                                 break;
 377
 378                         case WID_GO_BASE_SFX_DESCRIPTION:
 379                                 /* Find the biggest description for the default size. */
 380                                 for (int i = 0; i < BaseSounds::GetNumSets(); i++) {
 381                                         SetDParamStr(0, BaseSounds::GetSet(i)->GetDescription(GetCurrentLanguageIsoCode()));
 382                                         size->height = max(size->height, (uint)GetStringHeight(STR_BLACK_RAW_STRING, size->width));
 383                                 }
 384                                 break;
 385
 386                         case WID_GO_BASE_MUSIC_DESCRIPTION:
 387                                 /* Find the biggest description for the default size. */
 388                                 for (int i = 0; i < BaseMusic::GetNumSets(); i++) {
 389                                         SetDParamStr(0, BaseMusic::GetSet(i)->GetDescription(GetCurrentLanguageIsoCode()));
 390                                         size->height = max(size->height, (uint)GetStringHeight(STR_BLACK_RAW_STRING, size->width));
 391                                 }
 392                                 break;
 393
 394                         case WID_GO_BASE_MUSIC_STATUS:
 395                                 /* Find the biggest description for the default size. */
 396                                 for (int i = 0; i < BaseMusic::GetNumSets(); i++) {
 397                                         uint invalid_files = BaseMusic::GetSet(i)->GetNumInvalid();
 398                                         if (invalid_files == 0) continue;
 399
 400                                         SetDParam(0, invalid_files);
 401                                         *size = maxdim(*size, GetStringBoundingBox(STR_GAME_OPTIONS_BASE_MUSIC_STATUS));
 402                                 }
 403                                 break;
 404
 405                         default: {
 406                                 int selected;
 407                                 DropDownList *list = this->BuildDropDownList(widget, &selected);
 408                                 if (list != NULL) {
 409                                         /* Find the biggest item for the default size. */
 410                                         for (const DropDownListItem * const *it = list->Begin(); it != list->End(); it++) {
 411                                                 Dimension string_dim;
 412                                                 int width = (*it)->Width();
 413                                                 string_dim.width = width + padding.width;
 414                                                 string_dim.height = (*it)->Height(width) + padding.height;
 415                                                 *size = maxdim(*size, string_dim);
 416                                         }
 417                                         delete list;
 418                                 }
 419                         }
 420                 }
 421         }
 422
 423         virtual void OnClick(Point pt, int widget, int click_count)
 424         {
 425                 if (widget >= WID_GO_BASE_GRF_TEXTFILE && widget < WID_GO_BASE_GRF_TEXTFILE + TFT_END) {
 426                         if (BaseGraphics::GetUsedSet() == NULL) return;
 427
 428                         ShowBaseSetTextfileWindow((TextfileType)(widget - WID_GO_BASE_GRF_TEXTFILE), BaseGraphics::GetUsedSet(), STR_CONTENT_TYPE_BASE_GRAPHICS);
 429                         return;
 430                 }
 431                 if (widget >= WID_GO_BASE_SFX_TEXTFILE && widget < WID_GO_BASE_SFX_TEXTFILE + TFT_END) {
 432                         if (BaseSounds::GetUsedSet() == NULL) return;
 433
 434                         ShowBaseSetTextfileWindow((TextfileType)(widget - WID_GO_BASE_SFX_TEXTFILE), BaseSounds::GetUsedSet(), STR_CONTENT_TYPE_BASE_SOUNDS);
 435                         return;
 436                 }
 437                 if (widget >= WID_GO_BASE_MUSIC_TEXTFILE && widget < WID_GO_BASE_MUSIC_TEXTFILE + TFT_END) {
 438                         if (BaseMusic::GetUsedSet() == NULL) return;
 439
 440                         ShowBaseSetTextfileWindow((TextfileType)(widget - WID_GO_BASE_MUSIC_TEXTFILE), BaseMusic::GetUsedSet(), STR_CONTENT_TYPE_BASE_MUSIC);
 441                         return;
 442                 }
 443                 switch (widget) {
 444                         case WID_GO_FULLSCREEN_BUTTON: // Click fullscreen on/off
 445                                 /* try to toggle full-screen on/off */
 446                                 if (!ToggleFullScreen(!_fullscreen)) {
 447                                         ShowErrorMessage(STR_ERROR_FULLSCREEN_FAILED, INVALID_STRING_ID, WL_ERROR);
 448                                 }
 449                                 this->SetWidgetLoweredState(WID_GO_FULLSCREEN_BUTTON, _fullscreen);
 450                                 this->SetDirty();
 451                                 break;
 452
 453                         default: {
 454                                 int selected;
 455                                 DropDownList *list = this->BuildDropDownList(widget, &selected);
 456                                 if (list != NULL) {
 457                                         ShowDropDownList(this, list, selected, widget);
 458                                 } else {
 459                                         if (widget == WID_GO_RESOLUTION_DROPDOWN) ShowErrorMessage(STR_ERROR_RESOLUTION_LIST_FAILED, INVALID_STRING_ID, WL_ERROR);
 460                                 }
 461                                 break;
 462                         }
 463                 }
 464         }
 465
 466         /**
 467          * Set the base media set.
 468          * @param index the index of the media set
 469          * @tparam T class of media set
 470          */
 471         template <class T>
 472         void SetMediaSet(int index)
 473         {
 474                 if (_game_mode == GM_MENU) {
 475                         const char *name = T::GetSet(index)->name;
 476
 477                         free(T::ini_set);
 478                         T::ini_set = stredup(name);
 479
 480                         T::SetSet(name);
 481                         this->reload = true;
 482                         this->InvalidateData();
 483                 }
 484         }
 485
 486         virtual void OnDropdownSelect(int widget, int index)
 487         {
 488                 switch (widget) {
 489                         case WID_GO_CURRENCY_DROPDOWN: // Currency
 490                                 if (index == CURRENCY_CUSTOM) ShowCustCurrency();
 491                                 this->opt->locale.currency = index;
 492                                 ReInitAllWindows();
 493                                 break;
 494
 495                         case WID_GO_ROADSIDE_DROPDOWN: // Road side
 496                                 if (this->opt->vehicle.road_side != index) { // only change if setting changed
 497                                         uint i;
 498                                         if (GetSettingFromName("vehicle.road_side", &i) == NULL) NOT_REACHED();
 499                                         SetSettingValue(i, index);
 500                                         MarkWholeScreenDirty();
 501                                 }
 502                                 break;
 503
 504                         case WID_GO_TOWNNAME_DROPDOWN: // Town names
 505                                 if (_game_mode == GM_MENU || Town::GetNumItems() == 0) {
 506                                         this->opt->game_creation.town_name = index;
 507                                         SetWindowDirty(WC_GAME_OPTIONS, WN_GAME_OPTIONS_GAME_OPTIONS);
 508                                 }
 509                                 break;
 510
 511                         case WID_GO_AUTOSAVE_DROPDOWN: // Autosave options
 512                                 _settings_client.gui.autosave = index;
 513                                 this->SetDirty();
 514                                 break;
 515
 516                         case WID_GO_LANG_DROPDOWN: // Change interface language
 517                                 ReadLanguagePack(&_languages[index]);
 518                                 DeleteWindowByClass(WC_QUERY_STRING);
 519                                 CheckForMissingGlyphs();
 520                                 UpdateAllVirtCoords();
 521                                 ReInitAllWindows();
 522                                 break;
 523
 524                         case WID_GO_RESOLUTION_DROPDOWN: // Change resolution
 525                                 if (index < _num_resolutions && ChangeResInGame(_resolutions[index].width, _resolutions[index].height)) {
 526                                         this->SetDirty();
 527                                 }
 528                                 break;
 529
 530                         case WID_GO_GUI_ZOOM_DROPDOWN:
 531                                 extern void UpdateFontHeightCache();
 532                                 GfxClearSpriteCache();
 533                                 _gui_zoom = (ZoomLevel)(ZOOM_LVL_OUT_4X - index);
 534                                 UpdateCursorSize();
 535                                 UpdateFontHeightCache();
 536                                 LoadStringWidthTable();
 537                                 UpdateAllVirtCoords();
 538                                 break;
 539
 540                         case WID_GO_BASE_GRF_DROPDOWN:
 541                                 this->SetMediaSet<BaseGraphics>(index);
 542                                 break;
 543
 544                         case WID_GO_BASE_SFX_DROPDOWN:
 545                                 this->SetMediaSet<BaseSounds>(index);
 546                                 break;
 547
 548                         case WID_GO_BASE_MUSIC_DROPDOWN:
 549                                 this->SetMediaSet<BaseMusic>(index);
 550                                 break;
 551                 }
 552         }
 553
 554         /**
 555          * Some data on this window has become invalid.
 556          * @param data Information about the changed data. @see GameOptionsInvalidationData
 557          * @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.
 558          */
 559         virtual void OnInvalidateData(int data = 0, bool gui_scope = true)
 560         {
 561                 if (!gui_scope) return;
 562                 this->SetWidgetLoweredState(WID_GO_FULLSCREEN_BUTTON, _fullscreen);
 563
 564                 bool missing_files = BaseGraphics::GetUsedSet()->GetNumMissing() == 0;
 565                 this->GetWidget<NWidgetCore>(WID_GO_BASE_GRF_STATUS)->SetDataTip(missing_files ? STR_EMPTY : STR_GAME_OPTIONS_BASE_GRF_STATUS, STR_NULL);
 566
 567                 for (TextfileType tft = TFT_BEGIN; tft < TFT_END; tft++) {
 568                         this->SetWidgetDisabledState(WID_GO_BASE_GRF_TEXTFILE + tft, BaseGraphics::GetUsedSet() == NULL || BaseGraphics::GetUsedSet()->GetTextfile(tft) == NULL);
 569                         this->SetWidgetDisabledState(WID_GO_BASE_SFX_TEXTFILE + tft, BaseSounds::GetUsedSet() == NULL || BaseSounds::GetUsedSet()->GetTextfile(tft) == NULL);
 570                         this->SetWidgetDisabledState(WID_GO_BASE_MUSIC_TEXTFILE + tft, BaseMusic::GetUsedSet() == NULL || BaseMusic::GetUsedSet()->GetTextfile(tft) == NULL);
 571                 }
 572
 573                 missing_files = BaseMusic::GetUsedSet()->GetNumInvalid() == 0;
 574                 this->GetWidget<NWidgetCore>(WID_GO_BASE_MUSIC_STATUS)->SetDataTip(missing_files ? STR_EMPTY : STR_GAME_OPTIONS_BASE_MUSIC_STATUS, STR_NULL);
 575         }
 576 };
 577
 578 static const NWidgetPart _nested_game_options_widgets[] = {
 579         NWidget(NWID_HORIZONTAL),
 580                 NWidget(WWT_CLOSEBOX, COLOUR_GREY),
 581                 NWidget(WWT_CAPTION, COLOUR_GREY), SetDataTip(STR_GAME_OPTIONS_CAPTION, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
 582         EndContainer(),
 583         NWidget(WWT_PANEL, COLOUR_GREY, WID_GO_BACKGROUND), SetPIP(6, 6, 10),
 584                 NWidget(NWID_HORIZONTAL), SetPIP(10, 10, 10),
 585                         NWidget(NWID_VERTICAL), SetPIP(0, 6, 0),
 586                                 NWidget(WWT_FRAME, COLOUR_GREY), SetDataTip(STR_GAME_OPTIONS_ROAD_VEHICLES_FRAME, STR_NULL),
 587                                         NWidget(WWT_DROPDOWN, COLOUR_GREY, WID_GO_ROADSIDE_DROPDOWN), SetMinimalSize(150, 12), SetDataTip(STR_BLACK_STRING, STR_GAME_OPTIONS_ROAD_VEHICLES_DROPDOWN_TOOLTIP), SetFill(1, 0),
 588                                 EndContainer(),
 589                                 NWidget(WWT_FRAME, COLOUR_GREY), SetDataTip(STR_GAME_OPTIONS_AUTOSAVE_FRAME, STR_NULL),
 590                                         NWidget(WWT_DROPDOWN, COLOUR_GREY, WID_GO_AUTOSAVE_DROPDOWN), SetMinimalSize(150, 12), SetDataTip(STR_BLACK_STRING, STR_GAME_OPTIONS_AUTOSAVE_DROPDOWN_TOOLTIP), SetFill(1, 0),
 591                                 EndContainer(),
 592                                 NWidget(WWT_FRAME, COLOUR_GREY), SetDataTip(STR_GAME_OPTIONS_RESOLUTION, STR_NULL),
 593                                         NWidget(WWT_DROPDOWN, COLOUR_GREY, WID_GO_RESOLUTION_DROPDOWN), SetMinimalSize(150, 12), SetDataTip(STR_BLACK_STRING, STR_GAME_OPTIONS_RESOLUTION_TOOLTIP), SetFill(1, 0), SetPadding(0, 0, 3, 0),
 594                                         NWidget(NWID_HORIZONTAL),
 595                                                 NWidget(WWT_TEXT, COLOUR_GREY), SetMinimalSize(0, 12), SetFill(1, 0), SetDataTip(STR_GAME_OPTIONS_FULLSCREEN, STR_NULL),
 596                                                 NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_GO_FULLSCREEN_BUTTON), SetMinimalSize(21, 9), SetDataTip(STR_EMPTY, STR_GAME_OPTIONS_FULLSCREEN_TOOLTIP),
 597                                         EndContainer(),
 598                                 EndContainer(),
 599                                 NWidget(WWT_FRAME, COLOUR_GREY), SetDataTip(STR_GAME_OPTIONS_GUI_ZOOM_FRAME, STR_NULL),
 600                                         NWidget(WWT_DROPDOWN, COLOUR_GREY, WID_GO_GUI_ZOOM_DROPDOWN), SetMinimalSize(150, 12), SetDataTip(STR_BLACK_STRING, STR_GAME_OPTIONS_GUI_ZOOM_DROPDOWN_TOOLTIP), SetFill(1, 0),
 601                                 EndContainer(),
 602                         EndContainer(),
 603
 604                         NWidget(NWID_VERTICAL), SetPIP(0, 6, 0),
 605                                 NWidget(WWT_FRAME, COLOUR_GREY), SetDataTip(STR_GAME_OPTIONS_TOWN_NAMES_FRAME, STR_NULL),
 606                                         NWidget(WWT_DROPDOWN, COLOUR_GREY, WID_GO_TOWNNAME_DROPDOWN), SetMinimalSize(150, 12), SetDataTip(STR_BLACK_STRING, STR_GAME_OPTIONS_TOWN_NAMES_DROPDOWN_TOOLTIP), SetFill(1, 0),
 607                                 EndContainer(),
 608                                 NWidget(WWT_FRAME, COLOUR_GREY), SetDataTip(STR_GAME_OPTIONS_LANGUAGE, STR_NULL),
 609                                         NWidget(WWT_DROPDOWN, COLOUR_GREY, WID_GO_LANG_DROPDOWN), SetMinimalSize(150, 12), SetDataTip(STR_BLACK_RAW_STRING, STR_GAME_OPTIONS_LANGUAGE_TOOLTIP), SetFill(1, 0),
 610                                 EndContainer(),
 611                                 NWidget(WWT_FRAME, COLOUR_GREY), SetDataTip(STR_GAME_OPTIONS_CURRENCY_UNITS_FRAME, STR_NULL),
 612                                         NWidget(WWT_DROPDOWN, COLOUR_GREY, WID_GO_CURRENCY_DROPDOWN), SetMinimalSize(150, 12), SetDataTip(STR_BLACK_STRING, STR_GAME_OPTIONS_CURRENCY_UNITS_DROPDOWN_TOOLTIP), SetFill(1, 0),
 613                                 EndContainer(),
 614                                 NWidget(NWID_SPACER), SetMinimalSize(0, 0), SetFill(0, 1),
 615                         EndContainer(),
 616                 EndContainer(),
 617
 618                 NWidget(WWT_FRAME, COLOUR_GREY), SetDataTip(STR_GAME_OPTIONS_BASE_GRF, STR_NULL), SetPadding(0, 10, 0, 10),
 619                         NWidget(NWID_HORIZONTAL), SetPIP(0, 30, 0),
 620                                 NWidget(WWT_DROPDOWN, COLOUR_GREY, WID_GO_BASE_GRF_DROPDOWN), SetMinimalSize(150, 12), SetDataTip(STR_BLACK_RAW_STRING, STR_GAME_OPTIONS_BASE_GRF_TOOLTIP),
 621                                 NWidget(WWT_TEXT, COLOUR_GREY, WID_GO_BASE_GRF_STATUS), SetMinimalSize(150, 12), SetDataTip(STR_EMPTY, STR_NULL), SetFill(1, 0),
 622                         EndContainer(),
 623                         NWidget(WWT_TEXT, COLOUR_GREY, WID_GO_BASE_GRF_DESCRIPTION), SetMinimalSize(330, 0), SetDataTip(STR_EMPTY, STR_GAME_OPTIONS_BASE_GRF_DESCRIPTION_TOOLTIP), SetFill(1, 0), SetPadding(6, 0, 6, 0),
 624                         NWidget(NWID_HORIZONTAL, NC_EQUALSIZE), SetPIP(7, 0, 7),
 625                                 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_GO_BASE_GRF_TEXTFILE + TFT_README), SetFill(1, 0), SetResize(1, 0), SetDataTip(STR_TEXTFILE_VIEW_README, STR_NULL),
 626                                 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_GO_BASE_GRF_TEXTFILE + TFT_CHANGELOG), SetFill(1, 0), SetResize(1, 0), SetDataTip(STR_TEXTFILE_VIEW_CHANGELOG, STR_NULL),
 627                                 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_GO_BASE_GRF_TEXTFILE + TFT_LICENSE), SetFill(1, 0), SetResize(1, 0), SetDataTip(STR_TEXTFILE_VIEW_LICENCE, STR_NULL),
 628                         EndContainer(),
 629                 EndContainer(),
 630
 631                 NWidget(WWT_FRAME, COLOUR_GREY), SetDataTip(STR_GAME_OPTIONS_BASE_SFX, STR_NULL), SetPadding(0, 10, 0, 10),
 632                         NWidget(NWID_HORIZONTAL), SetPIP(0, 30, 0),
 633                                 NWidget(WWT_DROPDOWN, COLOUR_GREY, WID_GO_BASE_SFX_DROPDOWN), SetMinimalSize(150, 12), SetDataTip(STR_BLACK_RAW_STRING, STR_GAME_OPTIONS_BASE_SFX_TOOLTIP),
 634                                 NWidget(NWID_SPACER), SetFill(1, 0),
 635                         EndContainer(),
 636                         NWidget(WWT_TEXT, COLOUR_GREY, WID_GO_BASE_SFX_DESCRIPTION), SetMinimalSize(330, 0), SetDataTip(STR_EMPTY, STR_GAME_OPTIONS_BASE_SFX_DESCRIPTION_TOOLTIP), SetFill(1, 0), SetPadding(6, 0, 6, 0),
 637                         NWidget(NWID_HORIZONTAL, NC_EQUALSIZE), SetPIP(7, 0, 7),
 638                                 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_GO_BASE_SFX_TEXTFILE + TFT_README), SetFill(1, 0), SetResize(1, 0), SetDataTip(STR_TEXTFILE_VIEW_README, STR_NULL),
 639                                 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_GO_BASE_SFX_TEXTFILE + TFT_CHANGELOG), SetFill(1, 0), SetResize(1, 0), SetDataTip(STR_TEXTFILE_VIEW_CHANGELOG, STR_NULL),
 640                                 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_GO_BASE_SFX_TEXTFILE + TFT_LICENSE), SetFill(1, 0), SetResize(1, 0), SetDataTip(STR_TEXTFILE_VIEW_LICENCE, STR_NULL),
 641                         EndContainer(),
 642                 EndContainer(),
 643
 644                 NWidget(WWT_FRAME, COLOUR_GREY), SetDataTip(STR_GAME_OPTIONS_BASE_MUSIC, STR_NULL), SetPadding(0, 10, 0, 10),
 645                         NWidget(NWID_HORIZONTAL), SetPIP(0, 30, 0),
 646                                 NWidget(WWT_DROPDOWN, COLOUR_GREY, WID_GO_BASE_MUSIC_DROPDOWN), SetMinimalSize(150, 12), SetDataTip(STR_BLACK_RAW_STRING, STR_GAME_OPTIONS_BASE_MUSIC_TOOLTIP),
 647                                 NWidget(WWT_TEXT, COLOUR_GREY, WID_GO_BASE_MUSIC_STATUS), SetMinimalSize(150, 12), SetDataTip(STR_EMPTY, STR_NULL), SetFill(1, 0),
 648                         EndContainer(),
 649                         NWidget(WWT_TEXT, COLOUR_GREY, WID_GO_BASE_MUSIC_DESCRIPTION), SetMinimalSize(330, 0), SetDataTip(STR_EMPTY, STR_GAME_OPTIONS_BASE_MUSIC_DESCRIPTION_TOOLTIP), SetFill(1, 0), SetPadding(6, 0, 6, 0),
 650                         NWidget(NWID_HORIZONTAL, NC_EQUALSIZE), SetPIP(7, 0, 7),
 651                                 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_GO_BASE_MUSIC_TEXTFILE + TFT_README), SetFill(1, 0), SetResize(1, 0), SetDataTip(STR_TEXTFILE_VIEW_README, STR_NULL),
 652                                 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_GO_BASE_MUSIC_TEXTFILE + TFT_CHANGELOG), SetFill(1, 0), SetResize(1, 0), SetDataTip(STR_TEXTFILE_VIEW_CHANGELOG, STR_NULL),
 653                                 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_GO_BASE_MUSIC_TEXTFILE + TFT_LICENSE), SetFill(1, 0), SetResize(1, 0), SetDataTip(STR_TEXTFILE_VIEW_LICENCE, STR_NULL),
 654                         EndContainer(),
 655                 EndContainer(),
 656         EndContainer(),
 657 };
 658
 659 static WindowDesc _game_options_desc(
 660         WDP_CENTER, "settings_game", 0, 0,
 661         WC_GAME_OPTIONS, WC_NONE,
 662         0,
 663         _nested_game_options_widgets, lengthof(_nested_game_options_widgets)
 664 );
 665
 666 /** Open the game options window. */
 667 void ShowGameOptions()
 668 {
 669         DeleteWindowByClass(WC_GAME_OPTIONS);
 670         new GameOptionsWindow(&_game_options_desc);
 671 }
 672
 673 static int SETTING_HEIGHT = 11;    ///< Height of a single setting in the tree view in pixels
 674 static const int LEVEL_WIDTH = 15; ///< Indenting width of a sub-page in pixels
 675
 676 /**
 677  * Flags for #SettingEntry
 678  * @note The #SEF_BUTTONS_MASK matches expectations of the formal parameter 'state' of #DrawArrowButtons
 679  */
 680 enum SettingEntryFlags {
 681         SEF_LEFT_DEPRESSED  = 0x01, ///< Of a numeric setting entry, the left button is depressed
 682         SEF_RIGHT_DEPRESSED = 0x02, ///< Of a numeric setting entry, the right button is depressed
 683         SEF_BUTTONS_MASK = (SEF_LEFT_DEPRESSED | SEF_RIGHT_DEPRESSED), ///< Bit-mask for button flags
 684
 685         SEF_LAST_FIELD = 0x04, ///< This entry is the last one in a (sub-)page
 686         SEF_FILTERED   = 0x08, ///< Entry is hidden by the string filter
 687 };
 688
 689 /** How the list of advanced settings is filtered. */
 690 enum RestrictionMode {
 691         RM_BASIC,                            ///< Display settings associated to the "basic" list.
 692         RM_ADVANCED,                         ///< Display settings associated to the "advanced" list.
 693         RM_ALL,                              ///< List all settings regardless of the default/newgame/... values.
 694         RM_CHANGED_AGAINST_DEFAULT,          ///< Show only settings which are different compared to default values.
 695         RM_CHANGED_AGAINST_NEW,              ///< Show only settings which are different compared to the user's new game setting values.
 696         RM_END,                              ///< End for iteration.
 697 };
 698 DECLARE_POSTFIX_INCREMENT(RestrictionMode)
 699
 700 /** Filter for settings list. */
 701 struct SettingFilter {
 702         StringFilter string;     ///< Filter string.
 703         RestrictionMode min_cat; ///< Minimum category needed to display all filtered strings (#RM_BASIC, #RM_ADVANCED, or #RM_ALL).
 704         bool type_hides;         ///< Whether the type hides filtered strings.
 705         RestrictionMode mode;    ///< Filter based on category.
 706         SettingType type;        ///< Filter based on type.
 707 };
 708
 709 /** Data structure describing a single setting in a tab */
 710 struct BaseSettingEntry {
 711         byte flags; ///< Flags of the setting entry. @see SettingEntryFlags
 712         byte level; ///< Nesting level of this setting entry
 713
 714         BaseSettingEntry() : flags(0), level(0) {}
 715         virtual ~BaseSettingEntry() {}
 716
 717         virtual void Init(byte level = 0);
 718         virtual void FoldAll() {}
 719         virtual void UnFoldAll() {}
 720
 721         /**
 722          * Set whether this is the last visible entry of the parent node.
 723          * @param last_field Value to set
 724          */
 725         void SetLastField(bool last_field) { if (last_field) SETBITS(this->flags, SEF_LAST_FIELD); else CLRBITS(this->flags, SEF_LAST_FIELD); }
 726
 727         virtual uint Length() const = 0;
 728         virtual void GetFoldingState(bool &all_folded, bool &all_unfolded) const {}
 729         virtual bool IsVisible(const BaseSettingEntry *item) const;
 730         virtual BaseSettingEntry *FindEntry(uint row, uint *cur_row);
 731         virtual uint GetMaxHelpHeight(int maxw) { return 0; }
 732
 733         /**
 734          * Check whether an entry is hidden due to filters
 735          * @return true if hidden.
 736          */
 737         bool IsFiltered() const { return (this->flags & SEF_FILTERED) != 0; }
 738
 739         virtual bool UpdateFilterState(SettingFilter &filter, bool force_visible) = 0;
 740
 741         virtual uint Draw(GameSettings *settings_ptr, int left, int right, int y, uint first_row, uint max_row, BaseSettingEntry *selected, uint cur_row = 0, uint parent_last = 0) const;
 742
 743 protected:
 744         virtual void DrawSetting(GameSettings *settings_ptr, int left, int right, int y, bool highlight) const = 0;
 745 };
 746
 747 /** Standard setting */
 748 struct SettingEntry : BaseSettingEntry {
 749         const char *name;           ///< Name of the setting
 750         const SettingDesc *setting; ///< Setting description of the setting
 751         uint index;                 ///< Index of the setting in the settings table
 752
 753         SettingEntry(const char *name);
 754
 755         virtual void Init(byte level = 0);
 756         virtual uint Length() const;
 757         virtual uint GetMaxHelpHeight(int maxw);
 758         virtual bool UpdateFilterState(SettingFilter &filter, bool force_visible);
 759
 760         void SetButtons(byte new_val);
 761
 762         /**
 763          * Get the help text of a single setting.
 764          * @return The requested help text.
 765          */
 766         inline StringID GetHelpText() const
 767         {
 768                 return this->setting->desc.str_help;
 769         }
 770
 771         void SetValueDParams(uint first_param, int32 value) const;
 772
 773 protected:
 774         virtual void DrawSetting(GameSettings *settings_ptr, int left, int right, int y, bool highlight) const;
 775
 776 private:
 777         bool IsVisibleByRestrictionMode(RestrictionMode mode) const;
 778 };
 779
 780 /** Containers for BaseSettingEntry */
 781 struct SettingsContainer {
 782         typedef std::vector<BaseSettingEntry*> EntryVector;
 783         EntryVector entries; ///< Settings on this page
 784
 785         template<typename T>
 786         T *Add(T *item)
 787         {
 788                 this->entries.push_back(item);
 789                 return item;
 790         }
 791
 792         void Init(byte level = 0);
 793         void FoldAll();
 794         void UnFoldAll();
 795
 796         uint Length() const;
 797         void GetFoldingState(bool &all_folded, bool &all_unfolded) const;
 798         bool IsVisible(const BaseSettingEntry *item) const;
 799         BaseSettingEntry *FindEntry(uint row, uint *cur_row);
 800         uint GetMaxHelpHeight(int maxw);
 801
 802         bool UpdateFilterState(SettingFilter &filter, bool force_visible);
 803
 804         uint Draw(GameSettings *settings_ptr, int left, int right, int y, uint first_row, uint max_row, BaseSettingEntry *selected, uint cur_row = 0, uint parent_last = 0) const;
 805 };
 806
 807 /** Data structure describing one page of settings in the settings window. */
 808 struct SettingsPage : BaseSettingEntry, SettingsContainer {
 809         StringID title;     ///< Title of the sub-page
 810         bool folded;        ///< Sub-page is folded (not visible except for its title)
 811
 812         SettingsPage(StringID title);
 813
 814         virtual void Init(byte level = 0);
 815         virtual void FoldAll();
 816         virtual void UnFoldAll();
 817
 818         virtual uint Length() const;
 819         virtual void GetFoldingState(bool &all_folded, bool &all_unfolded) const;
 820         virtual bool IsVisible(const BaseSettingEntry *item) const;
 821         virtual BaseSettingEntry *FindEntry(uint row, uint *cur_row);
 822         virtual uint GetMaxHelpHeight(int maxw) { return SettingsContainer::GetMaxHelpHeight(maxw); }
 823
 824         virtual bool UpdateFilterState(SettingFilter &filter, bool force_visible);
 825
 826         virtual uint Draw(GameSettings *settings_ptr, int left, int right, int y, uint first_row, uint max_row, BaseSettingEntry *selected, uint cur_row = 0, uint parent_last = 0) const;
 827
 828 protected:
 829         virtual void DrawSetting(GameSettings *settings_ptr, int left, int right, int y, bool highlight) const;
 830 };
 831
 832 /* == BaseSettingEntry methods == */
 833
 834 /**
 835  * Initialization of a setting entry
 836  * @param level      Page nesting level of this entry
 837  */
 838 void BaseSettingEntry::Init(byte level)
 839 {
 840         this->level = level;
 841 }
 842
 843 /**
 844  * Check whether an entry is visible and not folded or filtered away.
 845  * Note: This does not consider the scrolling range; it might still require scrolling to make the setting really visible.
 846  * @param item Entry to search for.
 847  * @return true if entry is visible.
 848  */
 849 bool BaseSettingEntry::IsVisible(const BaseSettingEntry *item) const
 850 {
 851         if (this->IsFiltered()) return false;
 852         if (this == item) return true;
 853         return false;
 854 }
 855
 856 /**
 857  * Find setting entry at row \a row_num
 858  * @param row_num Index of entry to return
 859  * @param cur_row Current row number
 860  * @return The requested setting entry or \c NULL if it not found (folded or filtered)
 861  */
 862 BaseSettingEntry *BaseSettingEntry::FindEntry(uint row_num, uint *cur_row)
 863 {
 864         if (this->IsFiltered()) return NULL;
 865         if (row_num == *cur_row) return this;
 866         (*cur_row)++;
 867         return NULL;
 868 }
 869
 870 /**
 871  * Draw a row in the settings panel.
 872  *
 873  * The scrollbar uses rows of the page, while the page data structure is a tree of #SettingsPage and #SettingEntry objects.
 874  * As a result, the drawing routing traverses the tree from top to bottom, counting rows in \a cur_row until it reaches \a first_row.
 875  * Then it enables drawing rows while traversing until \a max_row is reached, at which point drawing is terminated.
 876  *
 877  * The \a parent_last parameter ensures that the vertical lines at the left are
 878  * only drawn when another entry follows, that it prevents output like
 879  * \verbatim
 880  *  |-- setting
 881  *  |-- (-) - Title
 882  *  |    |-- setting
 883  *  |    |-- setting
 884  * \endverbatim
 885  * The left-most vertical line is not wanted. It is prevented by setting the
 886  * appropriate bit in the \a parent_last parameter.
 887  *
 888  * @param settings_ptr Pointer to current values of all settings
 889  * @param left         Left-most position in window/panel to start drawing \a first_row
 890  * @param right        Right-most x position to draw strings at.
 891  * @param y            Upper-most position in window/panel to start drawing \a first_row
 892  * @param first_row    First row number to draw
 893  * @param max_row      Row-number to stop drawing (the row-number of the row below the last row to draw)
 894  * @param selected     Selected entry by the user.
 895  * @param cur_row      Current row number (internal variable)
 896  * @param parent_last  Last-field booleans of parent page level (page level \e i sets bit \e i to 1 if it is its last field)
 897  * @return Row number of the next row to draw
 898  */
 899 uint BaseSettingEntry::Draw(GameSettings *settings_ptr, int left, int right, int y, uint first_row, uint max_row, BaseSettingEntry *selected, uint cur_row, uint parent_last) const
 900 {
 901         if (this->IsFiltered()) return cur_row;
 902         if (cur_row >= max_row) return cur_row;
 903
 904         bool rtl = _current_text_dir == TD_RTL;
 905         int offset = rtl ? -4 : 4;
 906         int level_width = rtl ? -LEVEL_WIDTH : LEVEL_WIDTH;
 907
 908         int x = rtl ? right : left;
 909         if (cur_row >= first_row) {
 910                 int colour = _colour_gradient[COLOUR_ORANGE][4];
 911                 y += (cur_row - first_row) * SETTING_HEIGHT; // Compute correct y start position
 912
 913                 /* Draw vertical for parent nesting levels */
 914                 for (uint lvl = 0; lvl < this->level; lvl++) {
 915                         if (!HasBit(parent_last, lvl)) GfxDrawLine(x + offset, y, x + offset, y + SETTING_HEIGHT - 1, colour);
 916                         x += level_width;
 917                 }
 918                 /* draw own |- prefix */
 919                 int halfway_y = y + SETTING_HEIGHT / 2;
 920                 int bottom_y = (flags & SEF_LAST_FIELD) ? halfway_y : y + SETTING_HEIGHT - 1;
 921                 GfxDrawLine(x + offset, y, x + offset, bottom_y, colour);
 922                 /* Small horizontal line from the last vertical line */
 923                 GfxDrawLine(x + offset, halfway_y, x + level_width - offset, halfway_y, colour);
 924                 x += level_width;
 925
 926                 this->DrawSetting(settings_ptr, rtl ? left : x, rtl ? x : right, y, this == selected);
 927         }
 928         cur_row++;
 929
 930         return cur_row;
 931 }
 932
 933 /* == SettingEntry methods == */
 934
 935 /**
 936  * Constructor for a single setting in the 'advanced settings' window
 937  * @param name Name of the setting in the setting table
 938  */
 939 SettingEntry::SettingEntry(const char *name)
 940 {
 941         this->name = name;
 942         this->setting = NULL;
 943         this->index = 0;
 944 }
 945
 946 /**
 947  * Initialization of a setting entry
 948  * @param level      Page nesting level of this entry
 949  */
 950 void SettingEntry::Init(byte level)
 951 {
 952         BaseSettingEntry::Init(level);
 953         this->setting = GetSettingFromName(this->name, &this->index);
 954         assert(this->setting != NULL);
 955 }
 956
 957 /**
 958  * Set the button-depressed flags (#SEF_LEFT_DEPRESSED and #SEF_RIGHT_DEPRESSED) to a specified value
 959  * @param new_val New value for the button flags
 960  * @see SettingEntryFlags
 961  */
 962 void SettingEntry::SetButtons(byte new_val)
 963 {
 964         assert((new_val & ~SEF_BUTTONS_MASK) == 0); // Should not touch any flags outside the buttons
 965         this->flags = (this->flags & ~SEF_BUTTONS_MASK) | new_val;
 966 }
 967
 968 /** Return number of rows needed to display the (filtered) entry */
 969 uint SettingEntry::Length() const
 970 {
 971         return this->IsFiltered() ? 0 : 1;
 972 }
 973
 974 /**
 975  * Get the biggest height of the help text(s), if the width is at least \a maxw. Help text gets wrapped if needed.
 976  * @param maxw Maximal width of a line help text.
 977  * @return Biggest height needed to display any help text of this node (and its descendants).
 978  */
 979 uint SettingEntry::GetMaxHelpHeight(int maxw)
 980 {
 981         return GetStringHeight(this->GetHelpText(), maxw);
 982 }
 983
 984 /**
 985  * Checks whether an entry shall be made visible based on the restriction mode.
 986  * @param mode The current status of the restriction drop down box.
 987  * @return true if the entry shall be visible.
 988  */
 989 bool SettingEntry::IsVisibleByRestrictionMode(RestrictionMode mode) const
 990 {
 991         /* There shall not be any restriction, i.e. all settings shall be visible. */
 992         if (mode == RM_ALL) return true;
 993
 994         GameSettings *settings_ptr = &GetGameSettings();
 995         const SettingDesc *sd = this->setting;
 996
 997         if (mode == RM_BASIC) return (this->setting->desc.cat & SC_BASIC_LIST) != 0;
 998         if (mode == RM_ADVANCED) return (this->setting->desc.cat & SC_ADVANCED_LIST) != 0;
 999
1000         /* Read the current value. */
1001         const void *var = ResolveVariableAddress(settings_ptr, sd);
1002         int64 current_value = ReadValue(var, sd->save.conv);
1003
1004         int64 filter_value;
1005
1006         if (mode == RM_CHANGED_AGAINST_DEFAULT) {
1007                 /* This entry shall only be visible, if the value deviates from its default value. */
1008
1009                 /* Read the default value. */
1010                 filter_value = ReadValue(&sd->desc.def, sd->save.conv);
1011         } else {
1012                 assert(mode == RM_CHANGED_AGAINST_NEW);
1013                 /* This entry shall only be visible, if the value deviates from
1014                  * its value is used when starting a new game. */
1015
1016                 /* Make sure we're not comparing the new game settings against itself. */
1017                 assert(settings_ptr != &_settings_newgame);
1018
1019                 /* Read the new game's value. */
1020                 var = ResolveVariableAddress(&_settings_newgame, sd);
1021                 filter_value = ReadValue(var, sd->save.conv);
1022         }
1023
1024         return current_value != filter_value;
1025 }
1026
1027 /**
1028  * Update the filter state.
1029  * @param filter Filter
1030  * @param force_visible Whether to force all items visible, no matter what (due to filter text; not affected by restriction drop down box).
1031  * @return true if item remains visible
1032  */
1033 bool SettingEntry::UpdateFilterState(SettingFilter &filter, bool force_visible)
1034 {
1035         CLRBITS(this->flags, SEF_FILTERED);
1036
1037         bool visible = true;
1038
1039         const SettingDesc *sd = this->setting;
1040         if (!force_visible && !filter.string.IsEmpty()) {
1041                 /* Process the search text filter for this item. */
1042                 filter.string.ResetState();
1043
1044                 const SettingDescBase *sdb = &sd->desc;
1045
1046                 SetDParam(0, STR_EMPTY);
1047                 filter.string.AddLine(sdb->str);
1048                 filter.string.AddLine(this->GetHelpText());
1049
1050                 visible = filter.string.GetState();
1051         }
1052
1053         if (visible) {
1054                 if (filter.type != ST_ALL && sd->GetType() != filter.type) {
1055                         filter.type_hides = true;
1056                         visible = false;
1057                 }
1058                 if (!this->IsVisibleByRestrictionMode(filter.mode)) {
1059                         while (filter.min_cat < RM_ALL && (filter.min_cat == filter.mode || !this->IsVisibleByRestrictionMode(filter.min_cat))) filter.min_cat++;
1060                         visible = false;
1061                 }
1062         }
1063
1064         if (!visible) SETBITS(this->flags, SEF_FILTERED);
1065         return visible;
1066 }
1067
1068
1069 static const void *ResolveVariableAddress(const GameSettings *settings_ptr, const SettingDesc *sd)
1070 {
1071         if ((sd->desc.flags & SGF_PER_COMPANY) != 0) {
1072                 if (Company::IsValidID(_local_company) && _game_mode != GM_MENU) {
1073                         return GetVariableAddress(&Company::Get(_local_company)->settings, &sd->save);
1074                 } else {
1075                         return GetVariableAddress(&_settings_client.company, &sd->save);
1076                 }
1077         } else {
1078                 return GetVariableAddress(settings_ptr, &sd->save);
1079         }
1080 }
1081
1082 /**
1083  * Set the DParams for drawing the value of a setting.
1084  * @param first_param First DParam to use
1085  * @param value Setting value to set params for.
1086  */
1087 void SettingEntry::SetValueDParams(uint first_param, int32 value) const
1088 {
1089         const SettingDescBase *sdb = &this->setting->desc;
1090         if (sdb->cmd == SDT_BOOLX) {
1091                 SetDParam(first_param++, value != 0 ? STR_CONFIG_SETTING_ON : STR_CONFIG_SETTING_OFF);
1092         } else {
1093                 if ((sdb->flags & SGF_MULTISTRING) != 0) {
1094                         SetDParam(first_param++, sdb->str_val - sdb->min + value);
1095                 } else if ((sdb->flags & SGF_DISPLAY_ABS) != 0) {
1096                         SetDParam(first_param++, sdb->str_val + ((value >= 0) ? 1 : 0));
1097                         value = abs(value);
1098                 } else {
1099                         SetDParam(first_param++, sdb->str_val + ((value == 0 && (sdb->flags & SGF_0ISDISABLED) != 0) ? 1 : 0));
1100                 }
1101                 SetDParam(first_param++, value);
1102         }
1103 }
1104
1105 /**
1106  * Function to draw setting value (button + text + current value)
1107  * @param settings_ptr Pointer to current values of all settings
1108  * @param left         Left-most position in window/panel to start drawing
1109  * @param right        Right-most position in window/panel to draw
1110  * @param y            Upper-most position in window/panel to start drawing
1111  * @param highlight    Highlight entry.
1112  */
1113 void SettingEntry::DrawSetting(GameSettings *settings_ptr, int left, int right, int y, bool highlight) const
1114 {
1115         const SettingDesc *sd = this->setting;
1116         const SettingDescBase *sdb = &sd->desc;
1117         const void *var = ResolveVariableAddress(settings_ptr, sd);
1118         int state = this->flags & SEF_BUTTONS_MASK;
1119
1120         bool rtl = _current_text_dir == TD_RTL;
1121         uint buttons_left = rtl ? right + 1 - SETTING_BUTTON_WIDTH : left;
1122         uint text_left  = left + (rtl ? 0 : SETTING_BUTTON_WIDTH + 5);
1123         uint text_right = right - (rtl ? SETTING_BUTTON_WIDTH + 5 : 0);
1124         uint button_y = y + (SETTING_HEIGHT - SETTING_BUTTON_HEIGHT) / 2;
1125
1126         /* We do not allow changes of some items when we are a client in a networkgame */
1127         bool editable = sd->IsEditable();
1128
1129         SetDParam(0, highlight ? STR_ORANGE_STRING1_WHITE : STR_ORANGE_STRING1_LTBLUE);
1130         int32 value = (int32)ReadValue(var, sd->save.conv);
1131         if (sdb->cmd == SDT_BOOLX) {
1132                 /* Draw checkbox for boolean-value either on/off */
1133                 DrawBoolButton(buttons_left, button_y, value != 0, editable);
1134         } else if ((sdb->flags & SGF_MULTISTRING) != 0) {
1135                 /* Draw [v] button for settings of an enum-type */
1136                 DrawDropDownButton(buttons_left, button_y, COLOUR_YELLOW, state != 0, editable);
1137         } else {
1138                 /* Draw [<][>] boxes for settings of an integer-type */
1139                 DrawArrowButtons(buttons_left, button_y, COLOUR_YELLOW, state,
1140                                 editable && value != (sdb->flags & SGF_0ISDISABLED ? 0 : sdb->min), editable && (uint32)value != sdb->max);
1141         }
1142         this->SetValueDParams(1, value);
1143         DrawString(text_left, text_right, y + (SETTING_HEIGHT - FONT_HEIGHT_NORMAL) / 2, sdb->str, highlight ? TC_WHITE : TC_LIGHT_BLUE);
1144 }
1145
1146 /* == SettingsContainer methods == */
1147
1148 /**
1149  * Initialization of an entire setting page
1150  * @param level Nesting level of this page (internal variable, do not provide a value for it when calling)
1151  */
1152 void SettingsContainer::Init(byte level)
1153 {
1154         for (EntryVector::iterator it = this->entries.begin(); it != this->entries.end(); ++it) {
1155                 (*it)->Init(level);
1156         }
1157 }
1158
1159 /** Recursively close all folds of sub-pages */
1160 void SettingsContainer::FoldAll()
1161 {
1162         for (EntryVector::iterator it = this->entries.begin(); it != this->entries.end(); ++it) {
1163                 (*it)->FoldAll();
1164         }
1165 }
1166
1167 /** Recursively open all folds of sub-pages */
1168 void SettingsContainer::UnFoldAll()
1169 {
1170         for (EntryVector::iterator it = this->entries.begin(); it != this->entries.end(); ++it) {
1171                 (*it)->UnFoldAll();
1172         }
1173 }
1174
1175 /**
1176  * Recursively accumulate the folding state of the tree.
1177  * @param[in,out] all_folded Set to false, if one entry is not folded.
1178  * @param[in,out] all_unfolded Set to false, if one entry is folded.
1179  */
1180 void SettingsContainer::GetFoldingState(bool &all_folded, bool &all_unfolded) const
1181 {
1182         for (EntryVector::const_iterator it = this->entries.begin(); it != this->entries.end(); ++it) {
1183                 (*it)->GetFoldingState(all_folded, all_unfolded);
1184         }
1185 }
1186
1187 /**
1188  * Update the filter state.
1189  * @param filter Filter
1190  * @param force_visible Whether to force all items visible, no matter what
1191  * @return true if item remains visible
1192  */
1193 bool SettingsContainer::UpdateFilterState(SettingFilter &filter, bool force_visible)
1194 {
1195         bool visible = false;
1196         bool first_visible = true;
1197         for (EntryVector::reverse_iterator it = this->entries.rbegin(); it != this->entries.rend(); ++it) {
1198                 visible |= (*it)->UpdateFilterState(filter, force_visible);
1199                 (*it)->SetLastField(first_visible);
1200                 if (visible && first_visible) first_visible = false;
1201         }
1202         return visible;
1203 }
1204
1205
1206 /**
1207  * Check whether an entry is visible and not folded or filtered away.
1208  * Note: This does not consider the scrolling range; it might still require scrolling to make the setting really visible.
1209  * @param item Entry to search for.
1210  * @return true if entry is visible.
1211  */
1212 bool SettingsContainer::IsVisible(const BaseSettingEntry *item) const
1213 {
1214         for (EntryVector::const_iterator it = this->entries.begin(); it != this->entries.end(); ++it) {
1215                 if ((*it)->IsVisible(item)) return true;
1216         }
1217         return false;
1218 }
1219
1220 /** Return number of rows needed to display the whole page */
1221 uint SettingsContainer::Length() const
1222 {
1223         uint length = 0;
1224         for (EntryVector::const_iterator it = this->entries.begin(); it != this->entries.end(); ++it) {
1225                 length += (*it)->Length();
1226         }
1227         return length;
1228 }
1229
1230 /**
1231  * Find the setting entry at row number \a row_num
1232  * @param row_num Index of entry to return
1233  * @param cur_row Variable used for keeping track of the current row number. Should point to memory initialized to \c 0 when first called.
1234  * @return The requested setting entry or \c NULL if it does not exist
1235  */
1236 BaseSettingEntry *SettingsContainer::FindEntry(uint row_num, uint *cur_row)
1237 {
1238         BaseSettingEntry *pe = NULL;
1239         for (EntryVector::iterator it = this->entries.begin(); it != this->entries.end(); ++it) {
1240                 pe = (*it)->FindEntry(row_num, cur_row);
1241                 if (pe != NULL) {
1242                         break;
1243                 }
1244         }
1245         return pe;
1246 }
1247
1248 /**
1249  * Get the biggest height of the help texts, if the width is at least \a maxw. Help text gets wrapped if needed.
1250  * @param maxw Maximal width of a line help text.
1251  * @return Biggest height needed to display any help text of this (sub-)tree.
1252  */
1253 uint SettingsContainer::GetMaxHelpHeight(int maxw)
1254 {
1255         uint biggest = 0;
1256         for (EntryVector::const_iterator it = this->entries.begin(); it != this->entries.end(); ++it) {
1257                 biggest = max(biggest, (*it)->GetMaxHelpHeight(maxw));
1258         }
1259         return biggest;
1260 }
1261
1262
1263 /**
1264  * Draw a row in the settings panel.
1265  *
1266  * @param settings_ptr Pointer to current values of all settings
1267  * @param left         Left-most position in window/panel to start drawing \a first_row
1268  * @param right        Right-most x position to draw strings at.
1269  * @param y            Upper-most position in window/panel to start drawing \a first_row
1270  * @param first_row    First row number to draw
1271  * @param max_row      Row-number to stop drawing (the row-number of the row below the last row to draw)
1272  * @param selected     Selected entry by the user.
1273  * @param cur_row      Current row number (internal variable)
1274  * @param parent_last  Last-field booleans of parent page level (page level \e i sets bit \e i to 1 if it is its last field)
1275  * @return Row number of the next row to draw
1276  */
1277 uint SettingsContainer::Draw(GameSettings *settings_ptr, int left, int right, int y, uint first_row, uint max_row, BaseSettingEntry *selected, uint cur_row, uint parent_last) const
1278 {
1279         for (EntryVector::const_iterator it = this->entries.begin(); it != this->entries.end(); ++it) {
1280                 cur_row = (*it)->Draw(settings_ptr, left, right, y, first_row, max_row, selected, cur_row, parent_last);
1281                 if (cur_row >= max_row) {
1282                         break;
1283                 }
1284         }
1285         return cur_row;
1286 }
1287
1288 /* == SettingsPage methods == */
1289
1290 /**
1291  * Constructor for a sub-page in the 'advanced settings' window
1292  * @param title Title of the sub-page
1293  */
1294 SettingsPage::SettingsPage(StringID title)
1295 {
1296         this->title = title;
1297         this->folded = true;
1298 }
1299
1300 /**
1301  * Initialization of an entire setting page
1302  * @param level Nesting level of this page (internal variable, do not provide a value for it when calling)
1303  */
1304 void SettingsPage::Init(byte level)
1305 {
1306         BaseSettingEntry::Init(level);
1307         SettingsContainer::Init(level + 1);
1308 }
1309
1310 /** Recursively close all (filtered) folds of sub-pages */
1311 void SettingsPage::FoldAll()
1312 {
1313         if (this->IsFiltered()) return;
1314         this->folded = true;
1315
1316         SettingsContainer::FoldAll();
1317 }
1318
1319 /** Recursively open all (filtered) folds of sub-pages */
1320 void SettingsPage::UnFoldAll()
1321 {
1322         if (this->IsFiltered()) return;
1323         this->folded = false;
1324
1325         SettingsContainer::UnFoldAll();
1326 }
1327
1328 /**
1329  * Recursively accumulate the folding state of the (filtered) tree.
1330  * @param[in,out] all_folded Set to false, if one entry is not folded.
1331  * @param[in,out] all_unfolded Set to false, if one entry is folded.
1332  */
1333 void SettingsPage::GetFoldingState(bool &all_folded, bool &all_unfolded) const
1334 {
1335         if (this->IsFiltered()) return;
1336
1337         if (this->folded) {
1338                 all_unfolded = false;
1339         } else {
1340                 all_folded = false;
1341         }
1342
1343         SettingsContainer::GetFoldingState(all_folded, all_unfolded);
1344 }
1345
1346 /**
1347  * Update the filter state.
1348  * @param filter Filter
1349  * @param force_visible Whether to force all items visible, no matter what (due to filter text; not affected by restriction drop down box).
1350  * @return true if item remains visible
1351  */
1352 bool SettingsPage::UpdateFilterState(SettingFilter &filter, bool force_visible)
1353 {
1354         if (!force_visible && !filter.string.IsEmpty()) {
1355                 filter.string.ResetState();
1356                 filter.string.AddLine(this->title);
1357                 force_visible = filter.string.GetState();
1358         }
1359
1360         bool visible = SettingsContainer::UpdateFilterState(filter, force_visible);
1361         if (visible) {
1362                 CLRBITS(this->flags, SEF_FILTERED);
1363         } else {
1364                 SETBITS(this->flags, SEF_FILTERED);
1365         }
1366         return visible;
1367 }
1368
1369 /**
1370  * Check whether an entry is visible and not folded or filtered away.
1371  * Note: This does not consider the scrolling range; it might still require scrolling to make the setting really visible.
1372  * @param item Entry to search for.
1373  * @return true if entry is visible.
1374  */
1375 bool SettingsPage::IsVisible(const BaseSettingEntry *item) const
1376 {
1377         if (this->IsFiltered()) return false;
1378         if (this == item) return true;
1379         if (this->folded) return false;
1380
1381         return SettingsContainer::IsVisible(item);
1382 }
1383
1384 /** Return number of rows needed to display the (filtered) entry */
1385 uint SettingsPage::Length() const
1386 {
1387         if (this->IsFiltered()) return 0;
1388         if (this->folded) return 1; // Only displaying the title
1389
1390         return 1 + SettingsContainer::Length();
1391 }
1392
1393 /**
1394  * Find setting entry at row \a row_num
1395  * @param row_num Index of entry to return
1396  * @param cur_row Current row number
1397  * @return The requested setting entry or \c NULL if it not found (folded or filtered)
1398  */
1399 BaseSettingEntry *SettingsPage::FindEntry(uint row_num, uint *cur_row)
1400 {
1401         if (this->IsFiltered()) return NULL;
1402         if (row_num == *cur_row) return this;
1403         (*cur_row)++;
1404         if (this->folded) return NULL;
1405
1406         return SettingsContainer::FindEntry(row_num, cur_row);
1407 }
1408
1409 /**
1410  * Draw a row in the settings panel.
1411  *
1412  * @param settings_ptr Pointer to current values of all settings
1413  * @param left         Left-most position in window/panel to start drawing \a first_row
1414  * @param right        Right-most x position to draw strings at.
1415  * @param y            Upper-most position in window/panel to start drawing \a first_row
1416  * @param first_row    First row number to draw
1417  * @param max_row      Row-number to stop drawing (the row-number of the row below the last row to draw)
1418  * @param selected     Selected entry by the user.
1419  * @param cur_row      Current row number (internal variable)
1420  * @param parent_last  Last-field booleans of parent page level (page level \e i sets bit \e i to 1 if it is its last field)
1421  * @return Row number of the next row to draw
1422  */
1423 uint SettingsPage::Draw(GameSettings *settings_ptr, int left, int right, int y, uint first_row, uint max_row, BaseSettingEntry *selected, uint cur_row, uint parent_last) const
1424 {
1425         if (this->IsFiltered()) return cur_row;
1426         if (cur_row >= max_row) return cur_row;
1427
1428         cur_row = BaseSettingEntry::Draw(settings_ptr, left, right, y, first_row, max_row, selected, cur_row, parent_last);
1429
1430         if (!this->folded) {
1431                 if (this->flags & SEF_LAST_FIELD) {
1432                         assert(this->level < 8 * sizeof(parent_last));
1433                         SetBit(parent_last, this->level); // Add own last-field state
1434                 }
1435
1436                 cur_row = SettingsContainer::Draw(settings_ptr, left, right, y, first_row, max_row, selected, cur_row, parent_last);
1437         }
1438
1439         return cur_row;
1440 }
1441
1442 /**
1443  * Function to draw setting value (button + text + current value)
1444  * @param settings_ptr Pointer to current values of all settings
1445  * @param left         Left-most position in window/panel to start drawing
1446  * @param right        Right-most position in window/panel to draw
1447  * @param y            Upper-most position in window/panel to start drawing
1448  * @param highlight    Highlight entry.
1449  */
1450 void SettingsPage::DrawSetting(GameSettings *settings_ptr, int left, int right, int y, bool highlight) const
1451 {
1452         bool rtl = _current_text_dir == TD_RTL;
1453         DrawSprite((this->folded ? SPR_CIRCLE_FOLDED : SPR_CIRCLE_UNFOLDED), PAL_NONE, rtl ? right - _circle_size.width : left, y + (SETTING_HEIGHT - _circle_size.height) / 2);
1454         DrawString(rtl ? left : left + _circle_size.width + 2, rtl ? right - _circle_size.width - 2 : right, y + (SETTING_HEIGHT - FONT_HEIGHT_NORMAL) / 2, this->title);
1455 }
1456
1457 /** Construct settings tree */
1458 static SettingsContainer &GetSettingsTree()
1459 {
1460         static SettingsContainer *main = NULL;
1461
1462         if (main == NULL)
1463         {
1464                 /* Build up the dynamic settings-array only once per OpenTTD session */
1465                 main = new SettingsContainer();
1466
1467                 SettingsPage *localisation = main->Add(new SettingsPage(STR_CONFIG_SETTING_LOCALISATION));
1468                 {
1469                         localisation->Add(new SettingEntry("locale.units_velocity"));
1470                         localisation->Add(new SettingEntry("locale.units_power"));
1471                         localisation->Add(new SettingEntry("locale.units_weight"));
1472                         localisation->Add(new SettingEntry("locale.units_volume"));
1473                         localisation->Add(new SettingEntry("locale.units_force"));
1474                         localisation->Add(new SettingEntry("locale.units_height"));
1475                         localisation->Add(new SettingEntry("gui.date_format_in_default_names"));
1476                 }
1477
1478                 SettingsPage *graphics = main->Add(new SettingsPage(STR_CONFIG_SETTING_GRAPHICS));
1479                 {
1480                         graphics->Add(new SettingEntry("gui.zoom_min"));
1481                         graphics->Add(new SettingEntry("gui.zoom_max"));
1482                         graphics->Add(new SettingEntry("gui.smallmap_land_colour"));
1483                         graphics->Add(new SettingEntry("gui.graph_line_thickness"));
1484                         graphics->Add(new SettingEntry("gui.show_vehicle_route_steps"));
1485                         graphics->Add(new SettingEntry("gui.show_vehicle_route"));
1486                         graphics->Add(new SettingEntry("gui.dash_level_of_route_lines"));
1487                 }
1488
1489                 SettingsPage *sound = main->Add(new SettingsPage(STR_CONFIG_SETTING_SOUND));
1490                 {
1491                         sound->Add(new SettingEntry("sound.click_beep"));
1492                         sound->Add(new SettingEntry("sound.confirm"));
1493                         sound->Add(new SettingEntry("sound.news_ticker"));
1494                         sound->Add(new SettingEntry("sound.news_full"));
1495                         sound->Add(new SettingEntry("sound.new_year"));
1496                         sound->Add(new SettingEntry("sound.disaster"));
1497                         sound->Add(new SettingEntry("sound.vehicle"));
1498                         sound->Add(new SettingEntry("sound.ambient"));
1499                 }
1500
1501                 SettingsPage *interface = main->Add(new SettingsPage(STR_CONFIG_SETTING_INTERFACE));
1502                 {
1503                         SettingsPage *general = interface->Add(new SettingsPage(STR_CONFIG_SETTING_INTERFACE_GENERAL));
1504                         {
1505                                 general->Add(new SettingEntry("gui.osk_activation"));
1506                                 general->Add(new SettingEntry("gui.hover_delay_ms"));
1507                                 general->Add(new SettingEntry("gui.errmsg_duration"));
1508                                 general->Add(new SettingEntry("gui.window_snap_radius"));
1509                                 general->Add(new SettingEntry("gui.window_soft_limit"));
1510                                 general->Add(new SettingEntry("gui.right_mouse_wnd_close"));
1511                         }
1512
1513                         SettingsPage *viewports = interface->Add(new SettingsPage(STR_CONFIG_SETTING_INTERFACE_VIEWPORTS));
1514                         {
1515                                 SettingsPage *viewport_map = interface->Add(new SettingsPage(STR_CONFIG_SETTING_VIEWPORT_MAP_OPTIONS));
1516                                 {
1517                                         viewport_map->Add(new SettingEntry("gui.default_viewport_map_mode"));
1518                                         viewport_map->Add(new SettingEntry("gui.action_when_viewport_map_is_dblclicked"));
1519                                         viewport_map->Add(new SettingEntry("gui.viewport_map_scan_surroundings"));
1520                                         viewport_map->Add(new SettingEntry("gui.show_scrolling_viewport_on_map"));
1521                                         viewport_map->Add(new SettingEntry("gui.show_slopes_on_viewport_map"));
1522                                         viewport_map->Add(new SettingEntry("gui.show_bridges_on_map"));
1523                                         viewport_map->Add(new SettingEntry("gui.show_tunnels_on_map"));
1524                                         viewport_map->Add(new SettingEntry("gui.use_owner_colour_for_tunnelbridge"));
1525                                 }
1526
1527                                 viewports->Add(new SettingEntry("gui.auto_scrolling"));
1528                                 viewports->Add(new SettingEntry("gui.reverse_scroll"));
1529                                 viewports->Add(new SettingEntry("gui.smooth_scroll"));
1530                                 viewports->Add(new SettingEntry("gui.left_mouse_btn_scrolling"));
1531                                 /* While the horizontal scrollwheel scrolling is written as general code, only
1532                                  *  the cocoa (OSX) driver generates input for it.
1533                                  *  Since it's also able to completely disable the scrollwheel will we display it on all platforms anyway */
1534                                 viewports->Add(new SettingEntry("gui.scrollwheel_scrolling"));
1535                                 viewports->Add(new SettingEntry("gui.scrollwheel_multiplier"));
1536 #ifdef __APPLE__
1537                                 /* We might need to emulate a right mouse button on mac */
1538                                 viewports->Add(new SettingEntry("gui.right_mouse_btn_emulation"));
1539 #endif
1540                                 viewports->Add(new SettingEntry("gui.population_in_label"));
1541                                 viewports->Add(new SettingEntry("gui.liveries"));
1542                                 viewports->Add(new SettingEntry("construction.train_signal_side"));
1543                                 viewports->Add(new SettingEntry("gui.measure_tooltip"));
1544                                 viewports->Add(new SettingEntry("gui.loading_indicators"));
1545                                 viewports->Add(new SettingEntry("gui.show_track_reservation"));
1546                                 viewports->Add(new SettingEntry("gui.show_track_overgrowth"));
1547                         }
1548
1549                         SettingsPage *construction = interface->Add(new SettingsPage(STR_CONFIG_SETTING_INTERFACE_CONSTRUCTION));
1550                         {
1551                                 construction->Add(new SettingEntry("gui.link_terraform_toolbar"));
1552                                 construction->Add(new SettingEntry("gui.enable_signal_gui"));
1553                                 construction->Add(new SettingEntry("gui.persistent_buildingtools"));
1554                                 construction->Add(new SettingEntry("gui.quick_goto"));
1555                                 construction->Add(new SettingEntry("gui.default_rail_type"));
1556                                 construction->Add(new SettingEntry("gui.disable_unsuitable_building"));
1557                         }
1558
1559                         SettingsPage *departureboards = interface->Add(new SettingsPage(STR_CONFIG_SETTING_INTERFACE_DEPARTUREBOARDS));
1560                         {
1561                                 departureboards->Add(new SettingEntry("gui.max_departures"));
1562                                 departureboards->Add(new SettingEntry("gui.departure_calc_frequency"));
1563                                 departureboards->Add(new SettingEntry("gui.departure_show_vehicle"));
1564                                 departureboards->Add(new SettingEntry("gui.departure_show_group"));
1565                                 departureboards->Add(new SettingEntry("gui.departure_show_company"));
1566                                 departureboards->Add(new SettingEntry("gui.departure_show_vehicle_type"));
1567                                 departureboards->Add(new SettingEntry("gui.departure_show_vehicle_color"));
1568                                 departureboards->Add(new SettingEntry("gui.departure_larger_font"));
1569                                 departureboards->Add(new SettingEntry("gui.departure_destination_type"));
1570                                 departureboards->Add(new SettingEntry("gui.departure_show_both"));
1571                                 departureboards->Add(new SettingEntry("gui.departure_only_passengers"));
1572                                 departureboards->Add(new SettingEntry("gui.departure_smart_terminus"));
1573                                 departureboards->Add(new SettingEntry("gui.departure_conditionals"));
1574                                 departureboards->Add(new SettingEntry("gui.departure_show_all_stops"));
1575                                 departureboards->Add(new SettingEntry("gui.departure_merge_identical"));
1576                         }
1577
1578                         interface->Add(new SettingEntry("gui.autosave"));
1579                         interface->Add(new SettingEntry("gui.toolbar_pos"));
1580                         interface->Add(new SettingEntry("gui.statusbar_pos"));
1581                         interface->Add(new SettingEntry("gui.prefer_teamchat"));
1582                         interface->Add(new SettingEntry("gui.advanced_vehicle_list"));
1583                         interface->Add(new SettingEntry("gui.advanced_train_purchase_window"));
1584                         interface->Add(new SettingEntry("gui.timetable_arrival_departure"));
1585                         interface->Add(new SettingEntry("gui.ticks_per_minute"));
1586                         interface->Add(new SettingEntry("gui.expenses_layout"));
1587                 }
1588
1589                 SettingsPage *advisors = main->Add(new SettingsPage(STR_CONFIG_SETTING_ADVISORS));
1590                 {
1591                         advisors->Add(new SettingEntry("gui.coloured_news_year"));
1592                         advisors->Add(new SettingEntry("news_display.general"));
1593                         advisors->Add(new SettingEntry("news_display.new_vehicles"));
1594                         advisors->Add(new SettingEntry("news_display.accident"));
1595                         advisors->Add(new SettingEntry("news_display.company_info"));
1596                         advisors->Add(new SettingEntry("news_display.acceptance"));
1597                         advisors->Add(new SettingEntry("news_display.arrival_player"));
1598                         advisors->Add(new SettingEntry("news_display.arrival_other"));
1599                         advisors->Add(new SettingEntry("news_display.advice"));
1600                         advisors->Add(new SettingEntry("gui.order_review_system"));
1601                         advisors->Add(new SettingEntry("gui.vehicle_income_warn"));
1602                         advisors->Add(new SettingEntry("gui.lost_vehicle_warn"));
1603                         advisors->Add(new SettingEntry("gui.show_finances"));
1604                         advisors->Add(new SettingEntry("news_display.economy"));
1605                         advisors->Add(new SettingEntry("news_display.subsidies"));
1606                         advisors->Add(new SettingEntry("news_display.open"));
1607                         advisors->Add(new SettingEntry("news_display.close"));
1608                         advisors->Add(new SettingEntry("news_display.production_player"));
1609                         advisors->Add(new SettingEntry("news_display.production_other"));
1610                         advisors->Add(new SettingEntry("news_display.production_nobody"));
1611                 }
1612
1613                 SettingsPage *company = main->Add(new SettingsPage(STR_CONFIG_SETTING_COMPANY));
1614                 {
1615                         company->Add(new SettingEntry("gui.semaphore_build_before"));
1616                         company->Add(new SettingEntry("gui.default_signal_type"));
1617                         company->Add(new SettingEntry("gui.cycle_signal_types"));
1618                         company->Add(new SettingEntry("gui.drag_signals_fixed_distance"));
1619                         company->Add(new SettingEntry("construction.simulated_wormhole_signals"));
1620                         company->Add(new SettingEntry("gui.new_nonstop"));
1621                         company->Add(new SettingEntry("gui.stop_location"));
1622                         company->Add(new SettingEntry("company.engine_renew"));
1623                         company->Add(new SettingEntry("company.engine_renew_months"));
1624                         company->Add(new SettingEntry("company.engine_renew_money"));
1625                         company->Add(new SettingEntry("vehicle.servint_ispercent"));
1626                         company->Add(new SettingEntry("vehicle.servint_trains"));
1627                         company->Add(new SettingEntry("vehicle.servint_roadveh"));
1628                         company->Add(new SettingEntry("vehicle.servint_ships"));
1629                         company->Add(new SettingEntry("vehicle.servint_aircraft"));
1630                 }
1631
1632                 SettingsPage *accounting = main->Add(new SettingsPage(STR_CONFIG_SETTING_ACCOUNTING));
1633                 {
1634                         accounting->Add(new SettingEntry("economy.inflation"));
1635                         accounting->Add(new SettingEntry("difficulty.initial_interest"));
1636                         accounting->Add(new SettingEntry("difficulty.max_loan"));
1637                         accounting->Add(new SettingEntry("difficulty.subsidy_multiplier"));
1638                         accounting->Add(new SettingEntry("economy.infrastructure_maintenance"));
1639                         accounting->Add(new SettingEntry("difficulty.vehicle_costs"));
1640                         accounting->Add(new SettingEntry("difficulty.construction_cost"));
1641                 }
1642
1643                 SettingsPage *vehicles = main->Add(new SettingsPage(STR_CONFIG_SETTING_VEHICLES));
1644                 {
1645                         SettingsPage *physics = vehicles->Add(new SettingsPage(STR_CONFIG_SETTING_VEHICLES_PHYSICS));
1646                         {
1647                                 physics->Add(new SettingEntry("vehicle.train_acceleration_model"));
1648                                 physics->Add(new SettingEntry("vehicle.train_slope_steepness"));
1649                                 physics->Add(new SettingEntry("vehicle.wagon_speed_limits"));
1650                                 physics->Add(new SettingEntry("vehicle.train_speed_adaption"));
1651                                 physics->Add(new SettingEntry("vehicle.freight_trains"));
1652                                 physics->Add(new SettingEntry("vehicle.roadveh_acceleration_model"));
1653                                 physics->Add(new SettingEntry("vehicle.roadveh_slope_steepness"));
1654                                 physics->Add(new SettingEntry("vehicle.smoke_amount"));
1655                                 physics->Add(new SettingEntry("vehicle.plane_speed"));
1656                         }
1657
1658                         SettingsPage *routing = vehicles->Add(new SettingsPage(STR_CONFIG_SETTING_VEHICLES_ROUTING));
1659                         {
1660                                 routing->Add(new SettingEntry("pf.pathfinder_for_trains"));
1661                                 routing->Add(new SettingEntry("difficulty.line_reverse_mode"));
1662                                 routing->Add(new SettingEntry("pf.reverse_at_signals"));
1663                                 routing->Add(new SettingEntry("pf.back_of_one_way_pbs_waiting_point"));
1664                                 routing->Add(new SettingEntry("pf.forbid_90_deg"));
1665                                 routing->Add(new SettingEntry("pf.pathfinder_for_roadvehs"));
1666                                 routing->Add(new SettingEntry("pf.pathfinder_for_ships"));
1667                         }
1668
1669                         vehicles->Add(new SettingEntry("gui.specific_group_name"));
1670                         vehicles->Add(new SettingEntry("order.no_servicing_if_no_breakdowns"));
1671                         vehicles->Add(new SettingEntry("order.serviceathelipad"));
1672                         vehicles->Add(new SettingEntry("order.automatic_timetable_separation"));
1673                         vehicles->Add(new SettingEntry("order.timetable_auto_travel_buffer"));
1674                         vehicles->Add(new SettingEntry("order.timetable_auto_load_buffer"));
1675                         vehicles->Add(new SettingEntry("order.timetable_auto_travel_rounding"));
1676                         vehicles->Add(new SettingEntry("order.timetable_auto_load_rounding"));
1677                 }
1678
1679                 SettingsPage *limitations = main->Add(new SettingsPage(STR_CONFIG_SETTING_LIMITATIONS));
1680                 {
1681                         limitations->Add(new SettingEntry("construction.command_pause_level"));
1682                         limitations->Add(new SettingEntry("construction.autoslope"));
1683                         limitations->Add(new SettingEntry("construction.extra_dynamite"));
1684                         limitations->Add(new SettingEntry("construction.max_heightlevel"));
1685                         limitations->Add(new SettingEntry("construction.max_bridge_length"));
1686                         limitations->Add(new SettingEntry("construction.max_bridge_height"));
1687                         limitations->Add(new SettingEntry("construction.max_tunnel_length"));
1688                         limitations->Add(new SettingEntry("construction.chunnel"));
1689                         limitations->Add(new SettingEntry("station.never_expire_airports"));
1690                         limitations->Add(new SettingEntry("vehicle.never_expire_vehicles"));
1691                         limitations->Add(new SettingEntry("vehicle.max_trains"));
1692                         limitations->Add(new SettingEntry("vehicle.max_roadveh"));
1693                         limitations->Add(new SettingEntry("vehicle.max_aircraft"));
1694                         limitations->Add(new SettingEntry("vehicle.max_ships"));
1695                         limitations->Add(new SettingEntry("vehicle.max_train_length"));
1696                         limitations->Add(new SettingEntry("station.station_spread"));
1697                         limitations->Add(new SettingEntry("station.distant_join_stations"));
1698                         limitations->Add(new SettingEntry("construction.road_stop_on_town_road"));
1699                         limitations->Add(new SettingEntry("construction.road_stop_on_competitor_road"));
1700                         limitations->Add(new SettingEntry("vehicle.disable_elrails"));
1701                         limitations->Add(new SettingEntry("construction.road_custom_bridge_heads"));
1702                 }
1703
1704                 SettingsPage *disasters = main->Add(new SettingsPage(STR_CONFIG_SETTING_ACCIDENTS));
1705                 {
1706                         disasters->Add(new SettingEntry("difficulty.disasters"));
1707                         disasters->Add(new SettingEntry("difficulty.economy"));
1708                         disasters->Add(new SettingEntry("difficulty.vehicle_breakdowns"));
1709                         disasters->Add(new SettingEntry("vehicle.plane_crashes"));
1710                 }
1711
1712                 SettingsPage *genworld = main->Add(new SettingsPage(STR_CONFIG_SETTING_GENWORLD));
1713                 {
1714                         genworld->Add(new SettingEntry("game_creation.landscape"));
1715                         genworld->Add(new SettingEntry("game_creation.land_generator"));
1716                         genworld->Add(new SettingEntry("difficulty.terrain_type"));
1717                         genworld->Add(new SettingEntry("game_creation.tgen_smoothness"));
1718                         genworld->Add(new SettingEntry("game_creation.variety"));
1719                         genworld->Add(new SettingEntry("game_creation.snow_line_height"));
1720                         genworld->Add(new SettingEntry("game_creation.amount_of_rivers"));
1721                         genworld->Add(new SettingEntry("game_creation.min_river_length"));
1722                         genworld->Add(new SettingEntry("game_creation.tree_placer"));
1723                         genworld->Add(new SettingEntry("game_creation.tree_line_height"));
1724                         genworld->Add(new SettingEntry("construction.trees_around_snow_line_range"));
1725                         genworld->Add(new SettingEntry("vehicle.road_side"));
1726                         genworld->Add(new SettingEntry("economy.larger_towns"));
1727                         genworld->Add(new SettingEntry("economy.initial_city_size"));
1728                         genworld->Add(new SettingEntry("economy.town_cargo_factor"));
1729                         genworld->Add(new SettingEntry("economy.town_layout"));
1730                         genworld->Add(new SettingEntry("economy.town_min_distance"));
1731                         genworld->Add(new SettingEntry("economy.max_town_heightlevel"));
1732                         genworld->Add(new SettingEntry("game_creation.build_public_roads"));
1733                         genworld->Add(new SettingEntry("difficulty.industry_density"));
1734                         genworld->Add(new SettingEntry("gui.pause_on_newgame"));
1735                 }
1736
1737                 SettingsPage *environment = main->Add(new SettingsPage(STR_CONFIG_SETTING_ENVIRONMENT));
1738                 {
1739                         SettingsPage *authorities = environment->Add(new SettingsPage(STR_CONFIG_SETTING_ENVIRONMENT_AUTHORITIES));
1740                         {
1741                                 authorities->Add(new SettingEntry("difficulty.town_council_tolerance"));
1742                                 authorities->Add(new SettingEntry("economy.bribe"));
1743                                 authorities->Add(new SettingEntry("economy.exclusive_rights"));
1744                                 authorities->Add(new SettingEntry("economy.fund_roads"));
1745                                 authorities->Add(new SettingEntry("economy.fund_buildings"));
1746                                 authorities->Add(new SettingEntry("economy.station_noise_level"));
1747                         }
1748
1749                         SettingsPage *towns = environment->Add(new SettingsPage(STR_CONFIG_SETTING_ENVIRONMENT_TOWNS));
1750                         {
1751                                 towns->Add(new SettingEntry("economy.town_growth_rate"));
1752                                 towns->Add(new SettingEntry("economy.allow_town_roads"));
1753                                 towns->Add(new SettingEntry("economy.allow_town_level_crossings"));
1754                                 towns->Add(new SettingEntry("economy.found_town"));
1755                         }
1756
1757                         SettingsPage *industries = environment->Add(new SettingsPage(STR_CONFIG_SETTING_ENVIRONMENT_INDUSTRIES));
1758                         {
1759                                 industries->Add(new SettingEntry("construction.raw_industry_construction"));
1760                                 industries->Add(new SettingEntry("construction.industry_platform"));
1761                                 industries->Add(new SettingEntry("economy.multiple_industry_per_town"));
1762                                 industries->Add(new SettingEntry("game_creation.oil_refinery_limit"));
1763                                 industries->Add(new SettingEntry("economy.smooth_economy"));
1764                         }
1765
1766                         SettingsPage *cdist = environment->Add(new SettingsPage(STR_CONFIG_SETTING_ENVIRONMENT_CARGODIST));
1767                         {
1768                                 cdist->Add(new SettingEntry("linkgraph.recalc_time"));
1769                                 cdist->Add(new SettingEntry("linkgraph.recalc_interval"));
1770                                 cdist->Add(new SettingEntry("linkgraph.distribution_pax"));
1771                                 cdist->Add(new SettingEntry("linkgraph.distribution_mail"));
1772                                 cdist->Add(new SettingEntry("linkgraph.distribution_armoured"));
1773                                 cdist->Add(new SettingEntry("linkgraph.distribution_default"));
1774                                 cdist->Add(new SettingEntry("linkgraph.accuracy"));
1775                                 cdist->Add(new SettingEntry("linkgraph.demand_distance"));
1776                                 cdist->Add(new SettingEntry("linkgraph.demand_size"));
1777                                 cdist->Add(new SettingEntry("linkgraph.short_path_saturation"));
1778                         }
1779
1780                         environment->Add(new SettingEntry("economy.daylength"));
1781                         environment->Add(new SettingEntry("station.modified_catchment"));
1782                         environment->Add(new SettingEntry("construction.extra_tree_placement"));
1783                         environment->Add(new SettingEntry("construction.tree_growth_rate"));
1784                 }
1785
1786                 SettingsPage *ai = main->Add(new SettingsPage(STR_CONFIG_SETTING_AI));
1787                 {
1788                         SettingsPage *npc = ai->Add(new SettingsPage(STR_CONFIG_SETTING_AI_NPC));
1789                         {
1790                                 npc->Add(new SettingEntry("script.settings_profile"));
1791                                 npc->Add(new SettingEntry("script.script_max_opcode_till_suspend"));
1792                                 npc->Add(new SettingEntry("difficulty.competitor_speed"));
1793                                 npc->Add(new SettingEntry("ai.ai_in_multiplayer"));
1794                                 npc->Add(new SettingEntry("ai.ai_disable_veh_train"));
1795                                 npc->Add(new SettingEntry("ai.ai_disable_veh_roadveh"));
1796                                 npc->Add(new SettingEntry("ai.ai_disable_veh_aircraft"));
1797                                 npc->Add(new SettingEntry("ai.ai_disable_veh_ship"));
1798                         }
1799
1800                         ai->Add(new SettingEntry("economy.give_money"));
1801                         ai->Add(new SettingEntry("economy.allow_shares"));
1802                 }
1803
1804                 main->Init();
1805         }
1806         return *main;
1807 }
1808
1809 static const StringID _game_settings_restrict_dropdown[] = {
1810         STR_CONFIG_SETTING_RESTRICT_BASIC,                            // RM_BASIC
1811         STR_CONFIG_SETTING_RESTRICT_ADVANCED,                         // RM_ADVANCED
1812         STR_CONFIG_SETTING_RESTRICT_ALL,                              // RM_ALL
1813         STR_CONFIG_SETTING_RESTRICT_CHANGED_AGAINST_DEFAULT,          // RM_CHANGED_AGAINST_DEFAULT
1814         STR_CONFIG_SETTING_RESTRICT_CHANGED_AGAINST_NEW,              // RM_CHANGED_AGAINST_NEW
1815 };
1816 assert_compile(lengthof(_game_settings_restrict_dropdown) == RM_END);
1817
1818 /** Warnings about hidden search results. */
1819 enum WarnHiddenResult {
1820         WHR_NONE,          ///< Nothing was filtering matches away.
1821         WHR_CATEGORY,      ///< Category setting filtered matches away.
1822         WHR_TYPE,          ///< Type setting filtered matches away.
1823         WHR_CATEGORY_TYPE, ///< Both category and type settings filtered matches away.
1824 };
1825
1826 /** Window to edit settings of the game. */
1827 struct GameSettingsWindow : Window {
1828         static const int SETTINGTREE_LEFT_OFFSET   = 5; ///< Position of left edge of setting values
1829         static const int SETTINGTREE_RIGHT_OFFSET  = 5; ///< Position of right edge of setting values
1830         static const int SETTINGTREE_TOP_OFFSET    = 5; ///< Position of top edge of setting values
1831         static const int SETTINGTREE_BOTTOM_OFFSET = 5; ///< Position of bottom edge of setting values
1832
1833         static GameSettings *settings_ptr; ///< Pointer to the game settings being displayed and modified.
1834
1835         SettingEntry *valuewindow_entry;   ///< If non-NULL, pointer to setting for which a value-entering window has been opened.
1836         SettingEntry *clicked_entry;       ///< If non-NULL, pointer to a clicked numeric setting (with a depressed left or right button).
1837         SettingEntry *last_clicked;        ///< If non-NULL, pointer to the last clicked setting.
1838         SettingEntry *valuedropdown_entry; ///< If non-NULL, pointer to the value for which a dropdown window is currently opened.
1839         bool closing_dropdown;             ///< True, if the dropdown list is currently closing.
1840
1841         SettingFilter filter;              ///< Filter for the list.
1842         QueryString filter_editbox;        ///< Filter editbox;
1843         bool manually_changed_folding;     ///< Whether the user expanded/collapsed something manually.
1844         WarnHiddenResult warn_missing;     ///< Whether and how to warn about missing search results.
1845         int warn_lines;                    ///< Number of lines used for warning about missing search results.
1846
1847         Scrollbar *vscroll;
1848
1849         GameSettingsWindow(WindowDesc *desc) : Window(desc), filter_editbox(50)
1850         {
1851                 this->warn_missing = WHR_NONE;
1852                 this->warn_lines = 0;
1853                 this->filter.mode = (RestrictionMode)_settings_client.gui.settings_restriction_mode;
1854                 this->filter.min_cat = RM_ALL;
1855                 this->filter.type = ST_ALL;
1856                 this->filter.type_hides = false;
1857                 this->settings_ptr = &GetGameSettings();
1858
1859                 _circle_size = maxdim(GetSpriteSize(SPR_CIRCLE_FOLDED), GetSpriteSize(SPR_CIRCLE_UNFOLDED));
1860                 GetSettingsTree().FoldAll(); // Close all sub-pages
1861
1862                 this->valuewindow_entry = NULL; // No setting entry for which a entry window is opened
1863                 this->clicked_entry = NULL; // No numeric setting buttons are depressed
1864                 this->last_clicked = NULL;
1865                 this->valuedropdown_entry = NULL;
1866                 this->closing_dropdown = false;
1867                 this->manually_changed_folding = false;
1868
1869                 this->CreateNestedTree();
1870                 this->vscroll = this->GetScrollbar(WID_GS_SCROLLBAR);
1871                 this->FinishInitNested(WN_GAME_OPTIONS_GAME_SETTINGS);
1872
1873                 this->querystrings[WID_GS_FILTER] = &this->filter_editbox;
1874                 this->filter_editbox.cancel_button = QueryString::ACTION_CLEAR;
1875                 this->SetFocusedWidget(WID_GS_FILTER);
1876
1877                 this->InvalidateData();
1878         }
1879
1880         virtual void UpdateWidgetSize(int widget, Dimension *size, const Dimension &padding, Dimension *fill, Dimension *resize)
1881         {
1882                 switch (widget) {
1883                         case WID_GS_OPTIONSPANEL:
1884                                 resize->height = SETTING_HEIGHT = max(max<int>(_circle_size.height, SETTING_BUTTON_HEIGHT), FONT_HEIGHT_NORMAL) + 1;
1885                                 resize->width  = 1;
1886
1887                                 size->height = 5 * resize->height + SETTINGTREE_TOP_OFFSET + SETTINGTREE_BOTTOM_OFFSET;
1888                                 break;
1889
1890                         case WID_GS_HELP_TEXT: {
1891                                 static const StringID setting_types[] = {
1892                                         STR_CONFIG_SETTING_TYPE_CLIENT,
1893                                         STR_CONFIG_SETTING_TYPE_COMPANY_MENU, STR_CONFIG_SETTING_TYPE_COMPANY_INGAME,
1894                                         STR_CONFIG_SETTING_TYPE_GAME_MENU, STR_CONFIG_SETTING_TYPE_GAME_INGAME,
1895                                 };
1896                                 for (uint i = 0; i < lengthof(setting_types); i++) {
1897                                         SetDParam(0, setting_types[i]);
1898                                         size->width = max(size->width, GetStringBoundingBox(STR_CONFIG_SETTING_TYPE).width);
1899                                 }
1900                                 size->height = 2 * FONT_HEIGHT_NORMAL + WD_PAR_VSEP_NORMAL +
1901                                                 max(size->height, GetSettingsTree().GetMaxHelpHeight(size->width));
1902                                 break;
1903                         }
1904
1905                         case WID_GS_RESTRICT_CATEGORY:
1906                         case WID_GS_RESTRICT_TYPE:
1907                                 size->width = max(GetStringBoundingBox(STR_CONFIG_SETTING_RESTRICT_CATEGORY).width, GetStringBoundingBox(STR_CONFIG_SETTING_RESTRICT_TYPE).width);
1908                                 break;
1909
1910                         default:
1911                                 break;
1912                 }
1913         }
1914
1915         virtual void OnPaint()
1916         {
1917                 if (this->closing_dropdown) {
1918                         this->closing_dropdown = false;
1919                         assert(this->valuedropdown_entry != NULL);
1920                         this->valuedropdown_entry->SetButtons(0);
1921                         this->valuedropdown_entry = NULL;
1922                 }
1923
1924                 /* Reserve the correct number of lines for the 'some search results are hidden' notice in the central settings display panel. */
1925                 const NWidgetBase *panel = this->GetWidget<NWidgetBase>(WID_GS_OPTIONSPANEL);
1926                 StringID warn_str = STR_CONFIG_SETTING_CATEGORY_HIDES - 1 + this->warn_missing;
1927                 int new_warn_lines;
1928                 if (this->warn_missing == WHR_NONE) {
1929                         new_warn_lines = 0;
1930                 } else {
1931                         SetDParam(0, _game_settings_restrict_dropdown[this->filter.min_cat]);
1932                         new_warn_lines = GetStringLineCount(warn_str, panel->current_x);
1933                 }
1934                 if (this->warn_lines != new_warn_lines) {
1935                         this->vscroll->SetCount(this->vscroll->GetCount() - this->warn_lines + new_warn_lines);
1936                         this->warn_lines = new_warn_lines;
1937                 }
1938
1939                 this->DrawWidgets();
1940
1941                 /* Draw the 'some search results are hidden' notice. */
1942                 if (this->warn_missing != WHR_NONE) {
1943                         const int left = panel->pos_x;
1944                         const int right = left + panel->current_x - 1;
1945                         const int top = panel->pos_y + WD_FRAMETEXT_TOP + (SETTING_HEIGHT - FONT_HEIGHT_NORMAL) * this->warn_lines / 2;
1946                         SetDParam(0, _game_settings_restrict_dropdown[this->filter.min_cat]);
1947                         if (this->warn_lines == 1) {
1948                                 /* If the warning fits at one line, center it. */
1949                                 DrawString(left + WD_FRAMETEXT_LEFT, right - WD_FRAMETEXT_RIGHT, top, warn_str, TC_FROMSTRING, SA_HOR_CENTER);
1950                         } else {
1951                                 DrawStringMultiLine(left + WD_FRAMERECT_LEFT, right - WD_FRAMERECT_RIGHT, top, INT32_MAX, warn_str, TC_FROMSTRING, SA_HOR_CENTER);
1952                         }
1953                 }
1954         }
1955
1956         virtual void SetStringParameters(int widget) const
1957         {
1958                 switch (widget) {
1959                         case WID_GS_RESTRICT_DROPDOWN:
1960                                 SetDParam(0, _game_settings_restrict_dropdown[this->filter.mode]);
1961                                 break;
1962
1963                         case WID_GS_TYPE_DROPDOWN:
1964                                 switch (this->filter.type) {
1965                                         case ST_GAME:    SetDParam(0, _game_mode == GM_MENU ? STR_CONFIG_SETTING_TYPE_DROPDOWN_GAME_MENU : STR_CONFIG_SETTING_TYPE_DROPDOWN_GAME_INGAME); break;
1966                                         case ST_COMPANY: SetDParam(0, _game_mode == GM_MENU ? STR_CONFIG_SETTING_TYPE_DROPDOWN_COMPANY_MENU : STR_CONFIG_SETTING_TYPE_DROPDOWN_COMPANY_INGAME); break;
1967                                         case ST_CLIENT:  SetDParam(0, STR_CONFIG_SETTING_TYPE_DROPDOWN_CLIENT); break;
1968                                         default:         SetDParam(0, STR_CONFIG_SETTING_TYPE_DROPDOWN_ALL); break;
1969                                 }
1970                                 break;
1971                 }
1972         }
1973
1974         DropDownList *BuildDropDownList(int widget) const
1975         {
1976                 DropDownList *list = NULL;
1977                 switch (widget) {
1978                         case WID_GS_RESTRICT_DROPDOWN:
1979                                 list = new DropDownList();
1980
1981                                 for (int mode = 0; mode != RM_END; mode++) {
1982                                         /* If we are in adv. settings screen for the new game's settings,
1983                                          * we don't want to allow comparing with new game's settings. */
1984                                         bool disabled = mode == RM_CHANGED_AGAINST_NEW && settings_ptr == &_settings_newgame;
1985
1986                                         *list->Append() = new DropDownListStringItem(_game_settings_restrict_dropdown[mode], mode, disabled);
1987                                 }
1988                                 break;
1989
1990                         case WID_GS_TYPE_DROPDOWN:
1991                                 list = new DropDownList();
1992                                 *list->Append() = new DropDownListStringItem(STR_CONFIG_SETTING_TYPE_DROPDOWN_ALL, ST_ALL, false);
1993                                 *list->Append() = new DropDownListStringItem(_game_mode == GM_MENU ? STR_CONFIG_SETTING_TYPE_DROPDOWN_GAME_MENU : STR_CONFIG_SETTING_TYPE_DROPDOWN_GAME_INGAME, ST_GAME, false);
1994                                 *list->Append() = new DropDownListStringItem(_game_mode == GM_MENU ? STR_CONFIG_SETTING_TYPE_DROPDOWN_COMPANY_MENU : STR_CONFIG_SETTING_TYPE_DROPDOWN_COMPANY_INGAME, ST_COMPANY, false);
1995                                 *list->Append() = new DropDownListStringItem(STR_CONFIG_SETTING_TYPE_DROPDOWN_CLIENT, ST_CLIENT, false);
1996                                 break;
1997                 }
1998                 return list;
1999         }
2000
2001         virtual void DrawWidget(const Rect &r, int widget) const
2002         {
2003                 switch (widget) {
2004                         case WID_GS_OPTIONSPANEL: {
2005                                 int top_pos = r.top + SETTINGTREE_TOP_OFFSET + 1 + this->warn_lines * SETTING_HEIGHT;
2006                                 uint last_row = this->vscroll->GetPosition() + this->vscroll->GetCapacity() - this->warn_lines;
2007                                 int next_row = GetSettingsTree().Draw(settings_ptr, r.left + SETTINGTREE_LEFT_OFFSET, r.right - SETTINGTREE_RIGHT_OFFSET, top_pos,
2008                                                 this->vscroll->GetPosition(), last_row, this->last_clicked);
2009                                 if (next_row == 0) DrawString(r.left + SETTINGTREE_LEFT_OFFSET, r.right - SETTINGTREE_RIGHT_OFFSET, top_pos, STR_CONFIG_SETTINGS_NONE);
2010                                 break;
2011                         }
2012
2013                         case WID_GS_HELP_TEXT:
2014                                 if (this->last_clicked != NULL) {
2015                                         const SettingDesc *sd = this->last_clicked->setting;
2016
2017                                         int y = r.top;
2018                                         switch (sd->GetType()) {
2019                                                 case ST_COMPANY: SetDParam(0, _game_mode == GM_MENU ? STR_CONFIG_SETTING_TYPE_COMPANY_MENU : STR_CONFIG_SETTING_TYPE_COMPANY_INGAME); break;
2020                                                 case ST_CLIENT:  SetDParam(0, STR_CONFIG_SETTING_TYPE_CLIENT); break;
2021                                                 case ST_GAME:    SetDParam(0, _game_mode == GM_MENU ? STR_CONFIG_SETTING_TYPE_GAME_MENU : STR_CONFIG_SETTING_TYPE_GAME_INGAME); break;
2022                                                 default: NOT_REACHED();
2023                                         }
2024                                         DrawString(r.left, r.right, y, STR_CONFIG_SETTING_TYPE);
2025                                         y += FONT_HEIGHT_NORMAL;
2026
2027                                         int32 default_value = ReadValue(&sd->desc.def, sd->save.conv);
2028                                         this->last_clicked->SetValueDParams(0, default_value);
2029                                         DrawString(r.left, r.right, y, STR_CONFIG_SETTING_DEFAULT_VALUE);
2030                                         y += FONT_HEIGHT_NORMAL + WD_PAR_VSEP_NORMAL;
2031
2032                                         DrawStringMultiLine(r.left, r.right, y, r.bottom, this->last_clicked->GetHelpText(), TC_WHITE);
2033                                 }
2034                                 break;
2035
2036                         default:
2037                                 break;
2038                 }
2039         }
2040
2041         /**
2042          * Set the entry that should have its help text displayed, and mark the window dirty so it gets repainted.
2043          * @param pe Setting to display help text of, use \c NULL to stop displaying help of the currently displayed setting.
2044          */
2045         void SetDisplayedHelpText(SettingEntry *pe)
2046         {
2047                 if (this->last_clicked != pe) this->SetDirty();
2048                 this->last_clicked = pe;
2049         }
2050
2051         virtual void OnClick(Point pt, int widget, int click_count)
2052         {
2053                 switch (widget) {
2054                         case WID_GS_EXPAND_ALL:
2055                                 this->manually_changed_folding = true;
2056                                 GetSettingsTree().UnFoldAll();
2057                                 this->InvalidateData();
2058                                 break;
2059
2060                         case WID_GS_COLLAPSE_ALL:
2061                                 this->manually_changed_folding = true;
2062                                 GetSettingsTree().FoldAll();
2063                                 this->InvalidateData();
2064                                 break;
2065
2066                         case WID_GS_RESTRICT_DROPDOWN: {
2067                                 DropDownList *list = this->BuildDropDownList(widget);
2068                                 if (list != NULL) {
2069                                         ShowDropDownList(this, list, this->filter.mode, widget);
2070                                 }
2071                                 break;
2072                         }
2073
2074                         case WID_GS_TYPE_DROPDOWN: {
2075                                 DropDownList *list = this->BuildDropDownList(widget);
2076                                 if (list != NULL) {
2077                                         ShowDropDownList(this, list, this->filter.type, widget);
2078                                 }
2079                                 break;
2080                         }
2081                 }
2082
2083                 if (widget != WID_GS_OPTIONSPANEL) return;
2084
2085                 uint btn = this->vscroll->GetScrolledRowFromWidget(pt.y, this, WID_GS_OPTIONSPANEL, SETTINGTREE_TOP_OFFSET);
2086                 if (btn == INT_MAX || (int)btn < this->warn_lines) return;
2087                 btn -= this->warn_lines;
2088
2089                 uint cur_row = 0;
2090                 BaseSettingEntry *clicked_entry = GetSettingsTree().FindEntry(btn, &cur_row);
2091
2092                 if (clicked_entry == NULL) return;  // Clicked below the last setting of the page
2093
2094                 int x = (_current_text_dir == TD_RTL ? this->width - 1 - pt.x : pt.x) - SETTINGTREE_LEFT_OFFSET - (clicked_entry->level + 1) * LEVEL_WIDTH;  // Shift x coordinate
2095                 if (x < 0) return;  // Clicked left of the entry
2096
2097                 SettingsPage *clicked_page = dynamic_cast<SettingsPage*>(clicked_entry);
2098                 if (clicked_page != NULL) {
2099                         this->SetDisplayedHelpText(NULL);
2100                         clicked_page->folded = !clicked_page->folded; // Flip 'folded'-ness of the sub-page
2101
2102                         this->manually_changed_folding = true;
2103
2104                         this->InvalidateData();
2105                         return;
2106                 }
2107
2108                 SettingEntry *pe = dynamic_cast<SettingEntry*>(clicked_entry);
2109                 assert(pe != NULL);
2110                 const SettingDesc *sd = pe->setting;
2111
2112                 /* return if action is only active in network, or only settable by server */
2113                 if (!sd->IsEditable()) {
2114                         this->SetDisplayedHelpText(pe);
2115                         return;
2116                 }
2117
2118                 const void *var = ResolveVariableAddress(settings_ptr, sd);
2119                 int32 value = (int32)ReadValue(var, sd->save.conv);
2120
2121                 /* clicked on the icon on the left side. Either scroller, bool on/off or dropdown */
2122                 if (x < SETTING_BUTTON_WIDTH && (sd->desc.flags & SGF_MULTISTRING)) {
2123                         const SettingDescBase *sdb = &sd->desc;
2124                         this->SetDisplayedHelpText(pe);
2125
2126                         if (this->valuedropdown_entry == pe) {
2127                                 /* unclick the dropdown */
2128                                 HideDropDownMenu(this);
2129                                 this->closing_dropdown = false;
2130                                 this->valuedropdown_entry->SetButtons(0);
2131                                 this->valuedropdown_entry = NULL;
2132                         } else {
2133                                 if (this->valuedropdown_entry != NULL) this->valuedropdown_entry->SetButtons(0);
2134                                 this->closing_dropdown = false;
2135
2136                                 const NWidgetBase *wid = this->GetWidget<NWidgetBase>(WID_GS_OPTIONSPANEL);
2137                                 int rel_y = (pt.y - (int)wid->pos_y - SETTINGTREE_TOP_OFFSET) % wid->resize_y;
2138
2139                                 Rect wi_rect;
2140                                 wi_rect.left = pt.x - (_current_text_dir == TD_RTL ? SETTING_BUTTON_WIDTH - 1 - x : x);
2141                                 wi_rect.right = wi_rect.left + SETTING_BUTTON_WIDTH - 1;
2142                                 wi_rect.top = pt.y - rel_y + (SETTING_HEIGHT - SETTING_BUTTON_HEIGHT) / 2;
2143                                 wi_rect.bottom = wi_rect.top + SETTING_BUTTON_HEIGHT - 1;
2144
2145                                 /* For dropdowns we also have to check the y position thoroughly, the mouse may not above the just opening dropdown */
2146                                 if (pt.y >= wi_rect.top && pt.y <= wi_rect.bottom) {
2147                                         this->valuedropdown_entry = pe;
2148                                         this->valuedropdown_entry->SetButtons(SEF_LEFT_DEPRESSED);
2149
2150                                         DropDownList *list = new DropDownList();
2151                                         for (int i = sdb->min; i <= (int)sdb->max; i++) {
2152                                                 *list->Append() = new DropDownListStringItem(sdb->str_val + i - sdb->min, i, false);
2153                                         }
2154
2155                                         ShowDropDownListAt(this, list, value, -1, wi_rect, COLOUR_ORANGE, true);
2156                                 }
2157                         }
2158                         this->SetDirty();
2159                 } else if (x < SETTING_BUTTON_WIDTH) {
2160                         this->SetDisplayedHelpText(pe);
2161                         const SettingDescBase *sdb = &sd->desc;
2162                         int32 oldvalue = value;
2163
2164                         switch (sdb->cmd) {
2165                                 case SDT_BOOLX: value ^= 1; break;
2166                                 case SDT_ONEOFMANY:
2167                                 case SDT_NUMX: {
2168                                         /* Add a dynamic step-size to the scroller. In a maximum of
2169                                          * 50-steps you should be able to get from min to max,
2170                                          * unless specified otherwise in the 'interval' variable
2171                                          * of the current setting. */
2172                                         uint32 step = (sdb->interval == 0) ? ((sdb->max - sdb->min) / 50) : sdb->interval;
2173                                         if (step == 0) step = 1;
2174
2175                                         /* don't allow too fast scrolling */
2176                                         if ((this->flags & WF_TIMEOUT) && this->timeout_timer > 1) {
2177                                                 _left_button_clicked = false;
2178                                                 return;
2179                                         }
2180
2181                                         /* Increase or decrease the value and clamp it to extremes */
2182                                         if (x >= SETTING_BUTTON_WIDTH / 2) {
2183                                                 value += step;
2184                                                 if (sdb->min < 0) {
2185                                                         assert((int32)sdb->max >= 0);
2186                                                         if (value > (int32)sdb->max) value = (int32)sdb->max;
2187                                                 } else {
2188                                                         if ((uint32)value > sdb->max) value = (int32)sdb->max;
2189                                                 }
2190                                                 if (value < sdb->min) value = sdb->min; // skip between "disabled" and minimum
2191                                         } else {
2192                                                 value -= step;
2193                                                 if (value < sdb->min) value = (sdb->flags & SGF_0ISDISABLED) ? 0 : sdb->min;
2194                                         }
2195
2196                                         /* Set up scroller timeout for numeric values */
2197                                         if (value != oldvalue) {
2198                                                 if (this->clicked_entry != NULL) { // Release previous buttons if any
2199                                                         this->clicked_entry->SetButtons(0);
2200                                                 }
2201                                                 this->clicked_entry = pe;
2202                                                 this->clicked_entry->SetButtons((x >= SETTING_BUTTON_WIDTH / 2) != (_current_text_dir == TD_RTL) ? SEF_RIGHT_DEPRESSED : SEF_LEFT_DEPRESSED);
2203                                                 this->SetTimeout();
2204                                                 _left_button_clicked = false;
2205                                         }
2206                                         break;
2207                                 }
2208
2209                                 default: NOT_REACHED();
2210                         }
2211
2212                         if (value != oldvalue) {
2213                                 if ((sd->desc.flags & SGF_PER_COMPANY) != 0) {
2214                                         SetCompanySetting(pe->index, value);
2215                                 } else {
2216                                         SetSettingValue(pe->index, value);
2217                                 }
2218                                 this->SetDirty();
2219                         }
2220                 } else {
2221                         /* Only open editbox if clicked for the second time, and only for types where it is sensible for. */
2222                         if (this->last_clicked == pe && sd->desc.cmd != SDT_BOOLX && !(sd->desc.flags & SGF_MULTISTRING)) {
2223                                 /* Show the correct currency-translated value */
2224                                 if (sd->desc.flags & SGF_CURRENCY) value *= _currency->rate;
2225
2226                                 this->valuewindow_entry = pe;
2227                                 SetDParam(0, value);
2228                                 ShowQueryString(STR_JUST_INT, STR_CONFIG_SETTING_QUERY_CAPTION, 10, this, CS_NUMERAL, QSF_ENABLE_DEFAULT);
2229                         }
2230                         this->SetDisplayedHelpText(pe);
2231                 }
2232         }
2233
2234         virtual void OnTimeout()
2235         {
2236                 if (this->clicked_entry != NULL) { // On timeout, release any depressed buttons
2237                         this->clicked_entry->SetButtons(0);
2238                         this->clicked_entry = NULL;
2239                         this->SetDirty();
2240                 }
2241         }
2242
2243         virtual void OnQueryTextFinished(char *str)
2244         {
2245                 /* The user pressed cancel */
2246                 if (str == NULL) return;
2247
2248                 assert(this->valuewindow_entry != NULL);
2249                 const SettingDesc *sd = this->valuewindow_entry->setting;
2250
2251                 int32 value;
2252                 if (!StrEmpty(str)) {
2253                         value = atoi(str);
2254
2255                         /* Save the correct currency-translated value */
2256                         if (sd->desc.flags & SGF_CURRENCY) value /= _currency->rate;
2257                 } else {
2258                         value = (int32)(size_t)sd->desc.def;
2259                 }
2260
2261                 if ((sd->desc.flags & SGF_PER_COMPANY) != 0) {
2262                         SetCompanySetting(this->valuewindow_entry->index, value);
2263                 } else {
2264                         SetSettingValue(this->valuewindow_entry->index, value);
2265                 }
2266                 this->SetDirty();
2267         }
2268
2269         virtual void OnDropdownSelect(int widget, int index)
2270         {
2271                 switch (widget) {
2272                         case WID_GS_RESTRICT_DROPDOWN:
2273                                 this->filter.mode = (RestrictionMode)index;
2274                                 if (this->filter.mode == RM_CHANGED_AGAINST_DEFAULT ||
2275                                                 this->filter.mode == RM_CHANGED_AGAINST_NEW) {
2276
2277                                         if (!this->manually_changed_folding) {
2278                                                 /* Expand all when selecting 'changes'. Update the filter state first, in case it becomes less restrictive in some cases. */
2279                                                 GetSettingsTree().UpdateFilterState(this->filter, false);
2280                                                 GetSettingsTree().UnFoldAll();
2281                                         }
2282                                 } else {
2283                                         /* Non-'changes' filter. Save as default. */
2284                                         _settings_client.gui.settings_restriction_mode = this->filter.mode;
2285                                 }
2286                                 this->InvalidateData();
2287                                 break;
2288
2289                         case WID_GS_TYPE_DROPDOWN:
2290                                 this->filter.type = (SettingType)index;
2291                                 this->InvalidateData();
2292                                 break;
2293
2294                         default:
2295                                 if (widget < 0) {
2296                                         /* Deal with drop down boxes on the panel. */
2297                                         assert(this->valuedropdown_entry != NULL);
2298                                         const SettingDesc *sd = this->valuedropdown_entry->setting;
2299                                         assert(sd->desc.flags & SGF_MULTISTRING);
2300
2301                                         if ((sd->desc.flags & SGF_PER_COMPANY) != 0) {
2302                                                 SetCompanySetting(this->valuedropdown_entry->index, index);
2303                                         } else {
2304                                                 SetSettingValue(this->valuedropdown_entry->index, index);
2305                                         }
2306
2307                                         this->SetDirty();
2308                                 }
2309                                 break;
2310                 }
2311         }
2312
2313         virtual void OnDropdownClose(Point pt, int widget, int index, bool instant_close)
2314         {
2315                 if (widget >= 0) {
2316                         /* Normally the default implementation of OnDropdownClose() takes care of
2317                          * a few things. We want that behaviour here too, but only for
2318                          * "normal" dropdown boxes. The special dropdown boxes added for every
2319                          * setting that needs one can't have this call. */
2320                         Window::OnDropdownClose(pt, widget, index, instant_close);
2321                 } else {
2322                         /* We cannot raise the dropdown button just yet. OnClick needs some hint, whether
2323                          * the same dropdown button was clicked again, and then not open the dropdown again.
2324                          * So, we only remember that it was closed, and process it on the next OnPaint, which is
2325                          * after OnClick. */
2326                         assert(this->valuedropdown_entry != NULL);
2327                         this->closing_dropdown = true;
2328                         this->SetDirty();
2329                 }
2330         }
2331
2332         virtual void OnInvalidateData(int data = 0, bool gui_scope = true)
2333         {
2334                 if (!gui_scope) return;
2335
2336                 /* Update which settings are to be visible. */
2337                 RestrictionMode min_level = (this->filter.mode <= RM_ALL) ? this->filter.mode : RM_BASIC;
2338                 this->filter.min_cat = min_level;
2339                 this->filter.type_hides = false;
2340                 GetSettingsTree().UpdateFilterState(this->filter, false);
2341
2342                 if (this->filter.string.IsEmpty()) {
2343                         this->warn_missing = WHR_NONE;
2344                 } else if (min_level < this->filter.min_cat) {
2345                         this->warn_missing = this->filter.type_hides ? WHR_CATEGORY_TYPE : WHR_CATEGORY;
2346                 } else {
2347                         this->warn_missing = this->filter.type_hides ? WHR_TYPE : WHR_NONE;
2348                 }
2349                 this->vscroll->SetCount(GetSettingsTree().Length() + this->warn_lines);
2350
2351                 if (this->last_clicked != NULL && !GetSettingsTree().IsVisible(this->last_clicked)) {
2352                         this->SetDisplayedHelpText(NULL);
2353                 }
2354
2355                 bool all_folded = true;
2356                 bool all_unfolded = true;
2357                 GetSettingsTree().GetFoldingState(all_folded, all_unfolded);
2358                 this->SetWidgetDisabledState(WID_GS_EXPAND_ALL, all_unfolded);
2359                 this->SetWidgetDisabledState(WID_GS_COLLAPSE_ALL, all_folded);
2360         }
2361
2362         virtual void OnEditboxChanged(int wid)
2363         {
2364                 if (wid == WID_GS_FILTER) {
2365                         this->filter.string.SetFilterTerm(this->filter_editbox.text.buf);
2366                         if (!this->filter.string.IsEmpty() && !this->manually_changed_folding) {
2367                                 /* User never expanded/collapsed single pages and entered a filter term.
2368                                  * Expand everything, to save weird expand clicks, */
2369                                 GetSettingsTree().UnFoldAll();
2370                         }
2371                         this->InvalidateData();
2372                 }
2373         }
2374
2375         virtual void OnResize()
2376         {
2377                 this->vscroll->SetCapacityFromWidget(this, WID_GS_OPTIONSPANEL, SETTINGTREE_TOP_OFFSET + SETTINGTREE_BOTTOM_OFFSET);
2378         }
2379 };
2380
2381 GameSettings *GameSettingsWindow::settings_ptr = NULL;
2382
2383 static const NWidgetPart _nested_settings_selection_widgets[] = {
2384         NWidget(NWID_HORIZONTAL),
2385                 NWidget(WWT_CLOSEBOX, COLOUR_MAUVE),
2386                 NWidget(WWT_CAPTION, COLOUR_MAUVE), SetDataTip(STR_CONFIG_SETTING_TREE_CAPTION, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
2387                 NWidget(WWT_DEFSIZEBOX, COLOUR_MAUVE),
2388         EndContainer(),
2389         NWidget(WWT_PANEL, COLOUR_MAUVE),
2390                 NWidget(NWID_VERTICAL), SetPIP(0, WD_PAR_VSEP_NORMAL, 0), SetPadding(WD_TEXTPANEL_TOP, 0, WD_TEXTPANEL_BOTTOM, 0),
2391                         NWidget(NWID_HORIZONTAL), SetPIP(WD_FRAMETEXT_LEFT, WD_FRAMETEXT_RIGHT, WD_FRAMETEXT_RIGHT),
2392                                 NWidget(WWT_TEXT, COLOUR_MAUVE, WID_GS_RESTRICT_CATEGORY), SetDataTip(STR_CONFIG_SETTING_RESTRICT_CATEGORY, STR_NULL),
2393                                 NWidget(WWT_DROPDOWN, COLOUR_MAUVE, WID_GS_RESTRICT_DROPDOWN), SetMinimalSize(100, 12), SetDataTip(STR_BLACK_STRING, STR_CONFIG_SETTING_RESTRICT_DROPDOWN_HELPTEXT), SetFill(1, 0), SetResize(1, 0),
2394                         EndContainer(),
2395                         NWidget(NWID_HORIZONTAL), SetPIP(WD_FRAMETEXT_LEFT, WD_FRAMETEXT_RIGHT, WD_FRAMETEXT_RIGHT),
2396                                 NWidget(WWT_TEXT, COLOUR_MAUVE, WID_GS_RESTRICT_TYPE), SetDataTip(STR_CONFIG_SETTING_RESTRICT_TYPE, STR_NULL),
2397                                 NWidget(WWT_DROPDOWN, COLOUR_MAUVE, WID_GS_TYPE_DROPDOWN), SetMinimalSize(100, 12), SetDataTip(STR_BLACK_STRING, STR_CONFIG_SETTING_TYPE_DROPDOWN_HELPTEXT), SetFill(1, 0), SetResize(1, 0),
2398                         EndContainer(),
2399                 EndContainer(),
2400                 NWidget(NWID_HORIZONTAL), SetPadding(0, 0, WD_TEXTPANEL_BOTTOM, 0),
2401                                 SetPIP(WD_FRAMETEXT_LEFT, WD_FRAMETEXT_RIGHT, WD_FRAMETEXT_RIGHT),
2402                         NWidget(WWT_TEXT, COLOUR_MAUVE), SetFill(0, 1), SetDataTip(STR_CONFIG_SETTING_FILTER_TITLE, STR_NULL),
2403                         NWidget(WWT_EDITBOX, COLOUR_MAUVE, WID_GS_FILTER), SetFill(1, 0), SetMinimalSize(50, 12), SetResize(1, 0),
2404                                         SetDataTip(STR_LIST_FILTER_OSKTITLE, STR_LIST_FILTER_TOOLTIP),
2405                 EndContainer(),
2406         EndContainer(),
2407         NWidget(NWID_HORIZONTAL),
2408                 NWidget(WWT_PANEL, COLOUR_MAUVE, WID_GS_OPTIONSPANEL), SetMinimalSize(400, 174), SetScrollbar(WID_GS_SCROLLBAR), EndContainer(),
2409                 NWidget(NWID_VSCROLLBAR, COLOUR_MAUVE, WID_GS_SCROLLBAR),
2410         EndContainer(),
2411         NWidget(WWT_PANEL, COLOUR_MAUVE), SetMinimalSize(400, 40),
2412                 NWidget(WWT_EMPTY, INVALID_COLOUR, WID_GS_HELP_TEXT), SetMinimalSize(300, 25), SetFill(1, 1), SetResize(1, 0),
2413                                 SetPadding(WD_FRAMETEXT_TOP, WD_FRAMETEXT_RIGHT, WD_FRAMETEXT_BOTTOM, WD_FRAMETEXT_LEFT),
2414         EndContainer(),
2415         NWidget(NWID_HORIZONTAL),
2416                 NWidget(WWT_PUSHTXTBTN, COLOUR_MAUVE, WID_GS_EXPAND_ALL), SetDataTip(STR_CONFIG_SETTING_EXPAND_ALL, STR_NULL),
2417                 NWidget(WWT_PUSHTXTBTN, COLOUR_MAUVE, WID_GS_COLLAPSE_ALL), SetDataTip(STR_CONFIG_SETTING_COLLAPSE_ALL, STR_NULL),
2418                 NWidget(WWT_PANEL, COLOUR_MAUVE), SetFill(1, 0), SetResize(1, 0),
2419                 EndContainer(),
2420                 NWidget(WWT_RESIZEBOX, COLOUR_MAUVE),
2421         EndContainer(),
2422 };
2423
2424 static WindowDesc _settings_selection_desc(
2425         WDP_CENTER, "settings", 510, 450,
2426         WC_GAME_OPTIONS, WC_NONE,
2427         0,
2428         _nested_settings_selection_widgets, lengthof(_nested_settings_selection_widgets)
2429 );
2430
2431 /** Open advanced settings window. */
2432 void ShowGameSettings()
2433 {
2434         DeleteWindowByClass(WC_GAME_OPTIONS);
2435         new GameSettingsWindow(&_settings_selection_desc);
2436 }
2437
2438
2439 /**
2440  * Draw [<][>] boxes.
2441  * @param x the x position to draw
2442  * @param y the y position to draw
2443  * @param button_colour the colour of the button
2444  * @param state 0 = none clicked, 1 = first clicked, 2 = second clicked
2445  * @param clickable_left is the left button clickable?
2446  * @param clickable_right is the right button clickable?
2447  */
2448 void DrawArrowButtons(int x, int y, Colours button_colour, byte state, bool clickable_left, bool clickable_right)
2449 {
2450         int colour = _colour_gradient[button_colour][2];
2451         Dimension dim = NWidgetScrollbar::GetHorizontalDimension();
2452
2453         DrawFrameRect(x,             y, x + dim.width - 1,             y + dim.height - 1, button_colour, (state == 1) ? FR_LOWERED : FR_NONE);
2454         DrawFrameRect(x + dim.width, y, x + dim.width + dim.width - 1, y + dim.height - 1, button_colour, (state == 2) ? FR_LOWERED : FR_NONE);
2455         DrawSprite(SPR_ARROW_LEFT, PAL_NONE, x + WD_IMGBTN_LEFT, y + WD_IMGBTN_TOP);
2456         DrawSprite(SPR_ARROW_RIGHT, PAL_NONE, x + WD_IMGBTN_LEFT + dim.width, y + WD_IMGBTN_TOP);
2457
2458         /* Grey out the buttons that aren't clickable */
2459         bool rtl = _current_text_dir == TD_RTL;
2460         if (rtl ? !clickable_right : !clickable_left) {
2461                 GfxFillRect(x + 1, y, x + dim.width - 1, y + dim.height - 2, colour, FILLRECT_CHECKER);
2462         }
2463         if (rtl ? !clickable_left : !clickable_right) {
2464                 GfxFillRect(x + dim.width + 1, y, x + dim.width + dim.width - 1, y + dim.height - 2, colour, FILLRECT_CHECKER);
2465         }
2466 }
2467
2468 /**
2469  * Draw a dropdown button.
2470  * @param x the x position to draw
2471  * @param y the y position to draw
2472  * @param button_colour the colour of the button
2473  * @param state true = lowered
2474  * @param clickable is the button clickable?
2475  */
2476 void DrawDropDownButton(int x, int y, Colours button_colour, bool state, bool clickable)
2477 {
2478         int colour = _colour_gradient[button_colour][2];
2479
2480         DrawFrameRect(x, y, x + SETTING_BUTTON_WIDTH - 1, y + SETTING_BUTTON_HEIGHT - 1, button_colour, state ? FR_LOWERED : FR_NONE);
2481         DrawSprite(SPR_ARROW_DOWN, PAL_NONE, x + (SETTING_BUTTON_WIDTH - NWidgetScrollbar::GetVerticalDimension().width) / 2 + state, y + 2 + state);
2482
2483         if (!clickable) {
2484                 GfxFillRect(x +  1, y, x + SETTING_BUTTON_WIDTH - 1, y + SETTING_BUTTON_HEIGHT - 2, colour, FILLRECT_CHECKER);
2485         }
2486 }
2487
2488 /**
2489  * Draw a toggle button.
2490  * @param x the x position to draw
2491  * @param y the y position to draw
2492  * @param state true = lowered
2493  * @param clickable is the button clickable?
2494  */
2495 void DrawBoolButton(int x, int y, bool state, bool clickable)
2496 {
2497         static const Colours _bool_ctabs[2][2] = {{COLOUR_CREAM, COLOUR_RED}, {COLOUR_DARK_GREEN, COLOUR_GREEN}};
2498         DrawFrameRect(x, y, x + SETTING_BUTTON_WIDTH - 1, y + SETTING_BUTTON_HEIGHT - 1, _bool_ctabs[state][clickable], state ? FR_LOWERED : FR_NONE);
2499 }
2500
2501 struct CustomCurrencyWindow : Window {
2502         int query_widget;
2503
2504         CustomCurrencyWindow(WindowDesc *desc) : Window(desc)
2505         {
2506                 this->InitNested();
2507
2508                 SetButtonState();
2509         }
2510
2511         void SetButtonState()
2512         {
2513                 this->SetWidgetDisabledState(WID_CC_RATE_DOWN, _custom_currency.rate == 1);
2514                 this->SetWidgetDisabledState(WID_CC_RATE_UP, _custom_currency.rate == UINT16_MAX);
2515                 this->SetWidgetDisabledState(WID_CC_YEAR_DOWN, _custom_currency.to_euro == CF_NOEURO);
2516                 this->SetWidgetDisabledState(WID_CC_YEAR_UP, _custom_currency.to_euro == MAX_YEAR);
2517         }
2518
2519         virtual void SetStringParameters(int widget) const
2520         {
2521                 switch (widget) {
2522                         case WID_CC_RATE:      SetDParam(0, 1); SetDParam(1, 1);            break;
2523                         case WID_CC_SEPARATOR: SetDParamStr(0, _custom_currency.separator); break;
2524                         case WID_CC_PREFIX:    SetDParamStr(0, _custom_currency.prefix);    break;
2525                         case WID_CC_SUFFIX:    SetDParamStr(0, _custom_currency.suffix);    break;
2526                         case WID_CC_YEAR:
2527                                 SetDParam(0, (_custom_currency.to_euro != CF_NOEURO) ? STR_CURRENCY_SWITCH_TO_EURO : STR_CURRENCY_SWITCH_TO_EURO_NEVER);
2528                                 SetDParam(1, _custom_currency.to_euro);
2529                                 break;
2530
2531                         case WID_CC_PREVIEW:
2532                                 SetDParam(0, 10000);
2533                                 break;
2534                 }
2535         }
2536
2537         virtual void UpdateWidgetSize(int widget, Dimension *size, const Dimension &padding, Dimension *fill, Dimension *resize)
2538         {
2539                 switch (widget) {
2540                         /* Set the appropriate width for the edit 'buttons' */
2541                         case WID_CC_SEPARATOR_EDIT:
2542                         case WID_CC_PREFIX_EDIT:
2543                         case WID_CC_SUFFIX_EDIT:
2544                                 size->width  = this->GetWidget<NWidgetBase>(WID_CC_RATE_DOWN)->smallest_x + this->GetWidget<NWidgetBase>(WID_CC_RATE_UP)->smallest_x;
2545                                 break;
2546
2547                         /* Make sure the window is wide enough for the widest exchange rate */
2548                         case WID_CC_RATE:
2549                                 SetDParam(0, 1);
2550                                 SetDParam(1, INT32_MAX);
2551                                 *size = GetStringBoundingBox(STR_CURRENCY_EXCHANGE_RATE);
2552                                 break;
2553                 }
2554         }
2555
2556         virtual void OnClick(Point pt, int widget, int click_count)
2557         {
2558                 int line = 0;
2559                 int len = 0;
2560                 StringID str = 0;
2561                 CharSetFilter afilter = CS_ALPHANUMERAL;
2562
2563                 switch (widget) {
2564                         case WID_CC_RATE_DOWN:
2565                                 if (_custom_currency.rate > 1) _custom_currency.rate--;
2566                                 if (_custom_currency.rate == 1) this->DisableWidget(WID_CC_RATE_DOWN);
2567                                 this->EnableWidget(WID_CC_RATE_UP);
2568                                 break;
2569
2570                         case WID_CC_RATE_UP:
2571                                 if (_custom_currency.rate < UINT16_MAX) _custom_currency.rate++;
2572                                 if (_custom_currency.rate == UINT16_MAX) this->DisableWidget(WID_CC_RATE_UP);
2573                                 this->EnableWidget(WID_CC_RATE_DOWN);
2574                                 break;
2575
2576                         case WID_CC_RATE:
2577                                 SetDParam(0, _custom_currency.rate);
2578                                 str = STR_JUST_INT;
2579                                 len = 5;
2580                                 line = WID_CC_RATE;
2581                                 afilter = CS_NUMERAL;
2582                                 break;
2583
2584                         case WID_CC_SEPARATOR_EDIT:
2585                         case WID_CC_SEPARATOR:
2586                                 SetDParamStr(0, _custom_currency.separator);
2587                                 str = STR_JUST_RAW_STRING;
2588                                 len = 1;
2589                                 line = WID_CC_SEPARATOR;
2590                                 break;
2591
2592                         case WID_CC_PREFIX_EDIT:
2593                         case WID_CC_PREFIX:
2594                                 SetDParamStr(0, _custom_currency.prefix);
2595                                 str = STR_JUST_RAW_STRING;
2596                                 len = 12;
2597                                 line = WID_CC_PREFIX;
2598                                 break;
2599
2600                         case WID_CC_SUFFIX_EDIT:
2601                         case WID_CC_SUFFIX:
2602                                 SetDParamStr(0, _custom_currency.suffix);
2603                                 str = STR_JUST_RAW_STRING;
2604                                 len = 12;
2605                                 line = WID_CC_SUFFIX;
2606                                 break;
2607
2608                         case WID_CC_YEAR_DOWN:
2609                                 _custom_currency.to_euro = (_custom_currency.to_euro <= 2000) ? CF_NOEURO : _custom_currency.to_euro - 1;
2610                                 if (_custom_currency.to_euro == CF_NOEURO) this->DisableWidget(WID_CC_YEAR_DOWN);
2611                                 this->EnableWidget(WID_CC_YEAR_UP);
2612                                 break;
2613
2614                         case WID_CC_YEAR_UP:
2615                                 _custom_currency.to_euro = Clamp(_custom_currency.to_euro + 1, 2000, MAX_YEAR);
2616                                 if (_custom_currency.to_euro == MAX_YEAR) this->DisableWidget(WID_CC_YEAR_UP);
2617                                 this->EnableWidget(WID_CC_YEAR_DOWN);
2618                                 break;
2619
2620                         case WID_CC_YEAR:
2621                                 SetDParam(0, _custom_currency.to_euro);
2622                                 str = STR_JUST_INT;
2623                                 len = 7;
2624                                 line = WID_CC_YEAR;
2625                                 afilter = CS_NUMERAL;
2626                                 break;
2627                 }
2628
2629                 if (len != 0) {
2630                         this->query_widget = line;
2631                         ShowQueryString(str, STR_CURRENCY_CHANGE_PARAMETER, len + 1, this, afilter, QSF_NONE);
2632                 }
2633
2634                 this->SetTimeout();
2635                 this->SetDirty();
2636         }
2637
2638         virtual void OnQueryTextFinished(char *str)
2639         {
2640                 if (str == NULL) return;
2641
2642                 switch (this->query_widget) {
2643                         case WID_CC_RATE:
2644                                 _custom_currency.rate = Clamp(atoi(str), 1, UINT16_MAX);
2645                                 break;
2646
2647                         case WID_CC_SEPARATOR: // Thousands separator
2648                                 strecpy(_custom_currency.separator, str, lastof(_custom_currency.separator));
2649                                 break;
2650
2651                         case WID_CC_PREFIX:
2652                                 strecpy(_custom_currency.prefix, str, lastof(_custom_currency.prefix));
2653                                 break;
2654
2655                         case WID_CC_SUFFIX:
2656                                 strecpy(_custom_currency.suffix, str, lastof(_custom_currency.suffix));
2657                                 break;
2658
2659                         case WID_CC_YEAR: { // Year to switch to euro
2660                                 int val = atoi(str);
2661
2662                                 _custom_currency.to_euro = (val < 2000 ? CF_NOEURO : min(val, MAX_YEAR));
2663                                 break;
2664                         }
2665                 }
2666                 MarkWholeScreenDirty();
2667                 SetButtonState();
2668         }
2669
2670         virtual void OnTimeout()
2671         {
2672                 this->SetDirty();
2673         }
2674 };
2675
2676 static const NWidgetPart _nested_cust_currency_widgets[] = {
2677         NWidget(NWID_HORIZONTAL),
2678                 NWidget(WWT_CLOSEBOX, COLOUR_GREY),
2679                 NWidget(WWT_CAPTION, COLOUR_GREY), SetDataTip(STR_CURRENCY_WINDOW, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
2680         EndContainer(),
2681         NWidget(WWT_PANEL, COLOUR_GREY),
2682                 NWidget(NWID_VERTICAL, NC_EQUALSIZE), SetPIP(7, 3, 0),
2683                         NWidget(NWID_HORIZONTAL), SetPIP(10, 0, 5),
2684                                 NWidget(WWT_PUSHARROWBTN, COLOUR_YELLOW, WID_CC_RATE_DOWN), SetDataTip(AWV_DECREASE, STR_CURRENCY_DECREASE_EXCHANGE_RATE_TOOLTIP),
2685                                 NWidget(WWT_PUSHARROWBTN, COLOUR_YELLOW, WID_CC_RATE_UP), SetDataTip(AWV_INCREASE, STR_CURRENCY_INCREASE_EXCHANGE_RATE_TOOLTIP),
2686                                 NWidget(NWID_SPACER), SetMinimalSize(5, 0),
2687                                 NWidget(WWT_TEXT, COLOUR_BLUE, WID_CC_RATE), SetDataTip(STR_CURRENCY_EXCHANGE_RATE, STR_CURRENCY_SET_EXCHANGE_RATE_TOOLTIP), SetFill(1, 0),
2688                         EndContainer(),
2689                         NWidget(NWID_HORIZONTAL), SetPIP(10, 0, 5),
2690                                 NWidget(WWT_PUSHBTN, COLOUR_DARK_BLUE, WID_CC_SEPARATOR_EDIT), SetDataTip(0x0, STR_CURRENCY_SET_CUSTOM_CURRENCY_SEPARATOR_TOOLTIP), SetFill(0, 1),
2691                                 NWidget(NWID_SPACER), SetMinimalSize(5, 0),
2692                                 NWidget(WWT_TEXT, COLOUR_BLUE, WID_CC_SEPARATOR), SetDataTip(STR_CURRENCY_SEPARATOR, STR_CURRENCY_SET_CUSTOM_CURRENCY_SEPARATOR_TOOLTIP), SetFill(1, 0),
2693                         EndContainer(),
2694                         NWidget(NWID_HORIZONTAL), SetPIP(10, 0, 5),
2695                                 NWidget(WWT_PUSHBTN, COLOUR_DARK_BLUE, WID_CC_PREFIX_EDIT), SetDataTip(0x0, STR_CURRENCY_SET_CUSTOM_CURRENCY_PREFIX_TOOLTIP), SetFill(0, 1),
2696                                 NWidget(NWID_SPACER), SetMinimalSize(5, 0),
2697                                 NWidget(WWT_TEXT, COLOUR_BLUE, WID_CC_PREFIX), SetDataTip(STR_CURRENCY_PREFIX, STR_CURRENCY_SET_CUSTOM_CURRENCY_PREFIX_TOOLTIP), SetFill(1, 0),
2698                         EndContainer(),
2699                         NWidget(NWID_HORIZONTAL), SetPIP(10, 0, 5),
2700                                 NWidget(WWT_PUSHBTN, COLOUR_DARK_BLUE, WID_CC_SUFFIX_EDIT), SetDataTip(0x0, STR_CURRENCY_SET_CUSTOM_CURRENCY_SUFFIX_TOOLTIP), SetFill(0, 1),
2701                                 NWidget(NWID_SPACER), SetMinimalSize(5, 0),
2702                                 NWidget(WWT_TEXT, COLOUR_BLUE, WID_CC_SUFFIX), SetDataTip(STR_CURRENCY_SUFFIX, STR_CURRENCY_SET_CUSTOM_CURRENCY_SUFFIX_TOOLTIP), SetFill(1, 0),
2703                         EndContainer(),
2704                         NWidget(NWID_HORIZONTAL), SetPIP(10, 0, 5),
2705                                 NWidget(WWT_PUSHARROWBTN, COLOUR_YELLOW, WID_CC_YEAR_DOWN), SetDataTip(AWV_DECREASE, STR_CURRENCY_DECREASE_CUSTOM_CURRENCY_TO_EURO_TOOLTIP),
2706                                 NWidget(WWT_PUSHARROWBTN, COLOUR_YELLOW, WID_CC_YEAR_UP), SetDataTip(AWV_INCREASE, STR_CURRENCY_INCREASE_CUSTOM_CURRENCY_TO_EURO_TOOLTIP),
2707                                 NWidget(NWID_SPACER), SetMinimalSize(5, 0),
2708                                 NWidget(WWT_TEXT, COLOUR_BLUE, WID_CC_YEAR), SetDataTip(STR_JUST_STRING, STR_CURRENCY_SET_CUSTOM_CURRENCY_TO_EURO_TOOLTIP), SetFill(1, 0),
2709                         EndContainer(),
2710                 EndContainer(),
2711                 NWidget(WWT_LABEL, COLOUR_BLUE, WID_CC_PREVIEW),
2712                                                                 SetDataTip(STR_CURRENCY_PREVIEW, STR_CURRENCY_CUSTOM_CURRENCY_PREVIEW_TOOLTIP), SetPadding(15, 1, 18, 2),
2713         EndContainer(),
2714 };
2715
2716 static WindowDesc _cust_currency_desc(
2717         WDP_CENTER, NULL, 0, 0,
2718         WC_CUSTOM_CURRENCY, WC_NONE,
2719         0,
2720         _nested_cust_currency_widgets, lengthof(_nested_cust_currency_widgets)
2721 );
2722
2723 /** Open custom currency window. */
2724 static void ShowCustCurrency()
2725 {
2726         DeleteWindowById(WC_CUSTOM_CURRENCY, 0);
2727         new CustomCurrencyWindow(&_cust_currency_desc);
2728 }