OpenTTD Source: src/build_vehicle_gui.cpp Source File

OpenTTD Source 1.11.0-RC1

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
34 #include "widgets/build_vehicle_widget.h"
35
36 #include "table/strings.h"
37
38 #include "safeguards.h"
39
45 uint GetEngineListHeight(VehicleType type)
46 {
47 return std::max<uint>(FONT_HEIGHT_NORMAL + WD_MATRIX_TOP + WD_MATRIX_BOTTOM, GetVehicleImageCellSize(type, EIT_PURCHASE).height);
48 }
49
50 static const NWidgetPart _nested_build_vehicle_widgets[] = {
51 NWidget(NWID_HORIZONTAL),
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),
59 NWidget(NWID_VERTICAL),
60 NWidget(NWID_HORIZONTAL),
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(),
64 NWidget(NWID_HORIZONTAL),
65 NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_BV_SHOW_HIDDEN_ENGINES),
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. */
71 NWidget(NWID_HORIZONTAL),
72 NWidget(WWT_MATRIX, COLOUR_GREY, WID_BV_LIST), SetResize(1, 1), SetFill(1, 0), SetMatrixDataTip(1, 0, STR_NULL), SetScrollbar(WID_BV_SCROLLBAR),
73 NWidget(NWID_VSCROLLBAR, COLOUR_GREY, 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. */
78 NWidget(NWID_HORIZONTAL),
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;
91 static const CargoID CF_ENGINES = CT_AUTO_REFIT;
92
93 bool _engine_sort_direction;
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};
97 static CargoID _engine_sort_last_cargo_criteria[] = {CF_ANY, CF_ANY, CF_ANY, CF_ANY};
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 {
352 int va = GetTotalCapacityOfArticulatedParts(a);
353 int vb = GetTotalCapacityOfArticulatedParts(b);
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
432 EngList_SortTypeFunction * const _engine_sort_functions[][11] = {{
433 /* Trains */
434 &EngineNumberSorter,
435 &EngineCostSorter,
436 &EngineSpeedSorter,
437 &EnginePowerSorter,
438 &EngineTractiveEffortSorter,
439 &EngineIntroDateSorter,
440 &EngineNameSorter,
441 &EngineRunningCostSorter,
442 &EnginePowerVsRunningCostSorter,
443 &EngineReliabilitySorter,
444 &TrainEngineCapacitySorter,
445 }, {
446 /* Road vehicles */
447 &EngineNumberSorter,
448 &EngineCostSorter,
449 &EngineSpeedSorter,
450 &EnginePowerSorter,
451 &EngineTractiveEffortSorter,
452 &EngineIntroDateSorter,
453 &EngineNameSorter,
454 &EngineRunningCostSorter,
455 &EnginePowerVsRunningCostSorter,
456 &EngineReliabilitySorter,
457 &RoadVehEngineCapacitySorter,
458 }, {
459 /* Ships */
460 &EngineNumberSorter,
461 &EngineCostSorter,
462 &EngineSpeedSorter,
463 &EngineIntroDateSorter,
464 &EngineNameSorter,
465 &EngineRunningCostSorter,
466 &EngineReliabilitySorter,
467 &ShipEngineCapacitySorter,
468 }, {
469 /* Aircraft */
470 &EngineNumberSorter,
471 &EngineCostSorter,
472 &EngineSpeedSorter,
473 &EngineIntroDateSorter,
474 &EngineNameSorter,
475 &EngineRunningCostSorter,
476 &EngineReliabilitySorter,
477 &AircraftEngineCargoSorter,
478 &AircraftRangeSorter,
479 }};
480
482 const StringID _engine_sort_listing[][12] = {{
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,
495 INVALID_STRING_ID
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,
509 INVALID_STRING_ID
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,
520 INVALID_STRING_ID
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,
532 INVALID_STRING_ID
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[] = {
549 &CargoAndEngineFilter,
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 */
596 if (_settings_game.vehicle.wagon_speed_limits) {
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) {
641 SetDParam(0, e->GetDisplayMaxTractiveEffort());
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
669 if (_settings_game.vehicle.roadveh_acceleration_model != AM_ORIGINAL) {
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 */
696 SetDParam(0, e->GetDisplayMaxTractiveEffort());
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 */
828 SetDParam(0, e->GetAircraftTypeText());
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);
863 StopTextRefStackUsage();
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);
924 SetDParam(1, e->GetLifeLengthInDays() / DAYS_IN_LEAP_YEAR);
925 DrawString(left, right, y, STR_PURCHASE_INFO_DESIGNED_LIFE);
926 y += FONT_HEIGHT_NORMAL;
927
928 /* Reliability */
929 SetDParam(0, ToPercent16(e->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);
983 SetDParamMaxDigits(0, 3, FS_SMALL);
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
1042 struct BuildVehicleWindow : Window {
1043 VehicleType vehicle_type;
1044 union {
1045 RailType railtype;
1046 RoadType roadtype;
1047 } filter;
1048 bool descending_sort_order;
1049 byte sort_criteria;
1050 bool show_hidden_engines;
1051 bool listview_mode;
1052 EngineID sel_engine;
1053 EngineID rename_engine;
1054 GUIEngineList eng_list;
1055 CargoID cargo_filter[NUM_CARGO + 3];
1056 StringID cargo_filter_texts[NUM_CARGO + 4];
1057 byte cargo_filter_criteria;
1058 int details_height;
1059 Scrollbar *vscroll;
1060 TestedEngineDetails te;
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 */
1101 this->SetWidgetDisabledState(WID_BV_RENAME, _networking && !_network_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) * FONT_HEIGHT_NORMAL + WD_FRAMERECT_TOP + WD_FRAMERECT_BOTTOM;
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
1135 void UpdateFilterByTile()
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
1165 void SetCargoFilterArray()
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;
1190 FOR_ALL_SORTED_STANDARD_CARGOSPECS(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();
1236 this->te.capacity = _returned_refit_capacity;
1237 this->te.mail_capacity = _returned_mail_refit_capacity;
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
1255 void FilterEngineList()
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
1266 bool FilterSingleEngine(EngineID eid)
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 */
1317 _engine_sort_direction = this->descending_sort_order;
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
1416 _engine_sort_direction = this->descending_sort_order;
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) {
1426 case WID_BV_SORT_ASCENDING_DESCENDING:
1427 this->descending_sort_order ^= true;
1428 _engine_sort_last_order[this->vehicle_type] = this->descending_sort_order;
1429 this->eng_list.ForceRebuild();
1430 this->SetDirty();
1431 break;
1432
1433 case WID_BV_SHOW_HIDDEN_ENGINES:
1434 this->show_hidden_engines ^= true;
1435 _engine_sort_show_hidden_engines[this->vehicle_type] = this->show_hidden_engines;
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 &&
1503 _settings_game.vehicle.roadveh_acceleration_model == AM_ORIGINAL &&
1504 this->sort_criteria > 7) {
1505 this->sort_criteria = 0;
1506 _engine_sort_last_criteria[VEH_ROAD] = 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
1530 case WID_BV_CARGO_FILTER_DROPDOWN:
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 = this->details_height;
1557 break;
1558
1559 case WID_BV_SORT_ASCENDING_DESCENDING: {
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:
1587 DrawEngineList(
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,
1597 DEFAULT_GROUP
1598 );
1599 break;
1600
1601 case WID_BV_SORT_ASCENDING_DESCENDING:
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
1612 this->SetWidgetsDisabledState(this->sel_engine == INVALID_ENGINE, WID_BV_SHOW_HIDE, WID_BV_BUILD, WID_BV_RENAME, WIDGET_LIST_END);
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);
1621 int text_end = DrawVehiclePurchaseInfo(nwi->pos_x + WD_FRAMETEXT_LEFT, nwi->pos_x + nwi->current_x - WD_FRAMETEXT_RIGHT,
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_BOTTOM);
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);
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;
1647 _engine_sort_last_criteria[this->vehicle_type] = this->sort_criteria;
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,
1674 WC_BUILD_VEHICLE, WC_NONE,
1675 WDF_CONSTRUCTION,
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
1689 DeleteWindowById(WC_BUILD_VEHICLE, num);
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:389
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:78
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:1094
CcBuildPrimaryVehicle
void CcBuildPrimaryVehicle(const CommandCost &result, TileIndex tile, uint32 p1, uint32 p2, uint32 cmd)
This is the Callback method after the construction attempt of a primary vehicle.
Definition: vehicle_gui.cpp:3082
VehicleSettings::train_acceleration_model
uint8 train_acceleration_model
realistic acceleration for trains
Definition: settings_type.h:462
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:1966
_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:466
Scrollbar::SetCount
void SetCount(int num)
Sets the number of elements in the list.
Definition: widget_type.h:669
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:929
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:324
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:305
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:336
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:588
GetVehicleCallback
uint16 GetVehicleCallback(CallbackID callback, uint32 param1, uint32 param2, EngineID engine, const Vehicle *v)
Evaluate a newgrf callback for vehicles.
Definition: newgrf_engine.cpp:1188
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:2031
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:909
_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:1013
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:304
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:322
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:1031
_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:392
_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:1131
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 (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:494
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:312
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:998
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:524
NWidgetBase::pos_x
int pos_x
Horizontal position of top-left corner of the widget in the window.
Definition: widget_type.h:175
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:463
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:1113
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:946
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:1123
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:367
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:1980
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:176
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:83
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:625
SetFill
static NWidgetPart SetFill(uint fill_x, uint fill_y)
Widget part function for setting filling.
Definition: widget_type.h:982
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:568
ErrorUnknownCallbackResult
void ErrorUnknownCallbackResult(uint32 grfid, uint16 cbid, uint16 cb_res)
Record that a NewGRF returned an unknown/invalid callback result.
Definition: newgrf_commons.cpp:516
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:276
GUIList::RebuildDone
void RebuildDone()
Notify the sortlist that the rebuild is done.
Definition: sortlist_type.h:380
VEH_TRAIN
@ VEH_TRAIN
Train vehicle type.
Definition: vehicle_type.h:24
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:2838
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:282
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:172
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:383
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:1123
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:453
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:810
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:577
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:104
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