OpenTTD Source 20261112-master-gbcbec5e63f
station_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 <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
6 */
7
9
10#include "stdafx.h"
11#include "debug.h"
12#include "gui.h"
13#include "querystring_gui.h"
14#include "textbuf_gui.h"
15#include "company_func.h"
16#include "command_func.h"
17#include "tilearea_spiral.h"
18#include "vehicle_gui.h"
19#include "cargotype.h"
20#include "station_func.h"
21#include "station_gui.h"
22#include "strings_func.h"
23#include "string_func.h"
24#include "window_func.h"
25#include "viewport_func.h"
26#include "dropdown_type.h"
27#include "dropdown_func.h"
28#include "station_base.h"
29#include "waypoint_base.h"
30#include "tilehighlight_func.h"
31#include "company_base.h"
32#include "sortlist_type.h"
34#include "vehiclelist.h"
35#include "sound_func.h"
36#include "town.h"
37#include "linkgraph/linkgraph.h"
38#include "zoom_func.h"
39#include "station_cmd.h"
40
42#include "widgets/misc_widget.h"
43
44#include "table/strings.h"
45
47
48#include "safeguards.h"
49
51{
52 using StationType = Station;
53
54 static bool IsValidID(StationID id) { return Station::IsValidID(id); }
55 static bool IsValidBaseStation(const BaseStation *st) { return Station::IsExpected(st); }
56 static bool IsAcceptableWaypointTile(TileIndex) { return false; }
57 static constexpr bool IsWaypoint() { return false; }
58};
59
60template <bool ROAD, TileType TILE_TYPE>
62{
63 using StationType = Waypoint;
64
65 static bool IsValidID(StationID id) { return Waypoint::IsValidID(id) && HasBit(Waypoint::Get(id)->waypoint_flags, WPF_ROAD) == ROAD; }
66 static bool IsValidBaseStation(const BaseStation *st) { return Waypoint::IsExpected(st) && HasBit(Waypoint::From(st)->waypoint_flags, WPF_ROAD) == ROAD; }
67 static bool IsAcceptableWaypointTile(TileIndex tile) { return IsTileType(tile, TILE_TYPE); }
68 static constexpr bool IsWaypoint() { return true; }
69};
70using RailWaypointTypeFilter = GenericWaypointTypeFilter<false, TileType::Railway>;
71using RoadWaypointTypeFilter = GenericWaypointTypeFilter<true, TileType::Road>;
72
81int DrawStationCoverageAreaText(const Rect &r, StationCoverageType sct, int rad, bool supplies)
82{
83 TileIndex tile = TileVirtXY(_thd.pos.x, _thd.pos.y);
84 CargoTypes cargo_mask{};
85 if (_thd.drawstyle == HT_RECT && tile < Map::Size()) {
86 CargoArray cargoes;
87 if (supplies) {
88 cargoes = GetProductionAroundTiles(tile, _thd.size.x / TILE_SIZE, _thd.size.y / TILE_SIZE, rad);
89 } else {
90 cargoes = GetAcceptanceAroundTiles(tile, _thd.size.x / TILE_SIZE, _thd.size.y / TILE_SIZE, rad).first;
91 }
92
93 /* Convert cargo counts to a set of cargo bits, and draw the result. */
94 for (CargoType cargo : EnumRange(NUM_CARGO)) {
95 switch (sct) {
96 case SCT_PASSENGERS_ONLY: if (!IsCargoInClass(cargo, CargoClass::Passengers)) continue; break;
97 case SCT_NON_PASSENGERS_ONLY: if (IsCargoInClass(cargo, CargoClass::Passengers)) continue; break;
98 case SCT_ALL: break;
99 default: NOT_REACHED();
100 }
101 if (cargoes[cargo] >= (supplies ? 1U : 8U)) cargo_mask.Set(cargo);
102 }
103 }
104 return DrawStringMultiLine(r, GetString(supplies ? STR_STATION_BUILD_SUPPLIES_CARGO : STR_STATION_BUILD_ACCEPTS_CARGO, cargo_mask));
105}
106
111template <typename T>
113{
114 /* With distant join we don't know which station will be selected, so don't show any */
115 if (IsCtrlPressed()) {
116 SetViewportCatchmentSpecializedStation<typename T::StationType>(nullptr, true);
117 return;
118 }
119
120 /* Tile area for TileHighlightData */
121 TileArea location(TileVirtXY(_thd.pos.x, _thd.pos.y), _thd.size.x / TILE_SIZE - 1, _thd.size.y / TILE_SIZE - 1);
122
123 /* If the current tile is already a station, then it must be the nearest station. */
124 if (IsTileType(location.tile, TileType::Station) && GetTileOwner(location.tile) == _local_company) {
125 typename T::StationType *st = T::StationType::GetByTile(location.tile);
126 if (st != nullptr && T::IsValidBaseStation(st)) {
127 SetViewportCatchmentSpecializedStation<typename T::StationType>(st, true);
128 return;
129 }
130 }
131
132 /* Extended area by one tile */
133 uint x = TileX(location.tile);
134 uint y = TileY(location.tile);
135
136 /* Waypoints can only be built on existing rail/road tiles, so don't extend area if not highlighting a rail tile. */
137 int max_c = T::IsWaypoint() && !T::IsAcceptableWaypointTile(location.tile) ? 0 : 1;
138 TileArea ta(TileXY(std::max<int>(0, x - max_c), std::max<int>(0, y - max_c)), TileXY(std::min<int>(Map::MaxX(), x + location.w + max_c), std::min<int>(Map::MaxY(), y + location.h + max_c)));
139
140 typename T::StationType *adjacent = nullptr;
141
142 /* Direct loop instead of ForAllStationsAroundTiles as we are not interested in catchment area */
143 for (TileIndex tile : ta) {
145 typename T::StationType *st = T::StationType::GetByTile(tile);
146 if (st == nullptr || !T::IsValidBaseStation(st)) continue;
147 if (adjacent != nullptr && st != adjacent) {
148 /* Multiple nearby, distant join is required. */
149 adjacent = nullptr;
150 break;
151 }
152 adjacent = st;
153 }
154 }
155 SetViewportCatchmentSpecializedStation<typename T::StationType>(adjacent, true);
156}
157
164{
165 /* Test if ctrl state changed */
166 static bool _last_ctrl_pressed;
167 if (IsCtrlPressed() != _last_ctrl_pressed) {
168 _thd.dirty = 0xff;
169 _last_ctrl_pressed = IsCtrlPressed();
170 }
171
172 if (_thd.dirty & 1) {
173 _thd.dirty &= ~1;
174 w->SetDirty();
175
176 if (_settings_client.gui.station_show_coverage && _thd.drawstyle == HT_RECT) {
178 }
179 }
180}
181
182template <typename T>
183void CheckRedrawWaypointCoverage()
184{
185 /* Test if ctrl state changed */
186 static bool _last_ctrl_pressed;
187 if (IsCtrlPressed() != _last_ctrl_pressed) {
188 _thd.dirty = 0xff;
189 _last_ctrl_pressed = IsCtrlPressed();
190 }
191
192 if (_thd.dirty & 1) {
193 _thd.dirty &= ~1;
194
195 if (_thd.drawstyle == HT_RECT) {
197 }
198 }
199}
200
201void CheckRedrawRailWaypointCoverage(const Window *)
202{
203 CheckRedrawWaypointCoverage<RailWaypointTypeFilter>();
204}
205
206void CheckRedrawRoadWaypointCoverage(const Window *)
207{
208 CheckRedrawWaypointCoverage<RoadWaypointTypeFilter>();
209}
210
223static void StationsWndShowStationRating(int left, int right, int y, CargoType cargo, uint amount, uint8_t rating)
224{
225 static const uint units_full = 576;
226 static const uint rating_full = 224;
227
228 const CargoSpec *cs = CargoSpec::Get(cargo);
229 if (!cs->IsValid()) return;
230
231 int padding = ScaleGUITrad(1);
232 int width = right - left;
233 PixelColour colour = cs->rating_colour;
234 TextColour tc = GetContrastColour(colour);
235 uint w = std::min(amount + 5, units_full) * width / units_full;
236
237 int height = GetCharacterHeight(FontSize::Small) + padding - 1;
238
239 if (amount > 30) {
240 /* Draw total cargo (limited) on station */
241 GfxFillRect(left, y, left + w - 1, y + height, colour);
242 } else {
243 /* Draw a (scaled) one pixel-wide bar of additional cargo meter, useful
244 * for stations with only a small amount (<=30) */
245 uint rest = ScaleGUITrad(amount) / 5;
246 if (rest != 0) {
247 GfxFillRect(left, y + height - rest, left + padding - 1, y + height, colour);
248 }
249 }
250
251 DrawString(left + padding, right, y, cs->abbrev, tc, {AlignmentH::Centre, AlignmentV::Middle}, false, FontSize::Small);
252
253 /* Draw green/red ratings bar (fits under the waiting bar) */
254 y += height + padding + 1;
255 GfxFillRect(left + padding, y, right - padding - 1, y + padding - 1, PC_RED);
256 w = std::min<uint>(rating, rating_full) * (width - padding - padding) / rating_full;
257 if (w != 0) GfxFillRect(left + padding, y, left + w - 1, y + padding - 1, PC_GREEN);
258}
259
261
265class CompanyStationsWindow : public Window {
266protected:
274
275 static inline FilterState initial_state = {
276 {false, 0},
278 true,
279 ALL_CARGOTYPES,
280 };
281
283 static inline const StringID sorter_names[] = {
284 STR_SORT_BY_NAME,
285 STR_SORT_BY_FACILITY,
286 STR_SORT_BY_WAITING_TOTAL,
287 STR_SORT_BY_WAITING_AVAILABLE,
288 STR_SORT_BY_RATING_MAX,
289 STR_SORT_BY_RATING_MIN,
290 };
291 static const std::initializer_list<GUIStationList::SortFunction * const> sorter_funcs;
292
295
296 FilterState filter{};
297 GUIStationList stations{filter.cargoes};
298 Scrollbar *vscroll = nullptr;
299 uint rating_width = 0;
300 bool filter_expanded = false;
301 std::array<uint16_t, NUM_CARGO> stations_per_cargo_type{};
303
309 void BuildStationsList(const Owner owner)
310 {
311 if (!this->stations.NeedRebuild()) return;
312
313 Debug(Facility::Misc, Severity::Notice, "Building station list for company {}", owner);
314
315 this->stations.clear();
316 this->stations_per_cargo_type.fill(0);
317 this->stations_per_cargo_type_no_rating = 0;
318
319 for (const Station *st : Station::Iterate()) {
320 if (this->filter.facilities.Any(st->facilities)) { // only stations with selected facilities
321 if (st->owner == owner || (st->owner == OWNER_NONE && HasStationInUse(st->index, true, owner))) {
322 this->string_filter.ResetState();
323 this->string_filter.AddLine(st->GetCachedName());
324 if (!this->string_filter.GetState()) continue;
325
326 bool has_rating = false;
327 /* Add to the station/cargo counts. */
328 for (CargoType cargo : EnumRange(NUM_CARGO)) {
329 if (st->goods[cargo].HasRating()) this->stations_per_cargo_type[cargo]++;
330 }
331 for (CargoType cargo : EnumRange(NUM_CARGO)) {
332 if (st->goods[cargo].HasRating()) {
333 has_rating = true;
334 if (this->filter.cargoes.Test(cargo)) {
335 this->stations.push_back(st);
336 break;
337 }
338 }
339 }
340 /* Stations with no cargo rating. */
341 if (!has_rating) {
342 if (this->filter.include_no_rating) this->stations.push_back(st);
343 this->stations_per_cargo_type_no_rating++;
344 }
345 }
346 }
347 }
348
349 this->stations.RebuildDone();
350
351 this->vscroll->SetCount(this->stations.size()); // Update the scrollbar
352 }
353
355 static bool StationNameSorter(const Station * const &a, const Station * const &b, [[maybe_unused]] const CargoTypes &filter)
356 {
357 int r = StrNaturalCompare(a->GetCachedName(), b->GetCachedName()); // Sort by name (natural sorting).
358 if (r == 0) return a->index < b->index;
359 return r < 0;
360 }
361
363 static bool StationTypeSorter(const Station * const &a, const Station * const &b, [[maybe_unused]] const CargoTypes &filter)
364 {
365 return a->facilities < b->facilities;
366 }
367
369 static bool StationWaitingTotalSorter(const Station * const &a, const Station * const &b, const CargoTypes &filter)
370 {
371 int diff = 0;
372
373 for (CargoType cargo : filter) {
374 diff += a->goods[cargo].TotalCount() - b->goods[cargo].TotalCount();
375 }
376
377 return diff < 0;
378 }
379
381 static bool StationWaitingAvailableSorter(const Station * const &a, const Station * const &b, const CargoTypes &filter)
382 {
383 int diff = 0;
384
385 for (CargoType cargo : filter) {
386 diff += a->goods[cargo].AvailableCount() - b->goods[cargo].AvailableCount();
387 }
388
389 return diff < 0;
390 }
391
393 static bool StationRatingMaxSorter(const Station * const &a, const Station * const &b, const CargoTypes &filter)
394 {
395 uint8_t maxr1 = 0;
396 uint8_t maxr2 = 0;
397
398 for (CargoType cargo : filter) {
399 if (a->goods[cargo].HasRating()) maxr1 = std::max(maxr1, a->goods[cargo].rating);
400 if (b->goods[cargo].HasRating()) maxr2 = std::max(maxr2, b->goods[cargo].rating);
401 }
402
403 return maxr1 < maxr2;
404 }
405
407 static bool StationRatingMinSorter(const Station * const &a, const Station * const &b, const CargoTypes &filter)
408 {
409 uint8_t minr1 = 255;
410 uint8_t minr2 = 255;
411
412 for (CargoType cargo : filter) {
413 if (a->goods[cargo].HasRating()) minr1 = std::min(minr1, a->goods[cargo].rating);
414 if (b->goods[cargo].HasRating()) minr2 = std::min(minr2, b->goods[cargo].rating);
415 }
416
417 return minr1 > minr2;
418 }
419
422 {
423 if (!this->stations.Sort()) return;
424
425 /* Set the modified widget dirty */
427 }
428
429public:
431 {
432 /* Load initial filter state. */
433 this->filter = CompanyStationsWindow::initial_state;
434 if (this->filter.cargoes == ALL_CARGOTYPES) this->filter.cargoes = _cargo_mask;
435
436 this->stations.SetListing(this->filter.last_sorting);
437 this->stations.SetSortFuncs(CompanyStationsWindow::sorter_funcs);
438 this->stations.ForceRebuild();
439 this->stations.NeedResort();
440 this->SortStationsList();
441
442 this->CreateNestedTree();
443 this->vscroll = this->GetScrollbar(WID_STL_SCROLLBAR);
444 this->FinishInitNested(window_number);
445 this->owner = this->window_number;
446
447 this->querystrings[WID_STL_FILTER] = &this->name_editbox;
448 this->name_editbox.cancel_button = QueryString::ACTION_CLEAR;
449
450 if (this->filter.cargoes == ALL_CARGOTYPES) this->filter.cargoes = _cargo_mask;
451
452 for (StationFacility facil : this->filter.facilities) {
453 this->LowerWidget(WID_STL_TRAIN + to_underlying(facil));
454 }
455
456 this->GetWidget<NWidgetCore>(WID_STL_SORTDROPBTN)->SetString(CompanyStationsWindow::sorter_names[this->stations.SortType()]);
457 }
458
461 {
462 /* Save filter state. */
463 this->filter.last_sorting = this->stations.GetListing();
464 CompanyStationsWindow::initial_state = this->filter;
465 }
466
467 void UpdateWidgetSize(WidgetID widget, Dimension &size, [[maybe_unused]] const Dimension &padding, [[maybe_unused]] Dimension &fill, [[maybe_unused]] Dimension &resize) override
468 {
469 switch (widget) {
470 case WID_STL_SORTBY: {
472 d.width += padding.width + Window::SortButtonWidth() * 2; // Doubled since the string is centred and it also looks better.
473 d.height += padding.height;
474 size = maxdim(size, d);
475 break;
476 }
477
478 case WID_STL_SORTDROPBTN: {
480 d.width += padding.width;
481 d.height += padding.height;
482 size = maxdim(size, d);
483 break;
484 }
485
486 case WID_STL_LIST:
488 size.height = padding.height + 5 * resize.height;
489
490 /* Determine appropriate width for mini station rating graph */
491 this->rating_width = 0;
492 for (const CargoSpec *cs : _sorted_standard_cargo_specs) {
493 this->rating_width = std::max(this->rating_width, GetStringBoundingBox(cs->abbrev, FontSize::Small).width);
494 }
495 /* Approximately match original 16 pixel wide rating bars by multiplying string width by 1.6 */
496 this->rating_width = this->rating_width * 16 / 10;
497 break;
498 }
499 }
500
501 void OnPaint() override
502 {
503 this->BuildStationsList(this->window_number);
504 this->SortStationsList();
505
506 this->DrawWidgets();
507 }
508
509 void DrawWidget(const Rect &r, WidgetID widget) const override
510 {
511 switch (widget) {
512 case WID_STL_SORTBY:
513 /* draw arrow pointing up/down for ascending/descending sorting */
514 this->DrawSortButton(WID_STL_SORTBY, this->stations.IsDescSortOrder());
515 break;
516
517 case WID_STL_LIST: {
518 bool rtl = _current_text_dir == TD_RTL;
519 Rect tr = r.Shrink(WidgetDimensions::scaled.framerect);
520 uint line_height = this->GetWidget<NWidgetBase>(widget)->resize_y;
521 /* Spacing between station name and first rating graph. */
522 int text_spacing = WidgetDimensions::scaled.hsep_wide;
523 /* Spacing between additional rating graphs. */
524 int rating_spacing = WidgetDimensions::scaled.hsep_normal;
525
526 auto [first, last] = this->vscroll->GetVisibleRangeIterators(this->stations);
527 for (auto it = first; it != last; ++it) {
528 const Station *st = *it;
529 assert(st->xy != INVALID_TILE);
530
531 /* Do not do the complex check HasStationInUse here, it may be even false
532 * when the order had been removed and the station list hasn't been removed yet */
533 assert(st->owner == owner || st->owner == OWNER_NONE);
534
535 int x = DrawString(tr.left, tr.right, tr.top + (line_height - GetCharacterHeight(FontSize::Normal)) / 2, GetString(STR_STATION_LIST_STATION, st->index, st->facilities));
536 x += rtl ? -text_spacing : text_spacing;
537
538 /* show cargo waiting and station ratings */
539 for (const CargoSpec *cs : _sorted_standard_cargo_specs) {
540 CargoType cargo_type = cs->Index();
541 if (st->goods[cargo_type].HasRating()) {
542 /* For RTL we work in exactly the opposite direction. So
543 * decrement the space needed first, then draw to the left
544 * instead of drawing to the left and then incrementing
545 * the space. */
546 if (rtl) {
547 x -= rating_width + rating_spacing;
548 if (x < tr.left) break;
549 }
550 StationsWndShowStationRating(x, x + rating_width, tr.top, cargo_type, st->goods[cargo_type].TotalCount(), st->goods[cargo_type].rating);
551 if (!rtl) {
552 x += rating_width + rating_spacing;
553 if (x > tr.right) break;
554 }
555 }
556 }
557 tr.top += line_height;
558 }
559
560 if (this->vscroll->GetCount() == 0) { // company has no stations
561 DrawString(tr.left, tr.right, tr.top + (line_height - GetCharacterHeight(FontSize::Normal)) / 2, STR_STATION_LIST_NONE);
562 return;
563 }
564 break;
565 }
566 }
567 }
568
569 std::string GetWidgetString(WidgetID widget, StringID stringid) const override
570 {
571 if (widget == WID_STL_CAPTION) {
572 return GetString(STR_STATION_LIST_CAPTION, this->window_number, this->vscroll->GetCount());
573 }
574
575 if (widget == WID_STL_CARGODROPDOWN) {
576 if (this->filter.cargoes.None()) return GetString(this->filter.include_no_rating ? STR_STATION_LIST_CARGO_FILTER_ONLY_NO_RATING : STR_STATION_LIST_CARGO_FILTER_NO_CARGO_TYPES);
577 if (this->filter.cargoes == _cargo_mask) return GetString(this->filter.include_no_rating ? STR_STATION_LIST_CARGO_FILTER_ALL_AND_NO_RATING : STR_CARGO_TYPE_FILTER_ALL);
578 if (this->filter.cargoes.Count() == 1 && !this->filter.include_no_rating) return GetString(CargoSpec::Get(*this->filter.cargoes.begin())->name);
579 return GetString(STR_STATION_LIST_CARGO_FILTER_MULTIPLE);
580 }
581
582 return this->Window::GetWidgetString(widget, stringid);
583 }
584
585 DropDownList BuildCargoDropDownList(bool expanded) const
586 {
587 /* Define a custom item consisting of check mark, count string, icon and name string. */
589
590 DropDownList list;
591 list.push_back(MakeDropDownListStringItem(STR_STATION_LIST_CARGO_FILTER_SELECT_ALL, CargoFilterCriteria::CF_SELECT_ALL));
592 list.push_back(MakeDropDownListDividerItem());
593
594 bool any_hidden = false;
595
596 uint16_t count = this->stations_per_cargo_type_no_rating;
597 if (count == 0 && !expanded) {
598 any_hidden = true;
599 } else {
600 list.push_back(std::make_unique<DropDownString<DropDownListCheckedItem, FontSize::Small, true>>(fmt::format("{}", count), 0, this->filter.include_no_rating, GetString(STR_STATION_LIST_CARGO_FILTER_NO_RATING), CargoFilterCriteria::CF_NO_RATING, false, count == 0));
601 }
602
603 Dimension d = GetLargestCargoIconSize();
604 for (const CargoSpec *cs : _sorted_cargo_specs) {
605 count = this->stations_per_cargo_type[cs->Index()];
606 if (count == 0 && !expanded) {
607 any_hidden = true;
608 } else {
609 list.push_back(std::make_unique<DropDownListCargoItem>(this->filter.cargoes.Test(cs->Index()), fmt::format("{}", count), d, cs->GetCargoIcon(), PAL_NONE, GetString(cs->name), cs->Index(), false, count == 0));
610 }
611 }
612
613 if (!expanded && any_hidden) {
614 if (list.size() > 2) list.push_back(MakeDropDownListDividerItem());
615 list.push_back(MakeDropDownListStringItem(STR_STATION_LIST_CARGO_FILTER_EXPAND, CargoFilterCriteria::CF_EXPAND_LIST));
616 }
617
618 return list;
619 }
620
621 void OnClick([[maybe_unused]] Point pt, WidgetID widget, [[maybe_unused]] int click_count) override
622 {
623 switch (widget) {
624 case WID_STL_LIST: {
625 auto it = this->vscroll->GetScrolledItemFromWidget(this->stations, pt.y, this, WID_STL_LIST, WidgetDimensions::scaled.framerect.top);
626 if (it == this->stations.end()) return; // click out of list bound
627
628 const Station *st = *it;
629 /* do not check HasStationInUse - it is slow and may be invalid */
630 assert(st->owner == this->window_number || st->owner == OWNER_NONE);
631
632 if (IsCtrlPressed()) {
634 } else {
636 }
637 break;
638 }
639
640 case WID_STL_TRAIN:
641 case WID_STL_TRUCK:
642 case WID_STL_BUS:
643 case WID_STL_AIRPLANE:
644 case WID_STL_SHIP:
645 if (IsCtrlPressed()) {
646 this->filter.facilities.Flip(static_cast<StationFacility>(widget - WID_STL_TRAIN));
647 this->ToggleWidgetLoweredState(widget);
648 } else {
649 for (StationFacility facil : this->filter.facilities) {
651 }
652 this->filter.facilities = static_cast<StationFacility>(widget - WID_STL_TRAIN);
653 this->LowerWidget(widget);
654 }
655 this->stations.ForceRebuild();
656 this->SetDirty();
657 SndClickBeep();
658 break;
659
660 case WID_STL_FACILALL:
661 for (WidgetID i = WID_STL_TRAIN; i <= WID_STL_SHIP; i++) {
662 this->LowerWidget(i);
663 }
664
666 this->stations.ForceRebuild();
667 this->SetDirty();
668 break;
669
670 case WID_STL_SORTBY: // flip sorting method asc/desc
671 this->stations.ToggleSortOrder();
672 this->SetDirty();
673 break;
674
675 case WID_STL_SORTDROPBTN: // select sorting criteria dropdown menu
677 break;
678
680 static std::string cargo_filter;
681 this->filter_expanded = false;
682 ShowDropDownList(this, this->BuildCargoDropDownList(this->filter_expanded), -1, widget, 0, {DropDownOption::Persist, DropDownOption::Filterable}, &cargo_filter);
683 break;
684 }
685 }
686 }
687
688 void OnDropdownSelect(WidgetID widget, int index, int) override
689 {
690 if (widget == WID_STL_SORTDROPBTN) {
691 if (this->stations.SortType() != index) {
692 this->stations.SetSortType(index);
693
694 /* Display the current sort variant */
696
697 this->SetDirty();
698 }
699 }
700
701 if (widget == WID_STL_CARGODROPDOWN) {
702 FilterState oldstate = this->filter;
703
704 if (index >= 0 && index < NUM_CARGO) {
705 if (IsCtrlPressed()) {
706 this->filter.cargoes.Flip(static_cast<CargoType>(index));
707 } else {
708 this->filter.cargoes = static_cast<CargoType>(index);
709 this->filter.include_no_rating = false;
710 }
711 } else if (index == CargoFilterCriteria::CF_NO_RATING) {
712 if (IsCtrlPressed()) {
713 this->filter.include_no_rating = !this->filter.include_no_rating;
714 } else {
715 this->filter.include_no_rating = true;
716 this->filter.cargoes.Reset();
717 }
718 } else if (index == CargoFilterCriteria::CF_SELECT_ALL) {
719 this->filter.cargoes = _cargo_mask;
720 this->filter.include_no_rating = true;
721 } else if (index == CargoFilterCriteria::CF_EXPAND_LIST) {
722 this->filter_expanded = true;
723 ReplaceDropDownList(this, this->BuildCargoDropDownList(this->filter_expanded));
724 return;
725 }
726
727 if (oldstate.cargoes != this->filter.cargoes || oldstate.include_no_rating != this->filter.include_no_rating) {
728 this->stations.ForceRebuild();
729 this->SetDirty();
730
731 /* Only refresh the list if it's changed. */
732 if (IsCtrlPressed()) ReplaceDropDownList(this, this->BuildCargoDropDownList(this->filter_expanded));
733 }
734
735 /* Always close the list if ctrl is not pressed. */
736 if (!IsCtrlPressed()) this->CloseChildWindows(WindowClass::DropdownMenu);
737 }
738 }
739
740 void OnGameTick() override
741 {
742 if (this->stations.NeedResort()) {
743 Debug(Facility::Misc, Severity::Notice, "Periodic rebuild station list company {}", static_cast<int>(this->window_number));
744 this->SetDirty();
745 }
746 }
747
748 void OnResize() override
749 {
750 this->vscroll->SetCapacityFromWidget(this, WID_STL_LIST, WidgetDimensions::scaled.framerect.Vertical());
751 }
752
753 void OnEditboxChanged(WidgetID wid) override
754 {
755 if (wid == WID_STL_FILTER) {
756 this->string_filter.SetFilterTerm(this->name_editbox.text.GetText());
757 this->InvalidateData(TDIWD_FORCE_REBUILD);
758 }
759 }
760
766 void OnInvalidateData([[maybe_unused]] int data = 0, [[maybe_unused]] bool gui_scope = true) override
767 {
768 if (data == 0) {
769 /* This needs to be done in command-scope to enforce rebuilding before resorting invalid data */
770 this->stations.ForceRebuild();
771 } else {
772 this->stations.ForceResort();
773 }
774 }
775};
776
777/* Available station sorting functions */
778const std::initializer_list<GUIStationList::SortFunction * const> CompanyStationsWindow::sorter_funcs = {
785};
786
787static constexpr std::initializer_list<NWidgetPart> _nested_company_stations_widgets = {
794 EndContainer(),
796 NWidget(WWT_TEXTBTN, Colours::Grey, WID_STL_TRAIN), SetAspect(WidgetDimensions::ASPECT_VEHICLE_ICON), SetStringTip(STR_TRAIN, STR_STATION_LIST_USE_CTRL_TO_SELECT_MORE_TOOLTIP), SetFill(0, 1),
797 NWidget(WWT_TEXTBTN, Colours::Grey, WID_STL_TRUCK), SetAspect(WidgetDimensions::ASPECT_VEHICLE_ICON), SetStringTip(STR_LORRY, STR_STATION_LIST_USE_CTRL_TO_SELECT_MORE_TOOLTIP), SetFill(0, 1),
798 NWidget(WWT_TEXTBTN, Colours::Grey, WID_STL_BUS), SetAspect(WidgetDimensions::ASPECT_VEHICLE_ICON), SetStringTip(STR_BUS, STR_STATION_LIST_USE_CTRL_TO_SELECT_MORE_TOOLTIP), SetFill(0, 1),
799 NWidget(WWT_TEXTBTN, Colours::Grey, WID_STL_SHIP), SetAspect(WidgetDimensions::ASPECT_VEHICLE_ICON), SetStringTip(STR_SHIP, STR_STATION_LIST_USE_CTRL_TO_SELECT_MORE_TOOLTIP), SetFill(0, 1),
800 NWidget(WWT_TEXTBTN, Colours::Grey, WID_STL_AIRPLANE), SetAspect(WidgetDimensions::ASPECT_VEHICLE_ICON), SetStringTip(STR_PLANE, STR_STATION_LIST_USE_CTRL_TO_SELECT_MORE_TOOLTIP), SetFill(0, 1),
801 NWidget(WWT_PUSHTXTBTN, Colours::Grey, WID_STL_FACILALL), SetAspect(WidgetDimensions::ASPECT_VEHICLE_ICON), SetStringTip(STR_ABBREV_ALL, STR_STATION_LIST_SELECT_ALL_FACILITIES_TOOLTIP), SetTextStyle(TextColour::Black, FontSize::Small), SetFill(0, 1),
803 NWidget(WWT_DROPDOWN, Colours::Grey, WID_STL_CARGODROPDOWN), SetFill(1, 0), SetToolTip(STR_STATION_LIST_USE_CTRL_TO_SELECT_MORE_TOOLTIP),
805 EndContainer(),
807 NWidget(WWT_PUSHTXTBTN, Colours::Grey, WID_STL_SORTBY), SetMinimalSize(0, 12), SetStringTip(STR_BUTTON_SORT_BY, STR_TOOLTIP_SORT_ORDER),
808 NWidget(WWT_DROPDOWN, Colours::Grey, WID_STL_SORTDROPBTN), SetMinimalSize(0, 12), SetStringTip(STR_SORT_BY_NAME, STR_TOOLTIP_SORT_CRITERIA), // widget_data gets overwritten.
809 NWidget(WWT_EDITBOX, Colours::Grey, WID_STL_FILTER), SetFill(1, 0), SetResize(1, 0), SetStringTip(STR_LIST_FILTER_OSKTITLE, STR_LIST_FILTER_TOOLTIP),
810 EndContainer(),
816 EndContainer(),
817 EndContainer(),
818};
819
822 WindowPosition::Automatic, "list_stations", 358, 162,
823 WindowClass::StationList, WindowClass::None,
824 {},
825 _nested_company_stations_widgets
826);
827
833void ShowCompanyStations(CompanyID company)
834{
835 if (!Company::IsValidID(company)) return;
836
838}
839
840static constexpr std::initializer_list<NWidgetPart> _nested_station_view_widgets = {
843 NWidget(WWT_PUSHIMGBTN, Colours::Grey, WID_SV_RENAME), SetAspect(WidgetDimensions::ASPECT_RENAME), SetSpriteTip(SPR_RENAME, STR_STATION_VIEW_EDIT_TOOLTIP),
845 NWidget(WWT_PUSHIMGBTN, Colours::Grey, WID_SV_LOCATION), SetAspect(WidgetDimensions::ASPECT_LOCATION), SetSpriteTip(SPR_GOTO_LOCATION, STR_STATION_VIEW_CENTER_TOOLTIP),
849 EndContainer(),
851 NWidget(WWT_TEXTBTN, Colours::Grey, WID_SV_GROUP), SetMinimalSize(81, 12), SetFill(1, 1), SetStringTip(STR_STATION_VIEW_GROUP),
852 NWidget(WWT_DROPDOWN, Colours::Grey, WID_SV_GROUP_BY), SetMinimalSize(168, 12), SetResize(1, 0), SetFill(0, 1), SetToolTip(STR_TOOLTIP_GROUP_ORDER),
853 EndContainer(),
855 NWidget(WWT_PUSHTXTBTN, Colours::Grey, WID_SV_SORT_ORDER), SetMinimalSize(81, 12), SetFill(1, 1), SetStringTip(STR_BUTTON_SORT_BY, STR_TOOLTIP_SORT_ORDER),
856 NWidget(WWT_DROPDOWN, Colours::Grey, WID_SV_SORT_BY), SetMinimalSize(168, 12), SetResize(1, 0), SetFill(0, 1), SetToolTip(STR_TOOLTIP_SORT_CRITERIA),
857 EndContainer(),
861 EndContainer(),
865 SetStringTip(STR_STATION_VIEW_RATINGS_BUTTON, STR_STATION_VIEW_RATINGS_TOOLTIP),
868 SetStringTip(STR_STATION_VIEW_CLOSE_AIRPORT, STR_STATION_VIEW_CLOSE_AIRPORT_TOOLTIP),
869 EndContainer(),
870 NWidget(WWT_TEXTBTN, Colours::Grey, WID_SV_CATCHMENT), SetMinimalSize(45, 12), SetResize(1, 0), SetFill(1, 1), SetStringTip(STR_BUTTON_CATCHMENT, STR_TOOLTIP_CATCHMENT),
871 NWidget(WWT_PUSHTXTBTN, Colours::Grey, WID_SV_TRAINS), SetAspect(WidgetDimensions::ASPECT_VEHICLE_ICON), SetFill(0, 1), SetStringTip(STR_TRAIN, STR_STATION_VIEW_SCHEDULED_TRAINS_TOOLTIP),
872 NWidget(WWT_PUSHTXTBTN, Colours::Grey, WID_SV_ROADVEHS), SetAspect(WidgetDimensions::ASPECT_VEHICLE_ICON), SetFill(0, 1), SetStringTip(STR_LORRY, STR_STATION_VIEW_SCHEDULED_ROAD_VEHICLES_TOOLTIP),
873 NWidget(WWT_PUSHTXTBTN, Colours::Grey, WID_SV_SHIPS), SetAspect(WidgetDimensions::ASPECT_VEHICLE_ICON), SetFill(0, 1), SetStringTip(STR_SHIP, STR_STATION_VIEW_SCHEDULED_SHIPS_TOOLTIP),
874 NWidget(WWT_PUSHTXTBTN, Colours::Grey, WID_SV_PLANES), SetAspect(WidgetDimensions::ASPECT_VEHICLE_ICON), SetFill(0, 1), SetStringTip(STR_PLANE, STR_STATION_VIEW_SCHEDULED_AIRCRAFT_TOOLTIP),
876 EndContainer(),
877};
878
879enum SortOrder : uint8_t {
880 SO_DESCENDING,
881 SO_ASCENDING
882};
883
884class CargoDataEntry;
885
894
895class CargoSorter {
896public:
897 using is_transparent = void;
898 CargoSorter(CargoSortType t = CargoSortType::StationID, SortOrder o = SO_ASCENDING) : type(t), order(o) {}
899 CargoSortType GetSortType() {return this->type;}
900 bool operator()(const CargoDataEntry &cd1, const CargoDataEntry &cd2) const;
901 bool operator()(const CargoDataEntry &cd1, const std::unique_ptr<CargoDataEntry> &cd2) const { return this->operator()(cd1, *cd2); }
902 bool operator()(const std::unique_ptr<CargoDataEntry> &cd1, const CargoDataEntry &cd2) const { return this->operator()(*cd1, cd2); }
903 bool operator()(const std::unique_ptr<CargoDataEntry> &cd1, const std::unique_ptr<CargoDataEntry> &cd2) const { return this->operator()(*cd1, *cd2); }
904
905private:
906 CargoSortType type;
907 SortOrder order;
908
909 template <class Tid>
910 bool SortId(Tid st1, Tid st2) const;
911 bool SortCount(const CargoDataEntry &cd1, const CargoDataEntry &cd2) const;
912 bool SortStation(StationID st1, StationID st2) const;
913};
914
915typedef std::set<std::unique_ptr<CargoDataEntry>, CargoSorter> CargoDataSet;
916
922class CargoDataEntry {
923public:
924 CargoDataEntry();
926
932 CargoDataEntry &InsertOrRetrieve(StationID station)
933 {
934 return this->InsertOrRetrieve<StationID>(station);
935 }
936
943 {
944 return this->InsertOrRetrieve<CargoType>(cargo);
945 }
946
947 void Update(uint count);
948
953 void Remove(StationID station)
954 {
955 CargoDataEntry t(station);
956 this->Remove(t);
957 }
958
964 {
965 CargoDataEntry t(cargo);
966 this->Remove(t);
967 }
968
974 CargoDataEntry *Retrieve(StationID station) const
975 {
976 CargoDataEntry t(station);
977 return this->Retrieve(this->children->find(t));
978 }
979
985 CargoDataEntry *Retrieve(CargoType cargo) const
986 {
987 CargoDataEntry t(cargo);
988 return this->Retrieve(this->children->find(t));
989 }
990
991 void Resort(CargoSortType type, SortOrder order);
992
997 StationID GetStation() const { return this->station; }
998
1003 CargoType GetCargo() const { return this->cargo; }
1004
1009 uint GetCount() const { return this->count; }
1010
1015 CargoDataEntry *GetParent() const { return this->parent; }
1016
1021 uint GetNumChildren() const { return this->num_children; }
1022
1027 CargoDataSet::iterator Begin() const { return this->children->begin(); }
1028
1033 CargoDataSet::iterator End() const { return this->children->end(); }
1034
1039 bool HasTransfers() const { return this->transfers; }
1040
1045 void SetTransfers(bool value) { this->transfers = value; }
1046
1047 void Clear();
1048
1051 CargoDataEntry(StationID station);
1053
1054private:
1055 CargoDataEntry *Retrieve(CargoDataSet::iterator i) const;
1056
1057 template <class Tid>
1059
1060 void Remove(CargoDataEntry &entry);
1061 void IncrementSize();
1062
1063 CargoDataEntry *parent;
1064 const union {
1065 StationID station;
1066 struct {
1069 };
1070 };
1072 uint count;
1073 std::unique_ptr<CargoDataSet> children;
1074};
1075
1076CargoDataEntry::CargoDataEntry() :
1077 parent(nullptr),
1078 station(StationID::Invalid()),
1079 num_children(0),
1080 count(0),
1081 children(std::make_unique<CargoDataSet>(CargoSorter(CargoSortType::CargoType)))
1082{}
1083
1084CargoDataEntry::CargoDataEntry(CargoType cargo, uint count, CargoDataEntry *parent) :
1085 parent(parent),
1086 cargo(cargo),
1087 num_children(0),
1088 count(count),
1089 children(std::make_unique<CargoDataSet>())
1090{}
1091
1092CargoDataEntry::CargoDataEntry(StationID station, uint count, CargoDataEntry *parent) :
1093 parent(parent),
1094 station(station),
1095 num_children(0),
1096 count(count),
1097 children(std::make_unique<CargoDataSet>())
1098{}
1099
1100CargoDataEntry::CargoDataEntry(StationID station) :
1101 parent(nullptr),
1102 station(station),
1103 num_children(0),
1104 count(0),
1105 children(nullptr)
1106{}
1107
1108CargoDataEntry::CargoDataEntry(CargoType cargo) :
1109 parent(nullptr),
1110 cargo(cargo),
1111 num_children(0),
1112 count(0),
1113 children(nullptr)
1114{}
1115
1118{
1119 this->Clear();
1120}
1121
1126{
1127 if (this->children != nullptr) this->children->clear();
1128 if (this->parent != nullptr) this->parent->count -= this->count;
1129 this->count = 0;
1130 this->num_children = 0;
1131}
1132
1139void CargoDataEntry::Remove(CargoDataEntry &entry)
1140{
1141 CargoDataSet::iterator i = this->children->find(entry);
1142 if (i != this->children->end()) this->children->erase(i);
1143}
1144
1151template <class Tid>
1152CargoDataEntry &CargoDataEntry::InsertOrRetrieve(Tid child_id)
1153{
1154 CargoDataEntry tmp(child_id);
1155 CargoDataSet::iterator i = this->children->find(tmp);
1156 if (i == this->children->end()) {
1157 IncrementSize();
1158 return **(this->children->insert(std::make_unique<CargoDataEntry>(child_id, 0, this)).first);
1159 } else {
1160 assert(this->children->value_comp().GetSortType() != CargoSortType::Count);
1161 return **i;
1162 }
1163}
1164
1171{
1172 this->count += count;
1173 if (this->parent != nullptr) this->parent->Update(count);
1174}
1175
1180{
1181 ++this->num_children;
1182 if (this->parent != nullptr) this->parent->IncrementSize();
1183}
1184
1185void CargoDataEntry::Resort(CargoSortType type, SortOrder order)
1186{
1187 auto new_children = std::make_unique<CargoDataSet>(CargoSorter(type, order));
1188 new_children->merge(*this->children);
1189 this->children = std::move(new_children);
1190}
1191
1192CargoDataEntry *CargoDataEntry::Retrieve(CargoDataSet::iterator i) const
1193{
1194 if (i == this->children->end()) {
1195 return nullptr;
1196 } else {
1197 assert(this->children->value_comp().GetSortType() != CargoSortType::Count);
1198 return i->get();
1199 }
1200}
1201
1202bool CargoSorter::operator()(const CargoDataEntry &cd1, const CargoDataEntry &cd2) const
1203{
1204 switch (this->type) {
1206 return this->SortId<StationID>(cd1.GetStation(), cd2.GetStation());
1208 return this->SortId<CargoType>(cd1.GetCargo(), cd2.GetCargo());
1210 return this->SortCount(cd1, cd2);
1212 return this->SortStation(cd1.GetStation(), cd2.GetStation());
1213 default:
1214 NOT_REACHED();
1215 }
1216}
1217
1218template <class Tid>
1219bool CargoSorter::SortId(Tid st1, Tid st2) const
1220{
1221 return (this->order == SO_ASCENDING) ? st1 < st2 : st2 < st1;
1222}
1223
1224bool CargoSorter::SortCount(const CargoDataEntry &cd1, const CargoDataEntry &cd2) const
1225{
1226 uint c1 = cd1.GetCount();
1227 uint c2 = cd2.GetCount();
1228 if (c1 == c2) {
1229 return this->SortStation(cd1.GetStation(), cd2.GetStation());
1230 } else if (this->order == SO_ASCENDING) {
1231 return c1 < c2;
1232 } else {
1233 return c2 < c1;
1234 }
1235}
1236
1237bool CargoSorter::SortStation(StationID st1, StationID st2) const
1238{
1239 if (!Station::IsValidID(st1)) {
1240 return Station::IsValidID(st2) ? this->order == SO_ASCENDING : this->SortId(st1, st2);
1241 } else if (!Station::IsValidID(st2)) {
1242 return order == SO_DESCENDING;
1243 }
1244
1245 int res = StrNaturalCompare(Station::Get(st1)->GetCachedName(), Station::Get(st2)->GetCachedName()); // Sort by name (natural sorting).
1246 if (res == 0) {
1247 return this->SortId(st1, st2);
1248 } else {
1249 return (this->order == SO_ASCENDING) ? res < 0 : res > 0;
1250 }
1251}
1252
1256struct StationViewWindow : public Window {
1260 struct RowDisplay {
1261 RowDisplay(CargoDataEntry *f, StationID n) : filter(f), next_station(n) {}
1262 RowDisplay(CargoDataEntry *f, CargoType n) : filter(f), next_cargo(n) {}
1263
1268 union {
1272 StationID next_station;
1273
1278 };
1279 };
1280
1281 typedef std::vector<RowDisplay> CargoDataVector;
1282
1283 static const int NUM_COLUMNS = 4;
1284
1288 enum Invalidation : uint16_t {
1289 INV_FLOWS = 0x100,
1290 INV_CARGO = 0x200
1291 };
1292
1302
1306 enum Mode : uint8_t {
1309 };
1310
1314 int line_height = 0;
1316 Scrollbar *vscroll = nullptr;
1317
1318 /* Height of the #WID_SV_ACCEPT_RATING_LIST widget for different views. */
1319 static constexpr uint RATING_LINES = 13;
1320 static constexpr uint ACCEPTS_LINES = 3;
1321
1323 static inline const StringID sort_names[] = {
1324 STR_STATION_VIEW_WAITING_STATION,
1325 STR_STATION_VIEW_WAITING_AMOUNT,
1326 STR_STATION_VIEW_PLANNED_STATION,
1327 STR_STATION_VIEW_PLANNED_AMOUNT,
1328 };
1329
1330 static inline const StringID group_names[] = {
1331 STR_STATION_VIEW_GROUP_S_V_D,
1332 STR_STATION_VIEW_GROUP_S_D_V,
1333 STR_STATION_VIEW_GROUP_V_S_D,
1334 STR_STATION_VIEW_GROUP_V_D_S,
1335 STR_STATION_VIEW_GROUP_D_S_V,
1336 STR_STATION_VIEW_GROUP_D_V_S,
1337 };
1338
1345 std::array<CargoSortType, NUM_COLUMNS> sortings{};
1346
1348 std::array<SortOrder, NUM_COLUMNS> sort_orders{};
1349
1350 int scroll_to_row = INT_MAX;
1353 std::array<Grouping, NUM_COLUMNS> groupings;
1354
1357 CargoDataVector displayed_rows{};
1358
1360 {
1361 this->CreateNestedTree();
1363 this->vscroll = this->GetScrollbar(WID_SV_SCROLLBAR);
1364 /* Nested widget tree creation is done in two steps to ensure that this->GetWidget<NWidgetCore>(WID_SV_ACCEPTS_RATINGS) exists in UpdateWidgetSize(). */
1365 this->FinishInitNested(window_number);
1366
1367 this->groupings[0] = GR_CARGO;
1368 this->sortings[0] = CargoSortType::AsGrouping;
1369 this->SelectGroupBy(_settings_client.gui.station_gui_group_order);
1370 this->SelectSortBy(_settings_client.gui.station_gui_sort_by);
1371 this->sort_orders[0] = SO_ASCENDING;
1372 this->SelectSortOrder((SortOrder)_settings_client.gui.station_gui_sort_order);
1373 this->owner = Station::Get(window_number)->owner;
1374 }
1375
1376 void OnInit() override
1377 {
1378 this->cargo_icon_size = GetLargestCargoIconSize();
1379 this->line_height = std::max<int>(GetCharacterHeight(FontSize::Normal), this->cargo_icon_size.height);
1380 this->expand_shrink_width = std::max(GetCharacterWidth(FontSize::Normal, '-'), GetCharacterWidth(FontSize::Normal, '+'));
1381 }
1382
1383 void Close([[maybe_unused]] int data = 0) override
1384 {
1385 CloseWindowById(WindowClass::TrainList, VehicleListIdentifier(VehicleListType::Station, VehicleType::Train, this->owner, this->window_number).ToWindowNumber(), false);
1386 CloseWindowById(WindowClass::RoadVehicleList, VehicleListIdentifier(VehicleListType::Station, VehicleType::Road, this->owner, this->window_number).ToWindowNumber(), false);
1387 CloseWindowById(WindowClass::ShipList, VehicleListIdentifier(VehicleListType::Station, VehicleType::Ship, this->owner, this->window_number).ToWindowNumber(), false);
1388 CloseWindowById(WindowClass::AircraftList, VehicleListIdentifier(VehicleListType::Station, VehicleType::Aircraft, this->owner, this->window_number).ToWindowNumber(), false);
1389
1390 SetViewportCatchmentStation(Station::Get(this->window_number), false);
1391 this->Window::Close();
1392 }
1393
1404 void ShowCargo(CargoDataEntry *data, CargoType cargo, StationID source, StationID next, StationID dest, uint count)
1405 {
1406 if (count == 0) return;
1407 bool auto_distributed = _settings_game.linkgraph.GetDistributionType(cargo) != DistributionType::Manual;
1408 const CargoDataEntry *expand = &this->expanded_rows;
1409 for (int i = 0; i < NUM_COLUMNS && expand != nullptr; ++i) {
1410 switch (groupings[i]) {
1411 case GR_CARGO:
1412 assert(i == 0);
1413 data = &data->InsertOrRetrieve(cargo);
1414 data->SetTransfers(source != this->window_number);
1415 expand = expand->Retrieve(cargo);
1416 break;
1417 case GR_SOURCE:
1418 if (auto_distributed || source != this->window_number) {
1419 data = &data->InsertOrRetrieve(source);
1420 expand = expand->Retrieve(source);
1421 }
1422 break;
1423 case GR_NEXT:
1424 if (auto_distributed) {
1425 data = &data->InsertOrRetrieve(next);
1426 expand = expand->Retrieve(next);
1427 }
1428 break;
1429 case GR_DESTINATION:
1430 if (auto_distributed) {
1431 data = &data->InsertOrRetrieve(dest);
1432 expand = expand->Retrieve(dest);
1433 }
1434 break;
1435 }
1436 }
1437 data->Update(count);
1438 }
1439
1440 void UpdateWidgetSize(WidgetID widget, Dimension &size, [[maybe_unused]] const Dimension &padding, [[maybe_unused]] Dimension &fill, [[maybe_unused]] Dimension &resize) override
1441 {
1442 switch (widget) {
1443 case WID_SV_WAITING:
1444 fill.height = resize.height = this->line_height;
1445 size.height = 4 * resize.height + padding.height;
1446 break;
1447
1449 size.height = ((this->GetWidget<NWidgetCore>(WID_SV_ACCEPTS_RATINGS)->GetString() == STR_STATION_VIEW_RATINGS_BUTTON) ? this->accepts_lines : this->rating_lines) * GetCharacterHeight(FontSize::Normal) + padding.height;
1450 break;
1451 }
1452 }
1453
1454 void OnPaint() override
1455 {
1456 const Station *st = Station::Get(this->window_number);
1457 CargoDataEntry cargo;
1458 BuildCargoList(&cargo, st);
1459
1460 this->vscroll->SetCount(cargo.GetNumChildren()); // update scrollbar
1461
1462 /* disable some buttons */
1468 this->SetWidgetDisabledState(WID_SV_CLOSE_AIRPORT, !st->facilities.Test(StationFacility::Airport) || st->owner != _local_company || st->owner == OWNER_NONE); // Also consider SE, where _local_company == OWNER_NONE
1470
1474
1475 this->DrawWidgets();
1476
1477 if (!this->IsShaded()) {
1478 /* Draw 'accepted cargo' or 'cargo ratings'. */
1480 const Rect r = wid->GetCurrentRect();
1481 if (this->GetWidget<NWidgetCore>(WID_SV_ACCEPTS_RATINGS)->GetString() == STR_STATION_VIEW_RATINGS_BUTTON) {
1482 int lines = this->DrawAcceptedCargo(r);
1483 if (lines > this->accepts_lines) { // Resize the widget, and perform re-initialization of the window.
1484 this->accepts_lines = lines;
1485 this->ReInit();
1486 return;
1487 }
1488 } else {
1489 int lines = this->DrawCargoRatings(r);
1490 if (lines > this->rating_lines) { // Resize the widget, and perform re-initialization of the window.
1491 this->rating_lines = lines;
1492 this->ReInit();
1493 return;
1494 }
1495 }
1496
1497 /* Draw arrow pointing up/down for ascending/descending sorting */
1498 this->DrawSortButton(WID_SV_SORT_ORDER, sort_orders[1] != SO_ASCENDING);
1499
1500 int pos = this->vscroll->GetPosition();
1501
1502 int maxrows = this->vscroll->GetCapacity();
1503
1504 displayed_rows.clear();
1505
1506 /* Draw waiting cargo. */
1508 Rect waiting_rect = nwi->GetCurrentRect().Shrink(WidgetDimensions::scaled.framerect);
1509 this->DrawEntries(cargo, waiting_rect, pos, maxrows, 0);
1510 scroll_to_row = INT_MAX;
1511 }
1512 }
1513
1514 std::string GetWidgetString(WidgetID widget, StringID stringid) const override
1515 {
1516 if (widget == WID_SV_CAPTION) {
1517 const Station *st = Station::Get(this->window_number);
1518 return GetString(STR_STATION_VIEW_CAPTION, st->index, st->facilities);
1519 }
1520
1521 return this->Window::GetWidgetString(widget, stringid);
1522 }
1523
1530 {
1531 const Station *st = Station::Get(this->window_number);
1532 CargoDataEntry &entry = cached_destinations.InsertOrRetrieve(cargo);
1533 entry.Clear();
1534
1535 if (!st->goods[cargo].HasData()) return;
1536
1537 for (const auto &it : st->goods[cargo].GetData().flows) {
1538 StationID from = it.first;
1539 CargoDataEntry &source_entry = entry.InsertOrRetrieve(from);
1540 uint32_t prev_count = 0;
1541 for (const auto &flow_it : *it.second.GetShares()) {
1542 StationID via = flow_it.second;
1543 CargoDataEntry &via_entry = source_entry.InsertOrRetrieve(via);
1544 if (via == this->window_number) {
1545 via_entry.InsertOrRetrieve(via).Update(flow_it.first - prev_count);
1546 } else {
1547 EstimateDestinations(cargo, from, via, flow_it.first - prev_count, via_entry);
1548 }
1549 prev_count = flow_it.first;
1550 }
1551 }
1552 }
1553
1563 void EstimateDestinations(CargoType cargo, StationID source, StationID next, uint count, CargoDataEntry &dest)
1564 {
1565 if (Station::IsValidID(next) && Station::IsValidID(source)) {
1566 GoodsEntry &ge = Station::Get(next)->goods[cargo];
1567 if (!ge.HasData()) return;
1568
1569 CargoDataEntry tmp;
1570 const FlowStatMap &flowmap = ge.GetData().flows;
1571 FlowStatMap::const_iterator map_it = flowmap.find(source);
1572 if (map_it != flowmap.end()) {
1573 const FlowStat::SharesMap *shares = map_it->second.GetShares();
1574 uint32_t prev_count = 0;
1575 for (FlowStat::SharesMap::const_iterator i = shares->begin(); i != shares->end(); ++i) {
1576 tmp.InsertOrRetrieve(i->second).Update(i->first - prev_count);
1577 prev_count = i->first;
1578 }
1579 }
1580
1581 if (tmp.GetCount() == 0) {
1582 dest.InsertOrRetrieve(StationID::Invalid()).Update(count);
1583 } else {
1584 uint sum_estimated = 0;
1585 while (sum_estimated < count) {
1586 for (CargoDataSet::iterator i = tmp.Begin(); i != tmp.End() && sum_estimated < count; ++i) {
1587 CargoDataEntry &child = **i;
1588 uint estimate = DivideApprox(child.GetCount() * count, tmp.GetCount());
1589 if (estimate == 0) estimate = 1;
1590
1591 sum_estimated += estimate;
1592 if (sum_estimated > count) {
1593 estimate -= sum_estimated - count;
1594 sum_estimated = count;
1595 }
1596
1597 if (estimate > 0) {
1598 if (child.GetStation() == next) {
1599 dest.InsertOrRetrieve(next).Update(estimate);
1600 } else {
1601 EstimateDestinations(cargo, source, child.GetStation(), estimate, dest);
1602 }
1603 }
1604 }
1605
1606 }
1607 }
1608 } else {
1609 dest.InsertOrRetrieve(StationID::Invalid()).Update(count);
1610 }
1611 }
1612
1619 void BuildFlowList(CargoType cargo, const FlowStatMap &flows, CargoDataEntry *entry)
1620 {
1621 const CargoDataEntry *source_dest = this->cached_destinations.Retrieve(cargo);
1622 for (FlowStatMap::const_iterator it = flows.begin(); it != flows.end(); ++it) {
1623 StationID from = it->first;
1624 const CargoDataEntry *source_entry = source_dest->Retrieve(from);
1625 const FlowStat::SharesMap *shares = it->second.GetShares();
1626 for (FlowStat::SharesMap::const_iterator flow_it = shares->begin(); flow_it != shares->end(); ++flow_it) {
1627 const CargoDataEntry *via_entry = source_entry->Retrieve(flow_it->second);
1628 for (CargoDataSet::iterator dest_it = via_entry->Begin(); dest_it != via_entry->End(); ++dest_it) {
1629 CargoDataEntry &dest_entry = **dest_it;
1630 ShowCargo(entry, cargo, from, flow_it->second, dest_entry.GetStation(), dest_entry.GetCount());
1631 }
1632 }
1633 }
1634 }
1635
1642 void BuildCargoList(CargoType cargo, const StationCargoList &packets, CargoDataEntry *entry)
1643 {
1644 const CargoDataEntry *source_dest = this->cached_destinations.Retrieve(cargo);
1645 for (StationCargoList::ConstIterator it = packets.Packets()->begin(); it != packets.Packets()->end(); it++) {
1646 const CargoPacket *cp = *it;
1647 StationID next = it.GetKey();
1648
1649 const CargoDataEntry *source_entry = source_dest->Retrieve(cp->GetFirstStation());
1650 if (source_entry == nullptr) {
1651 this->ShowCargo(entry, cargo, cp->GetFirstStation(), next, StationID::Invalid(), cp->Count());
1652 continue;
1653 }
1654
1655 const CargoDataEntry *via_entry = source_entry->Retrieve(next);
1656 if (via_entry == nullptr) {
1657 this->ShowCargo(entry, cargo, cp->GetFirstStation(), next, StationID::Invalid(), cp->Count());
1658 continue;
1659 }
1660
1661 uint remaining = cp->Count();
1662 for (CargoDataSet::iterator dest_it = via_entry->Begin(); dest_it != via_entry->End();) {
1663 CargoDataEntry &dest_entry = **dest_it;
1664
1665 /* Advance iterator here instead of in the for statement to test whether this is the last entry */
1666 ++dest_it;
1667
1668 uint val;
1669 if (dest_it == via_entry->End()) {
1670 /* Allocate all remaining waiting cargo to the last destination to avoid
1671 * waiting cargo being "lost", and the displayed total waiting cargo
1672 * not matching GoodsEntry::TotalCount() */
1673 val = remaining;
1674 } else {
1675 val = std::min<uint>(remaining, DivideApprox(cp->Count() * dest_entry.GetCount(), via_entry->GetCount()));
1676 remaining -= val;
1677 }
1678 this->ShowCargo(entry, cargo, cp->GetFirstStation(), next, dest_entry.GetStation(), val);
1679 }
1680 }
1681 this->ShowCargo(entry, cargo, NEW_STATION, NEW_STATION, NEW_STATION, packets.ReservedCount());
1682 }
1683
1689 void BuildCargoList(CargoDataEntry *entry, const Station *st)
1690 {
1691 for (CargoType cargo : EnumRange(NUM_CARGO)) {
1692
1693 if (this->cached_destinations.Retrieve(cargo) == nullptr) {
1694 this->RecalcDestinations(cargo);
1695 }
1696
1697 const GoodsEntry &ge = st->goods[cargo];
1698 if (!ge.HasData()) continue;
1699
1700 if (this->current_mode == MODE_WAITING) {
1701 this->BuildCargoList(cargo, ge.GetData().cargo, entry);
1702 } else {
1703 this->BuildFlowList(cargo, ge.GetData().flows, entry);
1704 }
1705 }
1706 }
1707
1713 {
1714 std::list<StationID> stations;
1715 const CargoDataEntry *parent = entry.GetParent();
1716 if (parent->GetParent() == nullptr) {
1717 this->displayed_rows.push_back(RowDisplay(&this->expanded_rows, entry.GetCargo()));
1718 return;
1719 }
1720
1721 StationID next = entry.GetStation();
1722 while (parent->GetParent()->GetParent() != nullptr) {
1723 stations.push_back(parent->GetStation());
1724 parent = parent->GetParent();
1725 }
1726
1727 CargoType cargo = parent->GetCargo();
1728 CargoDataEntry *filter = this->expanded_rows.Retrieve(cargo);
1729 while (!stations.empty()) {
1730 filter = filter->Retrieve(stations.back());
1731 stations.pop_back();
1732 }
1733
1734 this->displayed_rows.push_back(RowDisplay(filter, next));
1735 }
1736
1745 StringID GetEntryString(StationID station, StringID here, StringID other_station, StringID any) const
1746 {
1747 if (station == this->window_number) {
1748 return here;
1749 } else if (station == StationID::Invalid()) {
1750 return any;
1751 } else if (station == NEW_STATION) {
1752 return STR_STATION_VIEW_RESERVED;
1753 } else {
1754 return other_station;
1755 }
1756 }
1757
1758 StringID GetGroupingString(Grouping grouping, StationID station) const
1759 {
1760 switch (grouping) {
1761 case GR_SOURCE: return this->GetEntryString(station, STR_STATION_VIEW_FROM_HERE, STR_STATION_VIEW_FROM, STR_STATION_VIEW_FROM_ANY);
1762 case GR_NEXT: return this->GetEntryString(station, STR_STATION_VIEW_VIA_HERE, STR_STATION_VIEW_VIA, STR_STATION_VIEW_VIA_ANY);
1763 case GR_DESTINATION: return this->GetEntryString(station, STR_STATION_VIEW_TO_HERE, STR_STATION_VIEW_TO, STR_STATION_VIEW_TO_ANY);
1764 default: NOT_REACHED();
1765 }
1766 }
1767
1775 StringID SearchNonStop(CargoDataEntry &cd, StationID station, int column)
1776 {
1777 assert(column < NUM_COLUMNS);
1779 for (int i = column - 1; i > 0; --i) {
1780 if (this->groupings[i] == GR_DESTINATION) {
1781 if (parent->GetStation() == station) {
1782 return STR_STATION_VIEW_NONSTOP;
1783 } else {
1784 return STR_STATION_VIEW_VIA;
1785 }
1786 }
1787 parent = parent->GetParent();
1788 }
1789
1790 if (column < NUM_COLUMNS - 1 && this->groupings[column + 1] == GR_DESTINATION) {
1791 CargoDataSet::iterator begin = cd.Begin();
1792 CargoDataSet::iterator end = cd.End();
1793 if (begin != end && ++(cd.Begin()) == end && (*(begin))->GetStation() == station) {
1794 return STR_STATION_VIEW_NONSTOP;
1795 } else {
1796 return STR_STATION_VIEW_VIA;
1797 }
1798 }
1799
1800 return STR_STATION_VIEW_VIA;
1801 }
1802
1809 void DrawCargoIcons(CargoType cargo, uint waiting, const Rect &r) const
1810 {
1811 int width = ScaleSpriteTrad(10);
1812 uint num = std::min<uint>((waiting + (width / 2)) / width, r.Width() / width); // maximum is width / 10 icons so it won't overflow
1813 if (num == 0) return;
1814
1815 SpriteID sprite = CargoSpec::Get(cargo)->GetCargoIcon();
1816
1817 int x = _current_text_dir == TD_RTL ? r.left : r.right - num * width;
1818 int y = CentreBounds(r.top, r.bottom, this->cargo_icon_size.height);
1819 do {
1820 DrawSprite(sprite, PAL_NONE, x, y);
1821 x += width;
1822 } while (--num);
1823 }
1824
1835 int DrawEntries(CargoDataEntry &entry, const Rect &r, int pos, int maxrows, int column, CargoType cargo = INVALID_CARGO)
1836 {
1837 assert(column < NUM_COLUMNS);
1838 if (this->sortings[column] == CargoSortType::AsGrouping) {
1839 if (this->groupings[column] != GR_CARGO) {
1840 entry.Resort(CargoSortType::StationString, this->sort_orders[column]);
1841 }
1842 } else {
1843 entry.Resort(CargoSortType::Count, this->sort_orders[column]);
1844 }
1845 int text_y_offset = (this->line_height - GetCharacterHeight(FontSize::Normal)) / 2;
1846 for (CargoDataSet::iterator i = entry.Begin(); i != entry.End(); ++i) {
1847 CargoDataEntry &cd = **i;
1848
1849 Grouping grouping = this->groupings[column];
1850 if (grouping == GR_CARGO) cargo = cd.GetCargo();
1851 bool auto_distributed = _settings_game.linkgraph.GetDistributionType(cargo) != DistributionType::Manual;
1852
1853 if (pos > -maxrows && pos <= 0) {
1854 StringID str = STR_EMPTY;
1855 StationID station = StationID::Invalid();
1856 int y = r.top - pos * this->line_height;
1857 if (this->groupings[column] == GR_CARGO) {
1858 str = STR_STATION_VIEW_WAITING_CARGO;
1859 this->DrawCargoIcons(cd.GetCargo(), cd.GetCount(), Rect(r.left + this->expand_shrink_width, y, r.right - this->expand_shrink_width, y + this->line_height - 1));
1860 } else {
1861 if (!auto_distributed) grouping = GR_SOURCE;
1862 station = cd.GetStation();
1863 str = this->GetGroupingString(grouping, station);
1864 if (grouping == GR_NEXT && str == STR_STATION_VIEW_VIA) str = this->SearchNonStop(cd, station, column);
1865
1866 if (pos == -this->scroll_to_row && Station::IsValidID(station)) {
1868 }
1869 }
1870
1871 bool rtl = _current_text_dir == TD_RTL;
1872 Rect text = r.Indent(column * WidgetDimensions::scaled.hsep_indent, rtl).Indent(this->expand_shrink_width, !rtl);
1873 Rect shrink = r.WithWidth(this->expand_shrink_width, !rtl);
1874
1875 DrawString(text.left, text.right, y + text_y_offset, GetString(str, cargo, cd.GetCount(), station));
1876
1877 if (column < NUM_COLUMNS - 1) {
1878 std::string_view sym;
1879 if (cd.GetNumChildren() > 0) {
1880 sym = "-";
1881 } else if (auto_distributed && str != STR_STATION_VIEW_RESERVED) {
1882 sym = "+";
1883 } else {
1884 /* Only draw '+' if there is something to be shown. */
1885 const GoodsEntry &ge = Station::Get(this->window_number)->goods[cargo];
1886 if (ge.HasData()) {
1887 const StationCargoList &cargo_list = ge.GetData().cargo;
1888 if (grouping == GR_CARGO && (cargo_list.ReservedCount() > 0 || cd.HasTransfers())) {
1889 sym = "+";
1890 }
1891 }
1892 }
1893 if (!sym.empty()) DrawString(shrink.left, shrink.right, y + text_y_offset, sym, TextColour::Yellow);
1894 }
1895 this->SetDisplayedRow(cd);
1896 }
1897 --pos;
1898 if ((auto_distributed || column == 0) && column < NUM_COLUMNS - 1) {
1899 pos = this->DrawEntries(cd, r, pos, maxrows, column + 1, cargo);
1900 }
1901 }
1902 return pos;
1903 }
1904
1910 int DrawAcceptedCargo(const Rect &r) const
1911 {
1912 const Station *st = Station::Get(this->window_number);
1913 Rect tr = r.Shrink(WidgetDimensions::scaled.framerect);
1914
1915 int bottom = DrawStringMultiLine(tr.left, tr.right, tr.top, INT32_MAX, GetString(STR_STATION_VIEW_ACCEPTS_CARGO, GetAcceptanceMask(st)));
1916 return CeilDiv(bottom - r.top - WidgetDimensions::scaled.framerect.top, GetCharacterHeight(FontSize::Normal));
1917 }
1918
1924 int DrawCargoRatings(const Rect &r) const
1925 {
1926 const Station *st = Station::Get(this->window_number);
1927 bool rtl = _current_text_dir == TD_RTL;
1928 Rect tr = r.Shrink(WidgetDimensions::scaled.framerect);
1929
1930 if (st->town->exclusive_counter > 0) {
1931 tr.top = DrawStringMultiLine(tr, GetString(st->town->exclusivity == st->owner ? STR_STATION_VIEW_EXCLUSIVE_RIGHTS_SELF : STR_STATION_VIEW_EXCLUSIVE_RIGHTS_COMPANY, st->town->exclusivity));
1932 tr.top += WidgetDimensions::scaled.vsep_wide;
1933 }
1934
1935 DrawString(tr, TimerGameEconomy::UsingWallclockUnits() ? STR_STATION_VIEW_SUPPLY_RATINGS_TITLE_MINUTE : STR_STATION_VIEW_SUPPLY_RATINGS_TITLE_MONTH);
1937
1938 for (const CargoSpec *cs : _sorted_standard_cargo_specs) {
1939 const GoodsEntry *ge = &st->goods[cs->Index()];
1940 if (!ge->HasRating()) continue;
1941
1943 DrawString(tr.Indent(WidgetDimensions::scaled.hsep_indent, rtl),
1944 GetString(STR_STATION_VIEW_CARGO_SUPPLY_RATING,
1945 cs->name,
1946 lg != nullptr ? lg->Monthly((*lg)[ge->node].supply) : 0,
1947 STR_CARGO_RATING_APPALLING + (ge->rating >> 5),
1948 ToPercent8(ge->rating)));
1950 }
1951 return CeilDiv(tr.top - r.top - WidgetDimensions::scaled.framerect.top, GetCharacterHeight(FontSize::Normal));
1952 }
1953
1959 template <class Tid>
1961 {
1962 if (filter->Retrieve(next) != nullptr) {
1963 filter->Remove(next);
1964 } else {
1965 filter->InsertOrRetrieve(next);
1966 }
1967 }
1968
1974 {
1975 if (row < 0 || (uint)row >= this->displayed_rows.size()) return;
1976 if (IsCtrlPressed()) {
1977 this->scroll_to_row = row;
1978 } else {
1979 RowDisplay &display = this->displayed_rows[row];
1980 if (display.filter == &this->expanded_rows) {
1982 } else {
1984 }
1985 }
1988 }
1989
1990 void OnClick([[maybe_unused]] Point pt, WidgetID widget, [[maybe_unused]] int click_count) override
1991 {
1992 Window *w = FindWindowByClass(WindowClass::QueryString);
1993
1994 switch (widget) {
1995 case WID_SV_WAITING:
1996 this->HandleCargoWaitingClick(this->vscroll->GetScrolledRowFromWidget(pt.y, this, WID_SV_WAITING, WidgetDimensions::scaled.framerect.top) - this->vscroll->GetPosition());
1997 break;
1998
1999 case WID_SV_CATCHMENT:
2001 SndClickBeep();
2002
2003 if (w != nullptr && this->IsWidgetLowered(WID_SV_CATCHMENT)) {
2004 if (w->parent->window_class == WindowClass::StationView && w->IsWidgetLowered(WID_QS_MOVE)) SetViewportStationRect(Station::Get(w->parent->window_number), true);
2005 if (w->parent->window_class == WindowClass::WaypointView && w->IsWidgetLowered(WID_QS_MOVE)) SetViewportWaypointRect(Waypoint::Get(w->parent->window_number), true);
2006 }
2007 break;
2008
2009 case WID_SV_LOCATION:
2010 if (IsCtrlPressed()) {
2011 ShowExtraViewportWindow(Station::Get(this->window_number)->xy);
2012 } else {
2013 ScrollMainWindowToTile(Station::Get(this->window_number)->xy);
2014 }
2015 break;
2016
2018 /* Swap between 'accepts' and 'ratings' view. */
2019 int height_change;
2021 if (this->GetWidget<NWidgetCore>(WID_SV_ACCEPTS_RATINGS)->GetString() == STR_STATION_VIEW_RATINGS_BUTTON) {
2022 nwi->SetStringTip(STR_STATION_VIEW_ACCEPTS_BUTTON, STR_STATION_VIEW_ACCEPTS_TOOLTIP); // Switch to accepts view.
2023 height_change = this->rating_lines - this->accepts_lines;
2024 } else {
2025 nwi->SetStringTip(STR_STATION_VIEW_RATINGS_BUTTON, STR_STATION_VIEW_RATINGS_TOOLTIP); // Switch to ratings view.
2026 height_change = this->accepts_lines - this->rating_lines;
2027 }
2028 this->ReInit(0, height_change * GetCharacterHeight(FontSize::Normal));
2029 break;
2030 }
2031
2032 case WID_SV_RENAME:
2033 ShowQueryString(GetString(STR_STATION_NAME, this->window_number), STR_STATION_VIEW_EDIT_STATION_SIGN, MAX_LENGTH_STATION_NAME_CHARS,
2035 break;
2036
2038 Command<Commands::OpenCloseAirport>::Post(this->window_number);
2039 break;
2040
2041 case WID_SV_TRAINS: // Show list of scheduled trains to this station
2042 case WID_SV_ROADVEHS: // Show list of scheduled road-vehicles to this station
2043 case WID_SV_SHIPS: // Show list of scheduled ships to this station
2044 case WID_SV_PLANES: { // Show list of scheduled aircraft to this station
2045 Owner owner = Station::Get(this->window_number)->owner;
2046 ShowVehicleListWindow(owner, (VehicleType)(widget - WID_SV_TRAINS), static_cast<StationID>(this->window_number));
2047 break;
2048 }
2049
2050 case WID_SV_SORT_BY: {
2051 /* The initial selection is composed of current mode and
2052 * sorting criteria for columns 1, 2, and 3. Column 0 is always
2053 * sorted by cargo type. The others can theoretically be sorted
2054 * by different things but there is no UI for that. */
2056 this->current_mode * 2 + (this->sortings[1] == CargoSortType::Count ? 1 : 0),
2057 WID_SV_SORT_BY, 0, 0);
2058 break;
2059 }
2060
2061 case WID_SV_GROUP_BY: {
2062 ShowDropDownMenu(this, StationViewWindow::group_names, this->grouping_index, WID_SV_GROUP_BY, 0, 0);
2063 break;
2064 }
2065
2066 case WID_SV_SORT_ORDER: { // flip sorting method asc/desc
2067 this->SelectSortOrder(this->sort_orders[1] == SO_ASCENDING ? SO_DESCENDING : SO_ASCENDING);
2068 this->SetTimeout();
2070 break;
2071 }
2072 }
2073 }
2074
2079 void SelectSortOrder(SortOrder order)
2080 {
2081 this->sort_orders[1] = this->sort_orders[2] = this->sort_orders[3] = order;
2082 _settings_client.gui.station_gui_sort_order = this->sort_orders[1];
2083 this->SetDirty();
2084 }
2085
2090 void SelectSortBy(int index)
2091 {
2092 _settings_client.gui.station_gui_sort_by = index;
2093 switch (StationViewWindow::sort_names[index].base()) {
2094 case STR_STATION_VIEW_WAITING_STATION.base():
2095 this->current_mode = MODE_WAITING;
2096 this->sortings[1] = this->sortings[2] = this->sortings[3] = CargoSortType::AsGrouping;
2097 break;
2098 case STR_STATION_VIEW_WAITING_AMOUNT.base():
2099 this->current_mode = MODE_WAITING;
2100 this->sortings[1] = this->sortings[2] = this->sortings[3] = CargoSortType::Count;
2101 break;
2102 case STR_STATION_VIEW_PLANNED_STATION.base():
2103 this->current_mode = MODE_PLANNED;
2104 this->sortings[1] = this->sortings[2] = this->sortings[3] = CargoSortType::AsGrouping;
2105 break;
2106 case STR_STATION_VIEW_PLANNED_AMOUNT.base():
2107 this->current_mode = MODE_PLANNED;
2108 this->sortings[1] = this->sortings[2] = this->sortings[3] = CargoSortType::Count;
2109 break;
2110 default:
2111 NOT_REACHED();
2112 }
2113 /* Display the current sort variant */
2115 this->SetDirty();
2116 }
2117
2122 void SelectGroupBy(int index)
2123 {
2124 this->grouping_index = index;
2125 _settings_client.gui.station_gui_group_order = index;
2127 switch (StationViewWindow::group_names[index].base()) {
2128 case STR_STATION_VIEW_GROUP_S_V_D.base():
2129 this->groupings[1] = GR_SOURCE;
2130 this->groupings[2] = GR_NEXT;
2131 this->groupings[3] = GR_DESTINATION;
2132 break;
2133 case STR_STATION_VIEW_GROUP_S_D_V.base():
2134 this->groupings[1] = GR_SOURCE;
2135 this->groupings[2] = GR_DESTINATION;
2136 this->groupings[3] = GR_NEXT;
2137 break;
2138 case STR_STATION_VIEW_GROUP_V_S_D.base():
2139 this->groupings[1] = GR_NEXT;
2140 this->groupings[2] = GR_SOURCE;
2141 this->groupings[3] = GR_DESTINATION;
2142 break;
2143 case STR_STATION_VIEW_GROUP_V_D_S.base():
2144 this->groupings[1] = GR_NEXT;
2145 this->groupings[2] = GR_DESTINATION;
2146 this->groupings[3] = GR_SOURCE;
2147 break;
2148 case STR_STATION_VIEW_GROUP_D_S_V.base():
2149 this->groupings[1] = GR_DESTINATION;
2150 this->groupings[2] = GR_SOURCE;
2151 this->groupings[3] = GR_NEXT;
2152 break;
2153 case STR_STATION_VIEW_GROUP_D_V_S.base():
2154 this->groupings[1] = GR_DESTINATION;
2155 this->groupings[2] = GR_NEXT;
2156 this->groupings[3] = GR_SOURCE;
2157 break;
2158 }
2159 this->SetDirty();
2160 }
2161
2162 void OnDropdownSelect(WidgetID widget, int index, int) override
2163 {
2164 if (widget == WID_SV_SORT_BY) {
2165 this->SelectSortBy(index);
2166 } else {
2167 this->SelectGroupBy(index);
2168 }
2169 }
2170
2171 void OnQueryTextFinished(std::optional<std::string> str) override
2172 {
2173 if (!str.has_value()) return;
2174
2175 Command<Commands::RenameStation>::Post(STR_ERROR_CAN_T_RENAME_STATION, this->window_number, *str);
2176 }
2177
2178 void OnResize() override
2179 {
2180 this->vscroll->SetCapacityFromWidget(this, WID_SV_WAITING, WidgetDimensions::scaled.framerect.Vertical());
2181 }
2182
2188 void OnInvalidateData([[maybe_unused]] int data = 0, [[maybe_unused]] bool gui_scope = true) override
2189 {
2190 if (gui_scope) {
2191 if (data >= 0 && data < NUM_CARGO) {
2192 this->cached_destinations.Remove((CargoType)data);
2193 } else {
2194 this->ReInit();
2195 }
2196 }
2197 }
2198};
2199
2202 WindowPosition::Automatic, "view_station", 249, 117,
2203 WindowClass::StationView, WindowClass::None,
2204 {},
2205 _nested_station_view_widgets
2206);
2207
2217
2223
2224static std::vector<TileAndStation> _deleted_stations_nearby;
2225static std::vector<StationID> _stations_nearby_list;
2226
2234template <class T>
2235static void AddNearbyStation(TileIndex tile, TileArea *ctx)
2236{
2237 /* First check if there were deleted stations here */
2238 for (auto it = _deleted_stations_nearby.begin(); it != _deleted_stations_nearby.end(); /* nothing */) {
2239 if (it->tile == tile) {
2240 _stations_nearby_list.push_back(it->station);
2241 it = _deleted_stations_nearby.erase(it);
2242 } else {
2243 ++it;
2244 }
2245 }
2246
2247 /* Check if own station and if we stay within station spread */
2248 if (!IsTileType(tile, TileType::Station)) return;
2249
2250 StationID sid = GetStationIndex(tile);
2251
2252 /* This station is (likely) a waypoint */
2253 if (!T::IsValidID(sid)) return;
2254
2255 const BaseStation *st = BaseStation::Get(sid);
2256 if (st->owner != _local_company || std::ranges::find(_stations_nearby_list, sid) != _stations_nearby_list.end()) return;
2257
2258 if (CheckStationSpread(st->spread, *ctx).Succeeded()) {
2259 _stations_nearby_list.push_back(sid);
2260 }
2261}
2262
2272template <class T>
2273static void FindStationsNearby(TileArea ta, bool distant_join)
2274{
2275 TileArea ctx = ta;
2276
2277 _stations_nearby_list.clear();
2278 _stations_nearby_list.push_back(NEW_STATION);
2279 _deleted_stations_nearby.clear();
2280
2281 /* Look for deleted stations */
2282 for (const BaseStation *st : BaseStation::Iterate()) {
2283 if (T::IsValidBaseStation(st) && !st->IsInUse() && st->owner == _local_company) {
2284 /* Include only within station spread (yes, it is strictly less than) */
2285 if (std::max(DistanceMax(ta.tile, st->xy), DistanceMax(TileAddXY(ta.tile, ta.w - 1, ta.h - 1), st->xy)) < _settings_game.station.station_spread) {
2286 _deleted_stations_nearby.emplace_back(st->xy, st->index);
2287
2288 /* Add the station when it's within where we're going to build */
2289 if (IsInsideBS(TileX(st->xy), TileX(ctx.tile), ctx.w) &&
2290 IsInsideBS(TileY(st->xy), TileY(ctx.tile), ctx.h)) {
2291 AddNearbyStation<T>(st->xy, &ctx);
2292 }
2293 }
2294 }
2295 }
2296
2297 /* Add stations that are within station tile area. Stations do not have to occupy all tiles */
2298 for (auto t : ta) {
2299 AddNearbyStation<T>(t, &ctx);
2300 }
2301
2302 /* Only search tiles where we have a chance to stay within the station spread.
2303 * The complete check needs to be done in the callback as we don't know the
2304 * extent of the found station, yet. */
2305 if (distant_join && std::min(ta.w, ta.h) >= _settings_game.station.station_spread) return;
2306 uint max_dist = distant_join ? _settings_game.station.station_spread - std::min(ta.w, ta.h) : 1;
2307
2308 for (auto tile : SpiralTileSequence(TileAddByDir(ctx.tile, Direction::N), max_dist, ta.w, ta.h)) {
2309 AddNearbyStation<T>(tile, &ctx);
2310 }
2311}
2312
2313static constexpr std::initializer_list<NWidgetPart> _nested_select_station_widgets = {
2316 NWidget(WWT_CAPTION, Colours::DarkGreen, WID_JS_CAPTION), SetStringTip(STR_JOIN_STATION_CAPTION, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
2318 EndContainer(),
2324 EndContainer(),
2325 EndContainer(),
2326};
2327
2332template <class T>
2333struct SelectStationWindow : Window {
2334 StationPickerCmdProc select_station_proc{};
2336 Scrollbar *vscroll = nullptr;
2337
2338 SelectStationWindow(WindowDesc &desc, TileArea ta, StationPickerCmdProc&& proc) :
2339 Window(desc),
2340 select_station_proc(std::move(proc)),
2341 area(ta)
2342 {
2343 this->CreateNestedTree();
2344 this->vscroll = this->GetScrollbar(WID_JS_SCROLLBAR);
2345 this->GetWidget<NWidgetCore>(WID_JS_CAPTION)->SetString(T::IsWaypoint() ? STR_JOIN_WAYPOINT_CAPTION : STR_JOIN_STATION_CAPTION);
2346 this->FinishInitNested(0);
2347 this->OnInvalidateData(0);
2348
2349 _thd.freeze = true;
2350 }
2351
2352 void Close([[maybe_unused]] int data = 0) override
2353 {
2354 SetViewportCatchmentSpecializedStation<typename T::StationType>(nullptr, true);
2355
2356 _thd.freeze = false;
2357 this->Window::Close();
2358 }
2359
2360 void UpdateWidgetSize(WidgetID widget, Dimension &size, [[maybe_unused]] const Dimension &padding, [[maybe_unused]] Dimension &fill, [[maybe_unused]] Dimension &resize) override
2361 {
2362 if (widget != WID_JS_PANEL) return;
2363
2364 /* Determine the widest string */
2365 Dimension d = GetStringBoundingBox(T::IsWaypoint() ? STR_JOIN_WAYPOINT_CREATE_SPLIT_WAYPOINT : STR_JOIN_STATION_CREATE_SPLIT_STATION);
2366 for (const auto &station : _stations_nearby_list) {
2367 if (station == NEW_STATION) continue;
2368 const BaseStation *st = BaseStation::Get(station);
2369 d = maxdim(d, GetStringBoundingBox(T::IsWaypoint()
2370 ? GetString(STR_STATION_LIST_WAYPOINT, st->index)
2371 : GetString(STR_STATION_LIST_STATION, st->index, st->facilities)));
2372 }
2373
2374 fill.height = resize.height = d.height;
2375 d.height *= 5;
2376 d.width += padding.width;
2377 d.height += padding.height;
2378 size = d;
2379 }
2380
2381 void DrawWidget(const Rect &r, WidgetID widget) const override
2382 {
2383 if (widget != WID_JS_PANEL) return;
2384
2385 Rect tr = r.Shrink(WidgetDimensions::scaled.framerect);
2386 auto [first, last] = this->vscroll->GetVisibleRangeIterators(_stations_nearby_list);
2387 for (auto it = first; it != last; ++it, tr.top += this->resize.step_height) {
2388 if (*it == NEW_STATION) {
2389 DrawString(tr, T::IsWaypoint() ? STR_JOIN_WAYPOINT_CREATE_SPLIT_WAYPOINT : STR_JOIN_STATION_CREATE_SPLIT_STATION);
2390 } else {
2391 const BaseStation *st = BaseStation::Get(*it);
2392 DrawString(tr, T::IsWaypoint()
2393 ? GetString(STR_STATION_LIST_WAYPOINT, st->index)
2394 : GetString(STR_STATION_LIST_STATION, st->index, st->facilities));
2395 }
2396 }
2397
2398 }
2399
2400 void OnClick([[maybe_unused]] Point pt, WidgetID widget, [[maybe_unused]] int click_count) override
2401 {
2402 if (widget != WID_JS_PANEL) return;
2403
2404 auto it = this->vscroll->GetScrolledItemFromWidget(_stations_nearby_list, pt.y, this, WID_JS_PANEL, WidgetDimensions::scaled.framerect.top);
2405 if (it == _stations_nearby_list.end()) return;
2406
2407 /* Execute stored Command */
2408 this->select_station_proc(false, *it);
2409
2410 /* Close Window; this might cause double frees! */
2411 CloseWindowById(WindowClass::JoinStation, 0);
2412 }
2413
2414 void OnRealtimeTick([[maybe_unused]] uint delta_ms) override
2415 {
2416 if (_thd.dirty & 2) {
2417 _thd.dirty &= ~2;
2418 this->SetDirty();
2419 }
2420 }
2421
2422 void OnResize() override
2423 {
2424 this->vscroll->SetCapacityFromWidget(this, WID_JS_PANEL, WidgetDimensions::scaled.framerect.Vertical());
2425 }
2426
2432 void OnInvalidateData([[maybe_unused]] int data = 0, [[maybe_unused]] bool gui_scope = true) override
2433 {
2434 if (!gui_scope) return;
2435 FindStationsNearby<T>(this->area, true);
2436 this->vscroll->SetCount(_stations_nearby_list.size());
2437 this->SetDirty();
2438 }
2439
2440 void OnMouseOver([[maybe_unused]] Point pt, WidgetID widget) override
2441 {
2442 if (widget != WID_JS_PANEL) {
2443 SetViewportCatchmentSpecializedStation<typename T::StationType>(nullptr, true);
2444 return;
2445 }
2446
2447 /* Show coverage area of station under cursor */
2448 auto it = this->vscroll->GetScrolledItemFromWidget(_stations_nearby_list, pt.y, this, WID_JS_PANEL, WidgetDimensions::scaled.framerect.top);
2449 const typename T::StationType *st = it == _stations_nearby_list.end() || *it == NEW_STATION ? nullptr : T::StationType::Get(*it);
2450 SetViewportCatchmentSpecializedStation<typename T::StationType>(st, true);
2451 }
2452};
2453
2456 WindowPosition::Automatic, "build_station_join", 200, 180,
2457 WindowClass::JoinStation, WindowClass::None,
2459 _nested_select_station_widgets
2460);
2461
2462
2468static bool StationJoinerNeeded(const StationPickerCmdProc &proc)
2469{
2470 /* Only show selection if distant join is enabled in the settings */
2471 if (!_settings_game.station.distant_join_stations) return false;
2472
2473 /* If a window is already opened and we didn't ctrl-click,
2474 * return true (i.e. just flash the old window) */
2475 Window *selection_window = FindWindowById(WindowClass::JoinStation, 0);
2476 if (selection_window != nullptr) {
2477 /* Abort current distant-join and start new one */
2478 selection_window->Close();
2480 }
2481
2482 /* only show the popup, if we press ctrl */
2483 if (!IsCtrlPressed()) return false;
2484
2485 /* Now check if we could build there */
2486 return proc(true, StationID::Invalid());
2487}
2488
2495template <class T>
2496void ShowSelectBaseStationIfNeeded(TileArea ta, StationPickerCmdProc&& proc)
2497{
2498 if (StationJoinerNeeded(proc)) {
2499 if (!_settings_client.gui.persistent_buildingtools) ResetObjectToPlace();
2500 FindStationsNearby<T>(ta, false);
2501 new SelectStationWindow<T>(_select_station_desc, ta, std::move(proc));
2502 } else {
2503 proc(false, StationID::Invalid());
2504 }
2505}
2506
2512void ShowSelectStationIfNeeded(TileArea ta, StationPickerCmdProc proc)
2513{
2515}
2516
2522void ShowSelectRailWaypointIfNeeded(TileArea ta, StationPickerCmdProc proc)
2523{
2525}
2526
2532void ShowSelectRoadWaypointIfNeeded(TileArea ta, StationPickerCmdProc proc)
2533{
2535}
@ AirportClosed
Dummy block for indicating a closed airport.
Definition airport.h:131
constexpr bool HasBit(const T x, const uint8_t y)
Checks if a bit in a value is set.
static constexpr CargoType INVALID_CARGO
Invalid marker for cargoes.
Definition cargo_type.h:83
EnumBitSet< CargoType, uint64_t > CargoTypes
Bitset of CargoType elements.
Definition cargo_type.h:115
static constexpr CargoType NUM_CARGO
Maximum number of cargo types in a game.
Definition cargo_type.h:77
CargoType
Cargo slots to indicate a cargo type within a game.
Definition cargo_type.h:22
Dimension GetLargestCargoIconSize()
Get dimensions of largest cargo icon.
std::span< const CargoSpec * > _sorted_standard_cargo_specs
Standard cargo specifications sorted alphabetically by name.
std::vector< const CargoSpec * > _sorted_cargo_specs
Cargo specifications sorted alphabetically by name.
CargoTypes _cargo_mask
Bitmask of cargo types available.
Definition cargotype.cpp:30
Types/functions related to cargoes.
@ Passengers
Passengers.
Definition cargotype.h:50
bool IsCargoInClass(CargoType cargo, CargoClasses cc)
Does a given cargo have any cargo class from cc.
Definition cargotype.h:288
uint Count() const
Count the number of set bits.
constexpr bool Test(Tvalue_type value) const
Test if the value-th bit is set.
constexpr bool None() const
Test if none of the values are set.
constexpr Timpl & Flip()
Flip all bits.
constexpr Timpl & Reset()
Reset all bits.
constexpr Timpl & Set()
Set all bits.
auto begin() const
Returns an iterator to begin of the set bits.
constexpr bool Any(const Timpl &other) const
Test if any of the given values are set.
A cargo data entry representing one possible row in the station view window's top part.
uint count
sum of counts of all children or amount of cargo for this entry.
void Clear()
Delete all subentries, reset count and num_children and adapt parent's count.
StationID GetStation() const
Get the station ID for this entry.
void IncrementSize()
Increment.
void SetTransfers(bool value)
Set the transfers state.
~CargoDataEntry()
Remove ourselves from our parent.
CargoType GetCargo() const
Get the cargo type for this entry.
uint num_children
the number of subentries belonging to this entry.
void Remove(CargoType cargo)
Remove a child associated with the given cargo.
CargoDataEntry * Retrieve(StationID station) const
Retrieve a child for the given station.
uint GetCount() const
Get the cargo count for this entry.
CargoDataEntry * GetParent() const
Get the parent entry for this entry.
StationID station
ID of the station this entry is associated with.
CargoType cargo
ID of the cargo this entry is associated with.
CargoDataEntry & InsertOrRetrieve(StationID station)
Insert a new child or retrieve an existing child using a station ID as ID.
CargoDataEntry & InsertOrRetrieve(CargoType cargo)
Insert a new child or retrieve an existing child using a cargo type as ID.
CargoDataSet::iterator End() const
Get an iterator pointing to the end of the set of children.
void Update(uint count)
Update the count for this entry and propagate the change to the parent entry if there is one.
std::unique_ptr< CargoDataSet > children
the children of this entry.
bool transfers
If there are transfers for this cargo.
CargoDataSet::iterator Begin() const
Get an iterator pointing to the begin of the set of children.
bool HasTransfers() const
Has this entry transfers.
CargoDataEntry * Retrieve(CargoType cargo) const
Retrieve a child for the given cargo.
CargoDataEntry * parent
the parent of this entry.
void Remove(StationID station)
Remove a child associated with the given station.
uint GetNumChildren() const
Get the number of children for this entry.
const Tcont * Packets() const
Returns a pointer to the cargo packet list (so you can iterate over it etc).
StationCargoPacketMap::const_iterator ConstIterator
bool Succeeded() const
Did this command succeed?
The list of stations per company.
std::array< uint16_t, NUM_CARGO > stations_per_cargo_type
Number of stations with a rating for each cargo type.
static bool StationNameSorter(const Station *const &a, const Station *const &b, const CargoTypes &filter)
Sort stations by their name.
void UpdateWidgetSize(WidgetID widget, Dimension &size, const Dimension &padding, Dimension &fill, Dimension &resize) override
Update size and resize step of a widget in the window.
void OnEditboxChanged(WidgetID wid) override
The text in an editbox has been edited.
void OnResize() override
Called after the window got resized.
static bool StationWaitingAvailableSorter(const Station *const &a, const Station *const &b, const CargoTypes &filter)
Sort stations by their available waiting cargo.
void SortStationsList()
Sort the stations list.
void OnInvalidateData(int data=0, bool gui_scope=true) override
Some data on this window has become invalid.
StringFilter string_filter
Filter for name.
static const StringID sorter_names[]
Strings describing how stations are sorted.
void OnDropdownSelect(WidgetID widget, int index, int) override
A dropdown option associated to this window has been selected.
void OnClick(Point pt, WidgetID widget, int click_count) override
A click with the left mouse button has been made on the window.
static bool StationRatingMaxSorter(const Station *const &a, const Station *const &b, const CargoTypes &filter)
Sort stations by their rating.
std::string GetWidgetString(WidgetID widget, StringID stringid) const override
Get the raw string for a widget.
void OnPaint() override
The window must be repainted.
static bool StationWaitingTotalSorter(const Station *const &a, const Station *const &b, const CargoTypes &filter)
Sort stations by their waiting cargo.
void DrawWidget(const Rect &r, WidgetID widget) const override
Draw the contents of a nested widget.
QueryString name_editbox
Filter editbox.
static bool StationTypeSorter(const Station *const &a, const Station *const &b, const CargoTypes &filter)
Sort stations by their type.
void OnGameTick() override
Called once per (game) tick.
~CompanyStationsWindow() override
Save the last sorting state.
void BuildStationsList(const Owner owner)
(Re)Build station list
static const std::initializer_list< GUIStationList::SortFunction *const > sorter_funcs
Functions to sort stations.
uint16_t stations_per_cargo_type_no_rating
Number of stations without a rating.
static bool StationRatingMinSorter(const Station *const &a, const Station *const &b, const CargoTypes &filter)
Sort stations by their rating.
Drop down checkmark component.
Iterate a range of enum values.
Flow descriptions by origin stations.
List template of 'things' T to sort in a GUI.
void RebuildDone()
Notify the sortlist that the rebuild is done.
bool IsDescSortOrder() const
Check if the sort order is descending.
void ToggleSortOrder()
Toggle the sort order Since that is the worst condition for the sort function reverse the list here.
bool NeedRebuild() const
Check if a rebuild is needed.
void ForceRebuild()
Force that a rebuild is needed.
bool Sort(Comp compare)
Sort the list.
void ForceResort()
Force a resort next Sort call Reset the resort timer if used too.
uint8_t SortType() const
Get the sorttype of the list.
Listing GetListing() const
Export current sort conditions.
bool NeedResort()
Check if a resort is needed next loop If used the resort timer will decrease every call till 0.
void SetSortType(uint8_t n_type)
Set the sorttype of the list.
A connected component of a link graph.
Definition linkgraph.h:35
uint Monthly(uint base) const
Scale a value to its monthly equivalent, based on last compression.
Definition linkgraph.h:262
Baseclass for nested widgets.
Base class for a 'real' widget.
void SetString(StringID string)
Set string of the nested widget.
Definition widget.cpp:1190
void SetStringTip(StringID string, StringID tool_tip)
Set string and tool tip of the nested widget.
Definition widget.cpp:1200
uint16_t w
The width of the area.
TileIndex tile
The base tile of the area.
uint16_t h
The height of the area.
Scrollbar data structure.
size_type GetCapacity() const
Gets the number of visible elements of the scrollbar.
void SetCount(size_t num)
Sets the number of elements in the list.
auto GetScrolledItemFromWidget(Tcontainer &container, int clickpos, const Window *const w, WidgetID widget, int padding=0, int line_height=-1) const
Return an iterator pointing to the element of a scrolled widget that a user clicked in.
size_type GetScrolledRowFromWidget(int clickpos, const Window *const w, WidgetID widget, int padding=0, int line_height=-1) const
Compute the row of a scrolled widget that a user clicked in.
Definition widget.cpp:2474
void SetCapacityFromWidget(Window *w, WidgetID widget, int padding=0)
Set capacity of visible elements from the size and resize properties of a widget.
Definition widget.cpp:2548
size_type GetCount() const
Gets the number of elements in the list.
auto GetVisibleRangeIterators(Tcontainer &container) const
Get a pair of iterators for the range of visible elements in a container.
size_type GetPosition() const
Gets the position of the first visible element in the list.
Generate TileIndices around a center tile or tile area, with increasing distance.
CargoList that is used for stations.
uint ReservedCount() const
Returns sum of cargo reserved for loading onto vehicles.
static bool UsingWallclockUnits(bool newgame=false)
Check if we are using wallclock units.
static WidgetDimensions scaled
Widget dimensions scaled for current zoom level.
Definition window_gui.h:30
Functions related to commands.
Definition of stuff that is very close to a company, like the company struct itself.
CompanyID _local_company
Company controlled by the human player at this client. Can also be COMPANY_SPECTATOR.
Functions related to companies.
static constexpr Owner OWNER_NONE
The tile has no ownership.
Functions related to debugging.
#define Debug(facility, severity, format_string,...)
Output a line of debugging information.
Definition debug.h:36
@ Misc
Misc message facility.
Definition debug_type.h:32
@ Notice
Notice.
Definition debug_type.h:18
void ShowDropDownMenu(Window *w, std::span< const StringID > strings, int selected, WidgetID button, uint32_t disabled_mask, uint32_t hidden_mask, uint width, DropDownOptions options, std::string *const persistent_filter_text)
Show a dropdown menu window near a widget of the parent window.
Definition dropdown.cpp:633
std::unique_ptr< DropDownListItem > MakeDropDownListDividerItem()
Creates new DropDownListDividerItem.
Definition dropdown.cpp:36
std::unique_ptr< DropDownListItem > MakeDropDownListStringItem(StringID str, int value, bool masked, bool shaded)
Creates new DropDownListStringItem.
Definition dropdown.cpp:49
void ShowDropDownList(Window *w, DropDownList &&list, int selected, WidgetID button, uint width, DropDownOptions options, std::string *const persistent_filter_text)
Show a drop down list.
Definition dropdown.cpp:591
Common drop down list components.
Functions related to the drop down widget.
Types related to the drop down widget.
std::vector< std::unique_ptr< const DropDownListItem > > DropDownList
A drop down list is a collection of drop down list items.
@ Persist
Set if this dropdown should stay open after an option is selected.
@ Filterable
Set if the dropdown is filterable.
constexpr std::underlying_type_t< enum_type > to_underlying(enum_type e)
Implementation of std::to_underlying (from C++23).
Definition enum_type.hpp:21
int GetCharacterHeight(FontSize size)
Get height of a character for a given font size.
Definition fontcache.cpp:88
Dimension maxdim(const Dimension &d1, const Dimension &d2)
Compute bounding box of both dimensions.
Geometry functions.
int CentreBounds(int min, int max, int size)
Determine where to position a centred object.
Dimension GetStringBoundingBox(std::string_view str, FontSize start_fontsize)
Return the string dimension in pixels.
Definition gfx.cpp:894
Dimension GetStringListBoundingBox(std::span< const StringID > list, FontSize fontsize)
Get maximum dimension of a list of strings.
Definition gfx.cpp:933
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:1032
uint8_t GetCharacterWidth(FontSize size, char32_t key)
Return width of character glyph.
Definition gfx.cpp:1272
void GfxFillRect(int left, int top, int right, int bottom, const std::variant< PixelColour, PaletteID > &colour, FillRectMode mode)
Applies a certain FillRectMode-operation to a rectangle [left, right] x [top, bottom] on the screen.
Definition gfx.cpp:111
int DrawStringMultiLine(int left, int right, int top, int bottom, std::string_view str, ExtendedTextColour colour, Alignment align, bool underline, FontSize fontsize)
Draw string, possibly over multiple lines.
Definition gfx.cpp:782
int DrawString(int left, int right, int top, std::string_view str, ExtendedTextColour colour, Alignment align, bool underline, FontSize fontsize)
Draw string, possibly truncated to make it fit in its allocated space.
Definition gfx.cpp:663
bool IsCtrlPressed()
Test if the ctrl key is pressed.
Definition gfx_func.h:82
uint32_t SpriteID
The number of a sprite, without mapping bits and colourtables.
Definition gfx_type.h:17
@ Small
Index of the small font in the font tables.
Definition gfx_type.h:250
@ Normal
Index of the normal font in the font tables.
Definition gfx_type.h:249
@ Invalid
Invalid marker.
Definition gfx_type.h:302
@ Grey
Grey.
Definition gfx_type.h:299
@ DarkGreen
Dark green.
Definition gfx_type.h:292
TextColour
Colour of the strings, see _string_colourmap in table/string_colours.h or docs/ottd-colourtext-palett...
Definition gfx_type.h:315
@ Yellow
Yellow colour.
Definition gfx_type.h:326
@ Black
Black colour.
Definition gfx_type.h:334
constexpr NWidgetPart SetFill(uint16_t fill_x, uint16_t fill_y)
Widget part function for setting filling.
constexpr NWidgetPart SetSpriteTip(SpriteID sprite, StringID tip={})
Widget part function for setting the sprite and tooltip.
constexpr NWidgetPart SetScrollbar(WidgetID index)
Attach a scrollbar to a widget.
constexpr NWidgetPart SetStringTip(StringID string, StringID tip={})
Widget part function for setting the string and tooltip.
constexpr NWidgetPart SetAspect(float ratio, AspectFlags flags=AspectFlag::ResizeX)
Widget part function for setting the aspect ratio.
constexpr NWidgetPart SetMinimalSize(int16_t x, int16_t y)
Widget part function for setting the minimal size.
constexpr NWidgetPart SetToolTip(StringID tip)
Widget part function for setting tooltip and clearing the widget data.
constexpr NWidgetPart EndContainer()
Widget part function for denoting the end of a container (horizontal, vertical, WWT_FRAME,...
constexpr NWidgetPart SetTextStyle(TextColour colour, FontSize size=FontSize::Normal)
Widget part function for setting the text style.
constexpr NWidgetPart NWidget(WidgetType tp, Colours col, WidgetID idx=INVALID_WIDGET)
Widget part function for starting a new 'real' widget.
constexpr NWidgetPart SetResize(int16_t dx, int16_t dy)
Widget part function for setting the resize step.
void SetDirty() const
Mark entire window as dirty (in need of re-paint).
Definition window.cpp:1013
GUI functions that shouldn't be here.
void ShowExtraViewportWindow(TileIndex tile=INVALID_TILE)
Show a new Extra Viewport window.
Declaration of link graph classes used for cargo distribution.
@ Manual
Manual distribution. No link graph calculations are run.
#define Rect
Macro that prevents name conflicts between included headers.
#define Point
Macro that prevents name conflicts between included headers.
uint DistanceMax(TileIndex t0, TileIndex t1)
Gets the biggest distance component (x or y) between the two given tiles.
Definition map.cpp:200
TileIndex TileAddXY(TileIndex tile, int x, int y)
Adds a given offset to a tile.
Definition map_func.h:474
static TileIndex TileVirtXY(uint x, uint y)
Get a tile from the virtual XY-coordinate.
Definition map_func.h:407
TileIndex TileAddByDir(TileIndex tile, Direction dir)
Adds a Direction to a tile.
Definition map_func.h:603
static TileIndex TileXY(uint x, uint y)
Returns the TileIndex of a coordinate.
Definition map_func.h:376
static uint TileY(TileIndex tile)
Get the Y component of a tile.
Definition map_func.h:429
static uint TileX(TileIndex tile)
Get the X component of a tile.
Definition map_func.h:419
int DivideApprox(int a, int b)
Deterministic approximate division.
Definition math_func.cpp:22
constexpr bool IsInsideBS(const T x, const size_t base, const size_t size)
Checks if a value is between a window started at some base point.
constexpr uint CeilDiv(uint a, uint b)
Computes ceil(a / b) for non-negative a and b.
constexpr uint ToPercent8(uint i)
Converts a "fract" value 0..255 to "percent" value 0..100.
void ShowQueryString(std::string_view str, StringID caption, uint maxsize, Window *parent, CharSetFilter afilter, QueryStringFlags flags)
Show a query popup window with a textbox in it.
Types related to the misc widgets.
@ WID_QS_MOVE
Move button.
Definition misc_widget.h:39
static constexpr CargoType CF_EXPAND_LIST
Expand list to show all items (station list).
Definition cargo_type.h:104
static constexpr CargoType CF_NO_RATING
Show items with no rating (station list).
Definition cargo_type.h:102
static constexpr CargoType CF_SELECT_ALL
Select all items (station list).
Definition cargo_type.h:103
TextColour GetContrastColour(PixelColour background, uint8_t threshold)
Determine a contrasty text colour for a coloured background.
Definition palette.cpp:366
static constexpr PixelColour PC_GREEN
Green palette colour.
static constexpr PixelColour PC_RED
Red palette colour.
Base for the GUIs that have an edit box in them.
A number of safeguards to prevent using unsafe methods.
@ Invalid
broken savegame (used internally)
Definition saveload.h:438
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition settings.cpp:61
ClientSettings _settings_client
The current settings for this game.
Definition settings.cpp:60
Base types for having sorted lists in GUIs.
void SndClickBeep()
Play a beep sound for a click event if enabled in settings.
Definition sound.cpp:252
Functions related to sound.
CommandCost CheckStationSpread(TileArea area, const TileArea &new_area)
Check if adding a new area to a station will exceed the maximum station spread.
Definition station.cpp:526
Base classes/functions for stations.
std::pair< CargoArray, CargoTypes > GetAcceptanceAroundTiles(TileIndex center_tile, int w, int h, int rad)
Get the acceptance of cargoes around the tile in 1/8.
bool HasStationInUse(StationID station, bool include_company, CompanyID company)
Tests whether the company's vehicles have this station in orders.
CargoTypes GetAcceptanceMask(const Station *st)
Get a mask of the cargo types that the station accepts.
CargoArray GetProductionAroundTiles(TileIndex north_tile, int w, int h, int rad)
Get the cargo types being produced around the tile (in a rectangle).
Command definitions related to stations.
Functions related to stations.
static void StationsWndShowStationRating(int left, int right, int y, CargoType cargo, uint amount, uint8_t rating)
Draw small boxes of cargo amount and ratings data at the given coordinates.
void ShowSelectStationIfNeeded(TileArea ta, StationPickerCmdProc proc)
Show the station selection window when needed.
CargoSortType
Ways of sorting cargo in the UI.
@ StationID
by station id
@ CargoType
by cargo type
@ AsGrouping
by the same principle the entries are being grouped
@ StationString
by station name
@ Count
by amount of cargo
void ShowSelectRailWaypointIfNeeded(TileArea ta, StationPickerCmdProc proc)
Show the rail waypoint selection window when needed.
void FindStationsAroundSelection()
Find stations adjacent to the current tile highlight area, so that existing coverage area can be draw...
static bool StationJoinerNeeded(const StationPickerCmdProc &proc)
Check whether we need to show the station selection window.
int DrawStationCoverageAreaText(const Rect &r, StationCoverageType sct, int rad, bool supplies)
Calculates and draws the accepted or supplied cargo around the selected tile(s).
void ShowStationViewWindow(StationID station)
Opens StationViewWindow for given station.
void CheckRedrawStationCoverage(const Window *w)
Check whether we need to redraw the station coverage text.
static WindowDesc _select_station_desc(WindowPosition::Automatic, "build_station_join", 200, 180, WindowClass::JoinStation, WindowClass::None, WindowDefaultFlag::Construction, _nested_select_station_widgets)
Window definition for the station selection window for (distant) joining.
void ShowCompanyStations(CompanyID company)
Opens window with list of company's stations.
void ShowSelectBaseStationIfNeeded(TileArea ta, StationPickerCmdProc &&proc)
Show the station selection window when needed.
static WindowDesc _station_view_desc(WindowPosition::Automatic, "view_station", 249, 117, WindowClass::StationView, WindowClass::None, {}, _nested_station_view_widgets)
Window definition for the station view window.
static void FindStationsNearby(TileArea ta, bool distant_join)
Circulate around the to-be-built station to find stations we could join.
static WindowDesc _company_stations_desc(WindowPosition::Automatic, "list_stations", 358, 162, WindowClass::StationList, WindowClass::None, {}, _nested_company_stations_widgets)
Window definition for the company stations window.
static void AddNearbyStation(TileIndex tile, TileArea *ctx)
Add station on this tile to _stations_nearby_list if it's fully within the station spread.
void ShowSelectRoadWaypointIfNeeded(TileArea ta, StationPickerCmdProc proc)
Show the road waypoint selection window when needed.
Contains enums and function declarations connected with stations GUI.
StationCoverageType
Types of cargo to display for station coverage.
Definition station_gui.h:20
@ SCT_NON_PASSENGERS_ONLY
Draw all non-passenger class cargoes.
Definition station_gui.h:22
@ SCT_PASSENGERS_ONLY
Draw only passenger class cargoes.
Definition station_gui.h:21
@ SCT_ALL
Draw all cargoes.
Definition station_gui.h:23
StationID GetStationIndex(Tile t)
Get StationID from a tile.
Definition station_map.h:26
StationFacility
The facilities a station might be having.
@ Dock
Station with a dock.
@ TruckStop
Station with truck stops.
@ Train
Station with train station.
@ Airport
Station with an airport.
@ BusStop
Station with bus stops.
EnumBitSet< StationFacility, uint8_t > StationFacilities
Bitset of StationFacility elements.
static const uint MAX_LENGTH_STATION_NAME_CHARS
The maximum length of a station name in characters including '\0'.
Types related to the station widgets.
@ WID_JS_CAPTION
Caption of the window.
@ WID_JS_PANEL
Main panel.
@ WID_JS_SCROLLBAR
Scrollbar of the panel.
@ WID_SV_CLOSE_AIRPORT
'Close airport' button.
@ WID_SV_SORT_ORDER
'Sort order' button
@ WID_SV_CATCHMENT
Toggle catchment area highlight.
@ WID_SV_ROADVEHS
List of scheduled road vehs button.
@ WID_SV_SCROLLBAR
Scrollbar.
@ WID_SV_CAPTION
Caption of the window.
@ WID_SV_GROUP
label for "group by"
@ WID_SV_RENAME
'Rename' button.
@ WID_SV_SORT_BY
'Sort by' button
@ WID_SV_GROUP_BY
'Group by' button
@ WID_SV_PLANES
List of scheduled planes button.
@ WID_SV_ACCEPT_RATING_LIST
List of accepted cargoes / rating of cargoes.
@ WID_SV_WAITING
List of waiting cargo.
@ WID_SV_SHIPS
List of scheduled ships button.
@ WID_SV_LOCATION
'Location' button.
@ WID_SV_TRAINS
List of scheduled trains button.
@ WID_SV_ACCEPTS_RATINGS
'Accepts' / 'Ratings' button.
@ WID_SV_CLOSE_AIRPORT_SEL
Container for 'close airport' button, which can be hidden.
@ WID_STL_CAPTION
Caption of the window.
@ WID_STL_TRUCK
'TRUCK' button - list only facilities where is a truck stop.
@ WID_STL_SCROLLBAR
Scrollbar next to the main panel.
@ WID_STL_SORTDROPBTN
Dropdown button.
@ WID_STL_SORTBY
'Sort by' button - reverse sort direction.
@ WID_STL_TRAIN
'TRAIN' button - list only facilities where is a railroad station.
@ WID_STL_BUS
'BUS' button - list only facilities where is a bus stop.
@ WID_STL_FACILALL
'ALL' button - list all facilities.
@ WID_STL_LIST
The main panel, list of stations.
@ WID_STL_SHIP
'SHIP' button - list only facilities where is a dock.
@ WID_STL_FILTER
Filter of name.
@ WID_STL_CARGODROPDOWN
Cargo type dropdown list.
@ WID_STL_AIRPLANE
'AIRPLANE' button - list only facilities where is an airport.
Definition of base types and functions in a cross-platform compatible way.
int StrNaturalCompare(std::string_view s1, std::string_view s2, bool ignore_garbage_at_front)
Compares two strings using case insensitive natural sort.
Definition string.cpp:428
Functions related to low-level strings.
@ CS_ALPHANUMERAL
Both numeric and alphabetic and spaces and stuff.
Definition string_type.h:25
std::string GetString(StringID string)
Resolve the given StringID into a std::string with formatting but no parameters.
Definition strings.cpp:423
TextDirection _current_text_dir
Text direction of the currently selected language.
Definition strings.cpp:55
Functions related to OTTD's strings.
StrongType::Typedef< uint32_t, struct StringIDTag, StrongType::Compare, StrongType::Integer > StringID
Numeric value that represents a string, independent of the selected language.
@ TD_RTL
Text is written right-to-left by default.
static const int MAX_CHAR_LENGTH
Max. length of UTF-8 encoded unicode character.
AirportBlocks blocks
stores which blocks on the airport are taken. was 16 bit earlier on, then 32
Base class for all station-ish types.
TileIndex xy
Base tile of the station.
StationFacilities facilities
The facilities that this station has.
Owner owner
The owner of this station.
Town * town
The town this station is associated with.
TileArea spread
NOSAVE: Station spread tile area.
Class for storing amounts of cargo.
Definition cargo_type.h:120
Container for cargo from the same location and time.
Definition cargopacket.h:40
uint16_t Count() const
Gets the number of 'items' in this packet.
StationID GetFirstStation() const
Gets the ID of the station where the cargo was loaded for the first time.
Specification of a cargo type.
Definition cargotype.h:76
static CargoSpec * Get(size_t index)
Retrieve cargo details for the given cargo type.
Definition cargotype.h:140
StringID abbrev
Two letter abbreviation for this cargo type.
Definition cargotype.h:97
SpriteID GetCargoIcon() const
Get sprite for showing cargo of this type.
PixelColour rating_colour
Colour used for box representing the amount of cargo waiting at the station in the station rating vie...
Definition cargotype.h:80
bool IsValid() const
Tests for validity of this cargospec.
Definition cargotype.h:120
CargoTypes cargoes
bitmap of cargo types to include
StationFacilities facilities
types of stations of interest
bool include_no_rating
Whether we should include stations with no cargo rating.
Dimensions (a width and height) of a rectangle in 2D.
value_type height
The height of the rectangle.
value_type width
The width of the rectangle.
FlowStatMap flows
Planned flows through this station.
StationCargoList cargo
The cargo packets of cargo waiting in this station.
Stores station stats for a single cargo.
bool HasRating() const
Does this cargo have a rating at this station?
NodeID node
ID of node in link graph referring to this goods entry.
const GoodsEntryData & GetData() const
Get optional cargo packet/flow data.
LinkGraphID link_graph
Link graph this station belongs to.
uint8_t rating
Station rating for this cargo.
bool HasData() const
Test if this goods entry has optional cargo packet/flow data.
Data structure describing how to show the list (what sort direction and criteria).
static uint MaxY()
Gets the maximum Y coordinate within the map, including TileType::Void.
Definition map_func.h:298
static uint MaxX()
Gets the maximum X coordinate within the map, including TileType::Void.
Definition map_func.h:289
static uint Size()
Get the size of the map.
Definition map_func.h:280
Colour for pixel/line drawing.
Definition gfx_type.h:307
static Pool::IterateWrapper< BaseStation > Iterate(size_t from=0)
static BaseStation * Get(auto index)
static LinkGraph * GetIfValid(auto index)
Data stored about a string that can be modified in the GUI.
static const int ACTION_CLEAR
Clear editbox.
Specification of a rectangle with absolute coordinates of all edges.
Rect WithWidth(int width, bool end) const
Copy Rect and set its width.
int Width() const
Get width of Rect.
Rect Shrink(int s) const
Copy and shrink Rect by s pixels.
Rect Indent(int indent, bool end) const
Copy Rect and indent it from its position.
Window for selecting stations/waypoints to (distant) join to.
void DrawWidget(const Rect &r, WidgetID widget) const override
Draw the contents of a nested widget.
void OnRealtimeTick(uint delta_ms) override
Called periodically.
void OnClick(Point pt, WidgetID widget, int click_count) override
A click with the left mouse button has been made on the window.
void OnInvalidateData(int data=0, bool gui_scope=true) override
Some data on this window has become invalid.
void OnResize() override
Called after the window got resized.
void Close(int data=0) override
Hide the window and all its child windows, and mark them for a later deletion.
void OnMouseOver(Point pt, WidgetID widget) override
The mouse is currently moving over the window or has just moved outside of the window.
TileArea area
Location of new station.
void UpdateWidgetSize(WidgetID widget, Dimension &size, const Dimension &padding, Dimension &fill, Dimension &resize) override
Update size and resize step of a widget in the window.
static bool IsExpected(const BaseStation *st)
static Pool::IterateWrapper< Station > Iterate(size_t from=0)
static Waypoint * Get(auto index)
static Waypoint * From(BaseStation *st)
A row being displayed in the cargo view (as opposed to being "hidden" behind a plus sign).
StationID next_station
ID of the station belonging to the entry actually displayed if it's to/from/via.
CargoDataEntry * filter
Parent of the cargo entry belonging to the row.
CargoType next_cargo
ID of the cargo belonging to the entry actually displayed if it's cargo.
The StationView window.
void HandleCargoWaitingClick(int row)
Handle a click on a specific row in the cargo view.
int DrawEntries(CargoDataEntry &entry, const Rect &r, int pos, int maxrows, int column, CargoType cargo=INVALID_CARGO)
Draw the given cargo entries in the station GUI.
void OnQueryTextFinished(std::optional< std::string > str) override
The query window opened from this window has closed.
void OnDropdownSelect(WidgetID widget, int index, int) override
A dropdown option associated to this window has been selected.
Mode
Display mode of the cargo view.
@ MODE_PLANNED
Show cargo planned to pass through the station.
@ MODE_WAITING
Show cargo waiting at the station.
std::array< Grouping, NUM_COLUMNS > groupings
Grouping modes for the different columns.
void EstimateDestinations(CargoType cargo, StationID source, StationID next, uint count, CargoDataEntry &dest)
Estimate the amounts of cargo per final destination for a given cargo, source station and next hop an...
void SelectSortBy(int index)
Select a new sort criterium for the cargo view.
void OnResize() override
Called after the window got resized.
StringID SearchNonStop(CargoDataEntry &cd, StationID station, int column)
Determine if we need to show the special "non-stop" string.
void Close(int data=0) override
Hide the window and all its child windows, and mark them for a later deletion.
Grouping
Type of grouping used in each of the "columns".
@ GR_SOURCE
Group by source of cargo ("from").
@ GR_NEXT
Group by next station ("via").
@ GR_CARGO
Group by cargo type.
@ GR_DESTINATION
Group by estimated final destination ("to").
void BuildCargoList(CargoType cargo, const StationCargoList &packets, CargoDataEntry *entry)
Build up the cargo view for WAITING mode and a specific cargo.
int DrawCargoRatings(const Rect &r) const
Draw cargo ratings in the WID_SV_ACCEPT_RATING_LIST widget.
static const int NUM_COLUMNS
Number of "columns" in the cargo view: cargo, from, via, to.
void OnInit() override
Notification that the nested widget tree gets initialized.
void RecalcDestinations(CargoType cargo)
Rebuild the cache for estimated destinations which is used to quickly show the "destination" entries ...
int line_height
Height of a cargo line.
Dimension cargo_icon_size
Size of largest cargo icon.
Invalidation
Type of data invalidation.
@ INV_FLOWS
The planned flows have been recalculated and everything has to be updated.
@ INV_CARGO
Some cargo has been added or removed.
void BuildCargoList(CargoDataEntry *entry, const Station *st)
Build up the cargo view for all cargoes.
void SelectSortOrder(SortOrder order)
Select a new sort order for the cargo view.
CargoDataEntry expanded_rows
Parent entry of currently expanded rows.
void OnPaint() override
The window must be repainted.
static constexpr uint RATING_LINES
Height in lines of the cargo ratings view.
CargoDataVector displayed_rows
Parent entry of currently displayed rows (including collapsed ones).
static const StringID group_names[]
Names of the grouping options in the dropdown.
int grouping_index
Currently selected entry in the grouping drop down.
void UpdateWidgetSize(WidgetID widget, Dimension &size, const Dimension &padding, Dimension &fill, Dimension &resize) override
Update size and resize step of a widget in the window.
static constexpr uint ACCEPTS_LINES
Height in lines of the accepted cargo view.
void OnInvalidateData(int data=0, bool gui_scope=true) override
Some data on this window has become invalid.
StringID GetEntryString(StationID station, StringID here, StringID other_station, StringID any) const
Select the correct string for an entry referring to the specified station.
std::array< CargoSortType, NUM_COLUMNS > sortings
Sort types of the different 'columns'.
void SetDisplayedRow(const CargoDataEntry &entry)
Mark a specific row, characterized by its CargoDataEntry, as expanded.
std::string GetWidgetString(WidgetID widget, StringID stringid) const override
Get the raw string for a widget.
std::array< SortOrder, NUM_COLUMNS > sort_orders
Sort order (ascending/descending) for the 'columns'.
uint expand_shrink_width
The width allocated to the expand/shrink 'button'.
void HandleCargoWaitingClick(CargoDataEntry *filter, Tid next)
Expand or collapse a specific row.
int rating_lines
Number of lines in the cargo ratings view.
static const StringID sort_names[]
Names of the sorting options in the dropdown.
void DrawCargoIcons(CargoType cargo, uint waiting, const Rect &r) const
Draw icons of waiting cargo.
CargoDataEntry cached_destinations
Cache for the flows passing through this station.
int scroll_to_row
If set, scroll the main viewport to the station pointed to by this row.
Mode current_mode
Currently selected display mode of cargo view.
int accepts_lines
Number of lines in the accepted cargo view.
void BuildFlowList(CargoType cargo, const FlowStatMap &flows, CargoDataEntry *entry)
Build up the cargo view for PLANNED mode and a specific cargo.
void SelectGroupBy(int index)
Select a new grouping mode for the cargo view.
void OnClick(Point pt, WidgetID widget, int click_count) override
A click with the left mouse button has been made on the window.
int DrawAcceptedCargo(const Rect &r) const
Draw accepted cargo in the WID_SV_ACCEPT_RATING_LIST widget.
void ShowCargo(CargoDataEntry *data, CargoType cargo, StationID source, StationID next, StationID dest, uint count)
Show a certain cargo entry characterized by source/next/dest station, cargo type and amount of cargo ...
Station data structure.
std::array< GoodsEntry, NUM_CARGO > goods
Goods at this station.
Airport airport
Tile area the airport covers.
String filter and state.
void SetFilterTerm(std::string_view str)
Set the term to filter on.
void ResetState()
Reset the matching state to process a new item.
bool GetState() const
Get the matching state of the current item.
std::string_view GetText() const
Get the current text.
Definition textbuf.cpp:283
Struct containing TileIndex and StationID.
TileIndex tile
TileIndex.
StationID station
StationID.
CompanyID exclusivity
which company has exclusivity
Definition town.h:87
uint8_t exclusive_counter
months till the exclusivity expires
Definition town.h:88
The information about a vehicle list.
Definition vehiclelist.h:32
Representation of a waypoint.
High level window description.
Definition window_gui.h:171
Number to differentiate different windows of the same class.
Data structure for an opened window.
Definition window_gui.h:272
void ReInit(int rx=0, int ry=0, bool reposition=false)
Re-initialize a window, and optionally change its size.
Definition window.cpp:1025
void CloseChildWindows(WindowClass wc=WindowClass::Invalid) const
Close all children a window might have in a head-recursive manner.
Definition window.cpp:1122
virtual void Close(int data=0)
Hide the window and all its child windows, and mark them for a later deletion.
Definition window.cpp:1150
static int SortButtonWidth()
Get width of up/down arrow of sort button state.
Definition widget.cpp:839
void FinishInitNested(WindowNumber window_number=0)
Perform the second part of the initialization of a nested widget tree.
Definition window.cpp:1855
void DrawWidgets() const
Paint all widgets of a window.
Definition widget.cpp:792
void InvalidateData(int data=0, bool gui_scope=true)
Mark this window's data as invalid (in need of re-computing).
Definition window.cpp:3317
Window * parent
Parent window.
Definition window_gui.h:327
void RaiseWidget(WidgetID widget_index)
Marks a widget as raised.
Definition window_gui.h:468
void SetWidgetDirty(WidgetID widget_index) const
Invalidate a widget, i.e.
Definition window.cpp:565
virtual std::string GetWidgetString(WidgetID widget, StringID stringid) const
Get the raw string for a widget.
Definition window.cpp:513
ResizeInfo resize
Resize information.
Definition window_gui.h:313
void DrawSortButton(WidgetID widget, bool descending) const
Draw a sort button's up or down arrow symbol.
Definition widget.cpp:824
void CreateNestedTree()
Perform the first part of the initialization of a nested widget tree.
Definition window.cpp:1845
WindowClass window_class
Window class.
Definition window_gui.h:300
bool IsWidgetLowered(WidgetID widget_index) const
Gets the lowered state of a widget.
Definition window_gui.h:490
Owner owner
The owner of the content shown in this window. Company colour is acquired from this variable.
Definition window_gui.h:315
void SetWidgetLoweredState(WidgetID widget_index, bool lowered_stat)
Sets the lowered/raised status of a widget.
Definition window_gui.h:440
bool IsShaded() const
Is window shaded currently?
Definition window_gui.h:561
void SetTimeout()
Set the timeout flag of the window and initiate the timer.
Definition window_gui.h:354
Window(WindowDesc &desc)
Empty constructor, initialization has been moved to InitNested() called from the constructor of the d...
Definition window.cpp:1879
const NWID * GetWidget(WidgetID widnum) const
Get the nested widget with number widnum from the nested widget tree.
void LowerWidget(WidgetID widget_index)
Marks a widget as lowered.
Definition window_gui.h:459
const Scrollbar * GetScrollbar(WidgetID widnum) const
Return the Scrollbar to a widget index.
Definition window.cpp:322
void SetWidgetDisabledState(WidgetID widget_index, bool disab_stat)
Sets the enabled/disabled status of a widget.
Definition window_gui.h:380
int width
width of the window (number of pixels to the right in x direction)
Definition window_gui.h:310
void ToggleWidgetLoweredState(WidgetID widget_index)
Invert the lowered/raised status of a widget.
Definition window_gui.h:449
WindowNumber window_number
Window number within the window class.
Definition window_gui.h:301
Stuff related to the text buffer GUI.
@ EnableMove
enable the 'Move' button
Definition textbuf_gui.h:22
@ EnableDefault
enable the 'Default' button ("\0" is returned)
Definition textbuf_gui.h:20
@ LengthIsInChars
the length of the string is counted in characters
Definition textbuf_gui.h:21
static bool IsTileType(Tile tile, TileType type)
Checks if a tile is a given tiletype.
Definition tile_map.h:150
Owner GetTileOwner(Tile tile)
Returns the owner of a tile.
Definition tile_map.h:178
StrongType::Typedef< uint32_t, struct TileIndexTag, StrongType::Compare, StrongType::Integer, StrongType::Compatible< int32_t >, StrongType::Compatible< int64_t > > TileIndex
The index/ID of a Tile.
Definition tile_type.h:92
constexpr TileIndex INVALID_TILE
The very nice invalid tile marker.
Definition tile_type.h:100
static constexpr uint TILE_SIZE
Tile size in world coordinates.
Definition tile_type.h:15
@ Station
A tile of a station or airport.
Definition tile_type.h:54
OrthogonalTileArea TileArea
Shorthand for the much more common orthogonal tile area.
Type for iterating a sprial tile area.
Functions related to tile highlights.
void ResetObjectToPlace()
Reset the cursor and mouse mode handling back to default (normal cursor, only clicking in windows).
void UpdateTileSelection()
Updates tile highlighting for all cases.
@ HT_RECT
rectangle (stations, depots, ...)
Base of the town class.
Functions related to the vehicle's GUIs.
VehicleType
Available vehicle types.
@ Ship
Ship vehicle type.
@ Aircraft
Aircraft vehicle type.
@ Road
Road vehicle type.
@ Train
Train vehicle type.
Functions and type for generating vehicle lists.
@ Station
Index is the station.
Definition vehiclelist.h:25
bool ScrollMainWindowToTile(TileIndex tile, bool instant)
Scrolls the viewport of the main window to a given location.
void SetViewportStationRect(const Station *st, bool sel)
Select or deselect station for rectangle area highlight.
void SetViewportCatchmentStation(const Station *st, bool sel)
Select or deselect station for coverage area highlight.
void SetViewportWaypointRect(const Waypoint *wp, bool sel)
Select or deselect waypoint for rectangle area highlight.
const Station * _viewport_highlight_station
Currently selected station for coverage area highlight.
Functions related to (drawing on) viewports.
Base of waypoints.
@ WPF_ROAD
This is a road waypoint.
static RectPadding ScaleGUITrad(const RectPadding &r)
Scale a RectPadding to GUI zoom level.
Definition widget.cpp:49
@ WWT_PUSHTXTBTN
Normal push-button (no toggle button) with text caption.
@ WWT_PUSHIMGBTN
Normal push-button (no toggle button) with image caption.
@ WWT_EDITBOX
a textbox for typing
Definition widget_type.h:62
@ NWID_HORIZONTAL
Horizontal container.
Definition widget_type.h:66
@ WWT_TEXTBTN
(Toggle) Button with text
Definition widget_type.h:44
@ WWT_PANEL
Simple depressed panel.
Definition widget_type.h:39
@ WWT_STICKYBOX
Sticky box (at top-right of a window, after WWT_DEFSIZEBOX).
Definition widget_type.h:57
@ WWT_SHADEBOX
Shade box (at top-right of a window, between WWT_DEBUGBOX and WWT_DEFSIZEBOX).
Definition widget_type.h:55
@ WWT_CAPTION
Window caption (window title between closebox and stickybox).
Definition widget_type.h:52
@ NWID_VSCROLLBAR
Vertical scrollbar.
Definition widget_type.h:76
@ NWID_VERTICAL
Vertical container.
Definition widget_type.h:68
@ WWT_CLOSEBOX
Close box (at top-left of a window).
Definition widget_type.h:60
@ WWT_RESIZEBOX
Resize box (normally at bottom-right of a window).
Definition widget_type.h:59
@ WWT_DEFSIZEBOX
Default window size box (at top-right of a window, between WWT_SHADEBOX and WWT_STICKYBOX).
Definition widget_type.h:56
@ WWT_DROPDOWN
Drop down list.
Definition widget_type.h:61
@ NWID_SELECTION
Stacked widgets, only one visible at a time (eg in a panel with tabs).
Definition widget_type.h:71
@ SZSP_NONE
Display plane with zero size in both directions (none filling and resizing).
@ EqualSize
Containers should keep all their (resizing) children equally large.
void CloseWindowById(WindowClass cls, WindowNumber number, bool force, int data)
Close a window by its class and window number (if it is open).
Definition window.cpp:1242
Window * FindWindowByClass(WindowClass cls)
Find any window by its class.
Definition window.cpp:1214
Window * FindWindowById(WindowClass cls, WindowNumber number)
Find a window by its class and window number.
Definition window.cpp:1199
Window functions not directly related to making/drawing windows.
@ Construction
This window is used for construction; close it whenever changing company.
Definition window_gui.h:154
Twindow * AllocateWindowDescFront(WindowDesc &desc, WindowNumber window_number, Targs... extra_arguments)
Open a new window.
@ Automatic
Find a place automatically.
Definition window_gui.h:145
int WidgetID
Widget ID.
Definition window_type.h:21
Functions related to zooming.
int ScaleSpriteTrad(int value)
Scale traditional pixel dimensions to GUI zoom level, for drawing sprites.
Definition zoom_func.h:107