OpenTTD Source  1.11.0-beta2
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>
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,
103 };
104 
105 BaseVehicleListWindow::VehicleGroupSortFunction * const BaseVehicleListWindow::vehicle_group_shared_orders_sorter_funcs[] = {
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,
120 };
121 
122 const StringID BaseVehicleListWindow::vehicle_group_by_names[] = {
123  STR_GROUP_BY_NONE,
124  STR_GROUP_BY_SHARED_ORDERS,
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 
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 
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 {
378  byte subtype;
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];
481  int click_x;
483  uint8 num_vehicles;
484  bool auto_refit;
485 
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;
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. */
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 */
589  }
590  current_index++;
591  }
592  } while (v->IsGroundVehicle() && (v = v->Next()) != nullptr);
593  }
594 
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 
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 */
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:
743  size->height = resize->height * 8;
744  break;
745 
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 
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);
778 
779  Money money = cost.GetCost();
781  SetDParam(2, CT_MAIL);
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) {
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) {
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);
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);
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[] = {
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. */
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. */
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(),
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,
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 {
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 
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) {
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 
1169 {
1170  return a.NumVehicles() < b.NumVehicles();
1171 }
1172 
1175 {
1176  return a.GetDisplayProfitThisYear() < b.GetDisplayProfitThisYear();
1177 }
1178 
1181 {
1182  return a.GetDisplayProfitLastYear() < b.GetDisplayProfitLastYear();
1183 }
1184 
1187 {
1188  return a.GetDisplayProfitThisYear() * static_cast<uint>(b.NumVehicles()) < b.GetDisplayProfitThisYear() * static_cast<uint>(a.NumVehicles());
1189 }
1190 
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 {
1235  return (r != 0) ? r < 0 : VehicleNumberSorter(a, b);
1236 }
1237 
1239 static bool VehicleProfitLastYearSorter(const Vehicle * const &a, const Vehicle * const &b)
1240 {
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 {
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 {
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[] = {
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 
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 
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 
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 
1390  NWidget(NWID_SELECTION, INVALID_COLOUR, WID_VL_HIDE_BUTTONS),
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(),
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 
1630 private:
1635  };
1636 
1637 public:
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. */
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 
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 
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) {
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:
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,
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) {
1826  } else {
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 
1847  ShowBuildVehicleWindow(INVALID_TILE, this->vli.vtype);
1848  break;
1849 
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) {
1866  this->UpdateVehicleGroupBy(static_cast<GroupBy>(index));
1867  break;
1868 
1870  this->vehgroups.SetSortType(index);
1871  break;
1872 
1874  assert(this->vehicles.size() != 0);
1875 
1876  switch (index) {
1877  case ADI_REPLACE: // Replace window
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,
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,
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 
2003 
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(),
2017  SetDataTip(AWV_DECREASE, STR_VEHICLE_DETAILS_DECREASE_SERVICING_INTERVAL_TOOLTIP),
2019  SetDataTip(AWV_INCREASE, STR_VEHICLE_DETAILS_INCREASE_SERVICING_INTERVAL_TOOLTIP),
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 
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(),
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(),
2043  SetDataTip(AWV_DECREASE, STR_VEHICLE_DETAILS_DECREASE_SERVICING_INTERVAL_TOOLTIP),
2045  SetDataTip(AWV_INCREASE, STR_VEHICLE_DETAILS_INCREASE_SERVICING_INTERVAL_TOOLTIP),
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(),
2052  SetDataTip(STR_VEHICLE_DETAIL_TAB_CARGO, STR_VEHICLE_DETAILS_TRAIN_CARGO_TOOLTIP), SetFill(1, 0), SetResize(1, 0),
2054  SetDataTip(STR_VEHICLE_DETAIL_TAB_INFORMATION, STR_VEHICLE_DETAILS_TRAIN_INFORMATION_TOOLTIP), SetFill(1, 0), SetResize(1, 0),
2056  SetDataTip(STR_VEHICLE_DETAIL_TAB_CAPACITIES, STR_VEHICLE_DETAILS_TRAIN_CAPACITIES_TOOLTIP), SetFill(1, 0), SetResize(1, 0),
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,
2075 };
2076 
2080  Scrollbar *vscroll;
2081 
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 
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 };
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:
2187  size->height = 4 * resize->height;
2188  break;
2189 
2191  StringID *strs = _service_interval_dropdown;
2192  while (*strs != INVALID_STRING_ID) {
2193  *size = maxdim(*size, GetStringBoundingBox(*strs++));
2194  }
2195  size->width += padding.width;
2197  break;
2198  }
2199 
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
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);
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) {
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 */
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 */
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;
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()) {
2329  } else {
2330  uint sprite_left = rtl ? text_right : r.left;
2331  uint sprite_right = rtl ? r.right : text_left;
2332 
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 
2340  /* Draw service interval text */
2341  SetDParam(0, v->GetServiceInterval());
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 */
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 
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 
2399  this->SetWidgetsDisabledState(false,
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) {
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 
2438  WDP_AUTO, "view_vehicle_details_train", 405, 178,
2440  0,
2442 );
2443 
2446  WDP_AUTO, "view_vehicle_details", 405, 113,
2448  0,
2450 );
2451 
2453 static void ShowVehicleDetailsWindow(const Vehicle *v)
2454 {
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 
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(),
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(),
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. */
2488  SetDataTip(SPR_IGNORE_SIGNALS, STR_VEHICLE_VIEW_TRAIN_IGNORE_SIGNAL_TOOLTIP),
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(),
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 
2508  WDP_AUTO, "view_vehicle", 250, 116,
2510  0,
2512 );
2513 
2519  WDP_AUTO, "view_vehicle_train", 250, 134,
2521  0,
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 
2537  ZOOM_LVL_SHIP,
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 
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 
2619 private:
2624 
2627 
2630  };
2631  bool mouse_over_start_stop = false;
2632 
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:
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[] = {
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 
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) {
2754  this->SetWidgetDisabledState(WID_VV_FORCE_PROCEED, !is_localcompany);
2755  this->SetWidgetDisabledState(WID_VV_TURN_AROUND, !is_localcompany);
2756  }
2757 
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: {
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);
2820  SetDParam(2, v->GetDisplaySpeed());
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);
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,
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) {
2904  } else {
2905  ScrollMainWindowToTile(tile);
2906  }
2907  break;
2908  }
2909 
2910  case WID_VV_LOCATION: // center main view
2911  if (_ctrl_pressed) {
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
2929  break;
2930  case WID_VV_SHOW_ORDERS: // show orders
2931  if (_ctrl_pressed) {
2933  } else {
2934  ShowOrdersWindow(v);
2935  }
2936  break;
2937  case WID_VV_SHOW_DETAILS: // show details
2938  if (_ctrl_pressed) {
2940  } else {
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;
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);
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);
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 
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 {
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
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);
3088 }
3089 
3096 {
3097  switch (v->type) {
3098  case VEH_TRAIN:
3099  return Train::From(v)->GetDisplayImageWidth();
3100 
3101  case VEH_ROAD:
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 
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 
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:452
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:99
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:535
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:1688
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:530
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:532
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:453
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:534
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:533
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:102
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:558
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:567
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