OpenTTD Source: src/vehicle_gui.cpp Source File

OpenTTD Source 1.11.0-RC1

vehicle_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 "company_func.h"
13 #include "gui.h"
14 #include "textbuf_gui.h"
15 #include "command_func.h"
16 #include "vehicle_gui_base.h"
17 #include "viewport_func.h"
18 #include "newgrf_text.h"
19 #include "newgrf_debug.h"
20 #include "roadveh.h"
21 #include "train.h"
22 #include "aircraft.h"
23 #include "depot_map.h"
24 #include "group_gui.h"
25 #include "strings_func.h"
26 #include "vehicle_func.h"
27 #include "autoreplace_gui.h"
28 #include "string_func.h"
29 #include "widgets/dropdown_func.h"
30 #include "timetable.h"
31 #include "articulated_vehicles.h"
32 #include "spritecache.h"
33 #include "core/geometry_func.hpp"
34 #include "company_base.h"
35 #include "engine_func.h"
36 #include "station_base.h"
37 #include "tilehighlight_func.h"
38 #include "zoom_func.h"
39
40 #include "safeguards.h"
41
42
43 BaseVehicleListWindow::GroupBy _grouping[VLT_END][VEH_COMPANY_END];
44 Sorting _sorting[BaseVehicleListWindow::GB_END];
45
46 static BaseVehicleListWindow::VehicleIndividualSortFunction VehicleNumberSorter;
47 static BaseVehicleListWindow::VehicleIndividualSortFunction VehicleNameSorter;
48 static BaseVehicleListWindow::VehicleIndividualSortFunction VehicleAgeSorter;
49 static BaseVehicleListWindow::VehicleIndividualSortFunction VehicleProfitThisYearSorter;
50 static BaseVehicleListWindow::VehicleIndividualSortFunction VehicleProfitLastYearSorter;
51 static BaseVehicleListWindow::VehicleIndividualSortFunction VehicleCargoSorter;
52 static BaseVehicleListWindow::VehicleIndividualSortFunction VehicleReliabilitySorter;
53 static BaseVehicleListWindow::VehicleIndividualSortFunction VehicleMaxSpeedSorter;
54 static BaseVehicleListWindow::VehicleIndividualSortFunction VehicleModelSorter;
55 static BaseVehicleListWindow::VehicleIndividualSortFunction VehicleValueSorter;
56 static BaseVehicleListWindow::VehicleIndividualSortFunction VehicleLengthSorter;
57 static BaseVehicleListWindow::VehicleIndividualSortFunction VehicleTimeToLiveSorter;
58 static BaseVehicleListWindow::VehicleIndividualSortFunction VehicleTimetableDelaySorter;
59 static BaseVehicleListWindow::VehicleGroupSortFunction VehicleGroupLengthSorter;
60 static BaseVehicleListWindow::VehicleGroupSortFunction VehicleGroupTotalProfitThisYearSorter;
61 static BaseVehicleListWindow::VehicleGroupSortFunction VehicleGroupTotalProfitLastYearSorter;
62 static BaseVehicleListWindow::VehicleGroupSortFunction VehicleGroupAverageProfitThisYearSorter;
63 static BaseVehicleListWindow::VehicleGroupSortFunction VehicleGroupAverageProfitLastYearSorter;
64
66 template <BaseVehicleListWindow::VehicleIndividualSortFunction func>
67 static bool VehicleIndividualToGroupSorterWrapper(GUIVehicleGroup const &a, GUIVehicleGroup const &b)
68 {
69 return func(*(a.vehicles_begin), *(b.vehicles_begin));
70 }
71
72 BaseVehicleListWindow::VehicleGroupSortFunction * const BaseVehicleListWindow::vehicle_group_none_sorter_funcs[] = {
73 &VehicleIndividualToGroupSorterWrapper<VehicleNumberSorter>,
74 &VehicleIndividualToGroupSorterWrapper<VehicleNameSorter>,
75 &VehicleIndividualToGroupSorterWrapper<VehicleAgeSorter>,
76 &VehicleIndividualToGroupSorterWrapper<VehicleProfitThisYearSorter>,
77 &VehicleIndividualToGroupSorterWrapper<VehicleProfitLastYearSorter>,
78 &VehicleIndividualToGroupSorterWrapper<VehicleCargoSorter>,
79 &VehicleIndividualToGroupSorterWrapper<VehicleReliabilitySorter>,
80 &VehicleIndividualToGroupSorterWrapper<VehicleMaxSpeedSorter>,
81 &VehicleIndividualToGroupSorterWrapper<VehicleModelSorter>,
82 &VehicleIndividualToGroupSorterWrapper<VehicleValueSorter>,
83 &VehicleIndividualToGroupSorterWrapper<VehicleLengthSorter>,
84 &VehicleIndividualToGroupSorterWrapper<VehicleTimeToLiveSorter>,
85 &VehicleIndividualToGroupSorterWrapper<VehicleTimetableDelaySorter>,
86 };
87
88 const StringID BaseVehicleListWindow::vehicle_group_none_sorter_names[] = {
89 STR_SORT_BY_NUMBER,
90 STR_SORT_BY_NAME,
91 STR_SORT_BY_AGE,
92 STR_SORT_BY_PROFIT_THIS_YEAR,
93 STR_SORT_BY_PROFIT_LAST_YEAR,
94 STR_SORT_BY_TOTAL_CAPACITY_PER_CARGOTYPE,
95 STR_SORT_BY_RELIABILITY,
96 STR_SORT_BY_MAX_SPEED,
97 STR_SORT_BY_MODEL,
98 STR_SORT_BY_VALUE,
99 STR_SORT_BY_LENGTH,
100 STR_SORT_BY_LIFE_TIME,
101 STR_SORT_BY_TIMETABLE_DELAY,
102 INVALID_STRING_ID
103 };
104
105 BaseVehicleListWindow::VehicleGroupSortFunction * const BaseVehicleListWindow::vehicle_group_shared_orders_sorter_funcs[] = {
106 &VehicleGroupLengthSorter,
107 &VehicleGroupTotalProfitThisYearSorter,
108 &VehicleGroupTotalProfitLastYearSorter,
109 &VehicleGroupAverageProfitThisYearSorter,
110 &VehicleGroupAverageProfitLastYearSorter,
111 };
112
113 const StringID BaseVehicleListWindow::vehicle_group_shared_orders_sorter_names[] = {
114 STR_SORT_BY_NUM_VEHICLES,
115 STR_SORT_BY_TOTAL_PROFIT_THIS_YEAR,
116 STR_SORT_BY_TOTAL_PROFIT_LAST_YEAR,
117 STR_SORT_BY_AVERAGE_PROFIT_THIS_YEAR,
118 STR_SORT_BY_AVERAGE_PROFIT_LAST_YEAR,
119 INVALID_STRING_ID
120 };
121
122 const StringID BaseVehicleListWindow::vehicle_group_by_names[] = {
123 STR_GROUP_BY_NONE,
124 STR_GROUP_BY_SHARED_ORDERS,
125 INVALID_STRING_ID
126 };
127
128 const StringID BaseVehicleListWindow::vehicle_depot_name[] = {
129 STR_VEHICLE_LIST_SEND_TRAIN_TO_DEPOT,
130 STR_VEHICLE_LIST_SEND_ROAD_VEHICLE_TO_DEPOT,
131 STR_VEHICLE_LIST_SEND_SHIP_TO_DEPOT,
132 STR_VEHICLE_LIST_SEND_AIRCRAFT_TO_HANGAR
133 };
134
135 BaseVehicleListWindow::BaseVehicleListWindow(WindowDesc *desc, WindowNumber wno) : Window(desc), vli(VehicleListIdentifier::UnPack(wno))
136 {
137 this->grouping = _grouping[vli.type][vli.vtype];
138 this->UpdateSortingFromGrouping();
139 }
140
146 uint CountDigitsForAllocatingSpace(uint number)
147 {
148 if (number >= 10000) return 5;
149 if (number >= 1000) return 4;
150 if (number >= 100) return 3;
151
152 /*
153 * When the smallest unit number is less than 10, it is
154 * quite likely that it will expand to become more than
155 * 10 quite soon.
156 */
157 return 2;
158 }
159
165 uint GetUnitNumberDigits(VehicleList &vehicles)
166 {
167 uint unitnumber = 0;
168 for (const Vehicle *v : vehicles) {
169 unitnumber = std::max<uint>(unitnumber, v->unitnumber);
170 }
171
172 return CountDigitsForAllocatingSpace(unitnumber);
173 }
174
175 void BaseVehicleListWindow::BuildVehicleList()
176 {
177 if (!this->vehgroups.NeedRebuild()) return;
178
179 DEBUG(misc, 3, "Building vehicle list type %d for company %d given index %d", this->vli.type, this->vli.company, this->vli.index);
180
181 this->vehgroups.clear();
182
183 GenerateVehicleSortList(&this->vehicles, this->vli);
184
185 if (this->grouping == GB_NONE) {
186 uint max_unitnumber = 0;
187 for (auto it = this->vehicles.begin(); it != this->vehicles.end(); ++it) {
188 this->vehgroups.emplace_back(it, it + 1);
189
190 max_unitnumber = std::max<uint>(max_unitnumber, (*it)->unitnumber);
191 }
192 this->unitnumber_digits = CountDigitsForAllocatingSpace(max_unitnumber);
193 } else {
194 /* Sort by the primary vehicle; we just want all vehicles that share the same orders to form a contiguous range. */
195 std::stable_sort(this->vehicles.begin(), this->vehicles.end(), [](const Vehicle * const &u, const Vehicle * const &v) {
196 return u->FirstShared() < v->FirstShared();
197 });
198
199 uint max_num_vehicles = 0;
200
201 VehicleList::const_iterator begin = this->vehicles.begin();
202 while (begin != this->vehicles.end()) {
203 VehicleList::const_iterator end = std::find_if_not(begin, this->vehicles.cend(), [first_shared = (*begin)->FirstShared()](const Vehicle * const &v) {
204 return v->FirstShared() == first_shared;
205 });
206
207 this->vehgroups.emplace_back(begin, end);
208
209 max_num_vehicles = std::max<uint>(max_num_vehicles, static_cast<uint>(end - begin));
210
211 begin = end;
212 }
213
214 this->unitnumber_digits = CountDigitsForAllocatingSpace(max_num_vehicles);
215 }
216
217 this->vehgroups.RebuildDone();
218 this->vscroll->SetCount(static_cast<int>(this->vehgroups.size()));
219 }
220
227 Dimension BaseVehicleListWindow::GetActionDropdownSize(bool show_autoreplace, bool show_group)
228 {
229 Dimension d = {0, 0};
230
231 if (show_autoreplace) d = maxdim(d, GetStringBoundingBox(STR_VEHICLE_LIST_REPLACE_VEHICLES));
232 d = maxdim(d, GetStringBoundingBox(STR_VEHICLE_LIST_SEND_FOR_SERVICING));
233 d = maxdim(d, GetStringBoundingBox(this->vehicle_depot_name[this->vli.vtype]));
234
235 if (show_group) {
236 d = maxdim(d, GetStringBoundingBox(STR_GROUP_ADD_SHARED_VEHICLE));
237 d = maxdim(d, GetStringBoundingBox(STR_GROUP_REMOVE_ALL_VEHICLES));
238 }
239
240 return d;
241 }
242
249 DropDownList BaseVehicleListWindow::BuildActionDropdownList(bool show_autoreplace, bool show_group)
250 {
251 DropDownList list;
252
253 if (show_autoreplace) list.emplace_back(new DropDownListStringItem(STR_VEHICLE_LIST_REPLACE_VEHICLES, ADI_REPLACE, false));
254 list.emplace_back(new DropDownListStringItem(STR_VEHICLE_LIST_SEND_FOR_SERVICING, ADI_SERVICE, false));
255 list.emplace_back(new DropDownListStringItem(this->vehicle_depot_name[this->vli.vtype], ADI_DEPOT, false));
256
257 if (show_group) {
258 list.emplace_back(new DropDownListStringItem(STR_GROUP_ADD_SHARED_VEHICLE, ADI_ADD_SHARED, false));
259 list.emplace_back(new DropDownListStringItem(STR_GROUP_REMOVE_ALL_VEHICLES, ADI_REMOVE_ALL, false));
260 }
261
262 return list;
263 }
264
265 /* cached values for VehicleNameSorter to spare many GetString() calls */
266 static const Vehicle *_last_vehicle[2] = { nullptr, nullptr };
267
268 void BaseVehicleListWindow::SortVehicleList()
269 {
270 if (this->vehgroups.Sort()) return;
271
272 /* invalidate cached values for name sorter - vehicle names could change */
273 _last_vehicle[0] = _last_vehicle[1] = nullptr;
274 }
275
276 void DepotSortList(VehicleList *list)
277 {
278 if (list->size() < 2) return;
279 std::sort(list->begin(), list->end(), &VehicleNumberSorter);
280 }
281
283 static void DrawVehicleProfitButton(Date age, Money display_profit_last_year, uint num_vehicles, int x, int y)
284 {
285 SpriteID spr;
286
287 /* draw profit-based coloured icons */
288 if (age <= VEHICLE_PROFIT_MIN_AGE) {
289 spr = SPR_PROFIT_NA;
290 } else if (display_profit_last_year < 0) {
291 spr = SPR_PROFIT_NEGATIVE;
292 } else if (display_profit_last_year < VEHICLE_PROFIT_THRESHOLD * num_vehicles) {
293 spr = SPR_PROFIT_SOME;
294 } else {
295 spr = SPR_PROFIT_LOT;
296 }
297 DrawSprite(spr, PAL_NONE, x, y);
298 }
299
301 static const uint MAX_REFIT_CYCLE = 256;
302
312 byte GetBestFittingSubType(Vehicle *v_from, Vehicle *v_for, CargoID dest_cargo_type)
313 {
314 v_from = v_from->GetFirstEnginePart();
315 v_for = v_for->GetFirstEnginePart();
316
317 /* Create a list of subtypes used by the various parts of v_for */
318 static std::vector<StringID> subtypes;
319 subtypes.clear();
320 for (; v_from != nullptr; v_from = v_from->HasArticulatedPart() ? v_from->GetNextArticulatedPart() : nullptr) {
321 const Engine *e_from = v_from->GetEngine();
322 if (!e_from->CanCarryCargo() || !HasBit(e_from->info.callback_mask, CBM_VEHICLE_CARGO_SUFFIX)) continue;
323 include(subtypes, GetCargoSubtypeText(v_from));
324 }
325
326 byte ret_refit_cyc = 0;
327 bool success = false;
328 if (subtypes.size() > 0) {
329 /* Check whether any articulated part is refittable to 'dest_cargo_type' with a subtype listed in 'subtypes' */
330 for (Vehicle *v = v_for; v != nullptr; v = v->HasArticulatedPart() ? v->GetNextArticulatedPart() : nullptr) {
331 const Engine *e = v->GetEngine();
332 if (!e->CanCarryCargo() || !HasBit(e->info.callback_mask, CBM_VEHICLE_CARGO_SUFFIX)) continue;
333 if (!HasBit(e->info.refit_mask, dest_cargo_type) && v->cargo_type != dest_cargo_type) continue;
334
335 CargoID old_cargo_type = v->cargo_type;
336 byte old_cargo_subtype = v->cargo_subtype;
337
338 /* Set the 'destination' cargo */
339 v->cargo_type = dest_cargo_type;
340
341 /* Cycle through the refits */
342 for (uint refit_cyc = 0; refit_cyc < MAX_REFIT_CYCLE; refit_cyc++) {
343 v->cargo_subtype = refit_cyc;
344
345 /* Make sure we don't pick up anything cached. */
346 v->First()->InvalidateNewGRFCache();
347 v->InvalidateNewGRFCache();
348
349 StringID subtype = GetCargoSubtypeText(v);
350 if (subtype == STR_EMPTY) break;
351
352 if (std::find(subtypes.begin(), subtypes.end(), subtype) == subtypes.end()) continue;
353
354 /* We found something matching. */
355 ret_refit_cyc = refit_cyc;
356 success = true;
357 break;
358 }
359
360 /* Reset the vehicle's cargo type */
361 v->cargo_type = old_cargo_type;
362 v->cargo_subtype = old_cargo_subtype;
363
364 /* Make sure we don't taint the vehicle. */
365 v->First()->InvalidateNewGRFCache();
366 v->InvalidateNewGRFCache();
367
368 if (success) break;
369 }
370 }
371
372 return ret_refit_cyc;
373 }
374
376 struct RefitOption {
377 CargoID cargo;
378 byte subtype;
379 StringID string;
380
386 inline bool operator != (const RefitOption &other) const
387 {
388 return other.cargo != this->cargo || other.string != this->string;
389 }
390
396 inline bool operator == (const RefitOption &other) const
397 {
398 return other.cargo == this->cargo && other.string == this->string;
399 }
400 };
401
402 typedef std::vector<RefitOption> SubtypeList;
403
413 static void DrawVehicleRefitWindow(const SubtypeList list[NUM_CARGO], const int sel[2], uint pos, uint rows, uint delta, const Rect &r)
414 {
415 uint y = r.top + WD_MATRIX_TOP;
416 uint current = 0;
417
418 bool rtl = _current_text_dir == TD_RTL;
419 uint iconwidth = std::max(GetSpriteSize(SPR_CIRCLE_FOLDED).width, GetSpriteSize(SPR_CIRCLE_UNFOLDED).width);
420 uint iconheight = GetSpriteSize(SPR_CIRCLE_FOLDED).height;
421 int linecolour = _colour_gradient[COLOUR_ORANGE][4];
422
423 int iconleft = rtl ? r.right - WD_MATRIX_RIGHT - iconwidth : r.left + WD_MATRIX_LEFT;
424 int iconcenter = rtl ? r.right - WD_MATRIX_RIGHT - iconwidth / 2 : r.left + WD_MATRIX_LEFT + iconwidth / 2;
425 int iconinner = rtl ? r.right - WD_MATRIX_RIGHT - iconwidth : r.left + WD_MATRIX_LEFT + iconwidth;
426
427 int textleft = r.left + WD_MATRIX_LEFT + (rtl ? 0 : iconwidth + 4);
428 int textright = r.right - WD_MATRIX_RIGHT - (rtl ? iconwidth + 4 : 0);
429
430 /* Draw the list of subtypes for each cargo, and find the selected refit option (by its position). */
431 for (uint i = 0; current < pos + rows && i < NUM_CARGO; i++) {
432 for (uint j = 0; current < pos + rows && j < list[i].size(); j++) {
433 const RefitOption &refit = list[i][j];
434
435 /* Hide subtypes if sel[0] does not match */
436 if (sel[0] != (int)i && refit.subtype != 0xFF) continue;
437
438 /* Refit options with a position smaller than pos don't have to be drawn. */
439 if (current < pos) {
440 current++;
441 continue;
442 }
443
444 if (list[i].size() > 1) {
445 if (refit.subtype != 0xFF) {
446 /* Draw tree lines */
447 int ycenter = y + FONT_HEIGHT_NORMAL / 2;
448 GfxDrawLine(iconcenter, y - WD_MATRIX_TOP, iconcenter, j == list[i].size() - 1 ? ycenter : y - WD_MATRIX_TOP + delta - 1, linecolour);
449 GfxDrawLine(iconcenter, ycenter, iconinner, ycenter, linecolour);
450 } else {
451 /* Draw expand/collapse icon */
452 DrawSprite(sel[0] == (int)i ? SPR_CIRCLE_UNFOLDED : SPR_CIRCLE_FOLDED, PAL_NONE, iconleft, y + (FONT_HEIGHT_NORMAL - iconheight) / 2);
453 }
454 }
455
456 TextColour colour = (sel[0] == (int)i && (uint)sel[1] == j) ? TC_WHITE : TC_BLACK;
457 /* Get the cargo name. */
458 SetDParam(0, CargoSpec::Get(refit.cargo)->name);
459 SetDParam(1, refit.string);
460 DrawString(textleft, textright, y, STR_JUST_STRING_STRING, colour);
461
462 y += delta;
463 current++;
464 }
465 }
466 }
467
469 struct RefitWindow : public Window {
470 int sel[2];
471 RefitOption *cargo;
472 SubtypeList list[NUM_CARGO];
473 VehicleOrderID order;
474 uint information_width;
475 Scrollbar *vscroll;
476 Scrollbar *hscroll;
477 int vehicle_width;
478 int sprite_left;
479 int sprite_right;
480 uint vehicle_margin;
481 int click_x;
482 VehicleID selected_vehicle;
483 uint8 num_vehicles;
484 bool auto_refit;
485
489 void BuildRefitList()
490 {
491 for (uint i = 0; i < NUM_CARGO; i++) this->list[i].clear();
492 Vehicle *v = Vehicle::Get(this->window_number);
493
494 /* Check only the selected vehicles. */
495 VehicleSet vehicles_to_refit;
496 GetVehicleSet(vehicles_to_refit, Vehicle::Get(this->selected_vehicle), this->num_vehicles);
497
498 do {
499 if (v->type == VEH_TRAIN && std::find(vehicles_to_refit.begin(), vehicles_to_refit.end(), v->index) == vehicles_to_refit.end()) continue;
500 const Engine *e = v->GetEngine();
501 CargoTypes cmask = e->info.refit_mask;
502 byte callback_mask = e->info.callback_mask;
503
504 /* Skip this engine if it does not carry anything */
505 if (!e->CanCarryCargo()) continue;
506 /* Skip this engine if we build the list for auto-refitting and engine doesn't allow it. */
507 if (this->auto_refit && !HasBit(e->info.misc_flags, EF_AUTO_REFIT)) continue;
508
509 /* Loop through all cargoes in the refit mask */
510 int current_index = 0;
511 const CargoSpec *cs;
512 FOR_ALL_SORTED_CARGOSPECS(cs) {
513 CargoID cid = cs->Index();
514 /* Skip cargo type if it's not listed */
515 if (!HasBit(cmask, cid)) {
516 current_index++;
517 continue;
518 }
519
520 bool first_vehicle = this->list[current_index].size() == 0;
521 if (first_vehicle) {
522 /* Keeping the current subtype is always an option. It also serves as the option in case of no subtypes */
523 this->list[current_index].push_back({cid, 0xFF, STR_EMPTY});
524 }
525
526 /* Check the vehicle's callback mask for cargo suffixes.
527 * This is not supported for ordered refits, since subtypes only have a meaning
528 * for a specific vehicle at a specific point in time, which conflicts with shared orders,
529 * autoreplace, autorenew, clone, order restoration, ... */
530 if (this->order == INVALID_VEH_ORDER_ID && HasBit(callback_mask, CBM_VEHICLE_CARGO_SUFFIX)) {
531 /* Make a note of the original cargo type. It has to be
532 * changed to test the cargo & subtype... */
533 CargoID temp_cargo = v->cargo_type;
534 byte temp_subtype = v->cargo_subtype;
535
536 v->cargo_type = cid;
537
538 for (uint refit_cyc = 0; refit_cyc < MAX_REFIT_CYCLE; refit_cyc++) {
539 v->cargo_subtype = refit_cyc;
540
541 /* Make sure we don't pick up anything cached. */
542 v->First()->InvalidateNewGRFCache();
543 v->InvalidateNewGRFCache();
544
545 StringID subtype = GetCargoSubtypeText(v);
546
547 if (first_vehicle) {
548 /* Append new subtype (don't add duplicates though) */
549 if (subtype == STR_EMPTY) break;
550
551 RefitOption option;
552 option.cargo = cid;
553 option.subtype = refit_cyc;
554 option.string = subtype;
555 include(this->list[current_index], option);
556 } else {
557 /* Intersect the subtypes of earlier vehicles with the subtypes of this vehicle */
558 if (subtype == STR_EMPTY) {
559 /* No more subtypes for this vehicle, delete all subtypes >= refit_cyc */
560 SubtypeList &l = this->list[current_index];
561 /* 0xFF item is in front, other subtypes are sorted. So just truncate the list in the right spot */
562 for (uint i = 1; i < l.size(); i++) {
563 if (l[i].subtype >= refit_cyc) {
564 l.resize(i);
565 break;
566 }
567 }
568 break;
569 } else {
570 /* Check whether the subtype matches with the subtype of earlier vehicles. */
571 uint pos = 1;
572 SubtypeList &l = this->list[current_index];
573 while (pos < l.size() && l[pos].subtype != refit_cyc) pos++;
574 if (pos < l.size() && l[pos].string != subtype) {
575 /* String mismatch, remove item keeping the order */
576 l.erase(l.begin() + pos);
577 }
578 }
579 }
580 }
581
582 /* Reset the vehicle's cargo type */
583 v->cargo_type = temp_cargo;
584 v->cargo_subtype = temp_subtype;
585
586 /* And make sure we haven't tainted the cache */
587 v->First()->InvalidateNewGRFCache();
588 v->InvalidateNewGRFCache();
589 }
590 current_index++;
591 }
592 } while (v->IsGroundVehicle() && (v = v->Next()) != nullptr);
593 }
594
598 void RefreshScrollbar()
599 {
600 uint scroll_row = 0;
601 uint row = 0;
602
603 for (uint i = 0; i < NUM_CARGO; i++) {
604 for (uint j = 0; j < this->list[i].size(); j++) {
605 const RefitOption &refit = this->list[i][j];
606
607 /* Hide subtypes if sel[0] does not match */
608 if (this->sel[0] != (int)i && refit.subtype != 0xFF) continue;
609
610 if (this->sel[0] == (int)i && (uint)this->sel[1] == j) scroll_row = row;
611
612 row++;
613 }
614 }
615
616 this->vscroll->SetCount(row);
617 if (scroll_row < row) this->vscroll->ScrollTowards(scroll_row);
618 }
619
624 void SetSelection(uint click_row)
625 {
626 uint row = 0;
627
628 for (uint i = 0; i < NUM_CARGO; i++) {
629 for (uint j = 0; j < this->list[i].size(); j++) {
630 const RefitOption &refit = this->list[i][j];
631
632 /* Hide subtypes if sel[0] does not match */
633 if (this->sel[0] != (int)i && refit.subtype != 0xFF) continue;
634
635 if (row == click_row) {
636 this->sel[0] = i;
637 this->sel[1] = j;
638 return;
639 }
640
641 row++;
642 }
643 }
644
645 this->sel[0] = -1;
646 this->sel[1] = 0;
647 }
648
653 RefitOption *GetRefitOption()
654 {
655 if (this->sel[0] < 0) return nullptr;
656
657 SubtypeList &l = this->list[this->sel[0]];
658 if ((uint)this->sel[1] >= l.size()) return nullptr;
659
660 return &l[this->sel[1]];
661 }
662
663 RefitWindow(WindowDesc *desc, const Vehicle *v, VehicleOrderID order, bool auto_refit) : Window(desc)
664 {
665 this->sel[0] = -1;
666 this->sel[1] = 0;
667 this->auto_refit = auto_refit;
668 this->order = order;
669 this->CreateNestedTree();
670
671 this->vscroll = this->GetScrollbar(WID_VR_SCROLLBAR);
672 this->hscroll = (v->IsGroundVehicle() ? this->GetScrollbar(WID_VR_HSCROLLBAR) : nullptr);
673 this->GetWidget<NWidgetCore>(WID_VR_SELECT_HEADER)->tool_tip = STR_REFIT_TRAIN_LIST_TOOLTIP + v->type;
674 this->GetWidget<NWidgetCore>(WID_VR_MATRIX)->tool_tip = STR_REFIT_TRAIN_LIST_TOOLTIP + v->type;
675 NWidgetCore *nwi = this->GetWidget<NWidgetCore>(WID_VR_REFIT);
676 nwi->widget_data = STR_REFIT_TRAIN_REFIT_BUTTON + v->type;
677 nwi->tool_tip = STR_REFIT_TRAIN_REFIT_TOOLTIP + v->type;
678 this->GetWidget<NWidgetStacked>(WID_VR_SHOW_HSCROLLBAR)->SetDisplayedPlane(v->IsGroundVehicle() ? 0 : SZSP_HORIZONTAL);
679 this->GetWidget<NWidgetCore>(WID_VR_VEHICLE_PANEL_DISPLAY)->tool_tip = (v->type == VEH_TRAIN) ? STR_REFIT_SELECT_VEHICLES_TOOLTIP : STR_NULL;
680
681 this->FinishInitNested(v->index);
682 this->owner = v->owner;
683
684 this->SetWidgetDisabledState(WID_VR_REFIT, this->sel[0] < 0);
685 }
686
687 void OnInit() override
688 {
689 if (this->cargo != nullptr) {
690 /* Store the RefitOption currently in use. */
691 RefitOption current_refit_option = *(this->cargo);
692
693 /* Rebuild the refit list */
694 this->BuildRefitList();
695 this->sel[0] = -1;
696 this->sel[1] = 0;
697 this->cargo = nullptr;
698 for (uint i = 0; this->cargo == nullptr && i < NUM_CARGO; i++) {
699 for (uint j = 0; j < list[i].size(); j++) {
700 if (list[i][j] == current_refit_option) {
701 this->sel[0] = i;
702 this->sel[1] = j;
703 this->cargo = &list[i][j];
704 break;
705 }
706 }
707 }
708
709 this->SetWidgetDisabledState(WID_VR_REFIT, this->sel[0] < 0);
710 this->RefreshScrollbar();
711 } else {
712 /* Rebuild the refit list */
713 this->OnInvalidateData(VIWD_CONSIST_CHANGED);
714 }
715 }
716
717 void OnPaint() override
718 {
719 /* Determine amount of items for scroller. */
720 if (this->hscroll != nullptr) this->hscroll->SetCount(this->vehicle_width);
721
722 /* Calculate sprite position. */
723 NWidgetCore *vehicle_panel_display = this->GetWidget<NWidgetCore>(WID_VR_VEHICLE_PANEL_DISPLAY);
724 int sprite_width = std::max(0, ((int)vehicle_panel_display->current_x - this->vehicle_width) / 2);
725 this->sprite_left = vehicle_panel_display->pos_x;
726 this->sprite_right = vehicle_panel_display->pos_x + vehicle_panel_display->current_x - 1;
727 if (_current_text_dir == TD_RTL) {
728 this->sprite_right -= sprite_width;
729 this->vehicle_margin = vehicle_panel_display->current_x - sprite_right;
730 } else {
731 this->sprite_left += sprite_width;
732 this->vehicle_margin = sprite_left;
733 }
734
735 this->DrawWidgets();
736 }
737
738 void UpdateWidgetSize(int widget, Dimension *size, const Dimension &padding, Dimension *fill, Dimension *resize) override
739 {
740 switch (widget) {
741 case WID_VR_MATRIX:
742 resize->height = WD_MATRIX_TOP + FONT_HEIGHT_NORMAL + WD_MATRIX_BOTTOM;
743 size->height = resize->height * 8;
744 break;
745
746 case WID_VR_VEHICLE_PANEL_DISPLAY:
747 size->height = ScaleGUITrad(GetVehicleHeight(Vehicle::Get(this->window_number)->type));
748 break;
749
750 case WID_VR_INFO:
751 size->width = WD_FRAMERECT_LEFT + this->information_width + WD_FRAMERECT_RIGHT;
752 break;
753 }
754 }
755
756 void SetStringParameters(int widget) const override
757 {
758 if (widget == WID_VR_CAPTION) SetDParam(0, Vehicle::Get(this->window_number)->index);
759 }
760
767 StringID GetCapacityString(RefitOption *option) const
768 {
769 assert(_current_company == _local_company);
770 Vehicle *v = Vehicle::Get(this->window_number);
771 CommandCost cost = DoCommand(v->tile, this->selected_vehicle, option->cargo | option->subtype << 8 | this->num_vehicles << 16 |
772 (int)this->auto_refit << 24, DC_QUERY_COST, GetCmdRefitVeh(v->type));
773
774 if (cost.Failed()) return INVALID_STRING_ID;
775
776 SetDParam(0, option->cargo);
777 SetDParam(1, _returned_refit_capacity);
778
779 Money money = cost.GetCost();
780 if (_returned_mail_refit_capacity > 0) {
781 SetDParam(2, CT_MAIL);
782 SetDParam(3, _returned_mail_refit_capacity);
783 if (this->order != INVALID_VEH_ORDER_ID) {
784 /* No predictable cost */
785 return STR_PURCHASE_INFO_AIRCRAFT_CAPACITY;
786 } else if (money <= 0) {
787 SetDParam(4, -money);
788 return STR_REFIT_NEW_CAPACITY_INCOME_FROM_AIRCRAFT_REFIT;
789 } else {
790 SetDParam(4, money);
791 return STR_REFIT_NEW_CAPACITY_COST_OF_AIRCRAFT_REFIT;
792 }
793 } else {
794 if (this->order != INVALID_VEH_ORDER_ID) {
795 /* No predictable cost */
796 SetDParam(2, STR_EMPTY);
797 return STR_PURCHASE_INFO_CAPACITY;
798 } else if (money <= 0) {
799 SetDParam(2, -money);
800 return STR_REFIT_NEW_CAPACITY_INCOME_FROM_REFIT;
801 } else {
802 SetDParam(2, money);
803 return STR_REFIT_NEW_CAPACITY_COST_OF_REFIT;
804 }
805 }
806 }
807
808 void DrawWidget(const Rect &r, int widget) const override
809 {
810 switch (widget) {
811 case WID_VR_VEHICLE_PANEL_DISPLAY: {
812 Vehicle *v = Vehicle::Get(this->window_number);
813 DrawVehicleImage(v, this->sprite_left + WD_FRAMERECT_LEFT, this->sprite_right - WD_FRAMERECT_RIGHT,
814 r.top + WD_FRAMERECT_TOP, INVALID_VEHICLE, EIT_IN_DETAILS, this->hscroll != nullptr ? this->hscroll->GetPosition() : 0);
815
816 /* Highlight selected vehicles. */
817 if (this->order != INVALID_VEH_ORDER_ID) break;
818 int x = 0;
819 switch (v->type) {
820 case VEH_TRAIN: {
821 VehicleSet vehicles_to_refit;
822 GetVehicleSet(vehicles_to_refit, Vehicle::Get(this->selected_vehicle), this->num_vehicles);
823
824 int left = INT32_MIN;
825 int width = 0;
826
827 for (Train *u = Train::From(v); u != nullptr; u = u->Next()) {
828 /* Start checking. */
829 const bool contained = std::find(vehicles_to_refit.begin(), vehicles_to_refit.end(), u->index) != vehicles_to_refit.end();
830 if (contained && left == INT32_MIN) {
831 left = x - this->hscroll->GetPosition() + r.left + this->vehicle_margin;
832 width = 0;
833 }
834
835 /* Draw a selection. */
836 if ((!contained || u->Next() == nullptr) && left != INT32_MIN) {
837 if (u->Next() == nullptr && contained) {
838 int current_width = u->GetDisplayImageWidth();
839 width += current_width;
840 x += current_width;
841 }
842
843 int right = Clamp(left + width, 0, r.right);
844 left = std::max(0, left);
845
846 if (_current_text_dir == TD_RTL) {
847 right = this->GetWidget<NWidgetCore>(WID_VR_VEHICLE_PANEL_DISPLAY)->current_x - left;
848 left = right - width;
849 }
850
851 if (left != right) {
852 DrawFrameRect(left, r.top + WD_FRAMERECT_TOP, right, r.top + WD_FRAMERECT_TOP + ScaleGUITrad(14) - 1, COLOUR_WHITE, FR_BORDERONLY);
853 }
854
855 left = INT32_MIN;
856 }
857
858 int current_width = u->GetDisplayImageWidth();
859 width += current_width;
860 x += current_width;
861 }
862 break;
863 }
864
865 default: break;
866 }
867 break;
868 }
869
870 case WID_VR_MATRIX:
871 DrawVehicleRefitWindow(this->list, this->sel, this->vscroll->GetPosition(), this->vscroll->GetCapacity(), this->resize.step_height, r);
872 break;
873
874 case WID_VR_INFO:
875 if (this->cargo != nullptr) {
876 StringID string = this->GetCapacityString(this->cargo);
877 if (string != INVALID_STRING_ID) {
878 DrawStringMultiLine(r.left + WD_FRAMERECT_LEFT, r.right - WD_FRAMERECT_RIGHT,
879 r.top + WD_FRAMERECT_TOP, r.bottom - WD_FRAMERECT_BOTTOM, string);
880 }
881 }
882 break;
883 }
884 }
885
891 void OnInvalidateData(int data = 0, bool gui_scope = true) override
892 {
893 switch (data) {
894 case VIWD_AUTOREPLACE: // Autoreplace replaced the vehicle; selected_vehicle became invalid.
895 case VIWD_CONSIST_CHANGED: { // The consist has changed; rebuild the entire list.
896 /* Clear the selection. */
897 Vehicle *v = Vehicle::Get(this->window_number);
898 this->selected_vehicle = v->index;
899 this->num_vehicles = UINT8_MAX;
900 FALLTHROUGH;
901 }
902
903 case 2: { // The vehicle selection has changed; rebuild the entire list.
904 if (!gui_scope) break;
905 this->BuildRefitList();
906
907 /* The vehicle width has changed too. */
908 this->vehicle_width = GetVehicleWidth(Vehicle::Get(this->window_number), EIT_IN_DETAILS);
909 uint max_width = 0;
910
911 /* Check the width of all cargo information strings. */
912 for (uint i = 0; i < NUM_CARGO; i++) {
913 for (uint j = 0; j < this->list[i].size(); j++) {
914 StringID string = this->GetCapacityString(&list[i][j]);
915 if (string != INVALID_STRING_ID) {
916 Dimension dim = GetStringBoundingBox(string);
917 max_width = std::max(dim.width, max_width);
918 }
919 }
920 }
921
922 if (this->information_width < max_width) {
923 this->information_width = max_width;
924 this->ReInit();
925 }
926 FALLTHROUGH;
927 }
928
929 case 1: // A new cargo has been selected.
930 if (!gui_scope) break;
931 this->cargo = GetRefitOption();
932 this->RefreshScrollbar();
933 break;
934 }
935 }
936
937 int GetClickPosition(int click_x)
938 {
939 const NWidgetCore *matrix_widget = this->GetWidget<NWidgetCore>(WID_VR_VEHICLE_PANEL_DISPLAY);
940 if (_current_text_dir == TD_RTL) click_x = matrix_widget->current_x - click_x;
941 click_x -= this->vehicle_margin;
942 if (this->hscroll != nullptr) click_x += this->hscroll->GetPosition();
943
944 return click_x;
945 }
946
947 void SetSelectedVehicles(int drag_x)
948 {
949 drag_x = GetClickPosition(drag_x);
950
951 int left_x = std::min(this->click_x, drag_x);
952 int right_x = std::max(this->click_x, drag_x);
953 this->num_vehicles = 0;
954
955 Vehicle *v = Vehicle::Get(this->window_number);
956 /* Find the vehicle part that was clicked. */
957 switch (v->type) {
958 case VEH_TRAIN: {
959 /* Don't select anything if we are not clicking in the vehicle. */
960 if (left_x >= 0) {
961 const Train *u = Train::From(v);
962 bool start_counting = false;
963 for (; u != nullptr; u = u->Next()) {
964 int current_width = u->GetDisplayImageWidth();
965 left_x -= current_width;
966 right_x -= current_width;
967
968 if (left_x < 0 && !start_counting) {
969 this->selected_vehicle = u->index;
970 start_counting = true;
971
972 /* Count the first vehicle, even if articulated part */
973 this->num_vehicles++;
974 } else if (start_counting && !u->IsArticulatedPart()) {
975 /* Do not count articulated parts */
976 this->num_vehicles++;
977 }
978
979 if (right_x < 0) break;
980 }
981 }
982
983 /* If the selection is not correct, clear it. */
984 if (this->num_vehicles != 0) {
985 if (_ctrl_pressed) this->num_vehicles = UINT8_MAX;
986 break;
987 }
988 FALLTHROUGH;
989 }
990
991 default:
992 /* Clear the selection. */
993 this->selected_vehicle = v->index;
994 this->num_vehicles = UINT8_MAX;
995 break;
996 }
997 }
998
999 void OnClick(Point pt, int widget, int click_count) override
1000 {
1001 switch (widget) {
1002 case WID_VR_VEHICLE_PANEL_DISPLAY: { // Vehicle image.
1003 if (this->order != INVALID_VEH_ORDER_ID) break;
1004 NWidgetBase *nwi = this->GetWidget<NWidgetBase>(WID_VR_VEHICLE_PANEL_DISPLAY);
1005 this->click_x = GetClickPosition(pt.x - nwi->pos_x);
1006 this->SetSelectedVehicles(pt.x - nwi->pos_x);
1007 this->SetWidgetDirty(WID_VR_VEHICLE_PANEL_DISPLAY);
1008 if (!_ctrl_pressed) {
1009 SetObjectToPlaceWnd(SPR_CURSOR_MOUSE, PAL_NONE, HT_DRAG, this);
1010 } else {
1011 /* The vehicle selection has changed. */
1012 this->InvalidateData(2);
1013 }
1014 break;
1015 }
1016
1017 case WID_VR_MATRIX: { // listbox
1018 this->SetSelection(this->vscroll->GetScrolledRowFromWidget(pt.y, this, WID_VR_MATRIX));
1019 this->SetWidgetDisabledState(WID_VR_REFIT, this->sel[0] < 0);
1020 this->InvalidateData(1);
1021
1022 if (click_count == 1) break;
1023 FALLTHROUGH;
1024 }
1025
1026 case WID_VR_REFIT: // refit button
1027 if (this->cargo != nullptr) {
1028 const Vehicle *v = Vehicle::Get(this->window_number);
1029
1030 if (this->order == INVALID_VEH_ORDER_ID) {
1031 bool delete_window = this->selected_vehicle == v->index && this->num_vehicles == UINT8_MAX;
1032 if (DoCommandP(v->tile, this->selected_vehicle, this->cargo->cargo | this->cargo->subtype << 8 | this->num_vehicles << 16, GetCmdRefitVeh(v)) && delete_window) delete this;
1033 } else {
1034 if (DoCommandP(v->tile, v->index, this->cargo->cargo | this->order << 16, CMD_ORDER_REFIT)) delete this;
1035 }
1036 }
1037 break;
1038 }
1039 }
1040
1041 void OnMouseDrag(Point pt, int widget) override
1042 {
1043 switch (widget) {
1044 case WID_VR_VEHICLE_PANEL_DISPLAY: { // Vehicle image.
1045 if (this->order != INVALID_VEH_ORDER_ID) break;
1046 NWidgetBase *nwi = this->GetWidget<NWidgetBase>(WID_VR_VEHICLE_PANEL_DISPLAY);
1047 this->SetSelectedVehicles(pt.x - nwi->pos_x);
1048 this->SetWidgetDirty(WID_VR_VEHICLE_PANEL_DISPLAY);
1049 break;
1050 }
1051 }
1052 }
1053
1054 void OnDragDrop(Point pt, int widget) override
1055 {
1056 switch (widget) {
1057 case WID_VR_VEHICLE_PANEL_DISPLAY: { // Vehicle image.
1058 if (this->order != INVALID_VEH_ORDER_ID) break;
1059 NWidgetBase *nwi = this->GetWidget<NWidgetBase>(WID_VR_VEHICLE_PANEL_DISPLAY);
1060 this->SetSelectedVehicles(pt.x - nwi->pos_x);
1061 this->InvalidateData(2);
1062 break;
1063 }
1064 }
1065 }
1066
1067 void OnResize() override
1068 {
1069 this->vehicle_width = GetVehicleWidth(Vehicle::Get(this->window_number), EIT_IN_DETAILS);
1070 this->vscroll->SetCapacityFromWidget(this, WID_VR_MATRIX);
1071 if (this->hscroll != nullptr) this->hscroll->SetCapacityFromWidget(this, WID_VR_VEHICLE_PANEL_DISPLAY);
1072 }
1073 };
1074
1075 static const NWidgetPart _nested_vehicle_refit_widgets[] = {
1076 NWidget(NWID_HORIZONTAL),
1077 NWidget(WWT_CLOSEBOX, COLOUR_GREY),
1078 NWidget(WWT_CAPTION, COLOUR_GREY, WID_VR_CAPTION), SetDataTip(STR_REFIT_CAPTION, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
1079 NWidget(WWT_DEFSIZEBOX, COLOUR_GREY),
1080 EndContainer(),
1081 /* Vehicle display + scrollbar. */
1082 NWidget(NWID_VERTICAL),
1083 NWidget(WWT_PANEL, COLOUR_GREY, WID_VR_VEHICLE_PANEL_DISPLAY), SetMinimalSize(228, 14), SetResize(1, 0), SetScrollbar(WID_VR_HSCROLLBAR), EndContainer(),
1084 NWidget(NWID_SELECTION, INVALID_COLOUR, WID_VR_SHOW_HSCROLLBAR),
1085 NWidget(NWID_HSCROLLBAR, COLOUR_GREY, WID_VR_HSCROLLBAR),
1086 EndContainer(),
1087 EndContainer(),
1088 NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_VR_SELECT_HEADER), SetDataTip(STR_REFIT_TITLE, STR_NULL), SetResize(1, 0),
1089 /* Matrix + scrollbar. */
1090 NWidget(NWID_HORIZONTAL),
1091 NWidget(WWT_MATRIX, COLOUR_GREY, WID_VR_MATRIX), SetMinimalSize(228, 112), SetResize(1, 14), SetFill(1, 1), SetMatrixDataTip(1, 0, STR_NULL), SetScrollbar(WID_VR_SCROLLBAR),
1092 NWidget(NWID_VSCROLLBAR, COLOUR_GREY, WID_VR_SCROLLBAR),
1093 EndContainer(),
1094 NWidget(WWT_PANEL, COLOUR_GREY, WID_VR_INFO), SetMinimalTextLines(2, WD_FRAMERECT_TOP + WD_FRAMERECT_BOTTOM), SetResize(1, 0), EndContainer(),
1095 NWidget(NWID_HORIZONTAL),
1096 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_VR_REFIT), SetFill(1, 0), SetResize(1, 0),
1097 NWidget(WWT_RESIZEBOX, COLOUR_GREY),
1098 EndContainer(),
1099 };
1100
1101 static WindowDesc _vehicle_refit_desc(
1102 WDP_AUTO, "view_vehicle_refit", 240, 174,
1103 WC_VEHICLE_REFIT, WC_VEHICLE_VIEW,
1104 WDF_CONSTRUCTION,
1105 _nested_vehicle_refit_widgets, lengthof(_nested_vehicle_refit_widgets)
1106 );
1107
1115 void ShowVehicleRefitWindow(const Vehicle *v, VehicleOrderID order, Window *parent, bool auto_refit)
1116 {
1117 DeleteWindowById(WC_VEHICLE_REFIT, v->index);
1118 RefitWindow *w = new RefitWindow(&_vehicle_refit_desc, v, order, auto_refit);
1119 w->parent = parent;
1120 }
1121
1123 uint ShowRefitOptionsList(int left, int right, int y, EngineID engine)
1124 {
1125 /* List of cargo types of this engine */
1126 CargoTypes cmask = GetUnionOfArticulatedRefitMasks(engine, false);
1127 /* List of cargo types available in this climate */
1128 CargoTypes lmask = _cargo_mask;
1129
1130 /* Draw nothing if the engine is not refittable */
1131 if (HasAtMostOneBit(cmask)) return y;
1132
1133 if (cmask == lmask) {
1134 /* Engine can be refitted to all types in this climate */
1135 SetDParam(0, STR_PURCHASE_INFO_ALL_TYPES);
1136 } else {
1137 /* Check if we are able to refit to more cargo types and unable to. If
1138 * so, invert the cargo types to list those that we can't refit to. */
1139 if (CountBits(cmask ^ lmask) < CountBits(cmask) && CountBits(cmask ^ lmask) <= 7) {
1140 cmask ^= lmask;
1141 SetDParam(0, STR_PURCHASE_INFO_ALL_BUT);
1142 } else {
1143 SetDParam(0, STR_JUST_CARGO_LIST);
1144 }
1145 SetDParam(1, cmask);
1146 }
1147
1148 return DrawStringMultiLine(left, right, y, INT32_MAX, STR_PURCHASE_INFO_REFITTABLE_TO);
1149 }
1150
1152 StringID GetCargoSubtypeText(const Vehicle *v)
1153 {
1154 if (HasBit(EngInfo(v->engine_type)->callback_mask, CBM_VEHICLE_CARGO_SUFFIX)) {
1155 uint16 cb = GetVehicleCallback(CBID_VEHICLE_CARGO_SUFFIX, 0, 0, v->engine_type, v);
1156 if (cb != CALLBACK_FAILED) {
1157 if (cb > 0x400) ErrorUnknownCallbackResult(v->GetGRFID(), CBID_VEHICLE_CARGO_SUFFIX, cb);
1158 if (cb >= 0x400 || (v->GetGRF()->grf_version < 8 && cb == 0xFF)) cb = CALLBACK_FAILED;
1159 }
1160 if (cb != CALLBACK_FAILED) {
1161 return GetGRFStringID(v->GetGRFID(), 0xD000 + cb);
1162 }
1163 }
1164 return STR_EMPTY;
1165 }
1166
1168 static bool VehicleGroupLengthSorter(const GUIVehicleGroup &a, const GUIVehicleGroup &b)
1169 {
1170 return a.NumVehicles() < b.NumVehicles();
1171 }
1172
1174 static bool VehicleGroupTotalProfitThisYearSorter(const GUIVehicleGroup &a, const GUIVehicleGroup &b)
1175 {
1176 return a.GetDisplayProfitThisYear() < b.GetDisplayProfitThisYear();
1177 }
1178
1180 static bool VehicleGroupTotalProfitLastYearSorter(const GUIVehicleGroup &a, const GUIVehicleGroup &b)
1181 {
1182 return a.GetDisplayProfitLastYear() < b.GetDisplayProfitLastYear();
1183 }
1184
1186 static bool VehicleGroupAverageProfitThisYearSorter(const GUIVehicleGroup &a, const GUIVehicleGroup &b)
1187 {
1188 return a.GetDisplayProfitThisYear() * static_cast<uint>(b.NumVehicles()) < b.GetDisplayProfitThisYear() * static_cast<uint>(a.NumVehicles());
1189 }
1190
1192 static bool VehicleGroupAverageProfitLastYearSorter(const GUIVehicleGroup &a, const GUIVehicleGroup &b)
1193 {
1194 return a.GetDisplayProfitLastYear() * static_cast<uint>(b.NumVehicles()) < b.GetDisplayProfitLastYear() * static_cast<uint>(a.NumVehicles());
1195 }
1196
1198 static bool VehicleNumberSorter(const Vehicle * const &a, const Vehicle * const &b)
1199 {
1200 return a->unitnumber < b->unitnumber;
1201 }
1202
1204 static bool VehicleNameSorter(const Vehicle * const &a, const Vehicle * const &b)
1205 {
1206 static char last_name[2][64];
1207
1208 if (a != _last_vehicle[0]) {
1209 _last_vehicle[0] = a;
1210 SetDParam(0, a->index);
1211 GetString(last_name[0], STR_VEHICLE_NAME, lastof(last_name[0]));
1212 }
1213
1214 if (b != _last_vehicle[1]) {
1215 _last_vehicle[1] = b;
1216 SetDParam(0, b->index);
1217 GetString(last_name[1], STR_VEHICLE_NAME, lastof(last_name[1]));
1218 }
1219
1220 int r = strnatcmp(last_name[0], last_name[1]); // Sort by name (natural sorting).
1221 return (r != 0) ? r < 0: VehicleNumberSorter(a, b);
1222 }
1223
1225 static bool VehicleAgeSorter(const Vehicle * const &a, const Vehicle * const &b)
1226 {
1227 int r = a->age - b->age;
1228 return (r != 0) ? r < 0 : VehicleNumberSorter(a, b);
1229 }
1230
1232 static bool VehicleProfitThisYearSorter(const Vehicle * const &a, const Vehicle * const &b)
1233 {
1234 int r = ClampToI32(a->GetDisplayProfitThisYear() - b->GetDisplayProfitThisYear());
1235 return (r != 0) ? r < 0 : VehicleNumberSorter(a, b);
1236 }
1237
1239 static bool VehicleProfitLastYearSorter(const Vehicle * const &a, const Vehicle * const &b)
1240 {
1241 int r = ClampToI32(a->GetDisplayProfitLastYear() - b->GetDisplayProfitLastYear());
1242 return (r != 0) ? r < 0 : VehicleNumberSorter(a, b);
1243 }
1244
1246 static bool VehicleCargoSorter(const Vehicle * const &a, const Vehicle * const &b)
1247 {
1248 const Vehicle *v;
1249 CargoArray diff;
1250
1251 /* Append the cargo of the connected waggons */
1252 for (v = a; v != nullptr; v = v->Next()) diff[v->cargo_type] += v->cargo_cap;
1253 for (v = b; v != nullptr; v = v->Next()) diff[v->cargo_type] -= v->cargo_cap;
1254
1255 int r = 0;
1256 for (CargoID i = 0; i < NUM_CARGO; i++) {
1257 r = diff[i];
1258 if (r != 0) break;
1259 }
1260
1261 return (r != 0) ? r < 0 : VehicleNumberSorter(a, b);
1262 }
1263
1265 static bool VehicleReliabilitySorter(const Vehicle * const &a, const Vehicle * const &b)
1266 {
1267 int r = a->reliability - b->reliability;
1268 return (r != 0) ? r < 0 : VehicleNumberSorter(a, b);
1269 }
1270
1272 static bool VehicleMaxSpeedSorter(const Vehicle * const &a, const Vehicle * const &b)
1273 {
1274 int r = a->vcache.cached_max_speed - b->vcache.cached_max_speed;
1275 return (r != 0) ? r < 0 : VehicleNumberSorter(a, b);
1276 }
1277
1279 static bool VehicleModelSorter(const Vehicle * const &a, const Vehicle * const &b)
1280 {
1281 int r = a->engine_type - b->engine_type;
1282 return (r != 0) ? r < 0 : VehicleNumberSorter(a, b);
1283 }
1284
1286 static bool VehicleValueSorter(const Vehicle * const &a, const Vehicle * const &b)
1287 {
1288 const Vehicle *u;
1289 Money diff = 0;
1290
1291 for (u = a; u != nullptr; u = u->Next()) diff += u->value;
1292 for (u = b; u != nullptr; u = u->Next()) diff -= u->value;
1293
1294 int r = ClampToI32(diff);
1295 return (r != 0) ? r < 0 : VehicleNumberSorter(a, b);
1296 }
1297
1299 static bool VehicleLengthSorter(const Vehicle * const &a, const Vehicle * const &b)
1300 {
1301 int r = a->GetGroundVehicleCache()->cached_total_length - b->GetGroundVehicleCache()->cached_total_length;
1302 return (r != 0) ? r < 0 : VehicleNumberSorter(a, b);
1303 }
1304
1306 static bool VehicleTimeToLiveSorter(const Vehicle * const &a, const Vehicle * const &b)
1307 {
1308 int r = ClampToI32((a->max_age - a->age) - (b->max_age - b->age));
1309 return (r != 0) ? r < 0 : VehicleNumberSorter(a, b);
1310 }
1311
1313 static bool VehicleTimetableDelaySorter(const Vehicle * const &a, const Vehicle * const &b)
1314 {
1315 int r = a->lateness_counter - b->lateness_counter;
1316 return (r != 0) ? r < 0 : VehicleNumberSorter(a, b);
1317 }
1318
1319 void InitializeGUI()
1320 {
1321 MemSetT(&_grouping, 0);
1322 MemSetT(&_sorting, 0);
1323 }
1324
1331 static inline void ChangeVehicleWindow(WindowClass window_class, VehicleID from_index, VehicleID to_index)
1332 {
1333 Window *w = FindWindowById(window_class, from_index);
1334 if (w != nullptr) {
1335 /* Update window_number */
1336 w->window_number = to_index;
1337 if (w->viewport != nullptr) w->viewport->follow_vehicle = to_index;
1338
1339 /* Update vehicle drag data */
1340 if (_thd.window_class == window_class && _thd.window_number == (WindowNumber)from_index) {
1341 _thd.window_number = to_index;
1342 }
1343
1344 /* Notify the window. */
1345 w->InvalidateData(VIWD_AUTOREPLACE, false);
1346 }
1347 }
1348
1354 void ChangeVehicleViewWindow(VehicleID from_index, VehicleID to_index)
1355 {
1356 ChangeVehicleWindow(WC_VEHICLE_VIEW, from_index, to_index);
1357 ChangeVehicleWindow(WC_VEHICLE_ORDERS, from_index, to_index);
1358 ChangeVehicleWindow(WC_VEHICLE_REFIT, from_index, to_index);
1359 ChangeVehicleWindow(WC_VEHICLE_DETAILS, from_index, to_index);
1360 ChangeVehicleWindow(WC_VEHICLE_TIMETABLE, from_index, to_index);
1361 }
1362
1363 static const NWidgetPart _nested_vehicle_list[] = {
1364 NWidget(NWID_HORIZONTAL),
1365 NWidget(WWT_CLOSEBOX, COLOUR_GREY),
1366 NWidget(WWT_CAPTION, COLOUR_GREY, WID_VL_CAPTION),
1367 NWidget(WWT_SHADEBOX, COLOUR_GREY),
1368 NWidget(WWT_DEFSIZEBOX, COLOUR_GREY),
1369 NWidget(WWT_STICKYBOX, COLOUR_GREY),
1370 EndContainer(),
1371
1372 NWidget(NWID_HORIZONTAL),
1373 NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_VL_GROUP_ORDER), SetMinimalSize(81, 12), SetFill(0, 1), SetDataTip(STR_STATION_VIEW_GROUP, STR_TOOLTIP_GROUP_ORDER),
1374 NWidget(WWT_DROPDOWN, COLOUR_GREY, WID_VL_GROUP_BY_PULLDOWN), SetMinimalSize(167, 12), SetFill(0, 1), SetDataTip(0x0, STR_TOOLTIP_GROUP_ORDER),
1375 NWidget(WWT_PANEL, COLOUR_GREY), SetMinimalSize(12, 12), SetFill(1, 1), SetResize(1, 0), EndContainer(),
1376 EndContainer(),
1377
1378 NWidget(NWID_HORIZONTAL),
1379 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_VL_SORT_ORDER), SetMinimalSize(81, 12), SetFill(0, 1), SetDataTip(STR_BUTTON_SORT_BY, STR_TOOLTIP_SORT_ORDER),
1380 NWidget(WWT_DROPDOWN, COLOUR_GREY, WID_VL_SORT_BY_PULLDOWN), SetMinimalSize(167, 12), SetFill(0, 1), SetDataTip(0x0, STR_TOOLTIP_SORT_CRITERIA),
1381 NWidget(WWT_PANEL, COLOUR_GREY), SetMinimalSize(12, 12), SetFill(1, 1), SetResize(1, 0), EndContainer(),
1382 EndContainer(),
1383
1384 NWidget(NWID_HORIZONTAL),
1385 NWidget(WWT_MATRIX, COLOUR_GREY, WID_VL_LIST), SetMinimalSize(248, 0), SetFill(1, 0), SetResize(1, 1), SetMatrixDataTip(1, 0, STR_NULL), SetScrollbar(WID_VL_SCROLLBAR),
1386 NWidget(NWID_VSCROLLBAR, COLOUR_GREY, WID_VL_SCROLLBAR),
1387 EndContainer(),
1388
1389 NWidget(NWID_HORIZONTAL),
1390 NWidget(NWID_SELECTION, INVALID_COLOUR, WID_VL_HIDE_BUTTONS),
1391 NWidget(NWID_HORIZONTAL),
1392 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_VL_AVAILABLE_VEHICLES), SetMinimalSize(106, 12), SetFill(0, 1),
1393 SetDataTip(STR_BLACK_STRING, STR_VEHICLE_LIST_AVAILABLE_ENGINES_TOOLTIP),
1394 NWidget(WWT_PANEL, COLOUR_GREY), SetMinimalSize(0, 12), SetResize(1, 0), SetFill(1, 1), EndContainer(),
1395 NWidget(WWT_DROPDOWN, COLOUR_GREY, WID_VL_MANAGE_VEHICLES_DROPDOWN), SetMinimalSize(118, 12), SetFill(0, 1),
1396 SetDataTip(STR_VEHICLE_LIST_MANAGE_LIST, STR_VEHICLE_LIST_MANAGE_LIST_TOOLTIP),
1397 NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_VL_STOP_ALL), SetMinimalSize(12, 12), SetFill(0, 1),
1398 SetDataTip(SPR_FLAG_VEH_STOPPED, STR_VEHICLE_LIST_MASS_STOP_LIST_TOOLTIP),
1399 NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_VL_START_ALL), SetMinimalSize(12, 12), SetFill(0, 1),
1400 SetDataTip(SPR_FLAG_VEH_RUNNING, STR_VEHICLE_LIST_MASS_START_LIST_TOOLTIP),
1401 EndContainer(),
1402 /* Widget to be shown for other companies hiding the previous 5 widgets. */
1403 NWidget(WWT_PANEL, COLOUR_GREY), SetFill(1, 1), SetResize(1, 0), EndContainer(),
1404 EndContainer(),
1405 NWidget(WWT_RESIZEBOX, COLOUR_GREY),
1406 EndContainer(),
1407 };
1408
1409 static void DrawSmallOrderList(const Vehicle *v, int left, int right, int y, VehicleOrderID start = 0)
1410 {
1411 const Order *order = v->GetOrder(start);
1412 if (order == nullptr) return;
1413
1414 bool rtl = _current_text_dir == TD_RTL;
1415 int l_offset = rtl ? 0 : ScaleGUITrad(6);
1416 int r_offset = rtl ? ScaleGUITrad(6) : 0;
1417 int i = 0;
1418 VehicleOrderID oid = start;
1419
1420 do {
1421 if (oid == v->cur_real_order_index) DrawString(left, right, y, STR_TINY_RIGHT_ARROW, TC_BLACK);
1422
1423 if (order->IsType(OT_GOTO_STATION)) {
1424 SetDParam(0, order->GetDestination());
1425 DrawString(left + l_offset, right - r_offset, y, STR_TINY_BLACK_STATION);
1426
1427 y += FONT_HEIGHT_SMALL;
1428 if (++i == 4) break;
1429 }
1430
1431 oid++;
1432 order = order->next;
1433 if (order == nullptr) {
1434 order = v->orders.list->GetFirstOrder();
1435 oid = 0;
1436 }
1437 } while (oid != start);
1438 }
1439
1441 static void DrawSmallOrderList(const Order *order, int left, int right, int y)
1442 {
1443 bool rtl = _current_text_dir == TD_RTL;
1444 int l_offset = rtl ? 0 : ScaleGUITrad(6);
1445 int r_offset = rtl ? ScaleGUITrad(6) : 0;
1446 int i = 0;
1447 while (order != nullptr) {
1448 if (order->IsType(OT_GOTO_STATION)) {
1449 SetDParam(0, order->GetDestination());
1450 DrawString(left + l_offset, right - r_offset, y, STR_TINY_BLACK_STATION);
1451
1452 y += FONT_HEIGHT_SMALL;
1453 if (++i == 4) break;
1454 }
1455 order = order->next;
1456 }
1457 }
1458
1468 void DrawVehicleImage(const Vehicle *v, int left, int right, int y, VehicleID selection, EngineImageType image_type, int skip)
1469 {
1470 switch (v->type) {
1471 case VEH_TRAIN: DrawTrainImage(Train::From(v), left, right, y, selection, image_type, skip); break;
1472 case VEH_ROAD: DrawRoadVehImage(v, left, right, y, selection, image_type, skip); break;
1473 case VEH_SHIP: DrawShipImage(v, left, right, y, selection, image_type); break;
1474 case VEH_AIRCRAFT: DrawAircraftImage(v, left, right, y, selection, image_type); break;
1475 default: NOT_REACHED();
1476 }
1477 }
1478
1485 uint GetVehicleListHeight(VehicleType type, uint divisor)
1486 {
1487 /* Name + vehicle + profit */
1488 uint base = ScaleGUITrad(GetVehicleHeight(type)) + 2 * FONT_HEIGHT_SMALL;
1489 /* Drawing of the 4 small orders + profit*/
1490 if (type >= VEH_SHIP) base = std::max(base, 5U * FONT_HEIGHT_SMALL);
1491
1492 if (divisor == 1) return base;
1493
1494 /* Make sure the height is dividable by divisor */
1495 uint rem = base % divisor;
1496 return base + (rem == 0 ? 0 : divisor - rem);
1497 }
1498
1505 void BaseVehicleListWindow::DrawVehicleListItems(VehicleID selected_vehicle, int line_height, const Rect &r) const
1506 {
1507 int left = r.left + WD_MATRIX_LEFT;
1508 int right = r.right - WD_MATRIX_RIGHT;
1509 int width = right - left;
1510 bool rtl = _current_text_dir == TD_RTL;
1511
1512 int text_offset = std::max<int>(GetSpriteSize(SPR_PROFIT_LOT).width, GetDigitWidth() * this->unitnumber_digits) + WD_FRAMERECT_RIGHT;
1513 int text_left = left + (rtl ? 0 : text_offset);
1514 int text_right = right - (rtl ? text_offset : 0);
1515
1516 bool show_orderlist = this->vli.vtype >= VEH_SHIP;
1517 int orderlist_left = left + (rtl ? 0 : std::max(ScaleGUITrad(100) + text_offset, width / 2));
1518 int orderlist_right = right - (rtl ? std::max(ScaleGUITrad(100) + text_offset, width / 2) : 0);
1519
1520 int image_left = (rtl && show_orderlist) ? orderlist_right : text_left;
1521 int image_right = (!rtl && show_orderlist) ? orderlist_left : text_right;
1522
1523 int vehicle_button_x = rtl ? right - GetSpriteSize(SPR_PROFIT_LOT).width : left;
1524
1525 int y = r.top;
1526 uint max = static_cast<uint>(std::min<size_t>(this->vscroll->GetPosition() + this->vscroll->GetCapacity(), this->vehgroups.size()));
1527 for (uint i = this->vscroll->GetPosition(); i < max; ++i) {
1528
1529 const GUIVehicleGroup &vehgroup = this->vehgroups[i];
1530
1531 SetDParam(0, vehgroup.GetDisplayProfitThisYear());
1532 SetDParam(1, vehgroup.GetDisplayProfitLastYear());
1533 DrawString(text_left, text_right, y + line_height - FONT_HEIGHT_SMALL - WD_FRAMERECT_BOTTOM - 1, STR_VEHICLE_LIST_PROFIT_THIS_YEAR_LAST_YEAR);
1534
1535 DrawVehicleProfitButton(vehgroup.GetOldestVehicleAge(), vehgroup.GetDisplayProfitLastYear(), vehgroup.NumVehicles(), vehicle_button_x, y + FONT_HEIGHT_NORMAL + 3);
1536
1537 switch (this->grouping) {
1538 case GB_NONE: {
1539 const Vehicle *v = vehgroup.GetSingleVehicle();
1540
1541 DrawVehicleImage(v, image_left, image_right, y + FONT_HEIGHT_SMALL - 1, selected_vehicle, EIT_IN_LIST, 0);
1542
1543 if (!v->name.empty()) {
1544 /* The vehicle got a name so we will print it */
1545 SetDParam(0, v->index);
1546 DrawString(text_left, text_right, y, STR_TINY_BLACK_VEHICLE);
1547 } else if (v->group_id != DEFAULT_GROUP) {
1548 /* The vehicle has no name, but is member of a group, so print group name */
1549 SetDParam(0, v->group_id);
1550 DrawString(text_left, text_right, y, STR_TINY_GROUP, TC_BLACK);
1551 }
1552
1553 if (show_orderlist) DrawSmallOrderList(v, orderlist_left, orderlist_right, y, v->cur_real_order_index);
1554
1555 StringID str;
1556 if (v->IsChainInDepot()) {
1557 str = STR_BLUE_COMMA;
1558 } else {
1559 str = (v->age > v->max_age - DAYS_IN_LEAP_YEAR) ? STR_RED_COMMA : STR_BLACK_COMMA;
1560 }
1561
1562 SetDParam(0, v->unitnumber);
1563 DrawString(left, right, y + 2, str);
1564 break;
1565 }
1566
1567 case GB_SHARED_ORDERS:
1568 assert(vehgroup.NumVehicles() > 0);
1569
1570 for (int i = 0; i < static_cast<int>(vehgroup.NumVehicles()); ++i) {
1571 if (image_left + 8 * i >= image_right) break; // Break if there is no more space to draw any more vehicles anyway.
1572 DrawVehicleImage(vehgroup.vehicles_begin[i], image_left + 8 * i, image_right, y + FONT_HEIGHT_SMALL - 1, selected_vehicle, EIT_IN_LIST, 0);
1573 }
1574
1575 if (show_orderlist) DrawSmallOrderList((vehgroup.vehicles_begin[0])->GetFirstOrder(), orderlist_left, orderlist_right, y);
1576
1577 SetDParam(0, vehgroup.NumVehicles());
1578 DrawString(left, right, y + 2, STR_BLACK_COMMA);
1579 break;
1580
1581 default:
1582 NOT_REACHED();
1583 }
1584
1585 y += line_height;
1586 }
1587 }
1588
1589 void BaseVehicleListWindow::UpdateSortingFromGrouping()
1590 {
1591 /* Set up sorting. Make the window-specific _sorting variable
1592 * point to the correct global _sorting struct so we are freed
1593 * from having conditionals during window operation */
1594 switch (this->vli.vtype) {
1595 case VEH_TRAIN: this->sorting = &_sorting[this->grouping].train; break;
1596 case VEH_ROAD: this->sorting = &_sorting[this->grouping].roadveh; break;
1597 case VEH_SHIP: this->sorting = &_sorting[this->grouping].ship; break;
1598 case VEH_AIRCRAFT: this->sorting = &_sorting[this->grouping].aircraft; break;
1599 default: NOT_REACHED();
1600 }
1601 this->vehgroups.SetSortFuncs(this->GetVehicleSorterFuncs());
1602 this->vehgroups.SetListing(*this->sorting);
1603 this->vehgroups.ForceRebuild();
1604 this->vehgroups.NeedResort();
1605 }
1606
1607 void BaseVehicleListWindow::UpdateVehicleGroupBy(GroupBy group_by)
1608 {
1609 if (this->grouping != group_by) {
1610 /* Save the old sorting option, so that if we change the grouping option back later on,
1611 * UpdateSortingFromGrouping() will automatically restore the saved sorting option. */
1612 *this->sorting = this->vehgroups.GetListing();
1613
1614 this->grouping = group_by;
1615 _grouping[this->vli.type][this->vli.vtype] = group_by;
1616 this->UpdateSortingFromGrouping();
1617 }
1618 }
1619
1629 struct VehicleListWindow : public BaseVehicleListWindow {
1630 private:
1632 enum ButtonPlanes {
1633 BP_SHOW_BUTTONS,
1634 BP_HIDE_BUTTONS,
1635 };
1636
1637 public:
1638 VehicleListWindow(WindowDesc *desc, WindowNumber window_number) : BaseVehicleListWindow(desc, window_number)
1639 {
1640 this->CreateNestedTree();
1641
1642 this->vscroll = this->GetScrollbar(WID_VL_SCROLLBAR);
1643
1644 this->BuildVehicleList();
1645 this->SortVehicleList();
1646
1647 /* Set up the window widgets */
1648 this->GetWidget<NWidgetCore>(WID_VL_LIST)->tool_tip = STR_VEHICLE_LIST_TRAIN_LIST_TOOLTIP + this->vli.vtype;
1649
1650 if (this->vli.type == VL_SHARED_ORDERS) {
1651 this->GetWidget<NWidgetCore>(WID_VL_CAPTION)->widget_data = STR_VEHICLE_LIST_SHARED_ORDERS_LIST_CAPTION;
1652 /* If we are in the shared orders window, then disable the group-by dropdown menu.
1653 * Remove this when the group-by dropdown menu has another option apart from grouping by shared orders. */
1654 this->SetWidgetDisabledState(WID_VL_GROUP_ORDER, true);
1655 this->SetWidgetDisabledState(WID_VL_GROUP_BY_PULLDOWN, true);
1656 } else {
1657 this->GetWidget<NWidgetCore>(WID_VL_CAPTION)->widget_data = STR_VEHICLE_LIST_TRAIN_CAPTION + this->vli.vtype;
1658 }
1659
1660 this->FinishInitNested(window_number);
1661 if (this->vli.company != OWNER_NONE) this->owner = this->vli.company;
1662 }
1663
1664 ~VehicleListWindow()
1665 {
1666 *this->sorting = this->vehgroups.GetListing();
1667 }
1668
1669 void UpdateWidgetSize(int widget, Dimension *size, const Dimension &padding, Dimension *fill, Dimension *resize) override
1670 {
1671 switch (widget) {
1672 case WID_VL_LIST:
1673 resize->height = GetVehicleListHeight(this->vli.vtype, 1);
1674
1675 switch (this->vli.vtype) {
1676 case VEH_TRAIN:
1677 case VEH_ROAD:
1678 size->height = 6 * resize->height;
1679 break;
1680 case VEH_SHIP:
1681 case VEH_AIRCRAFT:
1682 size->height = 4 * resize->height;
1683 break;
1684 default: NOT_REACHED();
1685 }
1686 break;
1687
1688 case WID_VL_SORT_ORDER: {
1689 Dimension d = GetStringBoundingBox(this->GetWidget<NWidgetCore>(widget)->widget_data);
1690 d.width += padding.width + Window::SortButtonWidth() * 2; // Doubled since the string is centred and it also looks better.
1691 d.height += padding.height;
1692 *size = maxdim(*size, d);
1693 break;
1694 }
1695
1696 case WID_VL_MANAGE_VEHICLES_DROPDOWN: {
1697 Dimension d = this->GetActionDropdownSize(this->vli.type == VL_STANDARD, false);
1698 d.height += padding.height;
1699 d.width += padding.width;
1700 *size = maxdim(*size, d);
1701 break;
1702 }
1703 }
1704 }
1705
1706 void SetStringParameters(int widget) const override
1707 {
1708 switch (widget) {
1709 case WID_VL_AVAILABLE_VEHICLES:
1710 SetDParam(0, STR_VEHICLE_LIST_AVAILABLE_TRAINS + this->vli.vtype);
1711 break;
1712
1713 case WID_VL_CAPTION: {
1714 switch (this->vli.type) {
1715 case VL_SHARED_ORDERS: // Shared Orders
1716 if (this->vehicles.size() == 0) {
1717 /* We can't open this window without vehicles using this order
1718 * and we should close the window when deleting the order. */
1719 NOT_REACHED();
1720 }
1721 SetDParam(0, this->vehicles.size());
1722 break;
1723
1724 case VL_STANDARD: // Company Name
1725 SetDParam(0, STR_COMPANY_NAME);
1726 SetDParam(1, this->vli.index);
1727 SetDParam(3, this->vehicles.size());
1728 break;
1729
1730 case VL_STATION_LIST: // Station/Waypoint Name
1731 SetDParam(0, Station::IsExpected(BaseStation::Get(this->vli.index)) ? STR_STATION_NAME : STR_WAYPOINT_NAME);
1732 SetDParam(1, this->vli.index);
1733 SetDParam(3, this->vehicles.size());
1734 break;
1735
1736 case VL_DEPOT_LIST:
1737 SetDParam(0, STR_DEPOT_CAPTION);
1738 SetDParam(1, this->vli.vtype);
1739 SetDParam(2, this->vli.index);
1740 SetDParam(3, this->vehicles.size());
1741 break;
1742 default: NOT_REACHED();
1743 }
1744 break;
1745 }
1746 }
1747 }
1748
1749 void DrawWidget(const Rect &r, int widget) const override
1750 {
1751 switch (widget) {
1752 case WID_VL_SORT_ORDER:
1753 /* draw arrow pointing up/down for ascending/descending sorting */
1754 this->DrawSortButtonState(widget, this->vehgroups.IsDescSortOrder() ? SBS_DOWN : SBS_UP);
1755 break;
1756
1757 case WID_VL_LIST:
1758 this->DrawVehicleListItems(INVALID_VEHICLE, this->resize.step_height, r);
1759 break;
1760 }
1761 }
1762
1763 void OnPaint() override
1764 {
1765 this->BuildVehicleList();
1766 this->SortVehicleList();
1767
1768 if (this->vehicles.size() == 0 && this->IsWidgetLowered(WID_VL_MANAGE_VEHICLES_DROPDOWN)) {
1769 HideDropDownMenu(this);
1770 }
1771
1772 /* Hide the widgets that we will not use in this window
1773 * Some windows contains actions only fit for the owner */
1774 int plane_to_show = (this->owner == _local_company) ? BP_SHOW_BUTTONS : BP_HIDE_BUTTONS;
1775 NWidgetStacked *nwi = this->GetWidget<NWidgetStacked>(WID_VL_HIDE_BUTTONS);
1776 if (plane_to_show != nwi->shown_plane) {
1777 nwi->SetDisplayedPlane(plane_to_show);
1778 nwi->SetDirty(this);
1779 }
1780 if (this->owner == _local_company) {
1781 this->SetWidgetDisabledState(WID_VL_AVAILABLE_VEHICLES, this->vli.type != VL_STANDARD);
1782 this->SetWidgetsDisabledState(this->vehicles.size() == 0,
1783 WID_VL_MANAGE_VEHICLES_DROPDOWN,
1784 WID_VL_STOP_ALL,
1785 WID_VL_START_ALL,
1786 WIDGET_LIST_END);
1787 }
1788
1789 /* Set text of group by dropdown widget. */
1790 this->GetWidget<NWidgetCore>(WID_VL_GROUP_BY_PULLDOWN)->widget_data = this->vehicle_group_by_names[this->grouping];
1791
1792 /* Set text of sort by dropdown widget. */
1793 this->GetWidget<NWidgetCore>(WID_VL_SORT_BY_PULLDOWN)->widget_data = this->GetVehicleSorterNames()[this->vehgroups.SortType()];
1794
1795 this->DrawWidgets();
1796 }
1797
1798 void OnClick(Point pt, int widget, int click_count) override
1799 {
1800 switch (widget) {
1801 case WID_VL_SORT_ORDER: // Flip sorting method ascending/descending
1802 this->vehgroups.ToggleSortOrder();
1803 this->SetDirty();
1804 break;
1805
1806 case WID_VL_GROUP_BY_PULLDOWN: // Select sorting criteria dropdown menu
1807 ShowDropDownMenu(this, this->vehicle_group_by_names, this->grouping, WID_VL_GROUP_BY_PULLDOWN, 0, 0);
1808 return;
1809
1810 case WID_VL_SORT_BY_PULLDOWN: // Select sorting criteria dropdown menu
1811 ShowDropDownMenu(this, this->GetVehicleSorterNames(), this->vehgroups.SortType(), WID_VL_SORT_BY_PULLDOWN, 0,
1812 (this->vli.vtype == VEH_TRAIN || this->vli.vtype == VEH_ROAD) ? 0 : (1 << 10));
1813 return;
1814
1815 case WID_VL_LIST: { // Matrix to show vehicles
1816 uint id_v = this->vscroll->GetScrolledRowFromWidget(pt.y, this, WID_VL_LIST);
1817 if (id_v >= this->vehgroups.size()) return; // click out of list bound
1818
1819 const GUIVehicleGroup &vehgroup = this->vehgroups[id_v];
1820 switch (this->grouping) {
1821 case GB_NONE: {
1822 const Vehicle *v = vehgroup.GetSingleVehicle();
1823 if (!VehicleClicked(v)) {
1824 if (_ctrl_pressed) {
1825 ShowCompanyGroupForVehicle(v);
1826 } else {
1827 ShowVehicleViewWindow(v);
1828 }
1829 }
1830 break;
1831 }
1832
1833 case GB_SHARED_ORDERS:
1834 assert(vehgroup.NumVehicles() > 0);
1835 /* We do not support VehicleClicked() here since the contextual action may only make sense for individual vehicles */
1836
1837 ShowVehicleListWindow(vehgroup.vehicles_begin[0]);
1838 break;
1839
1840 default: NOT_REACHED();
1841 }
1842
1843 break;
1844 }
1845
1846 case WID_VL_AVAILABLE_VEHICLES:
1847 ShowBuildVehicleWindow(INVALID_TILE, this->vli.vtype);
1848 break;
1849
1850 case WID_VL_MANAGE_VEHICLES_DROPDOWN: {
1851 ShowDropDownList(this, this->BuildActionDropdownList(VehicleListIdentifier::UnPack(this->window_number).type == VL_STANDARD, false), 0, WID_VL_MANAGE_VEHICLES_DROPDOWN);
1852 break;
1853 }
1854
1855 case WID_VL_STOP_ALL:
1856 case WID_VL_START_ALL:
1857 DoCommandP(0, (1 << 1) | (widget == WID_VL_START_ALL ? (1 << 0) : 0), this->window_number, CMD_MASS_START_STOP);
1858 break;
1859 }
1860 }
1861
1862 void OnDropdownSelect(int widget, int index) override
1863 {
1864 switch (widget) {
1865 case WID_VL_GROUP_BY_PULLDOWN:
1866 this->UpdateVehicleGroupBy(static_cast<GroupBy>(index));
1867 break;
1868
1869 case WID_VL_SORT_BY_PULLDOWN:
1870 this->vehgroups.SetSortType(index);
1871 break;
1872
1873 case WID_VL_MANAGE_VEHICLES_DROPDOWN:
1874 assert(this->vehicles.size() != 0);
1875
1876 switch (index) {
1877 case ADI_REPLACE: // Replace window
1878 ShowReplaceGroupVehicleWindow(ALL_GROUP, this->vli.vtype);
1879 break;
1880 case ADI_SERVICE: // Send for servicing
1881 case ADI_DEPOT: // Send to Depots
1882 DoCommandP(0, DEPOT_MASS_SEND | (index == ADI_SERVICE ? DEPOT_SERVICE : (DepotCommand)0), this->window_number, GetCmdSendToDepot(this->vli.vtype));
1883 break;
1884
1885 default: NOT_REACHED();
1886 }
1887 break;
1888
1889 default: NOT_REACHED();
1890 }
1891 this->SetDirty();
1892 }
1893
1894 void OnGameTick() override
1895 {
1896 if (this->vehgroups.NeedResort()) {
1897 StationID station = (this->vli.type == VL_STATION_LIST) ? this->vli.index : INVALID_STATION;
1898
1899 DEBUG(misc, 3, "Periodic resort %d list company %d at station %d", this->vli.vtype, this->owner, station);
1900 this->SetDirty();
1901 }
1902 }
1903
1904 void OnResize() override
1905 {
1906 this->vscroll->SetCapacityFromWidget(this, WID_VL_LIST);
1907 }
1908
1914 void OnInvalidateData(int data = 0, bool gui_scope = true) override
1915 {
1916 if (!gui_scope && HasBit(data, 31) && this->vli.type == VL_SHARED_ORDERS) {
1917 /* Needs to be done in command-scope, so everything stays valid */
1918 this->vli.index = GB(data, 0, 20);
1919 this->window_number = this->vli.Pack();
1920 this->vehgroups.ForceRebuild();
1921 return;
1922 }
1923
1924 if (data == 0) {
1925 /* This needs to be done in command-scope to enforce rebuilding before resorting invalid data */
1926 this->vehgroups.ForceRebuild();
1927 } else {
1928 this->vehgroups.ForceResort();
1929 }
1930 }
1931 };
1932
1933 static WindowDesc _vehicle_list_other_desc(
1934 WDP_AUTO, "list_vehicles", 260, 246,
1935 WC_INVALID, WC_NONE,
1936 0,
1937 _nested_vehicle_list, lengthof(_nested_vehicle_list)
1938 );
1939
1940 static WindowDesc _vehicle_list_train_desc(
1941 WDP_AUTO, "list_vehicles_train", 325, 246,
1942 WC_TRAINS_LIST, WC_NONE,
1943 0,
1944 _nested_vehicle_list, lengthof(_nested_vehicle_list)
1945 );
1946
1947 static void ShowVehicleListWindowLocal(CompanyID company, VehicleListType vlt, VehicleType vehicle_type, uint32 unique_number)
1948 {
1949 if (!Company::IsValidID(company) && company != OWNER_NONE) return;
1950
1951 WindowNumber num = VehicleListIdentifier(vlt, vehicle_type, company, unique_number).Pack();
1952 if (vehicle_type == VEH_TRAIN) {
1953 AllocateWindowDescFront<VehicleListWindow>(&_vehicle_list_train_desc, num);
1954 } else {
1955 _vehicle_list_other_desc.cls = GetWindowClassForVehicleType(vehicle_type);
1956 AllocateWindowDescFront<VehicleListWindow>(&_vehicle_list_other_desc, num);
1957 }
1958 }
1959
1960 void ShowVehicleListWindow(CompanyID company, VehicleType vehicle_type)
1961 {
1962 /* If _settings_client.gui.advanced_vehicle_list > 1, display the Advanced list
1963 * if _settings_client.gui.advanced_vehicle_list == 1, display Advanced list only for local company
1964 * if _ctrl_pressed, do the opposite action (Advanced list x Normal list)
1965 */
1966
1967 if ((_settings_client.gui.advanced_vehicle_list > (uint)(company != _local_company)) != _ctrl_pressed) {
1968 ShowCompanyGroup(company, vehicle_type);
1969 } else {
1970 ShowVehicleListWindowLocal(company, VL_STANDARD, vehicle_type, company);
1971 }
1972 }
1973
1974 void ShowVehicleListWindow(const Vehicle *v)
1975 {
1976 ShowVehicleListWindowLocal(v->owner, VL_SHARED_ORDERS, v->type, v->FirstShared()->index);
1977 }
1978
1979 void ShowVehicleListWindow(CompanyID company, VehicleType vehicle_type, StationID station)
1980 {
1981 ShowVehicleListWindowLocal(company, VL_STATION_LIST, vehicle_type, station);
1982 }
1983
1984 void ShowVehicleListWindow(CompanyID company, VehicleType vehicle_type, TileIndex depot_tile)
1985 {
1986 uint16 depot_airport_index;
1987
1988 if (vehicle_type == VEH_AIRCRAFT) {
1989 depot_airport_index = GetStationIndex(depot_tile);
1990 } else {
1991 depot_airport_index = GetDepotIndex(depot_tile);
1992 }
1993 ShowVehicleListWindowLocal(company, VL_DEPOT_LIST, vehicle_type, depot_airport_index);
1994 }
1995
1996
1997 /* Unified vehicle GUI - Vehicle Details Window */
1998
1999 static_assert(WID_VD_DETAILS_CARGO_CARRIED == WID_VD_DETAILS_CARGO_CARRIED + TDW_TAB_CARGO );
2000 static_assert(WID_VD_DETAILS_TRAIN_VEHICLES == WID_VD_DETAILS_CARGO_CARRIED + TDW_TAB_INFO );
2001 static_assert(WID_VD_DETAILS_CAPACITY_OF_EACH == WID_VD_DETAILS_CARGO_CARRIED + TDW_TAB_CAPACITY);
2002 static_assert(WID_VD_DETAILS_TOTAL_CARGO == WID_VD_DETAILS_CARGO_CARRIED + TDW_TAB_TOTALS );
2003
2005 static const NWidgetPart _nested_nontrain_vehicle_details_widgets[] = {
2006 NWidget(NWID_HORIZONTAL),
2007 NWidget(WWT_CLOSEBOX, COLOUR_GREY),
2008 NWidget(WWT_CAPTION, COLOUR_GREY, WID_VD_CAPTION), SetDataTip(STR_VEHICLE_DETAILS_CAPTION, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
2009 NWidget(WWT_SHADEBOX, COLOUR_GREY),
2010 NWidget(WWT_DEFSIZEBOX, COLOUR_GREY),
2011 NWidget(WWT_STICKYBOX, COLOUR_GREY),
2012 EndContainer(),
2013 NWidget(WWT_PANEL, COLOUR_GREY, WID_VD_TOP_DETAILS), SetMinimalSize(405, 42), SetResize(1, 0), EndContainer(),
2014 NWidget(WWT_PANEL, COLOUR_GREY, WID_VD_MIDDLE_DETAILS), SetMinimalSize(405, 45), SetResize(1, 0), EndContainer(),
2015 NWidget(NWID_HORIZONTAL),
2016 NWidget(WWT_PUSHARROWBTN, COLOUR_GREY, WID_VD_DECREASE_SERVICING_INTERVAL), SetFill(0, 1),
2017 SetDataTip(AWV_DECREASE, STR_VEHICLE_DETAILS_DECREASE_SERVICING_INTERVAL_TOOLTIP),
2018 NWidget(WWT_PUSHARROWBTN, COLOUR_GREY, WID_VD_INCREASE_SERVICING_INTERVAL), SetFill(0, 1),
2019 SetDataTip(AWV_INCREASE, STR_VEHICLE_DETAILS_INCREASE_SERVICING_INTERVAL_TOOLTIP),
2020 NWidget(WWT_DROPDOWN, COLOUR_GREY, WID_VD_SERVICE_INTERVAL_DROPDOWN), SetFill(0, 1),
2021 SetDataTip(STR_EMPTY, STR_SERVICE_INTERVAL_DROPDOWN_TOOLTIP),
2022 NWidget(WWT_PANEL, COLOUR_GREY, WID_VD_SERVICING_INTERVAL), SetFill(1, 1), SetResize(1, 0), EndContainer(),
2023 NWidget(WWT_RESIZEBOX, COLOUR_GREY),
2024 EndContainer(),
2025 };
2026
2028 static const NWidgetPart _nested_train_vehicle_details_widgets[] = {
2029 NWidget(NWID_HORIZONTAL),
2030 NWidget(WWT_CLOSEBOX, COLOUR_GREY),
2031 NWidget(WWT_CAPTION, COLOUR_GREY, WID_VD_CAPTION), SetDataTip(STR_VEHICLE_DETAILS_CAPTION, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
2032 NWidget(WWT_SHADEBOX, COLOUR_GREY),
2033 NWidget(WWT_DEFSIZEBOX, COLOUR_GREY),
2034 NWidget(WWT_STICKYBOX, COLOUR_GREY),
2035 EndContainer(),
2036 NWidget(WWT_PANEL, COLOUR_GREY, WID_VD_TOP_DETAILS), SetResize(1, 0), SetMinimalSize(405, 42), EndContainer(),
2037 NWidget(NWID_HORIZONTAL),
2038 NWidget(WWT_MATRIX, COLOUR_GREY, WID_VD_MATRIX), SetResize(1, 1), SetMinimalSize(393, 45), SetMatrixDataTip(1, 0, STR_NULL), SetFill(1, 0), SetScrollbar(WID_VD_SCROLLBAR),
2039 NWidget(NWID_VSCROLLBAR, COLOUR_GREY, WID_VD_SCROLLBAR),
2040 EndContainer(),
2041 NWidget(NWID_HORIZONTAL),
2042 NWidget(WWT_PUSHARROWBTN, COLOUR_GREY, WID_VD_DECREASE_SERVICING_INTERVAL), SetFill(0, 1),
2043 SetDataTip(AWV_DECREASE, STR_VEHICLE_DETAILS_DECREASE_SERVICING_INTERVAL_TOOLTIP),
2044 NWidget(WWT_PUSHARROWBTN, COLOUR_GREY, WID_VD_INCREASE_SERVICING_INTERVAL), SetFill(0, 1),
2045 SetDataTip(AWV_INCREASE, STR_VEHICLE_DETAILS_INCREASE_SERVICING_INTERVAL_TOOLTIP),
2046 NWidget(WWT_DROPDOWN, COLOUR_GREY, WID_VD_SERVICE_INTERVAL_DROPDOWN), SetFill(0, 1),
2047 SetDataTip(STR_EMPTY, STR_SERVICE_INTERVAL_DROPDOWN_TOOLTIP),
2048 NWidget(WWT_PANEL, COLOUR_GREY, WID_VD_SERVICING_INTERVAL), SetFill(1, 1), SetResize(1, 0), EndContainer(),
2049 EndContainer(),
2050 NWidget(NWID_HORIZONTAL),
2051 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_VD_DETAILS_CARGO_CARRIED), SetMinimalSize(96, 12),
2052 SetDataTip(STR_VEHICLE_DETAIL_TAB_CARGO, STR_VEHICLE_DETAILS_TRAIN_CARGO_TOOLTIP), SetFill(1, 0), SetResize(1, 0),
2053 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_VD_DETAILS_TRAIN_VEHICLES), SetMinimalSize(99, 12),
2054 SetDataTip(STR_VEHICLE_DETAIL_TAB_INFORMATION, STR_VEHICLE_DETAILS_TRAIN_INFORMATION_TOOLTIP), SetFill(1, 0), SetResize(1, 0),
2055 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_VD_DETAILS_CAPACITY_OF_EACH), SetMinimalSize(99, 12),
2056 SetDataTip(STR_VEHICLE_DETAIL_TAB_CAPACITIES, STR_VEHICLE_DETAILS_TRAIN_CAPACITIES_TOOLTIP), SetFill(1, 0), SetResize(1, 0),
2057 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_VD_DETAILS_TOTAL_CARGO), SetMinimalSize(99, 12),
2058 SetDataTip(STR_VEHICLE_DETAIL_TAB_TOTAL_CARGO, STR_VEHICLE_DETAILS_TRAIN_TOTAL_CARGO_TOOLTIP), SetFill(1, 0), SetResize(1, 0),
2059 NWidget(WWT_RESIZEBOX, COLOUR_GREY),
2060 EndContainer(),
2061 };
2062
2063
2064 extern int GetTrainDetailsWndVScroll(VehicleID veh_id, TrainDetailsWindowTabs det_tab);
2065 extern void DrawTrainDetails(const Train *v, int left, int right, int y, int vscroll_pos, uint16 vscroll_cap, TrainDetailsWindowTabs det_tab);
2066 extern void DrawRoadVehDetails(const Vehicle *v, int left, int right, int y);
2067 extern void DrawShipDetails(const Vehicle *v, int left, int right, int y);
2068 extern void DrawAircraftDetails(const Aircraft *v, int left, int right, int y);
2069
2070 static StringID _service_interval_dropdown[] = {
2071 STR_VEHICLE_DETAILS_DEFAULT,
2072 STR_VEHICLE_DETAILS_DAYS,
2073 STR_VEHICLE_DETAILS_PERCENT,
2074 INVALID_STRING_ID,
2075 };
2076
2078 struct VehicleDetailsWindow : Window {
2079 TrainDetailsWindowTabs tab;
2080 Scrollbar *vscroll;
2081
2083 VehicleDetailsWindow(WindowDesc *desc, WindowNumber window_number) : Window(desc)
2084 {
2085 const Vehicle *v = Vehicle::Get(window_number);
2086
2087 this->CreateNestedTree();
2088 this->vscroll = (v->type == VEH_TRAIN ? this->GetScrollbar(WID_VD_SCROLLBAR) : nullptr);
2089 this->FinishInitNested(window_number);
2090
2091 this->owner = v->owner;
2092 this->tab = TDW_TAB_CARGO;
2093 }
2094
2100 void OnInvalidateData(int data = 0, bool gui_scope = true) override
2101 {
2102 if (data == VIWD_AUTOREPLACE) {
2103 /* Autoreplace replaced the vehicle.
2104 * Nothing to do for this window. */
2105 return;
2106 }
2107 if (!gui_scope) return;
2108 const Vehicle *v = Vehicle::Get(this->window_number);
2109 if (v->type == VEH_ROAD) {
2110 const NWidgetBase *nwid_info = this->GetWidget<NWidgetBase>(WID_VD_MIDDLE_DETAILS);
2111 uint aimed_height = this->GetRoadVehDetailsHeight(v);
2112 /* If the number of articulated parts changes, the size of the window must change too. */
2113 if (aimed_height != nwid_info->current_y) {
2114 this->ReInit();
2115 }
2116 }
2117 }
2118
2124 uint GetRoadVehDetailsHeight(const Vehicle *v)
2125 {
2126 uint desired_height;
2127 if (v->HasArticulatedPart()) {
2128 /* An articulated RV has its text drawn under the sprite instead of after it, hence 15 pixels extra. */
2129 desired_height = WD_FRAMERECT_TOP + ScaleGUITrad(15) + 3 * FONT_HEIGHT_NORMAL + 2 + WD_FRAMERECT_BOTTOM;
2130 /* Add space for the cargo amount for each part. */
2131 for (const Vehicle *u = v; u != nullptr; u = u->Next()) {
2132 if (u->cargo_cap != 0) desired_height += FONT_HEIGHT_NORMAL + 1;
2133 }
2134 } else {
2135 desired_height = WD_FRAMERECT_TOP + 4 * FONT_HEIGHT_NORMAL + 3 + WD_FRAMERECT_BOTTOM;
2136 }
2137 return desired_height;
2138 }
2139
2140 void UpdateWidgetSize(int widget, Dimension *size, const Dimension &padding, Dimension *fill, Dimension *resize) override
2141 {
2142 switch (widget) {
2143 case WID_VD_TOP_DETAILS: {
2144 Dimension dim = { 0, 0 };
2145 size->height = WD_FRAMERECT_TOP + 4 * FONT_HEIGHT_NORMAL + WD_FRAMERECT_BOTTOM;
2146
2147 for (uint i = 0; i < 4; i++) SetDParamMaxValue(i, INT16_MAX);
2148 static const StringID info_strings[] = {
2149 STR_VEHICLE_INFO_MAX_SPEED,
2150 STR_VEHICLE_INFO_WEIGHT_POWER_MAX_SPEED,
2151 STR_VEHICLE_INFO_WEIGHT_POWER_MAX_SPEED_MAX_TE,
2152 STR_VEHICLE_INFO_PROFIT_THIS_YEAR_LAST_YEAR,
2153 STR_VEHICLE_INFO_RELIABILITY_BREAKDOWNS
2154 };
2155 for (uint i = 0; i < lengthof(info_strings); i++) {
2156 dim = maxdim(dim, GetStringBoundingBox(info_strings[i]));
2157 }
2158 SetDParam(0, STR_VEHICLE_INFO_AGE);
2159 dim = maxdim(dim, GetStringBoundingBox(STR_VEHICLE_INFO_AGE_RUNNING_COST_YR));
2160 size->width = dim.width + WD_FRAMERECT_LEFT + WD_FRAMERECT_RIGHT;
2161 break;
2162 }
2163
2164 case WID_VD_MIDDLE_DETAILS: {
2165 const Vehicle *v = Vehicle::Get(this->window_number);
2166 switch (v->type) {
2167 case VEH_ROAD:
2168 size->height = this->GetRoadVehDetailsHeight(v);
2169 break;
2170
2171 case VEH_SHIP:
2172 size->height = WD_FRAMERECT_TOP + 4 * FONT_HEIGHT_NORMAL + 3 + WD_FRAMERECT_BOTTOM;
2173 break;
2174
2175 case VEH_AIRCRAFT:
2176 size->height = WD_FRAMERECT_TOP + 5 * FONT_HEIGHT_NORMAL + 4 + WD_FRAMERECT_BOTTOM;
2177 break;
2178
2179 default:
2180 NOT_REACHED(); // Train uses WID_VD_MATRIX instead.
2181 }
2182 break;
2183 }
2184
2185 case WID_VD_MATRIX:
2186 resize->height = std::max(ScaleGUITrad(14), WD_MATRIX_TOP + FONT_HEIGHT_NORMAL + WD_MATRIX_BOTTOM);
2187 size->height = 4 * resize->height;
2188 break;
2189
2190 case WID_VD_SERVICE_INTERVAL_DROPDOWN: {
2191 StringID *strs = _service_interval_dropdown;
2192 while (*strs != INVALID_STRING_ID) {
2193 *size = maxdim(*size, GetStringBoundingBox(*strs++));
2194 }
2195 size->width += padding.width;
2196 size->height = FONT_HEIGHT_NORMAL + WD_DROPDOWNTEXT_TOP + WD_DROPDOWNTEXT_BOTTOM;
2197 break;
2198 }
2199
2200 case WID_VD_SERVICING_INTERVAL:
2201 SetDParamMaxValue(0, MAX_SERVINT_DAYS); // Roughly the maximum interval
2202 SetDParamMaxValue(1, MAX_YEAR * DAYS_IN_YEAR); // Roughly the maximum year
2203 size->width = std::max(
2204 GetStringBoundingBox(STR_VEHICLE_DETAILS_SERVICING_INTERVAL_PERCENT).width,
2205 GetStringBoundingBox(STR_VEHICLE_DETAILS_SERVICING_INTERVAL_DAYS).width
2206 ) + WD_FRAMERECT_LEFT + WD_FRAMERECT_RIGHT;
2207 size->height = WD_FRAMERECT_TOP + FONT_HEIGHT_NORMAL + WD_FRAMERECT_BOTTOM;
2208 break;
2209 }
2210 }
2211
2213 static bool IsVehicleServiceIntervalEnabled(const VehicleType vehicle_type, CompanyID company_id)
2214 {
2215 const VehicleDefaultSettings *vds = &Company::Get(company_id)->settings.vehicle;
2216 switch (vehicle_type) {
2217 default: NOT_REACHED();
2218 case VEH_TRAIN: return vds->servint_trains != 0;
2219 case VEH_ROAD: return vds->servint_roadveh != 0;
2220 case VEH_SHIP: return vds->servint_ships != 0;
2221 case VEH_AIRCRAFT: return vds->servint_aircraft != 0;
2222 }
2223 }
2224
2236 static void DrawVehicleDetails(const Vehicle *v, int left, int right, int y, int vscroll_pos, uint vscroll_cap, TrainDetailsWindowTabs det_tab)
2237 {
2238 switch (v->type) {
2239 case VEH_TRAIN: DrawTrainDetails(Train::From(v), left, right, y, vscroll_pos, vscroll_cap, det_tab); break;
2240 case VEH_ROAD: DrawRoadVehDetails(v, left, right, y); break;
2241 case VEH_SHIP: DrawShipDetails(v, left, right, y); break;
2242 case VEH_AIRCRAFT: DrawAircraftDetails(Aircraft::From(v), left, right, y); break;
2243 default: NOT_REACHED();
2244 }
2245 }
2246
2247 void SetStringParameters(int widget) const override
2248 {
2249 if (widget == WID_VD_CAPTION) SetDParam(0, Vehicle::Get(this->window_number)->index);
2250 }
2251
2252 void DrawWidget(const Rect &r, int widget) const override
2253 {
2254 const Vehicle *v = Vehicle::Get(this->window_number);
2255
2256 switch (widget) {
2257 case WID_VD_TOP_DETAILS: {
2258 int y = r.top + WD_FRAMERECT_TOP;
2259
2260 /* Draw running cost */
2261 SetDParam(1, v->age / DAYS_IN_LEAP_YEAR);
2262 SetDParam(0, (v->age + DAYS_IN_YEAR < v->max_age) ? STR_VEHICLE_INFO_AGE : STR_VEHICLE_INFO_AGE_RED);
2263 SetDParam(2, v->max_age / DAYS_IN_LEAP_YEAR);
2264 SetDParam(3, v->GetDisplayRunningCost());
2265 DrawString(r.left + WD_FRAMERECT_LEFT, r.right - WD_FRAMERECT_RIGHT, y, STR_VEHICLE_INFO_AGE_RUNNING_COST_YR);
2266 y += FONT_HEIGHT_NORMAL;
2267
2268 /* Draw max speed */
2269 StringID string;
2270 if (v->type == VEH_TRAIN ||
2271 (v->type == VEH_ROAD && _settings_game.vehicle.roadveh_acceleration_model != AM_ORIGINAL)) {
2272 const GroundVehicleCache *gcache = v->GetGroundVehicleCache();
2273 SetDParam(2, v->GetDisplayMaxSpeed());
2274 SetDParam(1, gcache->cached_power);
2275 SetDParam(0, gcache->cached_weight);
2276 SetDParam(3, gcache->cached_max_te / 1000);
2277 if (v->type == VEH_TRAIN && (_settings_game.vehicle.train_acceleration_model == AM_ORIGINAL ||
2278 GetRailTypeInfo(Train::From(v)->railtype)->acceleration_type == 2)) {
2279 string = STR_VEHICLE_INFO_WEIGHT_POWER_MAX_SPEED;
2280 } else {
2281 string = STR_VEHICLE_INFO_WEIGHT_POWER_MAX_SPEED_MAX_TE;
2282 }
2283 } else {
2284 SetDParam(0, v->GetDisplayMaxSpeed());
2285 if (v->type == VEH_AIRCRAFT) {
2286 SetDParam(1, v->GetEngine()->GetAircraftTypeText());
2287 if (Aircraft::From(v)->GetRange() > 0) {
2288 SetDParam(2, Aircraft::From(v)->GetRange());
2289 string = STR_VEHICLE_INFO_MAX_SPEED_TYPE_RANGE;
2290 } else {
2291 string = STR_VEHICLE_INFO_MAX_SPEED_TYPE;
2292 }
2293 } else {
2294 string = STR_VEHICLE_INFO_MAX_SPEED;
2295 }
2296 }
2297 DrawString(r.left + WD_FRAMERECT_LEFT, r.right - WD_FRAMERECT_RIGHT, y, string);
2298 y += FONT_HEIGHT_NORMAL;
2299
2300 /* Draw profit */
2301 SetDParam(0, v->GetDisplayProfitThisYear());
2302 SetDParam(1, v->GetDisplayProfitLastYear());
2303 DrawString(r.left + WD_FRAMERECT_LEFT, r.right - WD_FRAMERECT_RIGHT, y, STR_VEHICLE_INFO_PROFIT_THIS_YEAR_LAST_YEAR);
2304 y += FONT_HEIGHT_NORMAL;
2305
2306 /* Draw breakdown & reliability */
2307 SetDParam(0, ToPercent16(v->reliability));
2308 SetDParam(1, v->breakdowns_since_last_service);
2309 DrawString(r.left + WD_FRAMERECT_LEFT, r.right - WD_FRAMERECT_RIGHT, y, STR_VEHICLE_INFO_RELIABILITY_BREAKDOWNS);
2310 break;
2311 }
2312
2313 case WID_VD_MATRIX:
2314 /* For trains only. */
2315 DrawVehicleDetails(v, r.left + WD_MATRIX_LEFT, r.right - WD_MATRIX_RIGHT, r.top + WD_MATRIX_TOP, this->vscroll->GetPosition(), this->vscroll->GetCapacity(), this->tab);
2316 break;
2317
2318 case WID_VD_MIDDLE_DETAILS: {
2319 /* For other vehicles, at the place of the matrix. */
2320 bool rtl = _current_text_dir == TD_RTL;
2321 uint sprite_width = GetSingleVehicleWidth(v, EIT_IN_DETAILS) + WD_FRAMERECT_LEFT + WD_FRAMERECT_RIGHT;
2322
2323 uint text_left = r.left + (rtl ? 0 : sprite_width);
2324 uint text_right = r.right - (rtl ? sprite_width : 0);
2325
2326 /* Articulated road vehicles use a complete line. */
2327 if (v->type == VEH_ROAD && v->HasArticulatedPart()) {
2328 DrawVehicleImage(v, r.left + WD_FRAMERECT_LEFT, r.right - WD_FRAMERECT_RIGHT, r.top + WD_FRAMERECT_TOP, INVALID_VEHICLE, EIT_IN_DETAILS, 0);
2329 } else {
2330 uint sprite_left = rtl ? text_right : r.left;
2331 uint sprite_right = rtl ? r.right : text_left;
2332
2333 DrawVehicleImage(v, sprite_left + WD_FRAMERECT_LEFT, sprite_right - WD_FRAMERECT_RIGHT, r.top + WD_FRAMERECT_TOP, INVALID_VEHICLE, EIT_IN_DETAILS, 0);
2334 }
2335 DrawVehicleDetails(v, text_left + WD_FRAMERECT_LEFT, text_right - WD_FRAMERECT_RIGHT, r.top + WD_FRAMERECT_TOP, 0, 0, this->tab);
2336 break;
2337 }
2338
2339 case WID_VD_SERVICING_INTERVAL:
2340 /* Draw service interval text */
2341 SetDParam(0, v->GetServiceInterval());
2342 SetDParam(1, v->date_of_last_service);
2343 DrawString(r.left + WD_FRAMERECT_LEFT, r.right - WD_FRAMERECT_RIGHT, r.top + (r.bottom - r.top + 1 - FONT_HEIGHT_NORMAL) / 2,
2344 v->ServiceIntervalIsPercent() ? STR_VEHICLE_DETAILS_SERVICING_INTERVAL_PERCENT : STR_VEHICLE_DETAILS_SERVICING_INTERVAL_DAYS);
2345 break;
2346 }
2347 }
2348
2350 void OnPaint() override
2351 {
2352 const Vehicle *v = Vehicle::Get(this->window_number);
2353
2354 if (v->type == VEH_TRAIN) {
2355 this->DisableWidget(this->tab + WID_VD_DETAILS_CARGO_CARRIED);
2356 this->vscroll->SetCount(GetTrainDetailsWndVScroll(v->index, this->tab));
2357 }
2358
2359 /* Disable service-scroller when interval is set to disabled */
2360 this->SetWidgetsDisabledState(!IsVehicleServiceIntervalEnabled(v->type, v->owner),
2361 WID_VD_INCREASE_SERVICING_INTERVAL,
2362 WID_VD_DECREASE_SERVICING_INTERVAL,
2363 WIDGET_LIST_END);
2364
2365 StringID str = v->ServiceIntervalIsCustom() ?
2366 (v->ServiceIntervalIsPercent() ? STR_VEHICLE_DETAILS_PERCENT : STR_VEHICLE_DETAILS_DAYS) :
2367 STR_VEHICLE_DETAILS_DEFAULT;
2368 this->GetWidget<NWidgetCore>(WID_VD_SERVICE_INTERVAL_DROPDOWN)->widget_data = str;
2369
2370 this->DrawWidgets();
2371 }
2372
2373 void OnClick(Point pt, int widget, int click_count) override
2374 {
2375 switch (widget) {
2376 case WID_VD_INCREASE_SERVICING_INTERVAL: // increase int
2377 case WID_VD_DECREASE_SERVICING_INTERVAL: { // decrease int
2378 int mod = _ctrl_pressed ? 5 : 10;
2379 const Vehicle *v = Vehicle::Get(this->window_number);
2380
2381 mod = (widget == WID_VD_DECREASE_SERVICING_INTERVAL) ? -mod : mod;
2382 mod = GetServiceIntervalClamped(mod + v->GetServiceInterval(), v->ServiceIntervalIsPercent());
2383 if (mod == v->GetServiceInterval()) return;
2384
2385 DoCommandP(v->tile, v->index, mod | (1 << 16) | (v->ServiceIntervalIsPercent() << 17), CMD_CHANGE_SERVICE_INT | CMD_MSG(STR_ERROR_CAN_T_CHANGE_SERVICING));
2386 break;
2387 }
2388
2389 case WID_VD_SERVICE_INTERVAL_DROPDOWN: {
2390 const Vehicle *v = Vehicle::Get(this->window_number);
2391 ShowDropDownMenu(this, _service_interval_dropdown, v->ServiceIntervalIsCustom() ? (v->ServiceIntervalIsPercent() ? 2 : 1) : 0, widget, 0, 0);
2392 break;
2393 }
2394
2395 case WID_VD_DETAILS_CARGO_CARRIED:
2396 case WID_VD_DETAILS_TRAIN_VEHICLES:
2397 case WID_VD_DETAILS_CAPACITY_OF_EACH:
2398 case WID_VD_DETAILS_TOTAL_CARGO:
2399 this->SetWidgetsDisabledState(false,
2400 WID_VD_DETAILS_CARGO_CARRIED,
2401 WID_VD_DETAILS_TRAIN_VEHICLES,
2402 WID_VD_DETAILS_CAPACITY_OF_EACH,
2403 WID_VD_DETAILS_TOTAL_CARGO,
2404 widget,
2405 WIDGET_LIST_END);
2406
2407 this->tab = (TrainDetailsWindowTabs)(widget - WID_VD_DETAILS_CARGO_CARRIED);
2408 this->SetDirty();
2409 break;
2410 }
2411 }
2412
2413 void OnDropdownSelect(int widget, int index) override
2414 {
2415 switch (widget) {
2416 case WID_VD_SERVICE_INTERVAL_DROPDOWN: {
2417 const Vehicle *v = Vehicle::Get(this->window_number);
2418 bool iscustom = index != 0;
2419 bool ispercent = iscustom ? (index == 2) : Company::Get(v->owner)->settings.vehicle.servint_ispercent;
2420 uint16 interval = GetServiceIntervalClamped(v->GetServiceInterval(), ispercent);
2421 DoCommandP(v->tile, v->index, interval | (iscustom << 16) | (ispercent << 17), CMD_CHANGE_SERVICE_INT | CMD_MSG(STR_ERROR_CAN_T_CHANGE_SERVICING));
2422 break;
2423 }
2424 }
2425 }
2426
2427 void OnResize() override
2428 {
2429 NWidgetCore *nwi = this->GetWidget<NWidgetCore>(WID_VD_MATRIX);
2430 if (nwi != nullptr) {
2431 this->vscroll->SetCapacityFromWidget(this, WID_VD_MATRIX);
2432 }
2433 }
2434 };
2435
2437 static WindowDesc _train_vehicle_details_desc(
2438 WDP_AUTO, "view_vehicle_details_train", 405, 178,
2439 WC_VEHICLE_DETAILS, WC_VEHICLE_VIEW,
2440 0,
2441 _nested_train_vehicle_details_widgets, lengthof(_nested_train_vehicle_details_widgets)
2442 );
2443
2445 static WindowDesc _nontrain_vehicle_details_desc(
2446 WDP_AUTO, "view_vehicle_details", 405, 113,
2447 WC_VEHICLE_DETAILS, WC_VEHICLE_VIEW,
2448 0,
2449 _nested_nontrain_vehicle_details_widgets, lengthof(_nested_nontrain_vehicle_details_widgets)
2450 );
2451
2453 static void ShowVehicleDetailsWindow(const Vehicle *v)
2454 {
2455 DeleteWindowById(WC_VEHICLE_ORDERS, v->index, false);
2456 DeleteWindowById(WC_VEHICLE_TIMETABLE, v->index, false);
2457 AllocateWindowDescFront<VehicleDetailsWindow>((v->type == VEH_TRAIN) ? &_train_vehicle_details_desc : &_nontrain_vehicle_details_desc, v->index);
2458 }
2459
2460
2461 /* Unified vehicle GUI - Vehicle View Window */
2462
2464 static const NWidgetPart _nested_vehicle_view_widgets[] = {
2465 NWidget(NWID_HORIZONTAL),
2466 NWidget(WWT_CLOSEBOX, COLOUR_GREY),
2467 NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_VV_RENAME), SetMinimalSize(12, 14), SetDataTip(SPR_RENAME, STR_NULL /* filled in later */),
2468 NWidget(WWT_CAPTION, COLOUR_GREY, WID_VV_CAPTION), SetDataTip(STR_VEHICLE_VIEW_CAPTION, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
2469 NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_VV_LOCATION), SetMinimalSize(12, 14), SetDataTip(SPR_GOTO_LOCATION, STR_NULL /* filled in later */),
2470 NWidget(WWT_DEBUGBOX, COLOUR_GREY),
2471 NWidget(WWT_SHADEBOX, COLOUR_GREY),
2472 NWidget(WWT_DEFSIZEBOX, COLOUR_GREY),
2473 NWidget(WWT_STICKYBOX, COLOUR_GREY),
2474 EndContainer(),
2475 NWidget(NWID_HORIZONTAL),
2476 NWidget(WWT_PANEL, COLOUR_GREY),
2477 NWidget(WWT_INSET, COLOUR_GREY), SetPadding(2, 2, 2, 2),
2478 NWidget(NWID_VIEWPORT, INVALID_COLOUR, WID_VV_VIEWPORT), SetMinimalSize(226, 84), SetResize(1, 1), SetPadding(1, 1, 1, 1),
2479 EndContainer(),
2480 EndContainer(),
2481 NWidget(NWID_VERTICAL),
2482 NWidget(NWID_SELECTION, INVALID_COLOUR, WID_VV_SELECT_DEPOT_CLONE),
2483 NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_VV_GOTO_DEPOT), SetMinimalSize(18, 18), SetDataTip(0x0 /* filled later */, 0x0 /* filled later */),
2484 NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_VV_CLONE), SetMinimalSize(18, 18), SetDataTip(0x0 /* filled later */, 0x0 /* filled later */),
2485 EndContainer(),
2486 /* For trains only, 'ignore signal' button. */
2487 NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_VV_FORCE_PROCEED), SetMinimalSize(18, 18),
2488 SetDataTip(SPR_IGNORE_SIGNALS, STR_VEHICLE_VIEW_TRAIN_IGNORE_SIGNAL_TOOLTIP),
2489 NWidget(NWID_SELECTION, INVALID_COLOUR, WID_VV_SELECT_REFIT_TURN),
2490 NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_VV_REFIT), SetMinimalSize(18, 18), SetDataTip(SPR_REFIT_VEHICLE, 0x0 /* filled later */),
2491 NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_VV_TURN_AROUND), SetMinimalSize(18, 18),
2492 SetDataTip(SPR_FORCE_VEHICLE_TURN, STR_VEHICLE_VIEW_ROAD_VEHICLE_REVERSE_TOOLTIP),
2493 EndContainer(),
2494 NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_VV_SHOW_ORDERS), SetMinimalSize(18, 18), SetDataTip(SPR_SHOW_ORDERS, 0x0 /* filled later */),
2495 NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_VV_SHOW_DETAILS), SetMinimalSize(18, 18), SetDataTip(SPR_SHOW_VEHICLE_DETAILS, 0x0 /* filled later */),
2496 NWidget(WWT_PANEL, COLOUR_GREY), SetMinimalSize(18, 0), SetResize(0, 1), EndContainer(),
2497 EndContainer(),
2498 EndContainer(),
2499 NWidget(NWID_HORIZONTAL),
2500 NWidget(WWT_PUSHBTN, COLOUR_GREY, WID_VV_START_STOP), SetMinimalTextLines(1, WD_FRAMERECT_TOP + WD_FRAMERECT_BOTTOM + 2), SetResize(1, 0), SetFill(1, 0),
2501 NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_VV_ORDER_LOCATION), SetMinimalSize(12, 14), SetDataTip(SPR_GOTO_LOCATION, STR_VEHICLE_VIEW_ORDER_LOCATION_TOOLTIP),
2502 NWidget(WWT_RESIZEBOX, COLOUR_GREY),
2503 EndContainer(),
2504 };
2505
2507 static WindowDesc _vehicle_view_desc(
2508 WDP_AUTO, "view_vehicle", 250, 116,
2509 WC_VEHICLE_VIEW, WC_NONE,
2510 0,
2511 _nested_vehicle_view_widgets, lengthof(_nested_vehicle_view_widgets)
2512 );
2513
2518 static WindowDesc _train_view_desc(
2519 WDP_AUTO, "view_vehicle_train", 250, 134,
2520 WC_VEHICLE_VIEW, WC_NONE,
2521 0,
2522 _nested_vehicle_view_widgets, lengthof(_nested_vehicle_view_widgets)
2523 );
2524
2525
2526 /* Just to make sure, nobody has changed the vehicle type constants, as we are
2527 using them for array indexing in a number of places here. */
2528 static_assert(VEH_TRAIN == 0);
2529 static_assert(VEH_ROAD == 1);
2530 static_assert(VEH_SHIP == 2);
2531 static_assert(VEH_AIRCRAFT == 3);
2532
2534 static const ZoomLevel _vehicle_view_zoom_levels[] = {
2535 ZOOM_LVL_TRAIN,
2536 ZOOM_LVL_ROADVEH,
2537 ZOOM_LVL_SHIP,
2538 ZOOM_LVL_AIRCRAFT,
2539 };
2540
2541 /* Constants for geometry of vehicle view viewport */
2542 static const int VV_INITIAL_VIEWPORT_WIDTH = 226;
2543 static const int VV_INITIAL_VIEWPORT_HEIGHT = 84;
2544 static const int VV_INITIAL_VIEWPORT_HEIGHT_TRAIN = 102;
2545
2547 enum VehicleCommandTranslation {
2548 VCT_CMD_START_STOP = 0,
2549 VCT_CMD_CLONE_VEH,
2550 VCT_CMD_TURN_AROUND,
2551 };
2552
2554 static const uint32 _vehicle_command_translation_table[][4] = {
2555 { // VCT_CMD_START_STOP
2556 CMD_START_STOP_VEHICLE | CMD_MSG(STR_ERROR_CAN_T_STOP_START_TRAIN),
2557 CMD_START_STOP_VEHICLE | CMD_MSG(STR_ERROR_CAN_T_STOP_START_ROAD_VEHICLE),
2558 CMD_START_STOP_VEHICLE | CMD_MSG(STR_ERROR_CAN_T_STOP_START_SHIP),
2559 CMD_START_STOP_VEHICLE | CMD_MSG(STR_ERROR_CAN_T_STOP_START_AIRCRAFT)
2560 },
2561 { // VCT_CMD_CLONE_VEH
2562 CMD_CLONE_VEHICLE | CMD_MSG(STR_ERROR_CAN_T_BUY_TRAIN),
2563 CMD_CLONE_VEHICLE | CMD_MSG(STR_ERROR_CAN_T_BUY_ROAD_VEHICLE),
2564 CMD_CLONE_VEHICLE | CMD_MSG(STR_ERROR_CAN_T_BUY_SHIP),
2565 CMD_CLONE_VEHICLE | CMD_MSG(STR_ERROR_CAN_T_BUY_AIRCRAFT)
2566 },
2567 { // VCT_CMD_TURN_AROUND
2568 CMD_REVERSE_TRAIN_DIRECTION | CMD_MSG(STR_ERROR_CAN_T_REVERSE_DIRECTION_TRAIN),
2569 CMD_TURN_ROADVEH | CMD_MSG(STR_ERROR_CAN_T_MAKE_ROAD_VEHICLE_TURN),
2570 0xffffffff, // invalid for ships
2571 0xffffffff // invalid for aircraft
2572 },
2573 };
2574
2582 void CcStartStopVehicle(const CommandCost &result, TileIndex tile, uint32 p1, uint32 p2, uint32 cmd)
2583 {
2584 if (result.Failed()) return;
2585
2586 const Vehicle *v = Vehicle::GetIfValid(p1);
2587 if (v == nullptr || !v->IsPrimaryVehicle() || v->owner != _local_company) return;
2588
2589 StringID msg = (v->vehstatus & VS_STOPPED) ? STR_VEHICLE_COMMAND_STOPPED : STR_VEHICLE_COMMAND_STARTED;
2590 Point pt = RemapCoords(v->x_pos, v->y_pos, v->z_pos);
2591 AddTextEffect(msg, pt.x, pt.y, DAY_TICKS, TE_RISING);
2592 }
2593
2599 void StartStopVehicle(const Vehicle *v, bool texteffect)
2600 {
2601 assert(v->IsPrimaryVehicle());
2602 DoCommandP(v->tile, v->index, 0, _vehicle_command_translation_table[VCT_CMD_START_STOP][v->type], texteffect ? CcStartStopVehicle : nullptr);
2603 }
2604
2606 static bool IsVehicleRefitable(const Vehicle *v)
2607 {
2608 if (!v->IsStoppedInDepot()) return false;
2609
2610 do {
2611 if (IsEngineRefittable(v->engine_type)) return true;
2612 } while (v->IsGroundVehicle() && (v = v->Next()) != nullptr);
2613
2614 return false;
2615 }
2616
2618 struct VehicleViewWindow : Window {
2619 private:
2621 enum PlaneSelections {
2622 SEL_DC_GOTO_DEPOT,
2623 SEL_DC_CLONE,
2624
2625 SEL_RT_REFIT,
2626 SEL_RT_TURN_AROUND,
2627
2628 SEL_DC_BASEPLANE = SEL_DC_GOTO_DEPOT,
2629 SEL_RT_BASEPLANE = SEL_RT_REFIT,
2630 };
2631 bool mouse_over_start_stop = false;
2632
2637 void SelectPlane(PlaneSelections plane)
2638 {
2639 switch (plane) {
2640 case SEL_DC_GOTO_DEPOT:
2641 case SEL_DC_CLONE:
2642 this->GetWidget<NWidgetStacked>(WID_VV_SELECT_DEPOT_CLONE)->SetDisplayedPlane(plane - SEL_DC_BASEPLANE);
2643 break;
2644
2645 case SEL_RT_REFIT:
2646 case SEL_RT_TURN_AROUND:
2647 this->GetWidget<NWidgetStacked>(WID_VV_SELECT_REFIT_TURN)->SetDisplayedPlane(plane - SEL_RT_BASEPLANE);
2648 break;
2649
2650 default:
2651 NOT_REACHED();
2652 }
2653 }
2654
2655 public:
2656 VehicleViewWindow(WindowDesc *desc, WindowNumber window_number) : Window(desc)
2657 {
2658 this->flags |= WF_DISABLE_VP_SCROLL;
2659 this->CreateNestedTree();
2660
2661 /* Sprites for the 'send to depot' button indexed by vehicle type. */
2662 static const SpriteID vehicle_view_goto_depot_sprites[] = {
2663 SPR_SEND_TRAIN_TODEPOT,
2664 SPR_SEND_ROADVEH_TODEPOT,
2665 SPR_SEND_SHIP_TODEPOT,
2666 SPR_SEND_AIRCRAFT_TODEPOT,
2667 };
2668 const Vehicle *v = Vehicle::Get(window_number);
2669 this->GetWidget<NWidgetCore>(WID_VV_GOTO_DEPOT)->widget_data = vehicle_view_goto_depot_sprites[v->type];
2670
2671 /* Sprites for the 'clone vehicle' button indexed by vehicle type. */
2672 static const SpriteID vehicle_view_clone_sprites[] = {
2673 SPR_CLONE_TRAIN,
2674 SPR_CLONE_ROADVEH,
2675 SPR_CLONE_SHIP,
2676 SPR_CLONE_AIRCRAFT,
2677 };
2678 this->GetWidget<NWidgetCore>(WID_VV_CLONE)->widget_data = vehicle_view_clone_sprites[v->type];
2679
2680 switch (v->type) {
2681 case VEH_TRAIN:
2682 this->GetWidget<NWidgetCore>(WID_VV_TURN_AROUND)->tool_tip = STR_VEHICLE_VIEW_TRAIN_REVERSE_TOOLTIP;
2683 break;
2684
2685 case VEH_ROAD:
2686 break;
2687
2688 case VEH_SHIP:
2689 case VEH_AIRCRAFT:
2690 this->SelectPlane(SEL_RT_REFIT);
2691 break;
2692
2693 default: NOT_REACHED();
2694 }
2695 this->FinishInitNested(window_number);
2696 this->owner = v->owner;
2697 this->GetWidget<NWidgetViewport>(WID_VV_VIEWPORT)->InitializeViewport(this, this->window_number | (1 << 31), _vehicle_view_zoom_levels[v->type]);
2698
2699 this->GetWidget<NWidgetCore>(WID_VV_START_STOP)->tool_tip = STR_VEHICLE_VIEW_TRAIN_STATUS_START_STOP_TOOLTIP + v->type;
2700 this->GetWidget<NWidgetCore>(WID_VV_RENAME)->tool_tip = STR_VEHICLE_DETAILS_TRAIN_RENAME + v->type;
2701 this->GetWidget<NWidgetCore>(WID_VV_LOCATION)->tool_tip = STR_VEHICLE_VIEW_TRAIN_CENTER_TOOLTIP + v->type;
2702 this->GetWidget<NWidgetCore>(WID_VV_REFIT)->tool_tip = STR_VEHICLE_VIEW_TRAIN_REFIT_TOOLTIP + v->type;
2703 this->GetWidget<NWidgetCore>(WID_VV_GOTO_DEPOT)->tool_tip = STR_VEHICLE_VIEW_TRAIN_SEND_TO_DEPOT_TOOLTIP + v->type;
2704 this->GetWidget<NWidgetCore>(WID_VV_SHOW_ORDERS)->tool_tip = STR_VEHICLE_VIEW_TRAIN_ORDERS_TOOLTIP + v->type;
2705 this->GetWidget<NWidgetCore>(WID_VV_SHOW_DETAILS)->tool_tip = STR_VEHICLE_VIEW_TRAIN_SHOW_DETAILS_TOOLTIP + v->type;
2706 this->GetWidget<NWidgetCore>(WID_VV_CLONE)->tool_tip = STR_VEHICLE_VIEW_CLONE_TRAIN_INFO + v->type;
2707
2708 this->UpdateButtonStatus();
2709 }
2710
2711 ~VehicleViewWindow()
2712 {
2713 DeleteWindowById(WC_VEHICLE_ORDERS, this->window_number, false);
2714 DeleteWindowById(WC_VEHICLE_REFIT, this->window_number, false);
2715 DeleteWindowById(WC_VEHICLE_DETAILS, this->window_number, false);
2716 DeleteWindowById(WC_VEHICLE_TIMETABLE, this->window_number, false);
2717 }
2718
2719 void UpdateWidgetSize(int widget, Dimension *size, const Dimension &padding, Dimension *fill, Dimension *resize) override
2720 {
2721 const Vehicle *v = Vehicle::Get(this->window_number);
2722 switch (widget) {
2723 case WID_VV_START_STOP:
2724 size->height = std::max(size->height, std::max(GetSpriteSize(SPR_FLAG_VEH_STOPPED).height, GetSpriteSize(SPR_FLAG_VEH_RUNNING).height) + WD_IMGBTN_TOP + WD_IMGBTN_BOTTOM);
2725 break;
2726
2727 case WID_VV_FORCE_PROCEED:
2728 if (v->type != VEH_TRAIN) {
2729 size->height = 0;
2730 size->width = 0;
2731 }
2732 break;
2733
2734 case WID_VV_VIEWPORT:
2735 size->width = VV_INITIAL_VIEWPORT_WIDTH;
2736 size->height = (v->type == VEH_TRAIN) ? VV_INITIAL_VIEWPORT_HEIGHT_TRAIN : VV_INITIAL_VIEWPORT_HEIGHT;
2737 break;
2738 }
2739 }
2740
2741 void OnPaint() override
2742 {
2743 const Vehicle *v = Vehicle::Get(this->window_number);
2744 bool is_localcompany = v->owner == _local_company;
2745 bool refitable_and_stopped_in_depot = IsVehicleRefitable(v);
2746
2747 this->SetWidgetDisabledState(WID_VV_RENAME, !is_localcompany);
2748 this->SetWidgetDisabledState(WID_VV_GOTO_DEPOT, !is_localcompany);
2749 this->SetWidgetDisabledState(WID_VV_REFIT, !refitable_and_stopped_in_depot || !is_localcompany);
2750 this->SetWidgetDisabledState(WID_VV_CLONE, !is_localcompany);
2751
2752 if (v->type == VEH_TRAIN) {
2753 this->SetWidgetLoweredState(WID_VV_FORCE_PROCEED, Train::From(v)->force_proceed == TFP_SIGNAL);
2754 this->SetWidgetDisabledState(WID_VV_FORCE_PROCEED, !is_localcompany);
2755 this->SetWidgetDisabledState(WID_VV_TURN_AROUND, !is_localcompany);
2756 }
2757
2758 this->SetWidgetDisabledState(WID_VV_ORDER_LOCATION, v->current_order.GetLocation(v) == INVALID_TILE);
2759
2760 this->DrawWidgets();
2761 }
2762
2763 void SetStringParameters(int widget) const override
2764 {
2765 if (widget != WID_VV_CAPTION) return;
2766
2767 const Vehicle *v = Vehicle::Get(this->window_number);
2768 SetDParam(0, v->index);
2769 }
2770
2771 void DrawWidget(const Rect &r, int widget) const override
2772 {
2773 if (widget != WID_VV_START_STOP) return;
2774
2775 const Vehicle *v = Vehicle::Get(this->window_number);
2776 StringID str;
2777 TextColour text_colour = TC_FROMSTRING;
2778 if (v->vehstatus & VS_CRASHED) {
2779 str = STR_VEHICLE_STATUS_CRASHED;
2780 } else if (v->type != VEH_AIRCRAFT && v->breakdown_ctr == 1) { // check for aircraft necessary?
2781 str = STR_VEHICLE_STATUS_BROKEN_DOWN;
2782 } else if (v->vehstatus & VS_STOPPED && (!mouse_over_start_stop || v->IsStoppedInDepot())) {
2783 if (v->type == VEH_TRAIN) {
2784 if (v->cur_speed == 0) {
2785 if (Train::From(v)->gcache.cached_power == 0) {
2786 str = STR_VEHICLE_STATUS_TRAIN_NO_POWER;
2787 } else {
2788 str = STR_VEHICLE_STATUS_STOPPED;
2789 }
2790 } else {
2791 SetDParam(0, v->GetDisplaySpeed());
2792 str = STR_VEHICLE_STATUS_TRAIN_STOPPING_VEL;
2793 }
2794 } else { // no train
2795 str = STR_VEHICLE_STATUS_STOPPED;
2796 }
2797 } else if (v->type == VEH_TRAIN && HasBit(Train::From(v)->flags, VRF_TRAIN_STUCK) && !v->current_order.IsType(OT_LOADING)) {
2798 str = STR_VEHICLE_STATUS_TRAIN_STUCK;
2799 } else if (v->type == VEH_AIRCRAFT && HasBit(Aircraft::From(v)->flags, VAF_DEST_TOO_FAR) && !v->current_order.IsType(OT_LOADING)) {
2800 str = STR_VEHICLE_STATUS_AIRCRAFT_TOO_FAR;
2801 } else { // vehicle is in a "normal" state, show current order
2802 if (mouse_over_start_stop) {
2803 if (v->vehstatus & VS_STOPPED) {
2804 text_colour = TC_RED | TC_FORCED;
2805 } else if (v->type == VEH_TRAIN && HasBit(Train::From(v)->flags, VRF_TRAIN_STUCK) && !v->current_order.IsType(OT_LOADING)) {
2806 text_colour = TC_ORANGE | TC_FORCED;
2807 }
2808 }
2809 switch (v->current_order.GetType()) {
2810 case OT_GOTO_STATION: {
2811 SetDParam(0, v->current_order.GetDestination());
2812 SetDParam(1, v->GetDisplaySpeed());
2813 str = STR_VEHICLE_STATUS_HEADING_FOR_STATION_VEL;
2814 break;
2815 }
2816
2817 case OT_GOTO_DEPOT: {
2818 SetDParam(0, v->type);
2819 SetDParam(1, v->current_order.GetDestination());
2820 SetDParam(2, v->GetDisplaySpeed());
2821 if (v->current_order.GetDepotActionType() & ODATFB_NEAREST_DEPOT) {
2822 /* This case *only* happens when multiple nearest depot orders
2823 * follow each other (including an order list only one order: a
2824 * nearest depot order) and there are no reachable depots.
2825 * It is primarily to guard for the case that there is no
2826 * depot with index 0, which would be used as fallback for
2827 * evaluating the string in the status bar. */
2828 str = STR_EMPTY;
2829 } else if (v->current_order.GetDepotActionType() & ODATFB_HALT) {
2830 str = STR_VEHICLE_STATUS_HEADING_FOR_DEPOT_VEL;
2831 } else {
2832 str = STR_VEHICLE_STATUS_HEADING_FOR_DEPOT_SERVICE_VEL;
2833 }
2834 break;
2835 }
2836
2837 case OT_LOADING:
2838 str = STR_VEHICLE_STATUS_LOADING_UNLOADING;
2839 break;
2840
2841 case OT_GOTO_WAYPOINT: {
2842 assert(v->type == VEH_TRAIN || v->type == VEH_SHIP);
2843 SetDParam(0, v->current_order.GetDestination());
2844 str = STR_VEHICLE_STATUS_HEADING_FOR_WAYPOINT_VEL;
2845 SetDParam(1, v->GetDisplaySpeed());
2846 break;
2847 }
2848
2849 case OT_LEAVESTATION:
2850 if (v->type != VEH_AIRCRAFT) {
2851 str = STR_VEHICLE_STATUS_LEAVING;
2852 break;
2853 }
2854 FALLTHROUGH;
2855 default:
2856 if (v->GetNumManualOrders() == 0) {
2857 str = STR_VEHICLE_STATUS_NO_ORDERS_VEL;
2858 SetDParam(0, v->GetDisplaySpeed());
2859 } else {
2860 str = STR_EMPTY;
2861 }
2862 break;
2863 }
2864 }
2865
2866 /* Draw the flag plus orders. */
2867 bool rtl = (_current_text_dir == TD_RTL);
2868 uint text_offset = std::max(GetSpriteSize(SPR_FLAG_VEH_STOPPED).width, GetSpriteSize(SPR_FLAG_VEH_RUNNING).width) + WD_IMGBTN_LEFT + WD_IMGBTN_RIGHT;
2869 int height = r.bottom - r.top;
2870 int text_left = r.left + (rtl ? (uint)WD_FRAMERECT_LEFT : text_offset);
2871 int text_right = r.right - (rtl ? text_offset : (uint)WD_FRAMERECT_RIGHT);
2872 int text_top = r.top + WD_FRAMERECT_TOP + (height - WD_FRAMERECT_TOP - WD_FRAMERECT_BOTTOM - FONT_HEIGHT_NORMAL) / 2;
2873 int image = ((v->vehstatus & VS_STOPPED) != 0) ? SPR_FLAG_VEH_STOPPED : SPR_FLAG_VEH_RUNNING;
2874 int image_left = (rtl ? text_right + 1 : r.left) + WD_IMGBTN_LEFT;
2875 int image_top = r.top + WD_IMGBTN_TOP + (height - WD_IMGBTN_TOP + WD_IMGBTN_BOTTOM - GetSpriteSize(image).height) / 2;
2876 int lowered = this->IsWidgetLowered(WID_VV_START_STOP) ? 1 : 0;
2877 DrawSprite(image, PAL_NONE, image_left + lowered, image_top + lowered);
2878 DrawString(text_left + lowered, text_right + lowered, text_top + lowered, str, text_colour, SA_HOR_CENTER);
2879 }
2880
2881 void OnClick(Point pt, int widget, int click_count) override
2882 {
2883 const Vehicle *v = Vehicle::Get(this->window_number);
2884
2885 switch (widget) {
2886 case WID_VV_RENAME: { // rename
2887 SetDParam(0, v->index);
2888 ShowQueryString(STR_VEHICLE_NAME, STR_QUERY_RENAME_TRAIN_CAPTION + v->type,
2889 MAX_LENGTH_VEHICLE_NAME_CHARS, this, CS_ALPHANUMERAL, QSF_ENABLE_DEFAULT | QSF_LEN_IN_CHARS);
2890 break;
2891 }
2892
2893 case WID_VV_START_STOP: // start stop
2894 StartStopVehicle(v, false);
2895 break;
2896
2897 case WID_VV_ORDER_LOCATION: {
2898 /* Scroll to current order destination */
2899 TileIndex tile = v->current_order.GetLocation(v);
2900 if (tile == INVALID_TILE) break;
2901
2902 if (_ctrl_pressed) {
2903 ShowExtraViewportWindow(tile);
2904 } else {
2905 ScrollMainWindowToTile(tile);
2906 }
2907 break;
2908 }
2909
2910 case WID_VV_LOCATION: // center main view
2911 if (_ctrl_pressed) {
2912 ShowExtraViewportWindow(TileVirtXY(v->x_pos, v->y_pos));
2913 } else {
2914 const Window *mainwindow = FindWindowById(WC_MAIN_WINDOW, 0);
2915 if (click_count > 1 && mainwindow->viewport->zoom <= ZOOM_LVL_OUT_4X) {
2916 /* main window 'follows' vehicle */
2917 mainwindow->viewport->follow_vehicle = v->index;
2918 } else {
2919 ScrollMainWindowTo(v->x_pos, v->y_pos, v->z_pos);
2920 }
2921 }
2922 break;
2923
2924 case WID_VV_GOTO_DEPOT: // goto hangar
2925 DoCommandP(v->tile, v->index | (_ctrl_pressed ? DEPOT_SERVICE : 0U), 0, GetCmdSendToDepot(v));
2926 break;
2927 case WID_VV_REFIT: // refit
2928 ShowVehicleRefitWindow(v, INVALID_VEH_ORDER_ID, this);
2929 break;
2930 case WID_VV_SHOW_ORDERS: // show orders
2931 if (_ctrl_pressed) {
2932 ShowTimetableWindow(v);
2933 } else {
2934 ShowOrdersWindow(v);
2935 }
2936 break;
2937 case WID_VV_SHOW_DETAILS: // show details
2938 if (_ctrl_pressed) {
2939 ShowCompanyGroupForVehicle(v);
2940 } else {
2941 ShowVehicleDetailsWindow(v);
2942 }
2943 break;
2944 case WID_VV_CLONE: // clone vehicle
2945 /* Suppress the vehicle GUI when share-cloning.
2946 * There is no point to it except for starting the vehicle.
2947 * For starting the vehicle the player has to open the depot GUI, which is
2948 * most likely already open, but is also visible in the vehicle viewport. */
2949 DoCommandP(v->tile, v->index, _ctrl_pressed ? 1 : 0,
2950 _vehicle_command_translation_table[VCT_CMD_CLONE_VEH][v->type],
2951 _ctrl_pressed ? nullptr : CcCloneVehicle);
2952 break;
2953 case WID_VV_TURN_AROUND: // turn around
2954 assert(v->IsGroundVehicle());
2955 DoCommandP(v->tile, v->index, 0,
2956 _vehicle_command_translation_table[VCT_CMD_TURN_AROUND][v->type]);
2957 break;
2958 case WID_VV_FORCE_PROCEED: // force proceed
2959 assert(v->type == VEH_TRAIN);
2960 DoCommandP(v->tile, v->index, 0, CMD_FORCE_TRAIN_PROCEED | CMD_MSG(STR_ERROR_CAN_T_MAKE_TRAIN_PASS_SIGNAL));
2961 break;
2962 }
2963 }
2964
2965 void OnQueryTextFinished(char *str) override
2966 {
2967 if (str == nullptr) return;
2968
2969 DoCommandP(0, this->window_number, 0, CMD_RENAME_VEHICLE | CMD_MSG(STR_ERROR_CAN_T_RENAME_TRAIN + Vehicle::Get(this->window_number)->type), nullptr, str);
2970 }
2971
2972 void OnMouseOver(Point pt, int widget) override
2973 {
2974 bool start_stop = widget == WID_VV_START_STOP;
2975 if (start_stop != mouse_over_start_stop) {
2976 mouse_over_start_stop = start_stop;
2977 this->SetWidgetDirty(WID_VV_START_STOP);
2978 }
2979 }
2980
2981 void OnResize() override
2982 {
2983 if (this->viewport != nullptr) {
2984 NWidgetViewport *nvp = this->GetWidget<NWidgetViewport>(WID_VV_VIEWPORT);
2985 nvp->UpdateViewportCoordinates(this);
2986 }
2987 }
2988
2989 void UpdateButtonStatus()
2990 {
2991 const Vehicle *v = Vehicle::Get(this->window_number);
2992 bool veh_stopped = v->IsStoppedInDepot();
2993
2994 /* Widget WID_VV_GOTO_DEPOT must be hidden if the vehicle is already stopped in depot.
2995 * Widget WID_VV_CLONE_VEH should then be shown, since cloning is allowed only while in depot and stopped.
2996 */
2997 PlaneSelections plane = veh_stopped ? SEL_DC_CLONE : SEL_DC_GOTO_DEPOT;
2998 NWidgetStacked *nwi = this->GetWidget<NWidgetStacked>(WID_VV_SELECT_DEPOT_CLONE); // Selection widget 'send to depot' / 'clone'.
2999 if (nwi->shown_plane + SEL_DC_BASEPLANE != plane) {
3000 this->SelectPlane(plane);
3001 this->SetWidgetDirty(WID_VV_SELECT_DEPOT_CLONE);
3002 }
3003 /* The same system applies to widget WID_VV_REFIT_VEH and VVW_WIDGET_TURN_AROUND.*/
3004 if (v->IsGroundVehicle()) {
3005 PlaneSelections plane = veh_stopped ? SEL_RT_REFIT : SEL_RT_TURN_AROUND;
3006 NWidgetStacked *nwi = this->GetWidget<NWidgetStacked>(WID_VV_SELECT_REFIT_TURN);
3007 if (nwi->shown_plane + SEL_RT_BASEPLANE != plane) {
3008 this->SelectPlane(plane);
3009 this->SetWidgetDirty(WID_VV_SELECT_REFIT_TURN);
3010 }
3011 }
3012 }
3013
3019 void OnInvalidateData(int data = 0, bool gui_scope = true) override
3020 {
3021 if (data == VIWD_AUTOREPLACE) {
3022 /* Autoreplace replaced the vehicle.
3023 * Nothing to do for this window. */
3024 return;
3025 }
3026
3027 this->UpdateButtonStatus();
3028 }
3029
3030 bool IsNewGRFInspectable() const override
3031 {
3032 return ::IsNewGRFInspectable(GetGrfSpecFeature(Vehicle::Get(this->window_number)->type), this->window_number);
3033 }
3034
3035 void ShowNewGRFInspectWindow() const override
3036 {
3037 ::ShowNewGRFInspectWindow(GetGrfSpecFeature(Vehicle::Get(this->window_number)->type), this->window_number);
3038 }
3039 };
3040
3041
3043 void ShowVehicleViewWindow(const Vehicle *v)
3044 {
3045 AllocateWindowDescFront<VehicleViewWindow>((v->type == VEH_TRAIN) ? &_train_view_desc : &_vehicle_view_desc, v->index);
3046 }
3047
3053 bool VehicleClicked(const Vehicle *v)
3054 {
3055 assert(v != nullptr);
3056 if (!(_thd.place_mode & HT_VEHICLE)) return false;
3057
3058 v = v->First();
3059 if (!v->IsPrimaryVehicle()) return false;
3060
3061 return _thd.GetCallbackWnd()->OnVehicleSelect(v);
3062 }
3063
3064 void StopGlobalFollowVehicle(const Vehicle *v)
3065 {
3066 Window *w = FindWindowById(WC_MAIN_WINDOW, 0);
3067 if (w != nullptr && w->viewport->follow_vehicle == v->index) {
3068 ScrollMainWindowTo(v->x_pos, v->y_pos, v->z_pos, true); // lock the main view on the vehicle's last position
3069 w->viewport->follow_vehicle = INVALID_VEHICLE;
3070 }
3071 }
3072
3073
3082 void CcBuildPrimaryVehicle(const CommandCost &result, TileIndex tile, uint32 p1, uint32 p2, uint32 cmd)
3083 {
3084 if (result.Failed()) return;
3085
3086 const Vehicle *v = Vehicle::Get(_new_vehicle_id);
3087 ShowVehicleViewWindow(v);
3088 }
3089
3095 int GetSingleVehicleWidth(const Vehicle *v, EngineImageType image_type)
3096 {
3097 switch (v->type) {
3098 case VEH_TRAIN:
3099 return Train::From(v)->GetDisplayImageWidth();
3100
3101 case VEH_ROAD:
3102 return RoadVehicle::From(v)->GetDisplayImageWidth();
3103
3104 default:
3105 bool rtl = _current_text_dir == TD_RTL;
3106 VehicleSpriteSeq seq;
3107 v->GetImage(rtl ? DIR_E : DIR_W, image_type, &seq);
3108 Rect rec;
3109 seq.GetBounds(&rec);
3110 return UnScaleGUI(rec.right - rec.left + 1);
3111 }
3112 }
3113
3119 int GetVehicleWidth(const Vehicle *v, EngineImageType image_type)
3120 {
3121 if (v->type == VEH_TRAIN || v->type == VEH_ROAD) {
3122 int vehicle_width = 0;
3123 for (const Vehicle *u = v; u != nullptr; u = u->Next()) {
3124 vehicle_width += GetSingleVehicleWidth(u, image_type);
3125 }
3126 return vehicle_width;
3127 } else {
3128 return GetSingleVehicleWidth(v, image_type);
3129 }
3130 }
3131
3137 void SetMouseCursorVehicle(const Vehicle *v, EngineImageType image_type)
3138 {
3139 bool rtl = _current_text_dir == TD_RTL;
3140
3141 _cursor.sprite_count = 0;
3142 int total_width = 0;
3143 for (; v != nullptr; v = v->HasArticulatedPart() ? v->GetNextArticulatedPart() : nullptr) {
3144 if (total_width >= ScaleGUITrad(2 * (int)VEHICLEINFO_FULL_VEHICLE_WIDTH)) break;
3145
3146 PaletteID pal = (v->vehstatus & VS_CRASHED) ? PALETTE_CRASH : GetVehiclePalette(v);
3147 VehicleSpriteSeq seq;
3148 v->GetImage(rtl ? DIR_E : DIR_W, image_type, &seq);
3149
3150 if (_cursor.sprite_count + seq.count > lengthof(_cursor.sprite_seq)) break;
3151
3152 for (uint i = 0; i < seq.count; ++i) {
3153 PaletteID pal2 = (v->vehstatus & VS_CRASHED) || !seq.seq[i].pal ? pal : seq.seq[i].pal;
3154 _cursor.sprite_seq[_cursor.sprite_count].sprite = seq.seq[i].sprite;
3155 _cursor.sprite_seq[_cursor.sprite_count].pal = pal2;
3156 _cursor.sprite_pos[_cursor.sprite_count].x = rtl ? -total_width : total_width;
3157 _cursor.sprite_pos[_cursor.sprite_count].y = 0;
3158 _cursor.sprite_count++;
3159 }
3160
3161 total_width += GetSingleVehicleWidth(v, image_type);
3162 }
3163
3164 int offs = (ScaleGUITrad(VEHICLEINFO_FULL_VEHICLE_WIDTH) - total_width) / 2;
3165 if (rtl) offs = -offs;
3166 for (uint i = 0; i < _cursor.sprite_count; ++i) {
3167 _cursor.sprite_pos[i].x += offs;
3168 }
3169
3170 UpdateCursorSize();
3171 }
VEH_AIRCRAFT
@ VEH_AIRCRAFT
Aircraft vehicle type.
Definition: vehicle_type.h:27
Train::GetDisplayImageWidth
int GetDisplayImageWidth(Point *offset=nullptr) const
Get the width of a train vehicle image in the GUI.
Definition: train_cmd.cpp:432
IsVehicleRefitable
static bool IsVehicleRefitable(const Vehicle *v)
Checks whether the vehicle may be refitted at the moment.
Definition: vehicle_gui.cpp:2606
WID_VL_AVAILABLE_VEHICLES
@ WID_VL_AVAILABLE_VEHICLES
Available vehicles.
Definition: vehicle_widget.h:72
Vehicle::GetGroundVehicleCache
GroundVehicleCache * GetGroundVehicleCache()
Access the ground vehicle cache of the vehicle.
Definition: vehicle.cpp:2883
Vehicle::IsChainInDepot
virtual bool IsChainInDepot() const
Check whether the whole vehicle chain is in the depot.
Definition: vehicle_base.h:521
TC_FORCED
@ TC_FORCED
Ignore colour changes from strings.
Definition: gfx_type.h:275
VehicleListWindow::BP_HIDE_BUTTONS
@ BP_HIDE_BUTTONS
Show the empty panel.
Definition: vehicle_gui.cpp:1634
VehicleViewWindow::OnPaint
void OnPaint() override
The window must be repainted.
Definition: vehicle_gui.cpp:2741
VehicleViewWindow::SEL_RT_TURN_AROUND
@ SEL_RT_TURN_AROUND
Display 'turn around' button in WID_VV_SELECT_REFIT_TURN stacked widget.
Definition: vehicle_gui.cpp:2626
VehicleOrderID
byte VehicleOrderID
The index of an order within its current vehicle (not pool related)
Definition: order_type.h:15
WD_FRAMERECT_TOP
@ WD_FRAMERECT_TOP
Offset at top to draw the frame rectangular area.
Definition: window_gui.h:62
CountDigitsForAllocatingSpace
uint CountDigitsForAllocatingSpace(uint number)
Get the number of digits of space required for the given number.
Definition: vehicle_gui.cpp:146
CMD_MSG
#define CMD_MSG(x)
Used to combine a StringID with the command.
Definition: command_type.h:372
TileIndex
uint32 TileIndex
The index/ID of a Tile.
Definition: tile_type.h:78
BaseVehicleListWindow::GetActionDropdownSize
Dimension GetActionDropdownSize(bool show_autoreplace, bool show_group)
Compute the size for the Action dropdown.
Definition: vehicle_gui.cpp:227
VehicleGroupLengthSorter
static bool VehicleGroupLengthSorter(const GUIVehicleGroup &a, const GUIVehicleGroup &b)
Sort vehicle groups by the number of vehicles in the group.
Definition: vehicle_gui.cpp:1168
WID_VV_TURN_AROUND
@ WID_VV_TURN_AROUND
Turn this vehicle around.
Definition: vehicle_widget.h:28
ClampToI32
static int32 ClampToI32(const int64 a)
Reduce a signed 64-bit int to a signed 32-bit one.
Definition: math_func.hpp:141
WC_INVALID
@ WC_INVALID
Invalid window.
Definition: window_type.h:700
DoCommand
CommandCost DoCommand(const CommandContainer *container, DoCommandFlag flags)
Shorthand for calling the long DoCommand with a container.
Definition: command.cpp:450
CMD_REVERSE_TRAIN_DIRECTION
@ CMD_REVERSE_TRAIN_DIRECTION
turn a train around
Definition: command_type.h:222
Order::IsType
bool IsType(OrderType type) const
Check whether this order is of the given type.
Definition: order_base.h:61
GUIList::SortType
uint8 SortType() const
Get the sorttype of the list.
Definition: sortlist_type.h:93
VehicleList
std::vector< const Vehicle * > VehicleList
A list of vehicles.
Definition: vehiclelist.h:53
Pool::PoolItem<&_vehicle_pool >::Get
static Titem * Get(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:329
VehicleViewWindow::PlaneSelections
PlaneSelections
Display planes available in the vehicle view window.
Definition: vehicle_gui.cpp:2621
WID_VR_MATRIX
@ WID_VR_MATRIX
Options to refit to.
Definition: vehicle_widget.h:39
ScrollMainWindowToTile
bool ScrollMainWindowToTile(TileIndex tile, bool instant)
Scrolls the viewport of the main window to a given location.
Definition: viewport.cpp:2443
VehicleListWindow::BP_SHOW_BUTTONS
@ BP_SHOW_BUTTONS
Show the buttons.
Definition: vehicle_gui.cpp:1633
WD_MATRIX_RIGHT
@ WD_MATRIX_RIGHT
Offset at right of a matrix cell.
Definition: window_gui.h:77
Vehicle::y_pos
int32 y_pos
y coordinate.
Definition: vehicle_base.h:279
HasAtMostOneBit
static bool HasAtMostOneBit(T value)
Test whether value has at most 1 bit set.
Definition: bitmath_func.hpp:286
VehicleDetailsWindow::GetRoadVehDetailsHeight
uint GetRoadVehDetailsHeight(const Vehicle *v)
Gets the desired height for the road vehicle details panel.
Definition: vehicle_gui.cpp:2124
TDW_TAB_INFO
@ TDW_TAB_INFO
Tab with name and value of the vehicles.
Definition: vehicle_gui.h:25
SetScrollbar
static NWidgetPart SetScrollbar(int index)
Attach a scrollbar to a widget.
Definition: widget_type.h:1094
ShowExtraViewportWindow
void ShowExtraViewportWindow(TileIndex tile=INVALID_TILE)
Show a new Extra Viewport window.
Definition: viewport_gui.cpp:168
CMD_ORDER_REFIT
@ CMD_ORDER_REFIT
change the refit information of an order (for "goto depot" )
Definition: command_type.h:272
CcBuildPrimaryVehicle
void CcBuildPrimaryVehicle(const CommandCost &result, TileIndex tile, uint32 p1, uint32 p2, uint32 cmd)
This is the Callback method after the construction attempt of a primary vehicle.
Definition: vehicle_gui.cpp:3082
GetServiceIntervalClamped
uint16 GetServiceIntervalClamped(uint interval, bool ispercent)
Clamp the service interval to the correct min/max.
Definition: order_cmd.cpp:1918
VehicleListIdentifier::company
CompanyID company
The company associated with this list.
Definition: vehiclelist.h:32
WID_VL_LIST
@ WID_VL_LIST
List of the vehicles.
Definition: vehicle_widget.h:69
GB
static uint GB(const T x, const uint8 s, const uint8 n)
Fetch n bits from x, started at bit s.
Definition: bitmath_func.hpp:32
Vehicle::GetNumManualOrders
VehicleOrderID GetNumManualOrders() const
Get the number of manually added orders this vehicle has.
Definition: vehicle_base.h:704
Vehicle::value
Money value
Value of the vehicle.
Definition: vehicle_base.h:251
VehicleSettings::train_acceleration_model
uint8 train_acceleration_model
realistic acceleration for trains
Definition: settings_type.h:462
Vehicle::x_pos
int32 x_pos
x coordinate.
Definition: vehicle_base.h:278
train.h
Dimension
Dimensions (a width and height) of a rectangle in 2D.
Definition: geometry_type.hpp:27
command_func.h
TE_RISING
@ TE_RISING
Make the text effect slowly go upwards.
Definition: texteff.hpp:21
RefitWindow::OnInvalidateData
void OnInvalidateData(int data=0, bool gui_scope=true) override
Some data on this window has become invalid.
Definition: vehicle_gui.cpp:891
VehicleViewWindow::OnResize
void OnResize() override
Called after the window got resized.
Definition: vehicle_gui.cpp:2981
WID_VL_CAPTION
@ WID_VL_CAPTION
Caption of window.
Definition: vehicle_widget.h:64
Window::DrawSortButtonState
void DrawSortButtonState(int widget, SortButtonState state) const
Draw a sort button's up or down arrow symbol.
Definition: widget.cpp:636
WWT_STICKYBOX
@ WWT_STICKYBOX
Sticky box (at top-right of a window, after WWT_DEFSIZEBOX)
Definition: widget_type.h:64
SetPadding
static NWidgetPart SetPadding(uint8 top, uint8 right, uint8 bottom, uint8 left)
Widget part function for setting additional space around a widget.
Definition: widget_type.h:1045
CursorVars::sprite_count
uint sprite_count
number of sprites to draw
Definition: gfx_type.h:130
Pool::PoolItem<&_vehicle_pool >::GetIfValid
static Titem * GetIfValid(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:340
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:309
WDF_CONSTRUCTION
@ WDF_CONSTRUCTION
This window is used for construction; close it whenever changing company.
Definition: window_gui.h:208
RefitWindow::click_x
int click_x
Position of the first click while dragging.
Definition: vehicle_gui.cpp:481
dropdown_func.h
VehicleDetailsWindow::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: vehicle_gui.cpp:2373
BaseVehicleListWindow::grouping
GroupBy grouping
How we want to group the list.
Definition: vehicle_gui_base.h:79
VehicleGroupTotalProfitThisYearSorter
static bool VehicleGroupTotalProfitThisYearSorter(const GUIVehicleGroup &a, const GUIVehicleGroup &b)
Sort vehicle groups by the total profit this year.
Definition: vehicle_gui.cpp:1174
VehicleListIdentifier
The information about a vehicle list.
Definition: vehiclelist.h:29
CBID_VEHICLE_CARGO_SUFFIX
@ CBID_VEHICLE_CARGO_SUFFIX
Determine the cargo "suffixes" for each refit possibility of a cargo.
Definition: newgrf_callbacks.h:60
RefitWindow::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: vehicle_gui.cpp:999
RefitWindow::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: vehicle_gui.cpp:738
Window::ReInit
void ReInit(int rx=0, int ry=0)
Re-initialize a window, and optionally change its size.
Definition: window.cpp:995
company_base.h
VehicleDetailsWindow::DrawVehicleDetails
static void DrawVehicleDetails(const Vehicle *v, int left, int right, int y, int vscroll_pos, uint vscroll_cap, TrainDetailsWindowTabs det_tab)
Draw the details for the given vehicle at the position of the Details windows.
Definition: vehicle_gui.cpp:2236
DrawRoadVehDetails
void DrawRoadVehDetails(const Vehicle *v, int left, int right, int y)
Draw the details for the given vehicle at the given position.
Definition: roadveh_gui.cpp:30
Vehicle::Next
Vehicle * Next() const
Get the next vehicle of this vehicle.
Definition: vehicle_base.h:592
SpecializedVehicle::Next
T * Next() const
Get next vehicle in the chain.
Definition: vehicle_base.h:1077
NWID_HSCROLLBAR
@ NWID_HSCROLLBAR
Horizontal scrollbar.
Definition: widget_type.h:81
RefitWindow::information_width
uint information_width
Width required for correctly displaying all cargoes in the information panel.
Definition: vehicle_gui.cpp:474
WD_MATRIX_TOP
@ WD_MATRIX_TOP
Offset at top of a matrix cell.
Definition: window_gui.h:78
WID_VL_GROUP_BY_PULLDOWN
@ WID_VL_GROUP_BY_PULLDOWN
Group by dropdown list.
Definition: vehicle_widget.h:66
Vehicle::GetDisplayMaxSpeed
virtual int GetDisplayMaxSpeed() const
Gets the maximum speed in km-ish/h that can be sent into SetDParam for string processing.
Definition: vehicle_base.h:497
TrainDetailsWindowTabs
TrainDetailsWindowTabs
The tabs in the train details window.
Definition: vehicle_gui.h:23
NWidgetViewport
Nested widget to display a viewport in a window.
Definition: widget_type.h:574
WWT_CAPTION
@ WWT_CAPTION
Window caption (window title between closebox and stickybox)
Definition: widget_type.h:59
Scrollbar::ScrollTowards
void ScrollTowards(int position)
Scroll towards the given position; if the item is visible nothing happens, otherwise it will be shown...
Definition: widget_type.h:730
Order::GetDestination
DestinationID GetDestination() const
Gets the destination of this order.
Definition: order_base.h:94
Vehicle::z_pos
int32 z_pos
z coordinate.
Definition: vehicle_base.h:280
RefitWindow::selected_vehicle
VehicleID selected_vehicle
First vehicle in the current selection.
Definition: vehicle_gui.cpp:482
VehicleDetailsWindow::OnInvalidateData
void OnInvalidateData(int data=0, bool gui_scope=true) override
Some data on this window has become invalid.
Definition: vehicle_gui.cpp:2100
Scrollbar::GetScrolledRowFromWidget
int GetScrolledRowFromWidget(int clickpos, const Window *const w, int widget, int padding=0, int line_height=-1) const
Compute the row of a scrolled widget that a user clicked in.
Definition: widget.cpp:1966
VehicleDetailsWindow::VehicleDetailsWindow
VehicleDetailsWindow(WindowDesc *desc, WindowNumber window_number)
Initialize a newly created vehicle details window.
Definition: vehicle_gui.cpp:2083
WF_DISABLE_VP_SCROLL
@ WF_DISABLE_VP_SCROLL
Window does not do autoscroll,.
Definition: window_gui.h:239
RemapCoords
static Point RemapCoords(int x, int y, int z)
Map 3D world or tile coordinate to equivalent 2D coordinate as used in the viewports and smallmap.
Definition: landscape.h:82
Window::viewport
ViewportData * viewport
Pointer to viewport data, if present.
Definition: window_gui.h:326
GetVehicleSet
void GetVehicleSet(VehicleSet &set, Vehicle *v, uint8 num_vehicles)
Calculates the set of vehicles that will be affected by a given selection.
Definition: vehicle.cpp:2946
DropDownList
std::vector< std::unique_ptr< const DropDownListItem > > DropDownList
A drop down list is a collection of drop down list items.
Definition: dropdown_type.h:100
DrawVehicleImage
void DrawVehicleImage(const Vehicle *v, int left, int right, int y, VehicleID selection, EngineImageType image_type, int skip)
Draws an image of a vehicle chain.
Definition: vehicle_gui.cpp:1468
Vehicle::vehstatus
byte vehstatus
Status.
Definition: vehicle_base.h:326
WID_VR_CAPTION
@ WID_VR_CAPTION
Caption of window.
Definition: vehicle_widget.h:34
BaseConsist::name
std::string name
Name of vehicle.
Definition: base_consist.h:19
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
RefitWindow::OnPaint
void OnPaint() override
The window must be repainted.
Definition: vehicle_gui.cpp:717
group_gui.h
Window::CreateNestedTree
void CreateNestedTree(bool fill_nested=true)
Perform the first part of the initialization of a nested widget tree.
Definition: window.cpp:1832
DEPOT_MASS_SEND
@ DEPOT_MASS_SEND
Tells that it's a mass send to depot command (type in VLW flag)
Definition: vehicle_type.h:67
Pool::PoolItem::index
Tindex index
Index of this pool item.
Definition: pool_type.hpp:227
CargoSpec::Get
static CargoSpec * Get(size_t index)
Retrieve cargo details for the given cargo ID.
Definition: cargotype.h:117
NWID_HORIZONTAL
@ NWID_HORIZONTAL
Horizontal container.
Definition: widget_type.h:73
CargoArray
Class for storing amounts of cargo.
Definition: cargo_type.h:81
PalSpriteID::sprite
SpriteID sprite
The 'real' sprite.
Definition: gfx_type.h:23
Vehicle::group_id
GroupID group_id
Index of group Pool array.
Definition: vehicle_base.h:335
maxdim
Dimension maxdim(const Dimension &d1, const Dimension &d2)
Compute bounding box of both dimensions.
Definition: geometry_func.cpp:22
WWT_MATRIX
@ WWT_MATRIX
Grid of rows and columns.
Definition: widget_type.h:57
FindWindowById
Window * FindWindowById(WindowClass cls, WindowNumber number)
Find a window by its class and window number.
Definition: window.cpp:1133
CcStartStopVehicle
void CcStartStopVehicle(const CommandCost &result, TileIndex tile, uint32 p1, uint32 p2, uint32 cmd)
This is the Callback method after attempting to start/stop a vehicle.
Definition: vehicle_gui.cpp:2582
BaseVehicleListWindow::sorting
Listing * sorting
Pointer to the vehicle type related sorting.
Definition: vehicle_gui_base.h:82
HasBit
static bool HasBit(const T x, const uint8 y)
Checks if a bit in a value is set.
Definition: bitmath_func.hpp:103
UnScaleGUI
static int UnScaleGUI(int value)
Short-hand to apply GUI zoom level.
Definition: zoom_func.h:66
RefitOption::subtype
byte subtype
Subcargo to use.
Definition: vehicle_gui.cpp:378
VehicleViewWindow::OnInvalidateData
void OnInvalidateData(int data=0, bool gui_scope=true) override
Some data on this window has become invalid.
Definition: vehicle_gui.cpp:3019
_returned_mail_refit_capacity
uint16 _returned_mail_refit_capacity
Stores the mail capacity after a refit operation (Aircraft only).
Definition: vehicle.cpp:86
VehicleListWindow::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: vehicle_gui.cpp:1798
ShowCompanyGroup
void ShowCompanyGroup(CompanyID company, VehicleType vehicle_type, GroupID group=INVALID_GROUP, bool need_existing_window=false)
Show the group window for the given company and vehicle type.
Definition: group_gui.cpp:1098
_vehicle_view_zoom_levels
static const ZoomLevel _vehicle_view_zoom_levels[]
Zoom levels for vehicle views indexed by vehicle type.
Definition: vehicle_gui.cpp:2534
include
bool include(std::vector< T > &vec, const T &item)
Helper function to append an item to a vector if it is not already contained Consider using std::set,...
Definition: smallvec_type.hpp:27
VehicleViewWindow::SEL_DC_BASEPLANE
@ SEL_DC_BASEPLANE
First plane of the WID_VV_SELECT_DEPOT_CLONE stacked widget.
Definition: vehicle_gui.cpp:2628
Scrollbar::SetCount
void SetCount(int num)
Sets the number of elements in the list.
Definition: widget_type.h:669
_ctrl_pressed
bool _ctrl_pressed
Is Ctrl pressed?
Definition: gfx.cpp:35
WID_VL_START_ALL
@ WID_VL_START_ALL
Start all button.
Definition: vehicle_widget.h:75
Vehicle::GetGRF
const GRFFile * GetGRF() const
Retrieve the NewGRF the vehicle is tied to.
Definition: vehicle.cpp:751
FOR_ALL_SORTED_CARGOSPECS
#define FOR_ALL_SORTED_CARGOSPECS(var)
Loop header for iterating over cargoes, sorted by name.
Definition: cargotype.h:164
VehicleViewWindow::SelectPlane
void SelectPlane(PlaneSelections plane)
Display a plane in the window.
Definition: vehicle_gui.cpp:2637
VehicleCommandTranslation
VehicleCommandTranslation
Command indices for the _vehicle_command_translation_table.
Definition: vehicle_gui.cpp:2547
WID_VD_SERVICE_INTERVAL_DROPDOWN
@ WID_VD_SERVICE_INTERVAL_DROPDOWN
Dropdown to select default/days/percent service interval.
Definition: vehicle_widget.h:51
TextColour
TextColour
Colour of the strings, see _string_colourmap in table/string_colours.h or docs/ottd-colourtext-palett...
Definition: gfx_type.h:250
SetResize
static NWidgetPart SetResize(int16 dx, int16 dy)
Widget part function for setting the resize step.
Definition: widget_type.h:929
zoom_func.h
autoreplace_gui.h
aircraft.h
GetUnitNumberDigits
uint GetUnitNumberDigits(VehicleList &vehicles)
Get the number of digits the biggest unit number of a set of vehicles has.
Definition: vehicle_gui.cpp:165
GUIVehicleGroup::vehicles_begin
VehicleList::const_iterator vehicles_begin
Pointer to beginning element of this vehicle group.
Definition: vehicle_gui_base.h:28
ZoomLevel
ZoomLevel
All zoom levels we know.
Definition: zoom_type.h:21
VehicleDetailsWindow::tab
TrainDetailsWindowTabs tab
For train vehicles: which tab is displayed.
Definition: vehicle_gui.cpp:2079
_settings_client
ClientSettings _settings_client
The current settings for this game.
Definition: settings.cpp:79
VehicleListWindow::SetStringParameters
void SetStringParameters(int widget) const override
Initialize string parameters for a widget.
Definition: vehicle_gui.cpp:1706
ChangeVehicleViewWindow
void ChangeVehicleViewWindow(VehicleID from_index, VehicleID to_index)
Report a change in vehicle IDs (due to autoreplace) to affected vehicle windows.
Definition: vehicle_gui.cpp:1354
EIT_IN_DETAILS
@ EIT_IN_DETAILS
Vehicle drawn in vehicle details, refit window, ...
Definition: vehicle_type.h:88
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:640
WindowDesc::cls
WindowClass cls
Class of the window,.
Definition: window_gui.h:175
CargoSpec
Specification of a cargo type.
Definition: cargotype.h:55
SZSP_HORIZONTAL
@ SZSP_HORIZONTAL
Display plane with zero size vertically, and filling and resizing horizontally.
Definition: widget_type.h:388
WID_VV_VIEWPORT
@ WID_VV_VIEWPORT
Viewport widget.
Definition: vehicle_widget.h:16
WC_VEHICLE_TIMETABLE
@ WC_VEHICLE_TIMETABLE
Vehicle timetable; Window numbers:
Definition: window_type.h:217
newgrf_debug.h
Window::owner
Owner owner
The owner of the content shown in this window. Company colour is acquired from this variable.
Definition: window_gui.h:324
WWT_PUSHARROWBTN
@ WWT_PUSHARROWBTN
Normal push-button (no toggle button) with arrow caption.
Definition: widget_type.h:104
WindowNumber
int32 WindowNumber
Number to differentiate different windows of the same class.
Definition: window_type.h:711
WID_VV_SHOW_ORDERS
@ WID_VV_SHOW_ORDERS
Show the orders of this vehicle.
Definition: vehicle_widget.h:23
DIR_W
@ DIR_W
West.
Definition: direction_type.h:32
Vehicle::GetNextArticulatedPart
Vehicle * GetNextArticulatedPart() const
Get the next part of an articulated engine.
Definition: vehicle_base.h:923
NWidgetCore::tool_tip
StringID tool_tip
Tooltip of the widget.
Definition: widget_type.h:305
EngineImageType
EngineImageType
Visualisation contexts of vehicles and engines.
Definition: vehicle_type.h:85
CBM_VEHICLE_CARGO_SUFFIX
@ CBM_VEHICLE_CARGO_SUFFIX
Show suffix after cargo name.
Definition: newgrf_callbacks.h:294
Engine
Definition: engine_base.h:21
VEH_ROAD
@ VEH_ROAD
Road vehicle type.
Definition: vehicle_type.h:25
Vehicle::cur_speed
uint16 cur_speed
current speed
Definition: vehicle_base.h:302
Vehicle
Vehicle data structure.
Definition: vehicle_base.h:222
Vehicle::IsPrimaryVehicle
virtual bool IsPrimaryVehicle() const
Whether this is the primary vehicle in the chain.
Definition: vehicle_base.h:444
Vehicle::IsGroundVehicle
bool IsGroundVehicle() const
Check if the vehicle is a ground vehicle.
Definition: vehicle_base.h:482
SA_HOR_CENTER
@ SA_HOR_CENTER
Horizontally center the text.
Definition: gfx_func.h:97
VehicleDefaultSettings::servint_ships
uint16 servint_ships
service interval for ships
Definition: settings_type.h:545
GUIList::SetSortType
void SetSortType(uint8 n_type)
Set the sorttype of the list.
Definition: sortlist_type.h:103
WID_VL_SCROLLBAR
@ WID_VL_SCROLLBAR
Scrollbar for the list.
Definition: vehicle_widget.h:70
Vehicle::owner
Owner owner
Which company owns the vehicle?
Definition: vehicle_base.h:283
CMD_TURN_ROADVEH
@ CMD_TURN_ROADVEH
turn a road vehicle around
Definition: command_type.h:254
Owner
Owner
Enum for all companies/owners.
Definition: company_type.h:18
VehicleGroupTotalProfitLastYearSorter
static bool VehicleGroupTotalProfitLastYearSorter(const GUIVehicleGroup &a, const GUIVehicleGroup &b)
Sort vehicle groups by the total profit last year.
Definition: vehicle_gui.cpp:1180
Scrollbar
Scrollbar data structure.
Definition: widget_type.h:588
GetVehicleCallback
uint16 GetVehicleCallback(CallbackID callback, uint32 param1, uint32 param2, EngineID engine, const Vehicle *v)
Evaluate a newgrf callback for vehicles.
Definition: newgrf_engine.cpp:1188
ShowTimetableWindow
void ShowTimetableWindow(const Vehicle *v)
Show the timetable for a given vehicle.
Definition: timetable_gui.cpp:708
WID_VD_DETAILS_CAPACITY_OF_EACH
@ WID_VD_DETAILS_CAPACITY_OF_EACH
Show the capacity of all train parts.
Definition: vehicle_widget.h:58
VehicleAgeSorter
static bool VehicleAgeSorter(const Vehicle *const &a, const Vehicle *const &b)
Sort vehicles by their age.
Definition: vehicle_gui.cpp:1225
_colour_gradient
byte _colour_gradient[COLOUR_END][8]
All 16 colour gradients 8 colours per gradient from darkest (0) to lightest (7)
Definition: gfx.cpp:52
WID_VV_FORCE_PROCEED
@ WID_VV_FORCE_PROCEED
Force this vehicle to pass a signal at danger.
Definition: vehicle_widget.h:29
CursorVars::sprite_pos
Point sprite_pos[16]
relative position of individual sprites
Definition: gfx_type.h:129
VehicleListWindow
Window for the (old) vehicle listing.
Definition: vehicle_gui.cpp:1629
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:199
VehicleListWindow::OnDropdownSelect
void OnDropdownSelect(int widget, int index) override
A dropdown option associated to this window has been selected.
Definition: vehicle_gui.cpp:1862
NWidgetPart
Partial widget specification to allow NWidgets to be written nested.
Definition: widget_type.h:909
RefitWindow::num_vehicles
uint8 num_vehicles
Number of selected vehicles.
Definition: vehicle_gui.cpp:483
SetDataTip
static NWidgetPart SetDataTip(uint32 data, StringID tip)
Widget part function for setting the data and tooltip.
Definition: widget_type.h:1013
_vehicle_view_desc
static WindowDesc _vehicle_view_desc(WDP_AUTO, "view_vehicle", 250, 116, WC_VEHICLE_VIEW, WC_NONE, 0, _nested_vehicle_view_widgets, lengthof(_nested_vehicle_view_widgets))
Vehicle view window descriptor for all vehicles but trains.
Vehicle::breakdowns_since_last_service
byte breakdowns_since_last_service
Counter for the amount of breakdowns.
Definition: vehicle_base.h:275
NWidgetCore::widget_data
uint32 widget_data
Data of the widget.
Definition: widget_type.h:304
RefitWindow::sprite_left
int sprite_left
Left position of the vehicle sprite.
Definition: vehicle_gui.cpp:478
VehicleDetailsWindow::IsVehicleServiceIntervalEnabled
static bool IsVehicleServiceIntervalEnabled(const VehicleType vehicle_type, CompanyID company_id)
Checks whether service interval is enabled for the vehicle.
Definition: vehicle_gui.cpp:2213
WD_IMGBTN_BOTTOM
@ WD_IMGBTN_BOTTOM
Bottom offset of image in the button.
Definition: window_gui.h:41
GetStringBoundingBox
Dimension GetStringBoundingBox(const char *str, FontSize start_fontsize)
Return the string dimension in pixels.
Definition: gfx.cpp:842
textbuf_gui.h
VehicleViewWindow::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: vehicle_gui.cpp:2881
RefitWindow::auto_refit
bool auto_refit
Select cargo for auto-refitting.
Definition: vehicle_gui.cpp:484
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:763
CountBits
static uint CountBits(T value)
Counts the number of set bits in a variable.
Definition: bitmath_func.hpp:251
QSF_LEN_IN_CHARS
@ QSF_LEN_IN_CHARS
the length of the string is counted in characters
Definition: textbuf_gui.h:22
VehicleDetailsWindow::SetStringParameters
void SetStringParameters(int widget) const override
Initialize string parameters for a widget.
Definition: vehicle_gui.cpp:2247
Vehicle::IsArticulatedPart
bool IsArticulatedPart() const
Check if the vehicle is an articulated part of an engine.
Definition: vehicle_base.h:904
WID_VR_REFIT
@ WID_VR_REFIT
Perform the refit.
Definition: vehicle_widget.h:42
VehicleListWindow::OnResize
void OnResize() override
Called after the window got resized.
Definition: vehicle_gui.cpp:1904
Order::GetType
OrderType GetType() const
Get the type of order of this order.
Definition: order_base.h:67
Aircraft
Aircraft, helicopters, rotors and their shadows belong to this class.
Definition: aircraft.h:74
UpdateCursorSize
void UpdateCursorSize()
Update cursor dimension.
Definition: gfx.cpp:1666
SpriteID
uint32 SpriteID
The number of a sprite, without mapping bits and colourtables.
Definition: gfx_type.h:17
ALL_GROUP
static const GroupID ALL_GROUP
All vehicles are in this group.
Definition: group_type.h:16
RefitWindow::list
SubtypeList list[NUM_CARGO]
List of refit subtypes available for each sorted cargo.
Definition: vehicle_gui.cpp:472
TDW_TAB_TOTALS
@ TDW_TAB_TOTALS
Tab with sum of total cargo transported.
Definition: vehicle_gui.h:27
WindowDesc
High level window description.
Definition: window_gui.h:166
GetGrfSpecFeature
GrfSpecFeature GetGrfSpecFeature(TileIndex tile)
Get the GrfSpecFeature associated with the tile.
Definition: newgrf_debug_gui.cpp:768
WID_VR_SHOW_HSCROLLBAR
@ WID_VR_SHOW_HSCROLLBAR
Selection widget for the horizontal scrollbar.
Definition: vehicle_widget.h:36
RefitWindow::sel
int sel[2]
Index in refit options, sel[0] == -1 if nothing is selected.
Definition: vehicle_gui.cpp:470
WID_VV_SHOW_DETAILS
@ WID_VV_SHOW_DETAILS
Show details of this vehicle.
Definition: vehicle_widget.h:24
GetRailTypeInfo
static const RailtypeInfo * GetRailTypeInfo(RailType railtype)
Returns a pointer to the Railtype information for a given railtype.
Definition: rail.h:304
Vehicle::GetDisplayRunningCost
Money GetDisplayRunningCost() const
Gets the running cost of a vehicle that can be sent into SetDParam for string processing.
Definition: vehicle_base.h:571
ShowVehicleDetailsWindow
static void ShowVehicleDetailsWindow(const Vehicle *v)
Shows the vehicle details window of the given vehicle.
Definition: vehicle_gui.cpp:2453
Vehicle::breakdown_ctr
byte breakdown_ctr
Counter for managing breakdown events.
Definition: vehicle_base.h:273
CargoSpec::Index
CargoID Index() const
Determines index of this cargospec.
Definition: cargotype.h:88
EngineID
uint16 EngineID
Unique identification number of an engine.
Definition: engine_type.h:21
BaseVehicleListWindow::vli
VehicleListIdentifier vli
Identifier of the vehicle list we want to currently show.
Definition: vehicle_gui_base.h:85
BaseVehicleListWindow::BuildActionDropdownList
DropDownList BuildActionDropdownList(bool show_autoreplace, bool show_group)
Display the Action dropdown window.
Definition: vehicle_gui.cpp:249
GroundVehicleCache::cached_total_length
uint16 cached_total_length
Length of the whole vehicle (valid only for the first engine).
Definition: ground_vehicle.hpp:42
EF_AUTO_REFIT
@ EF_AUTO_REFIT
Automatic refitting is allowed.
Definition: engine_type.h:158
Vehicle::GetDisplayProfitThisYear
Money GetDisplayProfitThisYear() const
Gets the profit vehicle had this year.
Definition: vehicle_base.h:577
GUIList::IsDescSortOrder
bool IsDescSortOrder() const
Check if the sort order is descending.
Definition: sortlist_type.h:223
RefitWindow::SetStringParameters
void SetStringParameters(int widget) const override
Initialize string parameters for a widget.
Definition: vehicle_gui.cpp:756
WDP_AUTO
@ WDP_AUTO
Find a place automatically.
Definition: window_gui.h:154
Vehicle::GetDisplaySpeed
virtual int GetDisplaySpeed() const
Gets the speed in km-ish/h that can be sent into SetDParam for string processing.
Definition: vehicle_base.h:491
GroundVehicleCache
Cached, frequently calculated values.
Definition: ground_vehicle.hpp:29
timetable.h
WID_VR_HSCROLLBAR
@ WID_VR_HSCROLLBAR
Horizontal scrollbar or the vehicle display.
Definition: vehicle_widget.h:37
WWT_PUSHBTN
@ WWT_PUSHBTN
Normal push-button (no toggle button) with custom drawing.
Definition: widget_type.h:101
Window::resize
ResizeInfo resize
Resize information.
Definition: window_gui.h:322
GetVehicleHeight
static uint GetVehicleHeight(VehicleType type)
Get the height of a single vehicle in the GUIs.
Definition: vehicle_gui.h:68
CommandCost
Common return value for all commands.
Definition: command_type.h:23
VehicleListWindow::OnPaint
void OnPaint() override
The window must be repainted.
Definition: vehicle_gui.cpp:1763
VRF_TRAIN_STUCK
@ VRF_TRAIN_STUCK
Train can't get a path reservation.
Definition: train.h:32
VehicleViewWindow::SEL_DC_GOTO_DEPOT
@ SEL_DC_GOTO_DEPOT
Display 'goto depot' button in WID_VV_SELECT_DEPOT_CLONE stacked widget.
Definition: vehicle_gui.cpp:2622
WC_VEHICLE_VIEW
@ WC_VEHICLE_VIEW
Vehicle view; Window numbers:
Definition: window_type.h:332
NWidgetViewport::UpdateViewportCoordinates
void UpdateViewportCoordinates(Window *w)
Update the position and size of the viewport (after eg a resize).
Definition: widget.cpp:1943
WID_VL_STOP_ALL
@ WID_VL_STOP_ALL
Stop all button.
Definition: vehicle_widget.h:74
tilehighlight_func.h
_train_view_desc
static WindowDesc _train_view_desc(WDP_AUTO, "view_vehicle_train", 250, 134, WC_VEHICLE_VIEW, WC_NONE, 0, _nested_vehicle_view_widgets, lengthof(_nested_vehicle_view_widgets))
Vehicle view window descriptor for trains.
GetUnionOfArticulatedRefitMasks
CargoTypes GetUnionOfArticulatedRefitMasks(EngineID engine, bool include_initial_cargo_type)
Ors the refit_masks of all articulated parts.
Definition: articulated_vehicles.cpp:255
DoCommandP
bool DoCommandP(const CommandContainer *container, bool my_cmd)
Shortcut for the long DoCommandP when having a container with the data.
Definition: command.cpp:541
StartStopVehicle
void StartStopVehicle(const Vehicle *v, bool texteffect)
Executes CMD_START_STOP_VEHICLE for given vehicle.
Definition: vehicle_gui.cpp:2599
WID_VL_SORT_ORDER
@ WID_VL_SORT_ORDER
Sort order.
Definition: vehicle_widget.h:67
INVALID_VEH_ORDER_ID
static const VehicleOrderID INVALID_VEH_ORDER_ID
Invalid vehicle order index (sentinel)
Definition: order_type.h:21
NWID_VIEWPORT
@ NWID_VIEWPORT
Nested widget containing a viewport.
Definition: widget_type.h:79
ShowCompanyGroupForVehicle
void ShowCompanyGroupForVehicle(const Vehicle *v)
Show the group window for the given vehicle.
Definition: group_gui.cpp:1117
VEH_COMPANY_END
@ VEH_COMPANY_END
Last company-ownable type.
Definition: vehicle_type.h:29
WID_VD_DETAILS_TRAIN_VEHICLES
@ WID_VD_DETAILS_TRAIN_VEHICLES
Show all parts of the train with their description.
Definition: vehicle_widget.h:57
WID_VD_MIDDLE_DETAILS
@ WID_VD_MIDDLE_DETAILS
Details for non-trains.
Definition: vehicle_widget.h:53
EngineInfo::callback_mask
byte callback_mask
Bitmask of vehicle callbacks that have to be called.
Definition: engine_type.h:143
DIR_E
@ DIR_E
East.
Definition: direction_type.h:28
_nested_nontrain_vehicle_details_widgets
static const NWidgetPart _nested_nontrain_vehicle_details_widgets[]
Vehicle details widgets (other than train).
Definition: vehicle_gui.cpp:2005
TileHighlightData::window_number
WindowNumber window_number
The WindowNumber of the window that is responsible for the selection mode.
Definition: tilehighlight_type.h:69
Window::height
int height
Height of the window (number of pixels down in y direction)
Definition: window_gui.h:320
VehicleClicked
bool VehicleClicked(const Vehicle *v)
Dispatch a "vehicle selected" event if any window waits for it.
Definition: vehicle_gui.cpp:3053
VehicleModelSorter
static bool VehicleModelSorter(const Vehicle *const &a, const Vehicle *const &b)
Sort vehicles by model.
Definition: vehicle_gui.cpp:1279
Vehicle::tile
TileIndex tile
Current tile index.
Definition: vehicle_base.h:240
VehicleGroupAverageProfitLastYearSorter
static bool VehicleGroupAverageProfitLastYearSorter(const GUIVehicleGroup &a, const GUIVehicleGroup &b)
Sort vehicle groups by the average profit last year.
Definition: vehicle_gui.cpp:1192
BaseVehicleListWindow
Definition: vehicle_gui_base.h:70
DEBUG
#define DEBUG(name, level,...)
Output a line of debugging information.
Definition: debug.h:35
VehicleProfitThisYearSorter
static bool VehicleProfitThisYearSorter(const Vehicle *const &a, const Vehicle *const &b)
Sort vehicles by this year profit.
Definition: vehicle_gui.cpp:1232
INVALID_VEHICLE
static const VehicleID INVALID_VEHICLE
Constant representing a non-existing vehicle.
Definition: vehicle_type.h:55
ZOOM_LVL_ROADVEH
@ ZOOM_LVL_ROADVEH
Default zoom level for the road vehicle view.
Definition: zoom_type.h:42
Window::SetDirty
void SetDirty() const
Mark entire window as dirty (in need of re-paint)
Definition: window.cpp:984
WID_VL_SORT_BY_PULLDOWN
@ WID_VL_SORT_BY_PULLDOWN
Sort by dropdown list.
Definition: vehicle_widget.h:68
VehicleViewWindow::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: vehicle_gui.cpp:2972
GUIList::SetListing
void SetListing(Listing l)
Import sort conditions.
Definition: sortlist_type.h:130
Vehicle::engine_type
EngineID engine_type
The type of engine used for this vehicle.
Definition: vehicle_base.h:297
RefitOption::operator!=
bool operator!=(const RefitOption &other) const
Inequality operator for RefitOption.
Definition: vehicle_gui.cpp:386
WD_FRAMERECT_LEFT
@ WD_FRAMERECT_LEFT
Offset at left to draw the frame rectangular area.
Definition: window_gui.h:60
VS_CRASHED
@ VS_CRASHED
Vehicle is crashed.
Definition: vehicle_base.h:37
CMD_CHANGE_SERVICE_INT
@ CMD_CHANGE_SERVICE_INT
change the server interval of a vehicle
Definition: command_type.h:230
VehicleSpriteSeq
Sprite sequence for a vehicle part.
Definition: vehicle_base.h:128
WID_VV_RENAME
@ WID_VV_RENAME
Rename vehicle.
Definition: vehicle_widget.h:18
SpecializedStation< Station, false >::IsExpected
static bool IsExpected(const BaseStation *st)
Helper for checking whether the given station is of this type.
Definition: base_station_base.h:200
VehicleMaxSpeedSorter
static bool VehicleMaxSpeedSorter(const Vehicle *const &a, const Vehicle *const &b)
Sort vehicles by their max speed.
Definition: vehicle_gui.cpp:1272
WD_FRAMERECT_RIGHT
@ WD_FRAMERECT_RIGHT
Offset at right to draw the frame rectangular area.
Definition: window_gui.h:61
DrawTrainImage
void DrawTrainImage(const Train *v, int left, int right, int y, VehicleID selection, EngineImageType image_type, int skip, VehicleID drag_dest)
Draws an image of a whole train.
Definition: train_gui.cpp:92
WD_FRAMERECT_BOTTOM
@ WD_FRAMERECT_BOTTOM
Offset at bottom to draw the frame rectangular area.
Definition: window_gui.h:63
CommandCost::Failed
bool Failed() const
Did this command fail?
Definition: command_type.h:159
WWT_PUSHTXTBTN
@ WWT_PUSHTXTBTN
Normal push-button (no toggle button) with text caption.
Definition: widget_type.h:102
vehicle_gui_base.h
NWidgetBase
Baseclass for nested widgets.
Definition: widget_type.h:124
Vehicle::current_order
Order current_order
The current order (+ status, like: loading)
Definition: vehicle_base.h:327
_cargo_mask
CargoTypes _cargo_mask
Bitmask of cargo types available.
Definition: cargotype.cpp:28
Date
int32 Date
The type to store our dates in.
Definition: date_type.h:14
Window::OnVehicleSelect
virtual bool OnVehicleSelect(const struct Vehicle *v)
The user clicked on a vehicle while HT_VEHICLE has been set.
Definition: window_gui.h:760
WID_VL_MANAGE_VEHICLES_DROPDOWN
@ WID_VL_MANAGE_VEHICLES_DROPDOWN
Manage vehicles dropdown list.
Definition: vehicle_widget.h:73
Vehicle::max_age
Date max_age
Maximum age.
Definition: vehicle_base.h:269
RefitWindow::vscroll
Scrollbar * vscroll
The main scrollbar.
Definition: vehicle_gui.cpp:475
SPR_CLONE_TRAIN
static const SpriteID SPR_CLONE_TRAIN
Clone vehicles stuff.
Definition: sprites.h:100
ShowDropDownList
void ShowDropDownList(Window *w, DropDownList &&list, int selected, int button, uint width, bool auto_width, bool instant_close)
Show a drop down list.
Definition: dropdown.cpp:453
GetVehicleListHeight
uint GetVehicleListHeight(VehicleType type, uint divisor)
Get the height of a vehicle in the vehicle list GUIs.
Definition: vehicle_gui.cpp:1485
SetMatrixDataTip
static NWidgetPart SetMatrixDataTip(uint8 cols, uint8 rows, StringID tip)
Widget part function for setting the data and tooltip of WWT_MATRIX widgets.
Definition: widget_type.h:1031
VehicleListIdentifier::Pack
uint32 Pack() const
Pack a VehicleListIdentifier in a single uint32.
Definition: vehiclelist.cpp:21
VehicleTimetableDelaySorter
static bool VehicleTimetableDelaySorter(const Vehicle *const &a, const Vehicle *const &b)
Sort vehicles by the timetable delay.
Definition: vehicle_gui.cpp:1313
WID_VD_TOP_DETAILS
@ WID_VD_TOP_DETAILS
Panel with generic details.
Definition: vehicle_widget.h:48
ODATFB_NEAREST_DEPOT
@ ODATFB_NEAREST_DEPOT
Send the vehicle to the nearest depot.
Definition: order_type.h:105
_settings_game
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition: settings.cpp:80
RefitWindow::hscroll
Scrollbar * hscroll
Only used for long vehicles.
Definition: vehicle_gui.cpp:476
VehicleViewWindow::SEL_DC_CLONE
@ SEL_DC_CLONE
Display 'clone vehicle' button in WID_VV_SELECT_DEPOT_CLONE stacked widget.
Definition: vehicle_gui.cpp:2623
VehicleListWindow::ButtonPlanes
ButtonPlanes
Enumeration of planes of the button row at the bottom.
Definition: vehicle_gui.cpp:1632
WC_VEHICLE_DETAILS
@ WC_VEHICLE_DETAILS
Vehicle details; Window numbers:
Definition: window_type.h:193
VehicleViewWindow::ShowNewGRFInspectWindow
void ShowNewGRFInspectWindow() const override
Show the NewGRF inspection window.
Definition: vehicle_gui.cpp:3035
ZOOM_LVL_AIRCRAFT
@ ZOOM_LVL_AIRCRAFT
Default zoom level for the aircraft view.
Definition: zoom_type.h:39
Window::SetWidgetDisabledState
void SetWidgetDisabledState(byte widget_index, bool disab_stat)
Sets the enabled/disabled status of a widget.
Definition: window_gui.h:392
VS_STOPPED
@ VS_STOPPED
Vehicle is stopped by the player.
Definition: vehicle_base.h:31
Window::parent
Window * parent
Parent window.
Definition: window_gui.h:337
Vehicle::GetGRFID
uint32 GetGRFID() const
Retrieve the GRF ID of the NewGRF the vehicle is tied to.
Definition: vehicle.cpp:761
_local_company
CompanyID _local_company
Company controlled by the human player at this client. Can also be COMPANY_SPECTATOR.
Definition: company_cmd.cpp:46
Vehicle::GetEngine
const Engine * GetEngine() const
Retrieves the engine of the vehicle.
Definition: vehicle.cpp:741
WID_VV_SELECT_REFIT_TURN
@ WID_VV_SELECT_REFIT_TURN
Selection widget between 'refit' and 'turn around' buttons.
Definition: vehicle_widget.h:27
DropDownListStringItem
Common string list item.
Definition: dropdown_type.h:39
_vehicle_command_translation_table
static const uint32 _vehicle_command_translation_table[][4]
Command codes for the shared buttons indexed by VehicleCommandTranslation and vehicle type.
Definition: vehicle_gui.cpp:2554
GenerateVehicleSortList
bool GenerateVehicleSortList(VehicleList *list, const VehicleListIdentifier &vli)
Generate a list of vehicles based on window type.
Definition: vehiclelist.cpp:113
safeguards.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:1131
Window::left
int left
x position of left edge of the window
Definition: window_gui.h:317
VehicleGroupAverageProfitThisYearSorter
static bool VehicleGroupAverageProfitThisYearSorter(const GUIVehicleGroup &a, const GUIVehicleGroup &b)
Sort vehicle groups by the average profit this year.
Definition: vehicle_gui.cpp:1186
Window::flags
WindowFlags flags
Window flags.
Definition: window_gui.h:310
Train
'Train' is either a loco or a wagon.
Definition: train.h:85
CommandCost::GetCost
Money GetCost() const
The costs as made up to this moment.
Definition: command_type.h:82
DEFAULT_GROUP
static const GroupID DEFAULT_GROUP
Ungrouped vehicles are in this group.
Definition: group_type.h:17
WID_VD_MATRIX
@ WID_VD_MATRIX
List of details for trains.
Definition: vehicle_widget.h:54
DepotCommand
DepotCommand
Flags to add to p1 for goto depot commands.
Definition: vehicle_type.h:65
GetGRFStringID
StringID GetGRFStringID(uint32 grfid, StringID stringid)
Returns the index for this stringid associated with its grfID.
Definition: newgrf_text.cpp:602
GroundVehicleCache::cached_max_te
uint32 cached_max_te
Maximum tractive effort of consist (valid only for the first engine).
Definition: ground_vehicle.hpp:33
WindowClass
WindowClass
Window classes.
Definition: window_type.h:37
SetMouseCursorVehicle
void SetMouseCursorVehicle(const Vehicle *v, EngineImageType image_type)
Set the mouse cursor to look like a vehicle.
Definition: vehicle_gui.cpp:3137
RefitWindow::DrawWidget
void DrawWidget(const Rect &r, int widget) const override
Draw the contents of a nested widget.
Definition: vehicle_gui.cpp:808
VehicleListWindow::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: vehicle_gui.cpp:1669
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:978
VehicleViewWindow::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: vehicle_gui.cpp:2719
newgrf_text.h
ZOOM_LVL_SHIP
@ ZOOM_LVL_SHIP
Default zoom level for the ship view.
Definition: zoom_type.h:40
WID_VL_HIDE_BUTTONS
@ WID_VL_HIDE_BUTTONS
Selection to hide the buttons.
Definition: vehicle_widget.h:71
VehicleDefaultSettings
Default settings for vehicles.
Definition: settings_type.h:540
RefitWindow::OnResize
void OnResize() override
Called after the window got resized.
Definition: vehicle_gui.cpp:1067
Point
Coordinates of a point in 2D.
Definition: geometry_type.hpp:21
ScrollMainWindowTo
bool ScrollMainWindowTo(int x, int y, int z, bool instant)
Scrolls the main window to given coordinates.
Definition: smallmap_gui.cpp:1869
WID_VR_SCROLLBAR
@ WID_VR_SCROLLBAR
Scrollbar for the refit options.
Definition: vehicle_widget.h:40
DrawShipImage
void DrawShipImage(const Vehicle *v, int left, int right, int y, VehicleID selection, EngineImageType image_type)
Draws an image of a ship.
Definition: ship_gui.cpp:32
VehicleViewWindow::SEL_RT_BASEPLANE
@ SEL_RT_BASEPLANE
First plane of the WID_VV_SELECT_REFIT_TURN stacked widget.
Definition: vehicle_gui.cpp:2629
WC_TRAINS_LIST
@ WC_TRAINS_LIST
Trains list; Window numbers:
Definition: window_type.h:301
GetSingleVehicleWidth
int GetSingleVehicleWidth(const Vehicle *v, EngineImageType image_type)
Get the width of a vehicle (part) in pixels.
Definition: vehicle_gui.cpp:3095
WID_VR_INFO
@ WID_VR_INFO
Information about the currently selected refit option.
Definition: vehicle_widget.h:41
WID_VL_GROUP_ORDER
@ WID_VL_GROUP_ORDER
Group order.
Definition: vehicle_widget.h:65
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:494
RefitWindow::sprite_right
int sprite_right
Right position of the vehicle sprite.
Definition: vehicle_gui.cpp:479
DAYS_IN_LEAP_YEAR
static const int DAYS_IN_LEAP_YEAR
sometimes, you need one day more...
Definition: date_type.h:30
WID_VV_CAPTION
@ WID_VV_CAPTION
Caption of window.
Definition: vehicle_widget.h:15
stdafx.h
WID_VD_CAPTION
@ WID_VD_CAPTION
Caption of window.
Definition: vehicle_widget.h:47
WID_VV_START_STOP
@ WID_VV_START_STOP
Start or stop this vehicle, and show information about the current state.
Definition: vehicle_widget.h:17
Window::window_number
WindowNumber window_number
Window number within the window class.
Definition: window_gui.h:312
WID_VV_CLONE
@ WID_VV_CLONE
Clone this vehicle.
Definition: vehicle_widget.h:25
VehicleType
VehicleType
Available vehicle types.
Definition: vehicle_type.h:21
ResizeInfo::step_height
uint step_height
Step-size of height resize changes.
Definition: window_gui.h:218
ChangeVehicleWindow
static void ChangeVehicleWindow(WindowClass window_class, VehicleID from_index, VehicleID to_index)
Assign a vehicle window a new vehicle.
Definition: vehicle_gui.cpp:1331
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
VehicleValueSorter
static bool VehicleValueSorter(const Vehicle *const &a, const Vehicle *const &b)
Sort vehicles by their value.
Definition: vehicle_gui.cpp:1286
VehicleListType
VehicleListType
Vehicle List type flags.
Definition: vehiclelist.h:19
RefitWindow::order
VehicleOrderID order
If not INVALID_VEH_ORDER_ID, selection is part of a refit order (rather than execute directly).
Definition: vehicle_gui.cpp:473
Window::InvalidateData
void InvalidateData(int data=0, bool gui_scope=true)
Mark this window's data as invalid (in need of re-computing)
Definition: window.cpp:3261
NWidgetStacked::SetDisplayedPlane
void SetDisplayedPlane(int plane)
Select which plane to show (for NWID_SELECTION only).
Definition: widget.cpp:1091
EngineInfo::misc_flags
byte misc_flags
Miscellaneous flags.
Definition: engine_type.h:142
CS_ALPHANUMERAL
@ CS_ALPHANUMERAL
Both numeric and alphabetic and spaces and stuff.
Definition: string_type.h:27
viewport_func.h
NWidgetBase::current_y
uint current_y
Current vertical size (after resizing).
Definition: widget_type.h:173
NWidgetStacked
Stacked widgets, widgets all occupying the same space in the window.
Definition: widget_type.h:404
WC_NONE
@ WC_NONE
No window, redirects to WC_MAIN_WINDOW.
Definition: window_type.h:38
RefitOption::string
StringID string
GRF-local String to display for the cargo.
Definition: vehicle_gui.cpp:379
VehicleViewWindow::SEL_RT_REFIT
@ SEL_RT_REFIT
Display 'refit' button in WID_VV_SELECT_REFIT_TURN stacked widget.
Definition: vehicle_gui.cpp:2625
GetDigitWidth
byte GetDigitWidth(FontSize size)
Return the maximum width of single digit.
Definition: gfx.cpp:1308
ODATFB_HALT
@ ODATFB_HALT
Service the vehicle and then halt it.
Definition: order_type.h:104
WC_VEHICLE_REFIT
@ WC_VEHICLE_REFIT
Vehicle refit; Window numbers:
Definition: window_type.h:199
_returned_refit_capacity
uint _returned_refit_capacity
Stores the capacity after a refit operation.
Definition: vehicle.cpp:85
NWID_VERTICAL
@ NWID_VERTICAL
Vertical container.
Definition: widget_type.h:75
WID_VD_DECREASE_SERVICING_INTERVAL
@ WID_VD_DECREASE_SERVICING_INTERVAL
Decrease the servicing interval.
Definition: vehicle_widget.h:50
VehicleListIdentifier::index
uint32 index
A vehicle list type specific index.
Definition: vehiclelist.h:33
HT_VEHICLE
@ HT_VEHICLE
vehicle is accepted as target as well (bitmask)
Definition: tilehighlight_type.h:27
FONT_HEIGHT_SMALL
#define FONT_HEIGHT_SMALL
Height of characters in the small (FS_SMALL) font.
Definition: gfx_func.h:176
GetCargoSubtypeText
StringID GetCargoSubtypeText(const Vehicle *v)
Get the cargo subtype text from NewGRF for the vehicle details window.
Definition: vehicle_gui.cpp:1152
HT_DRAG
@ HT_DRAG
dragging items in the depot windows
Definition: tilehighlight_type.h:24
VIWD_CONSIST_CHANGED
@ VIWD_CONSIST_CHANGED
Vehicle composition was changed.
Definition: vehicle_gui.h:34
VehicleLengthSorter
static bool VehicleLengthSorter(const Vehicle *const &a, const Vehicle *const &b)
Sort vehicles by their length.
Definition: vehicle_gui.cpp:1299
WID_VD_DETAILS_TOTAL_CARGO
@ WID_VD_DETAILS_TOTAL_CARGO
Show the capacity and carried cargo amounts aggregated per cargo of the train.
Definition: vehicle_widget.h:59
GetSpriteSize
Dimension GetSpriteSize(SpriteID sprid, Point *offset, ZoomLevel zoom)
Get the size of a sprite.
Definition: gfx.cpp:913
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
GUIList::NeedRebuild
bool NeedRebuild() const
Check if a rebuild is needed.
Definition: sortlist_type.h:362
Vehicle::list
OrderList * list
Pointer to the order list for this vehicle.
Definition: vehicle_base.h:330
BaseConsist::cur_real_order_index
VehicleOrderID cur_real_order_index
The index to the current real (non-implicit) order.
Definition: base_consist.h:28
CMD_START_STOP_VEHICLE
@ CMD_START_STOP_VEHICLE
start or stop a vehicle
Definition: command_type.h:315
TileHighlightData::place_mode
HighLightStyle place_mode
Method which is used to place the selection.
Definition: tilehighlight_type.h:67
BaseVehicleListWindow::DrawVehicleListItems
void DrawVehicleListItems(VehicleID selected_vehicle, int line_height, const Rect &r) const
Draw all the vehicle list items.
Definition: vehicle_gui.cpp:1505
GetWindowClassForVehicleType
static WindowClass GetWindowClassForVehicleType(VehicleType vt)
Get WindowClass for vehicle list of given vehicle type.
Definition: vehicle_gui.h:91
WD_DROPDOWNTEXT_TOP
@ WD_DROPDOWNTEXT_TOP
Top offset of the dropdown widget string.
Definition: window_gui.h:134
RefitOption::operator==
bool operator==(const RefitOption &other) const
Equality operator for RefitOption.
Definition: vehicle_gui.cpp:396
string_func.h
VAF_DEST_TOO_FAR
@ VAF_DEST_TOO_FAR
Next destination is too far away.
Definition: aircraft.h:39
spritecache.h
VehicleDetailsWindow::OnDropdownSelect
void OnDropdownSelect(int widget, int index) override
A dropdown option associated to this window has been selected.
Definition: vehicle_gui.cpp:2413
Vehicle::FirstShared
Vehicle * FirstShared() const
Get the first vehicle of this vehicle chain.
Definition: vehicle_base.h:686
CALLBACK_FAILED
static const uint CALLBACK_FAILED
Different values for Callback result evaluations.
Definition: newgrf_callbacks.h:404
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:103
SBS_DOWN
@ SBS_DOWN
Sort ascending.
Definition: window_gui.h:224
WID_VV_SELECT_DEPOT_CLONE
@ WID_VV_SELECT_DEPOT_CLONE
Selection widget between 'goto depot', and 'clone vehicle' buttons.
Definition: vehicle_widget.h:26
Vehicle::vcache
VehicleCache vcache
Cache of often used vehicle values.
Definition: vehicle_base.h:339
EIT_IN_LIST
@ EIT_IN_LIST
Vehicle drawn in vehicle list, group list, ...
Definition: vehicle_type.h:89
_current_company
CompanyID _current_company
Company currently doing an action.
Definition: company_cmd.cpp:47
vehicle_func.h
EndContainer
static NWidgetPart EndContainer()
Widget part function for denoting the end of a container (horizontal, vertical, WWT_FRAME,...
Definition: widget_type.h:998
RefitWindow::RefreshScrollbar
void RefreshScrollbar()
Refresh scrollbar after selection changed.
Definition: vehicle_gui.cpp:598
DEPOT_SERVICE
@ DEPOT_SERVICE
The vehicle will leave the depot right after arrival (service only)
Definition: vehicle_type.h:66
VehicleDetailsWindow
Class for managing the vehicle details window.
Definition: vehicle_gui.cpp:2078
station_base.h
Clamp
static T Clamp(const T a, const T min, const T max)
Clamp a value between an interval.
Definition: math_func.hpp:77
WID_VV_LOCATION
@ WID_VV_LOCATION
Center the main view on this vehicle.
Definition: vehicle_widget.h:19
PALETTE_CRASH
static const PaletteID PALETTE_CRASH
Recolour sprite greying of crashed vehicles.
Definition: sprites.h:1594
GetVehicleWidth
int GetVehicleWidth(const Vehicle *v, EngineImageType image_type)
Get the width of a vehicle (including all parts of the consist) in pixels.
Definition: vehicle_gui.cpp:3119
CMD_FORCE_TRAIN_PROCEED
@ CMD_FORCE_TRAIN_PROCEED
proceed a train to pass a red signal
Definition: command_type.h:221
strings_func.h
NWID_VSCROLLBAR
@ NWID_VSCROLLBAR
Vertical scrollbar.
Definition: widget_type.h:82
CMD_CLONE_VEHICLE
@ CMD_CLONE_VEHICLE
clone a vehicle
Definition: command_type.h:314
_train_vehicle_details_desc
static WindowDesc _train_vehicle_details_desc(WDP_AUTO, "view_vehicle_details_train", 405, 178, WC_VEHICLE_DETAILS, WC_VEHICLE_VIEW, 0, _nested_train_vehicle_details_widgets, lengthof(_nested_train_vehicle_details_widgets))
Vehicle details window descriptor.
Vehicle::First
Vehicle * First() const
Get the first vehicle of this vehicle chain.
Definition: vehicle_base.h:605
DeleteWindowById
void DeleteWindowById(WindowClass cls, WindowNumber number, bool force)
Delete a window by its class and window number (if it is open).
Definition: window.cpp:1165
Sorting
Definition: vehicle_gui_base.h:143
RefitWindow::vehicle_margin
uint vehicle_margin
Margin to use while selecting vehicles when the vehicle image is centered.
Definition: vehicle_gui.cpp:480
DrawRoadVehImage
void DrawRoadVehImage(const Vehicle *v, int left, int right, int y, VehicleID selection, EngineImageType image_type, int skip)
Draws an image of a road vehicle chain.
Definition: roadveh_gui.cpp:129
BaseConsist::lateness_counter
int32 lateness_counter
How many ticks late (or early if negative) this vehicle is.
Definition: base_consist.h:23
Vehicle::cargo_cap
uint16 cargo_cap
total capacity
Definition: vehicle_base.h:316
Engine::CanCarryCargo
bool CanCarryCargo() const
Determines whether an engine can carry something.
Definition: engine.cpp:169
VehicleDetailsWindow::OnPaint
void OnPaint() override
Repaint vehicle details window.
Definition: vehicle_gui.cpp:2350
GUIVehicleGroup
Definition: vehicle_gui_base.h:27
MAX_LENGTH_VEHICLE_NAME_CHARS
static const uint MAX_LENGTH_VEHICLE_NAME_CHARS
The maximum length of a vehicle name in characters including '\0'.
Definition: vehicle_type.h:73
RoadVehicle::GetDisplayImageWidth
int GetDisplayImageWidth(Point *offset=nullptr) const
Get the width of a road vehicle image in the GUI.
Definition: roadveh_cmd.cpp:90
NWidgetBase::pos_x
int pos_x
Horizontal position of top-left corner of the widget in the window.
Definition: widget_type.h:175
GroundVehicleCache::cached_power
uint32 cached_power
Total power of the consist (valid only for the first engine).
Definition: ground_vehicle.hpp:38
WID_VD_DETAILS_CARGO_CARRIED
@ WID_VD_DETAILS_CARGO_CARRIED
Show carried cargo per part of the train.
Definition: vehicle_widget.h:56
VehicleDefaultSettings::servint_trains
uint16 servint_trains
service interval for trains
Definition: settings_type.h:542
CMD_MASS_START_STOP
@ CMD_MASS_START_STOP
start/stop all vehicles (in a depot)
Definition: command_type.h:316
VehicleViewWindow::DrawWidget
void DrawWidget(const Rect &r, int widget) const override
Draw the contents of a nested widget.
Definition: vehicle_gui.cpp:2771
HideDropDownMenu
int HideDropDownMenu(Window *pw)
Delete the drop-down menu from window pw.
Definition: dropdown.cpp:512
BaseVehicleListWindow::vehgroups
GUIVehicleGroupList vehgroups
List of (groups of) vehicles. This stores iterators of vehicles, and should be rebuilt if vehicles is...
Definition: vehicle_gui_base.h:81
WIDGET_LIST_END
static const int WIDGET_LIST_END
indicate the end of widgets' list for vararg functions
Definition: widget_type.h:20
TDW_TAB_CAPACITY
@ TDW_TAB_CAPACITY
Tab with cargo capacity of the vehicles.
Definition: vehicle_gui.h:26
ShowReplaceGroupVehicleWindow
void ShowReplaceGroupVehicleWindow(GroupID id_g, VehicleType vehicletype)
Show the autoreplace configuration window for a particular group.
Definition: autoreplace_gui.cpp:834
VehicleViewWindow::OnQueryTextFinished
void OnQueryTextFinished(char *str) override
The query window opened from this window has closed.
Definition: vehicle_gui.cpp:2965
SpecializedVehicle< Train, Type >::From
static Train * From(Vehicle *v)
Converts a Vehicle to SpecializedVehicle with type checking.
Definition: vehicle_base.h:1162
GetVehiclePalette
PaletteID GetVehiclePalette(const Vehicle *v)
Get the colour map for a vehicle.
Definition: vehicle.cpp:2041
VehicleSettings::roadveh_acceleration_model
uint8 roadveh_acceleration_model
realistic acceleration for road vehicles
Definition: settings_type.h:463
FONT_HEIGHT_NORMAL
#define FONT_HEIGHT_NORMAL
Height of characters in the normal (FS_NORMAL) font.
Definition: gfx_func.h:179
VehicleListIdentifier::vtype
VehicleType vtype
The vehicle type associated with this list.
Definition: vehiclelist.h:31
Vehicle::GetFirstEnginePart
Vehicle * GetFirstEnginePart()
Get the first part of an articulated engine.
Definition: vehicle_base.h:933
VIWD_AUTOREPLACE
@ VIWD_AUTOREPLACE
Autoreplace replaced the vehicle.
Definition: vehicle_gui.h:35
ScaleGUITrad
static int ScaleGUITrad(int value)
Scale traditional pixel dimensions to GUI zoom level.
Definition: zoom_func.h:76
NWidget
static NWidgetPart NWidget(WidgetType tp, Colours col, int16 idx=-1)
Widget part function for starting a new 'real' widget.
Definition: widget_type.h:1113
geometry_func.hpp
PaletteID
uint32 PaletteID
The number of the palette.
Definition: gfx_type.h:18
SetDParamMaxValue
void SetDParamMaxValue(uint n, uint64 max_value, uint min_count, FontSize size)
Set DParam n to some number that is suitable for string size computations.
Definition: strings.cpp:104
SetMinimalSize
static NWidgetPart SetMinimalSize(int16 x, int16 y)
Widget part function for setting the minimal size.
Definition: widget_type.h:946
WID_VR_VEHICLE_PANEL_DISPLAY
@ WID_VR_VEHICLE_PANEL_DISPLAY
Display with a representation of the vehicle to refit.
Definition: vehicle_widget.h:35
WWT_PANEL
@ WWT_PANEL
Simple depressed panel.
Definition: widget_type.h:48
GetBestFittingSubType
byte GetBestFittingSubType(Vehicle *v_from, Vehicle *v_for, CargoID dest_cargo_type)
Get the best fitting subtype when 'cloning'/'replacing' v_from with v_for.
Definition: vehicle_gui.cpp:312
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
VehicleListIdentifier::type
VehicleListType type
The type of vehicle list.
Definition: vehiclelist.h:30
Window::SetWidgetsDisabledState
void CDECL SetWidgetsDisabledState(bool disab_stat, int widgets,...)
Sets the enabled/disabled status of a list of widgets.
Definition: window.cpp:536
Vehicle::orders
union Vehicle::@51 orders
The orders currently assigned to the vehicle.
Window::IsWidgetLowered
bool IsWidgetLowered(byte widget_index) const
Gets the lowered state of a widget.
Definition: window_gui.h:493
RefitWindow
Refit cargo window.
Definition: vehicle_gui.cpp:469
Vehicle::age
Date age
Age in days.
Definition: vehicle_base.h:268
NUM_CARGO
@ NUM_CARGO
Maximal number of cargo types in a game.
Definition: cargo_type.h:64
VehicleDefaultSettings::servint_aircraft
uint16 servint_aircraft
service interval for aircraft
Definition: settings_type.h:544
GetStationIndex
static StationID GetStationIndex(TileIndex t)
Get StationID from a tile.
Definition: station_map.h:28
Vehicle::HasArticulatedPart
bool HasArticulatedPart() const
Check if an engine has an articulated part.
Definition: vehicle_base.h:913
VehicleNumberSorter
static bool VehicleNumberSorter(const Vehicle *const &a, const Vehicle *const &b)
Sort vehicles by their number.
Definition: vehicle_gui.cpp:1198
Scrollbar::GetPosition
uint16 GetPosition() const
Gets the position of the first visible element in the list.
Definition: widget_type.h:630
VehicleViewWindow::SetStringParameters
void SetStringParameters(int widget) const override
Initialize string parameters for a widget.
Definition: vehicle_gui.cpp:2763
WD_IMGBTN_TOP
@ WD_IMGBTN_TOP
Top offset of image in the button.
Definition: window_gui.h:40
DAYS_IN_YEAR
static const int DAYS_IN_YEAR
days per year
Definition: date_type.h:29
VehicleCargoSorter
static bool VehicleCargoSorter(const Vehicle *const &a, const Vehicle *const &b)
Sort vehicles by their cargo.
Definition: vehicle_gui.cpp:1246
VehicleViewWindow::IsNewGRFInspectable
bool IsNewGRFInspectable() const override
Is the data related to this window NewGRF inspectable?
Definition: vehicle_gui.cpp:3030
CargoSpec::name
StringID name
Name of this type of cargo.
Definition: cargotype.h:70
WC_MAIN_WINDOW
@ WC_MAIN_WINDOW
Main window; Window numbers:
Definition: window_type.h:44
Window::FinishInitNested
void FinishInitNested(WindowNumber window_number=0)
Perform the second part of the initialization of a nested widget tree.
Definition: window.cpp:1848
_nested_vehicle_view_widgets
static const NWidgetPart _nested_vehicle_view_widgets[]
Vehicle view widgets.
Definition: vehicle_gui.cpp:2464
Vehicle::unitnumber
UnitID unitnumber
unit number, for display purposes only
Definition: vehicle_base.h:300
depot_map.h
VehicleTimeToLiveSorter
static bool VehicleTimeToLiveSorter(const Vehicle *const &a, const Vehicle *const &b)
Sort vehicles by the time they can still live.
Definition: vehicle_gui.cpp:1306
VehicleCache::cached_max_speed
uint16 cached_max_speed
Maximum speed of the consist (minimum of the max speed of all vehicles in the consist).
Definition: vehicle_base.h:121
VehicleDetailsWindow::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: vehicle_gui.cpp:2140
company_func.h
WWT_INSET
@ WWT_INSET
Pressed (inset) panel, most commonly used as combo box text area.
Definition: widget_type.h:49
ShowRefitOptionsList
uint ShowRefitOptionsList(int left, int right, int y, EngineID engine)
Display list of cargo types of the engine, for the purchase information window.
Definition: vehicle_gui.cpp:1123
GUIList::ForceResort
void ForceResort()
Force a resort next Sort call Reset the resort timer if used too.
Definition: sortlist_type.h:213
ZOOM_LVL_TRAIN
@ ZOOM_LVL_TRAIN
Default zoom level for the train view.
Definition: zoom_type.h:41
VehicleID
uint32 VehicleID
The type all our vehicle IDs have.
Definition: vehicle_type.h:16
VehicleViewWindow
Window manager class for viewing a vehicle.
Definition: vehicle_gui.cpp:2618
DrawFrameRect
void DrawFrameRect(int left, int top, int right, int bottom, Colours colour, FrameFlags flags)
Draw frame rectangle.
Definition: widget.cpp:175
Vehicle::InvalidateNewGRFCache
void InvalidateNewGRFCache()
Invalidates cached NewGRF variables.
Definition: vehicle_base.h:462
NWidgetBase::SetDirty
virtual void SetDirty(const Window *w) const
Mark the widget as 'dirty' (in need of repaint).
Definition: widget.cpp:773
VehicleListWindow::DrawWidget
void DrawWidget(const Rect &r, int widget) const override
Draw the contents of a nested widget.
Definition: vehicle_gui.cpp:1749
VehicleListIdentifier::UnPack
static VehicleListIdentifier UnPack(uint32 data)
Decode a packed vehicle list identifier into a new one.
Definition: vehiclelist.cpp:53
OrderList::GetFirstOrder
Order * GetFirstOrder() const
Get the first order of the order chain.
Definition: order_base.h:290
ViewportData::follow_vehicle
VehicleID follow_vehicle
VehicleID to follow if following a vehicle, INVALID_VEHICLE otherwise.
Definition: window_gui.h:257
WD_MATRIX_BOTTOM
@ WD_MATRIX_BOTTOM
Offset at bottom of a matrix cell.
Definition: window_gui.h:79
ShowVehicleViewWindow
void ShowVehicleViewWindow(const Vehicle *v)
Shows the vehicle view window of the given vehicle.
Definition: vehicle_gui.cpp:3043
DrawSmallOrderList
static void DrawSmallOrderList(const Order *order, int left, int right, int y)
Draw small order list in the vehicle GUI, but without the little black arrow.
Definition: vehicle_gui.cpp:1441
GUIList::ForceRebuild
void ForceRebuild()
Force that a rebuild is needed.
Definition: sortlist_type.h:370
BaseVehicleListWindow::vehicles
VehicleList vehicles
List of vehicles. This is the buffer for vehgroups to point into; if this is structurally modified,...
Definition: vehicle_gui_base.h:80
WID_VD_SCROLLBAR
@ WID_VD_SCROLLBAR
Scrollbar for train details.
Definition: vehicle_widget.h:55
CursorVars::sprite_seq
PalSpriteID sprite_seq[16]
current image of cursor
Definition: gfx_type.h:128
lengthof
#define lengthof(x)
Return the length of an fixed size array.
Definition: stdafx.h:367
Window::width
int width
width of the window (number of pixels to the right in x direction)
Definition: window_gui.h:319
Viewport::zoom
ZoomLevel zoom
The zoom level of the viewport.
Definition: viewport_type.h:33
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:1980
Window::SortButtonWidth
static int SortButtonWidth()
Get width of up/down arrow of sort button state.
Definition: widget.cpp:656
RefitWindow::OnMouseDrag
void OnMouseDrag(Point pt, int widget) override
An 'object' is being dragged at the provided position, highlight the target if possible.
Definition: vehicle_gui.cpp:1041
TileHighlightData::window_class
WindowClass window_class
The WindowClass of the window that is responsible for the selection mode.
Definition: tilehighlight_type.h:68
RefitOption::cargo
CargoID cargo
Cargo to refit to.
Definition: vehicle_gui.cpp:377
OverflowSafeInt< int64, INT64_MAX, INT64_MIN >
_nontrain_vehicle_details_desc
static WindowDesc _nontrain_vehicle_details_desc(WDP_AUTO, "view_vehicle_details", 405, 113, WC_VEHICLE_DETAILS, WC_VEHICLE_VIEW, 0, _nested_nontrain_vehicle_details_widgets, lengthof(_nested_nontrain_vehicle_details_widgets))
Vehicle details window descriptor for other vehicles than a train.
VehicleNameSorter
static bool VehicleNameSorter(const Vehicle *const &a, const Vehicle *const &b)
Sort vehicles by their name.
Definition: vehicle_gui.cpp:1204
CargoID
byte CargoID
Cargo slots to indicate a cargo type within a game.
Definition: cargo_type.h:20
Vehicle::IsStoppedInDepot
bool IsStoppedInDepot() const
Check whether the vehicle is in the depot and stopped.
Definition: vehicle_base.h:527
ToPercent16
static uint ToPercent16(uint i)
Converts a "fract" value 0..65535 to "percent" value 0..100.
Definition: math_func.hpp:238
MemSetT
static void MemSetT(T *ptr, byte value, size_t num=1)
Type-safe version of memset().
Definition: mem_func.hpp:49
TFP_SIGNAL
@ TFP_SIGNAL
Ignore next signal, after the signal ignore being stuck.
Definition: train.h:40
VehicleListWindow::OnInvalidateData
void OnInvalidateData(int data=0, bool gui_scope=true) override
Some data on this window has become invalid.
Definition: vehicle_gui.cpp:1914
INVALID_TILE
static const TileIndex INVALID_TILE
The very nice invalid tile marker.
Definition: tile_type.h:83
CcCloneVehicle
void CcCloneVehicle(const CommandCost &result, TileIndex tile, uint32 p1, uint32 p2, uint32 cmd)
This is the Callback method after the cloning attempt of a vehicle.
Definition: depot_gui.cpp:120
SetObjectToPlaceWnd
void SetObjectToPlaceWnd(CursorID icon, PaletteID pal, HighLightStyle mode, Window *w)
Change the cursor and mouse click/drag handling to a mode for performing special operations like tile...
Definition: viewport.cpp:3358
VehicleDefaultSettings::servint_roadveh
uint16 servint_roadveh
service interval for road vehicles
Definition: settings_type.h:543
RefitWindow::vehicle_width
int vehicle_width
Width of the vehicle being drawn.
Definition: vehicle_gui.cpp:477
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:625
Vehicle::cargo_type
CargoID cargo_type
type of cargo this vehicle is carrying
Definition: vehicle_base.h:314
RefitWindow::OnDragDrop
void OnDragDrop(Point pt, int widget) override
A dragged 'object' has been released.
Definition: vehicle_gui.cpp:1054
IsNewGRFInspectable
bool IsNewGRFInspectable(GrfSpecFeature feature, uint index)
Can we inspect the data given a certain feature and index.
Definition: newgrf_debug_gui.cpp:756
VehicleDetailsWindow::DrawWidget
void DrawWidget(const Rect &r, int widget) const override
Draw the contents of a nested widget.
Definition: vehicle_gui.cpp:2252
SetFill
static NWidgetPart SetFill(uint fill_x, uint fill_y)
Widget part function for setting filling.
Definition: widget_type.h:982
MAX_REFIT_CYCLE
static const uint MAX_REFIT_CYCLE
Maximum number of refit cycles we try, to prevent infinite loops.
Definition: vehicle_gui.cpp:301
Order::GetLocation
TileIndex GetLocation(const Vehicle *v, bool airport=false) const
Returns a tile somewhat representing the order destination (not suitable for pathfinding).
Definition: order_cmd.cpp:680
DrawTrainDetails
void DrawTrainDetails(const Train *v, int left, int right, int y, int vscroll_pos, uint16 vscroll_cap, TrainDetailsWindowTabs det_tab)
Draw the details for the given vehicle at the given position.
Definition: train_gui.cpp:361
gui.h
VehicleIndividualToGroupSorterWrapper
static bool VehicleIndividualToGroupSorterWrapper(GUIVehicleGroup const &a, GUIVehicleGroup const &b)
Wrapper to convert a VehicleIndividualSortFunction to a VehicleGroupSortFunction.
Definition: vehicle_gui.cpp:67
SPR_CURSOR_MOUSE
static const CursorID SPR_CURSOR_MOUSE
Cursor sprite numbers.
Definition: sprites.h:1374
PalSpriteID::pal
PaletteID pal
The palette (use PAL_NONE) if not needed)
Definition: gfx_type.h:24
BaseVehicleListWindow::unitnumber_digits
byte unitnumber_digits
The number of digits of the highest unit number.
Definition: vehicle_gui_base.h:83
GUISettings::advanced_vehicle_list
uint8 advanced_vehicle_list
use the "advanced" vehicle list
Definition: settings_type.h:111
WD_DROPDOWNTEXT_BOTTOM
@ WD_DROPDOWNTEXT_BOTTOM
Bottom offset of the dropdown widget string.
Definition: window_gui.h:135
articulated_vehicles.h
GameSettings::vehicle
VehicleSettings vehicle
options for vehicles
Definition: settings_type.h:568
ErrorUnknownCallbackResult
void ErrorUnknownCallbackResult(uint32 grfid, uint16 cbid, uint16 cb_res)
Record that a NewGRF returned an unknown/invalid callback result.
Definition: newgrf_commons.cpp:516
Vehicle::cargo_subtype
byte cargo_subtype
Used for livery refits (NewGRF variations)
Definition: vehicle_base.h:315
DrawAircraftDetails
void DrawAircraftDetails(const Aircraft *v, int left, int right, int y)
Draw the details for the given vehicle at the given position.
Definition: aircraft_gui.cpp:32
IsEngineRefittable
bool IsEngineRefittable(EngineID engine)
Check if an engine is refittable.
Definition: engine.cpp:1164
Window
Data structure for an opened window.
Definition: window_gui.h:276
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
DrawShipDetails
void DrawShipDetails(const Vehicle *v, int left, int right, int y)
Draw the details for the given vehicle at the given position.
Definition: ship_gui.cpp:64
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:318
WD_MATRIX_LEFT
@ WD_MATRIX_LEFT
Offset at left of a matrix cell.
Definition: window_gui.h:76
Vehicle::GetOrder
Order * GetOrder(int index) const
Returns order 'index' of a vehicle or nullptr when it doesn't exists.
Definition: vehicle_base.h:872
BaseVehicle::type
VehicleType type
Type of vehicle.
Definition: vehicle_type.h:52
Window::DrawWidgets
void DrawWidgets() const
Paint all widgets of a window.
Definition: widget.cpp:602
RefitWindow::BuildRefitList
void BuildRefitList()
Collects all (cargo, subcargo) refit options of a vehicle chain.
Definition: vehicle_gui.cpp:489
ZOOM_LVL_OUT_4X
@ ZOOM_LVL_OUT_4X
Zoomed 4 times out.
Definition: zoom_type.h:26
Vehicle::reliability
uint16 reliability
Reliability.
Definition: vehicle_base.h:271
DC_QUERY_COST
@ DC_QUERY_COST
query cost only, don't build.
Definition: command_type.h:350
VehicleProfitLastYearSorter
static bool VehicleProfitLastYearSorter(const Vehicle *const &a, const Vehicle *const &b)
Sort vehicles by last year profit.
Definition: vehicle_gui.cpp:1239
DrawVehicleProfitButton
static void DrawVehicleProfitButton(Date age, Money display_profit_last_year, uint num_vehicles, int x, int y)
draw the vehicle profit button in the vehicle list window.
Definition: vehicle_gui.cpp:283
SBS_UP
@ SBS_UP
Sort descending.
Definition: window_gui.h:225
WD_IMGBTN_LEFT
@ WD_IMGBTN_LEFT
Left offset of the image in the button.
Definition: window_gui.h:38
NWID_SELECTION
@ NWID_SELECTION
Stacked widgets, only one visible at a time (eg in a panel with tabs).
Definition: widget_type.h:78
NWidgetCore
Base class for a 'real' widget.
Definition: widget_type.h:282
WID_VD_INCREASE_SERVICING_INTERVAL
@ WID_VD_INCREASE_SERVICING_INTERVAL
Increase the servicing interval.
Definition: vehicle_widget.h:49
Window::SetWidgetDirty
void SetWidgetDirty(byte widget_index) const
Invalidate a widget, i.e.
Definition: window.cpp:597
WID_VV_ORDER_LOCATION
@ WID_VV_ORDER_LOCATION
Center the main view on the order's target location.
Definition: vehicle_widget.h:20
WWT_DEBUGBOX
@ WWT_DEBUGBOX
NewGRF debug box (at top-right of a window, between WWT_CAPTION and WWT_SHADEBOX)
Definition: widget_type.h:61
VEH_SHIP
@ VEH_SHIP
Ship vehicle type.
Definition: vehicle_type.h:26
RefitWindow::cargo
RefitOption * cargo
Refit option selected by sel.
Definition: vehicle_gui.cpp:471
Rect
Specification of a rectangle with absolute coordinates of all edges.
Definition: geometry_type.hpp:47
WID_VV_GOTO_DEPOT
@ WID_VV_GOTO_DEPOT
Order this vehicle to go to the depot.
Definition: vehicle_widget.h:21
DrawAircraftImage
void DrawAircraftImage(const Vehicle *v, int left, int right, int y, VehicleID selection, EngineImageType image_type)
Draws an image of an aircraft.
Definition: aircraft_gui.cpp:80
AWV_INCREASE
@ AWV_INCREASE
Arrow to the right or in case of RTL to the left.
Definition: widget_type.h:36
VehicleSpriteSeq::GetBounds
void GetBounds(Rect *bounds) const
Determine shared bounds of all sprites.
Definition: vehicle.cpp:98
Order::GetDepotActionType
OrderDepotActionFlags GetDepotActionType() const
What are we going to do when in the depot.
Definition: order_base.h:137
WID_VD_SERVICING_INTERVAL
@ WID_VD_SERVICING_INTERVAL
Information about the servicing interval.
Definition: vehicle_widget.h:52
ShowVehicleRefitWindow
void ShowVehicleRefitWindow(const Vehicle *v, VehicleOrderID order, Window *parent, bool auto_refit)
Show the refit window for a vehicle.
Definition: vehicle_gui.cpp:1115
QSF_ENABLE_DEFAULT
@ QSF_ENABLE_DEFAULT
enable the 'Default' button ("\0" is returned)
Definition: textbuf_gui.h:21
RefitWindow::OnInit
void OnInit() override
Notification that the nested widget tree gets initialized.
Definition: vehicle_gui.cpp:687
Window::DisableWidget
void DisableWidget(byte widget_index)
Sets a widget to disabled.
Definition: window_gui.h:402
CMD_RENAME_VEHICLE
@ CMD_RENAME_VEHICLE
rename a whole vehicle
Definition: command_type.h:244
NWidgetBase::current_x
uint current_x
Current horizontal size (after resizing).
Definition: widget_type.h:172
lastof
#define lastof(x)
Get the last element of an fixed size array.
Definition: stdafx.h:383
NWidgetStacked::shown_plane
int shown_plane
Plane being displayed (for NWID_SELECTION only).
Definition: widget_type.h:419
WID_VR_SELECT_HEADER
@ WID_VR_SELECT_HEADER
Header with question about the cargo to carry.
Definition: vehicle_widget.h:38
Order::next
Order * next
Pointer to next order. If nullptr, end of list.
Definition: order_base.h:49
Order
Definition: order_base.h:32
WID_VV_REFIT
@ WID_VV_REFIT
Open the refit window.
Definition: vehicle_widget.h:22
RefitWindow::SetSelection
void SetSelection(uint click_row)
Select a row.
Definition: vehicle_gui.cpp:624
GroundVehicleCache::cached_weight
uint32 cached_weight
Total weight of the consist (valid only for the first engine).
Definition: ground_vehicle.hpp:31
WD_IMGBTN_RIGHT
@ WD_IMGBTN_RIGHT
Right offset of the image in the button.
Definition: window_gui.h:39
Window::SetWidgetLoweredState
void SetWidgetLoweredState(byte widget_index, bool lowered_stat)
Sets the lowered/raised status of a widget.
Definition: window_gui.h:453
RefitWindow::GetCapacityString
StringID GetCapacityString(RefitOption *option) const
Gets the StringID to use for displaying capacity.
Definition: vehicle_gui.cpp:767
Engine::GetAircraftTypeText
StringID GetAircraftTypeText() const
Get the name of the aircraft type for display purposes.
Definition: engine.cpp:466
TD_RTL
@ TD_RTL
Text is written right-to-left by default.
Definition: strings_type.h:24
DAY_TICKS
static const int DAY_TICKS
1 day is 74 ticks; _date_fract used to be uint16 and incremented by 885.
Definition: date_type.h:28
_current_text_dir
TextDirection _current_text_dir
Text direction of the currently selected language.
Definition: strings.cpp:48
Vehicle::GetDisplayProfitLastYear
Money GetDisplayProfitLastYear() const
Gets the profit vehicle had last year.
Definition: vehicle_base.h:583
VehicleListWindow::OnGameTick
void OnGameTick() override
Called once per (game) tick.
Definition: vehicle_gui.cpp:1894
DrawVehicleRefitWindow
static void DrawVehicleRefitWindow(const SubtypeList list[NUM_CARGO], const int sel[2], uint pos, uint rows, uint delta, const Rect &r)
Draw the list of available refit options for a consist and highlight the selected refit option (if an...
Definition: vehicle_gui.cpp:413
RefitOption
Option to refit a vehicle chain.
Definition: vehicle_gui.cpp:376
VehicleReliabilitySorter
static bool VehicleReliabilitySorter(const Vehicle *const &a, const Vehicle *const &b)
Sort vehicles by their reliability.
Definition: vehicle_gui.cpp:1265
GetDepotIndex
static DepotID GetDepotIndex(TileIndex t)
Get the index of which depot is attached to the tile.
Definition: depot_map.h:52
GetTrainDetailsWndVScroll
int GetTrainDetailsWndVScroll(VehicleID veh_id, TrainDetailsWindowTabs det_tab)
Determines the number of lines in the train details window.
Definition: train_gui.cpp:318
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
WC_VEHICLE_ORDERS
@ WC_VEHICLE_ORDERS
Vehicle orders; Window numbers:
Definition: window_type.h:205
ClientSettings::gui
GUISettings gui
settings related to the GUI
Definition: settings_type.h:577
debug.h
FR_BORDERONLY
@ FR_BORDERONLY
Draw border only, no background.
Definition: window_gui.h:28
AWV_DECREASE
@ AWV_DECREASE
Arrow to the left or in case of RTL to the right.
Definition: widget_type.h:35
Vehicle::date_of_last_service
Date date_of_last_service
Last date the vehicle had a service at a depot.
Definition: vehicle_base.h:270
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:964
WWT_DROPDOWN
@ WWT_DROPDOWN
Drop down list.
Definition: widget_type.h:68
TileHighlightData::GetCallbackWnd
Window * GetCallbackWnd()
Get the window that started the current highlighting.
Definition: viewport.cpp:2516
GUIList::SetSortFuncs
void SetSortFuncs(SortFunction *const *n_funcs)
Hand the array of sort function pointers to the sort list.
Definition: sortlist_type.h:270
VEHICLE_PROFIT_MIN_AGE
static const int VEHICLE_PROFIT_MIN_AGE
Only vehicles older than this have a meaningful profit.
Definition: vehicle_func.h:27
VEHICLE_PROFIT_THRESHOLD
static const Money VEHICLE_PROFIT_THRESHOLD
Threshold for a vehicle to be considered making good profit.
Definition: vehicle_func.h:28
engine_func.h
TileVirtXY
static TileIndex TileVirtXY(uint x, uint y)
Get a tile from the virtual XY-coordinate.
Definition: map_func.h:194
VehicleDetailsWindow::OnResize
void OnResize() override
Called after the window got resized.
Definition: vehicle_gui.cpp:2427
roadveh.h
TDW_TAB_CARGO
@ TDW_TAB_CARGO
Tab with cargo carried by the vehicles.
Definition: vehicle_gui.h:24
RefitWindow::GetRefitOption
RefitOption * GetRefitOption()
Gets the RefitOption placed in the selected index.
Definition: vehicle_gui.cpp:653
SubtypeList
std::vector< RefitOption > SubtypeList
List of refit subtypes associated to a cargo.
Definition: vehicle_gui.cpp:402
_nested_train_vehicle_details_widgets
static const NWidgetPart _nested_train_vehicle_details_widgets[]
Train details widgets.
Definition: vehicle_gui.cpp:2028
MAX_YEAR
static const Year MAX_YEAR
MAX_YEAR, nicely rounded value of the number of years that can be encoded in a single 32 bits date,...
Definition: date_type.h:94
WWT_SHADEBOX
@ WWT_SHADEBOX
Shade box (at top-right of a window, between WWT_DEBUGBOX and WWT_DEFSIZEBOX)
Definition: widget_type.h:62
Vehicle::GetImage
virtual void GetImage(Direction direction, EngineImageType image_type, VehicleSpriteSeq *result) const
Gets the sprite to show for the given direction.
Definition: vehicle_base.h:453