OpenTTD Source: src/station_gui.cpp Source File

OpenTTD Source 13.1

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 <http://www.gnu.org/licenses/>.
6 */
7
10 #include "stdafx.h"
11 #include "debug.h"
12 #include "gui.h"
13 #include "textbuf_gui.h"
14 #include "company_func.h"
15 #include "command_func.h"
16 #include "vehicle_gui.h"
17 #include "cargotype.h"
18 #include "station_gui.h"
19 #include "strings_func.h"
20 #include "string_func.h"
21 #include "window_func.h"
22 #include "viewport_func.h"
23 #include "widgets/dropdown_func.h"
24 #include "station_base.h"
25 #include "waypoint_base.h"
26 #include "tilehighlight_func.h"
27 #include "company_base.h"
28 #include "sortlist_type.h"
29 #include "core/geometry_func.hpp"
30 #include "vehiclelist.h"
31 #include "town.h"
32 #include "linkgraph/linkgraph.h"
33 #include "zoom_func.h"
34 #include "station_cmd.h"
35
36 #include "widgets/station_widget.h"
37
38 #include "table/strings.h"
39
40 #include <set>
41 #include <vector>
42
43 #include "safeguards.h"
44
55 int DrawStationCoverageAreaText(int left, int right, int top, StationCoverageType sct, int rad, bool supplies)
56 {
57 TileIndex tile = TileVirtXY(_thd.pos.x, _thd.pos.y);
58 CargoTypes cargo_mask = 0;
59 if (_thd.drawstyle == HT_RECT && tile < MapSize()) {
60 CargoArray cargoes;
61 if (supplies) {
62 cargoes = GetProductionAroundTiles(tile, _thd.size.x / TILE_SIZE, _thd.size.y / TILE_SIZE, rad);
63 } else {
64 cargoes = GetAcceptanceAroundTiles(tile, _thd.size.x / TILE_SIZE, _thd.size.y / TILE_SIZE, rad);
65 }
66
67 /* Convert cargo counts to a set of cargo bits, and draw the result. */
68 for (CargoID i = 0; i < NUM_CARGO; i++) {
69 switch (sct) {
70 case SCT_PASSENGERS_ONLY: if (!IsCargoInClass(i, CC_PASSENGERS)) continue; break;
71 case SCT_NON_PASSENGERS_ONLY: if (IsCargoInClass(i, CC_PASSENGERS)) continue; break;
72 case SCT_ALL: break;
73 default: NOT_REACHED();
74 }
75 if (cargoes[i] >= (supplies ? 1U : 8U)) SetBit(cargo_mask, i);
76 }
77 }
78 SetDParam(0, cargo_mask);
79 return DrawStringMultiLine(left, right, top, INT32_MAX, supplies ? STR_STATION_BUILD_SUPPLIES_CARGO : STR_STATION_BUILD_ACCEPTS_CARGO);
80 }
81
86 static void FindStationsAroundSelection()
87 {
88 /* With distant join we don't know which station will be selected, so don't show any */
89 if (_ctrl_pressed) {
90 SetViewportCatchmentStation(nullptr, true);
91 return;
92 }
93
94 /* Tile area for TileHighlightData */
95 TileArea location(TileVirtXY(_thd.pos.x, _thd.pos.y), _thd.size.x / TILE_SIZE - 1, _thd.size.y / TILE_SIZE - 1);
96
97 /* Extended area by one tile */
98 uint x = TileX(location.tile);
99 uint y = TileY(location.tile);
100
101 int max_c = 1;
102 TileArea ta(TileXY(std::max<int>(0, x - max_c), std::max<int>(0, y - max_c)), TileXY(std::min<int>(MapMaxX(), x + location.w + max_c), std::min<int>(MapMaxY(), y + location.h + max_c)));
103
104 Station *adjacent = nullptr;
105
106 /* Direct loop instead of ForAllStationsAroundTiles as we are not interested in catchment area */
107 for (TileIndex tile : ta) {
108 if (IsTileType(tile, MP_STATION) && GetTileOwner(tile) == _local_company) {
109 Station *st = Station::GetByTile(tile);
110 if (st == nullptr) continue;
111 if (adjacent != nullptr && st != adjacent) {
112 /* Multiple nearby, distant join is required. */
113 adjacent = nullptr;
114 break;
115 }
116 adjacent = st;
117 }
118 }
119 SetViewportCatchmentStation(adjacent, true);
120 }
121
127 void CheckRedrawStationCoverage(const Window *w)
128 {
129 /* Test if ctrl state changed */
130 static bool _last_ctrl_pressed;
131 if (_ctrl_pressed != _last_ctrl_pressed) {
132 _thd.dirty = 0xff;
133 _last_ctrl_pressed = _ctrl_pressed;
134 }
135
136 if (_thd.dirty & 1) {
137 _thd.dirty &= ~1;
138 w->SetDirty();
139
140 if (_settings_client.gui.station_show_coverage && _thd.drawstyle == HT_RECT) {
141 FindStationsAroundSelection();
142 }
143 }
144 }
145
158 static void StationsWndShowStationRating(int left, int right, int y, CargoID type, uint amount, byte rating)
159 {
160 static const uint units_full = 576;
161 static const uint rating_full = 224;
162
163 const CargoSpec *cs = CargoSpec::Get(type);
164 if (!cs->IsValid()) return;
165
166 int padding = ScaleGUITrad(1);
167 int width = right - left;
168 int colour = cs->rating_colour;
169 TextColour tc = GetContrastColour(colour);
170 uint w = std::min(amount + 5, units_full) * width / units_full;
171
172 int height = GetCharacterHeight(FS_SMALL) + padding - 1;
173
174 if (amount > 30) {
175 /* Draw total cargo (limited) on station */
176 GfxFillRect(left, y, left + w - 1, y + height, colour);
177 } else {
178 /* Draw a (scaled) one pixel-wide bar of additional cargo meter, useful
179 * for stations with only a small amount (<=30) */
180 uint rest = ScaleGUITrad(amount) / 5;
181 if (rest != 0) {
182 GfxFillRect(left, y + height - rest, left + padding - 1, y + height, colour);
183 }
184 }
185
186 DrawString(left + padding, right, y, cs->abbrev, tc);
187
188 /* Draw green/red ratings bar (fits under the waiting bar) */
189 y += height + padding + 1;
190 GfxFillRect(left + padding, y, right - padding - 1, y + padding - 1, PC_RED);
191 w = std::min<uint>(rating, rating_full) * (width - padding - padding) / rating_full;
192 if (w != 0) GfxFillRect(left + padding, y, left + w - 1, y + padding - 1, PC_GREEN);
193 }
194
195 typedef GUIList<const Station*> GUIStationList;
196
200 class CompanyStationsWindow : public Window
201 {
202 protected:
203 /* Runtime saved values */
204 static Listing last_sorting;
205 static byte facilities; // types of stations of interest
206 static bool include_empty; // whether we should include stations without waiting cargo
207 static const CargoTypes cargo_filter_max;
208 static CargoTypes cargo_filter; // bitmap of cargo types to include
209
210 /* Constants for sorting stations */
211 static const StringID sorter_names[];
212 static GUIStationList::SortFunction * const sorter_funcs[];
213
214 GUIStationList stations;
215 Scrollbar *vscroll;
216 uint rating_width;
217
223 void BuildStationsList(const Owner owner)
224 {
225 if (!this->stations.NeedRebuild()) return;
226
227 Debug(misc, 3, "Building station list for company {}", owner);
228
229 this->stations.clear();
230
231 for (const Station *st : Station::Iterate()) {
232 if (st->owner == owner || (st->owner == OWNER_NONE && HasStationInUse(st->index, true, owner))) {
233 if (this->facilities & st->facilities) { // only stations with selected facilities
234 int num_waiting_cargo = 0;
235 for (CargoID j = 0; j < NUM_CARGO; j++) {
236 if (st->goods[j].HasRating()) {
237 num_waiting_cargo++; // count number of waiting cargo
238 if (HasBit(this->cargo_filter, j)) {
239 this->stations.push_back(st);
240 break;
241 }
242 }
243 }
244 /* stations without waiting cargo */
245 if (num_waiting_cargo == 0 && this->include_empty) {
246 this->stations.push_back(st);
247 }
248 }
249 }
250 }
251
252 this->stations.shrink_to_fit();
253 this->stations.RebuildDone();
254
255 this->vscroll->SetCount((uint)this->stations.size()); // Update the scrollbar
256 }
257
259 static bool StationNameSorter(const Station * const &a, const Station * const &b)
260 {
261 int r = strnatcmp(a->GetCachedName(), b->GetCachedName()); // Sort by name (natural sorting).
262 if (r == 0) return a->index < b->index;
263 return r < 0;
264 }
265
267 static bool StationTypeSorter(const Station * const &a, const Station * const &b)
268 {
269 return a->facilities < b->facilities;
270 }
271
273 static bool StationWaitingTotalSorter(const Station * const &a, const Station * const &b)
274 {
275 int diff = 0;
276
277 for (CargoID j : SetCargoBitIterator(cargo_filter)) {
278 diff += a->goods[j].cargo.TotalCount() - b->goods[j].cargo.TotalCount();
279 }
280
281 return diff < 0;
282 }
283
285 static bool StationWaitingAvailableSorter(const Station * const &a, const Station * const &b)
286 {
287 int diff = 0;
288
289 for (CargoID j : SetCargoBitIterator(cargo_filter)) {
290 diff += a->goods[j].cargo.AvailableCount() - b->goods[j].cargo.AvailableCount();
291 }
292
293 return diff < 0;
294 }
295
297 static bool StationRatingMaxSorter(const Station * const &a, const Station * const &b)
298 {
299 byte maxr1 = 0;
300 byte maxr2 = 0;
301
302 for (CargoID j : SetCargoBitIterator(cargo_filter)) {
303 if (a->goods[j].HasRating()) maxr1 = std::max(maxr1, a->goods[j].rating);
304 if (b->goods[j].HasRating()) maxr2 = std::max(maxr2, b->goods[j].rating);
305 }
306
307 return maxr1 < maxr2;
308 }
309
311 static bool StationRatingMinSorter(const Station * const &a, const Station * const &b)
312 {
313 byte minr1 = 255;
314 byte minr2 = 255;
315
316 for (CargoID j = 0; j < NUM_CARGO; j++) {
317 if (!HasBit(cargo_filter, j)) continue;
318 if (a->goods[j].HasRating()) minr1 = std::min(minr1, a->goods[j].rating);
319 if (b->goods[j].HasRating()) minr2 = std::min(minr2, b->goods[j].rating);
320 }
321
322 return minr1 > minr2;
323 }
324
326 void SortStationsList()
327 {
328 if (!this->stations.Sort()) return;
329
330 /* Set the modified widget dirty */
331 this->SetWidgetDirty(WID_STL_LIST);
332 }
333
334 public:
335 CompanyStationsWindow(WindowDesc *desc, WindowNumber window_number) : Window(desc)
336 {
337 this->stations.SetListing(this->last_sorting);
338 this->stations.SetSortFuncs(this->sorter_funcs);
339 this->stations.ForceRebuild();
340 this->stations.NeedResort();
341 this->SortStationsList();
342
343 this->CreateNestedTree();
344 this->vscroll = this->GetScrollbar(WID_STL_SCROLLBAR);
345 this->FinishInitNested(window_number);
346 this->owner = (Owner)this->window_number;
347
348 uint8 index = 0;
349 for (const CargoSpec *cs : _sorted_standard_cargo_specs) {
350 if (HasBit(this->cargo_filter, cs->Index())) {
351 this->LowerWidget(WID_STL_CARGOSTART + index);
352 }
353 index++;
354 }
355
356 if (this->cargo_filter == this->cargo_filter_max) this->cargo_filter = _cargo_mask;
357
358 for (uint i = 0; i < 5; i++) {
359 if (HasBit(this->facilities, i)) this->LowerWidget(i + WID_STL_TRAIN);
360 }
361 this->SetWidgetLoweredState(WID_STL_NOCARGOWAITING, this->include_empty);
362
363 this->GetWidget<NWidgetCore>(WID_STL_SORTDROPBTN)->widget_data = this->sorter_names[this->stations.SortType()];
364 }
365
366 ~CompanyStationsWindow()
367 {
368 this->last_sorting = this->stations.GetListing();
369 }
370
371 void UpdateWidgetSize(int widget, Dimension *size, const Dimension &padding, Dimension *fill, Dimension *resize) override
372 {
373 switch (widget) {
374 case WID_STL_SORTBY: {
375 Dimension d = GetStringBoundingBox(this->GetWidget<NWidgetCore>(widget)->widget_data);
376 d.width += padding.width + Window::SortButtonWidth() * 2; // Doubled since the string is centred and it also looks better.
377 d.height += padding.height;
378 *size = maxdim(*size, d);
379 break;
380 }
381
382 case WID_STL_SORTDROPBTN: {
383 Dimension d = {0, 0};
384 for (int i = 0; this->sorter_names[i] != INVALID_STRING_ID; i++) {
385 d = maxdim(d, GetStringBoundingBox(this->sorter_names[i]));
386 }
387 d.width += padding.width;
388 d.height += padding.height;
389 *size = maxdim(*size, d);
390 break;
391 }
392
393 case WID_STL_LIST:
394 resize->height = std::max(FONT_HEIGHT_NORMAL, FONT_HEIGHT_SMALL + ScaleGUITrad(3));
395 size->height = padding.height + 5 * resize->height;
396
397 /* Determine appropriate width for mini station rating graph */
398 this->rating_width = 0;
399 for (const CargoSpec *cs : _sorted_standard_cargo_specs) {
400 this->rating_width = std::max(this->rating_width, GetStringBoundingBox(cs->abbrev).width);
401 }
402 /* Approximately match original 16 pixel wide rating bars by multiplying string width by 1.6 */
403 this->rating_width = this->rating_width * 16 / 10;
404 break;
405
406 default:
407 if (widget >= WID_STL_CARGOSTART) {
408 Dimension d = GetStringBoundingBox(_sorted_cargo_specs[widget - WID_STL_CARGOSTART]->abbrev);
409 d.width += padding.width + 2;
410 d.height += padding.height;
411 *size = maxdim(*size, d);
412 }
413 break;
414 }
415 }
416
417 void OnPaint() override
418 {
419 this->BuildStationsList((Owner)this->window_number);
420 this->SortStationsList();
421
422 this->DrawWidgets();
423 }
424
425 void DrawWidget(const Rect &r, int widget) const override
426 {
427 switch (widget) {
428 case WID_STL_SORTBY:
429 /* draw arrow pointing up/down for ascending/descending sorting */
430 this->DrawSortButtonState(WID_STL_SORTBY, this->stations.IsDescSortOrder() ? SBS_DOWN : SBS_UP);
431 break;
432
433 case WID_STL_LIST: {
434 bool rtl = _current_text_dir == TD_RTL;
435 int max = std::min<size_t>(this->vscroll->GetPosition() + this->vscroll->GetCapacity(), this->stations.size());
436 Rect tr = r.Shrink(WidgetDimensions::scaled.framerect);
437 uint line_height = this->GetWidget<NWidgetBase>(widget)->resize_y;
438 /* Spacing between station name and first rating graph. */
439 int text_spacing = WidgetDimensions::scaled.hsep_wide;
440 /* Spacing between additional rating graphs. */
441 int rating_spacing = WidgetDimensions::scaled.hsep_normal;
442
443 for (int i = this->vscroll->GetPosition(); i < max; ++i) { // do until max number of stations of owner
444 const Station *st = this->stations[i];
445 assert(st->xy != INVALID_TILE);
446
447 /* Do not do the complex check HasStationInUse here, it may be even false
448 * when the order had been removed and the station list hasn't been removed yet */
449 assert(st->owner == owner || st->owner == OWNER_NONE);
450
451 SetDParam(0, st->index);
452 SetDParam(1, st->facilities);
453 int x = DrawString(tr.left, tr.right, tr.top + (line_height - FONT_HEIGHT_NORMAL) / 2, STR_STATION_LIST_STATION);
454 x += rtl ? -text_spacing : text_spacing;
455
456 /* show cargo waiting and station ratings */
457 for (const CargoSpec *cs : _sorted_standard_cargo_specs) {
458 CargoID cid = cs->Index();
459 if (st->goods[cid].cargo.TotalCount() > 0) {
460 /* For RTL we work in exactly the opposite direction. So
461 * decrement the space needed first, then draw to the left
462 * instead of drawing to the left and then incrementing
463 * the space. */
464 if (rtl) {
465 x -= rating_width + rating_spacing;
466 if (x < tr.left) break;
467 }
468 StationsWndShowStationRating(x, x + rating_width, tr.top, cid, st->goods[cid].cargo.TotalCount(), st->goods[cid].rating);
469 if (!rtl) {
470 x += rating_width + rating_spacing;
471 if (x > tr.right) break;
472 }
473 }
474 }
475 tr.top += line_height;
476 }
477
478 if (this->vscroll->GetCount() == 0) { // company has no stations
479 DrawString(tr.left, tr.right, tr.top + (line_height - FONT_HEIGHT_NORMAL) / 2, STR_STATION_LIST_NONE);
480 return;
481 }
482 break;
483 }
484
485 default:
486 if (widget >= WID_STL_CARGOSTART) {
487 Rect br = r.Shrink(WidgetDimensions::scaled.bevel);
488 const CargoSpec *cs = _sorted_cargo_specs[widget - WID_STL_CARGOSTART];
489 int cg_ofst = HasBit(this->cargo_filter, cs->Index()) ? WidgetDimensions::scaled.pressed : 0;
490 br = br.Translate(cg_ofst, cg_ofst);
491 GfxFillRect(br, cs->rating_colour);
492 TextColour tc = GetContrastColour(cs->rating_colour);
493 DrawString(br.left, br.right, CenterBounds(br.top, br.bottom, FONT_HEIGHT_SMALL), cs->abbrev, tc, SA_HOR_CENTER);
494 }
495 break;
496 }
497 }
498
499 void SetStringParameters(int widget) const override
500 {
501 if (widget == WID_STL_CAPTION) {
502 SetDParam(0, this->window_number);
503 SetDParam(1, this->vscroll->GetCount());
504 }
505 }
506
507 void OnClick(Point pt, int widget, int click_count) override
508 {
509 switch (widget) {
510 case WID_STL_LIST: {
511 uint id_v = this->vscroll->GetScrolledRowFromWidget(pt.y, this, WID_STL_LIST);
512 if (id_v >= this->stations.size()) return; // click out of list bound
513
514 const Station *st = this->stations[id_v];
515 /* do not check HasStationInUse - it is slow and may be invalid */
516 assert(st->owner == (Owner)this->window_number || st->owner == OWNER_NONE);
517
518 if (_ctrl_pressed) {
519 ShowExtraViewportWindow(st->xy);
520 } else {
521 ScrollMainWindowToTile(st->xy);
522 }
523 break;
524 }
525
526 case WID_STL_TRAIN:
527 case WID_STL_TRUCK:
528 case WID_STL_BUS:
529 case WID_STL_AIRPLANE:
530 case WID_STL_SHIP:
531 if (_ctrl_pressed) {
532 ToggleBit(this->facilities, widget - WID_STL_TRAIN);
533 this->ToggleWidgetLoweredState(widget);
534 } else {
535 for (uint i : SetBitIterator(this->facilities)) {
536 this->RaiseWidget(i + WID_STL_TRAIN);
537 }
538 this->facilities = 1 << (widget - WID_STL_TRAIN);
539 this->LowerWidget(widget);
540 }
541 this->stations.ForceRebuild();
542 this->SetDirty();
543 break;
544
545 case WID_STL_FACILALL:
546 for (uint i = WID_STL_TRAIN; i <= WID_STL_SHIP; i++) {
547 this->LowerWidget(i);
548 }
549
550 this->facilities = FACIL_TRAIN | FACIL_TRUCK_STOP | FACIL_BUS_STOP | FACIL_AIRPORT | FACIL_DOCK;
551 this->stations.ForceRebuild();
552 this->SetDirty();
553 break;
554
555 case WID_STL_CARGOALL: {
556 for (uint i = 0; i < _sorted_standard_cargo_specs.size(); i++) {
557 this->LowerWidget(WID_STL_CARGOSTART + i);
558 }
559 this->LowerWidget(WID_STL_NOCARGOWAITING);
560
561 this->cargo_filter = _cargo_mask;
562 this->include_empty = true;
563 this->stations.ForceRebuild();
564 this->SetDirty();
565 break;
566 }
567
568 case WID_STL_SORTBY: // flip sorting method asc/desc
569 this->stations.ToggleSortOrder();
570 this->SetDirty();
571 break;
572
573 case WID_STL_SORTDROPBTN: // select sorting criteria dropdown menu
574 ShowDropDownMenu(this, this->sorter_names, this->stations.SortType(), WID_STL_SORTDROPBTN, 0, 0);
575 break;
576
577 case WID_STL_NOCARGOWAITING:
578 if (_ctrl_pressed) {
579 this->include_empty = !this->include_empty;
580 this->ToggleWidgetLoweredState(WID_STL_NOCARGOWAITING);
581 } else {
582 for (uint i = 0; i < _sorted_standard_cargo_specs.size(); i++) {
583 this->RaiseWidget(WID_STL_CARGOSTART + i);
584 }
585
586 this->cargo_filter = 0;
587 this->include_empty = true;
588
589 this->LowerWidget(WID_STL_NOCARGOWAITING);
590 }
591 this->stations.ForceRebuild();
592 this->SetDirty();
593 break;
594
595 default:
596 if (widget >= WID_STL_CARGOSTART) { // change cargo_filter
597 /* Determine the selected cargo type */
598 const CargoSpec *cs = _sorted_cargo_specs[widget - WID_STL_CARGOSTART];
599
600 if (_ctrl_pressed) {
601 ToggleBit(this->cargo_filter, cs->Index());
602 this->ToggleWidgetLoweredState(widget);
603 } else {
604 for (uint i = 0; i < _sorted_standard_cargo_specs.size(); i++) {
605 this->RaiseWidget(WID_STL_CARGOSTART + i);
606 }
607 this->RaiseWidget(WID_STL_NOCARGOWAITING);
608
609 this->cargo_filter = 0;
610 this->include_empty = false;
611
612 SetBit(this->cargo_filter, cs->Index());
613 this->LowerWidget(widget);
614 }
615 this->stations.ForceRebuild();
616 this->SetDirty();
617 }
618 break;
619 }
620 }
621
622 void OnDropdownSelect(int widget, int index) override
623 {
624 if (this->stations.SortType() != index) {
625 this->stations.SetSortType(index);
626
627 /* Display the current sort variant */
628 this->GetWidget<NWidgetCore>(WID_STL_SORTDROPBTN)->widget_data = this->sorter_names[this->stations.SortType()];
629
630 this->SetDirty();
631 }
632 }
633
634 void OnGameTick() override
635 {
636 if (this->stations.NeedResort()) {
637 Debug(misc, 3, "Periodic rebuild station list company {}", this->window_number);
638 this->SetDirty();
639 }
640 }
641
642 void OnResize() override
643 {
644 this->vscroll->SetCapacityFromWidget(this, WID_STL_LIST, WidgetDimensions::scaled.framerect.Vertical());
645 }
646
652 void OnInvalidateData(int data = 0, bool gui_scope = true) override
653 {
654 if (data == 0) {
655 /* This needs to be done in command-scope to enforce rebuilding before resorting invalid data */
656 this->stations.ForceRebuild();
657 } else {
658 this->stations.ForceResort();
659 }
660 }
661 };
662
663 Listing CompanyStationsWindow::last_sorting = {false, 0};
664 byte CompanyStationsWindow::facilities = FACIL_TRAIN | FACIL_TRUCK_STOP | FACIL_BUS_STOP | FACIL_AIRPORT | FACIL_DOCK;
665 bool CompanyStationsWindow::include_empty = true;
666 const CargoTypes CompanyStationsWindow::cargo_filter_max = ALL_CARGOTYPES;
667 CargoTypes CompanyStationsWindow::cargo_filter = ALL_CARGOTYPES;
668
669 /* Available station sorting functions */
670 GUIStationList::SortFunction * const CompanyStationsWindow::sorter_funcs[] = {
671 &StationNameSorter,
672 &StationTypeSorter,
673 &StationWaitingTotalSorter,
674 &StationWaitingAvailableSorter,
675 &StationRatingMaxSorter,
676 &StationRatingMinSorter
677 };
678
679 /* Names of the sorting functions */
680 const StringID CompanyStationsWindow::sorter_names[] = {
681 STR_SORT_BY_NAME,
682 STR_SORT_BY_FACILITY,
683 STR_SORT_BY_WAITING_TOTAL,
684 STR_SORT_BY_WAITING_AVAILABLE,
685 STR_SORT_BY_RATING_MAX,
686 STR_SORT_BY_RATING_MIN,
687 INVALID_STRING_ID
688 };
689
695 static NWidgetBase *CargoWidgets(int *biggest_index)
696 {
697 NWidgetHorizontal *container = new NWidgetHorizontal();
698
699 for (uint i = 0; i < _sorted_standard_cargo_specs.size(); i++) {
700 NWidgetBackground *panel = new NWidgetBackground(WWT_PANEL, COLOUR_GREY, WID_STL_CARGOSTART + i);
701 panel->SetMinimalSize(14, 0);
702 panel->SetMinimalTextLines(1, 0, FS_NORMAL);
703 panel->SetResize(0, 0);
704 panel->SetFill(0, 1);
705 panel->SetDataTip(0, STR_STATION_LIST_USE_CTRL_TO_SELECT_MORE);
706 container->Add(panel);
707 }
708 *biggest_index = WID_STL_CARGOSTART + static_cast<int>(_sorted_standard_cargo_specs.size());
709 return container;
710 }
711
712 static const NWidgetPart _nested_company_stations_widgets[] = {
713 NWidget(NWID_HORIZONTAL),
714 NWidget(WWT_CLOSEBOX, COLOUR_GREY),
715 NWidget(WWT_CAPTION, COLOUR_GREY, WID_STL_CAPTION), SetDataTip(STR_STATION_LIST_CAPTION, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
716 NWidget(WWT_SHADEBOX, COLOUR_GREY),
717 NWidget(WWT_DEFSIZEBOX, COLOUR_GREY),
718 NWidget(WWT_STICKYBOX, COLOUR_GREY),
719 EndContainer(),
720 NWidget(NWID_HORIZONTAL),
721 NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_STL_TRAIN), SetMinimalSize(14, 0), SetMinimalTextLines(1, 0), SetDataTip(STR_TRAIN, STR_STATION_LIST_USE_CTRL_TO_SELECT_MORE), SetFill(0, 1),
722 NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_STL_TRUCK), SetMinimalSize(14, 0), SetMinimalTextLines(1, 0), SetDataTip(STR_LORRY, STR_STATION_LIST_USE_CTRL_TO_SELECT_MORE), SetFill(0, 1),
723 NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_STL_BUS), SetMinimalSize(14, 0), SetMinimalTextLines(1, 0), SetDataTip(STR_BUS, STR_STATION_LIST_USE_CTRL_TO_SELECT_MORE), SetFill(0, 1),
724 NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_STL_SHIP), SetMinimalSize(14, 0), SetMinimalTextLines(1, 0), SetDataTip(STR_SHIP, STR_STATION_LIST_USE_CTRL_TO_SELECT_MORE), SetFill(0, 1),
725 NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_STL_AIRPLANE), SetMinimalSize(14, 0), SetMinimalTextLines(1, 0), SetDataTip(STR_PLANE, STR_STATION_LIST_USE_CTRL_TO_SELECT_MORE), SetFill(0, 1),
726 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_STL_FACILALL), SetMinimalSize(14, 0), SetMinimalTextLines(1, 0), SetDataTip(STR_ABBREV_ALL, STR_STATION_LIST_SELECT_ALL_FACILITIES), SetFill(0, 1),
727 NWidget(WWT_PANEL, COLOUR_GREY), SetMinimalSize(5, 0), SetFill(0, 1), EndContainer(),
728 NWidgetFunction(CargoWidgets),
729 NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_STL_NOCARGOWAITING), SetMinimalSize(14, 0), SetMinimalTextLines(1, 0), SetDataTip(STR_ABBREV_NONE, STR_STATION_LIST_NO_WAITING_CARGO), SetFill(0, 1),
730 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_STL_CARGOALL), SetMinimalSize(14, 0), SetMinimalTextLines(1, 0), SetDataTip(STR_ABBREV_ALL, STR_STATION_LIST_SELECT_ALL_TYPES), SetFill(0, 1),
731 NWidget(WWT_PANEL, COLOUR_GREY), SetResize(1, 0), SetFill(1, 1), EndContainer(),
732 EndContainer(),
733 NWidget(NWID_HORIZONTAL),
734 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_STL_SORTBY), SetMinimalSize(81, 12), SetDataTip(STR_BUTTON_SORT_BY, STR_TOOLTIP_SORT_ORDER),
735 NWidget(WWT_DROPDOWN, COLOUR_GREY, WID_STL_SORTDROPBTN), SetMinimalSize(163, 12), SetDataTip(STR_SORT_BY_NAME, STR_TOOLTIP_SORT_CRITERIA), // widget_data gets overwritten.
736 NWidget(WWT_PANEL, COLOUR_GREY), SetResize(1, 0), SetFill(1, 1), EndContainer(),
737 EndContainer(),
738 NWidget(NWID_HORIZONTAL),
739 NWidget(WWT_PANEL, COLOUR_GREY, WID_STL_LIST), SetMinimalSize(346, 125), SetResize(1, 10), SetDataTip(0x0, STR_STATION_LIST_TOOLTIP), SetScrollbar(WID_STL_SCROLLBAR), EndContainer(),
740 NWidget(NWID_VERTICAL),
741 NWidget(NWID_VSCROLLBAR, COLOUR_GREY, WID_STL_SCROLLBAR),
742 NWidget(WWT_RESIZEBOX, COLOUR_GREY),
743 EndContainer(),
744 EndContainer(),
745 };
746
747 static WindowDesc _company_stations_desc(
748 WDP_AUTO, "list_stations", 358, 162,
749 WC_STATION_LIST, WC_NONE,
750 0,
751 _nested_company_stations_widgets, lengthof(_nested_company_stations_widgets)
752 );
753
759 void ShowCompanyStations(CompanyID company)
760 {
761 if (!Company::IsValidID(company)) return;
762
763 AllocateWindowDescFront<CompanyStationsWindow>(&_company_stations_desc, company);
764 }
765
766 static const NWidgetPart _nested_station_view_widgets[] = {
767 NWidget(NWID_HORIZONTAL),
768 NWidget(WWT_CLOSEBOX, COLOUR_GREY),
769 NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_SV_RENAME), SetMinimalSize(12, 14), SetDataTip(SPR_RENAME, STR_STATION_VIEW_RENAME_TOOLTIP),
770 NWidget(WWT_CAPTION, COLOUR_GREY, WID_SV_CAPTION), SetDataTip(STR_STATION_VIEW_CAPTION, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
771 NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_SV_LOCATION), SetMinimalSize(12, 14), SetDataTip(SPR_GOTO_LOCATION, STR_STATION_VIEW_CENTER_TOOLTIP),
772 NWidget(WWT_SHADEBOX, COLOUR_GREY),
773 NWidget(WWT_DEFSIZEBOX, COLOUR_GREY),
774 NWidget(WWT_STICKYBOX, COLOUR_GREY),
775 EndContainer(),
776 NWidget(NWID_HORIZONTAL),
777 NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_SV_GROUP), SetMinimalSize(81, 12), SetFill(1, 1), SetDataTip(STR_STATION_VIEW_GROUP, 0x0),
778 NWidget(WWT_DROPDOWN, COLOUR_GREY, WID_SV_GROUP_BY), SetMinimalSize(168, 12), SetResize(1, 0), SetFill(0, 1), SetDataTip(0x0, STR_TOOLTIP_GROUP_ORDER),
779 EndContainer(),
780 NWidget(NWID_HORIZONTAL),
781 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_SV_SORT_ORDER), SetMinimalSize(81, 12), SetFill(1, 1), SetDataTip(STR_BUTTON_SORT_BY, STR_TOOLTIP_SORT_ORDER),
782 NWidget(WWT_DROPDOWN, COLOUR_GREY, WID_SV_SORT_BY), SetMinimalSize(168, 12), SetResize(1, 0), SetFill(0, 1), SetDataTip(0x0, STR_TOOLTIP_SORT_CRITERIA),
783 EndContainer(),
784 NWidget(NWID_HORIZONTAL),
785 NWidget(WWT_PANEL, COLOUR_GREY, WID_SV_WAITING), SetMinimalSize(237, 44), SetResize(1, 10), SetScrollbar(WID_SV_SCROLLBAR), EndContainer(),
786 NWidget(NWID_VSCROLLBAR, COLOUR_GREY, WID_SV_SCROLLBAR),
787 EndContainer(),
788 NWidget(WWT_PANEL, COLOUR_GREY, WID_SV_ACCEPT_RATING_LIST), SetMinimalSize(249, 23), SetResize(1, 0), EndContainer(),
789 NWidget(NWID_HORIZONTAL, NC_EQUALSIZE),
790 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_SV_ACCEPTS_RATINGS), SetMinimalSize(46, 12), SetResize(1, 0), SetFill(1, 1),
791 SetDataTip(STR_STATION_VIEW_RATINGS_BUTTON, STR_STATION_VIEW_RATINGS_TOOLTIP),
792 NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_SV_CLOSE_AIRPORT), SetMinimalSize(45, 12), SetResize(1, 0), SetFill(1, 1),
793 SetDataTip(STR_STATION_VIEW_CLOSE_AIRPORT, STR_STATION_VIEW_CLOSE_AIRPORT_TOOLTIP),
794 NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_SV_CATCHMENT), SetMinimalSize(45, 12), SetResize(1, 0), SetFill(1, 1), SetDataTip(STR_BUTTON_CATCHMENT, STR_TOOLTIP_CATCHMENT),
795 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_SV_TRAINS), SetMinimalSize(14, 12), SetFill(0, 1), SetDataTip(STR_TRAIN, STR_STATION_VIEW_SCHEDULED_TRAINS_TOOLTIP),
796 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_SV_ROADVEHS), SetMinimalSize(14, 12), SetFill(0, 1), SetDataTip(STR_LORRY, STR_STATION_VIEW_SCHEDULED_ROAD_VEHICLES_TOOLTIP),
797 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_SV_SHIPS), SetMinimalSize(14, 12), SetFill(0, 1), SetDataTip(STR_SHIP, STR_STATION_VIEW_SCHEDULED_SHIPS_TOOLTIP),
798 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_SV_PLANES), SetMinimalSize(14, 12), SetFill(0, 1), SetDataTip(STR_PLANE, STR_STATION_VIEW_SCHEDULED_AIRCRAFT_TOOLTIP),
799 NWidget(WWT_RESIZEBOX, COLOUR_GREY),
800 EndContainer(),
801 };
802
812 static void DrawCargoIcons(CargoID i, uint waiting, int left, int right, int y)
813 {
814 int width = ScaleSpriteTrad(10);
815 uint num = std::min<uint>((waiting + (width / 2)) / width, (right - left) / width); // maximum is width / 10 icons so it won't overflow
816 if (num == 0) return;
817
818 SpriteID sprite = CargoSpec::Get(i)->GetCargoIcon();
819
820 int x = _current_text_dir == TD_RTL ? left : right - num * width;
821 do {
822 DrawSprite(sprite, PAL_NONE, x, y);
823 x += width;
824 } while (--num);
825 }
826
827 enum SortOrder {
828 SO_DESCENDING,
829 SO_ASCENDING
830 };
831
832 class CargoDataEntry;
833
834 enum CargoSortType {
835 ST_AS_GROUPING,
836 ST_COUNT,
837 ST_STATION_STRING,
838 ST_STATION_ID,
839 ST_CARGO_ID,
840 };
841
842 class CargoSorter {
843 public:
844 CargoSorter(CargoSortType t = ST_STATION_ID, SortOrder o = SO_ASCENDING) : type(t), order(o) {}
845 CargoSortType GetSortType() {return this->type;}
846 bool operator()(const CargoDataEntry *cd1, const CargoDataEntry *cd2) const;
847
848 private:
849 CargoSortType type;
850 SortOrder order;
851
852 template<class Tid>
853 bool SortId(Tid st1, Tid st2) const;
854 bool SortCount(const CargoDataEntry *cd1, const CargoDataEntry *cd2) const;
855 bool SortStation (StationID st1, StationID st2) const;
856 };
857
858 typedef std::set<CargoDataEntry *, CargoSorter> CargoDataSet;
859
865 class CargoDataEntry {
866 public:
867 CargoDataEntry();
868 ~CargoDataEntry();
869
875 CargoDataEntry *InsertOrRetrieve(StationID station)
876 {
877 return this->InsertOrRetrieve<StationID>(station);
878 }
879
885 CargoDataEntry *InsertOrRetrieve(CargoID cargo)
886 {
887 return this->InsertOrRetrieve<CargoID>(cargo);
888 }
889
890 void Update(uint count);
891
896 void Remove(StationID station)
897 {
898 CargoDataEntry t(station);
899 this->Remove(&t);
900 }
901
906 void Remove(CargoID cargo)
907 {
908 CargoDataEntry t(cargo);
909 this->Remove(&t);
910 }
911
917 CargoDataEntry *Retrieve(StationID station) const
918 {
919 CargoDataEntry t(station);
920 return this->Retrieve(this->children->find(&t));
921 }
922
928 CargoDataEntry *Retrieve(CargoID cargo) const
929 {
930 CargoDataEntry t(cargo);
931 return this->Retrieve(this->children->find(&t));
932 }
933
934 void Resort(CargoSortType type, SortOrder order);
935
939 StationID GetStation() const { return this->station; }
940
944 CargoID GetCargo() const { return this->cargo; }
945
949 uint GetCount() const { return this->count; }
950
954 CargoDataEntry *GetParent() const { return this->parent; }
955
959 uint GetNumChildren() const { return this->num_children; }
960
964 CargoDataSet::iterator Begin() const { return this->children->begin(); }
965
969 CargoDataSet::iterator End() const { return this->children->end(); }
970
974 bool HasTransfers() const { return this->transfers; }
975
979 void SetTransfers(bool value) { this->transfers = value; }
980
981 void Clear();
982 private:
983
984 CargoDataEntry(StationID st, uint c, CargoDataEntry *p);
985 CargoDataEntry(CargoID car, uint c, CargoDataEntry *p);
986 CargoDataEntry(StationID st);
987 CargoDataEntry(CargoID car);
988
989 CargoDataEntry *Retrieve(CargoDataSet::iterator i) const;
990
991 template<class Tid>
992 CargoDataEntry *InsertOrRetrieve(Tid s);
993
994 void Remove(CargoDataEntry *comp);
995 void IncrementSize();
996
997 CargoDataEntry *parent;
998 const union {
999 StationID station;
1000 struct {
1001 CargoID cargo;
1002 bool transfers;
1003 };
1004 };
1005 uint num_children;
1006 uint count;
1007 CargoDataSet *children;
1008 };
1009
1010 CargoDataEntry::CargoDataEntry() :
1011 parent(nullptr),
1012 station(INVALID_STATION),
1013 num_children(0),
1014 count(0),
1015 children(new CargoDataSet(CargoSorter(ST_CARGO_ID)))
1016 {}
1017
1018 CargoDataEntry::CargoDataEntry(CargoID cargo, uint count, CargoDataEntry *parent) :
1019 parent(parent),
1020 cargo(cargo),
1021 num_children(0),
1022 count(count),
1023 children(new CargoDataSet)
1024 {}
1025
1026 CargoDataEntry::CargoDataEntry(StationID station, uint count, CargoDataEntry *parent) :
1027 parent(parent),
1028 station(station),
1029 num_children(0),
1030 count(count),
1031 children(new CargoDataSet)
1032 {}
1033
1034 CargoDataEntry::CargoDataEntry(StationID station) :
1035 parent(nullptr),
1036 station(station),
1037 num_children(0),
1038 count(0),
1039 children(nullptr)
1040 {}
1041
1042 CargoDataEntry::CargoDataEntry(CargoID cargo) :
1043 parent(nullptr),
1044 cargo(cargo),
1045 num_children(0),
1046 count(0),
1047 children(nullptr)
1048 {}
1049
1050 CargoDataEntry::~CargoDataEntry()
1051 {
1052 this->Clear();
1053 delete this->children;
1054 }
1055
1059 void CargoDataEntry::Clear()
1060 {
1061 if (this->children != nullptr) {
1062 for (CargoDataSet::iterator i = this->children->begin(); i != this->children->end(); ++i) {
1063 assert(*i != this);
1064 delete *i;
1065 }
1066 this->children->clear();
1067 }
1068 if (this->parent != nullptr) this->parent->count -= this->count;
1069 this->count = 0;
1070 this->num_children = 0;
1071 }
1072
1079 void CargoDataEntry::Remove(CargoDataEntry *child)
1080 {
1081 CargoDataSet::iterator i = this->children->find(child);
1082 if (i != this->children->end()) {
1083 delete *i;
1084 this->children->erase(i);
1085 }
1086 }
1087
1094 template<class Tid>
1095 CargoDataEntry *CargoDataEntry::InsertOrRetrieve(Tid child_id)
1096 {
1097 CargoDataEntry tmp(child_id);
1098 CargoDataSet::iterator i = this->children->find(&tmp);
1099 if (i == this->children->end()) {
1100 IncrementSize();
1101 return *(this->children->insert(new CargoDataEntry(child_id, 0, this)).first);
1102 } else {
1103 CargoDataEntry *ret = *i;
1104 assert(this->children->value_comp().GetSortType() != ST_COUNT);
1105 return ret;
1106 }
1107 }
1108
1114 void CargoDataEntry::Update(uint count)
1115 {
1116 this->count += count;
1117 if (this->parent != nullptr) this->parent->Update(count);
1118 }
1119
1123 void CargoDataEntry::IncrementSize()
1124 {
1125 ++this->num_children;
1126 if (this->parent != nullptr) this->parent->IncrementSize();
1127 }
1128
1129 void CargoDataEntry::Resort(CargoSortType type, SortOrder order)
1130 {
1131 CargoDataSet *new_subs = new CargoDataSet(this->children->begin(), this->children->end(), CargoSorter(type, order));
1132 delete this->children;
1133 this->children = new_subs;
1134 }
1135
1136 CargoDataEntry *CargoDataEntry::Retrieve(CargoDataSet::iterator i) const
1137 {
1138 if (i == this->children->end()) {
1139 return nullptr;
1140 } else {
1141 assert(this->children->value_comp().GetSortType() != ST_COUNT);
1142 return *i;
1143 }
1144 }
1145
1146 bool CargoSorter::operator()(const CargoDataEntry *cd1, const CargoDataEntry *cd2) const
1147 {
1148 switch (this->type) {
1149 case ST_STATION_ID:
1150 return this->SortId<StationID>(cd1->GetStation(), cd2->GetStation());
1151 case ST_CARGO_ID:
1152 return this->SortId<CargoID>(cd1->GetCargo(), cd2->GetCargo());
1153 case ST_COUNT:
1154 return this->SortCount(cd1, cd2);
1155 case ST_STATION_STRING:
1156 return this->SortStation(cd1->GetStation(), cd2->GetStation());
1157 default:
1158 NOT_REACHED();
1159 }
1160 }
1161
1162 template<class Tid>
1163 bool CargoSorter::SortId(Tid st1, Tid st2) const
1164 {
1165 return (this->order == SO_ASCENDING) ? st1 < st2 : st2 < st1;
1166 }
1167
1168 bool CargoSorter::SortCount(const CargoDataEntry *cd1, const CargoDataEntry *cd2) const
1169 {
1170 uint c1 = cd1->GetCount();
1171 uint c2 = cd2->GetCount();
1172 if (c1 == c2) {
1173 return this->SortStation(cd1->GetStation(), cd2->GetStation());
1174 } else if (this->order == SO_ASCENDING) {
1175 return c1 < c2;
1176 } else {
1177 return c2 < c1;
1178 }
1179 }
1180
1181 bool CargoSorter::SortStation(StationID st1, StationID st2) const
1182 {
1183 if (!Station::IsValidID(st1)) {
1184 return Station::IsValidID(st2) ? this->order == SO_ASCENDING : this->SortId(st1, st2);
1185 } else if (!Station::IsValidID(st2)) {
1186 return order == SO_DESCENDING;
1187 }
1188
1189 int res = strnatcmp(Station::Get(st1)->GetCachedName(), Station::Get(st2)->GetCachedName()); // Sort by name (natural sorting).
1190 if (res == 0) {
1191 return this->SortId(st1, st2);
1192 } else {
1193 return (this->order == SO_ASCENDING) ? res < 0 : res > 0;
1194 }
1195 }
1196
1200 struct StationViewWindow : public Window {
1204 struct RowDisplay {
1205 RowDisplay(CargoDataEntry *f, StationID n) : filter(f), next_station(n) {}
1206 RowDisplay(CargoDataEntry *f, CargoID n) : filter(f), next_cargo(n) {}
1207
1211 CargoDataEntry *filter;
1212 union {
1216 StationID next_station;
1217
1221 CargoID next_cargo;
1222 };
1223 };
1224
1225 typedef std::vector<RowDisplay> CargoDataVector;
1226
1227 static const int NUM_COLUMNS = 4;
1228
1232 enum Invalidation {
1233 INV_FLOWS = 0x100,
1234 INV_CARGO = 0x200
1235 };
1236
1240 enum Grouping {
1241 GR_SOURCE,
1242 GR_NEXT,
1243 GR_DESTINATION,
1244 GR_CARGO,
1245 };
1246
1250 enum Mode {
1251 MODE_WAITING,
1252 MODE_PLANNED
1253 };
1254
1255 uint expand_shrink_width;
1256 int rating_lines;
1257 int accepts_lines;
1258 Scrollbar *vscroll;
1259
1261 enum AcceptListHeight {
1262 ALH_RATING = 13,
1263 ALH_ACCEPTS = 3,
1264 };
1265
1266 static const StringID _sort_names[];
1267 static const StringID _group_names[];
1268
1275 CargoSortType sortings[NUM_COLUMNS];
1276
1278 SortOrder sort_orders[NUM_COLUMNS];
1279
1280 int scroll_to_row;
1281 int grouping_index;
1282 Mode current_mode;
1283 Grouping groupings[NUM_COLUMNS];
1284
1285 CargoDataEntry expanded_rows;
1286 CargoDataEntry cached_destinations;
1287 CargoDataVector displayed_rows;
1288
1289 StationViewWindow(WindowDesc *desc, WindowNumber window_number) : Window(desc),
1290 scroll_to_row(INT_MAX), grouping_index(0)
1291 {
1292 this->rating_lines = ALH_RATING;
1293 this->accepts_lines = ALH_ACCEPTS;
1294
1295 this->CreateNestedTree();
1296 this->vscroll = this->GetScrollbar(WID_SV_SCROLLBAR);
1297 /* Nested widget tree creation is done in two steps to ensure that this->GetWidget<NWidgetCore>(WID_SV_ACCEPTS_RATINGS) exists in UpdateWidgetSize(). */
1298 this->FinishInitNested(window_number);
1299
1300 this->groupings[0] = GR_CARGO;
1301 this->sortings[0] = ST_AS_GROUPING;
1302 this->SelectGroupBy(_settings_client.gui.station_gui_group_order);
1303 this->SelectSortBy(_settings_client.gui.station_gui_sort_by);
1304 this->sort_orders[0] = SO_ASCENDING;
1305 this->SelectSortOrder((SortOrder)_settings_client.gui.station_gui_sort_order);
1306 this->owner = Station::Get(window_number)->owner;
1307 }
1308
1309 void Close() override
1310 {
1311 CloseWindowById(WC_TRAINS_LIST, VehicleListIdentifier(VL_STATION_LIST, VEH_TRAIN, this->owner, this->window_number).Pack(), false);
1312 CloseWindowById(WC_ROADVEH_LIST, VehicleListIdentifier(VL_STATION_LIST, VEH_ROAD, this->owner, this->window_number).Pack(), false);
1313 CloseWindowById(WC_SHIPS_LIST, VehicleListIdentifier(VL_STATION_LIST, VEH_SHIP, this->owner, this->window_number).Pack(), false);
1314 CloseWindowById(WC_AIRCRAFT_LIST, VehicleListIdentifier(VL_STATION_LIST, VEH_AIRCRAFT, this->owner, this->window_number).Pack(), false);
1315
1316 SetViewportCatchmentStation(Station::Get(this->window_number), false);
1317 this->Window::Close();
1318 }
1319
1330 void ShowCargo(CargoDataEntry *data, CargoID cargo, StationID source, StationID next, StationID dest, uint count)
1331 {
1332 if (count == 0) return;
1333 bool auto_distributed = _settings_game.linkgraph.GetDistributionType(cargo) != DT_MANUAL;
1334 const CargoDataEntry *expand = &this->expanded_rows;
1335 for (int i = 0; i < NUM_COLUMNS && expand != nullptr; ++i) {
1336 switch (groupings[i]) {
1337 case GR_CARGO:
1338 assert(i == 0);
1339 data = data->InsertOrRetrieve(cargo);
1340 data->SetTransfers(source != this->window_number);
1341 expand = expand->Retrieve(cargo);
1342 break;
1343 case GR_SOURCE:
1344 if (auto_distributed || source != this->window_number) {
1345 data = data->InsertOrRetrieve(source);
1346 expand = expand->Retrieve(source);
1347 }
1348 break;
1349 case GR_NEXT:
1350 if (auto_distributed) {
1351 data = data->InsertOrRetrieve(next);
1352 expand = expand->Retrieve(next);
1353 }
1354 break;
1355 case GR_DESTINATION:
1356 if (auto_distributed) {
1357 data = data->InsertOrRetrieve(dest);
1358 expand = expand->Retrieve(dest);
1359 }
1360 break;
1361 }
1362 }
1363 data->Update(count);
1364 }
1365
1366 void UpdateWidgetSize(int widget, Dimension *size, const Dimension &padding, Dimension *fill, Dimension *resize) override
1367 {
1368 switch (widget) {
1369 case WID_SV_WAITING:
1370 resize->height = FONT_HEIGHT_NORMAL;
1371 size->height = 4 * resize->height + padding.height;
1372 this->expand_shrink_width = std::max(GetStringBoundingBox("-").width, GetStringBoundingBox("+").width);
1373 break;
1374
1375 case WID_SV_ACCEPT_RATING_LIST:
1376 size->height = ((this->GetWidget<NWidgetCore>(WID_SV_ACCEPTS_RATINGS)->widget_data == STR_STATION_VIEW_RATINGS_BUTTON) ? this->accepts_lines : this->rating_lines) * FONT_HEIGHT_NORMAL + padding.height;
1377 break;
1378
1379 case WID_SV_CLOSE_AIRPORT:
1380 if (!(Station::Get(this->window_number)->facilities & FACIL_AIRPORT)) {
1381 /* Hide 'Close Airport' button if no airport present. */
1382 size->width = 0;
1383 resize->width = 0;
1384 fill->width = 0;
1385 }
1386 break;
1387 }
1388 }
1389
1390 void OnPaint() override
1391 {
1392 const Station *st = Station::Get(this->window_number);
1393 CargoDataEntry cargo;
1394 BuildCargoList(&cargo, st);
1395
1396 this->vscroll->SetCount(cargo.GetNumChildren()); // update scrollbar
1397
1398 /* disable some buttons */
1399 this->SetWidgetDisabledState(WID_SV_RENAME, st->owner != _local_company);
1400 this->SetWidgetDisabledState(WID_SV_TRAINS, !(st->facilities & FACIL_TRAIN));
1401 this->SetWidgetDisabledState(WID_SV_ROADVEHS, !(st->facilities & FACIL_TRUCK_STOP) && !(st->facilities & FACIL_BUS_STOP));
1402 this->SetWidgetDisabledState(WID_SV_SHIPS, !(st->facilities & FACIL_DOCK));
1403 this->SetWidgetDisabledState(WID_SV_PLANES, !(st->facilities & FACIL_AIRPORT));
1404 this->SetWidgetDisabledState(WID_SV_CLOSE_AIRPORT, !(st->facilities & FACIL_AIRPORT) || st->owner != _local_company || st->owner == OWNER_NONE); // Also consider SE, where _local_company == OWNER_NONE
1405 this->SetWidgetLoweredState(WID_SV_CLOSE_AIRPORT, (st->facilities & FACIL_AIRPORT) && (st->airport.flags & AIRPORT_CLOSED_block) != 0);
1406
1407 extern const Station *_viewport_highlight_station;
1408 this->SetWidgetDisabledState(WID_SV_CATCHMENT, st->facilities == FACIL_NONE);
1409 this->SetWidgetLoweredState(WID_SV_CATCHMENT, _viewport_highlight_station == st);
1410
1411 this->DrawWidgets();
1412
1413 if (!this->IsShaded()) {
1414 /* Draw 'accepted cargo' or 'cargo ratings'. */
1415 const NWidgetBase *wid = this->GetWidget<NWidgetBase>(WID_SV_ACCEPT_RATING_LIST);
1416 const Rect r = wid->GetCurrentRect();
1417 if (this->GetWidget<NWidgetCore>(WID_SV_ACCEPTS_RATINGS)->widget_data == STR_STATION_VIEW_RATINGS_BUTTON) {
1418 int lines = this->DrawAcceptedCargo(r);
1419 if (lines > this->accepts_lines) { // Resize the widget, and perform re-initialization of the window.
1420 this->accepts_lines = lines;
1421 this->ReInit();
1422 return;
1423 }
1424 } else {
1425 int lines = this->DrawCargoRatings(r);
1426 if (lines > this->rating_lines) { // Resize the widget, and perform re-initialization of the window.
1427 this->rating_lines = lines;
1428 this->ReInit();
1429 return;
1430 }
1431 }
1432
1433 /* Draw arrow pointing up/down for ascending/descending sorting */
1434 this->DrawSortButtonState(WID_SV_SORT_ORDER, sort_orders[1] == SO_ASCENDING ? SBS_UP : SBS_DOWN);
1435
1436 int pos = this->vscroll->GetPosition();
1437
1438 int maxrows = this->vscroll->GetCapacity();
1439
1440 displayed_rows.clear();
1441
1442 /* Draw waiting cargo. */
1443 NWidgetBase *nwi = this->GetWidget<NWidgetBase>(WID_SV_WAITING);
1444 Rect waiting_rect = nwi->GetCurrentRect().Shrink(WidgetDimensions::scaled.framerect);
1445 this->DrawEntries(&cargo, waiting_rect, pos, maxrows, 0);
1446 scroll_to_row = INT_MAX;
1447 }
1448 }
1449
1450 void SetStringParameters(int widget) const override
1451 {
1452 const Station *st = Station::Get(this->window_number);
1453 SetDParam(0, st->index);
1454 SetDParam(1, st->facilities);
1455 }
1456
1462 void RecalcDestinations(CargoID i)
1463 {
1464 const Station *st = Station::Get(this->window_number);
1465 CargoDataEntry *cargo_entry = cached_destinations.InsertOrRetrieve(i);
1466 cargo_entry->Clear();
1467
1468 const FlowStatMap &flows = st->goods[i].flows;
1469 for (FlowStatMap::const_iterator it = flows.begin(); it != flows.end(); ++it) {
1470 StationID from = it->first;
1471 CargoDataEntry *source_entry = cargo_entry->InsertOrRetrieve(from);
1472 const FlowStat::SharesMap *shares = it->second.GetShares();
1473 uint32 prev_count = 0;
1474 for (FlowStat::SharesMap::const_iterator flow_it = shares->begin(); flow_it != shares->end(); ++flow_it) {
1475 StationID via = flow_it->second;
1476 CargoDataEntry *via_entry = source_entry->InsertOrRetrieve(via);
1477 if (via == this->window_number) {
1478 via_entry->InsertOrRetrieve(via)->Update(flow_it->first - prev_count);
1479 } else {
1480 EstimateDestinations(i, from, via, flow_it->first - prev_count, via_entry);
1481 }
1482 prev_count = flow_it->first;
1483 }
1484 }
1485 }
1486
1496 void EstimateDestinations(CargoID cargo, StationID source, StationID next, uint count, CargoDataEntry *dest)
1497 {
1498 if (Station::IsValidID(next) && Station::IsValidID(source)) {
1499 CargoDataEntry tmp;
1500 const FlowStatMap &flowmap = Station::Get(next)->goods[cargo].flows;
1501 FlowStatMap::const_iterator map_it = flowmap.find(source);
1502 if (map_it != flowmap.end()) {
1503 const FlowStat::SharesMap *shares = map_it->second.GetShares();
1504 uint32 prev_count = 0;
1505 for (FlowStat::SharesMap::const_iterator i = shares->begin(); i != shares->end(); ++i) {
1506 tmp.InsertOrRetrieve(i->second)->Update(i->first - prev_count);
1507 prev_count = i->first;
1508 }
1509 }
1510
1511 if (tmp.GetCount() == 0) {
1512 dest->InsertOrRetrieve(INVALID_STATION)->Update(count);
1513 } else {
1514 uint sum_estimated = 0;
1515 while (sum_estimated < count) {
1516 for (CargoDataSet::iterator i = tmp.Begin(); i != tmp.End() && sum_estimated < count; ++i) {
1517 CargoDataEntry *child = *i;
1518 uint estimate = DivideApprox(child->GetCount() * count, tmp.GetCount());
1519 if (estimate == 0) estimate = 1;
1520
1521 sum_estimated += estimate;
1522 if (sum_estimated > count) {
1523 estimate -= sum_estimated - count;
1524 sum_estimated = count;
1525 }
1526
1527 if (estimate > 0) {
1528 if (child->GetStation() == next) {
1529 dest->InsertOrRetrieve(next)->Update(estimate);
1530 } else {
1531 EstimateDestinations(cargo, source, child->GetStation(), estimate, dest);
1532 }
1533 }
1534 }
1535
1536 }
1537 }
1538 } else {
1539 dest->InsertOrRetrieve(INVALID_STATION)->Update(count);
1540 }
1541 }
1542
1549 void BuildFlowList(CargoID i, const FlowStatMap &flows, CargoDataEntry *cargo)
1550 {
1551 const CargoDataEntry *source_dest = this->cached_destinations.Retrieve(i);
1552 for (FlowStatMap::const_iterator it = flows.begin(); it != flows.end(); ++it) {
1553 StationID from = it->first;
1554 const CargoDataEntry *source_entry = source_dest->Retrieve(from);
1555 const FlowStat::SharesMap *shares = it->second.GetShares();
1556 for (FlowStat::SharesMap::const_iterator flow_it = shares->begin(); flow_it != shares->end(); ++flow_it) {
1557 const CargoDataEntry *via_entry = source_entry->Retrieve(flow_it->second);
1558 for (CargoDataSet::iterator dest_it = via_entry->Begin(); dest_it != via_entry->End(); ++dest_it) {
1559 CargoDataEntry *dest_entry = *dest_it;
1560 ShowCargo(cargo, i, from, flow_it->second, dest_entry->GetStation(), dest_entry->GetCount());
1561 }
1562 }
1563 }
1564 }
1565
1572 void BuildCargoList(CargoID i, const StationCargoList &packets, CargoDataEntry *cargo)
1573 {
1574 const CargoDataEntry *source_dest = this->cached_destinations.Retrieve(i);
1575 for (StationCargoList::ConstIterator it = packets.Packets()->begin(); it != packets.Packets()->end(); it++) {
1576 const CargoPacket *cp = *it;
1577 StationID next = it.GetKey();
1578
1579 const CargoDataEntry *source_entry = source_dest->Retrieve(cp->SourceStation());
1580 if (source_entry == nullptr) {
1581 this->ShowCargo(cargo, i, cp->SourceStation(), next, INVALID_STATION, cp->Count());
1582 continue;
1583 }
1584
1585 const CargoDataEntry *via_entry = source_entry->Retrieve(next);
1586 if (via_entry == nullptr) {
1587 this->ShowCargo(cargo, i, cp->SourceStation(), next, INVALID_STATION, cp->Count());
1588 continue;
1589 }
1590
1591 for (CargoDataSet::iterator dest_it = via_entry->Begin(); dest_it != via_entry->End(); ++dest_it) {
1592 CargoDataEntry *dest_entry = *dest_it;
1593 uint val = DivideApprox(cp->Count() * dest_entry->GetCount(), via_entry->GetCount());
1594 this->ShowCargo(cargo, i, cp->SourceStation(), next, dest_entry->GetStation(), val);
1595 }
1596 }
1597 this->ShowCargo(cargo, i, NEW_STATION, NEW_STATION, NEW_STATION, packets.ReservedCount());
1598 }
1599
1605 void BuildCargoList(CargoDataEntry *cargo, const Station *st)
1606 {
1607 for (CargoID i = 0; i < NUM_CARGO; i++) {
1608
1609 if (this->cached_destinations.Retrieve(i) == nullptr) {
1610 this->RecalcDestinations(i);
1611 }
1612
1613 if (this->current_mode == MODE_WAITING) {
1614 this->BuildCargoList(i, st->goods[i].cargo, cargo);
1615 } else {
1616 this->BuildFlowList(i, st->goods[i].flows, cargo);
1617 }
1618 }
1619 }
1620
1625 void SetDisplayedRow(const CargoDataEntry *data)
1626 {
1627 std::list<StationID> stations;
1628 const CargoDataEntry *parent = data->GetParent();
1629 if (parent->GetParent() == nullptr) {
1630 this->displayed_rows.push_back(RowDisplay(&this->expanded_rows, data->GetCargo()));
1631 return;
1632 }
1633
1634 StationID next = data->GetStation();
1635 while (parent->GetParent()->GetParent() != nullptr) {
1636 stations.push_back(parent->GetStation());
1637 parent = parent->GetParent();
1638 }
1639
1640 CargoID cargo = parent->GetCargo();
1641 CargoDataEntry *filter = this->expanded_rows.Retrieve(cargo);
1642 while (!stations.empty()) {
1643 filter = filter->Retrieve(stations.back());
1644 stations.pop_back();
1645 }
1646
1647 this->displayed_rows.push_back(RowDisplay(filter, next));
1648 }
1649
1658 StringID GetEntryString(StationID station, StringID here, StringID other_station, StringID any)
1659 {
1660 if (station == this->window_number) {
1661 return here;
1662 } else if (station == INVALID_STATION) {
1663 return any;
1664 } else if (station == NEW_STATION) {
1665 return STR_STATION_VIEW_RESERVED;
1666 } else {
1667 SetDParam(2, station);
1668 return other_station;
1669 }
1670 }
1671
1679 StringID SearchNonStop(CargoDataEntry *cd, StationID station, int column)
1680 {
1681 CargoDataEntry *parent = cd->GetParent();
1682 for (int i = column - 1; i > 0; --i) {
1683 if (this->groupings[i] == GR_DESTINATION) {
1684 if (parent->GetStation() == station) {
1685 return STR_STATION_VIEW_NONSTOP;
1686 } else {
1687 return STR_STATION_VIEW_VIA;
1688 }
1689 }
1690 parent = parent->GetParent();
1691 }
1692
1693 if (this->groupings[column + 1] == GR_DESTINATION) {
1694 CargoDataSet::iterator begin = cd->Begin();
1695 CargoDataSet::iterator end = cd->End();
1696 if (begin != end && ++(cd->Begin()) == end && (*(begin))->GetStation() == station) {
1697 return STR_STATION_VIEW_NONSTOP;
1698 } else {
1699 return STR_STATION_VIEW_VIA;
1700 }
1701 }
1702
1703 return STR_STATION_VIEW_VIA;
1704 }
1705
1716 int DrawEntries(CargoDataEntry *entry, const Rect &r, int pos, int maxrows, int column, CargoID cargo = CT_INVALID)
1717 {
1718 if (this->sortings[column] == ST_AS_GROUPING) {
1719 if (this->groupings[column] != GR_CARGO) {
1720 entry->Resort(ST_STATION_STRING, this->sort_orders[column]);
1721 }
1722 } else {
1723 entry->Resort(ST_COUNT, this->sort_orders[column]);
1724 }
1725 for (CargoDataSet::iterator i = entry->Begin(); i != entry->End(); ++i) {
1726 CargoDataEntry *cd = *i;
1727
1728 Grouping grouping = this->groupings[column];
1729 if (grouping == GR_CARGO) cargo = cd->GetCargo();
1730 bool auto_distributed = _settings_game.linkgraph.GetDistributionType(cargo) != DT_MANUAL;
1731
1732 if (pos > -maxrows && pos <= 0) {
1733 StringID str = STR_EMPTY;
1734 int y = r.top - pos * FONT_HEIGHT_NORMAL;
1735 SetDParam(0, cargo);
1736 SetDParam(1, cd->GetCount());
1737
1738 if (this->groupings[column] == GR_CARGO) {
1739 str = STR_STATION_VIEW_WAITING_CARGO;
1740 DrawCargoIcons(cd->GetCargo(), cd->GetCount(), r.left + this->expand_shrink_width, r.right - this->expand_shrink_width, y);
1741 } else {
1742 if (!auto_distributed) grouping = GR_SOURCE;
1743 StationID station = cd->GetStation();
1744
1745 switch (grouping) {
1746 case GR_SOURCE:
1747 str = this->GetEntryString(station, STR_STATION_VIEW_FROM_HERE, STR_STATION_VIEW_FROM, STR_STATION_VIEW_FROM_ANY);
1748 break;
1749 case GR_NEXT:
1750 str = this->GetEntryString(station, STR_STATION_VIEW_VIA_HERE, STR_STATION_VIEW_VIA, STR_STATION_VIEW_VIA_ANY);
1751 if (str == STR_STATION_VIEW_VIA) str = this->SearchNonStop(cd, station, column);
1752 break;
1753 case GR_DESTINATION:
1754 str = this->GetEntryString(station, STR_STATION_VIEW_TO_HERE, STR_STATION_VIEW_TO, STR_STATION_VIEW_TO_ANY);
1755 break;
1756 default:
1757 NOT_REACHED();
1758 }
1759 if (pos == -this->scroll_to_row && Station::IsValidID(station)) {
1760 ScrollMainWindowToTile(Station::Get(station)->xy);
1761 }
1762 }
1763
1764 bool rtl = _current_text_dir == TD_RTL;
1765 Rect text = r.Indent(column * WidgetDimensions::scaled.hsep_indent, rtl).Indent(this->expand_shrink_width, !rtl);
1766 Rect shrink = r.WithWidth(this->expand_shrink_width, !rtl);
1767
1768 DrawString(text.left, text.right, y, str);
1769
1770 if (column < NUM_COLUMNS - 1) {
1771 const char *sym = nullptr;
1772 if (cd->GetNumChildren() > 0) {
1773 sym = "-";
1774 } else if (auto_distributed && str != STR_STATION_VIEW_RESERVED) {
1775 sym = "+";
1776 } else {
1777 /* Only draw '+' if there is something to be shown. */
1778 const StationCargoList &list = Station::Get(this->window_number)->goods[cargo].cargo;
1779 if (grouping == GR_CARGO && (list.ReservedCount() > 0 || cd->HasTransfers())) {
1780 sym = "+";
1781 }
1782 }
1783 if (sym != nullptr) DrawString(shrink.left, shrink.right, y, sym, TC_YELLOW);
1784 }
1785 this->SetDisplayedRow(cd);
1786 }
1787 --pos;
1788 if (auto_distributed || column == 0) {
1789 pos = this->DrawEntries(cd, r, pos, maxrows, column + 1, cargo);
1790 }
1791 }
1792 return pos;
1793 }
1794
1800 int DrawAcceptedCargo(const Rect &r) const
1801 {
1802 const Station *st = Station::Get(this->window_number);
1803 Rect tr = r.Shrink(WidgetDimensions::scaled.framerect);
1804
1805 CargoTypes cargo_mask = 0;
1806 for (CargoID i = 0; i < NUM_CARGO; i++) {
1807 if (HasBit(st->goods[i].status, GoodsEntry::GES_ACCEPTANCE)) SetBit(cargo_mask, i);
1808 }
1809 SetDParam(0, cargo_mask);
1810 int bottom = DrawStringMultiLine(tr.left, tr.right, tr.top, INT32_MAX, STR_STATION_VIEW_ACCEPTS_CARGO);
1811 return CeilDiv(bottom - r.top - WidgetDimensions::scaled.framerect.top, FONT_HEIGHT_NORMAL);
1812 }
1813
1819 int DrawCargoRatings(const Rect &r) const
1820 {
1821 const Station *st = Station::Get(this->window_number);
1822 bool rtl = _current_text_dir == TD_RTL;
1823 Rect tr = r.Shrink(WidgetDimensions::scaled.framerect);
1824
1825 if (st->town->exclusive_counter > 0) {
1826 SetDParam(0, st->town->exclusivity);
1827 tr.top = DrawStringMultiLine(tr, st->town->exclusivity == st->owner ? STR_STATION_VIEW_EXCLUSIVE_RIGHTS_SELF : STR_STATION_VIEW_EXCLUSIVE_RIGHTS_COMPANY);
1828 tr.top += WidgetDimensions::scaled.vsep_wide;
1829 }
1830
1831 DrawString(tr, STR_STATION_VIEW_SUPPLY_RATINGS_TITLE);
1832 tr.top += FONT_HEIGHT_NORMAL;
1833
1834 for (const CargoSpec *cs : _sorted_standard_cargo_specs) {
1835 const GoodsEntry *ge = &st->goods[cs->Index()];
1836 if (!ge->HasRating()) continue;
1837
1838 const LinkGraph *lg = LinkGraph::GetIfValid(ge->link_graph);
1839 SetDParam(0, cs->name);
1840 SetDParam(1, lg != nullptr ? lg->Monthly((*lg)[ge->node].Supply()) : 0);
1841 SetDParam(2, STR_CARGO_RATING_APPALLING + (ge->rating >> 5));
1842 SetDParam(3, ToPercent8(ge->rating));
1843 DrawString(tr.Indent(WidgetDimensions::scaled.hsep_indent, rtl), STR_STATION_VIEW_CARGO_SUPPLY_RATING);
1844 tr.top += FONT_HEIGHT_NORMAL;
1845 }
1846 return CeilDiv(tr.top - r.top - WidgetDimensions::scaled.framerect.top, FONT_HEIGHT_NORMAL);
1847 }
1848
1854 template<class Tid>
1855 void HandleCargoWaitingClick(CargoDataEntry *filter, Tid next)
1856 {
1857 if (filter->Retrieve(next) != nullptr) {
1858 filter->Remove(next);
1859 } else {
1860 filter->InsertOrRetrieve(next);
1861 }
1862 }
1863
1868 void HandleCargoWaitingClick(int row)
1869 {
1870 if (row < 0 || (uint)row >= this->displayed_rows.size()) return;
1871 if (_ctrl_pressed) {
1872 this->scroll_to_row = row;
1873 } else {
1874 RowDisplay &display = this->displayed_rows[row];
1875 if (display.filter == &this->expanded_rows) {
1876 this->HandleCargoWaitingClick<CargoID>(display.filter, display.next_cargo);
1877 } else {
1878 this->HandleCargoWaitingClick<StationID>(display.filter, display.next_station);
1879 }
1880 }
1881 this->SetWidgetDirty(WID_SV_WAITING);
1882 }
1883
1884 void OnClick(Point pt, int widget, int click_count) override
1885 {
1886 switch (widget) {
1887 case WID_SV_WAITING:
1888 this->HandleCargoWaitingClick(this->vscroll->GetScrolledRowFromWidget(pt.y, this, WID_SV_WAITING, WidgetDimensions::scaled.framerect.top) - this->vscroll->GetPosition());
1889 break;
1890
1891 case WID_SV_CATCHMENT:
1892 SetViewportCatchmentStation(Station::Get(this->window_number), !this->IsWidgetLowered(WID_SV_CATCHMENT));
1893 break;
1894
1895 case WID_SV_LOCATION:
1896 if (_ctrl_pressed) {
1897 ShowExtraViewportWindow(Station::Get(this->window_number)->xy);
1898 } else {
1899 ScrollMainWindowToTile(Station::Get(this->window_number)->xy);
1900 }
1901 break;
1902
1903 case WID_SV_ACCEPTS_RATINGS: {
1904 /* Swap between 'accepts' and 'ratings' view. */
1905 int height_change;
1906 NWidgetCore *nwi = this->GetWidget<NWidgetCore>(WID_SV_ACCEPTS_RATINGS);
1907 if (this->GetWidget<NWidgetCore>(WID_SV_ACCEPTS_RATINGS)->widget_data == STR_STATION_VIEW_RATINGS_BUTTON) {
1908 nwi->SetDataTip(STR_STATION_VIEW_ACCEPTS_BUTTON, STR_STATION_VIEW_ACCEPTS_TOOLTIP); // Switch to accepts view.
1909 height_change = this->rating_lines - this->accepts_lines;
1910 } else {
1911 nwi->SetDataTip(STR_STATION_VIEW_RATINGS_BUTTON, STR_STATION_VIEW_RATINGS_TOOLTIP); // Switch to ratings view.
1912 height_change = this->accepts_lines - this->rating_lines;
1913 }
1914 this->ReInit(0, height_change * FONT_HEIGHT_NORMAL);
1915 break;
1916 }
1917
1918 case WID_SV_RENAME:
1919 SetDParam(0, this->window_number);
1920 ShowQueryString(STR_STATION_NAME, STR_STATION_VIEW_RENAME_STATION_CAPTION, MAX_LENGTH_STATION_NAME_CHARS,
1921 this, CS_ALPHANUMERAL, QSF_ENABLE_DEFAULT | QSF_LEN_IN_CHARS);
1922 break;
1923
1924 case WID_SV_CLOSE_AIRPORT:
1925 Command<CMD_OPEN_CLOSE_AIRPORT>::Post(this->window_number);
1926 break;
1927
1928 case WID_SV_TRAINS: // Show list of scheduled trains to this station
1929 case WID_SV_ROADVEHS: // Show list of scheduled road-vehicles to this station
1930 case WID_SV_SHIPS: // Show list of scheduled ships to this station
1931 case WID_SV_PLANES: { // Show list of scheduled aircraft to this station
1932 Owner owner = Station::Get(this->window_number)->owner;
1933 ShowVehicleListWindow(owner, (VehicleType)(widget - WID_SV_TRAINS), (StationID)this->window_number);
1934 break;
1935 }
1936
1937 case WID_SV_SORT_BY: {
1938 /* The initial selection is composed of current mode and
1939 * sorting criteria for columns 1, 2, and 3. Column 0 is always
1940 * sorted by cargo ID. The others can theoretically be sorted
1941 * by different things but there is no UI for that. */
1942 ShowDropDownMenu(this, _sort_names,
1943 this->current_mode * 2 + (this->sortings[1] == ST_COUNT ? 1 : 0),
1944 WID_SV_SORT_BY, 0, 0);
1945 break;
1946 }
1947
1948 case WID_SV_GROUP_BY: {
1949 ShowDropDownMenu(this, _group_names, this->grouping_index, WID_SV_GROUP_BY, 0, 0);
1950 break;
1951 }
1952
1953 case WID_SV_SORT_ORDER: { // flip sorting method asc/desc
1954 this->SelectSortOrder(this->sort_orders[1] == SO_ASCENDING ? SO_DESCENDING : SO_ASCENDING);
1955 this->SetTimeout();
1956 this->LowerWidget(WID_SV_SORT_ORDER);
1957 break;
1958 }
1959 }
1960 }
1961
1966 void SelectSortOrder(SortOrder order)
1967 {
1968 this->sort_orders[1] = this->sort_orders[2] = this->sort_orders[3] = order;
1969 _settings_client.gui.station_gui_sort_order = this->sort_orders[1];
1970 this->SetDirty();
1971 }
1972
1977 void SelectSortBy(int index)
1978 {
1979 _settings_client.gui.station_gui_sort_by = index;
1980 switch (_sort_names[index]) {
1981 case STR_STATION_VIEW_WAITING_STATION:
1982 this->current_mode = MODE_WAITING;
1983 this->sortings[1] = this->sortings[2] = this->sortings[3] = ST_AS_GROUPING;
1984 break;
1985 case STR_STATION_VIEW_WAITING_AMOUNT:
1986 this->current_mode = MODE_WAITING;
1987 this->sortings[1] = this->sortings[2] = this->sortings[3] = ST_COUNT;
1988 break;
1989 case STR_STATION_VIEW_PLANNED_STATION:
1990 this->current_mode = MODE_PLANNED;
1991 this->sortings[1] = this->sortings[2] = this->sortings[3] = ST_AS_GROUPING;
1992 break;
1993 case STR_STATION_VIEW_PLANNED_AMOUNT:
1994 this->current_mode = MODE_PLANNED;
1995 this->sortings[1] = this->sortings[2] = this->sortings[3] = ST_COUNT;
1996 break;
1997 default:
1998 NOT_REACHED();
1999 }
2000 /* Display the current sort variant */
2001 this->GetWidget<NWidgetCore>(WID_SV_SORT_BY)->widget_data = _sort_names[index];
2002 this->SetDirty();
2003 }
2004
2009 void SelectGroupBy(int index)
2010 {
2011 this->grouping_index = index;
2012 _settings_client.gui.station_gui_group_order = index;
2013 this->GetWidget<NWidgetCore>(WID_SV_GROUP_BY)->widget_data = _group_names[index];
2014 switch (_group_names[index]) {
2015 case STR_STATION_VIEW_GROUP_S_V_D:
2016 this->groupings[1] = GR_SOURCE;
2017 this->groupings[2] = GR_NEXT;
2018 this->groupings[3] = GR_DESTINATION;
2019 break;
2020 case STR_STATION_VIEW_GROUP_S_D_V:
2021 this->groupings[1] = GR_SOURCE;
2022 this->groupings[2] = GR_DESTINATION;
2023 this->groupings[3] = GR_NEXT;
2024 break;
2025 case STR_STATION_VIEW_GROUP_V_S_D:
2026 this->groupings[1] = GR_NEXT;
2027 this->groupings[2] = GR_SOURCE;
2028 this->groupings[3] = GR_DESTINATION;
2029 break;
2030 case STR_STATION_VIEW_GROUP_V_D_S:
2031 this->groupings[1] = GR_NEXT;
2032 this->groupings[2] = GR_DESTINATION;
2033 this->groupings[3] = GR_SOURCE;
2034 break;
2035 case STR_STATION_VIEW_GROUP_D_S_V:
2036 this->groupings[1] = GR_DESTINATION;
2037 this->groupings[2] = GR_SOURCE;
2038 this->groupings[3] = GR_NEXT;
2039 break;
2040 case STR_STATION_VIEW_GROUP_D_V_S:
2041 this->groupings[1] = GR_DESTINATION;
2042 this->groupings[2] = GR_NEXT;
2043 this->groupings[3] = GR_SOURCE;
2044 break;
2045 }
2046 this->SetDirty();
2047 }
2048
2049 void OnDropdownSelect(int widget, int index) override
2050 {
2051 if (widget == WID_SV_SORT_BY) {
2052 this->SelectSortBy(index);
2053 } else {
2054 this->SelectGroupBy(index);
2055 }
2056 }
2057
2058 void OnQueryTextFinished(char *str) override
2059 {
2060 if (str == nullptr) return;
2061
2062 Command<CMD_RENAME_STATION>::Post(STR_ERROR_CAN_T_RENAME_STATION, this->window_number, str);
2063 }
2064
2065 void OnResize() override
2066 {
2067 this->vscroll->SetCapacityFromWidget(this, WID_SV_WAITING, WidgetDimensions::scaled.framerect.Vertical());
2068 }
2069
2075 void OnInvalidateData(int data = 0, bool gui_scope = true) override
2076 {
2077 if (gui_scope) {
2078 if (data >= 0 && data < NUM_CARGO) {
2079 this->cached_destinations.Remove((CargoID)data);
2080 } else {
2081 this->ReInit();
2082 }
2083 }
2084 }
2085 };
2086
2087 const StringID StationViewWindow::_sort_names[] = {
2088 STR_STATION_VIEW_WAITING_STATION,
2089 STR_STATION_VIEW_WAITING_AMOUNT,
2090 STR_STATION_VIEW_PLANNED_STATION,
2091 STR_STATION_VIEW_PLANNED_AMOUNT,
2092 INVALID_STRING_ID
2093 };
2094
2095 const StringID StationViewWindow::_group_names[] = {
2096 STR_STATION_VIEW_GROUP_S_V_D,
2097 STR_STATION_VIEW_GROUP_S_D_V,
2098 STR_STATION_VIEW_GROUP_V_S_D,
2099 STR_STATION_VIEW_GROUP_V_D_S,
2100 STR_STATION_VIEW_GROUP_D_S_V,
2101 STR_STATION_VIEW_GROUP_D_V_S,
2102 INVALID_STRING_ID
2103 };
2104
2105 static WindowDesc _station_view_desc(
2106 WDP_AUTO, "view_station", 249, 117,
2107 WC_STATION_VIEW, WC_NONE,
2108 0,
2109 _nested_station_view_widgets, lengthof(_nested_station_view_widgets)
2110 );
2111
2117 void ShowStationViewWindow(StationID station)
2118 {
2119 AllocateWindowDescFront<StationViewWindow>(&_station_view_desc, station);
2120 }
2121
2123 struct TileAndStation {
2124 TileIndex tile;
2125 StationID station;
2126 };
2127
2128 static std::vector<TileAndStation> _deleted_stations_nearby;
2129 static std::vector<StationID> _stations_nearby_list;
2130
2138 template <class T>
2139 static bool AddNearbyStation(TileIndex tile, void *user_data)
2140 {
2141 TileArea *ctx = (TileArea *)user_data;
2142
2143 /* First check if there were deleted stations here */
2144 for (uint i = 0; i < _deleted_stations_nearby.size(); i++) {
2145 auto ts = _deleted_stations_nearby.begin() + i;
2146 if (ts->tile == tile) {
2147 _stations_nearby_list.push_back(_deleted_stations_nearby[i].station);
2148 _deleted_stations_nearby.erase(ts);
2149 i--;
2150 }
2151 }
2152
2153 /* Check if own station and if we stay within station spread */
2154 if (!IsTileType(tile, MP_STATION)) return false;
2155
2156 StationID sid = GetStationIndex(tile);
2157
2158 /* This station is (likely) a waypoint */
2159 if (!T::IsValidID(sid)) return false;
2160
2161 T *st = T::Get(sid);
2162 if (st->owner != _local_company || std::find(_stations_nearby_list.begin(), _stations_nearby_list.end(), sid) != _stations_nearby_list.end()) return false;
2163
2164 if (st->rect.BeforeAddRect(ctx->tile, ctx->w, ctx->h, StationRect::ADD_TEST).Succeeded()) {
2165 _stations_nearby_list.push_back(sid);
2166 }
2167
2168 return false; // We want to include *all* nearby stations
2169 }
2170
2180 template <class T>
2181 static const T *FindStationsNearby(TileArea ta, bool distant_join)
2182 {
2183 TileArea ctx = ta;
2184
2185 _stations_nearby_list.clear();
2186 _deleted_stations_nearby.clear();
2187
2188 /* Check the inside, to return, if we sit on another station */
2189 for (TileIndex t : ta) {
2190 if (t < MapSize() && IsTileType(t, MP_STATION) && T::IsValidID(GetStationIndex(t))) return T::GetByTile(t);
2191 }
2192
2193 /* Look for deleted stations */
2194 for (const BaseStation *st : BaseStation::Iterate()) {
2195 if (T::IsExpected(st) && !st->IsInUse() && st->owner == _local_company) {
2196 /* Include only within station spread (yes, it is strictly less than) */
2197 if (std::max(DistanceMax(ta.tile, st->xy), DistanceMax(TILE_ADDXY(ta.tile, ta.w - 1, ta.h - 1), st->xy)) < _settings_game.station.station_spread) {
2198 _deleted_stations_nearby.push_back({st->xy, st->index});
2199
2200 /* Add the station when it's within where we're going to build */
2201 if (IsInsideBS(TileX(st->xy), TileX(ctx.tile), ctx.w) &&
2202 IsInsideBS(TileY(st->xy), TileY(ctx.tile), ctx.h)) {
2203 AddNearbyStation<T>(st->xy, &ctx);
2204 }
2205 }
2206 }
2207 }
2208
2209 /* Only search tiles where we have a chance to stay within the station spread.
2210 * The complete check needs to be done in the callback as we don't know the
2211 * extent of the found station, yet. */
2212 if (distant_join && std::min(ta.w, ta.h) >= _settings_game.station.station_spread) return nullptr;
2213 uint max_dist = distant_join ? _settings_game.station.station_spread - std::min(ta.w, ta.h) : 1;
2214
2215 TileIndex tile = TileAddByDir(ctx.tile, DIR_N);
2216 CircularTileSearch(&tile, max_dist, ta.w, ta.h, AddNearbyStation<T>, &ctx);
2217
2218 return nullptr;
2219 }
2220
2221 static const NWidgetPart _nested_select_station_widgets[] = {
2222 NWidget(NWID_HORIZONTAL),
2223 NWidget(WWT_CLOSEBOX, COLOUR_DARK_GREEN),
2224 NWidget(WWT_CAPTION, COLOUR_DARK_GREEN, WID_JS_CAPTION), SetDataTip(STR_JOIN_STATION_CAPTION, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
2225 NWidget(WWT_DEFSIZEBOX, COLOUR_DARK_GREEN),
2226 EndContainer(),
2227 NWidget(NWID_HORIZONTAL),
2228 NWidget(WWT_PANEL, COLOUR_DARK_GREEN, WID_JS_PANEL), SetResize(1, 0), SetScrollbar(WID_JS_SCROLLBAR), EndContainer(),
2229 NWidget(NWID_VERTICAL),
2230 NWidget(NWID_VSCROLLBAR, COLOUR_DARK_GREEN, WID_JS_SCROLLBAR),
2231 NWidget(WWT_RESIZEBOX, COLOUR_DARK_GREEN),
2232 EndContainer(),
2233 EndContainer(),
2234 };
2235
2240 template <class T>
2241 struct SelectStationWindow : Window {
2242 StationPickerCmdProc select_station_proc;
2243 TileArea area;
2244 Scrollbar *vscroll;
2245
2246 SelectStationWindow(WindowDesc *desc, TileArea ta, StationPickerCmdProc&& proc) :
2247 Window(desc),
2248 select_station_proc(std::move(proc)),
2249 area(ta)
2250 {
2251 this->CreateNestedTree();
2252 this->vscroll = this->GetScrollbar(WID_JS_SCROLLBAR);
2253 this->GetWidget<NWidgetCore>(WID_JS_CAPTION)->widget_data = T::EXPECTED_FACIL == FACIL_WAYPOINT ? STR_JOIN_WAYPOINT_CAPTION : STR_JOIN_STATION_CAPTION;
2254 this->FinishInitNested(0);
2255 this->OnInvalidateData(0);
2256
2257 _thd.freeze = true;
2258 }
2259
2260 void Close() override
2261 {
2262 if (_settings_client.gui.station_show_coverage) SetViewportCatchmentStation(nullptr, true);
2263
2264 _thd.freeze = false;
2265 this->Window::Close();
2266 }
2267
2268 void UpdateWidgetSize(int widget, Dimension *size, const Dimension &padding, Dimension *fill, Dimension *resize) override
2269 {
2270 if (widget != WID_JS_PANEL) return;
2271
2272 /* Determine the widest string */
2273 Dimension d = GetStringBoundingBox(T::EXPECTED_FACIL == FACIL_WAYPOINT ? STR_JOIN_WAYPOINT_CREATE_SPLITTED_WAYPOINT : STR_JOIN_STATION_CREATE_SPLITTED_STATION);
2274 for (uint i = 0; i < _stations_nearby_list.size(); i++) {
2275 const T *st = T::Get(_stations_nearby_list[i]);
2276 SetDParam(0, st->index);
2277 SetDParam(1, st->facilities);
2278 d = maxdim(d, GetStringBoundingBox(T::EXPECTED_FACIL == FACIL_WAYPOINT ? STR_STATION_LIST_WAYPOINT : STR_STATION_LIST_STATION));
2279 }
2280
2281 resize->height = d.height;
2282 d.height *= 5;
2283 d.width += padding.width;
2284 d.height += padding.height;
2285 *size = d;
2286 }
2287
2288 void DrawWidget(const Rect &r, int widget) const override
2289 {
2290 if (widget != WID_JS_PANEL) return;
2291
2292 Rect tr = r.Shrink(WidgetDimensions::scaled.framerect);
2293 if (this->vscroll->GetPosition() == 0) {
2294 DrawString(tr, T::EXPECTED_FACIL == FACIL_WAYPOINT ? STR_JOIN_WAYPOINT_CREATE_SPLITTED_WAYPOINT : STR_JOIN_STATION_CREATE_SPLITTED_STATION);
2295 tr.top += this->resize.step_height;
2296 }
2297
2298 for (uint i = std::max<uint>(1, this->vscroll->GetPosition()); i <= _stations_nearby_list.size(); ++i, tr.top += this->resize.step_height) {
2299 /* Don't draw anything if it extends past the end of the window. */
2300 if (i - this->vscroll->GetPosition() >= this->vscroll->GetCapacity()) break;
2301
2302 const T *st = T::Get(_stations_nearby_list[i - 1]);
2303 SetDParam(0, st->index);
2304 SetDParam(1, st->facilities);
2305 DrawString(tr, T::EXPECTED_FACIL == FACIL_WAYPOINT ? STR_STATION_LIST_WAYPOINT : STR_STATION_LIST_STATION);
2306 }
2307 }
2308
2309 void OnClick(Point pt, int widget, int click_count) override
2310 {
2311 if (widget != WID_JS_PANEL) return;
2312
2313 uint st_index = this->vscroll->GetScrolledRowFromWidget(pt.y, this, WID_JS_PANEL, WidgetDimensions::scaled.framerect.top);
2314 bool distant_join = (st_index > 0);
2315 if (distant_join) st_index--;
2316
2317 if (distant_join && st_index >= _stations_nearby_list.size()) return;
2318
2319 /* Execute stored Command */
2320 this->select_station_proc(false, distant_join ? _stations_nearby_list[st_index] : NEW_STATION);
2321
2322 /* Close Window; this might cause double frees! */
2323 CloseWindowById(WC_SELECT_STATION, 0);
2324 }
2325
2326 void OnRealtimeTick(uint delta_ms) override
2327 {
2328 if (_thd.dirty & 2) {
2329 _thd.dirty &= ~2;
2330 this->SetDirty();
2331 }
2332 }
2333
2334 void OnResize() override
2335 {
2336 this->vscroll->SetCapacityFromWidget(this, WID_JS_PANEL, WidgetDimensions::scaled.framerect.Vertical());
2337 }
2338
2344 void OnInvalidateData(int data = 0, bool gui_scope = true) override
2345 {
2346 if (!gui_scope) return;
2347 FindStationsNearby<T>(this->area, true);
2348 this->vscroll->SetCount((uint)_stations_nearby_list.size() + 1);
2349 this->SetDirty();
2350 }
2351
2352 void OnMouseOver(Point pt, int widget) override
2353 {
2354 if (widget != WID_JS_PANEL || T::EXPECTED_FACIL == FACIL_WAYPOINT) {
2355 SetViewportCatchmentStation(nullptr, true);
2356 return;
2357 }
2358
2359 /* Show coverage area of station under cursor */
2360 uint st_index = this->vscroll->GetScrolledRowFromWidget(pt.y, this, WID_JS_PANEL, WidgetDimensions::scaled.framerect.top);
2361 if (st_index == 0 || st_index > _stations_nearby_list.size()) {
2362 SetViewportCatchmentStation(nullptr, true);
2363 } else {
2364 st_index--;
2365 SetViewportCatchmentStation(Station::Get(_stations_nearby_list[st_index]), true);
2366 }
2367 }
2368 };
2369
2370 static WindowDesc _select_station_desc(
2371 WDP_AUTO, "build_station_join", 200, 180,
2372 WC_SELECT_STATION, WC_NONE,
2373 WDF_CONSTRUCTION,
2374 _nested_select_station_widgets, lengthof(_nested_select_station_widgets)
2375 );
2376
2377
2385 template <class T>
2386 static bool StationJoinerNeeded(TileArea ta, const StationPickerCmdProc &proc)
2387 {
2388 /* Only show selection if distant join is enabled in the settings */
2389 if (!_settings_game.station.distant_join_stations) return false;
2390
2391 /* If a window is already opened and we didn't ctrl-click,
2392 * return true (i.e. just flash the old window) */
2393 Window *selection_window = FindWindowById(WC_SELECT_STATION, 0);
2394 if (selection_window != nullptr) {
2395 /* Abort current distant-join and start new one */
2396 selection_window->Close();
2397 UpdateTileSelection();
2398 }
2399
2400 /* only show the popup, if we press ctrl */
2401 if (!_ctrl_pressed) return false;
2402
2403 /* Now check if we could build there */
2404 if (!proc(true, INVALID_STATION)) return false;
2405
2406 /* Test for adjacent station or station below selection.
2407 * If adjacent-stations is disabled and we are building next to a station, do not show the selection window.
2408 * but join the other station immediately. */
2409 const T *st = FindStationsNearby<T>(ta, false);
2410 return st == nullptr && (_settings_game.station.adjacent_stations || _stations_nearby_list.size() == 0);
2411 }
2412
2419 template <class T>
2420 void ShowSelectBaseStationIfNeeded(TileArea ta, StationPickerCmdProc&& proc)
2421 {
2422 if (StationJoinerNeeded<T>(ta, proc)) {
2423 if (!_settings_client.gui.persistent_buildingtools) ResetObjectToPlace();
2424 new SelectStationWindow<T>(&_select_station_desc, ta, std::move(proc));
2425 } else {
2426 proc(false, INVALID_STATION);
2427 }
2428 }
2429
2435 void ShowSelectStationIfNeeded(TileArea ta, StationPickerCmdProc proc)
2436 {
2437 ShowSelectBaseStationIfNeeded<Station>(ta, std::move(proc));
2438 }
2439
2445 void ShowSelectWaypointIfNeeded(TileArea ta, StationPickerCmdProc proc)
2446 {
2447 ShowSelectBaseStationIfNeeded<Waypoint>(ta, std::move(proc));
2448 }
VEH_AIRCRAFT
@ VEH_AIRCRAFT
Aircraft vehicle type.
Definition: vehicle_type.h:27
StationViewWindow::grouping_index
int grouping_index
Currently selected entry in the grouping drop down.
Definition: station_gui.cpp:1281
StationJoinerNeeded
static bool StationJoinerNeeded(TileArea ta, const StationPickerCmdProc &proc)
Check whether we need to show the station selection window.
Definition: station_gui.cpp:2386
StationViewWindow::HandleCargoWaitingClick
void HandleCargoWaitingClick(CargoDataEntry *filter, Tid next)
Expand or collapse a specific row.
Definition: station_gui.cpp:1855
CompanyStationsWindow::OnInvalidateData
void OnInvalidateData(int data=0, bool gui_scope=true) override
Some data on this window has become invalid.
Definition: station_gui.cpp:652
BaseStation::facilities
StationFacility facilities
The facilities that this station has.
Definition: base_station_base.h:63
Window::SetTimeout
void SetTimeout()
Set the timeout flag of the window and initiate the timer.
Definition: window_gui.h:295
StationViewWindow
The StationView window.
Definition: station_gui.cpp:1200
CargoList< StationCargoList, StationCargoPacketMap >::ConstIterator
StationCargoPacketMap ::const_iterator ConstIterator
The const iterator for our container.
Definition: cargopacket.h:208
WC_ROADVEH_LIST
@ WC_ROADVEH_LIST
Road vehicle list; Window numbers:
Definition: window_type.h:307
CompanyStationsWindow::StationRatingMaxSorter
static bool StationRatingMaxSorter(const Station *const &a, const Station *const &b)
Sort stations by their rating.
Definition: station_gui.cpp:297
WID_STL_SORTBY
@ WID_STL_SORTBY
'Sort by' button - reverse sort direction.
Definition: station_widget.h:52
TileHighlightData::size
Point size
Size, in tile "units", of the white/red selection area.
Definition: tilehighlight_type.h:48
Station::goods
GoodsEntry goods[NUM_CARGO]
Goods at this station.
Definition: station_base.h:483
StationViewWindow::Close
void Close() override
Hide the window and all its child windows, and mark them for a later deletion.
Definition: station_gui.cpp:1309
StationViewWindow::OnClick
void OnClick(Point pt, int widget, int click_count) override
A click with the left mouse button has been made on the window.
Definition: station_gui.cpp:1884
NWidgetFunction
static NWidgetPart NWidgetFunction(NWidgetFunctionType *func_ptr)
Obtain a nested widget (sub)tree from an external source.
Definition: widget_type.h:1259
GUIList::SortType
uint8 SortType() const
Get the sorttype of the list.
Definition: sortlist_type.h:93
GUISettings::station_show_coverage
bool station_show_coverage
whether to highlight coverage area
Definition: settings_type.h:166
ScrollMainWindowToTile
bool ScrollMainWindowToTile(TileIndex tile, bool instant)
Scrolls the viewport of the main window to a given location.
Definition: viewport.cpp:2456
vehicle_gui.h
GameSettings::station
StationSettings station
settings related to station management
Definition: settings_type.h:598
StationViewWindow::ALH_ACCEPTS
@ ALH_ACCEPTS
Height of the accepted cargo view.
Definition: station_gui.cpp:1263
UpdateTileSelection
void UpdateTileSelection()
Updates tile highlighting for all cases.
Definition: viewport.cpp:2543
LinkGraph
A connected component of a link graph.
Definition: linkgraph.h:39
SetScrollbar
static NWidgetPart SetScrollbar(int index)
Attach a scrollbar to a widget.
Definition: widget_type.h:1208
ShowExtraViewportWindow
void ShowExtraViewportWindow(TileIndex tile=INVALID_TILE)
Show a new Extra Viewport window.
Definition: viewport_gui.cpp:168
StationViewWindow::RowDisplay::filter
CargoDataEntry * filter
Parent of the cargo entry belonging to the row.
Definition: station_gui.cpp:1211
DivideApprox
int DivideApprox(int a, int b)
Deterministic approximate division.
Definition: math_func.cpp:57
ToPercent8
static uint ToPercent8(uint i)
Converts a "fract" value 0..255 to "percent" value 0..100.
Definition: math_func.hpp:227
GetAcceptanceAroundTiles
CargoArray GetAcceptanceAroundTiles(TileIndex center_tile, int w, int h, int rad, CargoTypes *always_accepted)
Get the acceptance of cargoes around the tile in 1/8.
Definition: station_cmd.cpp:548
Dimension
Dimensions (a width and height) of a rectangle in 2D.
Definition: geometry_type.hpp:27
Scrollbar::GetCapacity
uint16 GetCapacity() const
Gets the number of visible elements of the scrollbar.
Definition: widget_type.h:667
command_func.h
Window::DrawSortButtonState
void DrawSortButtonState(int widget, SortButtonState state) const
Draw a sort button's up or down arrow symbol.
Definition: widget.cpp:890
GUISettings::station_gui_sort_by
uint8 station_gui_sort_by
sort cargo entries in the station gui by station name or amount
Definition: settings_type.h:184
WWT_STICKYBOX
@ WWT_STICKYBOX
Sticky box (at top-right of a window, after WWT_DEFSIZEBOX)
Definition: widget_type.h:64
Pool::PoolItem<&_link_graph_pool >::GetIfValid
static Titem * GetIfValid(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:348
GUIList::Sort
bool Sort(Comp compare)
Sort the list.
Definition: sortlist_type.h:247
Window::GetScrollbar
const Scrollbar * GetScrollbar(uint widnum) const
Return the Scrollbar to a widget index.
Definition: window.cpp:320
WDF_CONSTRUCTION
@ WDF_CONSTRUCTION
This window is used for construction; close it whenever changing company.
Definition: window_gui.h:144
dropdown_func.h
Rect::Shrink
Rect Shrink(int s) const
Copy and shrink Rect by s pixels.
Definition: geometry_type.hpp:92
VehicleListIdentifier
The information about a vehicle list.
Definition: vehiclelist.h:29
CargoDataEntry::InsertOrRetrieve
CargoDataEntry * InsertOrRetrieve(StationID station)
Insert a new child or retrieve an existing child using a station ID as ID.
Definition: station_gui.cpp:875
_sorted_cargo_specs
std::vector< const CargoSpec * > _sorted_cargo_specs
Cargo specifications sorted alphabetically by name.
Definition: cargotype.cpp:153
Window::ReInit
void ReInit(int rx=0, int ry=0)
Re-initialize a window, and optionally change its size.
Definition: window.cpp:1015
company_base.h
StationViewWindow::INV_FLOWS
@ INV_FLOWS
The planned flows have been recalculated and everything has to be updated.
Definition: station_gui.cpp:1233
NWidgetContainer::Add
void Add(NWidgetBase *wid)
Append widget wid to container.
Definition: widget.cpp:1261
CargoList::Packets
const Tcont * Packets() const
Returns a pointer to the cargo packet list (so you can iterate over it etc).
Definition: cargopacket.h:247
CargoDataEntry::cargo
CargoID cargo
ID of the cargo this entry is associated with.
Definition: station_gui.cpp:1001
BaseStation::town
Town * town
The town this station is associated with.
Definition: base_station_base.h:61
CompanyStationsWindow::SetStringParameters
void SetStringParameters(int widget) const override
Initialize string parameters for a widget.
Definition: station_gui.cpp:499
GetContrastColour
TextColour GetContrastColour(uint8 background, uint8 threshold)
Determine a contrasty text colour for a coloured background.
Definition: gfx.cpp:1432
CompanyStationsWindow
The list of stations per company.
Definition: station_gui.cpp:200
FACIL_TRUCK_STOP
@ FACIL_TRUCK_STOP
Station with truck stops.
Definition: station_type.h:54
CompanyStationsWindow::BuildStationsList
void BuildStationsList(const Owner owner)
(Re)Build station list
Definition: station_gui.cpp:223
WidgetDimensions::pressed
int pressed
Offset for contents of depressed widget.
Definition: window_gui.h:60
WID_SV_WAITING
@ WID_SV_WAITING
List of waiting cargo.
Definition: station_widget.h:20
WWT_CAPTION
@ WWT_CAPTION
Window caption (window title between closebox and stickybox)
Definition: widget_type.h:59
Station
Station data structure.
Definition: station_base.h:454
CheckRedrawStationCoverage
void CheckRedrawStationCoverage(const Window *w)
Check whether we need to redraw the station coverage text.
Definition: station_gui.cpp:127
StationViewWindow::OnInvalidateData
void OnInvalidateData(int data=0, bool gui_scope=true) override
Some data on this window has become invalid.
Definition: station_gui.cpp:2075
GUIList< const Station * >
GUISettings::station_gui_group_order
uint8 station_gui_group_order
the order of grouping cargo entries in the station gui
Definition: settings_type.h:183
StationViewWindow::OnDropdownSelect
void OnDropdownSelect(int widget, int index) override
A dropdown option associated to this window has been selected.
Definition: station_gui.cpp:2049
SelectStationWindow::OnResize
void OnResize() override
Called after the window got resized.
Definition: station_gui.cpp:2334
PC_RED
static const uint8 PC_RED
Red palette colour.
Definition: gfx_func.h:249
vehiclelist.h
TileAddByDir
static TileIndex TileAddByDir(TileIndex tile, Direction dir)
Adds a Direction to a tile.
Definition: map_func.h:370
WWT_DEFSIZEBOX
@ WWT_DEFSIZEBOX
Default window size box (at top-right of a window, between WWT_SHADEBOX and WWT_STICKYBOX)
Definition: widget_type.h:63
NWidgetResizeBase::SetMinimalTextLines
void SetMinimalTextLines(uint8 min_lines, uint8 spacing, FontSize size)
Set minimal text lines for the widget.
Definition: widget.cpp:1106
Window::CreateNestedTree
void CreateNestedTree(bool fill_nested=true)
Perform the first part of the initialization of a nested widget tree.
Definition: window.cpp:1771
Pool::PoolItem::index
Tindex index
Index of this pool item.
Definition: pool_type.hpp:235
CargoSpec::Get
static CargoSpec * Get(size_t index)
Retrieve cargo details for the given cargo ID.
Definition: cargotype.h:118
NWID_HORIZONTAL
@ NWID_HORIZONTAL
Horizontal container.
Definition: widget_type.h:73
CargoArray
Class for storing amounts of cargo.
Definition: cargo_type.h:82
maxdim
Dimension maxdim(const Dimension &d1, const Dimension &d2)
Compute bounding box of both dimensions.
Definition: geometry_func.cpp:22
DT_MANUAL
@ DT_MANUAL
Manual distribution. No link graph calculations are run.
Definition: linkgraph_type.h:25
StationViewWindow::cached_destinations
CargoDataEntry cached_destinations
Cache for the flows passing through this station.
Definition: station_gui.cpp:1286
StationViewWindow::RowDisplay
A row being displayed in the cargo view (as opposed to being "hidden" behind a plus sign).
Definition: station_gui.cpp:1204
FindWindowById
Window * FindWindowById(WindowClass cls, WindowNumber number)
Find a window by its class and window number.
Definition: window.cpp:1157
WID_SV_GROUP_BY
@ WID_SV_GROUP_BY
'Group by' button
Definition: station_widget.h:17
HasBit
static bool HasBit(const T x, const uint8 y)
Checks if a bit in a value is set.
Definition: bitmath_func.hpp:103
INVALID_TILE
static constexpr TileIndex INVALID_TILE
The very nice invalid tile marker.
Definition: tile_type.h:108
CargoDataEntry::GetCargo
CargoID GetCargo() const
Get the cargo ID for this entry.
Definition: station_gui.cpp:944
StationViewWindow::SelectSortBy
void SelectSortBy(int index)
Select a new sort criterium for the cargo view.
Definition: station_gui.cpp:1977
TileIndex
The index/ID of a Tile.
Definition: tile_type.h:85
Scrollbar::SetCount
void SetCount(int num)
Sets the number of elements in the list.
Definition: widget_type.h:715
StationViewWindow::DrawEntries
int DrawEntries(CargoDataEntry *entry, const Rect &r, int pos, int maxrows, int column, CargoID cargo=CT_INVALID)
Draw the given cargo entries in the station GUI.
Definition: station_gui.cpp:1716
_ctrl_pressed
bool _ctrl_pressed
Is Ctrl pressed?
Definition: gfx.cpp:38
WID_STL_LIST
@ WID_STL_LIST
The main panel, list of stations.
Definition: station_widget.h:38
StationCargoList
CargoList that is used for stations.
Definition: cargopacket.h:449
StationViewWindow::UpdateWidgetSize
void UpdateWidgetSize(int widget, Dimension *size, const Dimension &padding, Dimension *fill, Dimension *resize) override
Update size and resize step of a widget in the window.
Definition: station_gui.cpp:1366
StationViewWindow::BuildCargoList
void BuildCargoList(CargoID i, const StationCargoList &packets, CargoDataEntry *cargo)
Build up the cargo view for WAITING mode and a specific cargo.
Definition: station_gui.cpp:1572
DrawCargoIcons
static void DrawCargoIcons(CargoID i, uint waiting, int left, int right, int y)
Draws icons of waiting cargo in the StationView window.
Definition: station_gui.cpp:812
TextColour
TextColour
Colour of the strings, see _string_colourmap in table/string_colours.h or docs/ottd-colourtext-palett...
Definition: gfx_type.h:257
SetResize
static NWidgetPart SetResize(int16 dx, int16 dy)
Widget part function for setting the resize step.
Definition: widget_type.h:995
zoom_func.h
FACIL_NONE
@ FACIL_NONE
The station has no facilities at all.
Definition: station_type.h:52
TILE_SIZE
static const uint TILE_SIZE
Tile size in world coordinates.
Definition: tile_type.h:15
StationViewWindow::BuildCargoList
void BuildCargoList(CargoDataEntry *cargo, const Station *st)
Build up the cargo view for all cargoes.
Definition: station_gui.cpp:1605
StationViewWindow::DrawCargoRatings
int DrawCargoRatings(const Rect &r) const
Draw cargo ratings in the WID_SV_ACCEPT_RATING_LIST widget.
Definition: station_gui.cpp:1819
ShowCompanyStations
void ShowCompanyStations(CompanyID company)
Opens window with list of company's stations.
Definition: station_gui.cpp:759
AddNearbyStation
static bool AddNearbyStation(TileIndex tile, void *user_data)
Add station on this tile to _stations_nearby_list if it's fully within the station spread.
Definition: station_gui.cpp:2139
SpecializedStation< Station, false >::Get
static Station * Get(size_t index)
Gets station with given index.
Definition: base_station_base.h:218
_settings_client
ClientSettings _settings_client
The current settings for this game.
Definition: settings.cpp:53
DrawString
int DrawString(int left, int right, int top, const char *str, TextColour colour, StringAlignment align, bool underline, FontSize fontsize)
Draw string, possibly truncated to make it fit in its allocated space.
Definition: gfx.cpp:644
StationViewWindow::OnQueryTextFinished
void OnQueryTextFinished(char *str) override
The query window opened from this window has closed.
Definition: station_gui.cpp:2058
CargoSpec
Specification of a cargo type.
Definition: cargotype.h:57
SpecializedStation< Station, false >::IsValidID
static bool IsValidID(size_t index)
Tests whether given index is a valid index for station of this type.
Definition: base_station_base.h:209
CargoDataEntry::GetCount
uint GetCount() const
Get the cargo count for this entry.
Definition: station_gui.cpp:949
town.h
TileY
static uint TileY(TileIndex tile)
Get the Y component of a tile.
Definition: map_func.h:215
Window::owner
Owner owner
The owner of the content shown in this window. Company colour is acquired from this variable.
Definition: window_gui.h:253
FindStationsAroundSelection
static void FindStationsAroundSelection()
Find stations adjacent to the current tile highlight area, so that existing coverage area can be draw...
Definition: station_gui.cpp:86
WindowNumber
int32 WindowNumber
Number to differentiate different windows of the same class.
Definition: window_type.h:713
WC_STATION_VIEW
@ WC_STATION_VIEW
Station view; Window numbers:
Definition: window_type.h:338
WID_STL_CAPTION
@ WID_STL_CAPTION
Caption of the window.
Definition: station_widget.h:37
CargoSpec::GetCargoIcon
SpriteID GetCargoIcon() const
Get sprite for showing cargo of this type.
Definition: cargotype.cpp:140
StationViewWindow::_sort_names
static const StringID _sort_names[]
Names of the sorting options in the dropdown.
Definition: station_gui.cpp:1266
VEH_ROAD
@ VEH_ROAD
Road vehicle type.
Definition: vehicle_type.h:25
CC_PASSENGERS
@ CC_PASSENGERS
Passengers.
Definition: cargotype.h:41
CompanyStationsWindow::OnPaint
void OnPaint() override
The window must be repainted.
Definition: station_gui.cpp:417
GUIList::SetSortType
void SetSortType(uint8 n_type)
Set the sorttype of the list.
Definition: sortlist_type.h:103
Scrollbar::GetScrolledRowFromWidget
int GetScrolledRowFromWidget(int clickpos, const Window *const w, int widget, int padding=0) const
Compute the row of a scrolled widget that a user clicked in.
Definition: widget.cpp:2353
StationViewWindow::GR_DESTINATION
@ GR_DESTINATION
Group by estimated final destination ("to").
Definition: station_gui.cpp:1243
WID_SV_SORT_BY
@ WID_SV_SORT_BY
'Sort by' button
Definition: station_widget.h:19
StationViewWindow::SearchNonStop
StringID SearchNonStop(CargoDataEntry *cd, StationID station, int column)
Determine if we need to show the special "non-stop" string.
Definition: station_gui.cpp:1679
SelectStationWindow::area
TileArea area
Location of new station.
Definition: station_gui.cpp:2243
Owner
Owner
Enum for all companies/owners.
Definition: company_type.h:18
Scrollbar
Scrollbar data structure.
Definition: widget_type.h:634
BaseStation::owner
Owner owner
The owner of this station.
Definition: base_station_base.h:62
DIR_N
@ DIR_N
North.
Definition: direction_type.h:26
StationViewWindow::expand_shrink_width
uint expand_shrink_width
The width allocated to the expand/shrink 'button'.
Definition: station_gui.cpp:1255
SetDParam
static void SetDParam(uint n, uint64 v)
Set a string parameter v at index n in the global string parameter array.
Definition: strings_func.h:196
StationViewWindow::MODE_PLANNED
@ MODE_PLANNED
Show cargo planned to pass through the station.
Definition: station_gui.cpp:1252
NWidgetPart
Partial widget specification to allow NWidgets to be written nested.
Definition: widget_type.h:973
CargoDataEntry::children
CargoDataSet * children
the children of this entry.
Definition: station_gui.cpp:1007
GoodsEntry::status
byte status
Status of this cargo, see GoodsEntryStatus.
Definition: station_base.h:223
SetDataTip
static NWidgetPart SetDataTip(uint32 data, StringID tip)
Widget part function for setting the data and tooltip.
Definition: widget_type.h:1109
StationViewWindow::GR_SOURCE
@ GR_SOURCE
Group by source of cargo ("from").
Definition: station_gui.cpp:1241
StationViewWindow::AcceptListHeight
AcceptListHeight
Height of the WID_SV_ACCEPT_RATING_LIST widget for different views.
Definition: station_gui.cpp:1261
ShowStationViewWindow
void ShowStationViewWindow(StationID station)
Opens StationViewWindow for given station.
Definition: station_gui.cpp:2117
StationCargoList::TotalCount
uint TotalCount() const
Returns total count of cargo at the station, including cargo which is already reserved for loading.
Definition: cargopacket.h:527
GetStringBoundingBox
Dimension GetStringBoundingBox(const char *str, FontSize start_fontsize)
Return the string dimension in pixels.
Definition: gfx.cpp:890
textbuf_gui.h
CompanyStationsWindow::OnClick
void OnClick(Point pt, int widget, int click_count) override
A click with the left mouse button has been made on the window.
Definition: station_gui.cpp:507
StationViewWindow::INV_CARGO
@ INV_CARGO
Some cargo has been added or removed.
Definition: station_gui.cpp:1234
TileX
static uint TileX(TileIndex tile)
Get the X component of a tile.
Definition: map_func.h:205
StationViewWindow::SetStringParameters
void SetStringParameters(int widget) const override
Initialize string parameters for a widget.
Definition: station_gui.cpp:1450
CompanyStationsWindow::StationWaitingAvailableSorter
static bool StationWaitingAvailableSorter(const Station *const &a, const Station *const &b)
Sort stations by their available waiting cargo.
Definition: station_gui.cpp:285
DrawStringMultiLine
int DrawStringMultiLine(int left, int right, int top, int bottom, const char *str, TextColour colour, StringAlignment align, bool underline, FontSize fontsize)
Draw string, possibly over multiple lines.
Definition: gfx.cpp:789
QSF_LEN_IN_CHARS
@ QSF_LEN_IN_CHARS
the length of the string is counted in characters
Definition: textbuf_gui.h:22
CargoDataEntry::InsertOrRetrieve
CargoDataEntry * InsertOrRetrieve(CargoID cargo)
Insert a new child or retrieve an existing child using a cargo ID as ID.
Definition: station_gui.cpp:885
SpecializedStation< Station, false >::Iterate
static Pool::IterateWrapper< Station > Iterate(size_t from=0)
Returns an iterable ensemble of all valid stations of type T.
Definition: base_station_base.h:269
WID_SV_ROADVEHS
@ WID_SV_ROADVEHS
List of scheduled road vehs button.
Definition: station_widget.h:28
ST_STATION_ID
@ ST_STATION_ID
by station id
Definition: station_gui.cpp:838
SpriteID
uint32 SpriteID
The number of a sprite, without mapping bits and colourtables.
Definition: gfx_type.h:17
StationViewWindow::current_mode
Mode current_mode
Currently selected display mode of cargo view.
Definition: station_gui.cpp:1282
WID_SV_CATCHMENT
@ WID_SV_CATCHMENT
Toggle catchment area highlight.
Definition: station_widget.h:31
StationViewWindow::NUM_COLUMNS
static const int NUM_COLUMNS
Number of "columns" in the cargo view: cargo, from, via, to.
Definition: station_gui.cpp:1227
WindowDesc
High level window description.
Definition: window_gui.h:102
StationViewWindow::OnResize
void OnResize() override
Called after the window got resized.
Definition: station_gui.cpp:2065
GoodsEntry::cargo
StationCargoList cargo
The cargo packets of cargo waiting in this station.
Definition: station_base.h:252
CargoDataEntry::num_children
uint num_children
the number of subentries belonging to this entry.
Definition: station_gui.cpp:1005
NC_EQUALSIZE
@ NC_EQUALSIZE
Value of the NCB_EQUALSIZE flag.
Definition: widget_type.h:467
FACIL_BUS_STOP
@ FACIL_BUS_STOP
Station with bus stops.
Definition: station_type.h:55
GetProductionAroundTiles
CargoArray GetProductionAroundTiles(TileIndex north_tile, int w, int h, int rad)
Get the cargo types being produced around the tile (in a rectangle).
Definition: station_cmd.cpp:509
CargoSpec::Index
CargoID Index() const
Determines index of this cargospec.
Definition: cargotype.h:89
StationViewWindow::GetEntryString
StringID GetEntryString(StationID station, StringID here, StringID other_station, StringID any)
Select the correct string for an entry referring to the specified station.
Definition: station_gui.cpp:1658
GUIList::IsDescSortOrder
bool IsDescSortOrder() const
Check if the sort order is descending.
Definition: sortlist_type.h:223
WDP_AUTO
@ WDP_AUTO
Find a place automatically.
Definition: window_gui.h:90
Listing
Data structure describing how to show the list (what sort direction and criteria).
Definition: sortlist_type.h:30
SCT_PASSENGERS_ONLY
@ SCT_PASSENGERS_ONLY
Draw only passenger class cargoes.
Definition: station_gui.h:22
MapSize
static uint MapSize()
Get the size of the map.
Definition: map_func.h:92
Window::resize
ResizeInfo resize
Resize information.
Definition: window_gui.h:251
StationViewWindow::sortings
CargoSortType sortings[NUM_COLUMNS]
Sort types of the different 'columns'.
Definition: station_gui.cpp:1275
SetBitIterator
Iterable ensemble of each set bit in a value.
Definition: bitmath_func.hpp:329
CargoDataEntry::GetNumChildren
uint GetNumChildren() const
Get the number of children for this entry.
Definition: station_gui.cpp:959
Scrollbar::GetCount
uint16 GetCount() const
Gets the number of elements in the list.
Definition: widget_type.h:658
tilehighlight_func.h
CircularTileSearch
bool CircularTileSearch(TileIndex *tile, uint size, TestTileOnSearchProc proc, void *user_data)
Function performing a search around a center tile and going outward, thus in circle.
Definition: map.cpp:258
WID_STL_CARGOSTART
@ WID_STL_CARGOSTART
Widget numbers used for list of cargo types (not present in _company_stations_widgets).
Definition: station_widget.h:55
CargoPacket::SourceStation
StationID SourceStation() const
Gets the ID of the station where the cargo was loaded for the first time.
Definition: cargopacket.h:159
FS_NORMAL
@ FS_NORMAL
Index of the normal font in the font tables.
Definition: gfx_type.h:207
Rect::Translate
Rect Translate(int x, int y) const
Copy and translate Rect by x,y pixels.
Definition: geometry_type.hpp:168
WidgetDimensions::hsep_normal
int hsep_normal
Normal horizontal spacing.
Definition: window_gui.h:63
CompanyStationsWindow::UpdateWidgetSize
void UpdateWidgetSize(int widget, Dimension *size, const Dimension &padding, Dimension *fill, Dimension *resize) override
Update size and resize step of a widget in the window.
Definition: station_gui.cpp:371
StationViewWindow::DrawAcceptedCargo
int DrawAcceptedCargo(const Rect &r) const
Draw accepted cargo in the WID_SV_ACCEPT_RATING_LIST widget.
Definition: station_gui.cpp:1800
StationCoverageType
StationCoverageType
Types of cargo to display for station coverage.
Definition: station_gui.h:21
StationViewWindow::SetDisplayedRow
void SetDisplayedRow(const CargoDataEntry *data)
Mark a specific row, characterized by its CargoDataEntry, as expanded.
Definition: station_gui.cpp:1625
StationViewWindow::ShowCargo
void ShowCargo(CargoDataEntry *data, CargoID cargo, StationID source, StationID next, StationID dest, uint count)
Show a certain cargo entry characterized by source/next/dest station, cargo ID and amount of cargo at...
Definition: station_gui.cpp:1330
StationViewWindow::RowDisplay::next_station
StationID next_station
ID of the station belonging to the entry actually displayed if it's to/from/via.
Definition: station_gui.cpp:1216
WID_STL_TRUCK
@ WID_STL_TRUCK
'TRUCK' button - list only facilities where is a truck stop.
Definition: station_widget.h:43
GoodsEntry::HasRating
bool HasRating() const
Does this cargo have a rating at this station?
Definition: station_base.h:270
CompanyStationsWindow::OnResize
void OnResize() override
Called after the window got resized.
Definition: station_gui.cpp:642
NWidgetResizeBase::SetResize
void SetResize(uint resize_x, uint resize_y)
Set resize step of the widget.
Definition: widget.cpp:1130
GUIList< const Station * >::SortFunction
bool SortFunction(const const Station * &, const const Station * &)
Signature of sort function.
Definition: sortlist_type.h:48
CargoSpec::IsValid
bool IsValid() const
Tests for validity of this cargospec.
Definition: cargotype.h:99
Window::SetDirty
void SetDirty() const
Mark entire window as dirty (in need of re-paint)
Definition: window.cpp:1004
GUIList::SetListing
void SetListing(Listing l)
Import sort conditions.
Definition: sortlist_type.h:130
StationViewWindow::HandleCargoWaitingClick
void HandleCargoWaitingClick(int row)
Handle a click on a specific row in the cargo view.
Definition: station_gui.cpp:1868
FS_SMALL
@ FS_SMALL
Index of the small font in the font tables.
Definition: gfx_type.h:208
IsInsideBS
static 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.
Definition: math_func.hpp:188
StationViewWindow::OnPaint
void OnPaint() override
The window must be repainted.
Definition: station_gui.cpp:1390
OrthogonalTileArea::w
uint16 w
The width of the area.
Definition: tilearea_type.h:20
GoodsEntry::node
NodeID node
ID of node in link graph referring to this goods entry.
Definition: station_base.h:255
station_cmd.h
CargoSortType
CargoSortType
Definition: station_gui.cpp:834
StationsWndShowStationRating
static void StationsWndShowStationRating(int left, int right, int y, CargoID type, uint amount, byte rating)
Draw small boxes of cargo amount and ratings data at the given coordinates.
Definition: station_gui.cpp:158
WWT_PUSHTXTBTN
@ WWT_PUSHTXTBTN
Normal push-button (no toggle button) with text caption.
Definition: widget_type.h:104
NWidgetBase
Baseclass for nested widgets.
Definition: widget_type.h:126
_cargo_mask
CargoTypes _cargo_mask
Bitmask of cargo types available.
Definition: cargotype.cpp:29
WidgetDimensions::hsep_wide
int hsep_wide
Wide horizontal spacing.
Definition: window_gui.h:64
Station::airport
Airport airport
Tile area the airport covers.
Definition: station_base.h:468
WID_SV_SORT_ORDER
@ WID_SV_SORT_ORDER
'Sort order' button
Definition: station_widget.h:18
ScaleSpriteTrad
static int ScaleSpriteTrad(int value)
Scale traditional pixel dimensions to GUI zoom level, for drawing sprites.
Definition: zoom_func.h:107
OrthogonalTileArea
Represents the covered area of e.g.
Definition: tilearea_type.h:18
CargoWidgets
static NWidgetBase * CargoWidgets(int *biggest_index)
Make a horizontal row of cargo buttons, starting at widget WID_STL_CARGOSTART.
Definition: station_gui.cpp:695
ShowSelectStationIfNeeded
void ShowSelectStationIfNeeded(TileArea ta, StationPickerCmdProc proc)
Show the station selection window when needed.
Definition: station_gui.cpp:2435
CompanyStationsWindow::StationTypeSorter
static bool StationTypeSorter(const Station *const &a, const Station *const &b)
Sort stations by their type.
Definition: station_gui.cpp:267
_settings_game
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition: settings.cpp:54
StationViewWindow::BuildFlowList
void BuildFlowList(CargoID i, const FlowStatMap &flows, CargoDataEntry *cargo)
Build up the cargo view for PLANNED mode and a specific cargo.
Definition: station_gui.cpp:1549
SelectStationWindow
Window for selecting stations/waypoints to (distant) join to.
Definition: station_gui.cpp:2241
Window::SetWidgetDisabledState
void SetWidgetDisabledState(byte widget_index, bool disab_stat)
Sets the enabled/disabled status of a widget.
Definition: window_gui.h:321
Window::parent
Window * parent
Parent window.
Definition: window_gui.h:266
_local_company
CompanyID _local_company
Company controlled by the human player at this client. Can also be COMPANY_SPECTATOR.
Definition: company_cmd.cpp:46
safeguards.h
sortlist_type.h
ShowQueryString
void ShowQueryString(StringID str, StringID caption, uint maxsize, Window *parent, CharSetFilter afilter, QueryStringFlags flags)
Show a query popup window with a textbox in it.
Definition: misc_gui.cpp:1115
CargoDataEntry::Retrieve
CargoDataEntry * Retrieve(CargoID cargo) const
Retrieve a child for the given cargo.
Definition: station_gui.cpp:928
ShowSelectWaypointIfNeeded
void ShowSelectWaypointIfNeeded(TileArea ta, StationPickerCmdProc proc)
Show the waypoint selection window when needed.
Definition: station_gui.cpp:2445
Airport::flags
uint64 flags
stores which blocks on the airport are taken. was 16 bit earlier on, then 32
Definition: station_base.h:305
Rect::Indent
Rect Indent(int indent, bool end) const
Copy Rect and indent it from its position.
Definition: geometry_type.hpp:192
WC_SHIPS_LIST
@ WC_SHIPS_LIST
Ships list; Window numbers:
Definition: window_type.h:313
CargoDataEntry::station
StationID station
ID of the station this entry is associated with.
Definition: station_gui.cpp:999
StationViewWindow::groupings
Grouping groupings[NUM_COLUMNS]
Grouping modes for the different columns.
Definition: station_gui.cpp:1283
StationViewWindow::RecalcDestinations
void RecalcDestinations(CargoID i)
Rebuild the cache for estimated destinations which is used to quickly show the "destination" entries ...
Definition: station_gui.cpp:1462
CargoPacket::Count
uint16 Count() const
Gets the number of 'items' in this packet.
Definition: cargopacket.h:100
Rect::WithWidth
Rect WithWidth(int width, bool end) const
Copy Rect and set its width.
Definition: geometry_type.hpp:179
TileHighlightData::pos
Point pos
Location, in tile "units", of the northern tile of the selected area.
Definition: tilehighlight_type.h:47
DrawSprite
void DrawSprite(SpriteID img, PaletteID pal, int x, int y, const SubSprite *sub, ZoomLevel zoom)
Draw a sprite, not in a viewport.
Definition: gfx.cpp:1058
WID_SV_LOCATION
@ WID_SV_LOCATION
'Location' button.
Definition: station_widget.h:23
TileAndStation::tile
TileIndex tile
TileIndex.
Definition: station_gui.cpp:2124
StationViewWindow::MODE_WAITING
@ MODE_WAITING
Show cargo waiting at the station.
Definition: station_gui.cpp:1251
CargoDataEntry::Remove
void Remove(StationID station)
Remove a child associated with the given station.
Definition: station_gui.cpp:896
GoodsEntry::rating
byte rating
Station rating for this cargo.
Definition: station_base.h:232
Point
Coordinates of a point in 2D.
Definition: geometry_type.hpp:21
ST_CARGO_ID
@ ST_CARGO_ID
by cargo id
Definition: station_gui.cpp:839
GameSettings::linkgraph
LinkGraphSettings linkgraph
settings for link graph calculations
Definition: settings_type.h:597
WC_TRAINS_LIST
@ WC_TRAINS_LIST
Trains list; Window numbers:
Definition: window_type.h:301
StationCargoList::AvailableCount
uint AvailableCount() const
Returns sum of cargo still available for loading at the sation.
Definition: cargopacket.h:508
WID_STL_CARGOALL
@ WID_STL_CARGOALL
'ALL' button - list all stations.
Definition: station_widget.h:50
CargoDataEntry::GetParent
CargoDataEntry * GetParent() const
Get the parent entry for this entry.
Definition: station_gui.cpp:954
ShowDropDownMenu
void ShowDropDownMenu(Window *w, const StringID *strings, int selected, int button, uint32 disabled_mask, uint32 hidden_mask, uint width)
Show a dropdown menu window near a widget of the parent window.
Definition: dropdown.cpp:487
FACIL_DOCK
@ FACIL_DOCK
Station with a dock.
Definition: station_type.h:57
StationSettings::station_spread
byte station_spread
amount a station may spread
Definition: settings_type.h:563
CompanyStationsWindow::StationWaitingTotalSorter
static bool StationWaitingTotalSorter(const Station *const &a, const Station *const &b)
Sort stations by their waiting cargo.
Definition: station_gui.cpp:273
stdafx.h
Window::window_number
WindowNumber window_number
Window number within the window class.
Definition: window_gui.h:241
VehicleType
VehicleType
Available vehicle types.
Definition: vehicle_type.h:21
GfxFillRect
void GfxFillRect(int left, int top, int right, int bottom, int colour, FillRectMode mode)
Applies a certain FillRectMode-operation to a rectangle [left, right] x [top, bottom] on the screen.
Definition: gfx.cpp:116
GoodsEntry::link_graph
LinkGraphID link_graph
Link graph this station belongs to.
Definition: station_base.h:254
SelectStationWindow::OnMouseOver
void OnMouseOver(Point pt, int widget) override
The mouse is currently moving over the window or has just moved outside of the window.
Definition: station_gui.cpp:2352
ResizeInfo::step_height
uint step_height
Step-size of height resize changes.
Definition: window_gui.h:154
GUIList::ToggleSortOrder
void ToggleSortOrder()
Toggle the sort order Since that is the worst condition for the sort function reverse the list here.
Definition: sortlist_type.h:233
GUIList::NeedResort
bool NeedResort()
Check if a resort is needed next loop If used the resort timer will decrease every call till 0.
Definition: sortlist_type.h:199
CS_ALPHANUMERAL
@ CS_ALPHANUMERAL
Both numeric and alphabetic and spaces and stuff.
Definition: string_type.h:27
viewport_func.h
CompanyStationsWindow::SortStationsList
void SortStationsList()
Sort the stations list.
Definition: station_gui.cpp:326
WC_NONE
@ WC_NONE
No window, redirects to WC_MAIN_WINDOW.
Definition: window_type.h:38
StationViewWindow::_group_names
static const StringID _group_names[]
Names of the grouping options in the dropdown.
Definition: station_gui.cpp:1267
SA_HOR_CENTER
@ SA_HOR_CENTER
Horizontally center the text.
Definition: gfx_type.h:336
IsTileType
static bool IsTileType(TileIndex tile, TileType type)
Checks if a tile is a given tiletype.
Definition: tile_map.h:150
FACIL_WAYPOINT
@ FACIL_WAYPOINT
Station is a waypoint.
Definition: station_type.h:58
NWID_VERTICAL
@ NWID_VERTICAL
Vertical container.
Definition: widget_type.h:75
NWidgetResizeBase::SetFill
void SetFill(uint fill_x, uint fill_y)
Set the filling of the widget from initial size.
Definition: widget.cpp:1119
GetTileOwner
static Owner GetTileOwner(TileIndex tile)
Returns the owner of a tile.
Definition: tile_map.h:178
FONT_HEIGHT_SMALL
#define FONT_HEIGHT_SMALL
Height of characters in the small (FS_SMALL) font.
Definition: gfx_func.h:203
WID_STL_SHIP
@ WID_STL_SHIP
'SHIP' button - list only facilities where is a dock.
Definition: station_widget.h:46
OrthogonalTileArea::h
uint16 h
The height of the area.
Definition: tilearea_type.h:21
DistanceMax
uint DistanceMax(TileIndex t0, TileIndex t1)
Gets the biggest distance component (x or y) between the two given tiles.
Definition: map.cpp:189
StationCargoList::ReservedCount
uint ReservedCount() const
Returns sum of cargo reserved for loading onto vehicles.
Definition: cargopacket.h:517
WID_STL_NOCARGOWAITING
@ WID_STL_NOCARGOWAITING
'NO' button - list stations where no cargo is waiting.
Definition: station_widget.h:49
WWT_CLOSEBOX
@ WWT_CLOSEBOX
Close box (at top-left of a window)
Definition: widget_type.h:67
WWT_RESIZEBOX
@ WWT_RESIZEBOX
Resize box (normally at bottom-right of a window)
Definition: widget_type.h:66
MAX_LENGTH_STATION_NAME_CHARS
static const uint MAX_LENGTH_STATION_NAME_CHARS
The maximum length of a station name in characters including '\0'.
Definition: station_type.h:88
TileHighlightData::dirty
byte dirty
Whether the build station window needs to redraw due to the changed selection.
Definition: tilehighlight_type.h:58
GUIList::NeedRebuild
bool NeedRebuild() const
Check if a rebuild is needed.
Definition: sortlist_type.h:362
TileHighlightData::drawstyle
HighLightStyle drawstyle
Lower bits 0-3 are reserved for detailed highlight information.
Definition: tilehighlight_type.h:64
DrawStationCoverageAreaText
int DrawStationCoverageAreaText(int left, int right, int top, StationCoverageType sct, int rad, bool supplies)
Calculates and draws the accepted or supplied cargo around the selected tile(s)
Definition: station_gui.cpp:55
WID_STL_SORTDROPBTN
@ WID_STL_SORTDROPBTN
Dropdown button.
Definition: station_widget.h:53
string_func.h
AIRPORT_CLOSED_block
static const uint64 AIRPORT_CLOSED_block
Dummy block for indicating a closed airport.
Definition: airport.h:128
SCT_ALL
@ SCT_ALL
Draw all cargoes.
Definition: station_gui.h:24
StringID
uint32 StringID
Numeric value that represents a string, independent of the selected language.
Definition: strings_type.h:16
WWT_PUSHIMGBTN
@ WWT_PUSHIMGBTN
Normal push-button (no toggle button) with image caption.
Definition: widget_type.h:105
SBS_DOWN
@ SBS_DOWN
Sort ascending.
Definition: window_gui.h:160
CargoDataEntry::SetTransfers
void SetTransfers(bool value)
Set the transfers state.
Definition: station_gui.cpp:979
GoodsEntry
Stores station stats for a single cargo.
Definition: station_base.h:167
EndContainer
static NWidgetPart EndContainer()
Widget part function for denoting the end of a container (horizontal, vertical, WWT_FRAME,...
Definition: widget_type.h:1094
WC_SELECT_STATION
@ WC_SELECT_STATION
Select station (when joining stations); Window numbers:
Definition: window_type.h:235
station_base.h
Pool::PoolItem<&_station_pool >::Iterate
static Pool::IterateWrapper< Titem > Iterate(size_t from=0)
Returns an iterable ensemble of all valid Titem.
Definition: pool_type.hpp:386
ST_STATION_STRING
@ ST_STATION_STRING
by station name
Definition: station_gui.cpp:837
strings_func.h
NWID_VSCROLLBAR
@ NWID_VSCROLLBAR
Vertical scrollbar.
Definition: widget_type.h:82
_sorted_standard_cargo_specs
span< const CargoSpec * > _sorted_standard_cargo_specs
Standard cargo specifications sorted alphabetically by name.
Definition: cargotype.cpp:154
StationViewWindow::Invalidation
Invalidation
Type of data invalidation.
Definition: station_gui.cpp:1232
StationViewWindow::displayed_rows
CargoDataVector displayed_rows
Parent entry of currently displayed rows (including collapsed ones).
Definition: station_gui.cpp:1287
NWidgetCore::SetDataTip
void SetDataTip(uint32 widget_data, StringID tool_tip)
Set data and tool tip of the nested widget.
Definition: widget.cpp:1176
MapMaxY
static uint MapMaxY()
Gets the maximum Y coordinate within the map, including MP_VOID.
Definition: map_func.h:111
Window::IsShaded
bool IsShaded() const
Is window shaded currently?
Definition: window_gui.h:455
NWidgetHorizontal
Horizontal container.
Definition: widget_type.h:498
CargoDataEntry::Update
void Update(uint count)
Update the count for this entry and propagate the change to the parent entry if there is one.
Definition: station_gui.cpp:1114
TileXY
static TileIndex TileXY(uint x, uint y)
Returns the TileIndex of a coordinate.
Definition: map_func.h:163
CargoDataEntry::Retrieve
CargoDataEntry * Retrieve(StationID station) const
Retrieve a child for the given station.
Definition: station_gui.cpp:917
CargoDataEntry::Clear
void Clear()
Delete all subentries, reset count and num_children and adapt parent's count.
Definition: station_gui.cpp:1059
CargoDataEntry::GetStation
StationID GetStation() const
Get the station ID for this entry.
Definition: station_gui.cpp:939
FACIL_TRAIN
@ FACIL_TRAIN
Station with train station.
Definition: station_type.h:53
StationViewWindow::RowDisplay::next_cargo
CargoID next_cargo
ID of the cargo belonging to the entry actually displayed if it's cargo.
Definition: station_gui.cpp:1221
WidgetDimensions::hsep_indent
int hsep_indent
Width of identation for tree layouts.
Definition: window_gui.h:65
FONT_HEIGHT_NORMAL
#define FONT_HEIGHT_NORMAL
Height of characters in the normal (FS_NORMAL) font.
Definition: gfx_func.h:206
GoodsEntry::flows
FlowStatMap flows
Planned flows through this station.
Definition: station_base.h:256
NWidget
static NWidgetPart NWidget(WidgetType tp, Colours col, int16 idx=-1)
Widget part function for starting a new 'real' widget.
Definition: widget_type.h:1227
StationViewWindow::sort_orders
SortOrder sort_orders[NUM_COLUMNS]
Sort order (ascending/descending) for the 'columns'.
Definition: station_gui.cpp:1278
SCT_NON_PASSENGERS_ONLY
@ SCT_NON_PASSENGERS_ONLY
Draw all non-passenger class cargoes.
Definition: station_gui.h:23
geometry_func.hpp
OrthogonalTileArea::tile
TileIndex tile
The base tile of the area.
Definition: tilearea_type.h:19
SelectStationWindow::DrawWidget
void DrawWidget(const Rect &r, int widget) const override
Draw the contents of a nested widget.
Definition: station_gui.cpp:2288
SetMinimalSize
static NWidgetPart SetMinimalSize(int16 x, int16 y)
Widget part function for setting the minimal size.
Definition: widget_type.h:1012
WID_STL_BUS
@ WID_STL_BUS
'BUS' button - list only facilities where is a bus stop.
Definition: station_widget.h:44
WID_SV_ACCEPT_RATING_LIST
@ WID_SV_ACCEPT_RATING_LIST
List of accepted cargoes / rating of cargoes.
Definition: station_widget.h:22
FlowStatMap
Flow descriptions by origin stations.
Definition: station_base.h:149
TileAndStation::station
StationID station
StationID.
Definition: station_gui.cpp:2125
WWT_PANEL
@ WWT_PANEL
Simple depressed panel.
Definition: widget_type.h:48
GUIList::GetListing
Listing GetListing() const
Export current sort conditions.
Definition: sortlist_type.h:116
OWNER_NONE
@ OWNER_NONE
The tile has no ownership.
Definition: company_type.h:25
Window::IsWidgetLowered
bool IsWidgetLowered(byte widget_index) const
Gets the lowered state of a widget.
Definition: window_gui.h:422
MP_STATION
@ MP_STATION
A tile of a station.
Definition: tile_type.h:53
GUISettings::station_gui_sort_order
uint8 station_gui_sort_order
the sort order of entries in the station gui - ascending or descending
Definition: settings_type.h:185
WID_SV_GROUP
@ WID_SV_GROUP
label for "group by"
Definition: station_widget.h:16
NUM_CARGO
@ NUM_CARGO
Maximal number of cargo types in a game.
Definition: cargo_type.h:65
GoodsEntry::GES_ACCEPTANCE
@ GES_ACCEPTANCE
Set when the station accepts the cargo currently for final deliveries.
Definition: station_base.h:174
GetStationIndex
static StationID GetStationIndex(TileIndex t)
Get StationID from a tile.
Definition: station_map.h:28
SpecializedStation< Station, false >::GetByTile
static Station * GetByTile(TileIndex tile)
Get the station belonging to a specific tile.
Definition: base_station_base.h:237
waypoint_base.h
HT_RECT
@ HT_RECT
rectangle (stations, depots, ...)
Definition: tilehighlight_type.h:21
Scrollbar::GetPosition
uint16 GetPosition() const
Gets the position of the first visible element in the list.
Definition: widget_type.h:676
cargotype.h
WID_STL_AIRPLANE
@ WID_STL_AIRPLANE
'AIRPLANE' button - list only facilities where is an airport.
Definition: station_widget.h:45
WID_SV_ACCEPTS_RATINGS
@ WID_SV_ACCEPTS_RATINGS
'Accepts' / 'Ratings' button.
Definition: station_widget.h:24
linkgraph.h
StationViewWindow::Mode
Mode
Display mode of the cargo view.
Definition: station_gui.cpp:1250
Window::FinishInitNested
void FinishInitNested(WindowNumber window_number=0)
Perform the second part of the initialization of a nested widget tree.
Definition: window.cpp:1787
BaseStation::xy
TileIndex xy
Base tile of the station.
Definition: base_station_base.h:53
BaseStation
Base class for all station-ish types.
Definition: base_station_base.h:52
HasStationInUse
bool HasStationInUse(StationID station, bool include_company, CompanyID company)
Tests whether the company's vehicles have this station in orders.
Definition: station_cmd.cpp:2445
company_func.h
SetViewportCatchmentStation
void SetViewportCatchmentStation(const Station *st, bool sel)
Select or deselect station for coverage area highlight.
Definition: viewport.cpp:3533
CargoDataEntry::HasTransfers
bool HasTransfers() const
Has this entry transfers.
Definition: station_gui.cpp:974
MapMaxX
static uint MapMaxX()
Gets the maximum X coordinate within the map, including MP_VOID.
Definition: map_func.h:102
CargoSpec::abbrev
StringID abbrev
Two letter abbreviation for this cargo type.
Definition: cargotype.h:75
GUIList::ForceResort
void ForceResort()
Force a resort next Sort call Reset the resort timer if used too.
Definition: sortlist_type.h:213
TILE_ADDXY
#define TILE_ADDXY(tile, x, y)
Adds a given offset to a tile.
Definition: map_func.h:258
WidgetDimensions::framerect
RectPadding framerect
Offsets within frame area.
Definition: window_gui.h:47
StationSettings::distant_join_stations
bool distant_join_stations
allow to join non-adjacent stations
Definition: settings_type.h:561
StationViewWindow::GR_NEXT
@ GR_NEXT
Group by next station ("via").
Definition: station_gui.cpp:1242
CommandHelper
Definition: command_func.h:94
StationViewWindow::ALH_RATING
@ ALH_RATING
Height of the cargo ratings view.
Definition: station_gui.cpp:1262
StationSettings::adjacent_stations
bool adjacent_stations
allow stations to be built directly adjacent to other stations
Definition: settings_type.h:560
WID_STL_SCROLLBAR
@ WID_STL_SCROLLBAR
Scrollbar next to the main panel.
Definition: station_widget.h:39
window_func.h
CargoDataEntry
A cargo data entry representing one possible row in the station view window's top part.
Definition: station_gui.cpp:865
GUIList::ForceRebuild
void ForceRebuild()
Force that a rebuild is needed.
Definition: sortlist_type.h:370
CenterBounds
static int CenterBounds(int min, int max, int size)
Determine where to draw a centred object inside a widget.
Definition: gfx_func.h:178
ToggleBit
static T ToggleBit(T &x, const uint8 y)
Toggles a bit in a variable.
Definition: bitmath_func.hpp:181
Debug
#define Debug(name, level, format_string,...)
Ouptut a line of debugging information.
Definition: debug.h:37
Window::ToggleWidgetLoweredState
void ToggleWidgetLoweredState(byte widget_index)
Invert the lowered/raised status of a widget.
Definition: window_gui.h:392
GetCharacterHeight
int GetCharacterHeight(FontSize size)
Get height of a character for a given font size.
Definition: fontcache.cpp:62
SetBit
static T SetBit(T &x, const uint8 y)
Set a bit in a variable.
Definition: bitmath_func.hpp:121
lengthof
#define lengthof(x)
Return the length of an fixed size array.
Definition: stdafx.h:386
Window::width
int width
width of the window (number of pixels to the right in x direction)
Definition: window_gui.h:248
SelectStationWindow::OnInvalidateData
void OnInvalidateData(int data=0, bool gui_scope=true) override
Some data on this window has become invalid.
Definition: station_gui.cpp:2344
CargoPacket
Container for cargo from the same location and time.
Definition: cargopacket.h:43
Scrollbar::SetCapacityFromWidget
void SetCapacityFromWidget(Window *w, int widget, int padding=0)
Set capacity of visible elements from the size and resize properties of a widget.
Definition: widget.cpp:2427
Window::SortButtonWidth
static int SortButtonWidth()
Get width of up/down arrow of sort button state.
Definition: widget.cpp:907
StationViewWindow::SelectSortOrder
void SelectSortOrder(SortOrder order)
Select a new sort order for the cargo view.
Definition: station_gui.cpp:1966
StationViewWindow::SelectGroupBy
void SelectGroupBy(int index)
Select a new grouping mode for the cargo view.
Definition: station_gui.cpp:2009
WID_STL_TRAIN
@ WID_STL_TRAIN
'TRAIN' button - list only facilities where is a railroad station.
Definition: station_widget.h:42
CargoDataEntry::count
uint count
sum of counts of all children or amount of cargo for this entry.
Definition: station_gui.cpp:1006
CargoID
byte CargoID
Cargo slots to indicate a cargo type within a game.
Definition: cargo_type.h:20
CloseWindowById
void CloseWindowById(WindowClass cls, WindowNumber number, bool force)
Close a window by its class and window number (if it is open).
Definition: window.cpp:1187
WID_STL_FACILALL
@ WID_STL_FACILALL
'ALL' button - list all facilities.
Definition: station_widget.h:47
StationViewWindow::accepts_lines
int accepts_lines
Number of lines in the accepted cargo view.
Definition: station_gui.cpp:1257
SelectStationWindow::UpdateWidgetSize
void UpdateWidgetSize(int widget, Dimension *size, const Dimension &padding, Dimension *fill, Dimension *resize) override
Update size and resize step of a widget in the window.
Definition: station_gui.cpp:2268
CargoDataEntry::parent
CargoDataEntry * parent
the parent of this entry.
Definition: station_gui.cpp:997
ST_AS_GROUPING
@ ST_AS_GROUPING
by the same principle the entries are being grouped
Definition: station_gui.cpp:835
StationViewWindow::scroll_to_row
int scroll_to_row
If set, scroll the main viewport to the station pointed to by this row.
Definition: station_gui.cpp:1280
strnatcmp
int strnatcmp(const char *s1, const char *s2, bool ignore_garbage_at_front)
Compares two strings using case insensitive natural sort.
Definition: string.cpp:737
CargoSorter
Definition: station_gui.cpp:842
SetFill
static NWidgetPart SetFill(uint fill_x, uint fill_y)
Widget part function for setting filling.
Definition: widget_type.h:1078
CargoDataEntry::Remove
void Remove(CargoID cargo)
Remove a child associated with the given cargo.
Definition: station_gui.cpp:906
gui.h
CeilDiv
static uint CeilDiv(uint a, uint b)
Computes ceil(a / b) for non-negative a and b.
Definition: math_func.hpp:254
StationViewWindow::GR_CARGO
@ GR_CARGO
Group by cargo type.
Definition: station_gui.cpp:1244
WID_SV_CLOSE_AIRPORT
@ WID_SV_CLOSE_AIRPORT
'Close airport' button.
Definition: station_widget.h:26
Window
Data structure for an opened window.
Definition: window_gui.h:213
GUIList::RebuildDone
void RebuildDone()
Notify the sortlist that the rebuild is done.
Definition: sortlist_type.h:380
VEH_TRAIN
@ VEH_TRAIN
Train vehicle type.
Definition: vehicle_type.h:24
ST_COUNT
@ ST_COUNT
by amount of cargo
Definition: station_gui.cpp:836
CompanyStationsWindow::OnGameTick
void OnGameTick() override
Called once per (game) tick.
Definition: station_gui.cpp:634
Pool::PoolItem<&_company_pool >::IsValidID
static bool IsValidID(size_t index)
Tests whether given index can be used to get valid (non-nullptr) Titem.
Definition: pool_type.hpp:326
Window::RaiseWidget
void RaiseWidget(byte widget_index)
Marks a widget as raised.
Definition: window_gui.h:412
StationViewWindow::rating_lines
int rating_lines
Number of lines in the cargo ratings view.
Definition: station_gui.cpp:1256
_viewport_highlight_station
const Station * _viewport_highlight_station
Currently selected station for coverage area highlight.
Definition: viewport.cpp:997
SelectStationWindow::OnClick
void OnClick(Point pt, int widget, int click_count) override
A click with the left mouse button has been made on the window.
Definition: station_gui.cpp:2309
Window::DrawWidgets
void DrawWidgets() const
Paint all widgets of a window.
Definition: widget.cpp:858
StationViewWindow::expanded_rows
CargoDataEntry expanded_rows
Parent entry of currently expanded rows.
Definition: station_gui.cpp:1285
FACIL_AIRPORT
@ FACIL_AIRPORT
Station with an airport.
Definition: station_type.h:56
NWidgetBackground
Nested widget with a child.
Definition: widget_type.h:589
CompanyStationsWindow::DrawWidget
void DrawWidget(const Rect &r, int widget) const override
Draw the contents of a nested widget.
Definition: station_gui.cpp:425
StationViewWindow::Grouping
Grouping
Type of grouping used in each of the "columns".
Definition: station_gui.cpp:1240
CompanyStationsWindow::StationNameSorter
static bool StationNameSorter(const Station *const &a, const Station *const &b)
Sort stations by their name.
Definition: station_gui.cpp:259
SBS_UP
@ SBS_UP
Sort descending.
Definition: window_gui.h:161
WidgetDimensions::scaled
static WidgetDimensions scaled
Widget dimensions scaled for current zoom level.
Definition: window_gui.h:68
CompanyStationsWindow::StationRatingMinSorter
static bool StationRatingMinSorter(const Station *const &a, const Station *const &b)
Sort stations by their rating.
Definition: station_gui.cpp:311
WID_SV_SCROLLBAR
@ WID_SV_SCROLLBAR
Scrollbar.
Definition: station_widget.h:21
CT_INVALID
@ CT_INVALID
Invalid cargo type.
Definition: cargo_type.h:69
NWidgetCore
Base class for a 'real' widget.
Definition: widget_type.h:314
WID_SV_CAPTION
@ WID_SV_CAPTION
Caption of the window.
Definition: station_widget.h:15
IsCargoInClass
static bool IsCargoInClass(CargoID c, CargoClass cc)
Does cargo c have cargo class cc?
Definition: cargotype.h:200
Window::SetWidgetDirty
void SetWidgetDirty(byte widget_index) const
Invalidate a widget, i.e.
Definition: window.cpp:619
StationViewWindow::EstimateDestinations
void EstimateDestinations(CargoID 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...
Definition: station_gui.cpp:1496
VEH_SHIP
@ VEH_SHIP
Ship vehicle type.
Definition: vehicle_type.h:26
WID_SV_SHIPS
@ WID_SV_SHIPS
List of scheduled ships button.
Definition: station_widget.h:29
Rect
Specification of a rectangle with absolute coordinates of all edges.
Definition: geometry_type.hpp:69
Window::LowerWidget
void LowerWidget(byte widget_index)
Marks a widget as lowered.
Definition: window_gui.h:403
TileAndStation
Struct containing TileIndex and StationID.
Definition: station_gui.cpp:2123
Town::exclusivity
CompanyID exclusivity
which company has exclusivity
Definition: town.h:71
WidgetDimensions::vsep_wide
int vsep_wide
Wide vertical spacing.
Definition: window_gui.h:62
WC_AIRCRAFT_LIST
@ WC_AIRCRAFT_LIST
Aircraft list; Window numbers:
Definition: window_type.h:319
FindStationsNearby
static const T * FindStationsNearby(TileArea ta, bool distant_join)
Circulate around the to-be-built station to find stations we could join.
Definition: station_gui.cpp:2181
QSF_ENABLE_DEFAULT
@ QSF_ENABLE_DEFAULT
enable the 'Default' button ("\0" is returned)
Definition: textbuf_gui.h:21
Town::exclusive_counter
uint8 exclusive_counter
months till the exclusivity expires
Definition: town.h:72
WC_STATION_LIST
@ WC_STATION_LIST
Station list; Window numbers:
Definition: window_type.h:295
SelectStationWindow::OnRealtimeTick
void OnRealtimeTick(uint delta_ms) override
Called periodically.
Definition: station_gui.cpp:2326
WID_SV_TRAINS
@ WID_SV_TRAINS
List of scheduled trains button.
Definition: station_widget.h:27
ResetObjectToPlace
void ResetObjectToPlace()
Reset the cursor and mouse mode handling back to default (normal cursor, only clicking in windows).
Definition: viewport.cpp:3434
NWidgetResizeBase::SetMinimalSize
void SetMinimalSize(uint min_x, uint min_y)
Set minimal size of the widget.
Definition: widget.cpp:1080
PC_GREEN
static const uint8 PC_GREEN
Green palette colour.
Definition: gfx_func.h:259
Window::SetWidgetLoweredState
void SetWidgetLoweredState(byte widget_index, bool lowered_stat)
Sets the lowered/raised status of a widget.
Definition: window_gui.h:382
station_gui.h
TD_RTL
@ TD_RTL
Text is written right-to-left by default.
Definition: strings_type.h:24
_current_text_dir
TextDirection _current_text_dir
Text direction of the currently selected language.
Definition: strings.cpp:49
TileHighlightData::freeze
bool freeze
Freeze highlight in place.
Definition: tilehighlight_type.h:53
CompanyStationsWindow::OnDropdownSelect
void OnDropdownSelect(int widget, int index) override
A dropdown option associated to this window has been selected.
Definition: station_gui.cpp:622
CargoDataEntry::Begin
CargoDataSet::iterator Begin() const
Get an iterator pointing to the begin of the set of children.
Definition: station_gui.cpp:964
WWT_TEXTBTN
@ WWT_TEXTBTN
(Toggle) Button with text
Definition: widget_type.h:53
INVALID_STRING_ID
static const StringID INVALID_STRING_ID
Constant representing an invalid string (16bit in case it is used in savegames)
Definition: strings_type.h:17
ClientSettings::gui
GUISettings gui
settings related to the GUI
Definition: settings_type.h:604
station_widget.h
debug.h
WID_SV_PLANES
@ WID_SV_PLANES
List of scheduled planes button.
Definition: station_widget.h:30
LinkGraph::Monthly
uint Monthly(uint base) const
Scale a value to its monthly equivalent, based on last compression.
Definition: linkgraph.h:527
CargoDataEntry::transfers
bool transfers
If there are transfers for this cargo.
Definition: station_gui.cpp:1002
SetMinimalTextLines
static NWidgetPart SetMinimalTextLines(uint8 lines, uint8 spacing, FontSize size=FS_NORMAL)
Widget part function for setting the minimal text lines.
Definition: widget_type.h:1030
WWT_DROPDOWN
@ WWT_DROPDOWN
Drop down list.
Definition: widget_type.h:68
GUIList::SetSortFuncs
void SetSortFuncs(SortFunction *const *n_funcs)
Hand the array of sort function pointers to the sort list.
Definition: sortlist_type.h:270
GUISettings::persistent_buildingtools
bool persistent_buildingtools
keep the building tools active after usage
Definition: settings_type.h:167
TileVirtXY
static TileIndex TileVirtXY(uint x, uint y)
Get a tile from the virtual XY-coordinate.
Definition: map_func.h:194
ScaleGUITrad
static RectPadding ScaleGUITrad(const RectPadding &r)
Scale a RectPadding to GUI zoom level.
Definition: widget.cpp:168
ShowSelectBaseStationIfNeeded
void ShowSelectBaseStationIfNeeded(TileArea ta, StationPickerCmdProc &&proc)
Show the station selection window when needed.
Definition: station_gui.cpp:2420
SelectStationWindow::Close
void Close() override
Hide the window and all its child windows, and mark them for a later deletion.
Definition: station_gui.cpp:2260
CargoDataEntry::IncrementSize
void IncrementSize()
Increment.
Definition: station_gui.cpp:1123
WWT_SHADEBOX
@ WWT_SHADEBOX
Shade box (at top-right of a window, between WWT_DEBUGBOX and WWT_DEFSIZEBOX)
Definition: widget_type.h:62
Window::Close
virtual void Close()
Hide the window and all its child windows, and mark them for a later deletion.
Definition: window.cpp:1103
CargoDataEntry::End
CargoDataSet::iterator End() const
Get an iterator pointing to the end of the set of children.
Definition: station_gui.cpp:969
WID_SV_RENAME
@ WID_SV_RENAME
'Rename' button.
Definition: station_widget.h:25