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