OpenTTD Source: src/rail_gui.cpp Source File

OpenTTD Source 12.2

rail_gui.cpp
Go to the documentation of this file.
1 /*
2 * This file is part of OpenTTD.
3 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
4 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
5 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
6 */
7
10 #include "stdafx.h"
11 #include "gui.h"
12 #include "window_gui.h"
13 #include "station_gui.h"
14 #include "terraform_gui.h"
15 #include "viewport_func.h"
16 #include "command_func.h"
17 #include "waypoint_func.h"
18 #include "newgrf_station.h"
19 #include "company_base.h"
20 #include "strings_func.h"
21 #include "window_func.h"
22 #include "date_func.h"
23 #include "sound_func.h"
24 #include "company_func.h"
25 #include "widgets/dropdown_type.h"
26 #include "tunnelbridge.h"
27 #include "tilehighlight_func.h"
28 #include "spritecache.h"
29 #include "core/geometry_func.hpp"
30 #include "hotkeys.h"
31 #include "engine_base.h"
32 #include "vehicle_func.h"
33 #include "zoom_func.h"
34 #include "rail_gui.h"
35 #include "querystring_gui.h"
36 #include "sortlist_type.h"
37 #include "stringfilter_type.h"
38 #include "string_func.h"
39
40 #include "station_map.h"
41 #include "tunnelbridge_map.h"
42
43 #include "widgets/rail_widget.h"
44
45 #include "safeguards.h"
46
47
48 static RailType _cur_railtype;
49 static bool _remove_button_clicked;
50 static DiagDirection _build_depot_direction;
51 static byte _waypoint_count = 1;
52 static byte _cur_waypoint_type;
53 static bool _convert_signal_button;
54 static SignalVariant _cur_signal_variant;
55 static SignalType _cur_signal_type;
56
57 struct RailStationGUISettings {
58 Axis orientation;
59
60 bool newstations;
61 StationClassID station_class;
62 byte station_type;
63 byte station_count;
64 };
65 static RailStationGUISettings _railstation;
66
67
68 static void HandleStationPlacement(TileIndex start, TileIndex end);
69 static void ShowBuildTrainDepotPicker(Window *parent);
70 static void ShowBuildWaypointPicker(Window *parent);
71 static Window *ShowStationBuilder(Window *parent);
72 static void ShowSignalBuilder(Window *parent);
73
78 static bool IsStationAvailable(const StationSpec *statspec)
79 {
80 if (statspec == nullptr || !HasBit(statspec->callback_mask, CBM_STATION_AVAIL)) return true;
81
82 uint16 cb_res = GetStationCallback(CBID_STATION_AVAILABILITY, 0, 0, statspec, nullptr, INVALID_TILE);
83 if (cb_res == CALLBACK_FAILED) return true;
84
85 return Convert8bitBooleanCallback(statspec->grf_prop.grffile, CBID_STATION_AVAILABILITY, cb_res);
86 }
87
88 void CcPlaySound_CONSTRUCTION_RAIL(const CommandCost &result, TileIndex tile, uint32 p1, uint32 p2, uint32 cmd)
89 {
90 if (result.Succeeded() && _settings_client.sound.confirm) SndPlayTileFx(SND_20_CONSTRUCTION_RAIL, tile);
91 }
92
93 static void GenericPlaceRail(TileIndex tile, int cmd)
94 {
95 DoCommandP(tile, _cur_railtype, cmd | (_settings_client.gui.auto_remove_signals << 3),
96 _remove_button_clicked ?
97 CMD_REMOVE_SINGLE_RAIL | CMD_MSG(STR_ERROR_CAN_T_REMOVE_RAILROAD_TRACK) :
98 CMD_BUILD_SINGLE_RAIL | CMD_MSG(STR_ERROR_CAN_T_BUILD_RAILROAD_TRACK),
99 CcPlaySound_CONSTRUCTION_RAIL);
100 }
101
109 static void PlaceExtraDepotRail(TileIndex tile, DiagDirection dir, Track track)
110 {
111 if (GetRailTileType(tile) == RAIL_TILE_DEPOT) return;
112 if (GetRailTileType(tile) == RAIL_TILE_SIGNALS && !_settings_client.gui.auto_remove_signals) return;
113 if ((GetTrackBits(tile) & DiagdirReachesTracks(dir)) == 0) return;
114
115 DoCommandP(tile, _cur_railtype, track | (_settings_client.gui.auto_remove_signals << 3), CMD_BUILD_SINGLE_RAIL);
116 }
117
119 static const Track _place_depot_extra_track[12] = {
120 TRACK_LEFT, TRACK_UPPER, TRACK_UPPER, TRACK_RIGHT, // First additional track for directions 0..3
121 TRACK_X, TRACK_Y, TRACK_X, TRACK_Y, // Second additional track
122 TRACK_LOWER, TRACK_LEFT, TRACK_RIGHT, TRACK_LOWER, // Third additional track
123 };
124
126 static const DiagDirection _place_depot_extra_dir[12] = {
127 DIAGDIR_SE, DIAGDIR_SW, DIAGDIR_SE, DIAGDIR_SW,
128 DIAGDIR_SW, DIAGDIR_NW, DIAGDIR_NE, DIAGDIR_SE,
129 DIAGDIR_NW, DIAGDIR_NE, DIAGDIR_NW, DIAGDIR_NE,
130 };
131
132 void CcRailDepot(const CommandCost &result, TileIndex tile, uint32 p1, uint32 p2, uint32 cmd)
133 {
134 if (result.Failed()) return;
135
136 DiagDirection dir = (DiagDirection)p2;
137
138 if (_settings_client.sound.confirm) SndPlayTileFx(SND_20_CONSTRUCTION_RAIL, tile);
139 if (!_settings_client.gui.persistent_buildingtools) ResetObjectToPlace();
140
141 tile += TileOffsByDiagDir(dir);
142
143 if (IsTileType(tile, MP_RAILWAY)) {
144 PlaceExtraDepotRail(tile, _place_depot_extra_dir[dir], _place_depot_extra_track[dir]);
145 PlaceExtraDepotRail(tile, _place_depot_extra_dir[dir + 4], _place_depot_extra_track[dir + 4]);
146 PlaceExtraDepotRail(tile, _place_depot_extra_dir[dir + 8], _place_depot_extra_track[dir + 8]);
147 }
148 }
149
154 static void PlaceRail_Waypoint(TileIndex tile)
155 {
156 if (_remove_button_clicked) {
157 VpStartPlaceSizing(tile, VPM_X_AND_Y, DDSP_REMOVE_STATION);
158 return;
159 }
160
161 Axis axis = GetAxisForNewWaypoint(tile);
162 if (IsValidAxis(axis)) {
163 /* Valid tile for waypoints */
164 VpStartPlaceSizing(tile, axis == AXIS_X ? VPM_X_LIMITED : VPM_Y_LIMITED, DDSP_BUILD_STATION);
165 VpSetPlaceSizingLimit(_settings_game.station.station_spread);
166 } else {
167 /* Tile where we can't build rail waypoints. This is always going to fail,
168 * but provides the user with a proper error message. */
169 DoCommandP(tile, 1 << 8 | 1 << 16, STAT_CLASS_WAYP | INVALID_STATION << 16, CMD_BUILD_RAIL_WAYPOINT | CMD_MSG(STR_ERROR_CAN_T_BUILD_TRAIN_WAYPOINT));
170 }
171 }
172
173 void CcStation(const CommandCost &result, TileIndex tile, uint32 p1, uint32 p2, uint32 cmd)
174 {
175 if (result.Failed()) return;
176
177 if (_settings_client.sound.confirm) SndPlayTileFx(SND_20_CONSTRUCTION_RAIL, tile);
178 /* Only close the station builder window if the default station and non persistent building is chosen. */
179 if (_railstation.station_class == STAT_CLASS_DFLT && _railstation.station_type == 0 && !_settings_client.gui.persistent_buildingtools) ResetObjectToPlace();
180 }
181
186 static void PlaceRail_Station(TileIndex tile)
187 {
188 if (_remove_button_clicked) {
189 VpStartPlaceSizing(tile, VPM_X_AND_Y_LIMITED, DDSP_REMOVE_STATION);
190 VpSetPlaceSizingLimit(-1);
191 } else if (_settings_client.gui.station_dragdrop) {
192 VpStartPlaceSizing(tile, VPM_X_AND_Y_LIMITED, DDSP_BUILD_STATION);
193 VpSetPlaceSizingLimit(_settings_game.station.station_spread);
194 } else {
195 uint32 p1 = _cur_railtype | _railstation.orientation << 6 | _settings_client.gui.station_numtracks << 8 | _settings_client.gui.station_platlength << 16 | _ctrl_pressed << 24;
196 uint32 p2 = _railstation.station_class | _railstation.station_type << 8 | INVALID_STATION << 16;
197
198 int w = _settings_client.gui.station_numtracks;
199 int h = _settings_client.gui.station_platlength;
200 if (!_railstation.orientation) Swap(w, h);
201
202 CommandContainer cmdcont = { tile, p1, p2, CMD_BUILD_RAIL_STATION | CMD_MSG(STR_ERROR_CAN_T_BUILD_RAILROAD_STATION), CcStation, "" };
203 ShowSelectStationIfNeeded(cmdcont, TileArea(tile, w, h));
204 }
205 }
206
212 static void GenericPlaceSignals(TileIndex tile)
213 {
214 TrackBits trackbits = TrackStatusToTrackBits(GetTileTrackStatus(tile, TRANSPORT_RAIL, 0));
215
216 if (trackbits & TRACK_BIT_VERT) { // N-S direction
217 trackbits = (_tile_fract_coords.x <= _tile_fract_coords.y) ? TRACK_BIT_RIGHT : TRACK_BIT_LEFT;
218 }
219
220 if (trackbits & TRACK_BIT_HORZ) { // E-W direction
221 trackbits = (_tile_fract_coords.x + _tile_fract_coords.y <= 15) ? TRACK_BIT_UPPER : TRACK_BIT_LOWER;
222 }
223
224 Track track = FindFirstTrack(trackbits);
225
226 if (_remove_button_clicked) {
227 DoCommandP(tile, track, 0, CMD_REMOVE_SIGNALS | CMD_MSG(STR_ERROR_CAN_T_REMOVE_SIGNALS_FROM), CcPlaySound_CONSTRUCTION_RAIL);
228 } else {
229 const Window *w = FindWindowById(WC_BUILD_SIGNAL, 0);
230
231 /* various bitstuffed elements for CmdBuildSingleSignal() */
232 uint32 p1 = track;
233
234 /* Which signals should we cycle through? */
235 uint8 cycle_types;
236
237 if (_settings_client.gui.cycle_signal_types == SIGNAL_CYCLE_ALL && _settings_client.gui.signal_gui_mode == SIGNAL_GUI_ALL) {
238 cycle_types = SIGTYPE_NORMAL | (SIGTYPE_LAST << 3);
239 } else {
240 cycle_types = SIGTYPE_PBS | (SIGTYPE_LAST << 3);
241 }
242
243 if (w != nullptr) {
244 /* signal GUI is used */
245 SB(p1, 3, 1, _ctrl_pressed);
246 SB(p1, 4, 1, _cur_signal_variant);
247 SB(p1, 5, 3, _cur_signal_type);
248 SB(p1, 8, 1, _convert_signal_button);
249 SB(p1, 9, 6, cycle_types);
250 } else {
251 SB(p1, 3, 1, _ctrl_pressed);
252 SB(p1, 4, 1, (_cur_year < _settings_client.gui.semaphore_build_before ? SIG_SEMAPHORE : SIG_ELECTRIC));
253 SB(p1, 5, 3, _settings_client.gui.default_signal_type);
254 SB(p1, 8, 1, 0);
255 SB(p1, 9, 6, cycle_types);
256 }
257
258 DoCommandP(tile, p1, 0, CMD_BUILD_SIGNALS |
259 CMD_MSG((w != nullptr && _convert_signal_button) ? STR_ERROR_SIGNAL_CAN_T_CONVERT_SIGNALS_HERE : STR_ERROR_CAN_T_BUILD_SIGNALS_HERE),
260 CcPlaySound_CONSTRUCTION_RAIL);
261 }
262 }
263
269 static void PlaceRail_Bridge(TileIndex tile, Window *w)
270 {
271 if (IsBridgeTile(tile)) {
272 TileIndex other_tile = GetOtherTunnelBridgeEnd(tile);
273 Point pt = {0, 0};
274 w->OnPlaceMouseUp(VPM_X_OR_Y, DDSP_BUILD_BRIDGE, pt, other_tile, tile);
275 } else {
276 VpStartPlaceSizing(tile, VPM_X_OR_Y, DDSP_BUILD_BRIDGE);
277 }
278 }
279
281 void CcBuildRailTunnel(const CommandCost &result, TileIndex tile, uint32 p1, uint32 p2, uint32 cmd)
282 {
283 if (result.Succeeded()) {
284 if (_settings_client.sound.confirm) SndPlayTileFx(SND_20_CONSTRUCTION_RAIL, tile);
285 if (!_settings_client.gui.persistent_buildingtools) ResetObjectToPlace();
286 } else {
287 SetRedErrorSquare(_build_tunnel_endtile);
288 }
289 }
290
295 static void ToggleRailButton_Remove(Window *w)
296 {
297 CloseWindowById(WC_SELECT_STATION, 0);
298 w->ToggleWidgetLoweredState(WID_RAT_REMOVE);
299 w->SetWidgetDirty(WID_RAT_REMOVE);
300 _remove_button_clicked = w->IsWidgetLowered(WID_RAT_REMOVE);
301 SetSelectionRed(_remove_button_clicked);
302 }
303
309 static bool RailToolbar_CtrlChanged(Window *w)
310 {
311 if (w->IsWidgetDisabled(WID_RAT_REMOVE)) return false;
312
313 /* allow ctrl to switch remove mode only for these widgets */
314 for (uint i = WID_RAT_BUILD_NS; i <= WID_RAT_BUILD_STATION; i++) {
315 if ((i <= WID_RAT_AUTORAIL || i >= WID_RAT_BUILD_WAYPOINT) && w->IsWidgetLowered(i)) {
316 ToggleRailButton_Remove(w);
317 return true;
318 }
319 }
320
321 return false;
322 }
323
324
330 static void BuildRailClick_Remove(Window *w)
331 {
332 if (w->IsWidgetDisabled(WID_RAT_REMOVE)) return;
333 ToggleRailButton_Remove(w);
334 if (_settings_client.sound.click_beep) SndPlayFx(SND_15_BEEP);
335
336 /* handle station builder */
337 if (w->IsWidgetLowered(WID_RAT_BUILD_STATION)) {
338 if (_remove_button_clicked) {
339 /* starting drag & drop remove */
340 if (!_settings_client.gui.station_dragdrop) {
341 SetTileSelectSize(1, 1);
342 } else {
343 VpSetPlaceSizingLimit(-1);
344 }
345 } else {
346 /* starting station build mode */
347 if (!_settings_client.gui.station_dragdrop) {
348 int x = _settings_client.gui.station_numtracks;
349 int y = _settings_client.gui.station_platlength;
350 if (_railstation.orientation == 0) Swap(x, y);
351 SetTileSelectSize(x, y);
352 } else {
353 VpSetPlaceSizingLimit(_settings_game.station.station_spread);
354 }
355 }
356 }
357 }
358
359 static void DoRailroadTrack(int mode)
360 {
361 uint32 p2 = _cur_railtype | (mode << 6) | (_settings_client.gui.auto_remove_signals << 11);
362 DoCommandP(TileVirtXY(_thd.selstart.x, _thd.selstart.y), TileVirtXY(_thd.selend.x, _thd.selend.y), p2,
363 _remove_button_clicked ?
364 CMD_REMOVE_RAILROAD_TRACK | CMD_MSG(STR_ERROR_CAN_T_REMOVE_RAILROAD_TRACK) :
365 CMD_BUILD_RAILROAD_TRACK | CMD_MSG(STR_ERROR_CAN_T_BUILD_RAILROAD_TRACK),
366 CcPlaySound_CONSTRUCTION_RAIL);
367 }
368
369 static void HandleAutodirPlacement()
370 {
371 int trackstat = _thd.drawstyle & HT_DIR_MASK; // 0..5
372
373 if (_thd.drawstyle & HT_RAIL) { // one tile case
374 GenericPlaceRail(TileVirtXY(_thd.selend.x, _thd.selend.y), trackstat);
375 return;
376 }
377
378 DoRailroadTrack(trackstat);
379 }
380
387 static void HandleAutoSignalPlacement()
388 {
389 uint32 p2 = GB(_thd.drawstyle, 0, 3); // 0..5
390
391 if ((_thd.drawstyle & HT_DRAG_MASK) == HT_RECT) { // one tile case
392 GenericPlaceSignals(TileVirtXY(_thd.selend.x, _thd.selend.y));
393 return;
394 }
395
396 const Window *w = FindWindowById(WC_BUILD_SIGNAL, 0);
397
398 if (w != nullptr) {
399 /* signal GUI is used */
400 SB(p2, 3, 1, 0);
401 SB(p2, 4, 1, _cur_signal_variant);
402 SB(p2, 6, 1, _ctrl_pressed);
403 SB(p2, 7, 3, _cur_signal_type);
404 SB(p2, 24, 8, _settings_client.gui.drag_signals_density);
405 SB(p2, 10, 1, !_settings_client.gui.drag_signals_fixed_distance);
406 } else {
407 SB(p2, 3, 1, 0);
408 SB(p2, 4, 1, (_cur_year < _settings_client.gui.semaphore_build_before ? SIG_SEMAPHORE : SIG_ELECTRIC));
409 SB(p2, 6, 1, _ctrl_pressed);
410 SB(p2, 7, 3, _settings_client.gui.default_signal_type);
411 SB(p2, 24, 8, _settings_client.gui.drag_signals_density);
412 SB(p2, 10, 1, !_settings_client.gui.drag_signals_fixed_distance);
413 }
414
415 /* _settings_client.gui.drag_signals_density is given as a parameter such that each user
416 * in a network game can specify their own signal density */
417 DoCommandP(TileVirtXY(_thd.selstart.x, _thd.selstart.y), TileVirtXY(_thd.selend.x, _thd.selend.y), p2,
418 _remove_button_clicked ?
419 CMD_REMOVE_SIGNAL_TRACK | CMD_MSG(STR_ERROR_CAN_T_REMOVE_SIGNALS_FROM) :
420 CMD_BUILD_SIGNAL_TRACK | CMD_MSG(STR_ERROR_CAN_T_BUILD_SIGNALS_HERE),
421 CcPlaySound_CONSTRUCTION_RAIL);
422 }
423
424
426 struct BuildRailToolbarWindow : Window {
427 RailType railtype;
428 int last_user_action;
429
430 BuildRailToolbarWindow(WindowDesc *desc, RailType railtype) : Window(desc)
431 {
432 this->InitNested(TRANSPORT_RAIL);
433 this->SetupRailToolbar(railtype);
434 this->DisableWidget(WID_RAT_REMOVE);
435 this->last_user_action = WIDGET_LIST_END;
436
437 if (_settings_client.gui.link_terraform_toolbar) ShowTerraformToolbar(this);
438 }
439
440 void Close() override
441 {
442 if (this->IsWidgetLowered(WID_RAT_BUILD_STATION)) SetViewportCatchmentStation(nullptr, true);
443 if (_settings_client.gui.link_terraform_toolbar) CloseWindowById(WC_SCEN_LAND_GEN, 0, false);
444 this->Window::Close();
445 }
446
451 void SetupRailToolbar(RailType railtype)
452 {
453 this->railtype = railtype;
454 const RailtypeInfo *rti = GetRailTypeInfo(railtype);
455
456 assert(railtype < RAILTYPE_END);
457 this->GetWidget<NWidgetCore>(WID_RAT_BUILD_NS)->widget_data = rti->gui_sprites.build_ns_rail;
458 this->GetWidget<NWidgetCore>(WID_RAT_BUILD_X)->widget_data = rti->gui_sprites.build_x_rail;
459 this->GetWidget<NWidgetCore>(WID_RAT_BUILD_EW)->widget_data = rti->gui_sprites.build_ew_rail;
460 this->GetWidget<NWidgetCore>(WID_RAT_BUILD_Y)->widget_data = rti->gui_sprites.build_y_rail;
461 this->GetWidget<NWidgetCore>(WID_RAT_AUTORAIL)->widget_data = rti->gui_sprites.auto_rail;
462 this->GetWidget<NWidgetCore>(WID_RAT_BUILD_DEPOT)->widget_data = rti->gui_sprites.build_depot;
463 this->GetWidget<NWidgetCore>(WID_RAT_CONVERT_RAIL)->widget_data = rti->gui_sprites.convert_rail;
464 this->GetWidget<NWidgetCore>(WID_RAT_BUILD_TUNNEL)->widget_data = rti->gui_sprites.build_tunnel;
465 }
466
471 void ModifyRailType(RailType railtype)
472 {
473 this->SetupRailToolbar(railtype);
474 this->ReInit();
475 }
476
477 void UpdateRemoveWidgetStatus(int clicked_widget)
478 {
479 switch (clicked_widget) {
480 case WID_RAT_REMOVE:
481 /* If it is the removal button that has been clicked, do nothing,
482 * as it is up to the other buttons to drive removal status */
483 return;
484
485 case WID_RAT_BUILD_NS:
486 case WID_RAT_BUILD_X:
487 case WID_RAT_BUILD_EW:
488 case WID_RAT_BUILD_Y:
489 case WID_RAT_AUTORAIL:
490 case WID_RAT_BUILD_WAYPOINT:
491 case WID_RAT_BUILD_STATION:
492 case WID_RAT_BUILD_SIGNALS:
493 /* Removal button is enabled only if the rail/signal/waypoint/station
494 * button is still lowered. Once raised, it has to be disabled */
495 this->SetWidgetDisabledState(WID_RAT_REMOVE, !this->IsWidgetLowered(clicked_widget));
496 break;
497
498 default:
499 /* When any other buttons than rail/signal/waypoint/station, raise and
500 * disable the removal button */
501 this->DisableWidget(WID_RAT_REMOVE);
502 this->RaiseWidget(WID_RAT_REMOVE);
503 break;
504 }
505 }
506
507 void SetStringParameters(int widget) const override
508 {
509 if (widget == WID_RAT_CAPTION) {
510 const RailtypeInfo *rti = GetRailTypeInfo(this->railtype);
511 if (rti->max_speed > 0) {
512 SetDParam(0, STR_TOOLBAR_RAILTYPE_VELOCITY);
513 SetDParam(1, rti->strings.toolbar_caption);
514 SetDParam(2, rti->max_speed);
515 } else {
516 SetDParam(0, rti->strings.toolbar_caption);
517 }
518 }
519 }
520
521 void OnClick(Point pt, int widget, int click_count) override
522 {
523 if (widget < WID_RAT_BUILD_NS) return;
524
525 _remove_button_clicked = false;
526 switch (widget) {
527 case WID_RAT_BUILD_NS:
528 HandlePlacePushButton(this, WID_RAT_BUILD_NS, GetRailTypeInfo(_cur_railtype)->cursor.rail_ns, HT_LINE | HT_DIR_VL);
529 this->last_user_action = widget;
530 break;
531
532 case WID_RAT_BUILD_X:
533 HandlePlacePushButton(this, WID_RAT_BUILD_X, GetRailTypeInfo(_cur_railtype)->cursor.rail_swne, HT_LINE | HT_DIR_X);
534 this->last_user_action = widget;
535 break;
536
537 case WID_RAT_BUILD_EW:
538 HandlePlacePushButton(this, WID_RAT_BUILD_EW, GetRailTypeInfo(_cur_railtype)->cursor.rail_ew, HT_LINE | HT_DIR_HL);
539 this->last_user_action = widget;
540 break;
541
542 case WID_RAT_BUILD_Y:
543 HandlePlacePushButton(this, WID_RAT_BUILD_Y, GetRailTypeInfo(_cur_railtype)->cursor.rail_nwse, HT_LINE | HT_DIR_Y);
544 this->last_user_action = widget;
545 break;
546
547 case WID_RAT_AUTORAIL:
548 HandlePlacePushButton(this, WID_RAT_AUTORAIL, GetRailTypeInfo(_cur_railtype)->cursor.autorail, HT_RAIL);
549 this->last_user_action = widget;
550 break;
551
552 case WID_RAT_DEMOLISH:
553 HandlePlacePushButton(this, WID_RAT_DEMOLISH, ANIMCURSOR_DEMOLISH, HT_RECT | HT_DIAGONAL);
554 this->last_user_action = widget;
555 break;
556
557 case WID_RAT_BUILD_DEPOT:
558 if (HandlePlacePushButton(this, WID_RAT_BUILD_DEPOT, GetRailTypeInfo(_cur_railtype)->cursor.depot, HT_RECT)) {
559 ShowBuildTrainDepotPicker(this);
560 this->last_user_action = widget;
561 }
562 break;
563
564 case WID_RAT_BUILD_WAYPOINT:
565 this->last_user_action = widget;
566 _waypoint_count = StationClass::Get(STAT_CLASS_WAYP)->GetSpecCount();
567 if (HandlePlacePushButton(this, WID_RAT_BUILD_WAYPOINT, SPR_CURSOR_WAYPOINT, HT_RECT) && _waypoint_count > 1) {
568 ShowBuildWaypointPicker(this);
569 }
570 break;
571
572 case WID_RAT_BUILD_STATION:
573 if (HandlePlacePushButton(this, WID_RAT_BUILD_STATION, SPR_CURSOR_RAIL_STATION, HT_RECT)) {
574 ShowStationBuilder(this);
575 this->last_user_action = widget;
576 }
577 break;
578
579 case WID_RAT_BUILD_SIGNALS: {
580 this->last_user_action = widget;
581 bool started = HandlePlacePushButton(this, WID_RAT_BUILD_SIGNALS, ANIMCURSOR_BUILDSIGNALS, HT_RECT);
582 if (started != _ctrl_pressed) {
583 ShowSignalBuilder(this);
584 }
585 break;
586 }
587
588 case WID_RAT_BUILD_BRIDGE:
589 HandlePlacePushButton(this, WID_RAT_BUILD_BRIDGE, SPR_CURSOR_BRIDGE, HT_RECT);
590 this->last_user_action = widget;
591 break;
592
593 case WID_RAT_BUILD_TUNNEL:
594 HandlePlacePushButton(this, WID_RAT_BUILD_TUNNEL, GetRailTypeInfo(_cur_railtype)->cursor.tunnel, HT_SPECIAL);
595 this->last_user_action = widget;
596 break;
597
598 case WID_RAT_REMOVE:
599 BuildRailClick_Remove(this);
600 break;
601
602 case WID_RAT_CONVERT_RAIL:
603 HandlePlacePushButton(this, WID_RAT_CONVERT_RAIL, GetRailTypeInfo(_cur_railtype)->cursor.convert, HT_RECT | HT_DIAGONAL);
604 this->last_user_action = widget;
605 break;
606
607 default: NOT_REACHED();
608 }
609 this->UpdateRemoveWidgetStatus(widget);
610 if (_ctrl_pressed) RailToolbar_CtrlChanged(this);
611 }
612
613 EventState OnHotkey(int hotkey) override
614 {
615 MarkTileDirtyByTile(TileVirtXY(_thd.pos.x, _thd.pos.y)); // redraw tile selection
616 return Window::OnHotkey(hotkey);
617 }
618
619 void OnPlaceObject(Point pt, TileIndex tile) override
620 {
621 switch (this->last_user_action) {
622 case WID_RAT_BUILD_NS:
623 VpStartPlaceSizing(tile, VPM_FIX_VERTICAL | VPM_RAILDIRS, DDSP_PLACE_RAIL);
624 break;
625
626 case WID_RAT_BUILD_X:
627 VpStartPlaceSizing(tile, VPM_FIX_Y | VPM_RAILDIRS, DDSP_PLACE_RAIL);
628 break;
629
630 case WID_RAT_BUILD_EW:
631 VpStartPlaceSizing(tile, VPM_FIX_HORIZONTAL | VPM_RAILDIRS, DDSP_PLACE_RAIL);
632 break;
633
634 case WID_RAT_BUILD_Y:
635 VpStartPlaceSizing(tile, VPM_FIX_X | VPM_RAILDIRS, DDSP_PLACE_RAIL);
636 break;
637
638 case WID_RAT_AUTORAIL:
639 VpStartPlaceSizing(tile, VPM_RAILDIRS, DDSP_PLACE_RAIL);
640 break;
641
642 case WID_RAT_DEMOLISH:
643 PlaceProc_DemolishArea(tile);
644 break;
645
646 case WID_RAT_BUILD_DEPOT:
647 DoCommandP(tile, _cur_railtype, _build_depot_direction,
648 CMD_BUILD_TRAIN_DEPOT | CMD_MSG(STR_ERROR_CAN_T_BUILD_TRAIN_DEPOT),
649 CcRailDepot);
650 break;
651
652 case WID_RAT_BUILD_WAYPOINT:
653 PlaceRail_Waypoint(tile);
654 break;
655
656 case WID_RAT_BUILD_STATION:
657 PlaceRail_Station(tile);
658 break;
659
660 case WID_RAT_BUILD_SIGNALS:
661 VpStartPlaceSizing(tile, VPM_SIGNALDIRS, DDSP_BUILD_SIGNALS);
662 break;
663
664 case WID_RAT_BUILD_BRIDGE:
665 PlaceRail_Bridge(tile, this);
666 break;
667
668 case WID_RAT_BUILD_TUNNEL:
669 DoCommandP(tile, _cur_railtype | (TRANSPORT_RAIL << 8), 0, CMD_BUILD_TUNNEL | CMD_MSG(STR_ERROR_CAN_T_BUILD_TUNNEL_HERE), CcBuildRailTunnel);
670 break;
671
672 case WID_RAT_CONVERT_RAIL:
673 VpStartPlaceSizing(tile, VPM_X_AND_Y, DDSP_CONVERT_RAIL);
674 break;
675
676 default: NOT_REACHED();
677 }
678 }
679
680 void OnPlaceDrag(ViewportPlaceMethod select_method, ViewportDragDropSelectionProcess select_proc, Point pt) override
681 {
682 /* no dragging if you have pressed the convert button */
683 if (FindWindowById(WC_BUILD_SIGNAL, 0) != nullptr && _convert_signal_button && this->IsWidgetLowered(WID_RAT_BUILD_SIGNALS)) return;
684
685 VpSelectTilesWithMethod(pt.x, pt.y, select_method);
686 }
687
688 void OnPlaceMouseUp(ViewportPlaceMethod select_method, ViewportDragDropSelectionProcess select_proc, Point pt, TileIndex start_tile, TileIndex end_tile) override
689 {
690 if (pt.x != -1) {
691 switch (select_proc) {
692 default: NOT_REACHED();
693 case DDSP_BUILD_BRIDGE:
694 if (!_settings_client.gui.persistent_buildingtools) ResetObjectToPlace();
695 ShowBuildBridgeWindow(start_tile, end_tile, TRANSPORT_RAIL, _cur_railtype);
696 break;
697
698 case DDSP_PLACE_RAIL:
699 HandleAutodirPlacement();
700 break;
701
702 case DDSP_BUILD_SIGNALS:
703 HandleAutoSignalPlacement();
704 break;
705
706 case DDSP_DEMOLISH_AREA:
707 GUIPlaceProcDragXY(select_proc, start_tile, end_tile);
708 break;
709
710 case DDSP_CONVERT_RAIL:
711 DoCommandP(end_tile, start_tile, _cur_railtype | (_ctrl_pressed ? 1 << 6 : 0), CMD_CONVERT_RAIL | CMD_MSG(STR_ERROR_CAN_T_CONVERT_RAIL), CcPlaySound_CONSTRUCTION_RAIL);
712 break;
713
714 case DDSP_REMOVE_STATION:
715 case DDSP_BUILD_STATION:
716 if (this->IsWidgetLowered(WID_RAT_BUILD_STATION)) {
717 /* Station */
718 if (_remove_button_clicked) {
719 DoCommandP(end_tile, start_tile, _ctrl_pressed ? 0 : 1, CMD_REMOVE_FROM_RAIL_STATION | CMD_MSG(STR_ERROR_CAN_T_REMOVE_PART_OF_STATION), CcPlaySound_CONSTRUCTION_RAIL);
720 } else {
721 HandleStationPlacement(start_tile, end_tile);
722 }
723 } else {
724 /* Waypoint */
725 if (_remove_button_clicked) {
726 DoCommandP(end_tile, start_tile, _ctrl_pressed ? 0 : 1, CMD_REMOVE_FROM_RAIL_WAYPOINT | CMD_MSG(STR_ERROR_CAN_T_REMOVE_TRAIN_WAYPOINT), CcPlaySound_CONSTRUCTION_RAIL);
727 } else {
728 TileArea ta(start_tile, end_tile);
729 uint32 p1 = _cur_railtype | (select_method == VPM_X_LIMITED ? AXIS_X : AXIS_Y) << 6 | ta.w << 8 | ta.h << 16 | _ctrl_pressed << 24;
730 uint32 p2 = STAT_CLASS_WAYP | _cur_waypoint_type << 8 | INVALID_STATION << 16;
731
732 CommandContainer cmdcont = { ta.tile, p1, p2, CMD_BUILD_RAIL_WAYPOINT | CMD_MSG(STR_ERROR_CAN_T_BUILD_TRAIN_WAYPOINT), CcPlaySound_CONSTRUCTION_RAIL, "" };
733 ShowSelectWaypointIfNeeded(cmdcont, ta);
734 }
735 }
736 break;
737 }
738 }
739 }
740
741 void OnPlaceObjectAbort() override
742 {
743 if (this->IsWidgetLowered(WID_RAT_BUILD_STATION)) SetViewportCatchmentStation(nullptr, true);
744
745 this->RaiseButtons();
746 this->DisableWidget(WID_RAT_REMOVE);
747 this->SetWidgetDirty(WID_RAT_REMOVE);
748
749 CloseWindowById(WC_BUILD_SIGNAL, TRANSPORT_RAIL);
750 CloseWindowById(WC_BUILD_STATION, TRANSPORT_RAIL);
751 CloseWindowById(WC_BUILD_DEPOT, TRANSPORT_RAIL);
752 CloseWindowById(WC_BUILD_WAYPOINT, TRANSPORT_RAIL);
753 CloseWindowById(WC_SELECT_STATION, 0);
754 CloseWindowByClass(WC_BUILD_BRIDGE);
755 }
756
757 void OnPlacePresize(Point pt, TileIndex tile) override
758 {
759 DoCommand(tile, _cur_railtype | (TRANSPORT_RAIL << 8), 0, DC_AUTO, CMD_BUILD_TUNNEL);
760 VpSetPresizeRange(tile, _build_tunnel_endtile == 0 ? tile : _build_tunnel_endtile);
761 }
762
763 EventState OnCTRLStateChange() override
764 {
765 /* do not toggle Remove button by Ctrl when placing station */
766 if (!this->IsWidgetLowered(WID_RAT_BUILD_STATION) && !this->IsWidgetLowered(WID_RAT_BUILD_WAYPOINT) && RailToolbar_CtrlChanged(this)) return ES_HANDLED;
767 return ES_NOT_HANDLED;
768 }
769
770 static HotkeyList hotkeys;
771 };
772
778 static EventState RailToolbarGlobalHotkeys(int hotkey)
779 {
780 if (_game_mode != GM_NORMAL) return ES_NOT_HANDLED;
781 extern RailType _last_built_railtype;
782 Window *w = ShowBuildRailToolbar(_last_built_railtype);
783 if (w == nullptr) return ES_NOT_HANDLED;
784 return w->OnHotkey(hotkey);
785 }
786
787 const uint16 _railtoolbar_autorail_keys[] = {'5', 'A' | WKC_GLOBAL_HOTKEY, 0};
788
789 static Hotkey railtoolbar_hotkeys[] = {
790 Hotkey('1', "build_ns", WID_RAT_BUILD_NS),
791 Hotkey('2', "build_x", WID_RAT_BUILD_X),
792 Hotkey('3', "build_ew", WID_RAT_BUILD_EW),
793 Hotkey('4', "build_y", WID_RAT_BUILD_Y),
794 Hotkey(_railtoolbar_autorail_keys, "autorail", WID_RAT_AUTORAIL),
795 Hotkey('6', "demolish", WID_RAT_DEMOLISH),
796 Hotkey('7', "depot", WID_RAT_BUILD_DEPOT),
797 Hotkey('8', "waypoint", WID_RAT_BUILD_WAYPOINT),
798 Hotkey('9', "station", WID_RAT_BUILD_STATION),
799 Hotkey('S', "signal", WID_RAT_BUILD_SIGNALS),
800 Hotkey('B', "bridge", WID_RAT_BUILD_BRIDGE),
801 Hotkey('T', "tunnel", WID_RAT_BUILD_TUNNEL),
802 Hotkey('R', "remove", WID_RAT_REMOVE),
803 Hotkey('C', "convert", WID_RAT_CONVERT_RAIL),
804 HOTKEY_LIST_END
805 };
806 HotkeyList BuildRailToolbarWindow::hotkeys("railtoolbar", railtoolbar_hotkeys, RailToolbarGlobalHotkeys);
807
808 static const NWidgetPart _nested_build_rail_widgets[] = {
809 NWidget(NWID_HORIZONTAL),
810 NWidget(WWT_CLOSEBOX, COLOUR_DARK_GREEN),
811 NWidget(WWT_CAPTION, COLOUR_DARK_GREEN, WID_RAT_CAPTION), SetDataTip(STR_WHITE_STRING, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
812 NWidget(WWT_STICKYBOX, COLOUR_DARK_GREEN),
813 EndContainer(),
814 NWidget(NWID_HORIZONTAL),
815 NWidget(WWT_IMGBTN, COLOUR_DARK_GREEN, WID_RAT_BUILD_NS),
816 SetFill(0, 1), SetMinimalSize(22, 22), SetDataTip(SPR_IMG_RAIL_NS, STR_RAIL_TOOLBAR_TOOLTIP_BUILD_RAILROAD_TRACK),
817 NWidget(WWT_IMGBTN, COLOUR_DARK_GREEN, WID_RAT_BUILD_X),
818 SetFill(0, 1), SetMinimalSize(22, 22), SetDataTip(SPR_IMG_RAIL_NE, STR_RAIL_TOOLBAR_TOOLTIP_BUILD_RAILROAD_TRACK),
819 NWidget(WWT_IMGBTN, COLOUR_DARK_GREEN, WID_RAT_BUILD_EW),
820 SetFill(0, 1), SetMinimalSize(22, 22), SetDataTip(SPR_IMG_RAIL_EW, STR_RAIL_TOOLBAR_TOOLTIP_BUILD_RAILROAD_TRACK),
821 NWidget(WWT_IMGBTN, COLOUR_DARK_GREEN, WID_RAT_BUILD_Y),
822 SetFill(0, 1), SetMinimalSize(22, 22), SetDataTip(SPR_IMG_RAIL_NW, STR_RAIL_TOOLBAR_TOOLTIP_BUILD_RAILROAD_TRACK),
823 NWidget(WWT_IMGBTN, COLOUR_DARK_GREEN, WID_RAT_AUTORAIL),
824 SetFill(0, 1), SetMinimalSize(22, 22), SetDataTip(SPR_IMG_AUTORAIL, STR_RAIL_TOOLBAR_TOOLTIP_BUILD_AUTORAIL),
825
826 NWidget(WWT_PANEL, COLOUR_DARK_GREEN), SetMinimalSize(4, 22), SetDataTip(0x0, STR_NULL), EndContainer(),
827
828 NWidget(WWT_IMGBTN, COLOUR_DARK_GREEN, WID_RAT_DEMOLISH),
829 SetFill(0, 1), SetMinimalSize(22, 22), SetDataTip(SPR_IMG_DYNAMITE, STR_TOOLTIP_DEMOLISH_BUILDINGS_ETC),
830 NWidget(WWT_IMGBTN, COLOUR_DARK_GREEN, WID_RAT_BUILD_DEPOT),
831 SetFill(0, 1), SetMinimalSize(22, 22), SetDataTip(SPR_IMG_DEPOT_RAIL, STR_RAIL_TOOLBAR_TOOLTIP_BUILD_TRAIN_DEPOT_FOR_BUILDING),
832 NWidget(WWT_IMGBTN, COLOUR_DARK_GREEN, WID_RAT_BUILD_WAYPOINT),
833 SetFill(0, 1), SetMinimalSize(22, 22), SetDataTip(SPR_IMG_WAYPOINT, STR_RAIL_TOOLBAR_TOOLTIP_CONVERT_RAIL_TO_WAYPOINT),
834 NWidget(WWT_IMGBTN, COLOUR_DARK_GREEN, WID_RAT_BUILD_STATION),
835 SetFill(0, 1), SetMinimalSize(42, 22), SetDataTip(SPR_IMG_RAIL_STATION, STR_RAIL_TOOLBAR_TOOLTIP_BUILD_RAILROAD_STATION),
836 NWidget(WWT_IMGBTN, COLOUR_DARK_GREEN, WID_RAT_BUILD_SIGNALS),
837 SetFill(0, 1), SetMinimalSize(22, 22), SetDataTip(SPR_IMG_RAIL_SIGNALS, STR_RAIL_TOOLBAR_TOOLTIP_BUILD_RAILROAD_SIGNALS),
838 NWidget(WWT_IMGBTN, COLOUR_DARK_GREEN, WID_RAT_BUILD_BRIDGE),
839 SetFill(0, 1), SetMinimalSize(42, 22), SetDataTip(SPR_IMG_BRIDGE, STR_RAIL_TOOLBAR_TOOLTIP_BUILD_RAILROAD_BRIDGE),
840 NWidget(WWT_IMGBTN, COLOUR_DARK_GREEN, WID_RAT_BUILD_TUNNEL),
841 SetFill(0, 1), SetMinimalSize(20, 22), SetDataTip(SPR_IMG_TUNNEL_RAIL, STR_RAIL_TOOLBAR_TOOLTIP_BUILD_RAILROAD_TUNNEL),
842 NWidget(WWT_IMGBTN, COLOUR_DARK_GREEN, WID_RAT_REMOVE),
843 SetFill(0, 1), SetMinimalSize(22, 22), SetDataTip(SPR_IMG_REMOVE, STR_RAIL_TOOLBAR_TOOLTIP_TOGGLE_BUILD_REMOVE_FOR),
844 NWidget(WWT_IMGBTN, COLOUR_DARK_GREEN, WID_RAT_CONVERT_RAIL),
845 SetFill(0, 1), SetMinimalSize(22, 22), SetDataTip(SPR_IMG_CONVERT_RAIL, STR_RAIL_TOOLBAR_TOOLTIP_CONVERT_RAIL),
846 EndContainer(),
847 };
848
849 static WindowDesc _build_rail_desc(
850 WDP_ALIGN_TOOLBAR, "toolbar_rail", 0, 0,
851 WC_BUILD_TOOLBAR, WC_NONE,
852 WDF_CONSTRUCTION,
853 _nested_build_rail_widgets, lengthof(_nested_build_rail_widgets),
854 &BuildRailToolbarWindow::hotkeys
855 );
856
857
866 Window *ShowBuildRailToolbar(RailType railtype)
867 {
868 if (!Company::IsValidID(_local_company)) return nullptr;
869 if (!ValParamRailtype(railtype)) return nullptr;
870
871 CloseWindowByClass(WC_BUILD_TOOLBAR);
872 _cur_railtype = railtype;
873 _remove_button_clicked = false;
874 return new BuildRailToolbarWindow(&_build_rail_desc, railtype);
875 }
876
877 /* TODO: For custom stations, respect their allowed platforms/lengths bitmasks!
878 * --pasky */
879
880 static void HandleStationPlacement(TileIndex start, TileIndex end)
881 {
882 TileArea ta(start, end);
883 uint numtracks = ta.w;
884 uint platlength = ta.h;
885
886 if (_railstation.orientation == AXIS_X) Swap(numtracks, platlength);
887
888 uint32 p1 = _cur_railtype | _railstation.orientation << 6 | numtracks << 8 | platlength << 16 | _ctrl_pressed << 24;
889 uint32 p2 = _railstation.station_class | _railstation.station_type << 8 | INVALID_STATION << 16;
890
891 CommandContainer cmdcont = { ta.tile, p1, p2, CMD_BUILD_RAIL_STATION | CMD_MSG(STR_ERROR_CAN_T_BUILD_RAILROAD_STATION), CcStation, "" };
892 ShowSelectStationIfNeeded(cmdcont, ta);
893 }
894
896 enum BuildRalStationHotkeys {
897 BRASHK_FOCUS_FILTER_BOX,
898 };
899
900 struct BuildRailStationWindow : public PickerWindowBase {
901 private:
902 uint line_height;
903 uint coverage_height;
904 Scrollbar *vscroll;
905 Scrollbar *vscroll2;
906
907 typedef GUIList<StationClassID, StringFilter &> GUIStationClassList;
908
909 static const uint EDITBOX_MAX_SIZE = 16;
910
911 static Listing last_sorting;
912 static Filtering last_filtering;
913 static GUIStationClassList::SortFunction * const sorter_funcs[];
914 static GUIStationClassList::FilterFunction * const filter_funcs[];
915 GUIStationClassList station_classes;
916 StringFilter string_filter;
917 QueryString filter_editbox;
918
926 void EnsureSelectedStationClassIsVisible()
927 {
928 uint pos = 0;
929 for (auto station_class : this->station_classes) {
930 if (station_class == _railstation.station_class) break;
931 pos++;
932 }
933 this->vscroll->SetCount((int)this->station_classes.size());
934 this->vscroll->ScrollTowards(pos);
935 }
936
942 void CheckSelectedSize(const StationSpec *statspec)
943 {
944 if (statspec == nullptr || _settings_client.gui.station_dragdrop) return;
945
946 /* If current number of tracks is not allowed, make it as big as possible */
947 if (HasBit(statspec->disallowed_platforms, _settings_client.gui.station_numtracks - 1)) {
948 this->RaiseWidget(_settings_client.gui.station_numtracks + WID_BRAS_PLATFORM_NUM_BEGIN);
949 _settings_client.gui.station_numtracks = 1;
950 if (statspec->disallowed_platforms != UINT8_MAX) {
951 while (HasBit(statspec->disallowed_platforms, _settings_client.gui.station_numtracks - 1)) {
952 _settings_client.gui.station_numtracks++;
953 }
954 this->LowerWidget(_settings_client.gui.station_numtracks + WID_BRAS_PLATFORM_NUM_BEGIN);
955 }
956 }
957
958 if (HasBit(statspec->disallowed_lengths, _settings_client.gui.station_platlength - 1)) {
959 this->RaiseWidget(_settings_client.gui.station_platlength + WID_BRAS_PLATFORM_LEN_BEGIN);
960 _settings_client.gui.station_platlength = 1;
961 if (statspec->disallowed_lengths != UINT8_MAX) {
962 while (HasBit(statspec->disallowed_lengths, _settings_client.gui.station_platlength - 1)) {
963 _settings_client.gui.station_platlength++;
964 }
965 this->LowerWidget(_settings_client.gui.station_platlength + WID_BRAS_PLATFORM_LEN_BEGIN);
966 }
967 }
968 }
969
970 public:
971 BuildRailStationWindow(WindowDesc *desc, Window *parent, bool newstation) : PickerWindowBase(desc, parent), filter_editbox(EDITBOX_MAX_SIZE * MAX_CHAR_LENGTH, EDITBOX_MAX_SIZE)
972 {
973 this->coverage_height = 2 * FONT_HEIGHT_NORMAL + 3 * WD_PAR_VSEP_NORMAL;
974 this->vscroll = nullptr;
975 _railstation.newstations = newstation;
976
977 this->CreateNestedTree();
978 NWidgetStacked *newst_additions = this->GetWidget<NWidgetStacked>(WID_BRAS_SHOW_NEWST_ADDITIONS);
979 newst_additions->SetDisplayedPlane(newstation ? 0 : SZSP_NONE);
980 newst_additions = this->GetWidget<NWidgetStacked>(WID_BRAS_SHOW_NEWST_MATRIX);
981 newst_additions->SetDisplayedPlane(newstation ? 0 : SZSP_NONE);
982 newst_additions = this->GetWidget<NWidgetStacked>(WID_BRAS_SHOW_NEWST_DEFSIZE);
983 newst_additions->SetDisplayedPlane(newstation ? 0 : SZSP_NONE);
984 newst_additions = this->GetWidget<NWidgetStacked>(WID_BRAS_SHOW_NEWST_RESIZE);
985 newst_additions->SetDisplayedPlane(newstation ? 0 : SZSP_NONE);
986 /* Hide the station class filter if no stations other than the default one are available. */
987 this->GetWidget<NWidgetStacked>(WID_BRAS_FILTER_CONTAINER)->SetDisplayedPlane(newstation ? 0 : SZSP_NONE);
988 if (newstation) {
989 this->vscroll = this->GetScrollbar(WID_BRAS_NEWST_SCROLL);
990 this->vscroll2 = this->GetScrollbar(WID_BRAS_MATRIX_SCROLL);
991
992 this->querystrings[WID_BRAS_FILTER_EDITBOX] = &this->filter_editbox;
993 this->station_classes.SetListing(this->last_sorting);
994 this->station_classes.SetFiltering(this->last_filtering);
995 this->station_classes.SetSortFuncs(this->sorter_funcs);
996 this->station_classes.SetFilterFuncs(this->filter_funcs);
997 }
998
999 this->station_classes.ForceRebuild();
1000
1001 BuildStationClassesAvailable();
1002 SelectClassAndStation();
1003
1004 this->FinishInitNested(TRANSPORT_RAIL);
1005
1006 this->LowerWidget(_railstation.orientation + WID_BRAS_PLATFORM_DIR_X);
1007 if (_settings_client.gui.station_dragdrop) {
1008 this->LowerWidget(WID_BRAS_PLATFORM_DRAG_N_DROP);
1009 } else {
1010 this->LowerWidget(_settings_client.gui.station_numtracks + WID_BRAS_PLATFORM_NUM_BEGIN);
1011 this->LowerWidget(_settings_client.gui.station_platlength + WID_BRAS_PLATFORM_LEN_BEGIN);
1012 }
1013 this->SetWidgetLoweredState(WID_BRAS_HIGHLIGHT_OFF, !_settings_client.gui.station_show_coverage);
1014 this->SetWidgetLoweredState(WID_BRAS_HIGHLIGHT_ON, _settings_client.gui.station_show_coverage);
1015
1016 if (!newstation) {
1017 _railstation.station_class = StationClassID::STAT_CLASS_DFLT;
1018 _railstation.station_type = 0;
1019 this->vscroll2 = nullptr;
1020 } else {
1021 _railstation.station_count = StationClass::Get(_railstation.station_class)->GetSpecCount();
1022 _railstation.station_type = std::min<int>(_railstation.station_type, _railstation.station_count - 1);
1023
1024 NWidgetMatrix *matrix = this->GetWidget<NWidgetMatrix>(WID_BRAS_MATRIX);
1025 matrix->SetScrollbar(this->vscroll2);
1026 matrix->SetCount(_railstation.station_count);
1027 matrix->SetClicked(_railstation.station_type);
1028
1029 EnsureSelectedStationClassIsVisible();
1030 }
1031
1032 this->InvalidateData();
1033 }
1034
1035 void Close() override
1036 {
1037 CloseWindowById(WC_SELECT_STATION, 0);
1038 this->PickerWindowBase::Close();
1039 }
1040
1042 static bool StationClassIDSorter(StationClassID const &a, StationClassID const &b)
1043 {
1044 return a < b;
1045 }
1046
1048 static bool CDECL TagNameFilter(StationClassID const * sc, StringFilter &filter)
1049 {
1050 char buffer[DRAW_STRING_BUFFER];
1051 GetString(buffer, StationClass::Get(*sc)->name, lastof(buffer));
1052
1053 filter.ResetState();
1054 filter.AddLine(buffer);
1055 return filter.GetState();
1056 }
1057
1059 void BuildStationClassesAvailable()
1060 {
1061 if (!this->station_classes.NeedRebuild()) return;
1062
1063 this->station_classes.clear();
1064
1065 for (uint i = 0; i < StationClass::GetClassCount(); i++) {
1066 StationClassID station_class_id = (StationClassID)i;
1067 if (station_class_id == StationClassID::STAT_CLASS_WAYP) {
1068 // Skip waypoints.
1069 continue;
1070 }
1071 StationClass *station_class = StationClass::Get(station_class_id);
1072 if (station_class->GetUISpecCount() == 0) continue;
1073 station_classes.push_back(station_class_id);
1074 }
1075
1076 if (_railstation.newstations) {
1077 this->station_classes.Filter(this->string_filter);
1078 this->station_classes.shrink_to_fit();
1079 this->station_classes.RebuildDone();
1080 this->station_classes.Sort();
1081
1082 this->vscroll->SetCount((uint)this->station_classes.size());
1083 }
1084 }
1085
1090 void SelectClassAndStation()
1091 {
1092 if (_railstation.station_class == StationClassID::STAT_CLASS_DFLT) {
1093 /* This happens during the first time the window is open during the game life cycle. */
1094 this->SelectOtherClass(StationClassID::STAT_CLASS_DFLT);
1095 } else {
1096 /* Check if the previously selected station class is not available anymore as a
1097 * result of starting a new game without the corresponding NewGRF. */
1098 bool available = false;
1099 for (uint i = 0; i < StationClass::GetClassCount(); ++i) {
1100 if ((StationClassID)i == _railstation.station_class) {
1101 available = true;
1102 break;
1103 }
1104 }
1105
1106 this->SelectOtherClass(available ? _railstation.station_class : StationClassID::STAT_CLASS_DFLT);
1107 }
1108 }
1109
1114 void SelectOtherClass(StationClassID station_class)
1115 {
1116 _railstation.station_class = station_class;
1117 }
1118
1119 void OnInvalidateData(int data = 0, bool gui_scope = true) override
1120 {
1121 if (!gui_scope) return;
1122
1123 this->BuildStationClassesAvailable();
1124 }
1125
1126 EventState OnHotkey(int hotkey) override
1127 {
1128 switch (hotkey) {
1129 case BRASHK_FOCUS_FILTER_BOX:
1130 this->SetFocusedWidget(WID_BRAS_FILTER_EDITBOX);
1131 SetFocusedWindow(this); // The user has asked to give focus to the text box, so make sure this window is focused.
1132 break;
1133
1134 default:
1135 return ES_NOT_HANDLED;
1136 }
1137
1138 return ES_HANDLED;
1139 }
1140
1141 void OnEditboxChanged(int wid) override
1142 {
1143 string_filter.SetFilterTerm(this->filter_editbox.text.buf);
1144 this->station_classes.SetFilterState(!string_filter.IsEmpty());
1145 this->station_classes.ForceRebuild();
1146 this->InvalidateData();
1147 }
1148
1149 void OnPaint() override
1150 {
1151 bool newstations = _railstation.newstations;
1152 const StationSpec *statspec = newstations ? StationClass::Get(_railstation.station_class)->GetSpec(_railstation.station_type) : nullptr;
1153
1154 if (_settings_client.gui.station_dragdrop) {
1155 SetTileSelectSize(1, 1);
1156 } else {
1157 int x = _settings_client.gui.station_numtracks;
1158 int y = _settings_client.gui.station_platlength;
1159 if (_railstation.orientation == AXIS_X) Swap(x, y);
1160 if (!_remove_button_clicked) {
1161 SetTileSelectSize(x, y);
1162 }
1163 }
1164
1165 int rad = (_settings_game.station.modified_catchment) ? CA_TRAIN : CA_UNMODIFIED;
1166
1167 if (_settings_client.gui.station_show_coverage) SetTileSelectBigSize(-rad, -rad, 2 * rad, 2 * rad);
1168
1169 for (uint bits = 0; bits < 7; bits++) {
1170 bool disable = bits >= _settings_game.station.station_spread;
1171 if (statspec == nullptr) {
1172 this->SetWidgetDisabledState(bits + WID_BRAS_PLATFORM_NUM_1, disable);
1173 this->SetWidgetDisabledState(bits + WID_BRAS_PLATFORM_LEN_1, disable);
1174 } else {
1175 this->SetWidgetDisabledState(bits + WID_BRAS_PLATFORM_NUM_1, HasBit(statspec->disallowed_platforms, bits) || disable);
1176 this->SetWidgetDisabledState(bits + WID_BRAS_PLATFORM_LEN_1, HasBit(statspec->disallowed_lengths, bits) || disable);
1177 }
1178 }
1179
1180 this->DrawWidgets();
1181
1182 if (this->IsShaded()) return;
1183 /* 'Accepts' and 'Supplies' texts. */
1184 NWidgetBase *cov = this->GetWidget<NWidgetBase>(WID_BRAS_COVERAGE_TEXTS);
1185 int top = cov->pos_y + WD_PAR_VSEP_NORMAL;
1186 int left = cov->pos_x + WD_FRAMERECT_LEFT;
1187 int right = cov->pos_x + cov->current_x - WD_FRAMERECT_RIGHT;
1188 int bottom = cov->pos_y + cov->current_y;
1189 top = DrawStationCoverageAreaText(left, right, top, SCT_ALL, rad, false) + WD_PAR_VSEP_NORMAL;
1190 top = DrawStationCoverageAreaText(left, right, top, SCT_ALL, rad, true) + WD_PAR_VSEP_NORMAL;
1191 /* Resize background if the window is too small.
1192 * Never make the window smaller to avoid oscillating if the size change affects the acceptance.
1193 * (This is the case, if making the window bigger moves the mouse into the window.) */
1194 if (top > bottom) {
1195 this->coverage_height += top - bottom;
1196 this->ReInit();
1197 }
1198 }
1199
1200 void UpdateWidgetSize(int widget, Dimension *size, const Dimension &padding, Dimension *fill, Dimension *resize) override
1201 {
1202 switch (widget) {
1203 case WID_BRAS_NEWST_LIST: {
1204 Dimension d = {0, 0};
1205 for (auto station_class : this->station_classes) {
1206 d = maxdim(d, GetStringBoundingBox(StationClass::Get(station_class)->name));
1207 }
1208 size->width = std::max(size->width, d.width + padding.width);
1209 this->line_height = FONT_HEIGHT_NORMAL + WD_MATRIX_TOP + WD_MATRIX_BOTTOM;
1210 size->height = 5 * this->line_height;
1211 resize->height = this->line_height;
1212 break;
1213 }
1214
1215 case WID_BRAS_SHOW_NEWST_TYPE: {
1216 if (!_railstation.newstations) {
1217 size->width = 0;
1218 size->height = 0;
1219 break;
1220 }
1221
1222 /* If newstations exist, compute the non-zero minimal size. */
1223 Dimension d = {0, 0};
1224 StringID str = this->GetWidget<NWidgetCore>(widget)->widget_data;
1225 for (auto station_class : this->station_classes) {
1226 StationClass *stclass = StationClass::Get(station_class);
1227 for (uint j = 0; j < stclass->GetSpecCount(); j++) {
1228 const StationSpec *statspec = stclass->GetSpec(j);
1229 SetDParam(0, (statspec != nullptr && statspec->name != 0) ? statspec->name : STR_STATION_CLASS_DFLT);
1230 d = maxdim(d, GetStringBoundingBox(str));
1231 }
1232 }
1233 size->width = std::max(size->width, d.width + padding.width);
1234 break;
1235 }
1236
1237 case WID_BRAS_PLATFORM_DIR_X:
1238 case WID_BRAS_PLATFORM_DIR_Y:
1239 case WID_BRAS_IMAGE:
1240 size->width = ScaleGUITrad(64) + 2;
1241 size->height = ScaleGUITrad(58) + 2;
1242 break;
1243
1244 case WID_BRAS_COVERAGE_TEXTS:
1245 size->height = this->coverage_height;
1246 break;
1247
1248 case WID_BRAS_MATRIX:
1249 fill->height = 1;
1250 resize->height = 1;
1251 break;
1252 }
1253 }
1254
1255 void DrawWidget(const Rect &r, int widget) const override
1256 {
1257 DrawPixelInfo tmp_dpi;
1258
1259 switch (GB(widget, 0, 16)) {
1260 case WID_BRAS_PLATFORM_DIR_X:
1261 /* Set up a clipping area for the '/' station preview */
1262 if (FillDrawPixelInfo(&tmp_dpi, r.left, r.top, r.right - r.left + 1, r.bottom - r.top + 1)) {
1263 DrawPixelInfo *old_dpi = _cur_dpi;
1264 _cur_dpi = &tmp_dpi;
1265 int x = ScaleGUITrad(31) + 1;
1266 int y = r.bottom - r.top - ScaleGUITrad(31);
1267 if (!DrawStationTile(x, y, _cur_railtype, AXIS_X, _railstation.station_class, _railstation.station_type)) {
1268 StationPickerDrawSprite(x, y, STATION_RAIL, _cur_railtype, INVALID_ROADTYPE, 2);
1269 }
1270 _cur_dpi = old_dpi;
1271 }
1272 break;
1273
1274 case WID_BRAS_PLATFORM_DIR_Y:
1275 /* Set up a clipping area for the '\' station preview */
1276 if (FillDrawPixelInfo(&tmp_dpi, r.left, r.top, r.right - r.left + 1, r.bottom - r.top + 1)) {
1277 DrawPixelInfo *old_dpi = _cur_dpi;
1278 _cur_dpi = &tmp_dpi;
1279 int x = ScaleGUITrad(31) + 1;
1280 int y = r.bottom - r.top - ScaleGUITrad(31);
1281 if (!DrawStationTile(x, y, _cur_railtype, AXIS_Y, _railstation.station_class, _railstation.station_type)) {
1282 StationPickerDrawSprite(x, y, STATION_RAIL, _cur_railtype, INVALID_ROADTYPE, 3);
1283 }
1284 _cur_dpi = old_dpi;
1285 }
1286 break;
1287
1288 case WID_BRAS_NEWST_LIST: {
1289 uint statclass = 0;
1290 uint row = 0;
1291 for (auto station_class : this->station_classes) {
1292 if (this->vscroll->IsVisible(statclass)) {
1293 DrawString(r.left + WD_MATRIX_LEFT, r.right - WD_MATRIX_RIGHT, row * this->line_height + r.top + WD_MATRIX_TOP,
1294 StationClass::Get(station_class)->name,
1295 station_class == _railstation.station_class ? TC_WHITE : TC_BLACK);
1296 row++;
1297 }
1298 statclass++;
1299 }
1300 break;
1301 }
1302
1303 case WID_BRAS_IMAGE: {
1304 byte type = GB(widget, 16, 16);
1305 assert(type < _railstation.station_count);
1306 /* Check station availability callback */
1307 const StationSpec *statspec = StationClass::Get(_railstation.station_class)->GetSpec(type);
1308 if (!IsStationAvailable(statspec)) {
1309 GfxFillRect(r.left + 1, r.top + 1, r.right - 1, r.bottom - 1, PC_BLACK, FILLRECT_CHECKER);
1310 }
1311
1312 /* Set up a clipping area for the station preview. */
1313 if (FillDrawPixelInfo(&tmp_dpi, r.left, r.top, r.right - r.left + 1, r.bottom - r.top + 1)) {
1314 DrawPixelInfo *old_dpi = _cur_dpi;
1315 _cur_dpi = &tmp_dpi;
1316 int x = ScaleGUITrad(31) + 1;
1317 int y = r.bottom - r.top - ScaleGUITrad(31);
1318 if (!DrawStationTile(x, y, _cur_railtype, _railstation.orientation, _railstation.station_class, type)) {
1319 StationPickerDrawSprite(x, y, STATION_RAIL, _cur_railtype, INVALID_ROADTYPE, 2 + _railstation.orientation);
1320 }
1321 _cur_dpi = old_dpi;
1322 }
1323 break;
1324 }
1325 }
1326 }
1327
1328 void OnResize() override
1329 {
1330 if (this->vscroll != nullptr) { // New stations available.
1331 this->vscroll->SetCapacityFromWidget(this, WID_BRAS_NEWST_LIST);
1332 }
1333 }
1334
1335 void SetStringParameters(int widget) const override
1336 {
1337 if (widget == WID_BRAS_SHOW_NEWST_TYPE) {
1338 const StationSpec *statspec = StationClass::Get(_railstation.station_class)->GetSpec(_railstation.station_type);
1339 SetDParam(0, (statspec != nullptr && statspec->name != 0) ? statspec->name : STR_STATION_CLASS_DFLT);
1340 }
1341 }
1342
1343 void OnClick(Point pt, int widget, int click_count) override
1344 {
1345 switch (GB(widget, 0, 16)) {
1346 case WID_BRAS_PLATFORM_DIR_X:
1347 case WID_BRAS_PLATFORM_DIR_Y:
1348 this->RaiseWidget(_railstation.orientation + WID_BRAS_PLATFORM_DIR_X);
1349 _railstation.orientation = (Axis)(widget - WID_BRAS_PLATFORM_DIR_X);
1350 this->LowerWidget(_railstation.orientation + WID_BRAS_PLATFORM_DIR_X);
1351 if (_settings_client.sound.click_beep) SndPlayFx(SND_15_BEEP);
1352 this->SetDirty();
1353 CloseWindowById(WC_SELECT_STATION, 0);
1354 break;
1355
1356 case WID_BRAS_PLATFORM_NUM_1:
1357 case WID_BRAS_PLATFORM_NUM_2:
1358 case WID_BRAS_PLATFORM_NUM_3:
1359 case WID_BRAS_PLATFORM_NUM_4:
1360 case WID_BRAS_PLATFORM_NUM_5:
1361 case WID_BRAS_PLATFORM_NUM_6:
1362 case WID_BRAS_PLATFORM_NUM_7: {
1363 this->RaiseWidget(_settings_client.gui.station_numtracks + WID_BRAS_PLATFORM_NUM_BEGIN);
1364 this->RaiseWidget(WID_BRAS_PLATFORM_DRAG_N_DROP);
1365
1366 _settings_client.gui.station_numtracks = widget - WID_BRAS_PLATFORM_NUM_BEGIN;
1367 _settings_client.gui.station_dragdrop = false;
1368
1369 _settings_client.gui.station_dragdrop = false;
1370
1371 const StationSpec *statspec = _railstation.newstations ? StationClass::Get(_railstation.station_class)->GetSpec(_railstation.station_type) : nullptr;
1372 if (statspec != nullptr && HasBit(statspec->disallowed_lengths, _settings_client.gui.station_platlength - 1)) {
1373 /* The previously selected number of platforms in invalid */
1374 for (uint i = 0; i < 7; i++) {
1375 if (!HasBit(statspec->disallowed_lengths, i)) {
1376 this->RaiseWidget(_settings_client.gui.station_platlength + WID_BRAS_PLATFORM_LEN_BEGIN);
1377 _settings_client.gui.station_platlength = i + 1;
1378 break;
1379 }
1380 }
1381 }
1382
1383 this->LowerWidget(_settings_client.gui.station_numtracks + WID_BRAS_PLATFORM_NUM_BEGIN);
1384 this->LowerWidget(_settings_client.gui.station_platlength + WID_BRAS_PLATFORM_LEN_BEGIN);
1385 if (_settings_client.sound.click_beep) SndPlayFx(SND_15_BEEP);
1386 this->SetDirty();
1387 CloseWindowById(WC_SELECT_STATION, 0);
1388 break;
1389 }
1390
1391 case WID_BRAS_PLATFORM_LEN_1:
1392 case WID_BRAS_PLATFORM_LEN_2:
1393 case WID_BRAS_PLATFORM_LEN_3:
1394 case WID_BRAS_PLATFORM_LEN_4:
1395 case WID_BRAS_PLATFORM_LEN_5:
1396 case WID_BRAS_PLATFORM_LEN_6:
1397 case WID_BRAS_PLATFORM_LEN_7: {
1398 this->RaiseWidget(_settings_client.gui.station_platlength + WID_BRAS_PLATFORM_LEN_BEGIN);
1399 this->RaiseWidget(WID_BRAS_PLATFORM_DRAG_N_DROP);
1400
1401 _settings_client.gui.station_platlength = widget - WID_BRAS_PLATFORM_LEN_BEGIN;
1402 _settings_client.gui.station_dragdrop = false;
1403
1404 _settings_client.gui.station_dragdrop = false;
1405
1406 const StationSpec *statspec = _railstation.newstations ? StationClass::Get(_railstation.station_class)->GetSpec(_railstation.station_type) : nullptr;
1407 if (statspec != nullptr && HasBit(statspec->disallowed_platforms, _settings_client.gui.station_numtracks - 1)) {
1408 /* The previously selected number of tracks in invalid */
1409 for (uint i = 0; i < 7; i++) {
1410 if (!HasBit(statspec->disallowed_platforms, i)) {
1411 this->RaiseWidget(_settings_client.gui.station_numtracks + WID_BRAS_PLATFORM_NUM_BEGIN);
1412 _settings_client.gui.station_numtracks = i + 1;
1413 break;
1414 }
1415 }
1416 }
1417
1418 this->LowerWidget(_settings_client.gui.station_numtracks + WID_BRAS_PLATFORM_NUM_BEGIN);
1419 this->LowerWidget(_settings_client.gui.station_platlength + WID_BRAS_PLATFORM_LEN_BEGIN);
1420 if (_settings_client.sound.click_beep) SndPlayFx(SND_15_BEEP);
1421 this->SetDirty();
1422 CloseWindowById(WC_SELECT_STATION, 0);
1423 break;
1424 }
1425
1426 case WID_BRAS_PLATFORM_DRAG_N_DROP: {
1427 _settings_client.gui.station_dragdrop ^= true;
1428
1429 this->ToggleWidgetLoweredState(WID_BRAS_PLATFORM_DRAG_N_DROP);
1430
1431 /* get the first allowed length/number of platforms */
1432 const StationSpec *statspec = _railstation.newstations ? StationClass::Get(_railstation.station_class)->GetSpec(_railstation.station_type) : nullptr;
1433 if (statspec != nullptr && HasBit(statspec->disallowed_lengths, _settings_client.gui.station_platlength - 1)) {
1434 for (uint i = 0; i < 7; i++) {
1435 if (!HasBit(statspec->disallowed_lengths, i)) {
1436 this->RaiseWidget(_settings_client.gui.station_platlength + WID_BRAS_PLATFORM_LEN_BEGIN);
1437 _settings_client.gui.station_platlength = i + 1;
1438 break;
1439 }
1440 }
1441 }
1442 if (statspec != nullptr && HasBit(statspec->disallowed_platforms, _settings_client.gui.station_numtracks - 1)) {
1443 for (uint i = 0; i < 7; i++) {
1444 if (!HasBit(statspec->disallowed_platforms, i)) {
1445 this->RaiseWidget(_settings_client.gui.station_numtracks + WID_BRAS_PLATFORM_NUM_BEGIN);
1446 _settings_client.gui.station_numtracks = i + 1;
1447 break;
1448 }
1449 }
1450 }
1451
1452 this->SetWidgetLoweredState(_settings_client.gui.station_numtracks + WID_BRAS_PLATFORM_NUM_BEGIN, !_settings_client.gui.station_dragdrop);
1453 this->SetWidgetLoweredState(_settings_client.gui.station_platlength + WID_BRAS_PLATFORM_LEN_BEGIN, !_settings_client.gui.station_dragdrop);
1454 if (_settings_client.sound.click_beep) SndPlayFx(SND_15_BEEP);
1455 this->SetDirty();
1456 CloseWindowById(WC_SELECT_STATION, 0);
1457 break;
1458 }
1459
1460 case WID_BRAS_HIGHLIGHT_OFF:
1461 case WID_BRAS_HIGHLIGHT_ON:
1462 _settings_client.gui.station_show_coverage = (widget != WID_BRAS_HIGHLIGHT_OFF);
1463
1464 this->SetWidgetLoweredState(WID_BRAS_HIGHLIGHT_OFF, !_settings_client.gui.station_show_coverage);
1465 this->SetWidgetLoweredState(WID_BRAS_HIGHLIGHT_ON, _settings_client.gui.station_show_coverage);
1466 if (_settings_client.sound.click_beep) SndPlayFx(SND_15_BEEP);
1467 this->SetDirty();
1468 SetViewportCatchmentStation(nullptr, true);
1469 break;
1470
1471 case WID_BRAS_NEWST_LIST: {
1472 int y = this->vscroll->GetScrolledRowFromWidget(pt.y, this, WID_BRAS_NEWST_LIST);
1473 if (y >= (int)this->station_classes.size()) return;
1474 StationClassID station_class_id = this->station_classes[y];
1475 if (_railstation.station_class != station_class_id) {
1476 StationClass *station_class = StationClass::Get(station_class_id);
1477 _railstation.station_class = station_class_id;
1478 _railstation.station_count = station_class->GetSpecCount();
1479 _railstation.station_type = 0;
1480
1481 this->CheckSelectedSize(station_class->GetSpec(_railstation.station_type));
1482
1483 NWidgetMatrix *matrix = this->GetWidget<NWidgetMatrix>(WID_BRAS_MATRIX);
1484 matrix->SetCount(_railstation.station_count);
1485 matrix->SetClicked(_railstation.station_type);
1486 }
1487 if (_settings_client.sound.click_beep) SndPlayFx(SND_15_BEEP);
1488 this->SetDirty();
1489 CloseWindowById(WC_SELECT_STATION, 0);
1490 break;
1491 }
1492
1493 case WID_BRAS_IMAGE: {
1494 int y = GB(widget, 16, 16);
1495 if (y >= _railstation.station_count) return;
1496
1497 /* Check station availability callback */
1498 const StationSpec *statspec = StationClass::Get(_railstation.station_class)->GetSpec(y);
1499 if (!IsStationAvailable(statspec)) return;
1500
1501 _railstation.station_type = y;
1502
1503 this->CheckSelectedSize(statspec);
1504 this->GetWidget<NWidgetMatrix>(WID_BRAS_MATRIX)->SetClicked(_railstation.station_type);
1505
1506 if (_settings_client.sound.click_beep) SndPlayFx(SND_15_BEEP);
1507 this->SetDirty();
1508 CloseWindowById(WC_SELECT_STATION, 0);
1509 break;
1510 }
1511 }
1512 }
1513
1514 void OnRealtimeTick(uint delta_ms) override
1515 {
1516 CheckRedrawStationCoverage(this);
1517 }
1518
1519 static HotkeyList hotkeys;
1520 };
1521
1527 static EventState BuildRailStationGlobalHotkeys(int hotkey)
1528 {
1529 if (_game_mode == GM_MENU) return ES_NOT_HANDLED;
1530 Window *w = ShowStationBuilder(FindWindowById(WC_BUILD_TOOLBAR, TRANSPORT_RAIL));
1531 if (w == nullptr) return ES_NOT_HANDLED;
1532 return w->OnHotkey(hotkey);
1533 }
1534
1535 static Hotkey buildrailstation_hotkeys[] = {
1536 Hotkey('F', "focus_filter_box", BRASHK_FOCUS_FILTER_BOX),
1537 HOTKEY_LIST_END
1538 };
1539 HotkeyList BuildRailStationWindow::hotkeys("buildrailstation", buildrailstation_hotkeys, BuildRailStationGlobalHotkeys);
1540
1541 Listing BuildRailStationWindow::last_sorting = { false, 0 };
1542 Filtering BuildRailStationWindow::last_filtering = { false, 0 };
1543
1544 BuildRailStationWindow::GUIStationClassList::SortFunction * const BuildRailStationWindow::sorter_funcs[] = {
1545 &StationClassIDSorter,
1546 };
1547
1548 BuildRailStationWindow::GUIStationClassList::FilterFunction * const BuildRailStationWindow::filter_funcs[] = {
1549 &TagNameFilter,
1550 };
1551
1552 static const NWidgetPart _nested_station_builder_widgets[] = {
1553 NWidget(NWID_HORIZONTAL),
1554 NWidget(WWT_CLOSEBOX, COLOUR_DARK_GREEN),
1555 NWidget(WWT_CAPTION, COLOUR_DARK_GREEN), SetDataTip(STR_STATION_BUILD_RAIL_CAPTION, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
1556 NWidget(WWT_SHADEBOX, COLOUR_DARK_GREEN),
1557 NWidget(NWID_SELECTION, INVALID_COLOUR, WID_BRAS_SHOW_NEWST_DEFSIZE),
1558 NWidget(WWT_DEFSIZEBOX, COLOUR_DARK_GREEN),
1559 EndContainer(),
1560 EndContainer(),
1561 NWidget(WWT_PANEL, COLOUR_DARK_GREEN),
1562 NWidget(NWID_HORIZONTAL), SetPadding(2, 0, 0, 2),
1563 NWidget(NWID_VERTICAL),
1564 NWidget(NWID_SELECTION, INVALID_COLOUR, WID_BRAS_FILTER_CONTAINER),
1565 NWidget(NWID_HORIZONTAL), SetPadding(0, 5, 2, 0),
1566 NWidget(WWT_TEXT, COLOUR_DARK_GREEN), SetFill(0, 1), SetDataTip(STR_LIST_FILTER_TITLE, STR_NULL),
1567 NWidget(WWT_EDITBOX, COLOUR_GREY, WID_BRAS_FILTER_EDITBOX), SetFill(1, 0), SetResize(1, 0),
1568 SetDataTip(STR_LIST_FILTER_OSKTITLE, STR_LIST_FILTER_TOOLTIP),
1569 EndContainer(),
1570 EndContainer(),
1571 NWidget(NWID_SELECTION, INVALID_COLOUR, WID_BRAS_SHOW_NEWST_ADDITIONS),
1572 NWidget(NWID_HORIZONTAL), SetPadding(0, 5, 2, 0),
1573 NWidget(WWT_MATRIX, COLOUR_GREY, WID_BRAS_NEWST_LIST), SetMinimalSize(122, 71), SetFill(1, 0),
1574 SetMatrixDataTip(1, 0, STR_STATION_BUILD_STATION_CLASS_TOOLTIP), SetScrollbar(WID_BRAS_NEWST_SCROLL),
1575 NWidget(NWID_VSCROLLBAR, COLOUR_GREY, WID_BRAS_NEWST_SCROLL),
1576 EndContainer(),
1577 EndContainer(),
1578 NWidget(WWT_LABEL, COLOUR_DARK_GREEN), SetMinimalSize(144, 11), SetDataTip(STR_STATION_BUILD_ORIENTATION, STR_NULL), SetPadding(1, 2, 0, 0),
1579 NWidget(NWID_HORIZONTAL),
1580 NWidget(NWID_SPACER), SetMinimalSize(7, 0), SetFill(1, 0),
1581 NWidget(WWT_PANEL, COLOUR_GREY, WID_BRAS_PLATFORM_DIR_X), SetMinimalSize(66, 60), SetFill(0, 0), SetDataTip(0x0, STR_STATION_BUILD_RAILROAD_ORIENTATION_TOOLTIP), EndContainer(),
1582 NWidget(NWID_SPACER), SetMinimalSize(2, 0), SetFill(1, 0),
1583 NWidget(WWT_PANEL, COLOUR_GREY, WID_BRAS_PLATFORM_DIR_Y), SetMinimalSize(66, 60), SetFill(0, 0), SetDataTip(0x0, STR_STATION_BUILD_RAILROAD_ORIENTATION_TOOLTIP), EndContainer(),
1584 NWidget(NWID_SPACER), SetMinimalSize(7, 0), SetFill(1, 0),
1585 EndContainer(),
1586 NWidget(WWT_LABEL, COLOUR_DARK_GREEN, WID_BRAS_SHOW_NEWST_TYPE), SetMinimalSize(144, 11), SetDataTip(STR_ORANGE_STRING, STR_NULL), SetPadding(1, 2, 4, 2),
1587 NWidget(WWT_LABEL, COLOUR_DARK_GREEN), SetMinimalSize(144, 11), SetDataTip(STR_STATION_BUILD_NUMBER_OF_TRACKS, STR_NULL), SetPadding(0, 2, 0, 2),
1588 NWidget(NWID_HORIZONTAL),
1589 NWidget(NWID_SPACER), SetFill(1, 0),
1590 NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_BRAS_PLATFORM_NUM_1), SetMinimalSize(15, 12), SetDataTip(STR_BLACK_1, STR_STATION_BUILD_NUMBER_OF_TRACKS_TOOLTIP),
1591 NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_BRAS_PLATFORM_NUM_2), SetMinimalSize(15, 12), SetDataTip(STR_BLACK_2, STR_STATION_BUILD_NUMBER_OF_TRACKS_TOOLTIP),
1592 NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_BRAS_PLATFORM_NUM_3), SetMinimalSize(15, 12), SetDataTip(STR_BLACK_3, STR_STATION_BUILD_NUMBER_OF_TRACKS_TOOLTIP),
1593 NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_BRAS_PLATFORM_NUM_4), SetMinimalSize(15, 12), SetDataTip(STR_BLACK_4, STR_STATION_BUILD_NUMBER_OF_TRACKS_TOOLTIP),
1594 NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_BRAS_PLATFORM_NUM_5), SetMinimalSize(15, 12), SetDataTip(STR_BLACK_5, STR_STATION_BUILD_NUMBER_OF_TRACKS_TOOLTIP),
1595 NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_BRAS_PLATFORM_NUM_6), SetMinimalSize(15, 12), SetDataTip(STR_BLACK_6, STR_STATION_BUILD_NUMBER_OF_TRACKS_TOOLTIP),
1596 NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_BRAS_PLATFORM_NUM_7), SetMinimalSize(15, 12), SetDataTip(STR_BLACK_7, STR_STATION_BUILD_NUMBER_OF_TRACKS_TOOLTIP),
1597 NWidget(NWID_SPACER), SetFill(1, 0),
1598 EndContainer(),
1599 NWidget(WWT_LABEL, COLOUR_DARK_GREEN), SetMinimalSize(144, 11), SetDataTip(STR_STATION_BUILD_PLATFORM_LENGTH, STR_NULL), SetPadding(2, 2, 0, 2),
1600 NWidget(NWID_HORIZONTAL),
1601 NWidget(NWID_SPACER), SetFill(1, 0),
1602 NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_BRAS_PLATFORM_LEN_1), SetMinimalSize(15, 12), SetDataTip(STR_BLACK_1, STR_STATION_BUILD_PLATFORM_LENGTH_TOOLTIP),
1603 NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_BRAS_PLATFORM_LEN_2), SetMinimalSize(15, 12), SetDataTip(STR_BLACK_2, STR_STATION_BUILD_PLATFORM_LENGTH_TOOLTIP),
1604 NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_BRAS_PLATFORM_LEN_3), SetMinimalSize(15, 12), SetDataTip(STR_BLACK_3, STR_STATION_BUILD_PLATFORM_LENGTH_TOOLTIP),
1605 NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_BRAS_PLATFORM_LEN_4), SetMinimalSize(15, 12), SetDataTip(STR_BLACK_4, STR_STATION_BUILD_PLATFORM_LENGTH_TOOLTIP),
1606 NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_BRAS_PLATFORM_LEN_5), SetMinimalSize(15, 12), SetDataTip(STR_BLACK_5, STR_STATION_BUILD_PLATFORM_LENGTH_TOOLTIP),
1607 NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_BRAS_PLATFORM_LEN_6), SetMinimalSize(15, 12), SetDataTip(STR_BLACK_6, STR_STATION_BUILD_PLATFORM_LENGTH_TOOLTIP),
1608 NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_BRAS_PLATFORM_LEN_7), SetMinimalSize(15, 12), SetDataTip(STR_BLACK_7, STR_STATION_BUILD_PLATFORM_LENGTH_TOOLTIP),
1609 NWidget(NWID_SPACER), SetFill(1, 0),
1610 EndContainer(),
1611 NWidget(NWID_SPACER), SetMinimalSize(0, 2),
1612 NWidget(NWID_HORIZONTAL),
1613 NWidget(NWID_SPACER), SetMinimalSize(2, 0), SetFill(1, 0),
1614 NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_BRAS_PLATFORM_DRAG_N_DROP), SetMinimalSize(75, 12), SetDataTip(STR_STATION_BUILD_DRAG_DROP, STR_STATION_BUILD_DRAG_DROP_TOOLTIP),
1615 NWidget(NWID_SPACER), SetMinimalSize(2, 0), SetFill(1, 0),
1616 EndContainer(),
1617 NWidget(WWT_LABEL, COLOUR_DARK_GREEN), SetMinimalSize(144, 11), SetDataTip(STR_STATION_BUILD_COVERAGE_AREA_TITLE, STR_NULL), SetPadding(3, 2, 0, 0),
1618 NWidget(NWID_HORIZONTAL),
1619 NWidget(NWID_SPACER), SetMinimalSize(2, 0), SetFill(1, 0),
1620 NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_BRAS_HIGHLIGHT_OFF), SetMinimalSize(60, 12),
1621 SetDataTip(STR_STATION_BUILD_COVERAGE_OFF, STR_STATION_BUILD_COVERAGE_AREA_OFF_TOOLTIP),
1622 NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_BRAS_HIGHLIGHT_ON), SetMinimalSize(60, 12),
1623 SetDataTip(STR_STATION_BUILD_COVERAGE_ON, STR_STATION_BUILD_COVERAGE_AREA_ON_TOOLTIP),
1624 NWidget(NWID_SPACER), SetMinimalSize(2, 0), SetFill(1, 0),
1625 EndContainer(),
1626 EndContainer(),
1627 NWidget(NWID_SELECTION, INVALID_COLOUR, WID_BRAS_SHOW_NEWST_MATRIX),
1628 /* We need an additional background for the matrix, as the matrix cannot handle the scrollbar due to not being an NWidgetCore. */
1629 NWidget(WWT_PANEL, COLOUR_DARK_GREEN), SetScrollbar(WID_BRAS_MATRIX_SCROLL),
1630 NWidget(NWID_HORIZONTAL),
1631 NWidget(NWID_MATRIX, COLOUR_DARK_GREEN, WID_BRAS_MATRIX), SetScrollbar(WID_BRAS_MATRIX_SCROLL), SetPIP(0, 2, 0),
1632 NWidget(WWT_PANEL, COLOUR_DARK_GREEN, WID_BRAS_IMAGE), SetMinimalSize(66, 60),
1633 SetFill(0, 0), SetResize(0, 0), SetDataTip(0x0, STR_STATION_BUILD_STATION_TYPE_TOOLTIP), SetScrollbar(WID_BRAS_MATRIX_SCROLL),
1634 EndContainer(),
1635 EndContainer(),
1636 NWidget(NWID_VSCROLLBAR, COLOUR_DARK_GREEN, WID_BRAS_MATRIX_SCROLL),
1637 EndContainer(),
1638 EndContainer(),
1639 EndContainer(),
1640 EndContainer(),
1641 NWidget(NWID_HORIZONTAL),
1642 NWidget(WWT_EMPTY, INVALID_COLOUR, WID_BRAS_COVERAGE_TEXTS), SetPadding(2, 5, 0, 1), SetFill(1, 1), SetResize(1, 0),
1643 NWidget(NWID_SELECTION, INVALID_COLOUR, WID_BRAS_SHOW_NEWST_RESIZE),
1644 NWidget(NWID_VERTICAL),
1645 NWidget(WWT_PANEL, COLOUR_DARK_GREEN), SetFill(0, 1), EndContainer(),
1646 NWidget(WWT_RESIZEBOX, COLOUR_DARK_GREEN),
1647 EndContainer(),
1648 EndContainer(),
1649 EndContainer(),
1650 EndContainer(),
1651 };
1652
1654 static WindowDesc _station_builder_desc(
1655 WDP_AUTO, "build_station_rail", 350, 0,
1656 WC_BUILD_STATION, WC_BUILD_TOOLBAR,
1657 WDF_CONSTRUCTION,
1658 _nested_station_builder_widgets, lengthof(_nested_station_builder_widgets),
1659 &BuildRailStationWindow::hotkeys
1660 );
1661
1663 static Window *ShowStationBuilder(Window *parent)
1664 {
1665 bool newstations = StationClass::GetClassCount() > 2 || StationClass::Get(STAT_CLASS_DFLT)->GetSpecCount() != 1;
1666 return new BuildRailStationWindow(&_station_builder_desc, parent, newstations);
1667 }
1668
1669 struct BuildSignalWindow : public PickerWindowBase {
1670 private:
1671 Dimension sig_sprite_size;
1672 int sig_sprite_bottom_offset;
1673
1681 void DrawSignalSprite(byte widget_index, SpriteID image) const
1682 {
1683 Point offset;
1684 Dimension sprite_size = GetSpriteSize(image, &offset);
1685 const NWidgetBase *widget = this->GetWidget<NWidgetBase>(widget_index);
1686 int x = widget->pos_x - offset.x +
1687 (widget->current_x - sprite_size.width + offset.x) / 2; // centered
1688 int y = widget->pos_y - sig_sprite_bottom_offset + WD_IMGBTN_TOP +
1689 (widget->current_y - WD_IMGBTN_TOP - WD_IMGBTN_BOTTOM + sig_sprite_size.height) / 2; // aligned to bottom
1690
1691 DrawSprite(image, PAL_NONE,
1692 x + this->IsWidgetLowered(widget_index),
1693 y + this->IsWidgetLowered(widget_index));
1694 }
1695
1697 void SetSignalUIMode()
1698 {
1699 bool show_non_path_signals = (_settings_client.gui.signal_gui_mode == SIGNAL_GUI_ALL);
1700
1701 this->GetWidget<NWidgetStacked>(WID_BS_SEMAPHORE_NORM_SEL)->SetDisplayedPlane(show_non_path_signals ? 0 : SZSP_NONE);
1702 this->GetWidget<NWidgetStacked>(WID_BS_ELECTRIC_NORM_SEL)->SetDisplayedPlane(show_non_path_signals ? 0 : SZSP_NONE);
1703 this->GetWidget<NWidgetStacked>(WID_BS_SEMAPHORE_ENTRY_SEL)->SetDisplayedPlane(show_non_path_signals ? 0 : SZSP_NONE);
1704 this->GetWidget<NWidgetStacked>(WID_BS_ELECTRIC_ENTRY_SEL)->SetDisplayedPlane(show_non_path_signals ? 0 : SZSP_NONE);
1705 this->GetWidget<NWidgetStacked>(WID_BS_SEMAPHORE_EXIT_SEL)->SetDisplayedPlane(show_non_path_signals ? 0 : SZSP_NONE);
1706 this->GetWidget<NWidgetStacked>(WID_BS_ELECTRIC_EXIT_SEL)->SetDisplayedPlane(show_non_path_signals ? 0 : SZSP_NONE);
1707 this->GetWidget<NWidgetStacked>(WID_BS_SEMAPHORE_COMBO_SEL)->SetDisplayedPlane(show_non_path_signals ? 0 : SZSP_NONE);
1708 this->GetWidget<NWidgetStacked>(WID_BS_ELECTRIC_COMBO_SEL)->SetDisplayedPlane(show_non_path_signals ? 0 : SZSP_NONE);
1709 }
1710
1711 public:
1712 BuildSignalWindow(WindowDesc *desc, Window *parent) : PickerWindowBase(desc, parent)
1713 {
1714 this->CreateNestedTree();
1715 this->SetSignalUIMode();
1716 this->FinishInitNested(TRANSPORT_RAIL);
1717 this->OnInvalidateData();
1718 }
1719
1720 void Close() override
1721 {
1722 _convert_signal_button = false;
1723 this->PickerWindowBase::Close();
1724 }
1725
1726 void OnInit() override
1727 {
1728 /* Calculate maximum signal sprite size. */
1729 this->sig_sprite_size.width = 0;
1730 this->sig_sprite_size.height = 0;
1731 this->sig_sprite_bottom_offset = 0;
1732 const RailtypeInfo *rti = GetRailTypeInfo(_cur_railtype);
1733 for (uint type = SIGTYPE_NORMAL; type < SIGTYPE_END; type++) {
1734 for (uint variant = SIG_ELECTRIC; variant <= SIG_SEMAPHORE; variant++) {
1735 for (uint lowered = 0; lowered < 2; lowered++) {
1736 Point offset;
1737 Dimension sprite_size = GetSpriteSize(rti->gui_sprites.signals[type][variant][lowered], &offset);
1738 this->sig_sprite_bottom_offset = std::max<int>(this->sig_sprite_bottom_offset, sprite_size.height);
1739 this->sig_sprite_size.width = std::max<int>(this->sig_sprite_size.width, sprite_size.width - offset.x);
1740 this->sig_sprite_size.height = std::max<int>(this->sig_sprite_size.height, sprite_size.height - offset.y);
1741 }
1742 }
1743 }
1744 }
1745
1746 void UpdateWidgetSize(int widget, Dimension *size, const Dimension &padding, Dimension *fill, Dimension *resize) override
1747 {
1748 if (widget == WID_BS_DRAG_SIGNALS_DENSITY_LABEL) {
1749 /* Two digits for signals density. */
1750 size->width = std::max(size->width, 2 * GetDigitWidth() + padding.width + WD_FRAMERECT_LEFT + WD_FRAMERECT_RIGHT);
1751 } else if (IsInsideMM(widget, WID_BS_SEMAPHORE_NORM, WID_BS_ELECTRIC_PBS_OWAY + 1)) {
1752 size->width = std::max(size->width, this->sig_sprite_size.width + WD_IMGBTN_LEFT + WD_IMGBTN_RIGHT);
1753 size->height = std::max(size->height, this->sig_sprite_size.height + WD_IMGBTN_TOP + WD_IMGBTN_BOTTOM);
1754 } else if (widget == WID_BS_CAPTION) {
1755 size->width += WD_FRAMETEXT_LEFT + WD_FRAMETEXT_RIGHT;
1756 }
1757 }
1758
1759 void SetStringParameters(int widget) const override
1760 {
1761 switch (widget) {
1762 case WID_BS_DRAG_SIGNALS_DENSITY_LABEL:
1763 SetDParam(0, _settings_client.gui.drag_signals_density);
1764 break;
1765 }
1766 }
1767
1768 void DrawWidget(const Rect &r, int widget) const override
1769 {
1770 if (IsInsideMM(widget, WID_BS_SEMAPHORE_NORM, WID_BS_ELECTRIC_PBS_OWAY + 1)) {
1771 /* Extract signal from widget number. */
1772 int type = (widget - WID_BS_SEMAPHORE_NORM) % SIGTYPE_END;
1773 int var = SIG_SEMAPHORE - (widget - WID_BS_SEMAPHORE_NORM) / SIGTYPE_END; // SignalVariant order is reversed compared to the widgets.
1774 SpriteID sprite = GetRailTypeInfo(_cur_railtype)->gui_sprites.signals[type][var][this->IsWidgetLowered(widget)];
1775
1776 this->DrawSignalSprite(widget, sprite);
1777 }
1778 }
1779
1780 void OnClick(Point pt, int widget, int click_count) override
1781 {
1782 switch (widget) {
1783 case WID_BS_SEMAPHORE_NORM:
1784 case WID_BS_SEMAPHORE_ENTRY:
1785 case WID_BS_SEMAPHORE_EXIT:
1786 case WID_BS_SEMAPHORE_COMBO:
1787 case WID_BS_SEMAPHORE_PBS:
1788 case WID_BS_SEMAPHORE_PBS_OWAY:
1789 case WID_BS_ELECTRIC_NORM:
1790 case WID_BS_ELECTRIC_ENTRY:
1791 case WID_BS_ELECTRIC_EXIT:
1792 case WID_BS_ELECTRIC_COMBO:
1793 case WID_BS_ELECTRIC_PBS:
1794 case WID_BS_ELECTRIC_PBS_OWAY:
1795 this->RaiseWidget((_cur_signal_variant == SIG_ELECTRIC ? WID_BS_ELECTRIC_NORM : WID_BS_SEMAPHORE_NORM) + _cur_signal_type);
1796
1797 _cur_signal_type = (SignalType)((uint)((widget - WID_BS_SEMAPHORE_NORM) % (SIGTYPE_LAST + 1)));
1798 _cur_signal_variant = widget >= WID_BS_ELECTRIC_NORM ? SIG_ELECTRIC : SIG_SEMAPHORE;
1799
1800 /* Update default (last-used) signal type in config file. */
1801 _settings_client.gui.default_signal_type = _cur_signal_type;
1802
1803 /* If 'remove' button of rail build toolbar is active, disable it. */
1804 if (_remove_button_clicked) {
1805 Window *w = FindWindowById(WC_BUILD_TOOLBAR, TRANSPORT_RAIL);
1806 if (w != nullptr) ToggleRailButton_Remove(w);
1807 }
1808
1809 break;
1810
1811 case WID_BS_CONVERT:
1812 _convert_signal_button = !_convert_signal_button;
1813 break;
1814
1815 case WID_BS_DRAG_SIGNALS_DENSITY_DECREASE:
1816 if (_settings_client.gui.drag_signals_density > 1) {
1817 _settings_client.gui.drag_signals_density--;
1818 SetWindowDirty(WC_GAME_OPTIONS, WN_GAME_OPTIONS_GAME_SETTINGS);
1819 }
1820 break;
1821
1822 case WID_BS_DRAG_SIGNALS_DENSITY_INCREASE:
1823 if (_settings_client.gui.drag_signals_density < 20) {
1824 _settings_client.gui.drag_signals_density++;
1825 SetWindowDirty(WC_GAME_OPTIONS, WN_GAME_OPTIONS_GAME_SETTINGS);
1826 }
1827 break;
1828
1829 case WID_BS_TOGGLE_SIZE:
1830 _settings_client.gui.signal_gui_mode = (_settings_client.gui.signal_gui_mode == SIGNAL_GUI_ALL) ? SIGNAL_GUI_PATH : SIGNAL_GUI_ALL;
1831 this->SetSignalUIMode();
1832 this->ReInit();
1833 break;
1834
1835 default: break;
1836 }
1837
1838 this->InvalidateData();
1839 }
1840
1846 void OnInvalidateData(int data = 0, bool gui_scope = true) override
1847 {
1848 if (!gui_scope) return;
1849 this->LowerWidget((_cur_signal_variant == SIG_ELECTRIC ? WID_BS_ELECTRIC_NORM : WID_BS_SEMAPHORE_NORM) + _cur_signal_type);
1850
1851 this->SetWidgetLoweredState(WID_BS_CONVERT, _convert_signal_button);
1852
1853 this->SetWidgetDisabledState(WID_BS_DRAG_SIGNALS_DENSITY_DECREASE, _settings_client.gui.drag_signals_density == 1);
1854 this->SetWidgetDisabledState(WID_BS_DRAG_SIGNALS_DENSITY_INCREASE, _settings_client.gui.drag_signals_density == 20);
1855 }
1856 };
1857
1859 static const NWidgetPart _nested_signal_builder_widgets[] = {
1860 NWidget(NWID_HORIZONTAL),
1861 NWidget(WWT_CLOSEBOX, COLOUR_DARK_GREEN),
1862 NWidget(WWT_CAPTION, COLOUR_DARK_GREEN, WID_BS_CAPTION), SetDataTip(STR_BUILD_SIGNAL_CAPTION, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
1863 NWidget(WWT_IMGBTN, COLOUR_DARK_GREEN, WID_BS_TOGGLE_SIZE), SetDataTip(SPR_LARGE_SMALL_WINDOW, STR_BUILD_SIGNAL_TOGGLE_ADVANCED_SIGNAL_TOOLTIP),
1864 EndContainer(),
1865 NWidget(NWID_VERTICAL, NC_EQUALSIZE),
1866 NWidget(NWID_HORIZONTAL, NC_EQUALSIZE),
1867 NWidget(NWID_SELECTION, INVALID_COLOUR, WID_BS_SEMAPHORE_NORM_SEL),
1868 NWidget(WWT_PANEL, COLOUR_DARK_GREEN, WID_BS_SEMAPHORE_NORM), SetDataTip(STR_NULL, STR_BUILD_SIGNAL_SEMAPHORE_NORM_TOOLTIP), EndContainer(), SetFill(1, 1),
1869 EndContainer(),
1870 NWidget(NWID_SELECTION, INVALID_COLOUR, WID_BS_SEMAPHORE_ENTRY_SEL),
1871 NWidget(WWT_PANEL, COLOUR_DARK_GREEN, WID_BS_SEMAPHORE_ENTRY), SetDataTip(STR_NULL, STR_BUILD_SIGNAL_SEMAPHORE_ENTRY_TOOLTIP), EndContainer(), SetFill(1, 1),
1872 EndContainer(),
1873 NWidget(NWID_SELECTION, INVALID_COLOUR, WID_BS_SEMAPHORE_EXIT_SEL),
1874 NWidget(WWT_PANEL, COLOUR_DARK_GREEN, WID_BS_SEMAPHORE_EXIT), SetDataTip(STR_NULL, STR_BUILD_SIGNAL_SEMAPHORE_EXIT_TOOLTIP), EndContainer(), SetFill(1, 1),
1875 EndContainer(),
1876 NWidget(NWID_SELECTION, INVALID_COLOUR, WID_BS_SEMAPHORE_COMBO_SEL),
1877 NWidget(WWT_PANEL, COLOUR_DARK_GREEN, WID_BS_SEMAPHORE_COMBO), SetDataTip(STR_NULL, STR_BUILD_SIGNAL_SEMAPHORE_COMBO_TOOLTIP), EndContainer(), SetFill(1, 1),
1878 EndContainer(),
1879 NWidget(WWT_PANEL, COLOUR_DARK_GREEN, WID_BS_SEMAPHORE_PBS), SetDataTip(STR_NULL, STR_BUILD_SIGNAL_SEMAPHORE_PBS_TOOLTIP), EndContainer(), SetFill(1, 1),
1880 NWidget(WWT_PANEL, COLOUR_DARK_GREEN, WID_BS_SEMAPHORE_PBS_OWAY), SetDataTip(STR_NULL, STR_BUILD_SIGNAL_SEMAPHORE_PBS_OWAY_TOOLTIP), EndContainer(), SetFill(1, 1),
1881 NWidget(WWT_IMGBTN, COLOUR_DARK_GREEN, WID_BS_CONVERT), SetDataTip(SPR_IMG_SIGNAL_CONVERT, STR_BUILD_SIGNAL_CONVERT_TOOLTIP), SetFill(1, 1),
1882 EndContainer(),
1883 NWidget(NWID_HORIZONTAL, NC_EQUALSIZE),
1884 NWidget(NWID_SELECTION, INVALID_COLOUR, WID_BS_ELECTRIC_NORM_SEL),
1885 NWidget(WWT_PANEL, COLOUR_DARK_GREEN, WID_BS_ELECTRIC_NORM), SetDataTip(STR_NULL, STR_BUILD_SIGNAL_ELECTRIC_NORM_TOOLTIP), EndContainer(), SetFill(1, 1),
1886 EndContainer(),
1887 NWidget(NWID_SELECTION, INVALID_COLOUR, WID_BS_ELECTRIC_ENTRY_SEL),
1888 NWidget(WWT_PANEL, COLOUR_DARK_GREEN, WID_BS_ELECTRIC_ENTRY), SetDataTip(STR_NULL, STR_BUILD_SIGNAL_ELECTRIC_ENTRY_TOOLTIP), EndContainer(), SetFill(1, 1),
1889 EndContainer(),
1890 NWidget(NWID_SELECTION, INVALID_COLOUR, WID_BS_ELECTRIC_EXIT_SEL),
1891 NWidget(WWT_PANEL, COLOUR_DARK_GREEN, WID_BS_ELECTRIC_EXIT), SetDataTip(STR_NULL, STR_BUILD_SIGNAL_ELECTRIC_EXIT_TOOLTIP), EndContainer(), SetFill(1, 1),
1892 EndContainer(),
1893 NWidget(NWID_SELECTION, INVALID_COLOUR, WID_BS_ELECTRIC_COMBO_SEL),
1894 NWidget(WWT_PANEL, COLOUR_DARK_GREEN, WID_BS_ELECTRIC_COMBO), SetDataTip(STR_NULL, STR_BUILD_SIGNAL_ELECTRIC_COMBO_TOOLTIP), EndContainer(), SetFill(1, 1),
1895 EndContainer(),
1896 NWidget(WWT_PANEL, COLOUR_DARK_GREEN, WID_BS_ELECTRIC_PBS), SetDataTip(STR_NULL, STR_BUILD_SIGNAL_ELECTRIC_PBS_TOOLTIP), EndContainer(), SetFill(1, 1),
1897 NWidget(WWT_PANEL, COLOUR_DARK_GREEN, WID_BS_ELECTRIC_PBS_OWAY), SetDataTip(STR_NULL, STR_BUILD_SIGNAL_ELECTRIC_PBS_OWAY_TOOLTIP), EndContainer(), SetFill(1, 1),
1898 NWidget(WWT_PANEL, COLOUR_DARK_GREEN), SetDataTip(STR_NULL, STR_BUILD_SIGNAL_DRAG_SIGNALS_DENSITY_TOOLTIP), SetFill(1, 1),
1899 NWidget(WWT_LABEL, COLOUR_DARK_GREEN, WID_BS_DRAG_SIGNALS_DENSITY_LABEL), SetDataTip(STR_ORANGE_INT, STR_BUILD_SIGNAL_DRAG_SIGNALS_DENSITY_TOOLTIP), SetFill(1, 1),
1900 NWidget(NWID_HORIZONTAL), SetPIP(2, 0, 2),
1901 NWidget(NWID_SPACER), SetFill(1, 0),
1902 NWidget(WWT_PUSHARROWBTN, COLOUR_GREY, WID_BS_DRAG_SIGNALS_DENSITY_DECREASE), SetMinimalSize(9, 12), SetDataTip(AWV_DECREASE, STR_BUILD_SIGNAL_DRAG_SIGNALS_DENSITY_DECREASE_TOOLTIP),
1903 NWidget(WWT_PUSHARROWBTN, COLOUR_GREY, WID_BS_DRAG_SIGNALS_DENSITY_INCREASE), SetMinimalSize(9, 12), SetDataTip(AWV_INCREASE, STR_BUILD_SIGNAL_DRAG_SIGNALS_DENSITY_INCREASE_TOOLTIP),
1904 NWidget(NWID_SPACER), SetFill(1, 0),
1905 EndContainer(),
1906 NWidget(NWID_SPACER), SetMinimalSize(0, 2), SetFill(1, 0),
1907 EndContainer(),
1908 EndContainer(),
1909 EndContainer(),
1910 };
1911
1913 static WindowDesc _signal_builder_desc(
1914 WDP_AUTO, "build_signal", 0, 0,
1915 WC_BUILD_SIGNAL, WC_BUILD_TOOLBAR,
1916 WDF_CONSTRUCTION,
1917 _nested_signal_builder_widgets, lengthof(_nested_signal_builder_widgets)
1918 );
1919
1923 static void ShowSignalBuilder(Window *parent)
1924 {
1925 new BuildSignalWindow(&_signal_builder_desc, parent);
1926 }
1927
1928 struct BuildRailDepotWindow : public PickerWindowBase {
1929 BuildRailDepotWindow(WindowDesc *desc, Window *parent) : PickerWindowBase(desc, parent)
1930 {
1931 this->InitNested(TRANSPORT_RAIL);
1932 this->LowerWidget(_build_depot_direction + WID_BRAD_DEPOT_NE);
1933 }
1934
1935 void UpdateWidgetSize(int widget, Dimension *size, const Dimension &padding, Dimension *fill, Dimension *resize) override
1936 {
1937 if (!IsInsideMM(widget, WID_BRAD_DEPOT_NE, WID_BRAD_DEPOT_NW + 1)) return;
1938
1939 size->width = ScaleGUITrad(64) + 2;
1940 size->height = ScaleGUITrad(48) + 2;
1941 }
1942
1943 void DrawWidget(const Rect &r, int widget) const override
1944 {
1945 if (!IsInsideMM(widget, WID_BRAD_DEPOT_NE, WID_BRAD_DEPOT_NW + 1)) return;
1946
1947 DrawTrainDepotSprite(r.left + 1 + ScaleGUITrad(31), r.bottom - ScaleGUITrad(31), widget - WID_BRAD_DEPOT_NE + DIAGDIR_NE, _cur_railtype);
1948 }
1949
1950 void OnClick(Point pt, int widget, int click_count) override
1951 {
1952 switch (widget) {
1953 case WID_BRAD_DEPOT_NE:
1954 case WID_BRAD_DEPOT_SE:
1955 case WID_BRAD_DEPOT_SW:
1956 case WID_BRAD_DEPOT_NW:
1957 this->RaiseWidget(_build_depot_direction + WID_BRAD_DEPOT_NE);
1958 _build_depot_direction = (DiagDirection)(widget - WID_BRAD_DEPOT_NE);
1959 this->LowerWidget(_build_depot_direction + WID_BRAD_DEPOT_NE);
1960 if (_settings_client.sound.click_beep) SndPlayFx(SND_15_BEEP);
1961 this->SetDirty();
1962 break;
1963 }
1964 }
1965 };
1966
1968 static const NWidgetPart _nested_build_depot_widgets[] = {
1969 NWidget(NWID_HORIZONTAL),
1970 NWidget(WWT_CLOSEBOX, COLOUR_DARK_GREEN),
1971 NWidget(WWT_CAPTION, COLOUR_DARK_GREEN), SetDataTip(STR_BUILD_DEPOT_TRAIN_ORIENTATION_CAPTION, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
1972 EndContainer(),
1973 NWidget(WWT_PANEL, COLOUR_DARK_GREEN),
1974 NWidget(NWID_SPACER), SetMinimalSize(0, 3),
1975 NWidget(NWID_HORIZONTAL_LTR),
1976 NWidget(NWID_SPACER), SetMinimalSize(3, 0), SetFill(1, 0),
1977 NWidget(NWID_VERTICAL),
1978 NWidget(WWT_PANEL, COLOUR_GREY, WID_BRAD_DEPOT_NW), SetMinimalSize(66, 50), SetDataTip(0x0, STR_BUILD_DEPOT_TRAIN_ORIENTATION_TOOLTIP),
1979 EndContainer(),
1980 NWidget(NWID_SPACER), SetMinimalSize(0, 2),
1981 NWidget(WWT_PANEL, COLOUR_GREY, WID_BRAD_DEPOT_SW), SetMinimalSize(66, 50), SetDataTip(0x0, STR_BUILD_DEPOT_TRAIN_ORIENTATION_TOOLTIP),
1982 EndContainer(),
1983 EndContainer(),
1984 NWidget(NWID_SPACER), SetMinimalSize(2, 0),
1985 NWidget(NWID_VERTICAL),
1986 NWidget(WWT_PANEL, COLOUR_GREY, WID_BRAD_DEPOT_NE), SetMinimalSize(66, 50), SetDataTip(0x0, STR_BUILD_DEPOT_TRAIN_ORIENTATION_TOOLTIP),
1987 EndContainer(),
1988 NWidget(NWID_SPACER), SetMinimalSize(0, 2),
1989 NWidget(WWT_PANEL, COLOUR_GREY, WID_BRAD_DEPOT_SE), SetMinimalSize(66, 50), SetDataTip(0x0, STR_BUILD_DEPOT_TRAIN_ORIENTATION_TOOLTIP),
1990 EndContainer(),
1991 EndContainer(),
1992 NWidget(NWID_SPACER), SetMinimalSize(3, 0), SetFill(1, 0),
1993 EndContainer(),
1994 NWidget(NWID_SPACER), SetMinimalSize(0, 3),
1995 EndContainer(),
1996 };
1997
1998 static WindowDesc _build_depot_desc(
1999 WDP_AUTO, nullptr, 0, 0,
2000 WC_BUILD_DEPOT, WC_BUILD_TOOLBAR,
2001 WDF_CONSTRUCTION,
2002 _nested_build_depot_widgets, lengthof(_nested_build_depot_widgets)
2003 );
2004
2005 static void ShowBuildTrainDepotPicker(Window *parent)
2006 {
2007 new BuildRailDepotWindow(&_build_depot_desc, parent);
2008 }
2009
2010 struct BuildRailWaypointWindow : PickerWindowBase {
2011 BuildRailWaypointWindow(WindowDesc *desc, Window *parent) : PickerWindowBase(desc, parent)
2012 {
2013 this->CreateNestedTree();
2014
2015 NWidgetMatrix *matrix = this->GetWidget<NWidgetMatrix>(WID_BRW_WAYPOINT_MATRIX);
2016 matrix->SetScrollbar(this->GetScrollbar(WID_BRW_SCROLL));
2017
2018 this->FinishInitNested(TRANSPORT_RAIL);
2019
2020 matrix->SetCount(_waypoint_count);
2021 if (_cur_waypoint_type >= _waypoint_count) _cur_waypoint_type = 0;
2022 matrix->SetClicked(_cur_waypoint_type);
2023 }
2024
2025 void UpdateWidgetSize(int widget, Dimension *size, const Dimension &padding, Dimension *fill, Dimension *resize) override
2026 {
2027 switch (widget) {
2028 case WID_BRW_WAYPOINT_MATRIX:
2029 /* Three blobs high and wide. */
2030 size->width += resize->width * 2;
2031 size->height += resize->height * 2;
2032
2033 /* Resizing in X direction only at blob size, but at pixel level in Y. */
2034 resize->height = 1;
2035 break;
2036
2037 case WID_BRW_WAYPOINT:
2038 size->width = ScaleGUITrad(64) + 2;
2039 size->height = ScaleGUITrad(58) + 2;
2040 break;
2041 }
2042 }
2043
2044 void DrawWidget(const Rect &r, int widget) const override
2045 {
2046 switch (GB(widget, 0, 16)) {
2047 case WID_BRW_WAYPOINT: {
2048 byte type = GB(widget, 16, 16);
2049 const StationSpec *statspec = StationClass::Get(STAT_CLASS_WAYP)->GetSpec(type);
2050 DrawWaypointSprite(r.left + 1 + ScaleGUITrad(31), r.bottom - ScaleGUITrad(31), type, _cur_railtype);
2051
2052 if (!IsStationAvailable(statspec)) {
2053 GfxFillRect(r.left + 1, r.top + 1, r.right - 1, r.bottom - 1, PC_BLACK, FILLRECT_CHECKER);
2054 }
2055 }
2056 }
2057 }
2058
2059 void OnClick(Point pt, int widget, int click_count) override
2060 {
2061 switch (GB(widget, 0, 16)) {
2062 case WID_BRW_WAYPOINT: {
2063 byte type = GB(widget, 16, 16);
2064 this->GetWidget<NWidgetMatrix>(WID_BRW_WAYPOINT_MATRIX)->SetClicked(_cur_waypoint_type);
2065
2066 /* Check station availability callback */
2067 const StationSpec *statspec = StationClass::Get(STAT_CLASS_WAYP)->GetSpec(type);
2068 if (!IsStationAvailable(statspec)) return;
2069
2070 _cur_waypoint_type = type;
2071 this->GetWidget<NWidgetMatrix>(WID_BRW_WAYPOINT_MATRIX)->SetClicked(_cur_waypoint_type);
2072 if (_settings_client.sound.click_beep) SndPlayFx(SND_15_BEEP);
2073 this->SetDirty();
2074 break;
2075 }
2076 }
2077 }
2078 };
2079
2081 static const NWidgetPart _nested_build_waypoint_widgets[] = {
2082 NWidget(NWID_HORIZONTAL),
2083 NWidget(WWT_CLOSEBOX, COLOUR_DARK_GREEN),
2084 NWidget(WWT_CAPTION, COLOUR_DARK_GREEN), SetDataTip(STR_WAYPOINT_CAPTION, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
2085 NWidget(WWT_DEFSIZEBOX, COLOUR_DARK_GREEN),
2086 EndContainer(),
2087 NWidget(NWID_HORIZONTAL),
2088 NWidget(NWID_MATRIX, COLOUR_DARK_GREEN, WID_BRW_WAYPOINT_MATRIX), SetPIP(3, 2, 3), SetScrollbar(WID_BRW_SCROLL),
2089 NWidget(WWT_PANEL, COLOUR_DARK_GREEN, WID_BRW_WAYPOINT), SetMinimalSize(66, 60), SetDataTip(0x0, STR_WAYPOINT_GRAPHICS_TOOLTIP), SetScrollbar(WID_BRW_SCROLL), EndContainer(),
2090 EndContainer(),
2091 NWidget(NWID_VERTICAL),
2092 NWidget(NWID_VSCROLLBAR, COLOUR_DARK_GREEN, WID_BRW_SCROLL),
2093 NWidget(WWT_RESIZEBOX, COLOUR_DARK_GREEN),
2094 EndContainer(),
2095 EndContainer(),
2096 };
2097
2098 static WindowDesc _build_waypoint_desc(
2099 WDP_AUTO, "build_waypoint", 0, 0,
2100 WC_BUILD_WAYPOINT, WC_BUILD_TOOLBAR,
2101 WDF_CONSTRUCTION,
2102 _nested_build_waypoint_widgets, lengthof(_nested_build_waypoint_widgets)
2103 );
2104
2105 static void ShowBuildWaypointPicker(Window *parent)
2106 {
2107 new BuildRailWaypointWindow(&_build_waypoint_desc, parent);
2108 }
2109
2113 void InitializeRailGui()
2114 {
2115 _build_depot_direction = DIAGDIR_NW;
2116 _railstation.station_class = StationClassID::STAT_CLASS_DFLT;
2117 }
2118
2123 void ReinitGuiAfterToggleElrail(bool disable)
2124 {
2125 extern RailType _last_built_railtype;
2126 if (disable && _last_built_railtype == RAILTYPE_ELECTRIC) {
2127 _last_built_railtype = _cur_railtype = RAILTYPE_RAIL;
2128 BuildRailToolbarWindow *w = dynamic_cast<BuildRailToolbarWindow *>(FindWindowById(WC_BUILD_TOOLBAR, TRANSPORT_RAIL));
2129 if (w != nullptr) w->ModifyRailType(_cur_railtype);
2130 }
2131 MarkWholeScreenDirty();
2132 }
2133
2135 static void SetDefaultRailGui()
2136 {
2137 if (_local_company == COMPANY_SPECTATOR || !Company::IsValidID(_local_company)) return;
2138
2139 extern RailType _last_built_railtype;
2140 RailType rt;
2141 switch (_settings_client.gui.default_rail_type) {
2142 case 2: {
2143 /* Find the most used rail type */
2144 uint count[RAILTYPE_END];
2145 memset(count, 0, sizeof(count));
2146 for (TileIndex t = 0; t < MapSize(); t++) {
2147 if (IsTileType(t, MP_RAILWAY) || IsLevelCrossingTile(t) || HasStationTileRail(t) ||
2148 (IsTileType(t, MP_TUNNELBRIDGE) && GetTunnelBridgeTransportType(t) == TRANSPORT_RAIL)) {
2149 count[GetRailType(t)]++;
2150 }
2151 }
2152
2153 rt = static_cast<RailType>(std::max_element(count + RAILTYPE_BEGIN, count + RAILTYPE_END) - count);
2154 if (count[rt] > 0) break;
2155
2156 /* No rail, just get the first available one */
2157 FALLTHROUGH;
2158 }
2159 case 0: {
2160 /* Use first available type */
2161 std::vector<RailType>::const_iterator it = std::find_if(_sorted_railtypes.begin(), _sorted_railtypes.end(),
2162 [](RailType r){ return HasRailtypeAvail(_local_company, r); });
2163 rt = it != _sorted_railtypes.end() ? *it : RAILTYPE_BEGIN;
2164 break;
2165 }
2166 case 1: {
2167 /* Use last available type */
2168 std::vector<RailType>::const_reverse_iterator it = std::find_if(_sorted_railtypes.rbegin(), _sorted_railtypes.rend(),
2169 [](RailType r){ return HasRailtypeAvail(_local_company, r); });
2170 rt = it != _sorted_railtypes.rend() ? *it : RAILTYPE_BEGIN;
2171 break;
2172 }
2173 default:
2174 NOT_REACHED();
2175 }
2176
2177 _last_built_railtype = _cur_railtype = rt;
2178 BuildRailToolbarWindow *w = dynamic_cast<BuildRailToolbarWindow *>(FindWindowById(WC_BUILD_TOOLBAR, TRANSPORT_RAIL));
2179 if (w != nullptr) w->ModifyRailType(_cur_railtype);
2180 }
2181
2187 void ResetSignalVariant(int32 new_value)
2188 {
2189 SignalVariant new_variant = (_cur_year < _settings_client.gui.semaphore_build_before ? SIG_SEMAPHORE : SIG_ELECTRIC);
2190
2191 if (new_variant != _cur_signal_variant) {
2192 Window *w = FindWindowById(WC_BUILD_SIGNAL, 0);
2193 if (w != nullptr) {
2194 w->SetDirty();
2195 w->RaiseWidget((_cur_signal_variant == SIG_ELECTRIC ? WID_BS_ELECTRIC_NORM : WID_BS_SEMAPHORE_NORM) + _cur_signal_type);
2196 }
2197 _cur_signal_variant = new_variant;
2198 }
2199 }
2200
2205 void InitializeRailGUI()
2206 {
2207 SetDefaultRailGui();
2208
2209 _convert_signal_button = false;
2210 _cur_signal_type = _settings_client.gui.default_signal_type;
2211 ResetSignalVariant();
2212 }
2213
2220 DropDownList GetRailTypeDropDownList(bool for_replacement, bool all_option)
2221 {
2222 RailTypes used_railtypes;
2223 RailTypes avail_railtypes;
2224
2225 const Company *c = Company::Get(_local_company);
2226
2227 /* Find the used railtypes. */
2228 if (for_replacement) {
2229 avail_railtypes = GetCompanyRailtypes(c->index, false);
2230 used_railtypes = GetRailTypes(false);
2231 } else {
2232 avail_railtypes = c->avail_railtypes;
2233 used_railtypes = GetRailTypes(true);
2234 }
2235
2236 DropDownList list;
2237
2238 if (all_option) {
2239 list.emplace_back(new DropDownListStringItem(STR_REPLACE_ALL_RAILTYPE, INVALID_RAILTYPE, false));
2240 }
2241
2242 Dimension d = { 0, 0 };
2243 /* Get largest icon size, to ensure text is aligned on each menu item. */
2244 if (!for_replacement) {
2245 for (const auto &rt : _sorted_railtypes) {
2246 if (!HasBit(used_railtypes, rt)) continue;
2247 const RailtypeInfo *rti = GetRailTypeInfo(rt);
2248 d = maxdim(d, GetSpriteSize(rti->gui_sprites.build_x_rail));
2249 }
2250 }
2251
2252 for (const auto &rt : _sorted_railtypes) {
2253 /* If it's not used ever, don't show it to the user. */
2254 if (!HasBit(used_railtypes, rt)) continue;
2255
2256 const RailtypeInfo *rti = GetRailTypeInfo(rt);
2257
2258 StringID str = for_replacement ? rti->strings.replace_text : (rti->max_speed > 0 ? STR_TOOLBAR_RAILTYPE_VELOCITY : STR_JUST_STRING);
2259 DropDownListParamStringItem *item;
2260 if (for_replacement) {
2261 item = new DropDownListParamStringItem(str, rt, !HasBit(avail_railtypes, rt));
2262 } else {
2263 DropDownListIconItem *iconitem = new DropDownListIconItem(rti->gui_sprites.build_x_rail, PAL_NONE, str, rt, !HasBit(avail_railtypes, rt));
2264 iconitem->SetDimension(d);
2265 item = iconitem;
2266 }
2267 item->SetParam(0, rti->strings.menu_text);
2268 item->SetParam(1, rti->max_speed);
2269 list.emplace_back(item);
2270 }
2271
2272 if (list.size() == 0) {
2273 /* Empty dropdowns are not allowed */
2274 list.emplace_back(new DropDownListStringItem(STR_NONE, INVALID_RAILTYPE, true));
2275 }
2276
2277 return list;
2278 }
SZSP_NONE
@ SZSP_NONE
Display plane with zero size in both directions (none filling and resizing).
Definition: widget_type.h:423
ES_HANDLED
@ ES_HANDLED
The passed event is handled.
Definition: window_type.h:718
WID_BRAS_PLATFORM_LEN_6
@ WID_BRAS_PLATFORM_LEN_6
Button to select 6 tiles length station platforms.
Definition: rail_widget.h:52
HT_DIR_HL
@ HT_DIR_HL
horizontal lower
Definition: tilehighlight_type.h:36
RailtypeInfo::rail_nwse
CursorID rail_nwse
Cursor for building rail in Y direction.
Definition: rail.h:165
BuildRailToolbarWindow::OnPlaceDrag
void OnPlaceDrag(ViewportPlaceMethod select_method, ViewportDragDropSelectionProcess select_proc, Point pt) override
The user is dragging over the map when the tile highlight mode has been set.
Definition: rail_gui.cpp:680
WID_BRAS_PLATFORM_DRAG_N_DROP
@ WID_BRAS_PLATFORM_DRAG_N_DROP
Button to enable drag and drop type station placement.
Definition: rail_widget.h:55
GUISettings::station_numtracks
byte station_numtracks
the number of platforms to default on for rail stations
Definition: settings_type.h:160
SetTileSelectSize
void SetTileSelectSize(int w, int h)
Highlight w by h tiles at the cursor.
Definition: viewport.cpp:2472
DIAGDIR_SE
@ DIAGDIR_SE
Southeast.
Definition: direction_type.h:80
PickerWindowBase::Close
void Close() override
Hide the window and all its child windows, and mark them for a later deletion.
Definition: window.cpp:3528
DDSP_DEMOLISH_AREA
@ DDSP_DEMOLISH_AREA
Clear area.
Definition: viewport_type.h:116
tunnelbridge.h
_remove_button_clicked
static bool _remove_button_clicked
Flag whether 'remove' toggle-button is currently enabled.
Definition: rail_gui.cpp:49
CA_UNMODIFIED
@ CA_UNMODIFIED
Catchment for all stations with "modified catchment" disabled.
Definition: station_type.h:82
CMD_MSG
#define CMD_MSG(x)
Used to combine a StringID with the command.
Definition: command_type.h:372
TileIndex
uint32 TileIndex
The index/ID of a Tile.
Definition: tile_type.h:83
WID_RAT_DEMOLISH
@ WID_RAT_DEMOLISH
Destroy something with dynamite!
Definition: rail_widget.h:22
sound_func.h
DDSP_CONVERT_RAIL
@ DDSP_CONVERT_RAIL
Rail conversion.
Definition: viewport_type.h:132
GUISettings::station_dragdrop
bool station_dragdrop
whether drag and drop is enabled for stations
Definition: settings_type.h:162
BuildRailStationWindow::coverage_height
uint coverage_height
Height of the coverage texts.
Definition: rail_gui.cpp:903
WID_BS_SEMAPHORE_EXIT
@ WID_BS_SEMAPHORE_EXIT
Build a semaphore exit block signal.
Definition: rail_widget.h:85
RailToolbar_CtrlChanged
static bool RailToolbar_CtrlChanged(Window *w)
Updates the Remove button because of Ctrl state change.
Definition: rail_gui.cpp:309
BuildRalStationHotkeys
BuildRalStationHotkeys
Enum referring to the Hotkeys in the build rail station window.
Definition: rail_gui.cpp:896
RailtypeInfo::max_speed
uint16 max_speed
Maximum speed for vehicles travelling on this rail type.
Definition: rail.h:228
newgrf_station.h
DoCommand
CommandCost DoCommand(const CommandContainer *container, DoCommandFlag flags)
Shorthand for calling the long DoCommand with a container.
Definition: command.cpp:450
IsValidAxis
static bool IsValidAxis(Axis d)
Checks if an integer value is a valid Axis.
Definition: direction_func.h:43
GUISettings::station_show_coverage
bool station_show_coverage
whether to highlight coverage area
Definition: settings_type.h:163
Pool::PoolItem<&_company_pool >::Get
static Titem * Get(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:337
WC_BUILD_TOOLBAR
@ WC_BUILD_TOOLBAR
Build toolbar; Window numbers:
Definition: window_type.h:65
TileOffsByDiagDir
static TileIndexDiff TileOffsByDiagDir(DiagDirection dir)
Convert a DiagDirection to a TileIndexDiff.
Definition: map_func.h:341
GUISettings::drag_signals_fixed_distance
bool drag_signals_fixed_distance
keep fixed distance between signals when dragging
Definition: settings_type.h:156
VPM_FIX_VERTICAL
@ VPM_FIX_VERTICAL
drag only in vertical direction
Definition: viewport_type.h:103
BuildRailStationWindow::SelectClassAndStation
void SelectClassAndStation()
Checks if the previously selected current station class and station can be shown as selected to the u...
Definition: rail_gui.cpp:1090
GameSettings::station
StationSettings station
settings related to station management
Definition: settings_type.h:588
WD_MATRIX_RIGHT
@ WD_MATRIX_RIGHT
Offset at right of a matrix cell.
Definition: window_gui.h:79
GetRailTypeDropDownList
DropDownList GetRailTypeDropDownList(bool for_replacement, bool all_option)
Create a drop down list for all the rail types of the local company.
Definition: rail_gui.cpp:2220
SetWindowDirty
void SetWindowDirty(WindowClass cls, WindowNumber number)
Mark window as dirty (in need of repainting)
Definition: window.cpp:3136
querystring_gui.h
DropDownListParamStringItem
String list item with parameters.
Definition: dropdown_type.h:56
SetScrollbar
static NWidgetPart SetScrollbar(int index)
Attach a scrollbar to a widget.
Definition: widget_type.h:1188
WID_BS_TOGGLE_SIZE
@ WID_BS_TOGGLE_SIZE
Toggle showing advanced signal types.
Definition: rail_widget.h:82
NewGRFClass::GetUISpecCount
uint GetUISpecCount() const
Get the number of potentially user-available specs within the class.
Definition: newgrf_class.h:46
HotkeyList
List of hotkeys for a window.
Definition: hotkeys.h:40
VpSetPresizeRange
void VpSetPresizeRange(TileIndex from, TileIndex to)
Highlights all tiles between a set of two tiles.
Definition: viewport.cpp:2709
BuildRailDepotWindow::DrawWidget
void DrawWidget(const Rect &r, int widget) const override
Draw the contents of a nested widget.
Definition: rail_gui.cpp:1943
GB
static uint GB(const T x, const uint8 s, const uint8 n)
Fetch n bits from x, started at bit s.
Definition: bitmath_func.hpp:32
WID_RAT_BUILD_SIGNALS
@ WID_RAT_BUILD_SIGNALS
Build signals.
Definition: rail_widget.h:26
WID_RAT_BUILD_Y
@ WID_RAT_BUILD_Y
Build rail along the game grid Y axis.
Definition: rail_widget.h:20
SetFocusedWindow
void SetFocusedWindow(Window *w)
Set the window that has the focus.
Definition: window.cpp:445
BuildSignalWindow::sig_sprite_size
Dimension sig_sprite_size
Maximum size of signal GUI sprites.
Definition: rail_gui.cpp:1671
Dimension
Dimensions (a width and height) of a rectangle in 2D.
Definition: geometry_type.hpp:27
command_func.h
RailtypeInfo::menu_text
StringID menu_text
Name of this rail type in the main toolbar dropdown.
Definition: rail.h:175
WWT_STICKYBOX
@ WWT_STICKYBOX
Sticky box (at top-right of a window, after WWT_DEFSIZEBOX)
Definition: widget_type.h:64
SetPadding
static NWidgetPart SetPadding(uint8 top, uint8 right, uint8 bottom, uint8 left)
Widget part function for setting additional space around a widget.
Definition: widget_type.h:1139
BuildSignalWindow
Definition: rail_gui.cpp:1669
GUIList::Sort
bool Sort(Comp compare)
Sort the list.
Definition: sortlist_type.h:247
Window::GetScrollbar
const Scrollbar * GetScrollbar(uint widnum) const
Return the Scrollbar to a widget index.
Definition: window.cpp:320
WID_RAT_CAPTION
@ WID_RAT_CAPTION
Caption of the window.
Definition: rail_widget.h:16
WDF_CONSTRUCTION
@ WDF_CONSTRUCTION
This window is used for construction; close it whenever changing company.
Definition: window_gui.h:210
WID_BRAD_DEPOT_SE
@ WID_BRAD_DEPOT_SE
Build a depot with the entrance in the south east.
Definition: rail_widget.h:113
Company::avail_railtypes
RailTypes avail_railtypes
Rail types available to this company.
Definition: company_base.h:119
StringFilter::IsEmpty
bool IsEmpty() const
Check whether any filter words were entered.
Definition: stringfilter_type.h:59
_cur_signal_type
static SignalType _cur_signal_type
set the signal type (for signal GUI)
Definition: rail_gui.cpp:55
DDSP_BUILD_STATION
@ DDSP_BUILD_STATION
Station placement.
Definition: viewport_type.h:130
WID_BRAS_SHOW_NEWST_MATRIX
@ WID_BRAS_SHOW_NEWST_MATRIX
Selection for newstation image matrix.
Definition: rail_widget.h:69
Window::ReInit
void ReInit(int rx=0, int ry=0)
Re-initialize a window, and optionally change its size.
Definition: window.cpp:1004
company_base.h
RailtypeInfo::build_depot
SpriteID build_depot
button for building depots
Definition: rail.h:155
ViewportDragDropSelectionProcess
ViewportDragDropSelectionProcess
Drag and drop selection process, or, what to do with an area of land when you've selected it.
Definition: viewport_type.h:115
_cur_year
Year _cur_year
Current year, starting at 0.
Definition: date.cpp:26
TRANSPORT_RAIL
@ TRANSPORT_RAIL
Transport by train.
Definition: transport_type.h:27
tunnelbridge_map.h
StringFilter::SetFilterTerm
void SetFilterTerm(const char *str)
Set the term to filter on.
Definition: stringfilter.cpp:27
WD_MATRIX_TOP
@ WD_MATRIX_TOP
Offset at top of a matrix cell.
Definition: window_gui.h:80
_place_depot_extra_dir
static const DiagDirection _place_depot_extra_dir[12]
Direction to check for existing track pieces.
Definition: rail_gui.cpp:126
GetAxisForNewWaypoint
Axis GetAxisForNewWaypoint(TileIndex tile)
Get the axis for a new waypoint.
Definition: waypoint_cmd.cpp:97
Scrollbar::ScrollTowards
void ScrollTowards(int position)
Scroll towards the given position; if the item is visible nothing happens, otherwise it will be shown...
Definition: widget_type.h:775
WWT_CAPTION
@ WWT_CAPTION
Window caption (window title between closebox and stickybox)
Definition: widget_type.h:59
CBID_STATION_AVAILABILITY
@ CBID_STATION_AVAILABILITY
Determine whether a newstation should be made available to build.
Definition: newgrf_callbacks.h:39
NewGRFClass::GetSpecCount
uint GetSpecCount() const
Get the number of allocated specs within the class.
Definition: newgrf_class.h:44
CheckRedrawStationCoverage
void CheckRedrawStationCoverage(const Window *w)
Check whether we need to redraw the station coverage text.
Definition: station_gui.cpp:126
WID_BRAD_DEPOT_SW
@ WID_BRAD_DEPOT_SW
Build a depot with the entrance in the south west.
Definition: rail_widget.h:114
HandleAutoSignalPlacement
static void HandleAutoSignalPlacement()
Build new signals or remove signals or (if only one tile marked) edit a signal.
Definition: rail_gui.cpp:387
_cur_signal_variant
static SignalVariant _cur_signal_variant
set the signal variant (for signal GUI)
Definition: rail_gui.cpp:54
RailtypeInfo::convert
CursorID convert
Cursor for converting track.
Definition: rail.h:169
NWidgetMatrix
Matrix container with implicitly equal sized (virtual) sub-widgets.
Definition: widget_type.h:532
BuildRailToolbarWindow::OnHotkey
EventState OnHotkey(int hotkey) override
A hotkey has been pressed.
Definition: rail_gui.cpp:613
WWT_IMGBTN
@ WWT_IMGBTN
(Toggle) Button with image
Definition: widget_type.h:50
GUIList< StationClassID, StringFilter & >
INVALID_ROADTYPE
@ INVALID_ROADTYPE
flag for invalid roadtype
Definition: road_type.h:27
BuildSignalWindow::UpdateWidgetSize
void UpdateWidgetSize(int widget, Dimension *size, const Dimension &padding, Dimension *fill, Dimension *resize) override
Update size and resize step of a widget in the window.
Definition: rail_gui.cpp:1746
_railstation
static RailStationGUISettings _railstation
Settings of the station builder GUI.
Definition: rail_gui.cpp:65
TRACK_LOWER
@ TRACK_LOWER
Track in the lower corner of the tile (south)
Definition: track_type.h:24
BuildRailStationWindow::UpdateWidgetSize
void UpdateWidgetSize(int widget, Dimension *size, const Dimension &padding, Dimension *fill, Dimension *resize) override
Update size and resize step of a widget in the window.
Definition: rail_gui.cpp:1200
WID_BS_SEMAPHORE_ENTRY_SEL
@ WID_BS_SEMAPHORE_ENTRY_SEL
NWID_SELECTION for WID_BS_SEMAPHORE_ENTRY.
Definition: rail_widget.h:101
CMD_REMOVE_SIGNALS
@ CMD_REMOVE_SIGNALS
remove a signal
Definition: command_type.h:185
RailtypeInfo::replace_text
StringID replace_text
Text used in the autoreplace GUI.
Definition: rail.h:177
WWT_LABEL
@ WWT_LABEL
Centered label.
Definition: widget_type.h:55
RAIL_TILE_SIGNALS
@ RAIL_TILE_SIGNALS
Normal rail tile with signals.
Definition: rail_map.h:25
DropDownList
std::vector< std::unique_ptr< const DropDownListItem > > DropDownList
A drop down list is a collection of drop down list items.
Definition: dropdown_type.h:99
SetRedErrorSquare
void SetRedErrorSquare(TileIndex tile)
Set a tile to display a red error square.
Definition: viewport.cpp:2454
WWT_DEFSIZEBOX
@ WWT_DEFSIZEBOX
Default window size box (at top-right of a window, between WWT_SHADEBOX and WWT_STICKYBOX)
Definition: widget_type.h:63
BuildSignalWindow::SetStringParameters
void SetStringParameters(int widget) const override
Initialize string parameters for a widget.
Definition: rail_gui.cpp:1759
Window::CreateNestedTree
void CreateNestedTree(bool fill_nested=true)
Perform the first part of the initialization of a nested widget tree.
Definition: window.cpp:1760
WDP_ALIGN_TOOLBAR
@ WDP_ALIGN_TOOLBAR
Align toward the toolbar.
Definition: window_gui.h:158
CMD_REMOVE_RAILROAD_TRACK
@ CMD_REMOVE_RAILROAD_TRACK
remove a rail track
Definition: command_type.h:177
WID_BRAS_PLATFORM_NUM_BEGIN
@ WID_BRAS_PLATFORM_NUM_BEGIN
Helper for determining the chosen platform width.
Definition: rail_widget.h:75
Pool::PoolItem::index
Tindex index
Index of this pool item.
Definition: pool_type.hpp:235
NWID_HORIZONTAL
@ NWID_HORIZONTAL
Horizontal container.
Definition: widget_type.h:73
SIGNAL_GUI_PATH
@ SIGNAL_GUI_PATH
Show path signals only.
Definition: rail_gui.h:24
WID_BS_SEMAPHORE_PBS_OWAY
@ WID_BS_SEMAPHORE_PBS_OWAY
Build a semaphore one way path signal.
Definition: rail_widget.h:88
PlaceRail_Waypoint
static void PlaceRail_Waypoint(TileIndex tile)
Place a rail waypoint.
Definition: rail_gui.cpp:154
TRACK_X
@ TRACK_X
Track along the x-axis (north-east to south-west)
Definition: track_type.h:21
WID_BRAS_HIGHLIGHT_ON
@ WID_BRAS_HIGHLIGHT_ON
Button for turning coverage highlighting on.
Definition: rail_widget.h:58
GUISettings::default_rail_type
uint8 default_rail_type
the default rail type for the rail GUI
Definition: settings_type.h:126
maxdim
Dimension maxdim(const Dimension &d1, const Dimension &d2)
Compute bounding box of both dimensions.
Definition: geometry_func.cpp:22
WWT_MATRIX
@ WWT_MATRIX
Grid of rows and columns.
Definition: widget_type.h:57
ANIMCURSOR_BUILDSIGNALS
static const CursorID ANIMCURSOR_BUILDSIGNALS
1292 - 1293 - build signal
Definition: sprites.h:1502
FindWindowById
Window * FindWindowById(WindowClass cls, WindowNumber number)
Find a window by its class and window number.
Definition: window.cpp:1146
WID_BS_ELECTRIC_NORM
@ WID_BS_ELECTRIC_NORM
Build an electric normal block signal.
Definition: rail_widget.h:89
CMD_BUILD_SINGLE_RAIL
@ CMD_BUILD_SINGLE_RAIL
build a single rail track
Definition: command_type.h:178
NWID_HORIZONTAL_LTR
@ NWID_HORIZONTAL_LTR
Horizontal container that doesn't change the order of the widgets for RTL languages.
Definition: widget_type.h:74
WID_RAT_AUTORAIL
@ WID_RAT_AUTORAIL
Autorail tool.
Definition: rail_widget.h:21
HasBit
static bool HasBit(const T x, const uint8 y)
Checks if a bit in a value is set.
Definition: bitmath_func.hpp:103
RailtypeInfo::rail_swne
CursorID rail_swne
Cursor for building rail in X direction.
Definition: rail.h:163
RailtypeInfo
This struct contains all the info that is needed to draw and construct tracks.
Definition: rail.h:124
PlaceProc_DemolishArea
void PlaceProc_DemolishArea(TileIndex tile)
Start a drag for demolishing an area.
Definition: terraform_gui.cpp:146
BuildRailDepotWindow::OnClick
void OnClick(Point pt, int widget, int click_count) override
A click with the left mouse button has been made on the window.
Definition: rail_gui.cpp:1950
BuildRailStationWindow::StationClassIDSorter
static bool StationClassIDSorter(StationClassID const &a, StationClassID const &b)
Sort station classes by StationClassID.
Definition: rail_gui.cpp:1042
WID_BRAD_DEPOT_NE
@ WID_BRAD_DEPOT_NE
Build a depot with the entrance in the north east.
Definition: rail_widget.h:112
RailStationGUISettings::station_type
byte station_type
Station type within the currently selected custom station class (if newstations is true )
Definition: rail_gui.cpp:62
Scrollbar::SetCount
void SetCount(int num)
Sets the number of elements in the list.
Definition: widget_type.h:710
WID_BRAS_PLATFORM_LEN_1
@ WID_BRAS_PLATFORM_LEN_1
Button to select single tile length station platforms.
Definition: rail_widget.h:47
_ctrl_pressed
bool _ctrl_pressed
Is Ctrl pressed?
Definition: gfx.cpp:36
MP_RAILWAY
@ MP_RAILWAY
A railway.
Definition: tile_type.h:47
SIGNAL_GUI_ALL
@ SIGNAL_GUI_ALL
Show all signals, including block and presignals.
Definition: rail_gui.h:25
FILLRECT_CHECKER
@ FILLRECT_CHECKER
Draw only every second pixel, used for greying-out.
Definition: gfx_type.h:288
SND_15_BEEP
@ SND_15_BEEP
19 == 0x13 GUI button click
Definition: sound_type.h:58
RailtypeInfo::build_tunnel
SpriteID build_tunnel
button for building a tunnel
Definition: rail.h:156
IsStationAvailable
static bool IsStationAvailable(const StationSpec *statspec)
Check whether a station type can be build.
Definition: rail_gui.cpp:78
RailtypeInfo::depot
CursorID depot
Cursor for building a depot.
Definition: rail.h:167
GUISettings::default_signal_type
SignalType default_signal_type
The default signal type, which is set automatically by the last signal used. Not available in Setting...
Definition: settings_type.h:150
SetResize
static NWidgetPart SetResize(int16 dx, int16 dy)
Widget part function for setting the resize step.
Definition: widget_type.h:993
WID_BRAS_SHOW_NEWST_TYPE
@ WID_BRAS_SHOW_NEWST_TYPE
Display of selected station type.
Definition: rail_widget.h:71
SND_20_CONSTRUCTION_RAIL
@ SND_20_CONSTRUCTION_RAIL
30 == 0x1E Construction: rail infrastructure
Definition: sound_type.h:69
zoom_func.h
SIGNAL_CYCLE_ALL
@ SIGNAL_CYCLE_ALL
Cycle through all signals visible.
Definition: rail_gui.h:31
GetTrackBits
static TrackBits GetTrackBits(TileIndex tile)
Gets the track bits of the given tile.
Definition: rail_map.h:136
CommandContainer
Structure for buffering the build command when selecting a station to join.
Definition: command_type.h:479
RailtypeInfo::auto_rail
SpriteID auto_rail
button for the autorail construction
Definition: rail.h:154
WID_BS_ELECTRIC_NORM_SEL
@ WID_BS_ELECTRIC_NORM_SEL
NWID_SELECTION for WID_BS_ELECTRIC_NORM.
Definition: rail_widget.h:100
VPM_FIX_Y
@ VPM_FIX_Y
drag only in Y axis
Definition: viewport_type.h:99
NWidgetMatrix::SetScrollbar
void SetScrollbar(Scrollbar *sb)
Assign a scrollbar to this matrix.
Definition: widget.cpp:1651
_settings_client
ClientSettings _settings_client
The current settings for this game.
Definition: settings.cpp:52
CMD_BUILD_SIGNALS
@ CMD_BUILD_SIGNALS
build a signal
Definition: command_type.h:184
DrawString
int DrawString(int left, int right, int top, const char *str, TextColour colour, StringAlignment align, bool underline, FontSize fontsize)
Draw string, possibly truncated to make it fit in its allocated space.
Definition: gfx.cpp:643
BuildRailToolbarWindow::OnClick
void OnClick(Point pt, int widget, int click_count) override
A click with the left mouse button has been made on the window.
Definition: rail_gui.cpp:521
ShowBuildRailToolbar
Window * ShowBuildRailToolbar(RailType railtype)
Open the build rail toolbar window for a specific rail type.
Definition: rail_gui.cpp:866
WWT_EMPTY
@ WWT_EMPTY
Empty widget, place holder to reserve space in widget array.
Definition: widget_type.h:46
ANIMCURSOR_DEMOLISH
static const CursorID ANIMCURSOR_DEMOLISH
704 - 707 - demolish dynamite
Definition: sprites.h:1498
WWT_PUSHARROWBTN
@ WWT_PUSHARROWBTN
Normal push-button (no toggle button) with arrow caption.
Definition: widget_type.h:106
StringFilter::AddLine
void AddLine(const char *str)
Pass another text line from the current item to the filter.
Definition: stringfilter.cpp:104
BuildRailStationWindow::last_filtering
static Filtering last_filtering
Default filtering of GUIStationClassList.
Definition: rail_gui.cpp:912
DIAGDIR_NW
@ DIAGDIR_NW
Northwest.
Definition: direction_type.h:82
BuildRailToolbarWindow::last_user_action
int last_user_action
Last started user action.
Definition: rail_gui.cpp:428
CMD_REMOVE_FROM_RAIL_WAYPOINT
@ CMD_REMOVE_FROM_RAIL_WAYPOINT
remove a (rectangle of) tiles from a rail waypoint
Definition: command_type.h:195
WC_BUILD_STATION
@ WC_BUILD_STATION
Build station; Window numbers:
Definition: window_type.h:389
ToggleRailButton_Remove
static void ToggleRailButton_Remove(Window *w)
Toggles state of the Remove button of Build rail toolbar.
Definition: rail_gui.cpp:295
WID_RAT_BUILD_STATION
@ WID_RAT_BUILD_STATION
Build a station.
Definition: rail_widget.h:25
WID_BRAS_PLATFORM_LEN_4
@ WID_BRAS_PLATFORM_LEN_4
Button to select 4 tiles length station platforms.
Definition: rail_widget.h:50
BuildSignalWindow::SetSignalUIMode
void SetSignalUIMode()
Show or hide buttons for non-path signals in the signal GUI.
Definition: rail_gui.cpp:1697
ViewportPlaceMethod
ViewportPlaceMethod
Viewport place method (type of highlighted area and placed objects)
Definition: viewport_type.h:96
BuildSignalWindow::OnClick
void OnClick(Point pt, int widget, int click_count) override
A click with the left mouse button has been made on the window.
Definition: rail_gui.cpp:1780
BuildRailStationWindow::Close
void Close() override
Hide the window and all its child windows, and mark them for a later deletion.
Definition: rail_gui.cpp:1035
BuildRailWaypointWindow::UpdateWidgetSize
void UpdateWidgetSize(int widget, Dimension *size, const Dimension &padding, Dimension *fill, Dimension *resize) override
Update size and resize step of a widget in the window.
Definition: rail_gui.cpp:2025
Scrollbar::GetScrolledRowFromWidget
int GetScrolledRowFromWidget(int clickpos, const Window *const w, int widget, int padding=0) const
Compute the row of a scrolled widget that a user clicked in.
Definition: widget.cpp:2098
RailtypeInfo::build_ns_rail
SpriteID build_ns_rail
button for building single rail in N-S direction
Definition: rail.h:150
HT_DIR_Y
@ HT_DIR_Y
Y direction.
Definition: tilehighlight_type.h:34
NWID_MATRIX
@ NWID_MATRIX
Matrix container.
Definition: widget_type.h:76
Scrollbar
Scrollbar data structure.
Definition: widget_type.h:629
_cur_railtype
static RailType _cur_railtype
Rail type of the current build-rail toolbar.
Definition: rail_gui.cpp:48
WD_FRAMETEXT_LEFT
@ WD_FRAMETEXT_LEFT
Left offset of the text of the frame.
Definition: window_gui.h:72
GUISettings::drag_signals_density
byte drag_signals_density
many signals density
Definition: settings_type.h:155
Window::OnHotkey
virtual EventState OnHotkey(int hotkey)
A hotkey has been pressed.
Definition: window.cpp:621
SetDParam
static void SetDParam(uint n, uint64 v)
Set a string parameter v at index n in the global string parameter array.
Definition: strings_func.h:196
NWidgetPart
Partial widget specification to allow NWidgets to be written nested.
Definition: widget_type.h:971
WID_BRAS_PLATFORM_DIR_X
@ WID_BRAS_PLATFORM_DIR_X
Button to select '/' view.
Definition: rail_widget.h:36
TRACK_RIGHT
@ TRACK_RIGHT
Track in the right corner of the tile (east)
Definition: track_type.h:26
CMD_REMOVE_SIGNAL_TRACK
@ CMD_REMOVE_SIGNAL_TRACK
remove signals along a track (by dragging)
Definition: command_type.h:306
SetDataTip
static NWidgetPart SetDataTip(uint32 data, StringID tip)
Widget part function for setting the data and tooltip.
Definition: widget_type.h:1107
CMD_BUILD_RAILROAD_TRACK
@ CMD_BUILD_RAILROAD_TRACK
build a rail track
Definition: command_type.h:176
BuildRailStationWindow::OnHotkey
EventState OnHotkey(int hotkey) override
A hotkey has been pressed.
Definition: rail_gui.cpp:1126
WID_BRAD_DEPOT_NW
@ WID_BRAD_DEPOT_NW
Build a depot with the entrance in the north west.
Definition: rail_widget.h:115
QueryString
Data stored about a string that can be modified in the GUI.
Definition: querystring_gui.h:20
CMD_BUILD_TUNNEL
@ CMD_BUILD_TUNNEL
build a tunnel
Definition: command_type.h:188
TRACK_BIT_UPPER
@ TRACK_BIT_UPPER
Upper track.
Definition: track_type.h:42
WID_BRAS_FILTER_CONTAINER
@ WID_BRAS_FILTER_CONTAINER
Container for the filter text box for the station class list.
Definition: rail_widget.h:65
WD_IMGBTN_BOTTOM
@ WD_IMGBTN_BOTTOM
Bottom offset of image in the button.
Definition: window_gui.h:43
CommandCost::Succeeded
bool Succeeded() const
Did this command succeed?
Definition: command_type.h:150
GetStringBoundingBox
Dimension GetStringBoundingBox(const char *str, FontSize start_fontsize)
Return the string dimension in pixels.
Definition: gfx.cpp:889
GUIList::SetFilterFuncs
void SetFilterFuncs(FilterFunction *const *n_funcs)
Hand the array of filter function pointers to the sort list.
Definition: sortlist_type.h:341
Textbuf::buf
char *const buf
buffer in which text is saved
Definition: textbuf_type.h:32
Window::querystrings
SmallMap< int, QueryString * > querystrings
QueryString associated to WWT_EDITBOX widgets.
Definition: window_gui.h:323
WID_BRAS_SHOW_NEWST_DEFSIZE
@ WID_BRAS_SHOW_NEWST_DEFSIZE
Selection for default-size button for newstation.
Definition: rail_widget.h:67
Window::OnPlaceMouseUp
virtual void OnPlaceMouseUp(ViewportPlaceMethod select_method, ViewportDragDropSelectionProcess select_proc, Point pt, TileIndex start_tile, TileIndex end_tile)
The user has dragged over the map when the tile highlight mode has been set.
Definition: window_gui.h:782
GetTileTrackStatus
TrackStatus GetTileTrackStatus(TileIndex tile, TransportType mode, uint sub_mode, DiagDirection side)
Returns information about trackdirs and signal states.
Definition: landscape.cpp:590
RAILTYPE_ELECTRIC
@ RAILTYPE_ELECTRIC
Electric rails.
Definition: rail_type.h:30
MAX_CHAR_LENGTH
static const int MAX_CHAR_LENGTH
Max. length of UTF-8 encoded unicode character.
Definition: strings_type.h:18
SignalType
SignalType
Type of signal, i.e.
Definition: signal_type.h:23
WID_BS_SEMAPHORE_EXIT_SEL
@ WID_BS_SEMAPHORE_EXIT_SEL
NWID_SELECTION for WID_BS_SEMAPHORE_EXIT.
Definition: rail_widget.h:103
VPM_RAILDIRS
@ VPM_RAILDIRS
all rail directions
Definition: viewport_type.h:106
TRACK_BIT_RIGHT
@ TRACK_BIT_RIGHT
Right track.
Definition: track_type.h:45
IsInsideMM
static bool IsInsideMM(const T x, const size_t min, const size_t max)
Checks if a value is in an interval.
Definition: math_func.hpp:204
BuildRailStationWindow::CheckSelectedSize
void CheckSelectedSize(const StationSpec *statspec)
Verify whether the currently selected station size is allowed after selecting a new station class/typ...
Definition: rail_gui.cpp:942
SpriteID
uint32 SpriteID
The number of a sprite, without mapping bits and colourtables.
Definition: gfx_type.h:17
WID_BS_DRAG_SIGNALS_DENSITY_DECREASE
@ WID_BS_DRAG_SIGNALS_DENSITY_DECREASE
Decrease the signal density.
Definition: rail_widget.h:97
NWidgetMatrix::SetCount
void SetCount(int count)
Set the number of elements in this matrix.
Definition: widget.cpp:1627
WindowDesc
High level window description.
Definition: window_gui.h:168
WID_BRAS_SHOW_NEWST_RESIZE
@ WID_BRAS_SHOW_NEWST_RESIZE
Selection for panel and resize at bottom right for newstation.
Definition: rail_widget.h:70
SIG_ELECTRIC
@ SIG_ELECTRIC
Light signal.
Definition: signal_type.h:17
GetRailTypeInfo
static const RailtypeInfo * GetRailTypeInfo(RailType railtype)
Returns a pointer to the Railtype information for a given railtype.
Definition: rail.h:304
ValParamRailtype
bool ValParamRailtype(const RailType rail)
Validate functions for rail building.
Definition: rail.cpp:206
RailtypeInfo::build_x_rail
SpriteID build_x_rail
button for building single rail in X direction
Definition: rail.h:151
window_gui.h
RailtypeInfo::rail_ns
CursorID rail_ns
Cursor for building rail in N-S direction.
Definition: rail.h:162
GUISettings::cycle_signal_types
SignalCycleSettings cycle_signal_types
Which signal types to cycle with the build signal tool.
Definition: settings_type.h:149
BuildRailStationWindow::EnsureSelectedStationClassIsVisible
void EnsureSelectedStationClassIsVisible()
Scrolls WID_BRAS_NEWST_SCROLL so that the selected station class is visible.
Definition: rail_gui.cpp:926
NC_EQUALSIZE
@ NC_EQUALSIZE
Value of the NCB_EQUALSIZE flag.
Definition: widget_type.h:463
WID_RAT_BUILD_X
@ WID_RAT_BUILD_X
Build rail along the game grid X axis.
Definition: rail_widget.h:18
TRACK_BIT_VERT
@ TRACK_BIT_VERT
Left and right track.
Definition: track_type.h:48
DIAGDIR_SW
@ DIAGDIR_SW
Southwest.
Definition: direction_type.h:81
SIGTYPE_PBS
@ SIGTYPE_PBS
normal pbs signal
Definition: signal_type.h:28
DDSP_PLACE_RAIL
@ DDSP_PLACE_RAIL
Rail placement.
Definition: viewport_type.h:128
AXIS_Y
@ AXIS_Y
The y axis.
Definition: direction_type.h:125
WID_BRAS_PLATFORM_NUM_6
@ WID_BRAS_PLATFORM_NUM_6
Button to select stations with 6 platforms.
Definition: rail_widget.h:44
WDP_AUTO
@ WDP_AUTO
Find a place automatically.
Definition: window_gui.h:156
Listing
Data structure describing how to show the list (what sort direction and criteria).
Definition: sortlist_type.h:30
MapSize
static uint MapSize()
Get the size of the map.
Definition: map_func.h:92
GUIList::SetFilterState
void SetFilterState(bool state)
Enable or disable the filter.
Definition: sortlist_type.h:302
WKC_GLOBAL_HOTKEY
@ WKC_GLOBAL_HOTKEY
Fake keycode bit to indicate global hotkeys.
Definition: gfx_type.h:33
RailtypeInfo::gui_sprites
struct RailtypeInfo::@37 gui_sprites
struct containing the sprites for the rail GUI.
RailType
RailType
Enumeration for all possible railtypes.
Definition: rail_type.h:27
IsBridgeTile
static bool IsBridgeTile(TileIndex t)
checks if there is a bridge on this tile
Definition: bridge_map.h:35
DRAW_STRING_BUFFER
static const int DRAW_STRING_BUFFER
Size of the buffer used for drawing strings.
Definition: gfx_func.h:86
STAT_CLASS_WAYP
@ STAT_CLASS_WAYP
Waypoint class.
Definition: newgrf_station.h:86
Window::resize
ResizeInfo resize
Resize information.
Definition: window_gui.h:317
RailtypeInfo::tunnel
SpriteID tunnel
tunnel sprites base
Definition: rail.h:142
CommandCost
Common return value for all commands.
Definition: command_type.h:23
TRACK_Y
@ TRACK_Y
Track along the y-axis (north-west to south-east)
Definition: track_type.h:22
SIGTYPE_NORMAL
@ SIGTYPE_NORMAL
normal signal
Definition: signal_type.h:24
RailStationGUISettings::newstations
bool newstations
Are custom station definitions available?
Definition: rail_gui.cpp:60
tilehighlight_func.h
BuildRailStationWindow::EDITBOX_MAX_SIZE
static const uint EDITBOX_MAX_SIZE
The maximum number of characters for the filter edit box.
Definition: rail_gui.cpp:909
BuildRailToolbarWindow::Close
void Close() override
Hide the window and all its child windows, and mark them for a later deletion.
Definition: rail_gui.cpp:440
ClientSettings::sound
SoundSettings sound
sound effect settings
Definition: settings_type.h:597
DoCommandP
bool DoCommandP(const CommandContainer *container, bool my_cmd)
Shortcut for the long DoCommandP when having a container with the data.
Definition: command.cpp:541
HT_DIR_VL
@ HT_DIR_VL
vertical left
Definition: tilehighlight_type.h:37
Window::InitNested
void InitNested(WindowNumber number=0)
Perform complete initialization of the Window with nested widgets, to allow use.
Definition: window.cpp:1789
WWT_EDITBOX
@ WWT_EDITBOX
a textbox for typing
Definition: widget_type.h:69
VPM_FIX_X
@ VPM_FIX_X
drag only in X axis
Definition: viewport_type.h:98
WID_BS_ELECTRIC_EXIT_SEL
@ WID_BS_ELECTRIC_EXIT_SEL
NWID_SELECTION for WID_BS_ELECTRIC_EXIT.
Definition: rail_widget.h:104
VpStartPlaceSizing
void VpStartPlaceSizing(TileIndex tile, ViewportPlaceMethod method, ViewportDragDropSelectionProcess process)
highlighting tiles while only going over them with the mouse
Definition: viewport.cpp:2654
GetRailTileType
static RailTileType GetRailTileType(TileIndex t)
Returns the RailTileType (normal with or without signals, waypoint or depot).
Definition: rail_map.h:36
_nested_build_depot_widgets
static const NWidgetPart _nested_build_depot_widgets[]
Nested widget definition of the build rail depot window.
Definition: rail_gui.cpp:1968
WID_RAT_BUILD_WAYPOINT
@ WID_RAT_BUILD_WAYPOINT
Build a waypoint.
Definition: rail_widget.h:24
TrackStatusToTrackBits
static TrackBits TrackStatusToTrackBits(TrackStatus ts)
Returns the present-track-information of a TrackStatus.
Definition: track_func.h:362
GUIList< StationClassID, StringFilter & >::SortFunction
bool SortFunction(const StationClassID &, const StationClassID &)
Signature of sort function.
Definition: sortlist_type.h:48
Window::SetDirty
void SetDirty() const
Mark entire window as dirty (in need of re-paint)
Definition: window.cpp:993
Convert8bitBooleanCallback
bool Convert8bitBooleanCallback(const GRFFile *grffile, uint16 cbid, uint16 cb_res)
Converts a callback result into a boolean.
Definition: newgrf_commons.cpp:569
GUIList::SetListing
void SetListing(Listing l)
Import sort conditions.
Definition: sortlist_type.h:130
WD_FRAMERECT_LEFT
@ WD_FRAMERECT_LEFT
Offset at left to draw the frame rectangular area.
Definition: window_gui.h:62
HT_DIAGONAL
@ HT_DIAGONAL
Also allow 'diagonal rectangles'. Only usable in combination with HT_RECT or HT_POINT.
Definition: tilehighlight_type.h:28
SB
static T SB(T &x, const uint8 s, const uint8 n, const U d)
Set n bits in x starting at bit s to d.
Definition: bitmath_func.hpp:58
BuildRailStationGlobalHotkeys
static EventState BuildRailStationGlobalHotkeys(int hotkey)
Handler for global hotkeys of the BuildRailStationWindow.
Definition: rail_gui.cpp:1527
OrthogonalTileArea::w
uint16 w
The width of the area.
Definition: tilearea_type.h:20
PlaceRail_Bridge
static void PlaceRail_Bridge(TileIndex tile, Window *w)
Start placing a rail bridge.
Definition: rail_gui.cpp:269
WD_PAR_VSEP_NORMAL
@ WD_PAR_VSEP_NORMAL
Normal amount of vertical space between two paragraphs of text.
Definition: window_gui.h:139
CMD_BUILD_RAIL_WAYPOINT
@ CMD_BUILD_RAIL_WAYPOINT
build a waypoint
Definition: command_type.h:193
WD_FRAMERECT_RIGHT
@ WD_FRAMERECT_RIGHT
Offset at right to draw the frame rectangular area.
Definition: window_gui.h:63
ES_NOT_HANDLED
@ ES_NOT_HANDLED
The passed event is not handled.
Definition: window_type.h:719
CommandCost::Failed
bool Failed() const
Did this command fail?
Definition: command_type.h:159
HT_RAIL
@ HT_RAIL
autorail (one piece), lower bits: direction
Definition: tilehighlight_type.h:26
NWidgetBase
Baseclass for nested widgets.
Definition: widget_type.h:126
BuildRailToolbarWindow::SetStringParameters
void SetStringParameters(int widget) const override
Initialize string parameters for a widget.
Definition: rail_gui.cpp:507
TRACK_UPPER
@ TRACK_UPPER
Track in the upper corner of the tile (north)
Definition: track_type.h:23
BRASHK_FOCUS_FILTER_BOX
@ BRASHK_FOCUS_FILTER_BOX
Focus the edit box for editing the filter string.
Definition: rail_gui.cpp:897
BuildRailToolbarWindow::OnPlaceMouseUp
void OnPlaceMouseUp(ViewportPlaceMethod select_method, ViewportDragDropSelectionProcess select_proc, Point pt, TileIndex start_tile, TileIndex end_tile) override
The user has dragged over the map when the tile highlight mode has been set.
Definition: rail_gui.cpp:688
VpSelectTilesWithMethod
void VpSelectTilesWithMethod(int x, int y, ViewportPlaceMethod method)
Selects tiles while dragging.
Definition: viewport.cpp:3139
BuildRailToolbarWindow
Rail toolbar management class.
Definition: rail_gui.cpp:426
OrthogonalTileArea
Represents the covered area of e.g.
Definition: tilearea_type.h:18
SetMatrixDataTip
static NWidgetPart SetMatrixDataTip(uint8 cols, uint8 rows, StringID tip)
Widget part function for setting the data and tooltip of WWT_MATRIX widgets.
Definition: widget_type.h:1125
NewGRFClass
Struct containing information relating to NewGRF classes for stations and airports.
Definition: newgrf_class.h:19
WID_RAT_BUILD_BRIDGE
@ WID_RAT_BUILD_BRIDGE
Build a bridge.
Definition: rail_widget.h:27
dropdown_type.h
WID_BS_SEMAPHORE_COMBO
@ WID_BS_SEMAPHORE_COMBO
Build a semaphore combo block signal.
Definition: rail_widget.h:86
WID_BS_SEMAPHORE_COMBO_SEL
@ WID_BS_SEMAPHORE_COMBO_SEL
NWID_SELECTION for WID_BS_SEMAPHORE_COMBO.
Definition: rail_widget.h:105
_settings_game
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition: settings.cpp:53
WID_BS_ELECTRIC_PBS
@ WID_BS_ELECTRIC_PBS
Build an electric path signal.
Definition: rail_widget.h:93
Filtering
Data structure describing what to show in the list (filter criteria).
Definition: sortlist_type.h:35
RailtypeInfo::autorail
CursorID autorail
Cursor for autorail tool.
Definition: rail.h:166
ShowSignalBuilder
static void ShowSignalBuilder(Window *parent)
Open the signal selection window.
Definition: rail_gui.cpp:1923
Window::SetWidgetDisabledState
void SetWidgetDisabledState(byte widget_index, bool disab_stat)
Sets the enabled/disabled status of a widget.
Definition: window_gui.h:386
Window::parent
Window * parent
Parent window.
Definition: window_gui.h:332
_local_company
CompanyID _local_company
Company controlled by the human player at this client. Can also be COMPANY_SPECTATOR.
Definition: company_cmd.cpp:46
DropDownListStringItem
Common string list item.
Definition: dropdown_type.h:39
HasStationTileRail
static bool HasStationTileRail(TileIndex t)
Has this station tile a rail? In other words, is this station tile a rail station or rail waypoint?
Definition: station_map.h:146
DiagdirReachesTracks
static TrackBits DiagdirReachesTracks(DiagDirection diagdir)
Returns all tracks that can be reached when entering a tile from a given (diagonal) direction.
Definition: track_func.h:572
BuildRailStationWindow::OnEditboxChanged
void OnEditboxChanged(int wid) override
The text in an editbox has been edited.
Definition: rail_gui.cpp:1141
safeguards.h
WID_BRAS_PLATFORM_NUM_7
@ WID_BRAS_PLATFORM_NUM_7
Button to select stations with 7 platforms.
Definition: rail_widget.h:45
sortlist_type.h
WID_BRAS_PLATFORM_LEN_5
@ WID_BRAS_PLATFORM_LEN_5
Button to select 5 tiles length station platforms.
Definition: rail_widget.h:51
StationSpec::name
StringID name
Name of this station.
Definition: newgrf_station.h:127
HandlePlacePushButton
bool HandlePlacePushButton(Window *w, int widget, CursorID cursor, HighLightStyle mode)
This code is shared for the majority of the pushbuttons.
Definition: main_gui.cpp:61
Window::left
int left
x position of left edge of the window
Definition: window_gui.h:312
WC_BUILD_BRIDGE
@ WC_BUILD_BRIDGE
Build bridge; Window numbers:
Definition: window_type.h:381
RailToolbarGlobalHotkeys
static EventState RailToolbarGlobalHotkeys(int hotkey)
Handler for global hotkeys of the BuildRailToolbarWindow.
Definition: rail_gui.cpp:778
TRACK_LEFT
@ TRACK_LEFT
Track in the left corner of the tile (west)
Definition: track_type.h:25
BuildSignalWindow::Close
void Close() override
Hide the window and all its child windows, and mark them for a later deletion.
Definition: rail_gui.cpp:1720
CMD_REMOVE_SINGLE_RAIL
@ CMD_REMOVE_SINGLE_RAIL
remove a single rail track
Definition: command_type.h:179
WID_BS_ELECTRIC_COMBO_SEL
@ WID_BS_ELECTRIC_COMBO_SEL
NWID_SELECTION for WID_BS_ELECTRIC_COMBO.
Definition: rail_widget.h:106
WID_RAT_CONVERT_RAIL
@ WID_RAT_CONVERT_RAIL
Convert other rail to this type.
Definition: rail_widget.h:30
DDSP_BUILD_BRIDGE
@ DDSP_BUILD_BRIDGE
Bridge placement.
Definition: viewport_type.h:125
_nested_build_waypoint_widgets
static const NWidgetPart _nested_build_waypoint_widgets[]
Nested widget definition for the build NewGRF rail waypoint window.
Definition: rail_gui.cpp:2081
TileHighlightData::pos
Point pos
Location, in tile "units", of the northern tile of the selected area.
Definition: tilehighlight_type.h:47
DrawSprite
void DrawSprite(SpriteID img, PaletteID pal, int x, int y, const SubSprite *sub, ZoomLevel zoom)
Draw a sprite, not in a viewport.
Definition: gfx.cpp:1042
MP_TUNNELBRIDGE
@ MP_TUNNELBRIDGE
Tunnel entry/exit and bridge heads.
Definition: tile_type.h:55
WID_BS_DRAG_SIGNALS_DENSITY_LABEL
@ WID_BS_DRAG_SIGNALS_DENSITY_LABEL
The current signal density.
Definition: rail_widget.h:96
WID_RAT_BUILD_TUNNEL
@ WID_RAT_BUILD_TUNNEL
Build a tunnel.
Definition: rail_widget.h:28
waypoint_func.h
Point
Coordinates of a point in 2D.
Definition: geometry_type.hpp:21
BuildRailStationWindow
Definition: rail_gui.cpp:900
DiagDirection
DiagDirection
Enumeration for diagonal directions.
Definition: direction_type.h:77
BuildRailStationWindow::string_filter
StringFilter string_filter
Filter for available station classes.
Definition: rail_gui.cpp:916
CBM_STATION_AVAIL
@ CBM_STATION_AVAIL
Availability of station in construction window.
Definition: newgrf_callbacks.h:303
HT_DIR_MASK
@ HT_DIR_MASK
masks the drag-direction
Definition: tilehighlight_type.h:40
StationSettings::station_spread
byte station_spread
amount a station may spread
Definition: settings_type.h:553
BuildRailStationWindow::BuildStationClassesAvailable
void BuildStationClassesAvailable()
Builds the filter list of available station classes.
Definition: rail_gui.cpp:1059
date_func.h
TRACK_BIT_LOWER
@ TRACK_BIT_LOWER
Lower track.
Definition: track_type.h:43
WD_FRAMETEXT_RIGHT
@ WD_FRAMETEXT_RIGHT
Right offset of the text of the frame.
Definition: window_gui.h:73
StationSpec::disallowed_platforms
byte disallowed_platforms
Bitmask of number of platforms available for the station.
Definition: newgrf_station.h:133
Window::SetFocusedWidget
bool SetFocusedWidget(int widget_index)
Set focus within this window to the given widget.
Definition: window.cpp:506
stdafx.h
PC_BLACK
static const uint8 PC_BLACK
Black palette colour.
Definition: gfx_func.h:192
WID_BRAS_MATRIX_SCROLL
@ WID_BRAS_MATRIX_SCROLL
Scrollbar of the matrix widget.
Definition: rail_widget.h:63
CMD_BUILD_TRAIN_DEPOT
@ CMD_BUILD_TRAIN_DEPOT
build a train depot
Definition: command_type.h:183
BuildRailStationWindow::vscroll
Scrollbar * vscroll
Vertical scrollbar of the new station list.
Definition: rail_gui.cpp:904
GUISettings::link_terraform_toolbar
bool link_terraform_toolbar
display terraform toolbar when displaying rail, road, water and airport toolbars
Definition: settings_type.h:117
GfxFillRect
void GfxFillRect(int left, int top, int right, int bottom, int colour, FillRectMode mode)
Applies a certain FillRectMode-operation to a rectangle [left, right] x [top, bottom] on the screen.
Definition: gfx.cpp:117
RailtypeInfo::toolbar_caption
StringID toolbar_caption
Caption in the construction toolbar GUI for this rail type.
Definition: rail.h:174
CMD_REMOVE_FROM_RAIL_STATION
@ CMD_REMOVE_FROM_RAIL_STATION
remove a (rectangle of) tiles from a rail station
Definition: command_type.h:190
BuildRailStationWindow::vscroll2
Scrollbar * vscroll2
Vertical scrollbar of the matrix with new stations.
Definition: rail_gui.cpp:905
Window::InvalidateData
void InvalidateData(int data=0, bool gui_scope=true)
Mark this window's data as invalid (in need of re-computing)
Definition: window.cpp:3174
NWidgetStacked::SetDisplayedPlane
void SetDisplayedPlane(int plane)
Select which plane to show (for NWID_SELECTION only).
Definition: widget.cpp:1195
viewport_func.h
NWidgetBase::current_y
uint current_y
Current vertical size (after resizing).
Definition: widget_type.h:187
NWidgetStacked
Stacked widgets, widgets all occupying the same space in the window.
Definition: widget_type.h:438
WC_NONE
@ WC_NONE
No window, redirects to WC_MAIN_WINDOW.
Definition: window_type.h:37
IsTileType
static bool IsTileType(TileIndex tile, TileType type)
Checks if a tile is a given tiletype.
Definition: tile_map.h:150
RailStationGUISettings
Definition: rail_gui.cpp:57
GetDigitWidth
byte GetDigitWidth(FontSize size)
Return the maximum width of single digit.
Definition: gfx.cpp:1462
ShowSelectStationIfNeeded
void ShowSelectStationIfNeeded(const CommandContainer &cmd, TileArea ta)
Show the station selection window when needed.
Definition: station_gui.cpp:2464
NWID_VERTICAL
@ NWID_VERTICAL
Vertical container.
Definition: widget_type.h:75
WID_BS_SEMAPHORE_NORM
@ WID_BS_SEMAPHORE_NORM
Build a semaphore normal block signal.
Definition: rail_widget.h:83
FillDrawPixelInfo
bool FillDrawPixelInfo(DrawPixelInfo *n, int left, int top, int width, int height)
Set up a clipping area for only drawing into a certain area.
Definition: gfx.cpp:1770
WC_BUILD_DEPOT
@ WC_BUILD_DEPOT
Build depot; Window numbers:
Definition: window_type.h:409
WID_RAT_BUILD_EW
@ WID_RAT_BUILD_EW
Build rail along the game view X axis.
Definition: rail_widget.h:19
OrthogonalTileArea::h
uint16 h
The height of the area.
Definition: tilearea_type.h:21
GetSpriteSize
Dimension GetSpriteSize(SpriteID sprid, Point *offset, ZoomLevel zoom)
Get the size of a sprite.
Definition: gfx.cpp:977
WWT_CLOSEBOX
@ WWT_CLOSEBOX
Close box (at top-left of a window)
Definition: widget_type.h:67
WWT_RESIZEBOX
@ WWT_RESIZEBOX
Resize box (normally at bottom-right of a window)
Definition: widget_type.h:66
RAILTYPE_RAIL
@ RAILTYPE_RAIL
Standard non-electric rails.
Definition: rail_type.h:29
_signal_builder_desc
static WindowDesc _signal_builder_desc(WDP_AUTO, "build_signal", 0, 0, WC_BUILD_SIGNAL, WC_BUILD_TOOLBAR, WDF_CONSTRUCTION, _nested_signal_builder_widgets, lengthof(_nested_signal_builder_widgets))
Signal selection window description.
GUIList::NeedRebuild
bool NeedRebuild() const
Check if a rebuild is needed.
Definition: sortlist_type.h:362
WID_BS_ELECTRIC_PBS_OWAY
@ WID_BS_ELECTRIC_PBS_OWAY
Build an electric one way path signal.
Definition: rail_widget.h:94
ShowBuildBridgeWindow
void ShowBuildBridgeWindow(TileIndex start, TileIndex end, TransportType transport_type, byte road_rail_type)
Prepare the data for the build a bridge window.
Definition: bridge_gui.cpp:361
TileHighlightData::drawstyle
HighLightStyle drawstyle
Lower bits 0-3 are reserved for detailed highlight information.
Definition: tilehighlight_type.h:64
BuildRailStationWindow::sorter_funcs
static GUIStationClassList::SortFunction *const sorter_funcs[]
Sort functions of the GUIStationClassList.
Definition: rail_gui.cpp:913
DrawStationCoverageAreaText
int DrawStationCoverageAreaText(int left, int right, int top, StationCoverageType sct, int rad, bool supplies)
Calculates and draws the accepted or supplied cargo around the selected tile(s)
Definition: station_gui.cpp:54
BuildRailWaypointWindow::DrawWidget
void DrawWidget(const Rect &r, int widget) const override
Draw the contents of a nested widget.
Definition: rail_gui.cpp:2044
string_func.h
spritecache.h
SCT_ALL
@ SCT_ALL
Draw all cargoes.
Definition: station_gui.h:22
CALLBACK_FAILED
static const uint CALLBACK_FAILED
Different values for Callback result evaluations.
Definition: newgrf_callbacks.h:404
TRACK_BIT_HORZ
@ TRACK_BIT_HORZ
Upper and lower track.
Definition: track_type.h:47
rail_gui.h
StringID
uint32 StringID
Numeric value that represents a string, independent of the selected language.
Definition: strings_type.h:16
SoundSettings::confirm
bool confirm
Play sound effect on successful constructions or other actions.
Definition: settings_type.h:210
WID_BRW_WAYPOINT_MATRIX
@ WID_BRW_WAYPOINT_MATRIX
Matrix with waypoints.
Definition: rail_widget.h:120
RailStationGUISettings::station_class
StationClassID station_class
Currently selected custom station class (if newstations is true )
Definition: rail_gui.cpp:61
TileHighlightData::selstart
Point selstart
The location where the dragging started.
Definition: tilehighlight_type.h:60
WID_RAT_REMOVE
@ WID_RAT_REMOVE
Bulldozer to remove rail.
Definition: rail_widget.h:29
vehicle_func.h
WC_GAME_OPTIONS
@ WC_GAME_OPTIONS
Game options window; Window numbers:
Definition: window_type.h:604
GenericPlaceSignals
static void GenericPlaceSignals(TileIndex tile)
Build a new signal or edit/remove a present signal, use CmdBuildSingleSignal() or CmdRemoveSingleSign...
Definition: rail_gui.cpp:212
_convert_signal_button
static bool _convert_signal_button
convert signal button in the signal GUI pressed
Definition: rail_gui.cpp:53
EndContainer
static NWidgetPart EndContainer()
Widget part function for denoting the end of a container (horizontal, vertical, WWT_FRAME,...
Definition: widget_type.h:1092
WC_SELECT_STATION
@ WC_SELECT_STATION
Select station (when joining stations); Window numbers:
Definition: window_type.h:234
SignalVariant
SignalVariant
Variant of the signal, i.e.
Definition: signal_type.h:16
BuildRailStationWindow::DrawWidget
void DrawWidget(const Rect &r, int widget) const override
Draw the contents of a nested widget.
Definition: rail_gui.cpp:1255
GetRailTypes
RailTypes GetRailTypes(bool introduces)
Get list of rail types, regardless of company availability.
Definition: rail.cpp:282
WID_BRAS_COVERAGE_TEXTS
@ WID_BRAS_COVERAGE_TEXTS
Empty space for the coverage texts.
Definition: rail_widget.h:59
strings_func.h
_cur_waypoint_type
static byte _cur_waypoint_type
Currently selected waypoint type.
Definition: rail_gui.cpp:52
NWID_VSCROLLBAR
@ NWID_VSCROLLBAR
Vertical scrollbar.
Definition: widget_type.h:82
BuildSignalWindow::OnInit
void OnInit() override
Notification that the nested widget tree gets initialized.
Definition: rail_gui.cpp:1726
StationSpec
Station specification.
Definition: newgrf_station.h:113
PlaceExtraDepotRail
static void PlaceExtraDepotRail(TileIndex tile, DiagDirection dir, Track track)
Try to add an additional rail-track at the entrance of a depot.
Definition: rail_gui.cpp:109
terraform_gui.h
Window::IsShaded
bool IsShaded() const
Is window shaded currently?
Definition: window_gui.h:520
TRACK_BIT_LEFT
@ TRACK_BIT_LEFT
Left track.
Definition: track_type.h:44
NWidgetBase::pos_x
int pos_x
Horizontal position of top-left corner of the widget in the window.
Definition: widget_type.h:189
WC_BUILD_WAYPOINT
@ WC_BUILD_WAYPOINT
Build waypoint; Window numbers:
Definition: window_type.h:415
WID_BRAS_PLATFORM_LEN_3
@ WID_BRAS_PLATFORM_LEN_3
Button to select 3 tiles length station platforms.
Definition: rail_widget.h:49
WIDGET_LIST_END
static const int WIDGET_LIST_END
indicate the end of widgets' list for vararg functions
Definition: widget_type.h:20
VPM_Y_LIMITED
@ VPM_Y_LIMITED
Drag only in Y axis with limited size.
Definition: viewport_type.h:105
_build_depot_direction
static DiagDirection _build_depot_direction
Currently selected depot direction.
Definition: rail_gui.cpp:50
WWT_TEXT
@ WWT_TEXT
Pure simple text.
Definition: widget_type.h:56
BuildSignalWindow::DrawSignalSprite
void DrawSignalSprite(byte widget_index, SpriteID image) const
Draw dynamic a signal-sprite in a button in the signal GUI Draw the sprite +1px to the right and down...
Definition: rail_gui.cpp:1681
BuildRailStationWindow::filter_funcs
static GUIStationClassList::FilterFunction *const filter_funcs[]
Filter functions of the GUIStationClassList.
Definition: rail_gui.cpp:914
FONT_HEIGHT_NORMAL
#define FONT_HEIGHT_NORMAL
Height of characters in the normal (FS_NORMAL) font.
Definition: gfx_func.h:167
WC_SCEN_LAND_GEN
@ WC_SCEN_LAND_GEN
Landscape generation (in Scenario Editor); Window numbers:
Definition: window_type.h:441
HT_LINE
@ HT_LINE
used for autorail highlighting (longer stretches), lower bits: direction
Definition: tilehighlight_type.h:25
WID_BRW_SCROLL
@ WID_BRW_SCROLL
Scrollbar for the matrix.
Definition: rail_widget.h:122
ScaleGUITrad
static int ScaleGUITrad(int value)
Scale traditional pixel dimensions to GUI zoom level.
Definition: zoom_func.h:76
NWidget
static NWidgetPart NWidget(WidgetType tp, Colours col, int16 idx=-1)
Widget part function for starting a new 'real' widget.
Definition: widget_type.h:1207
COMPANY_SPECTATOR
@ COMPANY_SPECTATOR
The client is spectating.
Definition: company_type.h:35
RAILTYPE_END
@ RAILTYPE_END
Used for iterations.
Definition: rail_type.h:33
WID_BRW_WAYPOINT
@ WID_BRW_WAYPOINT
A single waypoint.
Definition: rail_widget.h:121
Scrollbar::IsVisible
bool IsVisible(uint16 item) const
Checks whether given current item is visible in the list.
Definition: widget_type.h:681
geometry_func.hpp
GUIList< StationClassID, StringFilter & >::FilterFunction
bool CDECL FilterFunction(const StationClassID *, StringFilter &)
Signature of filter function.
Definition: sortlist_type.h:49
OrthogonalTileArea::tile
TileIndex tile
The base tile of the area.
Definition: tilearea_type.h:19
GUISettings::semaphore_build_before
Year semaphore_build_before
build semaphore signals automatically before this year
Definition: settings_type.h:157
WID_BRAS_FILTER_EDITBOX
@ WID_BRAS_FILTER_EDITBOX
Filter text box for the station class list.
Definition: rail_widget.h:66
CloseWindowByClass
void CloseWindowByClass(WindowClass cls)
Close all windows of a given class.
Definition: window.cpp:1188
SetMinimalSize
static NWidgetPart SetMinimalSize(int16 x, int16 y)
Widget part function for setting the minimal size.
Definition: widget_type.h:1010
WID_BRAS_NEWST_LIST
@ WID_BRAS_NEWST_LIST
List with available newstation classes.
Definition: rail_widget.h:72
_build_tunnel_endtile
TileIndex _build_tunnel_endtile
The end of a tunnel; as hidden return from the tunnel build command for GUI purposes.
Definition: tunnelbridge_cmd.cpp:50
InitializeRailGui
void InitializeRailGui()
Initialize rail building GUI settings.
Definition: rail_gui.cpp:2113
StringFilter::ResetState
void ResetState()
Reset the matching state to process a new item.
Definition: stringfilter.cpp:88
WWT_PANEL
@ WWT_PANEL
Simple depressed panel.
Definition: widget_type.h:48
MarkTileDirtyByTile
void MarkTileDirtyByTile(TileIndex tile, int bridge_level_offset, int tile_height_override)
Mark a tile given by its index dirty for repaint.
Definition: viewport.cpp:1987
WID_BS_SEMAPHORE_PBS
@ WID_BS_SEMAPHORE_PBS
Build a semaphore path signal.
Definition: rail_widget.h:87
BuildRailDepotWindow
Definition: rail_gui.cpp:1928
GetCompanyRailtypes
RailTypes GetCompanyRailtypes(CompanyID company, bool introduces)
Get the rail types the given company can build.
Definition: rail.cpp:251
BuildRailStationWindow::line_height
uint line_height
Height of a single line in the newstation selection matrix (WID_BRAS_NEWST_LIST widget).
Definition: rail_gui.cpp:902
GetRailType
static RailType GetRailType(TileIndex t)
Gets the rail type of the given tile.
Definition: rail_map.h:115
Window::IsWidgetLowered
bool IsWidgetLowered(byte widget_index) const
Gets the lowered state of a widget.
Definition: window_gui.h:487
PlaceRail_Station
static void PlaceRail_Station(TileIndex tile)
Place a rail station.
Definition: rail_gui.cpp:186
StationClassID
StationClassID
Definition: newgrf_station.h:83
EventState
EventState
State of handling an event.
Definition: window_type.h:717
HT_RECT
@ HT_RECT
rectangle (stations, depots, ...)
Definition: tilehighlight_type.h:21
VPM_FIX_HORIZONTAL
@ VPM_FIX_HORIZONTAL
drag only in horizontal direction
Definition: viewport_type.h:102
VPM_X_AND_Y
@ VPM_X_AND_Y
area of land in X and Y directions
Definition: viewport_type.h:100
WID_BRAS_HIGHLIGHT_OFF
@ WID_BRAS_HIGHLIGHT_OFF
Button for turning coverage highlighting off.
Definition: rail_widget.h:57
GUIList::SetFiltering
void SetFiltering(Filtering f)
Import filter conditions.
Definition: sortlist_type.h:181
StringFilter::GetState
bool GetState() const
Get the matching state of the current item.
Definition: stringfilter_type.h:69
WD_IMGBTN_TOP
@ WD_IMGBTN_TOP
Top offset of image in the button.
Definition: window_gui.h:42
WID_BRAS_PLATFORM_NUM_5
@ WID_BRAS_PLATFORM_NUM_5
Button to select stations with 5 platforms.
Definition: rail_widget.h:43
WID_BRAS_PLATFORM_NUM_2
@ WID_BRAS_PLATFORM_NUM_2
Button to select stations with 2 platforms.
Definition: rail_widget.h:40
NewGRFClass::name
StringID name
Name of this class.
Definition: newgrf_class.h:39
BuildRailToolbarWindow::OnCTRLStateChange
EventState OnCTRLStateChange() override
The state of the control key has changed.
Definition: rail_gui.cpp:763
GUIList::Filter
bool Filter(FilterFunction *decide, F filter_data)
Filter the list.
Definition: sortlist_type.h:318
BuildRailWaypointWindow::OnClick
void OnClick(Point pt, int widget, int click_count) override
A click with the left mouse button has been made on the window.
Definition: rail_gui.cpp:2059
Window::FinishInitNested
void FinishInitNested(WindowNumber window_number=0)
Perform the second part of the initialization of a nested widget tree.
Definition: window.cpp:1776
DC_AUTO
@ DC_AUTO
don't allow building on structures
Definition: command_type.h:349
NWID_SPACER
@ NWID_SPACER
Invisible widget that takes some space.
Definition: widget_type.h:77
CcBuildRailTunnel
void CcBuildRailTunnel(const CommandCost &result, TileIndex tile, uint32 p1, uint32 p2, uint32 cmd)
Command callback for building a tunnel.
Definition: rail_gui.cpp:281
HT_DRAG_MASK
@ HT_DRAG_MASK
Mask for the tile drag-type modes.
Definition: tilehighlight_type.h:29
company_func.h
PickerWindowBase
Base class for windows opened from a toolbar.
Definition: window_gui.h:917
FindFirstTrack
static Track FindFirstTrack(TrackBits tracks)
Returns first Track from TrackBits or INVALID_TRACK.
Definition: track_func.h:176
WID_BRAS_IMAGE
@ WID_BRAS_IMAGE
Panel used at each cell of the matrix.
Definition: rail_widget.h:62
SetViewportCatchmentStation
void SetViewportCatchmentStation(const Station *st, bool sel)
Select or deselect station for coverage area highlight.
Definition: viewport.cpp:3524
IsLevelCrossingTile
static bool IsLevelCrossingTile(TileIndex t)
Return whether a tile is a level crossing tile.
Definition: road_map.h:94
ShowStationBuilder
static Window * ShowStationBuilder(Window *parent)
Open station build window.
Definition: rail_gui.cpp:1663
Window::top
int top
y position of top edge of the window
Definition: window_gui.h:313
BuildRailStationWindow::OnResize
void OnResize() override
Called after the window got resized.
Definition: rail_gui.cpp:1328
WID_BS_CONVERT
@ WID_BS_CONVERT
Convert the signal.
Definition: rail_widget.h:95
TileArea
OrthogonalTileArea TileArea
Shorthand for the much more common orthogonal tile area.
Definition: tilearea_type.h:102
rail_widget.h
RailtypeInfo::build_ew_rail
SpriteID build_ew_rail
button for building single rail in E-W direction
Definition: rail.h:152
TrackBits
TrackBits
Bitfield corresponding to Track.
Definition: track_type.h:38
BuildRailWaypointWindow
Definition: rail_gui.cpp:2010
DDSP_BUILD_SIGNALS
@ DDSP_BUILD_SIGNALS
Signal placement.
Definition: viewport_type.h:129
WD_MATRIX_BOTTOM
@ WD_MATRIX_BOTTOM
Offset at bottom of a matrix cell.
Definition: window_gui.h:81
BuildSignalWindow::sig_sprite_bottom_offset
int sig_sprite_bottom_offset
Maximum extent of signal GUI sprite from reference point towards bottom.
Definition: rail_gui.cpp:1672
station_map.h
BuildRailToolbarWindow::OnPlacePresize
void OnPlacePresize(Point pt, TileIndex tile) override
The user moves over the map when a tile highlight mode has been set when the special mouse mode has b...
Definition: rail_gui.cpp:757
window_func.h
BuildRailStationWindow::station_classes
GUIStationClassList station_classes
Available station classes.
Definition: rail_gui.cpp:915
GUIList::ForceRebuild
void ForceRebuild()
Force that a rebuild is needed.
Definition: sortlist_type.h:370
Window::ToggleWidgetLoweredState
void ToggleWidgetLoweredState(byte widget_index)
Invert the lowered/raised status of a widget.
Definition: window_gui.h:457
SoundSettings::click_beep
bool click_beep
Beep on a random selection of buttons.
Definition: settings_type.h:211
BuildSignalWindow::OnInvalidateData
void OnInvalidateData(int data=0, bool gui_scope=true) override
Some data on this window has become invalid.
Definition: rail_gui.cpp:1846
CMD_CONVERT_RAIL
@ CMD_CONVERT_RAIL
convert a rail type
Definition: command_type.h:191
lengthof
#define lengthof(x)
Return the length of an fixed size array.
Definition: stdafx.h:378
VPM_X_LIMITED
@ VPM_X_LIMITED
Drag only in X axis with limited size.
Definition: viewport_type.h:104
_place_depot_extra_track
static const Track _place_depot_extra_track[12]
Additional pieces of track to add at the entrance of a depot.
Definition: rail_gui.cpp:119
StationSpec::grf_prop
GRFFilePropsBase< NUM_CARGO+3 > grf_prop
Properties related the the grf file.
Definition: newgrf_station.h:125
stringfilter_type.h
NewGRFClass::Get
static NewGRFClass * Get(Tid cls_id)
Get a particular class.
Definition: newgrf_class_func.h:103
ShowTerraformToolbar
Window * ShowTerraformToolbar(Window *link)
Show the toolbar for terraforming in the game.
Definition: terraform_gui.cpp:357
Scrollbar::SetCapacityFromWidget
void SetCapacityFromWidget(Window *w, int widget, int padding=0)
Set capacity of visible elements from the size and resize properties of a widget.
Definition: widget.cpp:2172
MarkWholeScreenDirty
void MarkWholeScreenDirty()
This function mark the whole screen as dirty.
Definition: gfx.cpp:1751
WID_BS_ELECTRIC_EXIT
@ WID_BS_ELECTRIC_EXIT
Build an electric exit block signal.
Definition: rail_widget.h:91
CA_TRAIN
@ CA_TRAIN
Catchment for train stations with "modified catchment" enabled.
Definition: station_type.h:79
WID_BRAS_PLATFORM_NUM_4
@ WID_BRAS_PLATFORM_NUM_4
Button to select stations with 4 platforms.
Definition: rail_widget.h:42
GUISettings::auto_remove_signals
bool auto_remove_signals
automatically remove signals when in the way during rail construction
Definition: settings_type.h:172
SetPIP
static NWidgetPart SetPIP(uint8 pre, uint8 inter, uint8 post)
Widget part function for setting a pre/inter/post spaces.
Definition: widget_type.h:1169
CloseWindowById
void CloseWindowById(WindowClass cls, WindowNumber number, bool force)
Close a window by its class and window number (if it is open).
Definition: window.cpp:1176
NWidgetBase::pos_y
int pos_y
Vertical position of top-left corner of the widget in the window.
Definition: widget_type.h:190
INVALID_TILE
static const TileIndex INVALID_TILE
The very nice invalid tile marker.
Definition: tile_type.h:88
GUISettings::station_platlength
byte station_platlength
the platform length, in tiles, for rail stations
Definition: settings_type.h:161
WID_BS_DRAG_SIGNALS_DENSITY_INCREASE
@ WID_BS_DRAG_SIGNALS_DENSITY_INCREASE
Increase the signal density.
Definition: rail_widget.h:98
_nested_signal_builder_widgets
static const NWidgetPart _nested_signal_builder_widgets[]
Nested widget definition of the build signal window.
Definition: rail_gui.cpp:1859
Axis
Axis
Allow incrementing of DiagDirDiff variables.
Definition: direction_type.h:123
engine_base.h
WID_BS_ELECTRIC_COMBO
@ WID_BS_ELECTRIC_COMBO
Build an electric combo block signal.
Definition: rail_widget.h:92
SetFill
static NWidgetPart SetFill(uint fill_x, uint fill_y)
Widget part function for setting filling.
Definition: widget_type.h:1076
InitializeRailGUI
void InitializeRailGUI()
Resets the rail GUI - sets default railtype to build and resets the signal GUI.
Definition: rail_gui.cpp:2205
BuildRailStationWindow::last_sorting
static Listing last_sorting
Default sorting of GUIStationClassList.
Definition: rail_gui.cpp:911
GetOtherTunnelBridgeEnd
static TileIndex GetOtherTunnelBridgeEnd(TileIndex t)
Determines type of the wormhole and returns its other end.
Definition: tunnelbridge_map.h:78
ResetSignalVariant
void ResetSignalVariant(int32 new_value)
Updates the current signal variant used in the signal GUI to the one adequate to current year.
Definition: rail_gui.cpp:2187
gui.h
WID_RAT_BUILD_NS
@ WID_RAT_BUILD_NS
Build rail along the game view Y axis.
Definition: rail_widget.h:17
BuildRailToolbarWindow::OnPlaceObjectAbort
void OnPlaceObjectAbort() override
The user cancelled a tile highlight mode that has been set.
Definition: rail_gui.cpp:741
BuildRailStationWindow::OnPaint
void OnPaint() override
The window must be repainted.
Definition: rail_gui.cpp:1149
BuildRailToolbarWindow::ModifyRailType
void ModifyRailType(RailType railtype)
Switch to another rail type.
Definition: rail_gui.cpp:471
WID_RAT_BUILD_DEPOT
@ WID_RAT_BUILD_DEPOT
Build a depot.
Definition: rail_widget.h:23
WC_BUILD_SIGNAL
@ WC_BUILD_SIGNAL
Build signal toolbar; Window numbers:
Definition: window_type.h:90
WID_BS_SEMAPHORE_ENTRY
@ WID_BS_SEMAPHORE_ENTRY
Build a semaphore entry block signal.
Definition: rail_widget.h:84
BuildSignalWindow::DrawWidget
void DrawWidget(const Rect &r, int widget) const override
Draw the contents of a nested widget.
Definition: rail_gui.cpp:1768
Window
Data structure for an opened window.
Definition: window_gui.h:279
BuildRailStationWindow::OnRealtimeTick
void OnRealtimeTick(uint delta_ms) override
Called periodically.
Definition: rail_gui.cpp:1514
GUIList::RebuildDone
void RebuildDone()
Notify the sortlist that the rebuild is done.
Definition: sortlist_type.h:380
StationSpec::callback_mask
byte callback_mask
Bitmask of station callbacks that have to be called.
Definition: newgrf_station.h:158
ShowSelectWaypointIfNeeded
void ShowSelectWaypointIfNeeded(const CommandContainer &cmd, TileArea ta)
Show the waypoint selection window when needed.
Definition: station_gui.cpp:2474
BuildRailToolbarWindow::OnPlaceObject
void OnPlaceObject(Point pt, TileIndex tile) override
The user clicked some place on the map when a tile highlight mode has been set.
Definition: rail_gui.cpp:619
Pool::PoolItem<&_company_pool >::IsValidID
static bool IsValidID(size_t index)
Tests whether given index can be used to get valid (non-nullptr) Titem.
Definition: pool_type.hpp:326
RailtypeInfo::rail_ew
CursorID rail_ew
Cursor for building rail in E-W direction.
Definition: rail.h:164
WID_BRAS_PLATFORM_NUM_3
@ WID_BRAS_PLATFORM_NUM_3
Button to select stations with 3 platforms.
Definition: rail_widget.h:41
Window::RaiseWidget
void RaiseWidget(byte widget_index)
Marks a widget as raised.
Definition: window_gui.h:477
WD_MATRIX_LEFT
@ WD_MATRIX_LEFT
Offset at left of a matrix cell.
Definition: window_gui.h:78
StationSpec::disallowed_lengths
byte disallowed_lengths
Bitmask of platform lengths available for the station.
Definition: newgrf_station.h:138
RailtypeInfo::strings
struct RailtypeInfo::@39 strings
Strings associated with the rail type.
Window::DrawWidgets
void DrawWidgets() const
Paint all widgets of a window.
Definition: widget.cpp:636
RAIL_TILE_DEPOT
@ RAIL_TILE_DEPOT
Depot (one entrance)
Definition: rail_map.h:26
GRFFilePropsBase::grffile
const struct GRFFile * grffile
grf file that introduced this entity
Definition: newgrf_commons.h:320
CommandContainer::tile
TileIndex tile
tile command being executed on.
Definition: command_type.h:480
BuildRailToolbarWindow::SetupRailToolbar
void SetupRailToolbar(RailType railtype)
Configures the rail toolbar for railtype given.
Definition: rail_gui.cpp:451
WID_BRAS_MATRIX
@ WID_BRAS_MATRIX
Matrix widget displaying the available stations.
Definition: rail_widget.h:61
Swap
static void Swap(T &a, T &b)
Type safe swap operation.
Definition: math_func.hpp:215
WD_IMGBTN_LEFT
@ WD_IMGBTN_LEFT
Left offset of the image in the button.
Definition: window_gui.h:40
Track
Track
These are used to specify a single track.
Definition: track_type.h:19
BuildRailStationWindow::GUIStationClassList
GUIList< StationClassID, StringFilter & > GUIStationClassList
Type definition for the list to hold available station classes.
Definition: rail_gui.cpp:907
VPM_X_AND_Y_LIMITED
@ VPM_X_AND_Y_LIMITED
area of land of limited size
Definition: viewport_type.h:101
NWID_SELECTION
@ NWID_SELECTION
Stacked widgets, only one visible at a time (eg in a panel with tabs).
Definition: widget_type.h:78
WID_BRAS_PLATFORM_DIR_Y
@ WID_BRAS_PLATFORM_DIR_Y
Button to select '\' view.
Definition: rail_widget.h:37
Window::IsWidgetDisabled
bool IsWidgetDisabled(byte widget_index) const
Gets the enabled/disabled status of a widget.
Definition: window_gui.h:415
RailtypeInfo::build_y_rail
SpriteID build_y_rail
button for building single rail in Y direction
Definition: rail.h:153
RailtypeInfo::signals
SpriteID signals[SIGTYPE_END][2][2]
signal GUI sprites (type, variant, state)
Definition: rail.h:158
Window::SetWidgetDirty
void SetWidgetDirty(byte widget_index) const
Invalidate a widget, i.e.
Definition: window.cpp:608
BuildRailStationWindow::SetStringParameters
void SetStringParameters(int widget) const override
Initialize string parameters for a widget.
Definition: rail_gui.cpp:1335
WID_BS_CAPTION
@ WID_BS_CAPTION
Caption for the Signal Selection window.
Definition: rail_widget.h:81
GetTunnelBridgeTransportType
static TransportType GetTunnelBridgeTransportType(TileIndex t)
Tunnel: Get the transport type of the tunnel (road or rail) Bridge: Get the transport type of the bri...
Definition: tunnelbridge_map.h:39
DIAGDIR_NE
@ DIAGDIR_NE
Northeast, upper right on your monitor.
Definition: direction_type.h:79
BuildRailClick_Remove
static void BuildRailClick_Remove(Window *w)
The "remove"-button click proc of the build-rail toolbar.
Definition: rail_gui.cpp:330
Rect
Specification of a rectangle with absolute coordinates of all edges.
Definition: geometry_type.hpp:47
Window::LowerWidget
void LowerWidget(byte widget_index)
Marks a widget as lowered.
Definition: window_gui.h:468
Company
Definition: company_base.h:115
RailTypes
RailTypes
The different railtypes we support, but then a bitmask of them.
Definition: rail_type.h:46
WID_BS_ELECTRIC_ENTRY
@ WID_BS_ELECTRIC_ENTRY
Build an electric entry block signal.
Definition: rail_widget.h:90
GUISettings::signal_gui_mode
SignalGUISettings signal_gui_mode
select which signal types are shown in the signal GUI
Definition: settings_type.h:148
RailStationGUISettings::station_count
byte station_count
Number of custom stations (if newstations is true )
Definition: rail_gui.cpp:63
AWV_INCREASE
@ AWV_INCREASE
Arrow to the right or in case of RTL to the left.
Definition: widget_type.h:36
DrawStationTile
bool DrawStationTile(int x, int y, RailType railtype, Axis axis, StationClassID sclass, uint station)
Draw representation of a station tile for GUI purposes.
Definition: newgrf_station.cpp:780
STAT_CLASS_DFLT
@ STAT_CLASS_DFLT
Default station class.
Definition: newgrf_station.h:85
DDSP_REMOVE_STATION
@ DDSP_REMOVE_STATION
Station removal.
Definition: viewport_type.h:131
VPM_X_OR_Y
@ VPM_X_OR_Y
drag in X or Y direction
Definition: viewport_type.h:97
Window::DisableWidget
void DisableWidget(byte widget_index)
Sets a widget to disabled.
Definition: window_gui.h:396
NWidgetBase::current_x
uint current_x
Current horizontal size (after resizing).
Definition: widget_type.h:186
lastof
#define lastof(x)
Get the last element of an fixed size array.
Definition: stdafx.h:394
BuildRailStationWindow::SelectOtherClass
void SelectOtherClass(StationClassID station_class)
Select the specified station class.
Definition: rail_gui.cpp:1114
BuildRailStationWindow::OnClick
void OnClick(Point pt, int widget, int click_count) override
A click with the left mouse button has been made on the window.
Definition: rail_gui.cpp:1343
WID_BS_ELECTRIC_ENTRY_SEL
@ WID_BS_ELECTRIC_ENTRY_SEL
NWID_SELECTION for WID_BS_ELECTRIC_ENTRY.
Definition: rail_widget.h:102
_waypoint_count
static byte _waypoint_count
Number of waypoint types.
Definition: rail_gui.cpp:51
WID_BRAS_NEWST_SCROLL
@ WID_BRAS_NEWST_SCROLL
Scrollbar of the WID_BRAS_NEWST_LIST.
Definition: rail_widget.h:73
ResetObjectToPlace
void ResetObjectToPlace()
Reset the cursor and mouse mode handling back to default (normal cursor, only clicking in windows).
Definition: viewport.cpp:3423
HT_SPECIAL
@ HT_SPECIAL
special mode used for highlighting while dragging (and for tunnels/docks)
Definition: tilehighlight_type.h:23
DrawWaypointSprite
void DrawWaypointSprite(int x, int y, int stat_id, RailType railtype)
Draw a waypoint.
Definition: waypoint.cpp:27
WD_IMGBTN_RIGHT
@ WD_IMGBTN_RIGHT
Right offset of the image in the button.
Definition: window_gui.h:41
Window::SetWidgetLoweredState
void SetWidgetLoweredState(byte widget_index, bool lowered_stat)
Sets the lowered/raised status of a widget.
Definition: window_gui.h:447
station_gui.h
CMD_BUILD_RAIL_STATION
@ CMD_BUILD_RAIL_STATION
build a rail station
Definition: command_type.h:182
BuildRailStationWindow::TagNameFilter
static bool CDECL TagNameFilter(StationClassID const *sc, StringFilter &filter)
Filter station classes by class name.
Definition: rail_gui.cpp:1048
SIG_SEMAPHORE
@ SIG_SEMAPHORE
Old-fashioned semaphore signal.
Definition: signal_type.h:18
WID_BRAS_PLATFORM_LEN_BEGIN
@ WID_BRAS_PLATFORM_LEN_BEGIN
Helper for determining the chosen platform length.
Definition: rail_widget.h:76
CMD_BUILD_SIGNAL_TRACK
@ CMD_BUILD_SIGNAL_TRACK
add signals along a track (by dragging)
Definition: command_type.h:305
VPM_SIGNALDIRS
@ VPM_SIGNALDIRS
similar to VMP_RAILDIRS, but with different cursor
Definition: viewport_type.h:107
BuildRailStationWindow::filter_editbox
QueryString filter_editbox
Filter editbox.
Definition: rail_gui.cpp:917
WID_BRAS_PLATFORM_LEN_2
@ WID_BRAS_PLATFORM_LEN_2
Button to select 2 tiles length station platforms.
Definition: rail_widget.h:48
WID_BS_SEMAPHORE_NORM_SEL
@ WID_BS_SEMAPHORE_NORM_SEL
NWID_SELECTION for WID_BS_SEMAPHORE_NORM.
Definition: rail_widget.h:99
WID_BRAS_PLATFORM_NUM_1
@ WID_BRAS_PLATFORM_NUM_1
Button to select stations with a single platform.
Definition: rail_widget.h:39
StringFilter
String filter and state.
Definition: stringfilter_type.h:31
WID_BRAS_SHOW_NEWST_ADDITIONS
@ WID_BRAS_SHOW_NEWST_ADDITIONS
Selection for newstation class selection list.
Definition: rail_widget.h:68
DropDownListIconItem
List item with icon and string.
Definition: dropdown_type.h:82
BuildRailStationWindow::OnInvalidateData
void OnInvalidateData(int data=0, bool gui_scope=true) override
Some data on this window has become invalid.
Definition: rail_gui.cpp:1119
RailStationGUISettings::orientation
Axis orientation
Currently selected rail station orientation.
Definition: rail_gui.cpp:58
WWT_TEXTBTN
@ WWT_TEXTBTN
(Toggle) Button with text
Definition: widget_type.h:53
BuildRailToolbarWindow::railtype
RailType railtype
Rail type to build.
Definition: rail_gui.cpp:427
ClientSettings::gui
GUISettings gui
settings related to the GUI
Definition: settings_type.h:594
TileHighlightData::selend
Point selend
The location where the drag currently ends.
Definition: tilehighlight_type.h:61
HT_DIR_X
@ HT_DIR_X
X direction.
Definition: tilehighlight_type.h:33
AWV_DECREASE
@ AWV_DECREASE
Arrow to the left or in case of RTL to the right.
Definition: widget_type.h:35
BuildRailDepotWindow::UpdateWidgetSize
void UpdateWidgetSize(int widget, Dimension *size, const Dimension &padding, Dimension *fill, Dimension *resize) override
Update size and resize step of a widget in the window.
Definition: rail_gui.cpp:1935
WID_BRAS_PLATFORM_LEN_7
@ WID_BRAS_PLATFORM_LEN_7
Button to select 7 tiles length station platforms.
Definition: rail_widget.h:53
GUIList::SetSortFuncs
void SetSortFuncs(SortFunction *const *n_funcs)
Hand the array of sort function pointers to the sort list.
Definition: sortlist_type.h:270
DrawPixelInfo
Data about how and where to blit pixels.
Definition: gfx_type.h:155
GUISettings::persistent_buildingtools
bool persistent_buildingtools
keep the building tools active after usage
Definition: settings_type.h:164
_station_builder_desc
static WindowDesc _station_builder_desc(WDP_AUTO, "build_station_rail", 350, 0, WC_BUILD_STATION, WC_BUILD_TOOLBAR, WDF_CONSTRUCTION, _nested_station_builder_widgets, lengthof(_nested_station_builder_widgets), &BuildRailStationWindow::hotkeys)
High level window description of the station-build window (default & newGRF)
StationSettings::modified_catchment
bool modified_catchment
different-size catchment areas
Definition: settings_type.h:548
TileVirtXY
static TileIndex TileVirtXY(uint x, uint y)
Get a tile from the virtual XY-coordinate.
Definition: map_func.h:194
Hotkey
All data for a single hotkey.
Definition: hotkeys.h:22
RailtypeInfo::convert_rail
SpriteID convert_rail
button for converting rail
Definition: rail.h:157
hotkeys.h
ReinitGuiAfterToggleElrail
void ReinitGuiAfterToggleElrail(bool disable)
Re-initialize rail-build toolbar after toggling support for electric trains.
Definition: rail_gui.cpp:2123
INVALID_RAILTYPE
@ INVALID_RAILTYPE
Flag for invalid railtype.
Definition: rail_type.h:34
WWT_SHADEBOX
@ WWT_SHADEBOX
Shade box (at top-right of a window, between WWT_DEBUGBOX and WWT_DEFSIZEBOX)
Definition: widget_type.h:62
WN_GAME_OPTIONS_GAME_SETTINGS
@ WN_GAME_OPTIONS_GAME_SETTINGS
Game settings.
Definition: window_type.h:19
Window::Close
virtual void Close()
Hide the window and all its child windows, and mark them for a later deletion.
Definition: window.cpp:1092
RAILTYPE_BEGIN
@ RAILTYPE_BEGIN
Used for iterations.
Definition: rail_type.h:28
NWidgetMatrix::SetClicked
void SetClicked(int clicked)
Sets the clicked widget in the matrix.
Definition: widget.cpp:1610
AXIS_X
@ AXIS_X
The X axis.
Definition: direction_type.h:124
SetDefaultRailGui
static void SetDefaultRailGui()
Set the initial (default) railtype to use.
Definition: rail_gui.cpp:2135
GUIPlaceProcDragXY
bool GUIPlaceProcDragXY(ViewportDragDropSelectionProcess proc, TileIndex start_tile, TileIndex end_tile)
A central place to handle all X_AND_Y dragged GUI functions.
Definition: terraform_gui.cpp:107