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                 }
1676
1677                 SettingsPage *limitations = main->Add(new SettingsPage(STR_CONFIG_SETTING_LIMITATIONS));
1678                 {
1679                         limitations->Add(new SettingEntry("construction.command_pause_level"));
1680                         limitations->Add(new SettingEntry("construction.autoslope"));
1681                         limitations->Add(new SettingEntry("construction.extra_dynamite"));
1682                         limitations->Add(new SettingEntry("construction.max_heightlevel"));
1683                         limitations->Add(new SettingEntry("construction.max_bridge_length"));
1684                         limitations->Add(new SettingEntry("construction.max_bridge_height"));
1685                         limitations->Add(new SettingEntry("construction.max_tunnel_length"));
1686                         limitations->Add(new SettingEntry("construction.chunnel"));
1687                         limitations->Add(new SettingEntry("station.never_expire_airports"));
1688                         limitations->Add(new SettingEntry("vehicle.never_expire_vehicles"));
1689                         limitations->Add(new SettingEntry("vehicle.max_trains"));
1690                         limitations->Add(new SettingEntry("vehicle.max_roadveh"));
1691                         limitations->Add(new SettingEntry("vehicle.max_aircraft"));
1692                         limitations->Add(new SettingEntry("vehicle.max_ships"));
1693                         limitations->Add(new SettingEntry("vehicle.max_train_length"));
1694                         limitations->Add(new SettingEntry("station.station_spread"));
1695                         limitations->Add(new SettingEntry("station.distant_join_stations"));
1696                         limitations->Add(new SettingEntry("construction.road_stop_on_town_road"));
1697                         limitations->Add(new SettingEntry("construction.road_stop_on_competitor_road"));
1698                         limitations->Add(new SettingEntry("vehicle.disable_elrails"));
1699                         limitations->Add(new SettingEntry("construction.road_custom_bridge_heads"));
1700                 }
1701
1702                 SettingsPage *disasters = main->Add(new SettingsPage(STR_CONFIG_SETTING_ACCIDENTS));
1703                 {
1704                         disasters->Add(new SettingEntry("difficulty.disasters"));
1705                         disasters->Add(new SettingEntry("difficulty.economy"));
1706                         disasters->Add(new SettingEntry("difficulty.vehicle_breakdowns"));
1707                         disasters->Add(new SettingEntry("vehicle.plane_crashes"));
1708                 }
1709
1710                 SettingsPage *genworld = main->Add(new SettingsPage(STR_CONFIG_SETTING_GENWORLD));
1711                 {
1712                         genworld->Add(new SettingEntry("game_creation.landscape"));
1713                         genworld->Add(new SettingEntry("game_creation.land_generator"));
1714                         genworld->Add(new SettingEntry("difficulty.terrain_type"));
1715                         genworld->Add(new SettingEntry("game_creation.tgen_smoothness"));
1716                         genworld->Add(new SettingEntry("game_creation.variety"));
1717                         genworld->Add(new SettingEntry("game_creation.snow_line_height"));
1718                         genworld->Add(new SettingEntry("game_creation.amount_of_rivers"));
1719                         genworld->Add(new SettingEntry("game_creation.min_river_length"));
1720                         genworld->Add(new SettingEntry("game_creation.tree_placer"));
1721                         genworld->Add(new SettingEntry("game_creation.tree_line_height"));
1722                         genworld->Add(new SettingEntry("construction.trees_around_snow_line_range"));
1723                         genworld->Add(new SettingEntry("vehicle.road_side"));
1724                         genworld->Add(new SettingEntry("economy.larger_towns"));
1725                         genworld->Add(new SettingEntry("economy.initial_city_size"));
1726                         genworld->Add(new SettingEntry("economy.town_cargo_factor"));
1727                         genworld->Add(new SettingEntry("economy.town_layout"));
1728                         genworld->Add(new SettingEntry("economy.town_min_distance"));
1729                         genworld->Add(new SettingEntry("economy.max_town_heightlevel"));
1730                         genworld->Add(new SettingEntry("game_creation.build_public_roads"));
1731                         genworld->Add(new SettingEntry("difficulty.industry_density"));
1732                         genworld->Add(new SettingEntry("gui.pause_on_newgame"));
1733                 }
1734
1735                 SettingsPage *environment = main->Add(new SettingsPage(STR_CONFIG_SETTING_ENVIRONMENT));
1736                 {
1737                         SettingsPage *authorities = environment->Add(new SettingsPage(STR_CONFIG_SETTING_ENVIRONMENT_AUTHORITIES));
1738                         {
1739                                 authorities->Add(new SettingEntry("difficulty.town_council_tolerance"));
1740                                 authorities->Add(new SettingEntry("economy.bribe"));
1741                                 authorities->Add(new SettingEntry("economy.exclusive_rights"));
1742                                 authorities->Add(new SettingEntry("economy.fund_roads"));
1743                                 authorities->Add(new SettingEntry("economy.fund_buildings"));
1744                                 authorities->Add(new SettingEntry("economy.station_noise_level"));
1745                         }
1746
1747                         SettingsPage *towns = environment->Add(new SettingsPage(STR_CONFIG_SETTING_ENVIRONMENT_TOWNS));
1748                         {
1749                                 towns->Add(new SettingEntry("economy.town_growth_rate"));
1750                                 towns->Add(new SettingEntry("economy.allow_town_roads"));
1751                                 towns->Add(new SettingEntry("economy.allow_town_level_crossings"));
1752                                 towns->Add(new SettingEntry("economy.found_town"));
1753                         }
1754
1755                         SettingsPage *industries = environment->Add(new SettingsPage(STR_CONFIG_SETTING_ENVIRONMENT_INDUSTRIES));
1756                         {
1757                                 industries->Add(new SettingEntry("construction.raw_industry_construction"));
1758                                 industries->Add(new SettingEntry("construction.industry_platform"));
1759                                 industries->Add(new SettingEntry("economy.multiple_industry_per_town"));
1760                                 industries->Add(new SettingEntry("game_creation.oil_refinery_limit"));
1761                                 industries->Add(new SettingEntry("economy.smooth_economy"));
1762                         }
1763
1764                         SettingsPage *cdist = environment->Add(new SettingsPage(STR_CONFIG_SETTING_ENVIRONMENT_CARGODIST));
1765                         {
1766                                 cdist->Add(new SettingEntry("linkgraph.recalc_time"));
1767                                 cdist->Add(new SettingEntry("linkgraph.recalc_interval"));
1768                                 cdist->Add(new SettingEntry("linkgraph.distribution_pax"));
1769                                 cdist->Add(new SettingEntry("linkgraph.distribution_mail"));
1770                                 cdist->Add(new SettingEntry("linkgraph.distribution_armoured"));
1771                                 cdist->Add(new SettingEntry("linkgraph.distribution_default"));
1772                                 cdist->Add(new SettingEntry("linkgraph.accuracy"));
1773                                 cdist->Add(new SettingEntry("linkgraph.demand_distance"));
1774                                 cdist->Add(new SettingEntry("linkgraph.demand_size"));
1775                                 cdist->Add(new SettingEntry("linkgraph.short_path_saturation"));
1776                         }
1777
1778                         environment->Add(new SettingEntry("economy.daylength"));
1779                         environment->Add(new SettingEntry("station.modified_catchment"));
1780                         environment->Add(new SettingEntry("construction.extra_tree_placement"));
1781                         environment->Add(new SettingEntry("construction.tree_growth_rate"));
1782                 }
1783
1784                 SettingsPage *ai = main->Add(new SettingsPage(STR_CONFIG_SETTING_AI));
1785                 {
1786                         SettingsPage *npc = ai->Add(new SettingsPage(STR_CONFIG_SETTING_AI_NPC));
1787                         {
1788                                 npc->Add(new SettingEntry("script.settings_profile"));
1789                                 npc->Add(new SettingEntry("script.script_max_opcode_till_suspend"));
1790                                 npc->Add(new SettingEntry("difficulty.competitor_speed"));
1791                                 npc->Add(new SettingEntry("ai.ai_in_multiplayer"));
1792                                 npc->Add(new SettingEntry("ai.ai_disable_veh_train"));
1793                                 npc->Add(new SettingEntry("ai.ai_disable_veh_roadveh"));
1794                                 npc->Add(new SettingEntry("ai.ai_disable_veh_aircraft"));
1795                                 npc->Add(new SettingEntry("ai.ai_disable_veh_ship"));
1796                         }
1797
1798                         ai->Add(new SettingEntry("economy.give_money"));
1799                         ai->Add(new SettingEntry("economy.allow_shares"));
1800                 }
1801
1802                 main->Init();
1803         }
1804         return *main;
1805 }
1806
1807 static const StringID _game_settings_restrict_dropdown[] = {
1808         STR_CONFIG_SETTING_RESTRICT_BASIC,                            // RM_BASIC
1809         STR_CONFIG_SETTING_RESTRICT_ADVANCED,                         // RM_ADVANCED
1810         STR_CONFIG_SETTING_RESTRICT_ALL,                              // RM_ALL
1811         STR_CONFIG_SETTING_RESTRICT_CHANGED_AGAINST_DEFAULT,          // RM_CHANGED_AGAINST_DEFAULT
1812         STR_CONFIG_SETTING_RESTRICT_CHANGED_AGAINST_NEW,              // RM_CHANGED_AGAINST_NEW
1813 };
1814 assert_compile(lengthof(_game_settings_restrict_dropdown) == RM_END);
1815
1816 /** Warnings about hidden search results. */
1817 enum WarnHiddenResult {
1818         WHR_NONE,          ///< Nothing was filtering matches away.
1819         WHR_CATEGORY,      ///< Category setting filtered matches away.
1820         WHR_TYPE,          ///< Type setting filtered matches away.
1821         WHR_CATEGORY_TYPE, ///< Both category and type settings filtered matches away.
1822 };
1823
1824 /** Window to edit settings of the game. */
1825 struct GameSettingsWindow : Window {
1826         static const int SETTINGTREE_LEFT_OFFSET   = 5; ///< Position of left edge of setting values
1827         static const int SETTINGTREE_RIGHT_OFFSET  = 5; ///< Position of right edge of setting values
1828         static const int SETTINGTREE_TOP_OFFSET    = 5; ///< Position of top edge of setting values
1829         static const int SETTINGTREE_BOTTOM_OFFSET = 5; ///< Position of bottom edge of setting values
1830
1831         static GameSettings *settings_ptr; ///< Pointer to the game settings being displayed and modified.
1832
1833         SettingEntry *valuewindow_entry;   ///< If non-NULL, pointer to setting for which a value-entering window has been opened.
1834         SettingEntry *clicked_entry;       ///< If non-NULL, pointer to a clicked numeric setting (with a depressed left or right button).
1835         SettingEntry *last_clicked;        ///< If non-NULL, pointer to the last clicked setting.
1836         SettingEntry *valuedropdown_entry; ///< If non-NULL, pointer to the value for which a dropdown window is currently opened.
1837         bool closing_dropdown;             ///< True, if the dropdown list is currently closing.
1838
1839         SettingFilter filter;              ///< Filter for the list.
1840         QueryString filter_editbox;        ///< Filter editbox;
1841         bool manually_changed_folding;     ///< Whether the user expanded/collapsed something manually.
1842         WarnHiddenResult warn_missing;     ///< Whether and how to warn about missing search results.
1843         int warn_lines;                    ///< Number of lines used for warning about missing search results.
1844
1845         Scrollbar *vscroll;
1846
1847         GameSettingsWindow(WindowDesc *desc) : Window(desc), filter_editbox(50)
1848         {
1849                 this->warn_missing = WHR_NONE;
1850                 this->warn_lines = 0;
1851                 this->filter.mode = (RestrictionMode)_settings_client.gui.settings_restriction_mode;
1852                 this->filter.min_cat = RM_ALL;
1853                 this->filter.type = ST_ALL;
1854                 this->filter.type_hides = false;
1855                 this->settings_ptr = &GetGameSettings();
1856
1857                 _circle_size = maxdim(GetSpriteSize(SPR_CIRCLE_FOLDED), GetSpriteSize(SPR_CIRCLE_UNFOLDED));
1858                 GetSettingsTree().FoldAll(); // Close all sub-pages
1859
1860                 this->valuewindow_entry = NULL; // No setting entry for which a entry window is opened
1861                 this->clicked_entry = NULL; // No numeric setting buttons are depressed
1862                 this->last_clicked = NULL;
1863                 this->valuedropdown_entry = NULL;
1864                 this->closing_dropdown = false;
1865                 this->manually_changed_folding = false;
1866
1867                 this->CreateNestedTree();
1868                 this->vscroll = this->GetScrollbar(WID_GS_SCROLLBAR);
1869                 this->FinishInitNested(WN_GAME_OPTIONS_GAME_SETTINGS);
1870
1871                 this->querystrings[WID_GS_FILTER] = &this->filter_editbox;
1872                 this->filter_editbox.cancel_button = QueryString::ACTION_CLEAR;
1873                 this->SetFocusedWidget(WID_GS_FILTER);
1874
1875                 this->InvalidateData();
1876         }
1877
1878         virtual void UpdateWidgetSize(int widget, Dimension *size, const Dimension &padding, Dimension *fill, Dimension *resize)
1879         {
1880                 switch (widget) {
1881                         case WID_GS_OPTIONSPANEL:
1882                                 resize->height = SETTING_HEIGHT = max(max<int>(_circle_size.height, SETTING_BUTTON_HEIGHT), FONT_HEIGHT_NORMAL) + 1;
1883                                 resize->width  = 1;
1884
1885                                 size->height = 5 * resize->height + SETTINGTREE_TOP_OFFSET + SETTINGTREE_BOTTOM_OFFSET;
1886                                 break;
1887
1888                         case WID_GS_HELP_TEXT: {
1889                                 static const StringID setting_types[] = {
1890                                         STR_CONFIG_SETTING_TYPE_CLIENT,
1891                                         STR_CONFIG_SETTING_TYPE_COMPANY_MENU, STR_CONFIG_SETTING_TYPE_COMPANY_INGAME,
1892                                         STR_CONFIG_SETTING_TYPE_GAME_MENU, STR_CONFIG_SETTING_TYPE_GAME_INGAME,
1893                                 };
1894                                 for (uint i = 0; i < lengthof(setting_types); i++) {
1895                                         SetDParam(0, setting_types[i]);
1896                                         size->width = max(size->width, GetStringBoundingBox(STR_CONFIG_SETTING_TYPE).width);
1897                                 }
1898                                 size->height = 2 * FONT_HEIGHT_NORMAL + WD_PAR_VSEP_NORMAL +
1899                                                 max(size->height, GetSettingsTree().GetMaxHelpHeight(size->width));
1900                                 break;
1901                         }
1902
1903                         case WID_GS_RESTRICT_CATEGORY:
1904                         case WID_GS_RESTRICT_TYPE:
1905                                 size->width = max(GetStringBoundingBox(STR_CONFIG_SETTING_RESTRICT_CATEGORY).width, GetStringBoundingBox(STR_CONFIG_SETTING_RESTRICT_TYPE).width);
1906                                 break;
1907
1908                         default:
1909                                 break;
1910                 }
1911         }
1912
1913         virtual void OnPaint()
1914         {
1915                 if (this->closing_dropdown) {
1916                         this->closing_dropdown = false;
1917                         assert(this->valuedropdown_entry != NULL);
1918                         this->valuedropdown_entry->SetButtons(0);
1919                         this->valuedropdown_entry = NULL;
1920                 }
1921
1922                 /* Reserve the correct number of lines for the 'some search results are hidden' notice in the central settings display panel. */
1923                 const NWidgetBase *panel = this->GetWidget<NWidgetBase>(WID_GS_OPTIONSPANEL);
1924                 StringID warn_str = STR_CONFIG_SETTING_CATEGORY_HIDES - 1 + this->warn_missing;
1925                 int new_warn_lines;
1926                 if (this->warn_missing == WHR_NONE) {
1927                         new_warn_lines = 0;
1928                 } else {
1929                         SetDParam(0, _game_settings_restrict_dropdown[this->filter.min_cat]);
1930                         new_warn_lines = GetStringLineCount(warn_str, panel->current_x);
1931                 }
1932                 if (this->warn_lines != new_warn_lines) {
1933                         this->vscroll->SetCount(this->vscroll->GetCount() - this->warn_lines + new_warn_lines);
1934                         this->warn_lines = new_warn_lines;
1935                 }
1936
1937                 this->DrawWidgets();
1938
1939                 /* Draw the 'some search results are hidden' notice. */
1940                 if (this->warn_missing != WHR_NONE) {
1941                         const int left = panel->pos_x;
1942                         const int right = left + panel->current_x - 1;
1943                         const int top = panel->pos_y + WD_FRAMETEXT_TOP + (SETTING_HEIGHT - FONT_HEIGHT_NORMAL) * this->warn_lines / 2;
1944                         SetDParam(0, _game_settings_restrict_dropdown[this->filter.min_cat]);
1945                         if (this->warn_lines == 1) {
1946                                 /* If the warning fits at one line, center it. */
1947                                 DrawString(left + WD_FRAMETEXT_LEFT, right - WD_FRAMETEXT_RIGHT, top, warn_str, TC_FROMSTRING, SA_HOR_CENTER);
1948                         } else {
1949                                 DrawStringMultiLine(left + WD_FRAMERECT_LEFT, right - WD_FRAMERECT_RIGHT, top, INT32_MAX, warn_str, TC_FROMSTRING, SA_HOR_CENTER);
1950                         }
1951                 }
1952         }
1953
1954         virtual void SetStringParameters(int widget) const
1955         {
1956                 switch (widget) {
1957                         case WID_GS_RESTRICT_DROPDOWN:
1958                                 SetDParam(0, _game_settings_restrict_dropdown[this->filter.mode]);
1959                                 break;
1960
1961                         case WID_GS_TYPE_DROPDOWN:
1962                                 switch (this->filter.type) {
1963                                         case ST_GAME:    SetDParam(0, _game_mode == GM_MENU ? STR_CONFIG_SETTING_TYPE_DROPDOWN_GAME_MENU : STR_CONFIG_SETTING_TYPE_DROPDOWN_GAME_INGAME); break;
1964                                         case ST_COMPANY: SetDParam(0, _game_mode == GM_MENU ? STR_CONFIG_SETTING_TYPE_DROPDOWN_COMPANY_MENU : STR_CONFIG_SETTING_TYPE_DROPDOWN_COMPANY_INGAME); break;
1965                                         case ST_CLIENT:  SetDParam(0, STR_CONFIG_SETTING_TYPE_DROPDOWN_CLIENT); break;
1966                                         default:         SetDParam(0, STR_CONFIG_SETTING_TYPE_DROPDOWN_ALL); break;
1967                                 }
1968                                 break;
1969                 }
1970         }
1971
1972         DropDownList *BuildDropDownList(int widget) const
1973         {
1974                 DropDownList *list = NULL;
1975                 switch (widget) {
1976                         case WID_GS_RESTRICT_DROPDOWN:
1977                                 list = new DropDownList();
1978
1979                                 for (int mode = 0; mode != RM_END; mode++) {
1980                                         /* If we are in adv. settings screen for the new game's settings,
1981                                          * we don't want to allow comparing with new game's settings. */
1982                                         bool disabled = mode == RM_CHANGED_AGAINST_NEW && settings_ptr == &_settings_newgame;
1983
1984                                         *list->Append() = new DropDownListStringItem(_game_settings_restrict_dropdown[mode], mode, disabled);
1985                                 }
1986                                 break;
1987
1988                         case WID_GS_TYPE_DROPDOWN:
1989                                 list = new DropDownList();
1990                                 *list->Append() = new DropDownListStringItem(STR_CONFIG_SETTING_TYPE_DROPDOWN_ALL, ST_ALL, false);
1991                                 *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);
1992                                 *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);
1993                                 *list->Append() = new DropDownListStringItem(STR_CONFIG_SETTING_TYPE_DROPDOWN_CLIENT, ST_CLIENT, false);
1994                                 break;
1995                 }
1996                 return list;
1997         }
1998
1999         virtual void DrawWidget(const Rect &r, int widget) const
2000         {
2001                 switch (widget) {
2002                         case WID_GS_OPTIONSPANEL: {
2003                                 int top_pos = r.top + SETTINGTREE_TOP_OFFSET + 1 + this->warn_lines * SETTING_HEIGHT;
2004                                 uint last_row = this->vscroll->GetPosition() + this->vscroll->GetCapacity() - this->warn_lines;
2005                                 int next_row = GetSettingsTree().Draw(settings_ptr, r.left + SETTINGTREE_LEFT_OFFSET, r.right - SETTINGTREE_RIGHT_OFFSET, top_pos,
2006                                                 this->vscroll->GetPosition(), last_row, this->last_clicked);
2007                                 if (next_row == 0) DrawString(r.left + SETTINGTREE_LEFT_OFFSET, r.right - SETTINGTREE_RIGHT_OFFSET, top_pos, STR_CONFIG_SETTINGS_NONE);
2008                                 break;
2009                         }
2010
2011                         case WID_GS_HELP_TEXT:
2012                                 if (this->last_clicked != NULL) {
2013                                         const SettingDesc *sd = this->last_clicked->setting;
2014
2015                                         int y = r.top;
2016                                         switch (sd->GetType()) {
2017                                                 case ST_COMPANY: SetDParam(0, _game_mode == GM_MENU ? STR_CONFIG_SETTING_TYPE_COMPANY_MENU : STR_CONFIG_SETTING_TYPE_COMPANY_INGAME); break;
2018                                                 case ST_CLIENT:  SetDParam(0, STR_CONFIG_SETTING_TYPE_CLIENT); break;
2019                                                 case ST_GAME:    SetDParam(0, _game_mode == GM_MENU ? STR_CONFIG_SETTING_TYPE_GAME_MENU : STR_CONFIG_SETTING_TYPE_GAME_INGAME); break;
2020                                                 default: NOT_REACHED();
2021                                         }
2022                                         DrawString(r.left, r.right, y, STR_CONFIG_SETTING_TYPE);
2023                                         y += FONT_HEIGHT_NORMAL;
2024
2025                                         int32 default_value = ReadValue(&sd->desc.def, sd->save.conv);
2026                                         this->last_clicked->SetValueDParams(0, default_value);
2027                                         DrawString(r.left, r.right, y, STR_CONFIG_SETTING_DEFAULT_VALUE);
2028                                         y += FONT_HEIGHT_NORMAL + WD_PAR_VSEP_NORMAL;
2029
2030                                         DrawStringMultiLine(r.left, r.right, y, r.bottom, this->last_clicked->GetHelpText(), TC_WHITE);
2031                                 }
2032                                 break;
2033
2034                         default:
2035                                 break;
2036                 }
2037         }
2038
2039         /**
2040          * Set the entry that should have its help text displayed, and mark the window dirty so it gets repainted.
2041          * @param pe Setting to display help text of, use \c NULL to stop displaying help of the currently displayed setting.
2042          */
2043         void SetDisplayedHelpText(SettingEntry *pe)
2044         {
2045                 if (this->last_clicked != pe) this->SetDirty();
2046                 this->last_clicked = pe;
2047         }
2048
2049         virtual void OnClick(Point pt, int widget, int click_count)
2050         {
2051                 switch (widget) {
2052                         case WID_GS_EXPAND_ALL:
2053                                 this->manually_changed_folding = true;
2054                                 GetSettingsTree().UnFoldAll();
2055                                 this->InvalidateData();
2056                                 break;
2057
2058                         case WID_GS_COLLAPSE_ALL:
2059                                 this->manually_changed_folding = true;
2060                                 GetSettingsTree().FoldAll();
2061                                 this->InvalidateData();
2062                                 break;
2063
2064                         case WID_GS_RESTRICT_DROPDOWN: {
2065                                 DropDownList *list = this->BuildDropDownList(widget);
2066                                 if (list != NULL) {
2067                                         ShowDropDownList(this, list, this->filter.mode, widget);
2068                                 }
2069                                 break;
2070                         }
2071
2072                         case WID_GS_TYPE_DROPDOWN: {
2073                                 DropDownList *list = this->BuildDropDownList(widget);
2074                                 if (list != NULL) {
2075                                         ShowDropDownList(this, list, this->filter.type, widget);
2076                                 }
2077                                 break;
2078                         }
2079                 }
2080
2081                 if (widget != WID_GS_OPTIONSPANEL) return;
2082
2083                 uint btn = this->vscroll->GetScrolledRowFromWidget(pt.y, this, WID_GS_OPTIONSPANEL, SETTINGTREE_TOP_OFFSET);
2084                 if (btn == INT_MAX || (int)btn < this->warn_lines) return;
2085                 btn -= this->warn_lines;
2086
2087                 uint cur_row = 0;
2088                 BaseSettingEntry *clicked_entry = GetSettingsTree().FindEntry(btn, &cur_row);
2089
2090                 if (clicked_entry == NULL) return;  // Clicked below the last setting of the page
2091
2092                 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
2093                 if (x < 0) return;  // Clicked left of the entry
2094
2095                 SettingsPage *clicked_page = dynamic_cast<SettingsPage*>(clicked_entry);
2096                 if (clicked_page != NULL) {
2097                         this->SetDisplayedHelpText(NULL);
2098                         clicked_page->folded = !clicked_page->folded; // Flip 'folded'-ness of the sub-page
2099
2100                         this->manually_changed_folding = true;
2101
2102                         this->InvalidateData();
2103                         return;
2104                 }
2105
2106                 SettingEntry *pe = dynamic_cast<SettingEntry*>(clicked_entry);
2107                 assert(pe != NULL);
2108                 const SettingDesc *sd = pe->setting;
2109
2110                 /* return if action is only active in network, or only settable by server */
2111                 if (!sd->IsEditable()) {
2112                         this->SetDisplayedHelpText(pe);
2113                         return;
2114                 }
2115
2116                 const void *var = ResolveVariableAddress(settings_ptr, sd);
2117                 int32 value = (int32)ReadValue(var, sd->save.conv);
2118
2119                 /* clicked on the icon on the left side. Either scroller, bool on/off or dropdown */
2120                 if (x < SETTING_BUTTON_WIDTH && (sd->desc.flags & SGF_MULTISTRING)) {
2121                         const SettingDescBase *sdb = &sd->desc;
2122                         this->SetDisplayedHelpText(pe);
2123
2124                         if (this->valuedropdown_entry == pe) {
2125                                 /* unclick the dropdown */
2126                                 HideDropDownMenu(this);
2127                                 this->closing_dropdown = false;
2128                                 this->valuedropdown_entry->SetButtons(0);
2129                                 this->valuedropdown_entry = NULL;
2130                         } else {
2131                                 if (this->valuedropdown_entry != NULL) this->valuedropdown_entry->SetButtons(0);
2132                                 this->closing_dropdown = false;
2133
2134                                 const NWidgetBase *wid = this->GetWidget<NWidgetBase>(WID_GS_OPTIONSPANEL);
2135                                 int rel_y = (pt.y - (int)wid->pos_y - SETTINGTREE_TOP_OFFSET) % wid->resize_y;
2136
2137                                 Rect wi_rect;
2138                                 wi_rect.left = pt.x - (_current_text_dir == TD_RTL ? SETTING_BUTTON_WIDTH - 1 - x : x);
2139                                 wi_rect.right = wi_rect.left + SETTING_BUTTON_WIDTH - 1;
2140                                 wi_rect.top = pt.y - rel_y + (SETTING_HEIGHT - SETTING_BUTTON_HEIGHT) / 2;
2141                                 wi_rect.bottom = wi_rect.top + SETTING_BUTTON_HEIGHT - 1;
2142
2143                                 /* For dropdowns we also have to check the y position thoroughly, the mouse may not above the just opening dropdown */
2144                                 if (pt.y >= wi_rect.top && pt.y <= wi_rect.bottom) {
2145                                         this->valuedropdown_entry = pe;
2146                                         this->valuedropdown_entry->SetButtons(SEF_LEFT_DEPRESSED);
2147
2148                                         DropDownList *list = new DropDownList();
2149                                         for (int i = sdb->min; i <= (int)sdb->max; i++) {
2150                                                 *list->Append() = new DropDownListStringItem(sdb->str_val + i - sdb->min, i, false);
2151                                         }
2152
2153                                         ShowDropDownListAt(this, list, value, -1, wi_rect, COLOUR_ORANGE, true);
2154                                 }
2155                         }
2156                         this->SetDirty();
2157                 } else if (x < SETTING_BUTTON_WIDTH) {
2158                         this->SetDisplayedHelpText(pe);
2159                         const SettingDescBase *sdb = &sd->desc;
2160                         int32 oldvalue = value;
2161
2162                         switch (sdb->cmd) {
2163                                 case SDT_BOOLX: value ^= 1; break;
2164                                 case SDT_ONEOFMANY:
2165                                 case SDT_NUMX: {
2166                                         /* Add a dynamic step-size to the scroller. In a maximum of
2167                                          * 50-steps you should be able to get from min to max,
2168                                          * unless specified otherwise in the 'interval' variable
2169                                          * of the current setting. */
2170                                         uint32 step = (sdb->interval == 0) ? ((sdb->max - sdb->min) / 50) : sdb->interval;
2171                                         if (step == 0) step = 1;
2172
2173                                         /* don't allow too fast scrolling */
2174                                         if ((this->flags & WF_TIMEOUT) && this->timeout_timer > 1) {
2175                                                 _left_button_clicked = false;
2176                                                 return;
2177                                         }
2178
2179                                         /* Increase or decrease the value and clamp it to extremes */
2180                                         if (x >= SETTING_BUTTON_WIDTH / 2) {
2181                                                 value += step;
2182                                                 if (sdb->min < 0) {
2183                                                         assert((int32)sdb->max >= 0);
2184                                                         if (value > (int32)sdb->max) value = (int32)sdb->max;
2185                                                 } else {
2186                                                         if ((uint32)value > sdb->max) value = (int32)sdb->max;
2187                                                 }
2188                                                 if (value < sdb->min) value = sdb->min; // skip between "disabled" and minimum
2189                                         } else {
2190                                                 value -= step;
2191                                                 if (value < sdb->min) value = (sdb->flags & SGF_0ISDISABLED) ? 0 : sdb->min;
2192                                         }
2193
2194                                         /* Set up scroller timeout for numeric values */
2195                                         if (value != oldvalue) {
2196                                                 if (this->clicked_entry != NULL) { // Release previous buttons if any
2197                                                         this->clicked_entry->SetButtons(0);
2198                                                 }
2199                                                 this->clicked_entry = pe;
2200                                                 this->clicked_entry->SetButtons((x >= SETTING_BUTTON_WIDTH / 2) != (_current_text_dir == TD_RTL) ? SEF_RIGHT_DEPRESSED : SEF_LEFT_DEPRESSED);
2201                                                 this->SetTimeout();
2202                                                 _left_button_clicked = false;
2203                                         }
2204                                         break;
2205                                 }
2206
2207                                 default: NOT_REACHED();
2208                         }
2209
2210                         if (value != oldvalue) {
2211                                 if ((sd->desc.flags & SGF_PER_COMPANY) != 0) {
2212                                         SetCompanySetting(pe->index, value);
2213                                 } else {
2214                                         SetSettingValue(pe->index, value);
2215                                 }
2216                                 this->SetDirty();
2217                         }
2218                 } else {
2219                         /* Only open editbox if clicked for the second time, and only for types where it is sensible for. */
2220                         if (this->last_clicked == pe && sd->desc.cmd != SDT_BOOLX && !(sd->desc.flags & SGF_MULTISTRING)) {
2221                                 /* Show the correct currency-translated value */
2222                                 if (sd->desc.flags & SGF_CURRENCY) value *= _currency->rate;
2223
2224                                 this->valuewindow_entry = pe;
2225                                 SetDParam(0, value);
2226                                 ShowQueryString(STR_JUST_INT, STR_CONFIG_SETTING_QUERY_CAPTION, 10, this, CS_NUMERAL, QSF_ENABLE_DEFAULT);
2227                         }
2228                         this->SetDisplayedHelpText(pe);
2229                 }
2230         }
2231
2232         virtual void OnTimeout()
2233         {
2234                 if (this->clicked_entry != NULL) { // On timeout, release any depressed buttons
2235                         this->clicked_entry->SetButtons(0);
2236                         this->clicked_entry = NULL;
2237                         this->SetDirty();
2238                 }
2239         }
2240
2241         virtual void OnQueryTextFinished(char *str)
2242         {
2243                 /* The user pressed cancel */
2244                 if (str == NULL) return;
2245
2246                 assert(this->valuewindow_entry != NULL);
2247                 const SettingDesc *sd = this->valuewindow_entry->setting;
2248
2249                 int32 value;
2250                 if (!StrEmpty(str)) {
2251                         value = atoi(str);
2252
2253                         /* Save the correct currency-translated value */
2254                         if (sd->desc.flags & SGF_CURRENCY) value /= _currency->rate;
2255                 } else {
2256                         value = (int32)(size_t)sd->desc.def;
2257                 }
2258
2259                 if ((sd->desc.flags & SGF_PER_COMPANY) != 0) {
2260                         SetCompanySetting(this->valuewindow_entry->index, value);
2261                 } else {
2262                         SetSettingValue(this->valuewindow_entry->index, value);
2263                 }
2264                 this->SetDirty();
2265         }
2266
2267         virtual void OnDropdownSelect(int widget, int index)
2268         {
2269                 switch (widget) {
2270                         case WID_GS_RESTRICT_DROPDOWN:
2271                                 this->filter.mode = (RestrictionMode)index;
2272                                 if (this->filter.mode == RM_CHANGED_AGAINST_DEFAULT ||
2273                                                 this->filter.mode == RM_CHANGED_AGAINST_NEW) {
2274
2275                                         if (!this->manually_changed_folding) {
2276                                                 /* Expand all when selecting 'changes'. Update the filter state first, in case it becomes less restrictive in some cases. */
2277                                                 GetSettingsTree().UpdateFilterState(this->filter, false);
2278                                                 GetSettingsTree().UnFoldAll();
2279                                         }
2280                                 } else {
2281                                         /* Non-'changes' filter. Save as default. */
2282                                         _settings_client.gui.settings_restriction_mode = this->filter.mode;
2283                                 }
2284                                 this->InvalidateData();
2285                                 break;
2286
2287                         case WID_GS_TYPE_DROPDOWN:
2288                                 this->filter.type = (SettingType)index;
2289                                 this->InvalidateData();
2290                                 break;
2291
2292                         default:
2293                                 if (widget < 0) {
2294                                         /* Deal with drop down boxes on the panel. */
2295                                         assert(this->valuedropdown_entry != NULL);
2296                                         const SettingDesc *sd = this->valuedropdown_entry->setting;
2297                                         assert(sd->desc.flags & SGF_MULTISTRING);
2298
2299                                         if ((sd->desc.flags & SGF_PER_COMPANY) != 0) {
2300                                                 SetCompanySetting(this->valuedropdown_entry->index, index);
2301                                         } else {
2302                                                 SetSettingValue(this->valuedropdown_entry->index, index);
2303                                         }
2304
2305                                         this->SetDirty();
2306                                 }
2307                                 break;
2308                 }
2309         }
2310
2311         virtual void OnDropdownClose(Point pt, int widget, int index, bool instant_close)
2312         {
2313                 if (widget >= 0) {
2314                         /* Normally the default implementation of OnDropdownClose() takes care of
2315                          * a few things. We want that behaviour here too, but only for
2316                          * "normal" dropdown boxes. The special dropdown boxes added for every
2317                          * setting that needs one can't have this call. */
2318                         Window::OnDropdownClose(pt, widget, index, instant_close);
2319                 } else {
2320                         /* We cannot raise the dropdown button just yet. OnClick needs some hint, whether
2321                          * the same dropdown button was clicked again, and then not open the dropdown again.
2322                          * So, we only remember that it was closed, and process it on the next OnPaint, which is
2323                          * after OnClick. */
2324                         assert(this->valuedropdown_entry != NULL);
2325                         this->closing_dropdown = true;
2326                         this->SetDirty();
2327                 }
2328         }
2329
2330         virtual void OnInvalidateData(int data = 0, bool gui_scope = true)
2331         {
2332                 if (!gui_scope) return;
2333
2334                 /* Update which settings are to be visible. */
2335                 RestrictionMode min_level = (this->filter.mode <= RM_ALL) ? this->filter.mode : RM_BASIC;
2336                 this->filter.min_cat = min_level;
2337                 this->filter.type_hides = false;
2338                 GetSettingsTree().UpdateFilterState(this->filter, false);
2339
2340                 if (this->filter.string.IsEmpty()) {
2341                         this->warn_missing = WHR_NONE;
2342                 } else if (min_level < this->filter.min_cat) {
2343                         this->warn_missing = this->filter.type_hides ? WHR_CATEGORY_TYPE : WHR_CATEGORY;
2344                 } else {
2345                         this->warn_missing = this->filter.type_hides ? WHR_TYPE : WHR_NONE;
2346                 }
2347                 this->vscroll->SetCount(GetSettingsTree().Length() + this->warn_lines);
2348
2349                 if (this->last_clicked != NULL && !GetSettingsTree().IsVisible(this->last_clicked)) {
2350                         this->SetDisplayedHelpText(NULL);
2351                 }
2352
2353                 bool all_folded = true;
2354                 bool all_unfolded = true;
2355                 GetSettingsTree().GetFoldingState(all_folded, all_unfolded);
2356                 this->SetWidgetDisabledState(WID_GS_EXPAND_ALL, all_unfolded);
2357                 this->SetWidgetDisabledState(WID_GS_COLLAPSE_ALL, all_folded);
2358         }
2359
2360         virtual void OnEditboxChanged(int wid)
2361         {
2362                 if (wid == WID_GS_FILTER) {
2363                         this->filter.string.SetFilterTerm(this->filter_editbox.text.buf);
2364                         if (!this->filter.string.IsEmpty() && !this->manually_changed_folding) {
2365                                 /* User never expanded/collapsed single pages and entered a filter term.
2366                                  * Expand everything, to save weird expand clicks, */
2367                                 GetSettingsTree().UnFoldAll();
2368                         }
2369                         this->InvalidateData();
2370                 }
2371         }
2372
2373         virtual void OnResize()
2374         {
2375                 this->vscroll->SetCapacityFromWidget(this, WID_GS_OPTIONSPANEL, SETTINGTREE_TOP_OFFSET + SETTINGTREE_BOTTOM_OFFSET);
2376         }
2377 };
2378
2379 GameSettings *GameSettingsWindow::settings_ptr = NULL;
2380
2381 static const NWidgetPart _nested_settings_selection_widgets[] = {
2382         NWidget(NWID_HORIZONTAL),
2383                 NWidget(WWT_CLOSEBOX, COLOUR_MAUVE),
2384                 NWidget(WWT_CAPTION, COLOUR_MAUVE), SetDataTip(STR_CONFIG_SETTING_TREE_CAPTION, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
2385                 NWidget(WWT_DEFSIZEBOX, COLOUR_MAUVE),
2386         EndContainer(),
2387         NWidget(WWT_PANEL, COLOUR_MAUVE),
2388                 NWidget(NWID_VERTICAL), SetPIP(0, WD_PAR_VSEP_NORMAL, 0), SetPadding(WD_TEXTPANEL_TOP, 0, WD_TEXTPANEL_BOTTOM, 0),
2389                         NWidget(NWID_HORIZONTAL), SetPIP(WD_FRAMETEXT_LEFT, WD_FRAMETEXT_RIGHT, WD_FRAMETEXT_RIGHT),
2390                                 NWidget(WWT_TEXT, COLOUR_MAUVE, WID_GS_RESTRICT_CATEGORY), SetDataTip(STR_CONFIG_SETTING_RESTRICT_CATEGORY, STR_NULL),
2391                                 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),
2392                         EndContainer(),
2393                         NWidget(NWID_HORIZONTAL), SetPIP(WD_FRAMETEXT_LEFT, WD_FRAMETEXT_RIGHT, WD_FRAMETEXT_RIGHT),
2394                                 NWidget(WWT_TEXT, COLOUR_MAUVE, WID_GS_RESTRICT_TYPE), SetDataTip(STR_CONFIG_SETTING_RESTRICT_TYPE, STR_NULL),
2395                                 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),
2396                         EndContainer(),
2397                 EndContainer(),
2398                 NWidget(NWID_HORIZONTAL), SetPadding(0, 0, WD_TEXTPANEL_BOTTOM, 0),
2399                                 SetPIP(WD_FRAMETEXT_LEFT, WD_FRAMETEXT_RIGHT, WD_FRAMETEXT_RIGHT),
2400                         NWidget(WWT_TEXT, COLOUR_MAUVE), SetFill(0, 1), SetDataTip(STR_CONFIG_SETTING_FILTER_TITLE, STR_NULL),
2401                         NWidget(WWT_EDITBOX, COLOUR_MAUVE, WID_GS_FILTER), SetFill(1, 0), SetMinimalSize(50, 12), SetResize(1, 0),
2402                                         SetDataTip(STR_LIST_FILTER_OSKTITLE, STR_LIST_FILTER_TOOLTIP),
2403                 EndContainer(),
2404         EndContainer(),
2405         NWidget(NWID_HORIZONTAL),
2406                 NWidget(WWT_PANEL, COLOUR_MAUVE, WID_GS_OPTIONSPANEL), SetMinimalSize(400, 174), SetScrollbar(WID_GS_SCROLLBAR), EndContainer(),
2407                 NWidget(NWID_VSCROLLBAR, COLOUR_MAUVE, WID_GS_SCROLLBAR),
2408         EndContainer(),
2409         NWidget(WWT_PANEL, COLOUR_MAUVE), SetMinimalSize(400, 40),
2410                 NWidget(WWT_EMPTY, INVALID_COLOUR, WID_GS_HELP_TEXT), SetMinimalSize(300, 25), SetFill(1, 1), SetResize(1, 0),
2411                                 SetPadding(WD_FRAMETEXT_TOP, WD_FRAMETEXT_RIGHT, WD_FRAMETEXT_BOTTOM, WD_FRAMETEXT_LEFT),
2412         EndContainer(),
2413         NWidget(NWID_HORIZONTAL),
2414                 NWidget(WWT_PUSHTXTBTN, COLOUR_MAUVE, WID_GS_EXPAND_ALL), SetDataTip(STR_CONFIG_SETTING_EXPAND_ALL, STR_NULL),
2415                 NWidget(WWT_PUSHTXTBTN, COLOUR_MAUVE, WID_GS_COLLAPSE_ALL), SetDataTip(STR_CONFIG_SETTING_COLLAPSE_ALL, STR_NULL),
2416                 NWidget(WWT_PANEL, COLOUR_MAUVE), SetFill(1, 0), SetResize(1, 0),
2417                 EndContainer(),
2418                 NWidget(WWT_RESIZEBOX, COLOUR_MAUVE),
2419         EndContainer(),
2420 };
2421
2422 static WindowDesc _settings_selection_desc(
2423         WDP_CENTER, "settings", 510, 450,
2424         WC_GAME_OPTIONS, WC_NONE,
2425         0,
2426         _nested_settings_selection_widgets, lengthof(_nested_settings_selection_widgets)
2427 );
2428
2429 /** Open advanced settings window. */
2430 void ShowGameSettings()
2431 {
2432         DeleteWindowByClass(WC_GAME_OPTIONS);
2433         new GameSettingsWindow(&_settings_selection_desc);
2434 }
2435
2436
2437 /**
2438  * Draw [<][>] boxes.
2439  * @param x the x position to draw
2440  * @param y the y position to draw
2441  * @param button_colour the colour of the button
2442  * @param state 0 = none clicked, 1 = first clicked, 2 = second clicked
2443  * @param clickable_left is the left button clickable?
2444  * @param clickable_right is the right button clickable?
2445  */
2446 void DrawArrowButtons(int x, int y, Colours button_colour, byte state, bool clickable_left, bool clickable_right)
2447 {
2448         int colour = _colour_gradient[button_colour][2];
2449         Dimension dim = NWidgetScrollbar::GetHorizontalDimension();
2450
2451         DrawFrameRect(x,             y, x + dim.width - 1,             y + dim.height - 1, button_colour, (state == 1) ? FR_LOWERED : FR_NONE);
2452         DrawFrameRect(x + dim.width, y, x + dim.width + dim.width - 1, y + dim.height - 1, button_colour, (state == 2) ? FR_LOWERED : FR_NONE);
2453         DrawSprite(SPR_ARROW_LEFT, PAL_NONE, x + WD_IMGBTN_LEFT, y + WD_IMGBTN_TOP);
2454         DrawSprite(SPR_ARROW_RIGHT, PAL_NONE, x + WD_IMGBTN_LEFT + dim.width, y + WD_IMGBTN_TOP);
2455
2456         /* Grey out the buttons that aren't clickable */
2457         bool rtl = _current_text_dir == TD_RTL;
2458         if (rtl ? !clickable_right : !clickable_left) {
2459                 GfxFillRect(x + 1, y, x + dim.width - 1, y + dim.height - 2, colour, FILLRECT_CHECKER);
2460         }
2461         if (rtl ? !clickable_left : !clickable_right) {
2462                 GfxFillRect(x + dim.width + 1, y, x + dim.width + dim.width - 1, y + dim.height - 2, colour, FILLRECT_CHECKER);
2463         }
2464 }
2465
2466 /**
2467  * Draw a dropdown button.
2468  * @param x the x position to draw
2469  * @param y the y position to draw
2470  * @param button_colour the colour of the button
2471  * @param state true = lowered
2472  * @param clickable is the button clickable?
2473  */
2474 void DrawDropDownButton(int x, int y, Colours button_colour, bool state, bool clickable)
2475 {
2476         int colour = _colour_gradient[button_colour][2];
2477
2478         DrawFrameRect(x, y, x + SETTING_BUTTON_WIDTH - 1, y + SETTING_BUTTON_HEIGHT - 1, button_colour, state ? FR_LOWERED : FR_NONE);
2479         DrawSprite(SPR_ARROW_DOWN, PAL_NONE, x + (SETTING_BUTTON_WIDTH - NWidgetScrollbar::GetVerticalDimension().width) / 2 + state, y + 2 + state);
2480
2481         if (!clickable) {
2482                 GfxFillRect(x +  1, y, x + SETTING_BUTTON_WIDTH - 1, y + SETTING_BUTTON_HEIGHT - 2, colour, FILLRECT_CHECKER);
2483         }
2484 }
2485
2486 /**
2487  * Draw a toggle button.
2488  * @param x the x position to draw
2489  * @param y the y position to draw
2490  * @param state true = lowered
2491  * @param clickable is the button clickable?
2492  */
2493 void DrawBoolButton(int x, int y, bool state, bool clickable)
2494 {
2495         static const Colours _bool_ctabs[2][2] = {{COLOUR_CREAM, COLOUR_RED}, {COLOUR_DARK_GREEN, COLOUR_GREEN}};
2496         DrawFrameRect(x, y, x + SETTING_BUTTON_WIDTH - 1, y + SETTING_BUTTON_HEIGHT - 1, _bool_ctabs[state][clickable], state ? FR_LOWERED : FR_NONE);
2497 }
2498
2499 struct CustomCurrencyWindow : Window {
2500         int query_widget;
2501
2502         CustomCurrencyWindow(WindowDesc *desc) : Window(desc)
2503         {
2504                 this->InitNested();
2505
2506                 SetButtonState();
2507         }
2508
2509         void SetButtonState()
2510         {
2511                 this->SetWidgetDisabledState(WID_CC_RATE_DOWN, _custom_currency.rate == 1);
2512                 this->SetWidgetDisabledState(WID_CC_RATE_UP, _custom_currency.rate == UINT16_MAX);
2513                 this->SetWidgetDisabledState(WID_CC_YEAR_DOWN, _custom_currency.to_euro == CF_NOEURO);
2514                 this->SetWidgetDisabledState(WID_CC_YEAR_UP, _custom_currency.to_euro == MAX_YEAR);
2515         }
2516
2517         virtual void SetStringParameters(int widget) const
2518         {
2519                 switch (widget) {
2520                         case WID_CC_RATE:      SetDParam(0, 1); SetDParam(1, 1);            break;
2521                         case WID_CC_SEPARATOR: SetDParamStr(0, _custom_currency.separator); break;
2522                         case WID_CC_PREFIX:    SetDParamStr(0, _custom_currency.prefix);    break;
2523                         case WID_CC_SUFFIX:    SetDParamStr(0, _custom_currency.suffix);    break;
2524                         case WID_CC_YEAR:
2525                                 SetDParam(0, (_custom_currency.to_euro != CF_NOEURO) ? STR_CURRENCY_SWITCH_TO_EURO : STR_CURRENCY_SWITCH_TO_EURO_NEVER);
2526                                 SetDParam(1, _custom_currency.to_euro);
2527                                 break;
2528
2529                         case WID_CC_PREVIEW:
2530                                 SetDParam(0, 10000);
2531                                 break;
2532                 }
2533         }
2534
2535         virtual void UpdateWidgetSize(int widget, Dimension *size, const Dimension &padding, Dimension *fill, Dimension *resize)
2536         {
2537                 switch (widget) {
2538                         /* Set the appropriate width for the edit 'buttons' */
2539                         case WID_CC_SEPARATOR_EDIT:
2540                         case WID_CC_PREFIX_EDIT:
2541                         case WID_CC_SUFFIX_EDIT:
2542                                 size->width  = this->GetWidget<NWidgetBase>(WID_CC_RATE_DOWN)->smallest_x + this->GetWidget<NWidgetBase>(WID_CC_RATE_UP)->smallest_x;
2543                                 break;
2544
2545                         /* Make sure the window is wide enough for the widest exchange rate */
2546                         case WID_CC_RATE:
2547                                 SetDParam(0, 1);
2548                                 SetDParam(1, INT32_MAX);
2549                                 *size = GetStringBoundingBox(STR_CURRENCY_EXCHANGE_RATE);
2550                                 break;
2551                 }
2552         }
2553
2554         virtual void OnClick(Point pt, int widget, int click_count)
2555         {
2556                 int line = 0;
2557                 int len = 0;
2558                 StringID str = 0;
2559                 CharSetFilter afilter = CS_ALPHANUMERAL;
2560
2561                 switch (widget) {
2562                         case WID_CC_RATE_DOWN:
2563                                 if (_custom_currency.rate > 1) _custom_currency.rate--;
2564                                 if (_custom_currency.rate == 1) this->DisableWidget(WID_CC_RATE_DOWN);
2565                                 this->EnableWidget(WID_CC_RATE_UP);
2566                                 break;
2567
2568                         case WID_CC_RATE_UP:
2569                                 if (_custom_currency.rate < UINT16_MAX) _custom_currency.rate++;
2570                                 if (_custom_currency.rate == UINT16_MAX) this->DisableWidget(WID_CC_RATE_UP);
2571                                 this->EnableWidget(WID_CC_RATE_DOWN);
2572                                 break;
2573
2574                         case WID_CC_RATE:
2575                                 SetDParam(0, _custom_currency.rate);
2576                                 str = STR_JUST_INT;
2577                                 len = 5;
2578                                 line = WID_CC_RATE;
2579                                 afilter = CS_NUMERAL;
2580                                 break;
2581
2582                         case WID_CC_SEPARATOR_EDIT:
2583                         case WID_CC_SEPARATOR:
2584                                 SetDParamStr(0, _custom_currency.separator);
2585                                 str = STR_JUST_RAW_STRING;
2586                                 len = 1;
2587                                 line = WID_CC_SEPARATOR;
2588                                 break;
2589
2590                         case WID_CC_PREFIX_EDIT:
2591                         case WID_CC_PREFIX:
2592                                 SetDParamStr(0, _custom_currency.prefix);
2593                                 str = STR_JUST_RAW_STRING;
2594                                 len = 12;
2595                                 line = WID_CC_PREFIX;
2596                                 break;
2597
2598                         case WID_CC_SUFFIX_EDIT:
2599                         case WID_CC_SUFFIX:
2600                                 SetDParamStr(0, _custom_currency.suffix);
2601                                 str = STR_JUST_RAW_STRING;
2602                                 len = 12;
2603                                 line = WID_CC_SUFFIX;
2604                                 break;
2605
2606                         case WID_CC_YEAR_DOWN:
2607                                 _custom_currency.to_euro = (_custom_currency.to_euro <= 2000) ? CF_NOEURO : _custom_currency.to_euro - 1;
2608                                 if (_custom_currency.to_euro == CF_NOEURO) this->DisableWidget(WID_CC_YEAR_DOWN);
2609                                 this->EnableWidget(WID_CC_YEAR_UP);
2610                                 break;
2611
2612                         case WID_CC_YEAR_UP:
2613                                 _custom_currency.to_euro = Clamp(_custom_currency.to_euro + 1, 2000, MAX_YEAR);
2614                                 if (_custom_currency.to_euro == MAX_YEAR) this->DisableWidget(WID_CC_YEAR_UP);
2615                                 this->EnableWidget(WID_CC_YEAR_DOWN);
2616                                 break;
2617
2618                         case WID_CC_YEAR:
2619                                 SetDParam(0, _custom_currency.to_euro);
2620                                 str = STR_JUST_INT;
2621                                 len = 7;
2622                                 line = WID_CC_YEAR;
2623                                 afilter = CS_NUMERAL;
2624                                 break;
2625                 }
2626
2627                 if (len != 0) {
2628                         this->query_widget = line;
2629                         ShowQueryString(str, STR_CURRENCY_CHANGE_PARAMETER, len + 1, this, afilter, QSF_NONE);
2630                 }
2631
2632                 this->SetTimeout();
2633                 this->SetDirty();
2634         }
2635
2636         virtual void OnQueryTextFinished(char *str)
2637         {
2638                 if (str == NULL) return;
2639
2640                 switch (this->query_widget) {
2641                         case WID_CC_RATE:
2642                                 _custom_currency.rate = Clamp(atoi(str), 1, UINT16_MAX);
2643                                 break;
2644
2645                         case WID_CC_SEPARATOR: // Thousands separator
2646                                 strecpy(_custom_currency.separator, str, lastof(_custom_currency.separator));
2647                                 break;
2648
2649                         case WID_CC_PREFIX:
2650                                 strecpy(_custom_currency.prefix, str, lastof(_custom_currency.prefix));
2651                                 break;
2652
2653                         case WID_CC_SUFFIX:
2654                                 strecpy(_custom_currency.suffix, str, lastof(_custom_currency.suffix));
2655                                 break;
2656
2657                         case WID_CC_YEAR: { // Year to switch to euro
2658                                 int val = atoi(str);
2659
2660                                 _custom_currency.to_euro = (val < 2000 ? CF_NOEURO : min(val, MAX_YEAR));
2661                                 break;
2662                         }
2663                 }
2664                 MarkWholeScreenDirty();
2665                 SetButtonState();
2666         }
2667
2668         virtual void OnTimeout()
2669         {
2670                 this->SetDirty();
2671         }
2672 };
2673
2674 static const NWidgetPart _nested_cust_currency_widgets[] = {
2675         NWidget(NWID_HORIZONTAL),
2676                 NWidget(WWT_CLOSEBOX, COLOUR_GREY),
2677                 NWidget(WWT_CAPTION, COLOUR_GREY), SetDataTip(STR_CURRENCY_WINDOW, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
2678         EndContainer(),
2679         NWidget(WWT_PANEL, COLOUR_GREY),
2680                 NWidget(NWID_VERTICAL, NC_EQUALSIZE), SetPIP(7, 3, 0),
2681                         NWidget(NWID_HORIZONTAL), SetPIP(10, 0, 5),
2682                                 NWidget(WWT_PUSHARROWBTN, COLOUR_YELLOW, WID_CC_RATE_DOWN), SetDataTip(AWV_DECREASE, STR_CURRENCY_DECREASE_EXCHANGE_RATE_TOOLTIP),
2683                                 NWidget(WWT_PUSHARROWBTN, COLOUR_YELLOW, WID_CC_RATE_UP), SetDataTip(AWV_INCREASE, STR_CURRENCY_INCREASE_EXCHANGE_RATE_TOOLTIP),
2684                                 NWidget(NWID_SPACER), SetMinimalSize(5, 0),
2685                                 NWidget(WWT_TEXT, COLOUR_BLUE, WID_CC_RATE), SetDataTip(STR_CURRENCY_EXCHANGE_RATE, STR_CURRENCY_SET_EXCHANGE_RATE_TOOLTIP), SetFill(1, 0),
2686                         EndContainer(),
2687                         NWidget(NWID_HORIZONTAL), SetPIP(10, 0, 5),
2688                                 NWidget(WWT_PUSHBTN, COLOUR_DARK_BLUE, WID_CC_SEPARATOR_EDIT), SetDataTip(0x0, STR_CURRENCY_SET_CUSTOM_CURRENCY_SEPARATOR_TOOLTIP), SetFill(0, 1),
2689                                 NWidget(NWID_SPACER), SetMinimalSize(5, 0),
2690                                 NWidget(WWT_TEXT, COLOUR_BLUE, WID_CC_SEPARATOR), SetDataTip(STR_CURRENCY_SEPARATOR, STR_CURRENCY_SET_CUSTOM_CURRENCY_SEPARATOR_TOOLTIP), SetFill(1, 0),
2691                         EndContainer(),
2692                         NWidget(NWID_HORIZONTAL), SetPIP(10, 0, 5),
2693                                 NWidget(WWT_PUSHBTN, COLOUR_DARK_BLUE, WID_CC_PREFIX_EDIT), SetDataTip(0x0, STR_CURRENCY_SET_CUSTOM_CURRENCY_PREFIX_TOOLTIP), SetFill(0, 1),
2694                                 NWidget(NWID_SPACER), SetMinimalSize(5, 0),
2695                                 NWidget(WWT_TEXT, COLOUR_BLUE, WID_CC_PREFIX), SetDataTip(STR_CURRENCY_PREFIX, STR_CURRENCY_SET_CUSTOM_CURRENCY_PREFIX_TOOLTIP), SetFill(1, 0),
2696                         EndContainer(),
2697                         NWidget(NWID_HORIZONTAL), SetPIP(10, 0, 5),
2698                                 NWidget(WWT_PUSHBTN, COLOUR_DARK_BLUE, WID_CC_SUFFIX_EDIT), SetDataTip(0x0, STR_CURRENCY_SET_CUSTOM_CURRENCY_SUFFIX_TOOLTIP), SetFill(0, 1),
2699                                 NWidget(NWID_SPACER), SetMinimalSize(5, 0),
2700                                 NWidget(WWT_TEXT, COLOUR_BLUE, WID_CC_SUFFIX), SetDataTip(STR_CURRENCY_SUFFIX, STR_CURRENCY_SET_CUSTOM_CURRENCY_SUFFIX_TOOLTIP), SetFill(1, 0),
2701                         EndContainer(),
2702                         NWidget(NWID_HORIZONTAL), SetPIP(10, 0, 5),
2703                                 NWidget(WWT_PUSHARROWBTN, COLOUR_YELLOW, WID_CC_YEAR_DOWN), SetDataTip(AWV_DECREASE, STR_CURRENCY_DECREASE_CUSTOM_CURRENCY_TO_EURO_TOOLTIP),
2704                                 NWidget(WWT_PUSHARROWBTN, COLOUR_YELLOW, WID_CC_YEAR_UP), SetDataTip(AWV_INCREASE, STR_CURRENCY_INCREASE_CUSTOM_CURRENCY_TO_EURO_TOOLTIP),
2705                                 NWidget(NWID_SPACER), SetMinimalSize(5, 0),
2706                                 NWidget(WWT_TEXT, COLOUR_BLUE, WID_CC_YEAR), SetDataTip(STR_JUST_STRING, STR_CURRENCY_SET_CUSTOM_CURRENCY_TO_EURO_TOOLTIP), SetFill(1, 0),
2707                         EndContainer(),
2708                 EndContainer(),
2709                 NWidget(WWT_LABEL, COLOUR_BLUE, WID_CC_PREVIEW),
2710                                                                 SetDataTip(STR_CURRENCY_PREVIEW, STR_CURRENCY_CUSTOM_CURRENCY_PREVIEW_TOOLTIP), SetPadding(15, 1, 18, 2),
2711         EndContainer(),
2712 };
2713
2714 static WindowDesc _cust_currency_desc(
2715         WDP_CENTER, NULL, 0, 0,
2716         WC_CUSTOM_CURRENCY, WC_NONE,
2717         0,
2718         _nested_cust_currency_widgets, lengthof(_nested_cust_currency_widgets)
2719 );
2720
2721 /** Open custom currency window. */
2722 static void ShowCustCurrency()
2723 {
2724         DeleteWindowById(WC_CUSTOM_CURRENCY, 0);
2725         new CustomCurrencyWindow(&_cust_currency_desc);
2726 }