OpenTTD Source  1.11.2
build_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 "engine_base.h"
12 #include "engine_func.h"
13 #include "station_base.h"
14 #include "network/network.h"
15 #include "articulated_vehicles.h"
16 #include "textbuf_gui.h"
17 #include "command_func.h"
18 #include "company_func.h"
19 #include "vehicle_gui.h"
20 #include "newgrf_engine.h"
21 #include "newgrf_text.h"
22 #include "group.h"
23 #include "string_func.h"
24 #include "strings_func.h"
25 #include "window_func.h"
26 #include "date_func.h"
27 #include "vehicle_func.h"
28 #include "widgets/dropdown_func.h"
29 #include "engine_gui.h"
30 #include "cargotype.h"
31 #include "core/geometry_func.hpp"
32 #include "autoreplace_func.h"
33 
35 
36 #include "table/strings.h"
37 
38 #include "safeguards.h"
39 
46 {
48 }
49 
50 static const NWidgetPart _nested_build_vehicle_widgets[] = {
52  NWidget(WWT_CLOSEBOX, COLOUR_GREY),
53  NWidget(WWT_CAPTION, COLOUR_GREY, WID_BV_CAPTION), SetDataTip(STR_WHITE_STRING, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
54  NWidget(WWT_SHADEBOX, COLOUR_GREY),
55  NWidget(WWT_DEFSIZEBOX, COLOUR_GREY),
56  NWidget(WWT_STICKYBOX, COLOUR_GREY),
57  EndContainer(),
58  NWidget(WWT_PANEL, COLOUR_GREY),
61  NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_BV_SORT_ASCENDING_DESCENDING), SetDataTip(STR_BUTTON_SORT_BY, STR_TOOLTIP_SORT_ORDER),
62  NWidget(WWT_DROPDOWN, COLOUR_GREY, WID_BV_SORT_DROPDOWN), SetResize(1, 0), SetFill(1, 0), SetDataTip(STR_JUST_STRING, STR_TOOLTIP_SORT_CRITERIA),
63  EndContainer(),
66  NWidget(WWT_DROPDOWN, COLOUR_GREY, WID_BV_CARGO_FILTER_DROPDOWN), SetResize(1, 0), SetFill(1, 0), SetDataTip(STR_JUST_STRING, STR_TOOLTIP_FILTER_CRITERIA),
67  EndContainer(),
68  EndContainer(),
69  EndContainer(),
70  /* Vehicle list. */
72  NWidget(WWT_MATRIX, COLOUR_GREY, WID_BV_LIST), SetResize(1, 1), SetFill(1, 0), SetMatrixDataTip(1, 0, STR_NULL), SetScrollbar(WID_BV_SCROLLBAR),
74  EndContainer(),
75  /* Panel with details. */
76  NWidget(WWT_PANEL, COLOUR_GREY, WID_BV_PANEL), SetMinimalSize(240, 122), SetResize(1, 0), EndContainer(),
77  /* Build/rename buttons, resize button. */
79  NWidget(NWID_SELECTION, INVALID_COLOUR, WID_BV_BUILD_SEL),
80  NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_BV_BUILD), SetResize(1, 0), SetFill(1, 0),
81  EndContainer(),
82  NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_BV_SHOW_HIDE), SetResize(1, 0), SetFill(1, 0), SetDataTip(STR_JUST_STRING, STR_NULL),
83  NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_BV_RENAME), SetResize(1, 0), SetFill(1, 0),
84  NWidget(WWT_RESIZEBOX, COLOUR_GREY),
85  EndContainer(),
86 };
87 
89 static const CargoID CF_ANY = CT_NO_REFIT;
90 static const CargoID CF_NONE = CT_INVALID;
92 
94 byte _engine_sort_last_criteria[] = {0, 0, 0, 0};
95 bool _engine_sort_last_order[] = {false, false, false, false};
96 bool _engine_sort_show_hidden_engines[] = {false, false, false, false};
98 
105 static bool EngineNumberSorter(const EngineID &a, const EngineID &b)
106 {
107  int r = Engine::Get(a)->list_position - Engine::Get(b)->list_position;
108 
109  return _engine_sort_direction ? r > 0 : r < 0;
110 }
111 
118 static bool EngineIntroDateSorter(const EngineID &a, const EngineID &b)
119 {
120  const int va = Engine::Get(a)->intro_date;
121  const int vb = Engine::Get(b)->intro_date;
122  const int r = va - vb;
123 
124  /* Use EngineID to sort instead since we want consistent sorting */
125  if (r == 0) return EngineNumberSorter(a, b);
126  return _engine_sort_direction ? r > 0 : r < 0;
127 }
128 
129 /* cached values for EngineNameSorter to spare many GetString() calls */
130 static EngineID _last_engine[2] = { INVALID_ENGINE, INVALID_ENGINE };
131 
138 static bool EngineNameSorter(const EngineID &a, const EngineID &b)
139 {
140  static char last_name[2][64] = { "", "" };
141 
142  if (a != _last_engine[0]) {
143  _last_engine[0] = a;
144  SetDParam(0, a);
145  GetString(last_name[0], STR_ENGINE_NAME, lastof(last_name[0]));
146  }
147 
148  if (b != _last_engine[1]) {
149  _last_engine[1] = b;
150  SetDParam(0, b);
151  GetString(last_name[1], STR_ENGINE_NAME, lastof(last_name[1]));
152  }
153 
154  int r = strnatcmp(last_name[0], last_name[1]); // Sort by name (natural sorting).
155 
156  /* Use EngineID to sort instead since we want consistent sorting */
157  if (r == 0) return EngineNumberSorter(a, b);
158  return _engine_sort_direction ? r > 0 : r < 0;
159 }
160 
167 static bool EngineReliabilitySorter(const EngineID &a, const EngineID &b)
168 {
169  const int va = Engine::Get(a)->reliability;
170  const int vb = Engine::Get(b)->reliability;
171  const int r = va - vb;
172 
173  /* Use EngineID to sort instead since we want consistent sorting */
174  if (r == 0) return EngineNumberSorter(a, b);
175  return _engine_sort_direction ? r > 0 : r < 0;
176 }
177 
184 static bool EngineCostSorter(const EngineID &a, const EngineID &b)
185 {
186  Money va = Engine::Get(a)->GetCost();
187  Money vb = Engine::Get(b)->GetCost();
188  int r = ClampToI32(va - vb);
189 
190  /* Use EngineID to sort instead since we want consistent sorting */
191  if (r == 0) return EngineNumberSorter(a, b);
192  return _engine_sort_direction ? r > 0 : r < 0;
193 }
194 
201 static bool EngineSpeedSorter(const EngineID &a, const EngineID &b)
202 {
203  int va = Engine::Get(a)->GetDisplayMaxSpeed();
204  int vb = Engine::Get(b)->GetDisplayMaxSpeed();
205  int r = va - vb;
206 
207  /* Use EngineID to sort instead since we want consistent sorting */
208  if (r == 0) return EngineNumberSorter(a, b);
209  return _engine_sort_direction ? r > 0 : r < 0;
210 }
211 
218 static bool EnginePowerSorter(const EngineID &a, const EngineID &b)
219 {
220  int va = Engine::Get(a)->GetPower();
221  int vb = Engine::Get(b)->GetPower();
222  int r = va - vb;
223 
224  /* Use EngineID to sort instead since we want consistent sorting */
225  if (r == 0) return EngineNumberSorter(a, b);
226  return _engine_sort_direction ? r > 0 : r < 0;
227 }
228 
235 static bool EngineTractiveEffortSorter(const EngineID &a, const EngineID &b)
236 {
237  int va = Engine::Get(a)->GetDisplayMaxTractiveEffort();
238  int vb = Engine::Get(b)->GetDisplayMaxTractiveEffort();
239  int r = va - vb;
240 
241  /* Use EngineID to sort instead since we want consistent sorting */
242  if (r == 0) return EngineNumberSorter(a, b);
243  return _engine_sort_direction ? r > 0 : r < 0;
244 }
245 
252 static bool EngineRunningCostSorter(const EngineID &a, const EngineID &b)
253 {
254  Money va = Engine::Get(a)->GetRunningCost();
255  Money vb = Engine::Get(b)->GetRunningCost();
256  int r = ClampToI32(va - vb);
257 
258  /* Use EngineID to sort instead since we want consistent sorting */
259  if (r == 0) return EngineNumberSorter(a, b);
260  return _engine_sort_direction ? r > 0 : r < 0;
261 }
262 
269 static bool EnginePowerVsRunningCostSorter(const EngineID &a, const EngineID &b)
270 {
271  const Engine *e_a = Engine::Get(a);
272  const Engine *e_b = Engine::Get(b);
273  uint p_a = e_a->GetPower();
274  uint p_b = e_b->GetPower();
275  Money r_a = e_a->GetRunningCost();
276  Money r_b = e_b->GetRunningCost();
277  /* Check if running cost is zero in one or both engines.
278  * If only one of them is zero then that one has higher value,
279  * else if both have zero cost then compare powers. */
280  if (r_a == 0) {
281  if (r_b == 0) {
282  /* If it is ambiguous which to return go with their ID */
283  if (p_a == p_b) return EngineNumberSorter(a, b);
284  return _engine_sort_direction != (p_a < p_b);
285  }
286  return !_engine_sort_direction;
287  }
288  if (r_b == 0) return _engine_sort_direction;
289  /* Using double for more precision when comparing close values.
290  * This shouldn't have any major effects in performance nor in keeping
291  * the game in sync between players since it's used in GUI only in client side */
292  double v_a = (double)p_a / (double)r_a;
293  double v_b = (double)p_b / (double)r_b;
294  /* Use EngineID to sort if both have same power/running cost,
295  * since we want consistent sorting.
296  * Also if both have no power then sort with reverse of running cost to simulate
297  * previous sorting behaviour for wagons. */
298  if (v_a == 0 && v_b == 0) return !EngineRunningCostSorter(a, b);
299  if (v_a == v_b) return EngineNumberSorter(a, b);
300  return _engine_sort_direction != (v_a < v_b);
301 }
302 
303 /* Train sorting functions */
304 
311 static bool TrainEngineCapacitySorter(const EngineID &a, const EngineID &b)
312 {
313  const RailVehicleInfo *rvi_a = RailVehInfo(a);
314  const RailVehicleInfo *rvi_b = RailVehInfo(b);
315 
316  int va = GetTotalCapacityOfArticulatedParts(a) * (rvi_a->railveh_type == RAILVEH_MULTIHEAD ? 2 : 1);
317  int vb = GetTotalCapacityOfArticulatedParts(b) * (rvi_b->railveh_type == RAILVEH_MULTIHEAD ? 2 : 1);
318  int r = va - vb;
319 
320  /* Use EngineID to sort instead since we want consistent sorting */
321  if (r == 0) return EngineNumberSorter(a, b);
322  return _engine_sort_direction ? r > 0 : r < 0;
323 }
324 
331 static bool TrainEnginesThenWagonsSorter(const EngineID &a, const EngineID &b)
332 {
333  int val_a = (RailVehInfo(a)->railveh_type == RAILVEH_WAGON ? 1 : 0);
334  int val_b = (RailVehInfo(b)->railveh_type == RAILVEH_WAGON ? 1 : 0);
335  int r = val_a - val_b;
336 
337  /* Use EngineID to sort instead since we want consistent sorting */
338  if (r == 0) return EngineNumberSorter(a, b);
339  return _engine_sort_direction ? r > 0 : r < 0;
340 }
341 
342 /* Road vehicle sorting functions */
343 
350 static bool RoadVehEngineCapacitySorter(const EngineID &a, const EngineID &b)
351 {
354  int r = va - vb;
355 
356  /* Use EngineID to sort instead since we want consistent sorting */
357  if (r == 0) return EngineNumberSorter(a, b);
358  return _engine_sort_direction ? r > 0 : r < 0;
359 }
360 
361 /* Ship vehicle sorting functions */
362 
369 static bool ShipEngineCapacitySorter(const EngineID &a, const EngineID &b)
370 {
371  const Engine *e_a = Engine::Get(a);
372  const Engine *e_b = Engine::Get(b);
373 
374  int va = e_a->GetDisplayDefaultCapacity();
375  int vb = e_b->GetDisplayDefaultCapacity();
376  int r = va - vb;
377 
378  /* Use EngineID to sort instead since we want consistent sorting */
379  if (r == 0) return EngineNumberSorter(a, b);
380  return _engine_sort_direction ? r > 0 : r < 0;
381 }
382 
383 /* Aircraft sorting functions */
384 
391 static bool AircraftEngineCargoSorter(const EngineID &a, const EngineID &b)
392 {
393  const Engine *e_a = Engine::Get(a);
394  const Engine *e_b = Engine::Get(b);
395 
396  uint16 mail_a, mail_b;
397  int va = e_a->GetDisplayDefaultCapacity(&mail_a);
398  int vb = e_b->GetDisplayDefaultCapacity(&mail_b);
399  int r = va - vb;
400 
401  if (r == 0) {
402  /* The planes have the same passenger capacity. Check mail capacity instead */
403  r = mail_a - mail_b;
404 
405  if (r == 0) {
406  /* Use EngineID to sort instead since we want consistent sorting */
407  return EngineNumberSorter(a, b);
408  }
409  }
410  return _engine_sort_direction ? r > 0 : r < 0;
411 }
412 
419 static bool AircraftRangeSorter(const EngineID &a, const EngineID &b)
420 {
421  uint16 r_a = Engine::Get(a)->GetRange();
422  uint16 r_b = Engine::Get(b)->GetRange();
423 
424  int r = r_a - r_b;
425 
426  /* Use EngineID to sort instead since we want consistent sorting */
427  if (r == 0) return EngineNumberSorter(a, b);
428  return _engine_sort_direction ? r > 0 : r < 0;
429 }
430 
433  /* Trains */
445 }, {
446  /* Road vehicles */
458 }, {
459  /* Ships */
468 }, {
469  /* Aircraft */
479 }};
480 
483  /* Trains */
484  STR_SORT_BY_ENGINE_ID,
485  STR_SORT_BY_COST,
486  STR_SORT_BY_MAX_SPEED,
487  STR_SORT_BY_POWER,
488  STR_SORT_BY_TRACTIVE_EFFORT,
489  STR_SORT_BY_INTRO_DATE,
490  STR_SORT_BY_NAME,
491  STR_SORT_BY_RUNNING_COST,
492  STR_SORT_BY_POWER_VS_RUNNING_COST,
493  STR_SORT_BY_RELIABILITY,
494  STR_SORT_BY_CARGO_CAPACITY,
496 }, {
497  /* Road vehicles */
498  STR_SORT_BY_ENGINE_ID,
499  STR_SORT_BY_COST,
500  STR_SORT_BY_MAX_SPEED,
501  STR_SORT_BY_POWER,
502  STR_SORT_BY_TRACTIVE_EFFORT,
503  STR_SORT_BY_INTRO_DATE,
504  STR_SORT_BY_NAME,
505  STR_SORT_BY_RUNNING_COST,
506  STR_SORT_BY_POWER_VS_RUNNING_COST,
507  STR_SORT_BY_RELIABILITY,
508  STR_SORT_BY_CARGO_CAPACITY,
510 }, {
511  /* Ships */
512  STR_SORT_BY_ENGINE_ID,
513  STR_SORT_BY_COST,
514  STR_SORT_BY_MAX_SPEED,
515  STR_SORT_BY_INTRO_DATE,
516  STR_SORT_BY_NAME,
517  STR_SORT_BY_RUNNING_COST,
518  STR_SORT_BY_RELIABILITY,
519  STR_SORT_BY_CARGO_CAPACITY,
521 }, {
522  /* Aircraft */
523  STR_SORT_BY_ENGINE_ID,
524  STR_SORT_BY_COST,
525  STR_SORT_BY_MAX_SPEED,
526  STR_SORT_BY_INTRO_DATE,
527  STR_SORT_BY_NAME,
528  STR_SORT_BY_RUNNING_COST,
529  STR_SORT_BY_RELIABILITY,
530  STR_SORT_BY_CARGO_CAPACITY,
531  STR_SORT_BY_RANGE,
533 }};
534 
536 static bool CDECL CargoAndEngineFilter(const EngineID *eid, const CargoID cid)
537 {
538  if (cid == CF_ANY) {
539  return true;
540  } else if (cid == CF_ENGINES) {
541  return Engine::Get(*eid)->GetPower() != 0;
542  } else {
543  CargoTypes refit_mask = GetUnionOfArticulatedRefitMasks(*eid, true) & _standard_cargo_mask;
544  return (cid == CF_NONE ? refit_mask == 0 : HasBit(refit_mask, cid));
545  }
546 }
547 
548 static GUIEngineList::FilterFunction * const _filter_funcs[] = {
550 };
551 
552 static int DrawCargoCapacityInfo(int left, int right, int y, EngineID engine, TestedEngineDetails &te)
553 {
554  CargoArray cap;
555  CargoTypes refits;
556  GetArticulatedVehicleCargoesAndRefits(engine, &cap, &refits, te.cargo, te.capacity);
557 
558  for (CargoID c = 0; c < NUM_CARGO; c++) {
559  if (cap[c] == 0) continue;
560 
561  SetDParam(0, c);
562  SetDParam(1, cap[c]);
563  SetDParam(2, HasBit(refits, c) ? STR_PURCHASE_INFO_REFITTABLE : STR_EMPTY);
564  DrawString(left, right, y, STR_PURCHASE_INFO_CAPACITY);
565  y += FONT_HEIGHT_NORMAL;
566  }
567 
568  return y;
569 }
570 
571 /* Draw rail wagon specific details */
572 static int DrawRailWagonPurchaseInfo(int left, int right, int y, EngineID engine_number, const RailVehicleInfo *rvi, TestedEngineDetails &te)
573 {
574  const Engine *e = Engine::Get(engine_number);
575 
576  /* Purchase cost */
577  if (te.cost != 0) {
578  SetDParam(0, e->GetCost() + te.cost);
579  SetDParam(1, te.cost);
580  DrawString(left, right, y, STR_PURCHASE_INFO_COST_REFIT);
581  } else {
582  SetDParam(0, e->GetCost());
583  DrawString(left, right, y, STR_PURCHASE_INFO_COST);
584  }
585  y += FONT_HEIGHT_NORMAL;
586 
587  /* Wagon weight - (including cargo) */
588  uint weight = e->GetDisplayWeight();
589  SetDParam(0, weight);
590  uint cargo_weight = (e->CanCarryCargo() ? CargoSpec::Get(te.cargo)->weight * te.capacity / 16 : 0);
591  SetDParam(1, cargo_weight + weight);
592  DrawString(left, right, y, STR_PURCHASE_INFO_WEIGHT_CWEIGHT);
593  y += FONT_HEIGHT_NORMAL;
594 
595  /* Wagon speed limit, displayed if above zero */
597  uint max_speed = e->GetDisplayMaxSpeed();
598  if (max_speed > 0) {
599  SetDParam(0, max_speed);
600  DrawString(left, right, y, STR_PURCHASE_INFO_SPEED);
601  y += FONT_HEIGHT_NORMAL;
602  }
603  }
604 
605  /* Running cost */
606  if (rvi->running_cost_class != INVALID_PRICE) {
607  SetDParam(0, e->GetRunningCost());
608  DrawString(left, right, y, STR_PURCHASE_INFO_RUNNINGCOST);
609  y += FONT_HEIGHT_NORMAL;
610  }
611 
612  return y;
613 }
614 
615 /* Draw locomotive specific details */
616 static int DrawRailEnginePurchaseInfo(int left, int right, int y, EngineID engine_number, const RailVehicleInfo *rvi, TestedEngineDetails &te)
617 {
618  const Engine *e = Engine::Get(engine_number);
619 
620  /* Purchase Cost - Engine weight */
621  if (te.cost != 0) {
622  SetDParam(0, e->GetCost() + te.cost);
623  SetDParam(1, te.cost);
624  SetDParam(2, e->GetDisplayWeight());
625  DrawString(left, right, y, STR_PURCHASE_INFO_COST_REFIT_WEIGHT);
626  } else {
627  SetDParam(0, e->GetCost());
628  SetDParam(1, e->GetDisplayWeight());
629  DrawString(left, right, y, STR_PURCHASE_INFO_COST_WEIGHT);
630  }
631  y += FONT_HEIGHT_NORMAL;
632 
633  /* Max speed - Engine power */
634  SetDParam(0, e->GetDisplayMaxSpeed());
635  SetDParam(1, e->GetPower());
636  DrawString(left, right, y, STR_PURCHASE_INFO_SPEED_POWER);
637  y += FONT_HEIGHT_NORMAL;
638 
639  /* Max tractive effort - not applicable if old acceleration or maglev */
640  if (_settings_game.vehicle.train_acceleration_model != AM_ORIGINAL && GetRailTypeInfo(rvi->railtype)->acceleration_type != 2) {
642  DrawString(left, right, y, STR_PURCHASE_INFO_MAX_TE);
643  y += FONT_HEIGHT_NORMAL;
644  }
645 
646  /* Running cost */
647  if (rvi->running_cost_class != INVALID_PRICE) {
648  SetDParam(0, e->GetRunningCost());
649  DrawString(left, right, y, STR_PURCHASE_INFO_RUNNINGCOST);
650  y += FONT_HEIGHT_NORMAL;
651  }
652 
653  /* Powered wagons power - Powered wagons extra weight */
654  if (rvi->pow_wag_power != 0) {
655  SetDParam(0, rvi->pow_wag_power);
656  SetDParam(1, rvi->pow_wag_weight);
657  DrawString(left, right, y, STR_PURCHASE_INFO_PWAGPOWER_PWAGWEIGHT);
658  y += FONT_HEIGHT_NORMAL;
659  }
660 
661  return y;
662 }
663 
664 /* Draw road vehicle specific details */
665 static int DrawRoadVehPurchaseInfo(int left, int right, int y, EngineID engine_number, TestedEngineDetails &te)
666 {
667  const Engine *e = Engine::Get(engine_number);
668 
670  /* Purchase Cost */
671  if (te.cost != 0) {
672  SetDParam(0, e->GetCost() + te.cost);
673  SetDParam(1, te.cost);
674  DrawString(left, right, y, STR_PURCHASE_INFO_COST_REFIT);
675  } else {
676  SetDParam(0, e->GetCost());
677  DrawString(left, right, y, STR_PURCHASE_INFO_COST);
678  }
679  y += FONT_HEIGHT_NORMAL;
680 
681  /* Road vehicle weight - (including cargo) */
682  int16 weight = e->GetDisplayWeight();
683  SetDParam(0, weight);
684  uint cargo_weight = (e->CanCarryCargo() ? CargoSpec::Get(te.cargo)->weight * te.capacity / 16 : 0);
685  SetDParam(1, cargo_weight + weight);
686  DrawString(left, right, y, STR_PURCHASE_INFO_WEIGHT_CWEIGHT);
687  y += FONT_HEIGHT_NORMAL;
688 
689  /* Max speed - Engine power */
690  SetDParam(0, e->GetDisplayMaxSpeed());
691  SetDParam(1, e->GetPower());
692  DrawString(left, right, y, STR_PURCHASE_INFO_SPEED_POWER);
693  y += FONT_HEIGHT_NORMAL;
694 
695  /* Max tractive effort */
697  DrawString(left, right, y, STR_PURCHASE_INFO_MAX_TE);
698  y += FONT_HEIGHT_NORMAL;
699  } else {
700  /* Purchase cost - Max speed */
701  if (te.cost != 0) {
702  SetDParam(0, e->GetCost() + te.cost);
703  SetDParam(1, te.cost);
704  SetDParam(2, e->GetDisplayMaxSpeed());
705  DrawString(left, right, y, STR_PURCHASE_INFO_COST_REFIT_SPEED);
706  } else {
707  SetDParam(0, e->GetCost());
708  SetDParam(1, e->GetDisplayMaxSpeed());
709  DrawString(left, right, y, STR_PURCHASE_INFO_COST_SPEED);
710  }
711  y += FONT_HEIGHT_NORMAL;
712  }
713 
714  /* Running cost */
715  SetDParam(0, e->GetRunningCost());
716  DrawString(left, right, y, STR_PURCHASE_INFO_RUNNINGCOST);
717  y += FONT_HEIGHT_NORMAL;
718 
719  return y;
720 }
721 
722 /* Draw ship specific details */
723 static int DrawShipPurchaseInfo(int left, int right, int y, EngineID engine_number, bool refittable, TestedEngineDetails &te)
724 {
725  const Engine *e = Engine::Get(engine_number);
726 
727  /* Purchase cost - Max speed */
728  uint raw_speed = e->GetDisplayMaxSpeed();
729  uint ocean_speed = e->u.ship.ApplyWaterClassSpeedFrac(raw_speed, true);
730  uint canal_speed = e->u.ship.ApplyWaterClassSpeedFrac(raw_speed, false);
731 
732  if (ocean_speed == canal_speed) {
733  if (te.cost != 0) {
734  SetDParam(0, e->GetCost() + te.cost);
735  SetDParam(1, te.cost);
736  SetDParam(2, ocean_speed);
737  DrawString(left, right, y, STR_PURCHASE_INFO_COST_REFIT_SPEED);
738  } else {
739  SetDParam(0, e->GetCost());
740  SetDParam(1, ocean_speed);
741  DrawString(left, right, y, STR_PURCHASE_INFO_COST_SPEED);
742  }
743  y += FONT_HEIGHT_NORMAL;
744  } else {
745  if (te.cost != 0) {
746  SetDParam(0, e->GetCost() + te.cost);
747  SetDParam(1, te.cost);
748  DrawString(left, right, y, STR_PURCHASE_INFO_COST_REFIT);
749  } else {
750  SetDParam(0, e->GetCost());
751  DrawString(left, right, y, STR_PURCHASE_INFO_COST);
752  }
753  y += FONT_HEIGHT_NORMAL;
754 
755  SetDParam(0, ocean_speed);
756  DrawString(left, right, y, STR_PURCHASE_INFO_SPEED_OCEAN);
757  y += FONT_HEIGHT_NORMAL;
758 
759  SetDParam(0, canal_speed);
760  DrawString(left, right, y, STR_PURCHASE_INFO_SPEED_CANAL);
761  y += FONT_HEIGHT_NORMAL;
762  }
763 
764  /* Cargo type + capacity */
765  SetDParam(0, te.cargo);
766  SetDParam(1, te.capacity);
767  SetDParam(2, refittable ? STR_PURCHASE_INFO_REFITTABLE : STR_EMPTY);
768  DrawString(left, right, y, STR_PURCHASE_INFO_CAPACITY);
769  y += FONT_HEIGHT_NORMAL;
770 
771  /* Running cost */
772  SetDParam(0, e->GetRunningCost());
773  DrawString(left, right, y, STR_PURCHASE_INFO_RUNNINGCOST);
774  y += FONT_HEIGHT_NORMAL;
775 
776  return y;
777 }
778 
788 static int DrawAircraftPurchaseInfo(int left, int right, int y, EngineID engine_number, bool refittable, TestedEngineDetails &te)
789 {
790  const Engine *e = Engine::Get(engine_number);
791 
792  /* Purchase cost - Max speed */
793  if (te.cost != 0) {
794  SetDParam(0, e->GetCost() + te.cost);
795  SetDParam(1, te.cost);
796  SetDParam(2, e->GetDisplayMaxSpeed());
797  DrawString(left, right, y, STR_PURCHASE_INFO_COST_REFIT_SPEED);
798  } else {
799  SetDParam(0, e->GetCost());
800  SetDParam(1, e->GetDisplayMaxSpeed());
801  DrawString(left, right, y, STR_PURCHASE_INFO_COST_SPEED);
802  }
803  y += FONT_HEIGHT_NORMAL;
804 
805  /* Cargo capacity */
806  if (te.mail_capacity > 0) {
807  SetDParam(0, te.cargo);
808  SetDParam(1, te.capacity);
809  SetDParam(2, CT_MAIL);
810  SetDParam(3, te.mail_capacity);
811  DrawString(left, right, y, STR_PURCHASE_INFO_AIRCRAFT_CAPACITY);
812  } else {
813  /* Note, if the default capacity is selected by the refit capacity
814  * callback, then the capacity shown is likely to be incorrect. */
815  SetDParam(0, te.cargo);
816  SetDParam(1, te.capacity);
817  SetDParam(2, refittable ? STR_PURCHASE_INFO_REFITTABLE : STR_EMPTY);
818  DrawString(left, right, y, STR_PURCHASE_INFO_CAPACITY);
819  }
820  y += FONT_HEIGHT_NORMAL;
821 
822  /* Running cost */
823  SetDParam(0, e->GetRunningCost());
824  DrawString(left, right, y, STR_PURCHASE_INFO_RUNNINGCOST);
825  y += FONT_HEIGHT_NORMAL;
826 
827  /* Aircraft type */
829  DrawString(left, right, y, STR_PURCHASE_INFO_AIRCRAFT_TYPE);
830  y += FONT_HEIGHT_NORMAL;
831 
832  /* Aircraft range, if available. */
833  uint16 range = e->GetRange();
834  if (range != 0) {
835  SetDParam(0, range);
836  DrawString(left, right, y, STR_PURCHASE_INFO_AIRCRAFT_RANGE);
837  y += FONT_HEIGHT_NORMAL;
838  }
839 
840  return y;
841 }
842 
851 static uint ShowAdditionalText(int left, int right, int y, EngineID engine)
852 {
853  uint16 callback = GetVehicleCallback(CBID_VEHICLE_ADDITIONAL_TEXT, 0, 0, engine, nullptr);
854  if (callback == CALLBACK_FAILED || callback == 0x400) return y;
855  const GRFFile *grffile = Engine::Get(engine)->GetGRF();
856  if (callback > 0x400) {
857  ErrorUnknownCallbackResult(grffile->grfid, CBID_VEHICLE_ADDITIONAL_TEXT, callback);
858  return y;
859  }
860 
861  StartTextRefStackUsage(grffile, 6);
862  uint result = DrawStringMultiLine(left, right, y, INT32_MAX, GetGRFStringID(grffile->grfid, 0xD000 + callback), TC_BLACK);
864  return result;
865 }
866 
873 int DrawVehiclePurchaseInfo(int left, int right, int y, EngineID engine_number, TestedEngineDetails &te)
874 {
875  const Engine *e = Engine::Get(engine_number);
876  YearMonthDay ymd;
877  ConvertDateToYMD(e->intro_date, &ymd);
878  bool refittable = IsArticulatedVehicleRefittable(engine_number);
879  bool articulated_cargo = false;
880 
881  switch (e->type) {
882  default: NOT_REACHED();
883  case VEH_TRAIN:
884  if (e->u.rail.railveh_type == RAILVEH_WAGON) {
885  y = DrawRailWagonPurchaseInfo(left, right, y, engine_number, &e->u.rail, te);
886  } else {
887  y = DrawRailEnginePurchaseInfo(left, right, y, engine_number, &e->u.rail, te);
888  }
889  articulated_cargo = true;
890  break;
891 
892  case VEH_ROAD:
893  y = DrawRoadVehPurchaseInfo(left, right, y, engine_number, te);
894  articulated_cargo = true;
895  break;
896 
897  case VEH_SHIP:
898  y = DrawShipPurchaseInfo(left, right, y, engine_number, refittable, te);
899  break;
900 
901  case VEH_AIRCRAFT:
902  y = DrawAircraftPurchaseInfo(left, right, y, engine_number, refittable, te);
903  break;
904  }
905 
906  if (articulated_cargo) {
907  /* Cargo type + capacity, or N/A */
908  int new_y = DrawCargoCapacityInfo(left, right, y, engine_number, te);
909 
910  if (new_y == y) {
911  SetDParam(0, CT_INVALID);
912  SetDParam(2, STR_EMPTY);
913  DrawString(left, right, y, STR_PURCHASE_INFO_CAPACITY);
914  y += FONT_HEIGHT_NORMAL;
915  } else {
916  y = new_y;
917  }
918  }
919 
920  /* Draw details that apply to all types except rail wagons. */
921  if (e->type != VEH_TRAIN || e->u.rail.railveh_type != RAILVEH_WAGON) {
922  /* Design date - Life length */
923  SetDParam(0, ymd.year);
925  DrawString(left, right, y, STR_PURCHASE_INFO_DESIGNED_LIFE);
926  y += FONT_HEIGHT_NORMAL;
927 
928  /* Reliability */
930  DrawString(left, right, y, STR_PURCHASE_INFO_RELIABILITY);
931  y += FONT_HEIGHT_NORMAL;
932  }
933 
934  if (refittable) y = ShowRefitOptionsList(left, right, y, engine_number);
935 
936  /* Additional text from NewGRF */
937  y = ShowAdditionalText(left, right, y, engine_number);
938 
939  /* The NewGRF's name which the vehicle comes from */
940  const GRFConfig *config = GetGRFConfig(e->GetGRFID());
941  if (_settings_client.gui.show_newgrf_name && config != nullptr)
942  {
943  DrawString(left, right, y, config->GetName(), TC_BLACK);
944  y += FONT_HEIGHT_NORMAL;
945  }
946 
947  return y;
948 }
949 
963 void DrawEngineList(VehicleType type, int l, int r, int y, const GUIEngineList *eng_list, uint16 min, uint16 max, EngineID selected_id, bool show_count, GroupID selected_group)
964 {
965  static const int sprite_y_offsets[] = { -1, -1, -2, -2 };
966 
967  /* Obligatory sanity checks! */
968  assert(max <= eng_list->size());
969 
970  bool rtl = _current_text_dir == TD_RTL;
971  int step_size = GetEngineListHeight(type);
972  int sprite_left = GetVehicleImageCellSize(type, EIT_PURCHASE).extend_left;
973  int sprite_right = GetVehicleImageCellSize(type, EIT_PURCHASE).extend_right;
974  int sprite_width = sprite_left + sprite_right;
975 
976  int sprite_x = rtl ? r - sprite_right - 1 : l + sprite_left + 1;
977  int sprite_y_offset = sprite_y_offsets[type] + step_size / 2;
978 
979  Dimension replace_icon = {0, 0};
980  int count_width = 0;
981  if (show_count) {
982  replace_icon = GetSpriteSize(SPR_GROUP_REPLACE_ACTIVE);
984  count_width = GetStringBoundingBox(STR_TINY_BLACK_COMA).width;
985  }
986 
987  int text_left = l + (rtl ? WD_FRAMERECT_LEFT + replace_icon.width + 8 + count_width : sprite_width + WD_FRAMETEXT_LEFT);
988  int text_right = r - (rtl ? sprite_width + WD_FRAMETEXT_RIGHT : WD_FRAMERECT_RIGHT + replace_icon.width + 8 + count_width);
989  int replace_icon_left = rtl ? l + WD_FRAMERECT_LEFT : r - WD_FRAMERECT_RIGHT - replace_icon.width;
990  int count_left = l;
991  int count_right = rtl ? text_left : r - WD_FRAMERECT_RIGHT - replace_icon.width - 8;
992 
993  int normal_text_y_offset = (step_size - FONT_HEIGHT_NORMAL) / 2;
994  int small_text_y_offset = step_size - FONT_HEIGHT_SMALL - WD_FRAMERECT_BOTTOM - 1;
995  int replace_icon_y_offset = (step_size - replace_icon.height) / 2 - 1;
996 
997  for (; min < max; min++, y += step_size) {
998  const EngineID engine = (*eng_list)[min];
999  /* Note: num_engines is only used in the autoreplace GUI, so it is correct to use _local_company here. */
1000  const uint num_engines = GetGroupNumEngines(_local_company, selected_group, engine);
1001 
1002  const Engine *e = Engine::Get(engine);
1003  bool hidden = HasBit(e->company_hidden, _local_company);
1004  StringID str = hidden ? STR_HIDDEN_ENGINE_NAME : STR_ENGINE_NAME;
1005  TextColour tc = (engine == selected_id) ? TC_WHITE : (TC_NO_SHADE | (hidden ? TC_GREY : TC_BLACK));
1006 
1007  SetDParam(0, engine);
1008  DrawString(text_left, text_right, y + normal_text_y_offset, str, tc);
1009  DrawVehicleEngine(l, r, sprite_x, y + sprite_y_offset, engine, (show_count && num_engines == 0) ? PALETTE_CRASH : GetEnginePalette(engine, _local_company), EIT_PURCHASE);
1010  if (show_count) {
1011  SetDParam(0, num_engines);
1012  DrawString(count_left, count_right, y + small_text_y_offset, STR_TINY_BLACK_COMA, TC_FROMSTRING, SA_RIGHT | SA_FORCE);
1013  if (EngineHasReplacementForCompany(Company::Get(_local_company), engine, selected_group)) DrawSprite(SPR_GROUP_REPLACE_ACTIVE, num_engines == 0 ? PALETTE_CRASH : PAL_NONE, replace_icon_left, y + replace_icon_y_offset);
1014  }
1015  }
1016 }
1017 
1025 void DisplayVehicleSortDropDown(Window *w, VehicleType vehicle_type, int selected, int button)
1026 {
1027  uint32 hidden_mask = 0;
1028  /* Disable sorting by power or tractive effort when the original acceleration model for road vehicles is being used. */
1029  if (vehicle_type == VEH_ROAD && _settings_game.vehicle.roadveh_acceleration_model == AM_ORIGINAL) {
1030  SetBit(hidden_mask, 3); // power
1031  SetBit(hidden_mask, 4); // tractive effort
1032  SetBit(hidden_mask, 8); // power by running costs
1033  }
1034  /* Disable sorting by tractive effort when the original acceleration model for trains is being used. */
1035  if (vehicle_type == VEH_TRAIN && _settings_game.vehicle.train_acceleration_model == AM_ORIGINAL) {
1036  SetBit(hidden_mask, 4); // tractive effort
1037  }
1038  ShowDropDownMenu(w, _engine_sort_listing[vehicle_type], selected, button, 0, hidden_mask);
1039 }
1040 
1044  union {
1047  } filter;
1054  GUIEngineList eng_list;
1059  Scrollbar *vscroll;
1061 
1062  void SetBuyVehicleText()
1063  {
1064  NWidgetCore *widget = this->GetWidget<NWidgetCore>(WID_BV_BUILD);
1065 
1066  bool refit = this->sel_engine != INVALID_ENGINE && this->cargo_filter[this->cargo_filter_criteria] != CF_ANY && this->cargo_filter[this->cargo_filter_criteria] != CF_NONE;
1067  if (refit) refit = Engine::Get(this->sel_engine)->GetDefaultCargoType() != this->cargo_filter[this->cargo_filter_criteria];
1068 
1069  if (refit) {
1070  widget->widget_data = STR_BUY_VEHICLE_TRAIN_BUY_REFIT_VEHICLE_BUTTON + this->vehicle_type;
1071  widget->tool_tip = STR_BUY_VEHICLE_TRAIN_BUY_REFIT_VEHICLE_TOOLTIP + this->vehicle_type;
1072  } else {
1073  widget->widget_data = STR_BUY_VEHICLE_TRAIN_BUY_VEHICLE_BUTTON + this->vehicle_type;
1074  widget->tool_tip = STR_BUY_VEHICLE_TRAIN_BUY_VEHICLE_TOOLTIP + this->vehicle_type;
1075  }
1076  }
1077 
1078  BuildVehicleWindow(WindowDesc *desc, TileIndex tile, VehicleType type) : Window(desc)
1079  {
1080  this->vehicle_type = type;
1081  this->listview_mode = tile == INVALID_TILE;
1082  this->window_number = this->listview_mode ? (int)type : tile;
1083 
1084  this->sel_engine = INVALID_ENGINE;
1085 
1086  this->sort_criteria = _engine_sort_last_criteria[type];
1087  this->descending_sort_order = _engine_sort_last_order[type];
1088  this->show_hidden_engines = _engine_sort_show_hidden_engines[type];
1089 
1090  this->UpdateFilterByTile();
1091 
1092  this->CreateNestedTree();
1093 
1094  this->vscroll = this->GetScrollbar(WID_BV_SCROLLBAR);
1095 
1096  /* If we are just viewing the list of vehicles, we do not need the Build button.
1097  * So we just hide it, and enlarge the Rename button by the now vacant place. */
1098  if (this->listview_mode) this->GetWidget<NWidgetStacked>(WID_BV_BUILD_SEL)->SetDisplayedPlane(SZSP_NONE);
1099 
1100  /* disable renaming engines in network games if you are not the server */
1102 
1103  NWidgetCore *widget = this->GetWidget<NWidgetCore>(WID_BV_LIST);
1104  widget->tool_tip = STR_BUY_VEHICLE_TRAIN_LIST_TOOLTIP + type;
1105 
1106  widget = this->GetWidget<NWidgetCore>(WID_BV_SHOW_HIDE);
1107  widget->tool_tip = STR_BUY_VEHICLE_TRAIN_HIDE_SHOW_TOGGLE_TOOLTIP + type;
1108 
1109  widget = this->GetWidget<NWidgetCore>(WID_BV_RENAME);
1110  widget->widget_data = STR_BUY_VEHICLE_TRAIN_RENAME_BUTTON + type;
1111  widget->tool_tip = STR_BUY_VEHICLE_TRAIN_RENAME_TOOLTIP + type;
1112 
1113  widget = this->GetWidget<NWidgetCore>(WID_BV_SHOW_HIDDEN_ENGINES);
1114  widget->widget_data = STR_SHOW_HIDDEN_ENGINES_VEHICLE_TRAIN + type;
1115  widget->tool_tip = STR_SHOW_HIDDEN_ENGINES_VEHICLE_TRAIN_TOOLTIP + type;
1116  widget->SetLowered(this->show_hidden_engines);
1117 
1118  this->details_height = ((this->vehicle_type == VEH_TRAIN) ? 10 : 9);
1119 
1120  this->FinishInitNested(tile == INVALID_TILE ? (int)type : tile);
1121 
1122  this->owner = (tile != INVALID_TILE) ? GetTileOwner(tile) : _local_company;
1123 
1124  this->eng_list.ForceRebuild();
1125  this->GenerateBuildList(); // generate the list, since we need it in the next line
1126  /* Select the first engine in the list as default when opening the window */
1127  if (this->eng_list.size() > 0) {
1128  this->SelectEngine(this->eng_list[0]);
1129  } else {
1130  this->SelectEngine(INVALID_ENGINE);
1131  }
1132  }
1133 
1136  {
1137  switch (this->vehicle_type) {
1138  default: NOT_REACHED();
1139  case VEH_TRAIN:
1140  if (this->listview_mode) {
1141  this->filter.railtype = INVALID_RAILTYPE;
1142  } else {
1143  this->filter.railtype = GetRailType(this->window_number);
1144  }
1145  break;
1146 
1147  case VEH_ROAD:
1148  if (this->listview_mode) {
1149  this->filter.roadtype = INVALID_ROADTYPE;
1150  } else {
1151  this->filter.roadtype = GetRoadTypeRoad(this->window_number);
1152  if (this->filter.roadtype == INVALID_ROADTYPE) {
1153  this->filter.roadtype = GetRoadTypeTram(this->window_number);
1154  }
1155  }
1156  break;
1157 
1158  case VEH_SHIP:
1159  case VEH_AIRCRAFT:
1160  break;
1161  }
1162  }
1163 
1166  {
1167  uint filter_items = 0;
1168 
1169  /* Add item for disabling filtering. */
1170  this->cargo_filter[filter_items] = CF_ANY;
1171  this->cargo_filter_texts[filter_items] = STR_PURCHASE_INFO_ALL_TYPES;
1172  filter_items++;
1173 
1174  /* Specific filters for trains. */
1175  if (this->vehicle_type == VEH_TRAIN) {
1176  /* Add item for locomotives only in case of trains. */
1177  this->cargo_filter[filter_items] = CF_ENGINES;
1178  this->cargo_filter_texts[filter_items] = STR_PURCHASE_INFO_ENGINES_ONLY;
1179  filter_items++;
1180 
1181  /* Add item for vehicles not carrying anything, e.g. train engines.
1182  * This could also be useful for eyecandy vehicles of other types, but is likely too confusing for joe, */
1183  this->cargo_filter[filter_items] = CF_NONE;
1184  this->cargo_filter_texts[filter_items] = STR_PURCHASE_INFO_NONE;
1185  filter_items++;
1186  }
1187 
1188  /* Collect available cargo types for filtering. */
1189  const CargoSpec *cs;
1191  this->cargo_filter[filter_items] = cs->Index();
1192  this->cargo_filter_texts[filter_items] = cs->name;
1193  filter_items++;
1194  }
1195 
1196  /* Terminate the filter list. */
1197  this->cargo_filter_texts[filter_items] = INVALID_STRING_ID;
1198 
1199  /* If not found, the cargo criteria will be set to all cargoes. */
1200  this->cargo_filter_criteria = 0;
1201 
1202  /* Find the last cargo filter criteria. */
1203  for (uint i = 0; i < filter_items; i++) {
1204  if (this->cargo_filter[i] == _engine_sort_last_cargo_criteria[this->vehicle_type]) {
1205  this->cargo_filter_criteria = i;
1206  break;
1207  }
1208  }
1209 
1210  this->eng_list.SetFilterFuncs(_filter_funcs);
1211  this->eng_list.SetFilterState(this->cargo_filter[this->cargo_filter_criteria] != CF_ANY);
1212  }
1213 
1214  void SelectEngine(EngineID engine)
1215  {
1216  CargoID cargo = this->cargo_filter[this->cargo_filter_criteria];
1217  if (cargo == CF_ANY) cargo = CF_NONE;
1218 
1219  this->sel_engine = engine;
1220  this->SetBuyVehicleText();
1221 
1222  if (this->sel_engine == INVALID_ENGINE) return;
1223 
1224  const Engine *e = Engine::Get(this->sel_engine);
1225  if (!e->CanCarryCargo()) {
1226  this->te.cost = 0;
1227  this->te.cargo = CT_INVALID;
1228  return;
1229  }
1230 
1231  if (!this->listview_mode) {
1232  /* Query for cost and refitted capacity */
1233  CommandCost ret = DoCommand(this->window_number, this->sel_engine | (cargo << 24), 0, DC_QUERY_COST, GetCmdBuildVeh(this->vehicle_type), nullptr);
1234  if (ret.Succeeded()) {
1235  this->te.cost = ret.GetCost() - e->GetCost();
1238  this->te.cargo = (cargo == CT_INVALID) ? e->GetDefaultCargoType() : cargo;
1239  return;
1240  }
1241  }
1242 
1243  /* Purchase test was not possible or failed, fill in the defaults instead. */
1244  this->te.cost = 0;
1245  this->te.capacity = e->GetDisplayDefaultCapacity(&this->te.mail_capacity);
1246  this->te.cargo = e->GetDefaultCargoType();
1247  }
1248 
1249  void OnInit() override
1250  {
1251  this->SetCargoFilterArray();
1252  }
1253 
1256  {
1257  this->eng_list.Filter(this->cargo_filter[this->cargo_filter_criteria]);
1258  if (0 == this->eng_list.size()) { // no engine passed through the filter, invalidate the previously selected engine
1259  this->SelectEngine(INVALID_ENGINE);
1260  } else if (std::find(this->eng_list.begin(), this->eng_list.end(), this->sel_engine) == this->eng_list.end()) { // previously selected engine didn't pass the filter, select the first engine of the list
1261  this->SelectEngine(this->eng_list[0]);
1262  }
1263  }
1264 
1267  {
1268  CargoID filter_type = this->cargo_filter[this->cargo_filter_criteria];
1269  return CargoAndEngineFilter(&eid, filter_type);
1270  }
1271 
1272  /* Figure out what train EngineIDs to put in the list */
1273  void GenerateBuildTrainList()
1274  {
1275  EngineID sel_id = INVALID_ENGINE;
1276  int num_engines = 0;
1277  int num_wagons = 0;
1278 
1279  this->eng_list.clear();
1280 
1281  /* Make list of all available train engines and wagons.
1282  * Also check to see if the previously selected engine is still available,
1283  * and if not, reset selection to INVALID_ENGINE. This could be the case
1284  * when engines become obsolete and are removed */
1285  for (const Engine *e : Engine::IterateType(VEH_TRAIN)) {
1286  if (!this->show_hidden_engines && e->IsHidden(_local_company)) continue;
1287  EngineID eid = e->index;
1288  const RailVehicleInfo *rvi = &e->u.rail;
1289 
1290  if (this->filter.railtype != INVALID_RAILTYPE && !HasPowerOnRail(rvi->railtype, this->filter.railtype)) continue;
1291  if (!IsEngineBuildable(eid, VEH_TRAIN, _local_company)) continue;
1292 
1293  /* Filter now! So num_engines and num_wagons is valid */
1294  if (!FilterSingleEngine(eid)) continue;
1295 
1296  this->eng_list.push_back(eid);
1297 
1298  if (rvi->railveh_type != RAILVEH_WAGON) {
1299  num_engines++;
1300  } else {
1301  num_wagons++;
1302  }
1303 
1304  if (eid == this->sel_engine) sel_id = eid;
1305  }
1306 
1307  this->SelectEngine(sel_id);
1308 
1309  /* invalidate cached values for name sorter - engine names could change */
1310  _last_engine[0] = _last_engine[1] = INVALID_ENGINE;
1311 
1312  /* make engines first, and then wagons, sorted by selected sort_criteria */
1313  _engine_sort_direction = false;
1314  EngList_Sort(&this->eng_list, TrainEnginesThenWagonsSorter);
1315 
1316  /* and then sort engines */
1318  EngList_SortPartial(&this->eng_list, _engine_sort_functions[0][this->sort_criteria], 0, num_engines);
1319 
1320  /* and finally sort wagons */
1321  EngList_SortPartial(&this->eng_list, _engine_sort_functions[0][this->sort_criteria], num_engines, num_wagons);
1322  }
1323 
1324  /* Figure out what road vehicle EngineIDs to put in the list */
1325  void GenerateBuildRoadVehList()
1326  {
1327  EngineID sel_id = INVALID_ENGINE;
1328 
1329  this->eng_list.clear();
1330 
1331  for (const Engine *e : Engine::IterateType(VEH_ROAD)) {
1332  if (!this->show_hidden_engines && e->IsHidden(_local_company)) continue;
1333  EngineID eid = e->index;
1334  if (!IsEngineBuildable(eid, VEH_ROAD, _local_company)) continue;
1335  if (this->filter.roadtype != INVALID_ROADTYPE && !HasPowerOnRoad(e->u.road.roadtype, this->filter.roadtype)) continue;
1336 
1337  this->eng_list.push_back(eid);
1338 
1339  if (eid == this->sel_engine) sel_id = eid;
1340  }
1341  this->SelectEngine(sel_id);
1342  }
1343 
1344  /* Figure out what ship EngineIDs to put in the list */
1345  void GenerateBuildShipList()
1346  {
1347  EngineID sel_id = INVALID_ENGINE;
1348  this->eng_list.clear();
1349 
1350  for (const Engine *e : Engine::IterateType(VEH_SHIP)) {
1351  if (!this->show_hidden_engines && e->IsHidden(_local_company)) continue;
1352  EngineID eid = e->index;
1353  if (!IsEngineBuildable(eid, VEH_SHIP, _local_company)) continue;
1354  this->eng_list.push_back(eid);
1355 
1356  if (eid == this->sel_engine) sel_id = eid;
1357  }
1358  this->SelectEngine(sel_id);
1359  }
1360 
1361  /* Figure out what aircraft EngineIDs to put in the list */
1362  void GenerateBuildAircraftList()
1363  {
1364  EngineID sel_id = INVALID_ENGINE;
1365 
1366  this->eng_list.clear();
1367 
1368  const Station *st = this->listview_mode ? nullptr : Station::GetByTile(this->window_number);
1369 
1370  /* Make list of all available planes.
1371  * Also check to see if the previously selected plane is still available,
1372  * and if not, reset selection to INVALID_ENGINE. This could be the case
1373  * when planes become obsolete and are removed */
1374  for (const Engine *e : Engine::IterateType(VEH_AIRCRAFT)) {
1375  if (!this->show_hidden_engines && e->IsHidden(_local_company)) continue;
1376  EngineID eid = e->index;
1377  if (!IsEngineBuildable(eid, VEH_AIRCRAFT, _local_company)) continue;
1378  /* First VEH_END window_numbers are fake to allow a window open for all different types at once */
1379  if (!this->listview_mode && !CanVehicleUseStation(eid, st)) continue;
1380 
1381  this->eng_list.push_back(eid);
1382  if (eid == this->sel_engine) sel_id = eid;
1383  }
1384 
1385  this->SelectEngine(sel_id);
1386  }
1387 
1388  /* Generate the list of vehicles */
1389  void GenerateBuildList()
1390  {
1391  if (!this->eng_list.NeedRebuild()) return;
1392 
1393  /* Update filter type in case the road/railtype of the depot got converted */
1394  this->UpdateFilterByTile();
1395 
1396  switch (this->vehicle_type) {
1397  default: NOT_REACHED();
1398  case VEH_TRAIN:
1399  this->GenerateBuildTrainList();
1400  this->eng_list.shrink_to_fit();
1401  this->eng_list.RebuildDone();
1402  return; // trains should not reach the last sorting
1403  case VEH_ROAD:
1404  this->GenerateBuildRoadVehList();
1405  break;
1406  case VEH_SHIP:
1407  this->GenerateBuildShipList();
1408  break;
1409  case VEH_AIRCRAFT:
1410  this->GenerateBuildAircraftList();
1411  break;
1412  }
1413 
1414  this->FilterEngineList();
1415 
1417  EngList_Sort(&this->eng_list, _engine_sort_functions[this->vehicle_type][this->sort_criteria]);
1418 
1419  this->eng_list.shrink_to_fit();
1420  this->eng_list.RebuildDone();
1421  }
1422 
1423  void OnClick(Point pt, int widget, int click_count) override
1424  {
1425  switch (widget) {
1427  this->descending_sort_order ^= true;
1429  this->eng_list.ForceRebuild();
1430  this->SetDirty();
1431  break;
1432 
1434  this->show_hidden_engines ^= true;
1436  this->eng_list.ForceRebuild();
1437  this->SetWidgetLoweredState(widget, this->show_hidden_engines);
1438  this->SetDirty();
1439  break;
1440 
1441  case WID_BV_LIST: {
1442  uint i = this->vscroll->GetScrolledRowFromWidget(pt.y, this, WID_BV_LIST);
1443  size_t num_items = this->eng_list.size();
1444  this->SelectEngine((i < num_items) ? this->eng_list[i] : INVALID_ENGINE);
1445  this->SetDirty();
1446  if (_ctrl_pressed) {
1447  this->OnClick(pt, WID_BV_SHOW_HIDE, 1);
1448  } else if (click_count > 1 && !this->listview_mode) {
1449  this->OnClick(pt, WID_BV_BUILD, 1);
1450  }
1451  break;
1452  }
1453 
1454  case WID_BV_SORT_DROPDOWN: // Select sorting criteria dropdown menu
1455  DisplayVehicleSortDropDown(this, this->vehicle_type, this->sort_criteria, WID_BV_SORT_DROPDOWN);
1456  break;
1457 
1458  case WID_BV_CARGO_FILTER_DROPDOWN: // Select cargo filtering criteria dropdown menu
1459  ShowDropDownMenu(this, this->cargo_filter_texts, this->cargo_filter_criteria, WID_BV_CARGO_FILTER_DROPDOWN, 0, 0);
1460  break;
1461 
1462  case WID_BV_SHOW_HIDE: {
1463  const Engine *e = (this->sel_engine == INVALID_ENGINE) ? nullptr : Engine::Get(this->sel_engine);
1464  if (e != nullptr) {
1465  DoCommandP(0, 0, this->sel_engine | (e->IsHidden(_current_company) ? 0 : (1u << 31)), CMD_SET_VEHICLE_VISIBILITY);
1466  }
1467  break;
1468  }
1469 
1470  case WID_BV_BUILD: {
1471  EngineID sel_eng = this->sel_engine;
1472  if (sel_eng != INVALID_ENGINE) {
1473  CommandCallback *callback = (this->vehicle_type == VEH_TRAIN && RailVehInfo(sel_eng)->railveh_type == RAILVEH_WAGON) ? CcBuildWagon : CcBuildPrimaryVehicle;
1474  CargoID cargo = this->cargo_filter[this->cargo_filter_criteria];
1475  if (cargo == CF_ANY || cargo == CF_ENGINES) cargo = CF_NONE;
1476  DoCommandP(this->window_number, sel_eng | (cargo << 24), 0, GetCmdBuildVeh(this->vehicle_type), callback);
1477  }
1478  break;
1479  }
1480 
1481  case WID_BV_RENAME: {
1482  EngineID sel_eng = this->sel_engine;
1483  if (sel_eng != INVALID_ENGINE) {
1484  this->rename_engine = sel_eng;
1485  SetDParam(0, sel_eng);
1486  ShowQueryString(STR_ENGINE_NAME, STR_QUERY_RENAME_TRAIN_TYPE_CAPTION + this->vehicle_type, MAX_LENGTH_ENGINE_NAME_CHARS, this, CS_ALPHANUMERAL, QSF_ENABLE_DEFAULT | QSF_LEN_IN_CHARS);
1487  }
1488  break;
1489  }
1490  }
1491  }
1492 
1498  void OnInvalidateData(int data = 0, bool gui_scope = true) override
1499  {
1500  if (!gui_scope) return;
1501  /* When switching to original acceleration model for road vehicles, clear the selected sort criteria if it is not available now. */
1502  if (this->vehicle_type == VEH_ROAD &&
1504  this->sort_criteria > 7) {
1505  this->sort_criteria = 0;
1507  }
1508  this->eng_list.ForceRebuild();
1509  }
1510 
1511  void SetStringParameters(int widget) const override
1512  {
1513  switch (widget) {
1514  case WID_BV_CAPTION:
1515  if (this->vehicle_type == VEH_TRAIN && !this->listview_mode) {
1516  const RailtypeInfo *rti = GetRailTypeInfo(this->filter.railtype);
1517  SetDParam(0, rti->strings.build_caption);
1518  } else if (this->vehicle_type == VEH_ROAD && !this->listview_mode) {
1519  const RoadTypeInfo *rti = GetRoadTypeInfo(this->filter.roadtype);
1520  SetDParam(0, rti->strings.build_caption);
1521  } else {
1522  SetDParam(0, (this->listview_mode ? STR_VEHICLE_LIST_AVAILABLE_TRAINS : STR_BUY_VEHICLE_TRAIN_ALL_CAPTION) + this->vehicle_type);
1523  }
1524  break;
1525 
1526  case WID_BV_SORT_DROPDOWN:
1527  SetDParam(0, _engine_sort_listing[this->vehicle_type][this->sort_criteria]);
1528  break;
1529 
1531  SetDParam(0, this->cargo_filter_texts[this->cargo_filter_criteria]);
1532  break;
1533 
1534  case WID_BV_SHOW_HIDE: {
1535  const Engine *e = (this->sel_engine == INVALID_ENGINE) ? nullptr : Engine::Get(this->sel_engine);
1536  if (e != nullptr && e->IsHidden(_local_company)) {
1537  SetDParam(0, STR_BUY_VEHICLE_TRAIN_SHOW_TOGGLE_BUTTON + this->vehicle_type);
1538  } else {
1539  SetDParam(0, STR_BUY_VEHICLE_TRAIN_HIDE_TOGGLE_BUTTON + this->vehicle_type);
1540  }
1541  break;
1542  }
1543  }
1544  }
1545 
1546  void UpdateWidgetSize(int widget, Dimension *size, const Dimension &padding, Dimension *fill, Dimension *resize) override
1547  {
1548  switch (widget) {
1549  case WID_BV_LIST:
1550  resize->height = GetEngineListHeight(this->vehicle_type);
1551  size->height = 3 * resize->height;
1552  size->width = std::max(size->width, GetVehicleImageCellSize(this->vehicle_type, EIT_PURCHASE).extend_left + GetVehicleImageCellSize(this->vehicle_type, EIT_PURCHASE).extend_right + 165);
1553  break;
1554 
1555  case WID_BV_PANEL:
1556  size->height = FONT_HEIGHT_NORMAL * this->details_height + padding.height;
1557  break;
1558 
1560  Dimension d = GetStringBoundingBox(this->GetWidget<NWidgetCore>(widget)->widget_data);
1561  d.width += padding.width + Window::SortButtonWidth() * 2; // Doubled since the string is centred and it also looks better.
1562  d.height += padding.height;
1563  *size = maxdim(*size, d);
1564  break;
1565  }
1566 
1567  case WID_BV_BUILD:
1568  *size = GetStringBoundingBox(STR_BUY_VEHICLE_TRAIN_BUY_VEHICLE_BUTTON + this->vehicle_type);
1569  *size = maxdim(*size, GetStringBoundingBox(STR_BUY_VEHICLE_TRAIN_BUY_REFIT_VEHICLE_BUTTON + this->vehicle_type));
1570  size->width += padding.width;
1571  size->height += padding.height;
1572  break;
1573 
1574  case WID_BV_SHOW_HIDE:
1575  *size = GetStringBoundingBox(STR_BUY_VEHICLE_TRAIN_HIDE_TOGGLE_BUTTON + this->vehicle_type);
1576  *size = maxdim(*size, GetStringBoundingBox(STR_BUY_VEHICLE_TRAIN_SHOW_TOGGLE_BUTTON + this->vehicle_type));
1577  size->width += padding.width;
1578  size->height += padding.height;
1579  break;
1580  }
1581  }
1582 
1583  void DrawWidget(const Rect &r, int widget) const override
1584  {
1585  switch (widget) {
1586  case WID_BV_LIST:
1588  this->vehicle_type,
1589  r.left + WD_FRAMERECT_LEFT,
1590  r.right - WD_FRAMERECT_RIGHT,
1591  r.top + WD_FRAMERECT_TOP,
1592  &this->eng_list,
1593  this->vscroll->GetPosition(),
1594  static_cast<uint16>(std::min<size_t>(this->vscroll->GetPosition() + this->vscroll->GetCapacity(), this->eng_list.size())),
1595  this->sel_engine,
1596  false,
1598  );
1599  break;
1600 
1602  this->DrawSortButtonState(WID_BV_SORT_ASCENDING_DESCENDING, this->descending_sort_order ? SBS_DOWN : SBS_UP);
1603  break;
1604  }
1605  }
1606 
1607  void OnPaint() override
1608  {
1609  this->GenerateBuildList();
1610  this->vscroll->SetCount((uint)this->eng_list.size());
1611 
1613 
1614  this->DrawWidgets();
1615 
1616  if (!this->IsShaded()) {
1617  int needed_height = this->details_height;
1618  /* Draw details panels. */
1619  if (this->sel_engine != INVALID_ENGINE) {
1620  NWidgetBase *nwi = this->GetWidget<NWidgetBase>(WID_BV_PANEL);
1622  nwi->pos_y + WD_FRAMERECT_TOP, this->sel_engine, this->te);
1623  needed_height = std::max(needed_height, (text_end - (int)nwi->pos_y - WD_FRAMERECT_TOP) / FONT_HEIGHT_NORMAL);
1624  }
1625  if (needed_height != this->details_height) { // Details window are not high enough, enlarge them.
1626  int resize = needed_height - this->details_height;
1627  this->details_height = needed_height;
1628  this->ReInit(0, resize * FONT_HEIGHT_NORMAL);
1629  return;
1630  }
1631  }
1632  }
1633 
1634  void OnQueryTextFinished(char *str) override
1635  {
1636  if (str == nullptr) return;
1637 
1638  DoCommandP(0, this->rename_engine, 0, CMD_RENAME_ENGINE | CMD_MSG(STR_ERROR_CAN_T_RENAME_TRAIN_TYPE + this->vehicle_type), nullptr, str);
1639  }
1640 
1641  void OnDropdownSelect(int widget, int index) override
1642  {
1643  switch (widget) {
1644  case WID_BV_SORT_DROPDOWN:
1645  if (this->sort_criteria != index) {
1646  this->sort_criteria = index;
1648  this->eng_list.ForceRebuild();
1649  }
1650  break;
1651 
1652  case WID_BV_CARGO_FILTER_DROPDOWN: // Select a cargo filter criteria
1653  if (this->cargo_filter_criteria != index) {
1654  this->cargo_filter_criteria = index;
1655  _engine_sort_last_cargo_criteria[this->vehicle_type] = this->cargo_filter[this->cargo_filter_criteria];
1656  /* deactivate filter if criteria is 'Show All', activate it otherwise */
1657  this->eng_list.SetFilterState(this->cargo_filter[this->cargo_filter_criteria] != CF_ANY);
1658  this->eng_list.ForceRebuild();
1659  this->SelectEngine(this->sel_engine);
1660  }
1661  break;
1662  }
1663  this->SetDirty();
1664  }
1665 
1666  void OnResize() override
1667  {
1668  this->vscroll->SetCapacityFromWidget(this, WID_BV_LIST);
1669  }
1670 };
1671 
1672 static WindowDesc _build_vehicle_desc(
1673  WDP_AUTO, "build_vehicle", 240, 268,
1676  _nested_build_vehicle_widgets, lengthof(_nested_build_vehicle_widgets)
1677 );
1678 
1679 void ShowBuildVehicleWindow(TileIndex tile, VehicleType type)
1680 {
1681  /* We want to be able to open both Available Train as Available Ships,
1682  * so if tile == INVALID_TILE (Available XXX Window), use 'type' as unique number.
1683  * As it always is a low value, it won't collide with any real tile
1684  * number. */
1685  uint num = (tile == INVALID_TILE) ? (int)type : tile;
1686 
1687  assert(IsCompanyBuildableVehicleType(type));
1688 
1690 
1691  new BuildVehicleWindow(&_build_vehicle_desc, tile, type);
1692 }
SZSP_NONE
@ SZSP_NONE
Display plane with zero size in both directions (none filling and resizing).
Definition: widget_type.h:399
VEH_AIRCRAFT
@ VEH_AIRCRAFT
Aircraft vehicle type.
Definition: vehicle_type.h:27
_engine_sort_functions
EngList_SortTypeFunction *const _engine_sort_functions[][11]
Sort functions for the vehicle sort criteria, for each vehicle type.
Definition: build_vehicle_gui.cpp:432
BuildVehicleWindow::OnInvalidateData
void OnInvalidateData(int data=0, bool gui_scope=true) override
Some data on this window has become invalid.
Definition: build_vehicle_gui.cpp:1498
Engine::GetDisplayDefaultCapacity
uint GetDisplayDefaultCapacity(uint16 *mail_capacity=nullptr) const
Determines the default cargo capacity of an engine for display purposes.
Definition: engine_base.h:99
_standard_cargo_mask
CargoTypes _standard_cargo_mask
Bitmask of real cargo types available.
Definition: cargotype.cpp:33
EngineCostSorter
static bool EngineCostSorter(const EngineID &a, const EngineID &b)
Determines order of engines by purchase cost.
Definition: build_vehicle_gui.cpp:184
INVALID_ENGINE
static const EngineID INVALID_ENGINE
Constant denoting an invalid engine.
Definition: engine_type.h:174
IsCompanyBuildableVehicleType
static bool IsCompanyBuildableVehicleType(VehicleType type)
Is the given vehicle type buildable by a company?
Definition: vehicle_func.h:89
BuildVehicleWindow::OnPaint
void OnPaint() override
The window must be repainted.
Definition: build_vehicle_gui.cpp:1607
WD_FRAMERECT_TOP
@ WD_FRAMERECT_TOP
Offset at top to draw the frame rectangular area.
Definition: window_gui.h:62
WID_BV_SORT_DROPDOWN
@ WID_BV_SORT_DROPDOWN
Criteria of sorting dropdown.
Definition: build_vehicle_widget.h:17
CMD_MSG
#define CMD_MSG(x)
Used to combine a StringID with the command.
Definition: command_type.h:372
Engine::GetGRFID
uint32 GetGRFID() const
Retrieve the GRF ID of the NewGRF the engine is tied to.
Definition: engine.cpp:158
TileIndex
uint32 TileIndex
The index/ID of a Tile.
Definition: tile_type.h:83
RoadTypeInfo
Definition: road.h:75
WID_BV_SHOW_HIDE
@ WID_BV_SHOW_HIDE
Button to hide or show the selected engine.
Definition: build_vehicle_widget.h:24
ClampToI32
static int32 ClampToI32(const int64 a)
Reduce a signed 64-bit int to a signed 32-bit one.
Definition: math_func.hpp:141
FOR_ALL_SORTED_STANDARD_CARGOSPECS
#define FOR_ALL_SORTED_STANDARD_CARGOSPECS(var)
Loop header for iterating over 'real' cargoes, sorted by name.
Definition: cargotype.h:171
RailVehicleInfo::pow_wag_weight
byte pow_wag_weight
Extra weight applied to consist if wagon should be powered.
Definition: engine_type.h:56
Engine::IterateType
static Pool::IterateWrapperFiltered< Engine, EngineTypeFilter > IterateType(VehicleType vt, size_t from=0)
Returns an iterable ensemble of all valid engines of the given type.
Definition: engine_base.h:157
DoCommand
CommandCost DoCommand(const CommandContainer *container, DoCommandFlag flags)
Shorthand for calling the long DoCommand with a container.
Definition: command.cpp:450
Pool::PoolItem<&_engine_pool >::Get
static Titem * Get(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:329
vehicle_gui.h
BuildVehicleWindow::te
TestedEngineDetails te
Tested cost and capacity after refit.
Definition: build_vehicle_gui.cpp:1060
SetScrollbar
static NWidgetPart SetScrollbar(int index)
Attach a scrollbar to a widget.
Definition: widget_type.h:1104
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:3093
VehicleSettings::train_acceleration_model
uint8 train_acceleration_model
realistic acceleration for trains
Definition: settings_type.h:466
GUISettings::show_newgrf_name
bool show_newgrf_name
Show the name of the NewGRF in the build vehicle window.
Definition: settings_type.h:158
Dimension
Dimensions (a width and height) of a rectangle in 2D.
Definition: geometry_type.hpp:27
command_func.h
Window::DrawSortButtonState
void DrawSortButtonState(int widget, SortButtonState state) const
Draw a sort button's up or down arrow symbol.
Definition: widget.cpp:636
RoadTypeInfo::strings
struct RoadTypeInfo::@44 strings
Strings associated with the rail type.
WWT_STICKYBOX
@ WWT_STICKYBOX
Sticky box (at top-right of a window, after WWT_DEFSIZEBOX)
Definition: widget_type.h:64
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
dropdown_func.h
BuildVehicleWindow::vehicle_type
VehicleType vehicle_type
Type of vehicles shown in the window.
Definition: build_vehicle_gui.cpp:1043
EngineSpeedSorter
static bool EngineSpeedSorter(const EngineID &a, const EngineID &b)
Determines order of engines by speed.
Definition: build_vehicle_gui.cpp:201
EngineIntroDateSorter
static bool EngineIntroDateSorter(const EngineID &a, const EngineID &b)
Determines order of engines by introduction date.
Definition: build_vehicle_gui.cpp:118
WID_BV_SHOW_HIDDEN_ENGINES
@ WID_BV_SHOW_HIDDEN_ENGINES
Toggle whether to display the hidden vehicles.
Definition: build_vehicle_widget.h:19
Window::ReInit
void ReInit(int rx=0, int ry=0)
Re-initialize a window, and optionally change its size.
Definition: window.cpp:995
TestedEngineDetails::mail_capacity
uint16 mail_capacity
Mail capacity if available.
Definition: vehicle_gui.h:43
_engine_sort_last_order
bool _engine_sort_last_order[]
Last set direction of the sort order, for each vehicle type.
Definition: build_vehicle_gui.cpp:95
WD_MATRIX_TOP
@ WD_MATRIX_TOP
Offset at top of a matrix cell.
Definition: window_gui.h:78
RoadVehEngineCapacitySorter
static bool RoadVehEngineCapacitySorter(const EngineID &a, const EngineID &b)
Determines order of road vehicles by capacity.
Definition: build_vehicle_gui.cpp:350
BuildVehicleWindow::OnQueryTextFinished
void OnQueryTextFinished(char *str) override
The query window opened from this window has closed.
Definition: build_vehicle_gui.cpp:1634
GetTotalCapacityOfArticulatedParts
uint GetTotalCapacityOfArticulatedParts(EngineID engine)
Get the capacity of an engine with articulated parts.
Definition: engine_gui.cpp:163
WWT_CAPTION
@ WWT_CAPTION
Window caption (window title between closebox and stickybox)
Definition: widget_type.h:59
Station
Station data structure.
Definition: station_base.h:450
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:1972
_engine_sort_direction
bool _engine_sort_direction
false = descending, true = ascending.
Definition: build_vehicle_gui.cpp:93
SA_RIGHT
@ SA_RIGHT
Right align the text (must be a single bit).
Definition: gfx_func.h:98
GUIList< EngineID, CargoID >
INVALID_ROADTYPE
@ INVALID_ROADTYPE
flag for invalid roadtype
Definition: road_type.h:27
_network_server
bool _network_server
network-server is active
Definition: network.cpp:53
Engine::GetDisplayMaxTractiveEffort
uint GetDisplayMaxTractiveEffort() const
Returns the tractive effort of the engine for display purposes.
Definition: engine.cpp:425
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
Window::CreateNestedTree
void CreateNestedTree(bool fill_nested=true)
Perform the first part of the initialization of a nested widget tree.
Definition: window.cpp:1832
CF_ENGINES
static const CargoID CF_ENGINES
Show only engines (for rail vehicles only)
Definition: build_vehicle_gui.cpp:91
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
EIT_PURCHASE
@ EIT_PURCHASE
Vehicle drawn in purchase list, autoreplace gui, ...
Definition: vehicle_type.h:90
HasPowerOnRail
static bool HasPowerOnRail(RailType enginetype, RailType tiletype)
Checks if an engine of the given RailType got power on a tile with a given RailType.
Definition: rail.h:332
CargoArray
Class for storing amounts of cargo.
Definition: cargo_type.h:81
DrawEngineList
void DrawEngineList(VehicleType type, int l, int r, int y, const GUIEngineList *eng_list, uint16 min, uint16 max, EngineID selected_id, bool show_count, GroupID selected_group)
Engine drawing loop.
Definition: build_vehicle_gui.cpp:963
maxdim
Dimension maxdim(const Dimension &d1, const Dimension &d2)
Compute bounding box of both dimensions.
Definition: geometry_func.cpp:22
CargoAndEngineFilter
static bool CDECL CargoAndEngineFilter(const EngineID *eid, const CargoID cid)
Filters vehicles by cargo and engine (in case of rail vehicle).
Definition: build_vehicle_gui.cpp:536
WWT_MATRIX
@ WWT_MATRIX
Grid of rows and columns.
Definition: widget_type.h:57
HasBit
static bool HasBit(const T x, const uint8 y)
Checks if a bit in a value is set.
Definition: bitmath_func.hpp:103
_returned_mail_refit_capacity
uint16 _returned_mail_refit_capacity
Stores the mail capacity after a refit operation (Aircraft only).
Definition: vehicle.cpp:86
TrainEnginesThenWagonsSorter
static bool TrainEnginesThenWagonsSorter(const EngineID &a, const EngineID &b)
Determines order of train engines by engine / wagon.
Definition: build_vehicle_gui.cpp:331
Engine::GetRunningCost
Money GetRunningCost() const
Return how much the running costs of this engine are.
Definition: engine.cpp:280
RailtypeInfo
This struct contains all the info that is needed to draw and construct tracks.
Definition: rail.h:124
CMD_SET_VEHICLE_VISIBILITY
@ CMD_SET_VEHICLE_VISIBILITY
hide or unhide a vehicle in the build vehicle and autoreplace GUIs
Definition: command_type.h:218
group.h
VehicleSettings::wagon_speed_limits
bool wagon_speed_limits
enable wagon speed limits
Definition: settings_type.h:470
Scrollbar::SetCount
void SetCount(int num)
Sets the number of elements in the list.
Definition: widget_type.h:679
WID_BV_CAPTION
@ WID_BV_CAPTION
Caption of window.
Definition: build_vehicle_widget.h:15
_ctrl_pressed
bool _ctrl_pressed
Is Ctrl pressed?
Definition: gfx.cpp:35
CMD_RENAME_ENGINE
@ CMD_RENAME_ENGINE
rename a engine (in the engine list)
Definition: command_type.h:245
TextColour
TextColour
Colour of the strings, see _string_colourmap in table/string_colours.h or docs/ottd-colourtext-palett...
Definition: gfx_type.h:250
CommandCallback
void CommandCallback(const CommandCost &result, TileIndex tile, uint32 p1, uint32 p2, uint32 cmd)
Define a callback function for the client, after the command is finished.
Definition: command_type.h:474
SetResize
static NWidgetPart SetResize(int16 dx, int16 dy)
Widget part function for setting the resize step.
Definition: widget_type.h:939
StartTextRefStackUsage
void StartTextRefStackUsage(const GRFFile *grffile, byte numEntries, const uint32 *values)
Start using the TTDP compatible string code parsing.
Definition: newgrf_text.cpp:822
TestedEngineDetails::cargo
CargoID cargo
Cargo type.
Definition: vehicle_gui.h:41
WID_BV_BUILD_SEL
@ WID_BV_BUILD_SEL
Build button.
Definition: build_vehicle_widget.h:25
_settings_client
ClientSettings _settings_client
The current settings for this game.
Definition: settings.cpp:79
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
CargoSpec
Specification of a cargo type.
Definition: cargotype.h:55
VehicleCellSize::extend_right
uint extend_right
Extend of the cell to the right.
Definition: vehicle_gui.h:80
Window::owner
Owner owner
The owner of the content shown in this window. Company colour is acquired from this variable.
Definition: window_gui.h:325
Engine::GetLifeLengthInDays
Date GetLifeLengthInDays() const
Returns the vehicle's (not model's!) life length in days.
Definition: engine.cpp:442
EngineRunningCostSorter
static bool EngineRunningCostSorter(const EngineID &a, const EngineID &b)
Determines order of engines by running costs.
Definition: build_vehicle_gui.cpp:252
NWidgetCore::tool_tip
StringID tool_tip
Tooltip of the widget.
Definition: widget_type.h:315
StopTextRefStackUsage
void StopTextRefStackUsage()
Stop using the TTDP compatible string code parsing.
Definition: newgrf_text.cpp:839
BuildVehicleWindow::descending_sort_order
bool descending_sort_order
Sort direction,.
Definition: build_vehicle_gui.cpp:1048
Engine
Definition: engine_base.h:21
BuildVehicleWindow::FilterEngineList
void FilterEngineList()
Filter the engine list against the currently selected cargo filter.
Definition: build_vehicle_gui.cpp:1255
NWidgetCore::SetLowered
void SetLowered(bool lowered)
Lower or raise the widget.
Definition: widget_type.h:346
VEH_ROAD
@ VEH_ROAD
Road vehicle type.
Definition: vehicle_type.h:25
SA_FORCE
@ SA_FORCE
Force the alignment, i.e. don't swap for RTL languages.
Definition: gfx_func.h:108
Engine::GetDefaultCargoType
CargoID GetDefaultCargoType() const
Determines the default cargo type of an engine.
Definition: engine_base.h:79
Engine::company_hidden
CompanyMask company_hidden
Bit for each company whether the engine is normally hidden in the build gui for that company.
Definition: engine_base.h:38
RoadVehicleInfo::roadtype
RoadType roadtype
Road type.
Definition: engine_type.h:125
BuildVehicleWindow::DrawWidget
void DrawWidget(const Rect &r, int widget) const override
Draw the contents of a nested widget.
Definition: build_vehicle_gui.cpp:1583
ShipEngineCapacitySorter
static bool ShipEngineCapacitySorter(const EngineID &a, const EngineID &b)
Determines order of ships by capacity.
Definition: build_vehicle_gui.cpp:369
Scrollbar
Scrollbar data structure.
Definition: widget_type.h:598
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
WD_FRAMETEXT_LEFT
@ WD_FRAMETEXT_LEFT
Left offset of the text of the frame.
Definition: window_gui.h:70
GetEnginePalette
PaletteID GetEnginePalette(EngineID engine_type, CompanyID company)
Get the colour map for an engine.
Definition: vehicle.cpp:2034
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
GetVehicleImageCellSize
VehicleCellSize GetVehicleImageCellSize(VehicleType type, EngineImageType image_type)
Get the GUI cell size for a vehicle image.
Definition: depot_gui.cpp:158
NWidgetPart
Partial widget specification to allow NWidgets to be written nested.
Definition: widget_type.h:919
_engine_sort_show_hidden_engines
bool _engine_sort_show_hidden_engines[]
Last set 'show hidden engines' setting for each vehicle type.
Definition: build_vehicle_gui.cpp:96
SetDataTip
static NWidgetPart SetDataTip(uint32 data, StringID tip)
Widget part function for setting the data and tooltip.
Definition: widget_type.h:1023
WID_BV_BUILD
@ WID_BV_BUILD
Build panel.
Definition: build_vehicle_widget.h:23
NWidgetCore::widget_data
uint32 widget_data
Data of the widget.
Definition: widget_type.h:314
CommandCost::Succeeded
bool Succeeded() const
Did this command succeed?
Definition: command_type.h:150
GetStringBoundingBox
Dimension GetStringBoundingBox(const char *str, FontSize start_fontsize)
Return the string dimension in pixels.
Definition: gfx.cpp:842
GUIList::SetFilterFuncs
void SetFilterFuncs(FilterFunction *const *n_funcs)
Hand the array of filter function pointers to the sort list.
Definition: sortlist_type.h:341
textbuf_gui.h
TestedEngineDetails::capacity
uint capacity
Cargo capacity.
Definition: vehicle_gui.h:42
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
DisplayVehicleSortDropDown
void DisplayVehicleSortDropDown(Window *w, VehicleType vehicle_type, int selected, int button)
Display the dropdown for the vehicle sort criteria.
Definition: build_vehicle_gui.cpp:1025
QSF_LEN_IN_CHARS
@ QSF_LEN_IN_CHARS
the length of the string is counted in characters
Definition: textbuf_gui.h:22
CBID_VEHICLE_ADDITIONAL_TEXT
@ CBID_VEHICLE_ADDITIONAL_TEXT
This callback is called from vehicle purchase lists.
Definition: newgrf_callbacks.h:93
WID_BV_SORT_ASCENDING_DESCENDING
@ WID_BV_SORT_ASCENDING_DESCENDING
Sort direction.
Definition: build_vehicle_widget.h:16
WID_BV_PANEL
@ WID_BV_PANEL
Button panel.
Definition: build_vehicle_widget.h:22
BuildVehicleWindow::show_hidden_engines
bool show_hidden_engines
State of the 'show hidden engines' button.
Definition: build_vehicle_gui.cpp:1050
WindowDesc
High level window description.
Definition: window_gui.h:166
GetRailTypeInfo
static const RailtypeInfo * GetRailTypeInfo(RailType railtype)
Returns a pointer to the Railtype information for a given railtype.
Definition: rail.h:304
Engine::GetDisplayMaxSpeed
uint GetDisplayMaxSpeed() const
Returns max speed of the engine for display purposes.
Definition: engine.cpp:357
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
BuildVehicleWindow::cargo_filter_criteria
byte cargo_filter_criteria
Selected cargo filter.
Definition: build_vehicle_gui.cpp:1057
RailVehicleInfo
Information about a rail vehicle.
Definition: engine_type.h:42
_engine_sort_listing
const StringID _engine_sort_listing[][12]
Dropdown menu strings for the vehicle sort criteria.
Definition: build_vehicle_gui.cpp:482
WDP_AUTO
@ WDP_AUTO
Find a place automatically.
Definition: window_gui.h:154
GUIList::SetFilterState
void SetFilterState(bool state)
Enable or disable the filter.
Definition: sortlist_type.h:302
RailType
RailType
Enumeration for all possible railtypes.
Definition: rail_type.h:27
Window::resize
ResizeInfo resize
Resize information.
Definition: window_gui.h:323
CommandCost
Common return value for all commands.
Definition: command_type.h:23
GetUnionOfArticulatedRefitMasks
CargoTypes GetUnionOfArticulatedRefitMasks(EngineID engine, bool include_initial_cargo_type)
Ors the refit_masks of all articulated parts.
Definition: articulated_vehicles.cpp:255
GRFConfig
Information about GRF, used in the game and (part of it) in savegames.
Definition: newgrf_config.h:152
newgrf_engine.h
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
BuildVehicleWindow::listview_mode
bool listview_mode
If set, only display the available vehicles and do not show a 'build' button.
Definition: build_vehicle_gui.cpp:1051
Window::SetDirty
void SetDirty() const
Mark entire window as dirty (in need of re-paint)
Definition: window.cpp:984
WD_FRAMERECT_LEFT
@ WD_FRAMERECT_LEFT
Offset at left to draw the frame rectangular area.
Definition: window_gui.h:60
FS_SMALL
@ FS_SMALL
Index of the small font in the font tables.
Definition: gfx_type.h:208
WD_FRAMERECT_RIGHT
@ WD_FRAMERECT_RIGHT
Offset at right to draw the frame rectangular area.
Definition: window_gui.h:61
WD_FRAMERECT_BOTTOM
@ WD_FRAMERECT_BOTTOM
Offset at bottom to draw the frame rectangular area.
Definition: window_gui.h:63
WWT_PUSHTXTBTN
@ WWT_PUSHTXTBTN
Normal push-button (no toggle button) with text caption.
Definition: widget_type.h:102
MAX_LENGTH_ENGINE_NAME_CHARS
static const uint MAX_LENGTH_ENGINE_NAME_CHARS
The maximum length of an engine name in characters including '\0'.
Definition: engine_type.h:172
NWidgetBase
Baseclass for nested widgets.
Definition: widget_type.h:124
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:1041
_settings_game
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition: settings.cpp:80
AircraftEngineCargoSorter
static bool AircraftEngineCargoSorter(const EngineID &a, const EngineID &b)
Determines order of aircraft by cargo.
Definition: build_vehicle_gui.cpp:391
Engine::GetDisplayWeight
uint GetDisplayWeight() const
Returns the weight of the engine for display purposes.
Definition: engine.cpp:407
ConvertDateToYMD
void ConvertDateToYMD(Date date, YearMonthDay *ymd)
Converts a Date to a Year, Month & Day.
Definition: date.cpp:94
Window::SetWidgetDisabledState
void SetWidgetDisabledState(byte widget_index, bool disab_stat)
Sets the enabled/disabled status of a widget.
Definition: window_gui.h:393
_local_company
CompanyID _local_company
Company controlled by the human player at this client. Can also be COMPANY_SPECTATOR.
Definition: company_cmd.cpp:46
CF_NONE
static const CargoID CF_NONE
Show only vehicles which do not carry cargo (e.g. train engines)
Definition: build_vehicle_gui.cpp:90
safeguards.h
DrawAircraftPurchaseInfo
static int DrawAircraftPurchaseInfo(int left, int right, int y, EngineID engine_number, bool refittable, TestedEngineDetails &te)
Draw aircraft specific details in the buy window.
Definition: build_vehicle_gui.cpp:788
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:1141
BuildVehicleWindow::rename_engine
EngineID rename_engine
Engine being renamed.
Definition: build_vehicle_gui.cpp:1053
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
TestedEngineDetails
Extra information about refitted cargo and capacity.
Definition: vehicle_gui.h:39
GetGRFStringID
StringID GetGRFStringID(uint32 grfid, StringID stringid)
Returns the index for this stringid associated with its grfID.
Definition: newgrf_text.cpp:602
CargoSpec::weight
uint8 weight
Weight of a single unit of this cargo type in 1/16 ton (62.5 kg).
Definition: cargotype.h:60
TC_NO_SHADE
@ TC_NO_SHADE
Do not add shading to this text colour.
Definition: gfx_type.h:274
_networking
bool _networking
are we in networking mode?
Definition: network.cpp:52
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
EnginePowerVsRunningCostSorter
static bool EnginePowerVsRunningCostSorter(const EngineID &a, const EngineID &b)
Determines order of engines by running costs.
Definition: build_vehicle_gui.cpp:269
newgrf_text.h
Point
Coordinates of a point in 2D.
Definition: geometry_type.hpp:21
BuildVehicleWindow::cargo_filter
CargoID cargo_filter[NUM_CARGO+3]
Available cargo filters; CargoID or CF_ANY or CF_NONE or CF_ENGINES.
Definition: build_vehicle_gui.cpp:1055
BuildVehicleWindow::details_height
int details_height
Minimal needed height of the details panels, in text lines (found so far).
Definition: build_vehicle_gui.cpp:1058
build_vehicle_widget.h
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:488
WID_BV_CARGO_FILTER_DROPDOWN
@ WID_BV_CARGO_FILTER_DROPDOWN
Cargo filter dropdown.
Definition: build_vehicle_widget.h:18
DAYS_IN_LEAP_YEAR
static const int DAYS_IN_LEAP_YEAR
sometimes, you need one day more...
Definition: date_type.h:30
Engine::GetCost
Money GetCost() const
Return how much a new engine costs.
Definition: engine.cpp:317
BuildVehicleWindow::sort_criteria
byte sort_criteria
Current sort criterium.
Definition: build_vehicle_gui.cpp:1049
date_func.h
WID_BV_RENAME
@ WID_BV_RENAME
Rename button.
Definition: build_vehicle_widget.h:26
EnginePowerSorter
static bool EnginePowerSorter(const EngineID &a, const EngineID &b)
Determines order of engines by power.
Definition: build_vehicle_gui.cpp:218
WD_FRAMETEXT_RIGHT
@ WD_FRAMETEXT_RIGHT
Right offset of the text of the frame.
Definition: window_gui.h:71
stdafx.h
_engine_sort_last_criteria
byte _engine_sort_last_criteria[]
Last set sort criteria, for each vehicle type.
Definition: build_vehicle_gui.cpp:94
Window::window_number
WindowNumber window_number
Window number within the window class.
Definition: window_gui.h:313
RoadType
RoadType
The different roadtypes we support.
Definition: road_type.h:22
VehicleType
VehicleType
Available vehicle types.
Definition: vehicle_type.h:21
BuildVehicleWindow::FilterSingleEngine
bool FilterSingleEngine(EngineID eid)
Filter a single engine.
Definition: build_vehicle_gui.cpp:1266
RailVehicleInfo::pow_wag_power
uint16 pow_wag_power
Extra power applied to consist if wagon should be powered.
Definition: engine_type.h:55
IsArticulatedVehicleRefittable
bool IsArticulatedVehicleRefittable(EngineID engine)
Checks whether any of the articulated parts is refittable.
Definition: articulated_vehicles.cpp:203
CS_ALPHANUMERAL
@ CS_ALPHANUMERAL
Both numeric and alphabetic and spaces and stuff.
Definition: string_type.h:27
CcBuildWagon
void CcBuildWagon(const CommandCost &result, TileIndex tile, uint32 p1, uint32 p2, uint32 cmd)
Callback for building wagons.
Definition: train_gui.cpp:30
WC_NONE
@ WC_NONE
No window, redirects to WC_MAIN_WINDOW.
Definition: window_type.h:38
RAILVEH_WAGON
@ RAILVEH_WAGON
simple wagon, not motorized
Definition: engine_type.h:29
_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
GetTileOwner
static Owner GetTileOwner(TileIndex tile)
Returns the owner of a tile.
Definition: tile_map.h:178
FONT_HEIGHT_SMALL
#define FONT_HEIGHT_SMALL
Height of characters in the small (FS_SMALL) font.
Definition: gfx_func.h:176
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
EngineTractiveEffortSorter
static bool EngineTractiveEffortSorter(const EngineID &a, const EngineID &b)
Determines order of engines by tractive effort.
Definition: build_vehicle_gui.cpp:235
GUIList::NeedRebuild
bool NeedRebuild() const
Check if a rebuild is needed.
Definition: sortlist_type.h:362
EngList_SortPartial
void EngList_SortPartial(GUIEngineList *el, EngList_SortTypeFunction compare, uint begin, uint num_items)
Sort selected range of items (on indices @ <begin, begin+num_items-1>)
Definition: engine_gui.cpp:339
YearMonthDay::year
Year year
Year (0...)
Definition: date_type.h:104
string_func.h
CALLBACK_FAILED
static const uint CALLBACK_FAILED
Different values for Callback result evaluations.
Definition: newgrf_callbacks.h:404
RailtypeInfo::acceleration_type
uint8 acceleration_type
Acceleration type of this rail type.
Definition: rail.h:223
StringID
uint32 StringID
Numeric value that represents a string, independent of the selected language.
Definition: strings_type.h:16
_engine_sort_last_cargo_criteria
static CargoID _engine_sort_last_cargo_criteria[]
Last set filter criteria, for each vehicle type.
Definition: build_vehicle_gui.cpp:97
SBS_DOWN
@ SBS_DOWN
Sort ascending.
Definition: window_gui.h:224
_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:1008
station_base.h
WID_BV_SCROLLBAR
@ WID_BV_SCROLLBAR
Scrollbar of list.
Definition: build_vehicle_widget.h:21
PALETTE_CRASH
static const PaletteID PALETTE_CRASH
Recolour sprite greying of crashed vehicles.
Definition: sprites.h:1594
engine_gui.h
strings_func.h
NWID_VSCROLLBAR
@ NWID_VSCROLLBAR
Vertical scrollbar.
Definition: widget_type.h:82
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
Engine::IsHidden
bool IsHidden(CompanyID c) const
Check whether the engine is hidden in the GUI for the given company.
Definition: engine_base.h:119
Engine::CanCarryCargo
bool CanCarryCargo() const
Determines whether an engine can carry something.
Definition: engine.cpp:169
GroupID
uint16 GroupID
Type for all group identifiers.
Definition: group_type.h:13
Window::IsShaded
bool IsShaded() const
Is window shaded currently?
Definition: window_gui.h:525
NWidgetBase::pos_x
int pos_x
Horizontal position of top-left corner of the widget in the window.
Definition: widget_type.h:185
WC_BUILD_VEHICLE
@ WC_BUILD_VEHICLE
Build vehicle; Window numbers:
Definition: window_type.h:376
WIDGET_LIST_END
static const int WIDGET_LIST_END
indicate the end of widgets' list for vararg functions
Definition: widget_type.h:20
EngineReliabilitySorter
static bool EngineReliabilitySorter(const EngineID &a, const EngineID &b)
Determines order of engines by reliability.
Definition: build_vehicle_gui.cpp:167
VehicleSettings::roadveh_acceleration_model
uint8 roadveh_acceleration_model
realistic acceleration for road vehicles
Definition: settings_type.h:467
Engine::GetPower
uint GetPower() const
Returns the power of the engine for display and sorting purposes.
Definition: engine.cpp:389
FONT_HEIGHT_NORMAL
#define FONT_HEIGHT_NORMAL
Height of characters in the normal (FS_NORMAL) font.
Definition: gfx_func.h:179
NWidget
static NWidgetPart NWidget(WidgetType tp, Colours col, int16 idx=-1)
Widget part function for starting a new 'real' widget.
Definition: widget_type.h:1123
BuildVehicleWindow::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: build_vehicle_gui.cpp:1546
geometry_func.hpp
GUIList< EngineID, CargoID >::FilterFunction
bool CDECL FilterFunction(const EngineID *, CargoID)
Signature of filter function.
Definition: sortlist_type.h:49
BuildVehicleWindow::roadtype
RoadType roadtype
Road type to show, or INVALID_ROADTYPE.
Definition: build_vehicle_gui.cpp:1046
SetMinimalSize
static NWidgetPart SetMinimalSize(int16 x, int16 y)
Widget part function for setting the minimal size.
Definition: widget_type.h:956
BuildVehicleWindow
GUI for building vehicles.
Definition: build_vehicle_gui.cpp:1042
RAILVEH_MULTIHEAD
@ RAILVEH_MULTIHEAD
indicates a combination of two locomotives
Definition: engine_type.h:28
WWT_PANEL
@ WWT_PANEL
Simple depressed panel.
Definition: widget_type.h:48
Window::SetWidgetsDisabledState
void CDECL SetWidgetsDisabledState(bool disab_stat, int widgets,...)
Sets the enabled/disabled status of a list of widgets.
Definition: window.cpp:536
GetRailType
static RailType GetRailType(TileIndex t)
Gets the rail type of the given tile.
Definition: rail_map.h:115
BuildVehicleWindow::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: build_vehicle_gui.cpp:1423
CT_AUTO_REFIT
@ CT_AUTO_REFIT
Automatically choose cargo type when doing auto refitting.
Definition: cargo_type.h:66
NUM_CARGO
@ NUM_CARGO
Maximal number of cargo types in a game.
Definition: cargo_type.h:64
SpecializedStation< Station, false >::GetByTile
static Station * GetByTile(TileIndex tile)
Get the station belonging to a specific tile.
Definition: base_station_base.h:238
CF_ANY
static const CargoID CF_ANY
Special cargo filter criteria.
Definition: build_vehicle_gui.cpp:89
BuildVehicleWindow::OnDropdownSelect
void OnDropdownSelect(int widget, int index) override
A dropdown option associated to this window has been selected.
Definition: build_vehicle_gui.cpp:1641
cargotype.h
RailtypeInfo::build_caption
StringID build_caption
Caption of the build vehicle GUI for this rail type.
Definition: rail.h:176
EngList_Sort
void EngList_Sort(GUIEngineList *el, EngList_SortTypeFunction compare)
Sort all items using quick sort and given 'CompareItems' function.
Definition: engine_gui.cpp:326
TestedEngineDetails::cost
Money cost
Refit cost.
Definition: vehicle_gui.h:40
GetRoadTypeInfo
static const RoadTypeInfo * GetRoadTypeInfo(RoadType roadtype)
Returns a pointer to the Roadtype information for a given roadtype.
Definition: road.h:224
CargoSpec::name
StringID name
Name of this type of cargo.
Definition: cargotype.h:70
GUIList::Filter
bool Filter(FilterFunction *decide, F filter_data)
Filter the list.
Definition: sortlist_type.h:318
Window::FinishInitNested
void FinishInitNested(WindowNumber window_number=0)
Perform the second part of the initialization of a nested widget tree.
Definition: window.cpp:1848
RailtypeInfo::strings
struct RailtypeInfo::@41 strings
Strings associated with the rail type.
BuildVehicleWindow::railtype
RailType railtype
Rail type to show, or INVALID_RAILTYPE.
Definition: build_vehicle_gui.cpp:1045
GetGroupNumEngines
uint GetGroupNumEngines(CompanyID company, GroupID id_g, EngineID id_e)
Get the number of engines with EngineID id_e in the group with GroupID id_g and its sub-groups.
Definition: group_cmd.cpp:784
company_func.h
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:1128
BuildVehicleWindow::sel_engine
EngineID sel_engine
Currently selected engine, or INVALID_ENGINE.
Definition: build_vehicle_gui.cpp:1052
BuildVehicleWindow::OnInit
void OnInit() override
Notification that the nested widget tree gets initialized.
Definition: build_vehicle_gui.cpp:1249
network.h
WID_BV_LIST
@ WID_BV_LIST
List of vehicles.
Definition: build_vehicle_widget.h:20
WD_MATRIX_BOTTOM
@ WD_MATRIX_BOTTOM
Offset at bottom of a matrix cell.
Definition: window_gui.h:79
window_func.h
GUIList::ForceRebuild
void ForceRebuild()
Force that a rebuild is needed.
Definition: sortlist_type.h:370
BuildVehicleWindow::cargo_filter_texts
StringID cargo_filter_texts[NUM_CARGO+4]
Texts for filter_cargo, terminated by INVALID_STRING_ID.
Definition: build_vehicle_gui.cpp:1056
SetBit
static T SetBit(T &x, const uint8 y)
Set a bit in a variable.
Definition: bitmath_func.hpp:121
lengthof
#define lengthof(x)
Return the length of an fixed size array.
Definition: stdafx.h:369
YearMonthDay
Data structure to convert between Date and triplet (year, month, and day).
Definition: date_type.h:103
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:1986
Window::SortButtonWidth
static int SortButtonWidth()
Get width of up/down arrow of sort button state.
Definition: widget.cpp:656
OverflowSafeInt< int64, INT64_MAX, INT64_MIN >
AircraftRangeSorter
static bool AircraftRangeSorter(const EngineID &a, const EngineID &b)
Determines order of aircraft by range.
Definition: build_vehicle_gui.cpp:419
CargoID
byte CargoID
Cargo slots to indicate a cargo type within a game.
Definition: cargo_type.h:20
NWidgetBase::pos_y
int pos_y
Vertical position of top-left corner of the widget in the window.
Definition: widget_type.h:186
ToPercent16
static uint ToPercent16(uint i)
Converts a "fract" value 0..65535 to "percent" value 0..100.
Definition: math_func.hpp:238
HasPowerOnRoad
static bool HasPowerOnRoad(RoadType enginetype, RoadType tiletype)
Checks if an engine of the given RoadType got power on a tile with a given RoadType.
Definition: road.h:239
INVALID_TILE
static const TileIndex INVALID_TILE
The very nice invalid tile marker.
Definition: tile_type.h:88
engine_base.h
TrainEngineCapacitySorter
static bool TrainEngineCapacitySorter(const EngineID &a, const EngineID &b)
Determines order of train engines by capacity.
Definition: build_vehicle_gui.cpp:311
BuildVehicleWindow::SetStringParameters
void SetStringParameters(int widget) const override
Initialize string parameters for a widget.
Definition: build_vehicle_gui.cpp:1511
BuildVehicleWindow::OnResize
void OnResize() override
Called after the window got resized.
Definition: build_vehicle_gui.cpp:1666
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:643
SetFill
static NWidgetPart SetFill(uint fill_x, uint fill_y)
Widget part function for setting filling.
Definition: widget_type.h:992
BuildVehicleWindow::UpdateFilterByTile
void UpdateFilterByTile()
Set the filter type according to the depot type.
Definition: build_vehicle_gui.cpp:1135
articulated_vehicles.h
GameSettings::vehicle
VehicleSettings vehicle
options for vehicles
Definition: settings_type.h:572
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
ShowAdditionalText
static uint ShowAdditionalText(int left, int right, int y, EngineID engine)
Display additional text from NewGRF in the purchase information window.
Definition: build_vehicle_gui.cpp:851
Window
Data structure for an opened window.
Definition: window_gui.h:277
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
Window::DrawWidgets
void DrawWidgets() const
Paint all widgets of a window.
Definition: widget.cpp:602
GetArticulatedVehicleCargoesAndRefits
void GetArticulatedVehicleCargoesAndRefits(EngineID engine, CargoArray *cargoes, CargoTypes *refits, CargoID cargo_type, uint cargo_capacity)
Get the default cargoes and refits of an articulated vehicle.
Definition: articulated_vehicles.cpp:172
EngList_SortTypeFunction
bool EngList_SortTypeFunction(const EngineID &, const EngineID &)
argument type for EngList_Sort.
Definition: engine_gui.h:20
EngineNumberSorter
static bool EngineNumberSorter(const EngineID &a, const EngineID &b)
Determines order of engines by engineID.
Definition: build_vehicle_gui.cpp:105
DC_QUERY_COST
@ DC_QUERY_COST
query cost only, don't build.
Definition: command_type.h:350
Engine::GetRange
uint16 GetRange() const
Get the range of an aircraft type.
Definition: engine.cpp:452
autoreplace_func.h
SBS_UP
@ SBS_UP
Sort descending.
Definition: window_gui.h:225
CanVehicleUseStation
bool CanVehicleUseStation(EngineID engine_type, const Station *st)
Can this station be used by the given engine type?
Definition: vehicle.cpp:2841
NWID_SELECTION
@ NWID_SELECTION
Stacked widgets, only one visible at a time (eg in a panel with tabs).
Definition: widget_type.h:78
CT_INVALID
@ CT_INVALID
Invalid cargo type.
Definition: cargo_type.h:68
NWidgetCore
Base class for a 'real' widget.
Definition: widget_type.h:292
VEH_SHIP
@ VEH_SHIP
Ship vehicle type.
Definition: vehicle_type.h:26
Rect
Specification of a rectangle with absolute coordinates of all edges.
Definition: geometry_type.hpp:47
CT_NO_REFIT
@ CT_NO_REFIT
Do not refit cargo of a vehicle (used in vehicle orders and auto-replace/auto-new).
Definition: cargo_type.h:67
RoadTypeInfo::build_caption
StringID build_caption
Caption of the build vehicle GUI for this rail type.
Definition: road.h:103
QSF_ENABLE_DEFAULT
@ QSF_ENABLE_DEFAULT
enable the 'Default' button ("\0" is returned)
Definition: textbuf_gui.h:21
NWidgetBase::current_x
uint current_x
Current horizontal size (after resizing).
Definition: widget_type.h:182
ShipVehicleInfo::ApplyWaterClassSpeedFrac
uint ApplyWaterClassSpeedFrac(uint raw_speed, bool is_ocean) const
Apply ocean/canal speed fraction to a velocity.
Definition: engine_type.h:78
EngineHasReplacementForCompany
static bool EngineHasReplacementForCompany(const Company *c, EngineID engine, GroupID group)
Check if a company has a replacement set up for the given engine.
Definition: autoreplace_func.h:51
lastof
#define lastof(x)
Get the last element of an fixed size array.
Definition: stdafx.h:385
SetDParamMaxDigits
void SetDParamMaxDigits(uint n, uint count, FontSize size)
Set DParam n to some number that is suitable for string size computations.
Definition: strings.cpp:120
DrawVehiclePurchaseInfo
int DrawVehiclePurchaseInfo(int left, int right, int y, EngineID engine_number, TestedEngineDetails &te)
Draw the purchase info details of a vehicle at a given location.
Definition: build_vehicle_gui.cpp:873
IsEngineBuildable
bool IsEngineBuildable(EngineID engine, VehicleType type, CompanyID company)
Check if an engine is buildable.
Definition: engine.cpp:1127
GetEngineListHeight
uint GetEngineListHeight(VehicleType type)
Get the height of a single 'entry' in the engine lists.
Definition: build_vehicle_gui.cpp:45
Window::SetWidgetLoweredState
void SetWidgetLoweredState(byte widget_index, bool lowered_stat)
Sets the lowered/raised status of a widget.
Definition: window_gui.h:454
Engine::intro_date
Date intro_date
Date of introduction of the engine.
Definition: engine_base.h:23
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
_current_text_dir
TextDirection _current_text_dir
Text direction of the currently selected language.
Definition: strings.cpp:48
GetGRFConfig
GRFConfig * GetGRFConfig(uint32 grfid, uint32 mask)
Retrieve a NewGRF from the current config by its grfid.
Definition: newgrf_config.cpp:811
DrawVehicleEngine
void DrawVehicleEngine(int left, int right, int preferred_x, int y, EngineID engine, PaletteID pal, EngineImageType image_type)
Draw an engine.
Definition: engine_gui.cpp:296
VehicleCellSize::extend_left
uint extend_left
Extend of the cell to the left.
Definition: vehicle_gui.h:79
BuildVehicleWindow::filter
union BuildVehicleWindow::@0 filter
Filter to apply.
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
GRFFile
Dynamic data of a loaded NewGRF.
Definition: newgrf.h:105
ClientSettings::gui
GUISettings gui
settings related to the GUI
Definition: settings_type.h:581
Engine::reliability
uint16 reliability
Current reliability of the engine.
Definition: engine_base.h:25
Engine::type
VehicleType type
Vehicle type, ie VEH_ROAD, VEH_TRAIN, etc.
Definition: engine_base.h:40
WWT_DROPDOWN
@ WWT_DROPDOWN
Drop down list.
Definition: widget_type.h:68
BuildVehicleWindow::SetCargoFilterArray
void SetCargoFilterArray()
Populate the filter list and set the cargo filter criteria.
Definition: build_vehicle_gui.cpp:1165
GRFConfig::GetName
const char * GetName() const
Get the name of this grf.
Definition: newgrf_config.cpp:105
engine_func.h
EngineNameSorter
static bool EngineNameSorter(const EngineID &a, const EngineID &b)
Determines order of engines by name.
Definition: build_vehicle_gui.cpp:138
INVALID_RAILTYPE
@ INVALID_RAILTYPE
Flag for invalid railtype.
Definition: rail_type.h:34
WWT_SHADEBOX
@ WWT_SHADEBOX
Shade box (at top-right of a window, between WWT_DEBUGBOX and WWT_DEFSIZEBOX)
Definition: widget_type.h:62