OpenTTD Source: src/depot_gui.cpp Source File

OpenTTD Source 14.0-beta1

depot_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 "train.h"
12 #include "roadveh.h"
13 #include "ship.h"
14 #include "aircraft.h"
15 #include "gui.h"
16 #include "textbuf_gui.h"
17 #include "viewport_func.h"
18 #include "command_func.h"
19 #include "depot_base.h"
20 #include "spritecache.h"
21 #include "strings_func.h"
22 #include "vehicle_func.h"
23 #include "company_func.h"
24 #include "tilehighlight_func.h"
25 #include "window_gui.h"
26 #include "vehiclelist.h"
27 #include "vehicle_func.h"
28 #include "order_backup.h"
29 #include "zoom_func.h"
30 #include "error.h"
31 #include "depot_cmd.h"
32 #include "train_cmd.h"
33 #include "vehicle_cmd.h"
34 #include "core/geometry_func.hpp"
35
36 #include "widgets/depot_widget.h"
37
38 #include "table/strings.h"
39
40 #include "safeguards.h"
41
42 /*
43 * Since all depot window sizes aren't the same, we need to modify sizes a little.
44 * It's done with the following arrays of widget indexes. Each of them tells if a widget side should be moved and in what direction.
45 * How long they should be moved and for what window types are controlled in ShowDepotWindow()
46 */
47
49 static constexpr NWidgetPart _nested_train_depot_widgets[] = {
50 NWidget(NWID_HORIZONTAL),
51 NWidget(WWT_CLOSEBOX, COLOUR_GREY),
52 NWidget(NWID_SELECTION, INVALID_COLOUR, WID_D_SHOW_RENAME), // rename button
53 NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_D_RENAME), SetMinimalSize(12, 14), SetDataTip(SPR_RENAME, STR_DEPOT_RENAME_TOOLTIP),
54 EndContainer(),
55 NWidget(WWT_CAPTION, COLOUR_GREY, WID_D_CAPTION), SetDataTip(STR_DEPOT_CAPTION, STR_NULL),
56 NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_D_LOCATION), SetMinimalSize(12, 14), SetDataTip(SPR_GOTO_LOCATION, STR_NULL),
57 NWidget(WWT_SHADEBOX, COLOUR_GREY),
58 NWidget(WWT_DEFSIZEBOX, COLOUR_GREY),
59 NWidget(WWT_STICKYBOX, COLOUR_GREY),
60 EndContainer(),
61 NWidget(NWID_HORIZONTAL),
62 NWidget(NWID_VERTICAL),
63 NWidget(WWT_MATRIX, COLOUR_GREY, WID_D_MATRIX), SetResize(1, 1), SetScrollbar(WID_D_V_SCROLL),
64 NWidget(NWID_SELECTION, INVALID_COLOUR, WID_D_SHOW_H_SCROLL),
65 NWidget(NWID_HSCROLLBAR, COLOUR_GREY, WID_D_H_SCROLL),
66 EndContainer(),
67 EndContainer(),
68 NWidget(NWID_VERTICAL),
69 NWidget(WWT_IMGBTN, COLOUR_GREY, WID_D_SELL), SetDataTip(0x0, STR_NULL), SetResize(0, 1), SetFill(0, 1),
70 NWidget(NWID_SELECTION, INVALID_COLOUR, WID_D_SHOW_SELL_CHAIN),
71 NWidget(WWT_IMGBTN, COLOUR_GREY, WID_D_SELL_CHAIN), SetDataTip(SPR_SELL_CHAIN_TRAIN, STR_DEPOT_DRAG_WHOLE_TRAIN_TO_SELL_TOOLTIP), SetResize(0, 1), SetFill(0, 1),
72 EndContainer(),
73 NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_D_SELL_ALL), SetDataTip(0x0, STR_NULL),
74 NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_D_AUTOREPLACE), SetDataTip(0x0, STR_NULL),
75 EndContainer(),
76 NWidget(NWID_VSCROLLBAR, COLOUR_GREY, WID_D_V_SCROLL),
77 EndContainer(),
78 NWidget(NWID_HORIZONTAL, NC_EQUALSIZE),
79 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_D_BUILD), SetDataTip(0x0, STR_NULL), SetFill(1, 1), SetResize(1, 0),
80 NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_D_CLONE), SetDataTip(0x0, STR_NULL), SetFill(1, 1), SetResize(1, 0),
81 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_D_VEHICLE_LIST), SetDataTip(0x0, STR_NULL), SetFill(0, 1),
82 NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_D_STOP_ALL), SetDataTip(SPR_FLAG_VEH_STOPPED, STR_NULL), SetFill(0, 1),
83 NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_D_START_ALL), SetDataTip(SPR_FLAG_VEH_RUNNING, STR_NULL), SetFill(0, 1),
84 NWidget(WWT_RESIZEBOX, COLOUR_GREY),
85 EndContainer(),
86 };
87
88 static WindowDesc _train_depot_desc(__FILE__, __LINE__,
89 WDP_AUTO, "depot_train", 362, 123,
90 WC_VEHICLE_DEPOT, WC_NONE,
91 0,
92 std::begin(_nested_train_depot_widgets), std::end(_nested_train_depot_widgets)
93 );
94
95 static WindowDesc _road_depot_desc(__FILE__, __LINE__,
96 WDP_AUTO, "depot_roadveh", 316, 97,
97 WC_VEHICLE_DEPOT, WC_NONE,
98 0,
99 std::begin(_nested_train_depot_widgets), std::end(_nested_train_depot_widgets)
100 );
101
102 static WindowDesc _ship_depot_desc(__FILE__, __LINE__,
103 WDP_AUTO, "depot_ship", 306, 99,
104 WC_VEHICLE_DEPOT, WC_NONE,
105 0,
106 std::begin(_nested_train_depot_widgets), std::end(_nested_train_depot_widgets)
107 );
108
109 static WindowDesc _aircraft_depot_desc(__FILE__, __LINE__,
110 WDP_AUTO, "depot_aircraft", 332, 99,
111 WC_VEHICLE_DEPOT, WC_NONE,
112 0,
113 std::begin(_nested_train_depot_widgets), std::end(_nested_train_depot_widgets)
114 );
115
116 extern void DepotSortList(VehicleList *list);
117
123 void CcCloneVehicle(Commands, const CommandCost &result, VehicleID veh_id)
124 {
125 if (result.Failed()) return;
126
127 const Vehicle *v = Vehicle::Get(veh_id);
128
129 ShowVehicleViewWindow(v);
130 }
131
132 static void TrainDepotMoveVehicle(const Vehicle *wagon, VehicleID sel, const Vehicle *head)
133 {
134 const Vehicle *v = Vehicle::Get(sel);
135
136 if (v == wagon) return;
137
138 if (wagon == nullptr) {
139 if (head != nullptr) wagon = head->Last();
140 } else {
141 wagon = wagon->Previous();
142 if (wagon == nullptr) return;
143 }
144
145 if (wagon == v) return;
146
147 Command<CMD_MOVE_RAIL_VEHICLE>::Post(STR_ERROR_CAN_T_MOVE_VEHICLE, v->tile, v->index, wagon == nullptr ? INVALID_VEHICLE : wagon->index, _ctrl_pressed);
148 }
149
150 static VehicleCellSize _base_block_sizes_depot[VEH_COMPANY_END];
151 static VehicleCellSize _base_block_sizes_purchase[VEH_COMPANY_END];
152 static uint _consistent_train_width;
153
161 VehicleCellSize GetVehicleImageCellSize(VehicleType type, EngineImageType image_type)
162 {
163 switch (image_type) {
164 case EIT_IN_DEPOT: return _base_block_sizes_depot[type];
165 case EIT_PURCHASE: return _base_block_sizes_purchase[type];
166 default: NOT_REACHED();
167 }
168 }
169
170 static void InitBlocksizeForVehicles(VehicleType type, EngineImageType image_type)
171 {
172 int max_extend_left = 0;
173 int max_extend_right = 0;
174 uint max_height = 0;
175
176 for (const Engine *e : Engine::IterateType(type)) {
177 if (!e->IsEnabled()) continue;
178
179 EngineID eid = e->index;
180 uint x, y;
181 int x_offs, y_offs;
182
183 switch (type) {
184 default: NOT_REACHED();
185 case VEH_TRAIN: GetTrainSpriteSize( eid, x, y, x_offs, y_offs, image_type); break;
186 case VEH_ROAD: GetRoadVehSpriteSize( eid, x, y, x_offs, y_offs, image_type); break;
187 case VEH_SHIP: GetShipSpriteSize( eid, x, y, x_offs, y_offs, image_type); break;
188 case VEH_AIRCRAFT: GetAircraftSpriteSize(eid, x, y, x_offs, y_offs, image_type); break;
189 }
190 if (y > max_height) max_height = y;
191 if (-x_offs > max_extend_left) max_extend_left = -x_offs;
192 if ((int)x + x_offs > max_extend_right) max_extend_right = x + x_offs;
193 }
194
195 int min_extend = ScaleSpriteTrad(16);
196 int max_extend = ScaleSpriteTrad(98);
197
198 switch (image_type) {
199 case EIT_IN_DEPOT:
200 _base_block_sizes_depot[type].height = std::max<uint>(ScaleSpriteTrad(GetVehicleHeight(type)), max_height);
201 _base_block_sizes_depot[type].extend_left = Clamp(max_extend_left, min_extend, max_extend);
202 _base_block_sizes_depot[type].extend_right = Clamp(max_extend_right, min_extend, max_extend);
203 break;
204 case EIT_PURCHASE:
205 _base_block_sizes_purchase[type].height = std::max<uint>(ScaleSpriteTrad(GetVehicleHeight(type)), max_height);
206 _base_block_sizes_purchase[type].extend_left = Clamp(max_extend_left, min_extend, max_extend);
207 _base_block_sizes_purchase[type].extend_right = Clamp(max_extend_right, min_extend, max_extend);
208 break;
209
210 default: NOT_REACHED();
211 }
212 }
213
218 void InitDepotWindowBlockSizes()
219 {
220 for (VehicleType vt = VEH_BEGIN; vt < VEH_COMPANY_END; vt++) {
221 InitBlocksizeForVehicles(vt, EIT_IN_DEPOT);
222 InitBlocksizeForVehicles(vt, EIT_PURCHASE);
223 }
224
225 _consistent_train_width = TRAININFO_DEFAULT_VEHICLE_WIDTH;
226 bool first = true;
227 for (const Engine *e : Engine::IterateType(VEH_TRAIN)) {
228 if (!e->IsEnabled()) continue;
229
230 uint w = TRAININFO_DEFAULT_VEHICLE_WIDTH;
231 if (e->GetGRF() != nullptr && is_custom_sprite(e->u.rail.image_index)) {
232 w = e->GetGRF()->traininfo_vehicle_width;
233 if (w != VEHICLEINFO_FULL_VEHICLE_WIDTH) {
234 /* Hopeless.
235 * This is a NewGRF vehicle that uses TRAININFO_DEFAULT_VEHICLE_WIDTH.
236 * If the vehicles are shorter than 8/8 we have fractional lengths, which are not consistent after rounding.
237 */
238 _consistent_train_width = 0;
239 break;
240 }
241 }
242
243 if (first) {
244 _consistent_train_width = w;
245 first = false;
246 } else if (w != _consistent_train_width) {
247 _consistent_train_width = 0;
248 break;
249 }
250 }
251 }
252
253 static void DepotSellAllConfirmationCallback(Window *w, bool confirmed);
254 const Sprite *GetAircraftSprite(EngineID engine);
255
256 struct DepotWindow : Window {
257 VehicleID sel;
258 VehicleID vehicle_over;
259 VehicleType type;
260 bool generate_list;
261 WidgetID hovered_widget;
262 VehicleList vehicle_list;
263 VehicleList wagon_list;
264 uint unitnumber_digits;
265 uint num_columns;
266 Scrollbar *hscroll;
267 Scrollbar *vscroll;
268
269 DepotWindow(WindowDesc *desc, TileIndex tile, VehicleType type) : Window(desc)
270 {
271 assert(IsCompanyBuildableVehicleType(type)); // ensure that we make the call with a valid type
272
273 this->sel = INVALID_VEHICLE;
274 this->vehicle_over = INVALID_VEHICLE;
275 this->generate_list = true;
276 this->hovered_widget = -1;
277 this->type = type;
278 this->num_columns = 1; // for non-trains this gets set in FinishInitNested()
279 this->unitnumber_digits = 2;
280
281 this->CreateNestedTree();
282 this->hscroll = (this->type == VEH_TRAIN ? this->GetScrollbar(WID_D_H_SCROLL) : nullptr);
283 this->vscroll = this->GetScrollbar(WID_D_V_SCROLL);
284 /* Don't show 'rename button' of aircraft hangar */
285 this->GetWidget<NWidgetStacked>(WID_D_SHOW_RENAME)->SetDisplayedPlane(type == VEH_AIRCRAFT ? SZSP_NONE : 0);
286 /* Only train depots have a horizontal scrollbar and a 'sell chain' button */
287 if (type == VEH_TRAIN) this->GetWidget<NWidgetCore>(WID_D_MATRIX)->widget_data = 1 << MAT_COL_START;
288 this->GetWidget<NWidgetStacked>(WID_D_SHOW_H_SCROLL)->SetDisplayedPlane(type == VEH_TRAIN ? 0 : SZSP_HORIZONTAL);
289 this->GetWidget<NWidgetStacked>(WID_D_SHOW_SELL_CHAIN)->SetDisplayedPlane(type == VEH_TRAIN ? 0 : SZSP_NONE);
290 this->SetupWidgetData(type);
291 this->FinishInitNested(tile);
292
293 this->owner = GetTileOwner(tile);
294 OrderBackup::Reset();
295 }
296
297 void Close([[maybe_unused]] int data = 0) override
298 {
299 CloseWindowById(WC_BUILD_VEHICLE, this->window_number);
300 CloseWindowById(GetWindowClassForVehicleType(this->type), VehicleListIdentifier(VL_DEPOT_LIST, this->type, this->owner, this->GetDepotIndex()).Pack(), false);
301 OrderBackup::Reset(this->window_number);
302 this->Window::Close();
303 }
304
310 void DrawVehicleInDepot(const Vehicle *v, const Rect &r) const
311 {
312 bool free_wagon = false;
313
314 bool rtl = _current_text_dir == TD_RTL;
315 Rect text = r.Shrink(RectPadding::zero, WidgetDimensions::scaled.matrix); /* Ract for text elements, horizontal is already applied. */
316 Rect image = r.Indent(this->header_width, rtl).Indent(this->count_width, !rtl); /* Rect for vehicle images */
317
318 switch (v->type) {
319 case VEH_TRAIN: {
320 const Train *u = Train::From(v);
321 free_wagon = u->IsFreeWagon();
322
323 uint x_space = free_wagon ?
324 ScaleSpriteTrad(_consistent_train_width != 0 ? _consistent_train_width : TRAININFO_DEFAULT_VEHICLE_WIDTH) :
325 0;
326
327 DrawTrainImage(u, image.Indent(x_space, rtl), this->sel, EIT_IN_DEPOT, free_wagon ? 0 : this->hscroll->GetPosition(), this->vehicle_over);
328
329 /* Length of consist in tiles with 1 fractional digit (rounded up) */
330 SetDParam(0, CeilDiv(u->gcache.cached_total_length * 10, TILE_SIZE));
331 SetDParam(1, 1);
332 Rect count = text.WithWidth(this->count_width - WidgetDimensions::scaled.hsep_normal, !rtl);
333 DrawString(count.left, count.right, count.bottom - GetCharacterHeight(FS_SMALL) + 1, STR_JUST_DECIMAL, TC_BLACK, SA_RIGHT, false, FS_SMALL); // Draw the counter
334 break;
335 }
336
337 case VEH_ROAD: DrawRoadVehImage( v, image, this->sel, EIT_IN_DEPOT); break;
338 case VEH_SHIP: DrawShipImage( v, image, this->sel, EIT_IN_DEPOT); break;
339 case VEH_AIRCRAFT: DrawAircraftImage(v, image, this->sel, EIT_IN_DEPOT); break;
340 default: NOT_REACHED();
341 }
342
343 uint diff_x, diff_y;
344 if (v->IsGroundVehicle()) {
345 /* Arrange unitnumber and flag horizontally */
346 diff_x = this->flag_size.width + WidgetDimensions::scaled.hsep_normal;
347 diff_y = WidgetDimensions::scaled.matrix.top;
348 } else {
349 /* Arrange unitnumber and flag vertically */
350 diff_x = 0;
351 diff_y = WidgetDimensions::scaled.matrix.top + GetCharacterHeight(FS_NORMAL) + WidgetDimensions::scaled.vsep_normal;
352 }
353
354 text = text.WithWidth(this->header_width - WidgetDimensions::scaled.hsep_normal, rtl).WithHeight(GetCharacterHeight(FS_NORMAL)).Indent(diff_x, rtl);
355 if (free_wagon) {
356 DrawString(text, STR_DEPOT_NO_ENGINE);
357 } else {
358 Rect flag = r.WithWidth(this->flag_size.width, rtl).WithHeight(this->flag_size.height).Translate(0, diff_y);
359 DrawSpriteIgnorePadding((v->vehstatus & VS_STOPPED) ? SPR_FLAG_VEH_STOPPED : SPR_FLAG_VEH_RUNNING, PAL_NONE, flag, SA_CENTER);
360
361 SetDParam(0, v->unitnumber);
362 DrawString(text, STR_JUST_COMMA, (v->max_age - CalendarTime::DAYS_IN_LEAP_YEAR) >= v->age ? TC_BLACK : TC_RED);
363 }
364 }
365
366 void DrawWidget(const Rect &r, WidgetID widget) const override
367 {
368 if (widget != WID_D_MATRIX) return;
369
370 bool rtl = _current_text_dir == TD_RTL;
371
372 /* Set the row and number of boxes in each row based on the number of boxes drawn in the matrix */
373 const NWidgetCore *wid = this->GetWidget<NWidgetCore>(WID_D_MATRIX);
374
375 /* Set up rect for each cell */
376 Rect ir = r.WithHeight(this->resize.step_height);
377 if (this->num_columns != 1) ir = ir.WithWidth(this->resize.step_width, rtl);
378 ir = ir.Shrink(WidgetDimensions::scaled.framerect, RectPadding::zero);
379
380 /* Draw vertical separators at whole tiles.
381 * This only works in two cases:
382 * - All vehicles use VEHICLEINFO_FULL_VEHICLE_WIDTH as reference width.
383 * - All vehicles are 8/8. This cannot be checked for NewGRF, so instead we check for "all vehicles are original vehicles".
384 */
385 if (this->type == VEH_TRAIN && _consistent_train_width != 0) {
386 int w = ScaleSpriteTrad(2 * _consistent_train_width);
387 int col = _colour_gradient[wid->colour][4];
388 Rect image = ir.Indent(this->header_width, rtl).Indent(this->count_width, !rtl);
389 int first_line = w + (-this->hscroll->GetPosition()) % w;
390 if (rtl) {
391 for (int x = image.right - first_line; x >= image.left; x -= w) {
392 GfxDrawLine(x, r.top, x, r.bottom, col, ScaleGUITrad(1), ScaleGUITrad(3));
393 }
394 } else {
395 for (int x = image.left + first_line; x <= image.right; x += w) {
396 GfxDrawLine(x, r.top, x, r.bottom, col, ScaleGUITrad(1), ScaleGUITrad(3));
397 }
398 }
399 }
400
401 uint16_t rows_in_display = wid->current_y / wid->resize_y;
402
403 uint num = this->vscroll->GetPosition() * this->num_columns;
404 uint maxval = static_cast<uint>(std::min<size_t>(this->vehicle_list.size(), num + (rows_in_display * this->num_columns)));
405 for (; num < maxval; ir = ir.Translate(0, this->resize.step_height)) { // Draw the rows
406 Rect cell = ir; /* Keep track of horizontal cells */
407 for (uint i = 0; i < this->num_columns && num < maxval; i++, num++) {
408 /* Draw all vehicles in the current row */
409 const Vehicle *v = this->vehicle_list[num];
410 this->DrawVehicleInDepot(v, cell);
411 cell = cell.Translate(rtl ? -(int)this->resize.step_width : (int)this->resize.step_width, 0);
412 }
413 }
414
415 maxval = static_cast<uint>(std::min<size_t>(this->vehicle_list.size() + this->wagon_list.size(), (this->vscroll->GetPosition() * this->num_columns) + (rows_in_display * this->num_columns)));
416
417 /* Draw the train wagons without an engine in front. */
418 for (; num < maxval; num++, ir = ir.Translate(0, this->resize.step_height)) {
419 const Vehicle *v = this->wagon_list[num - this->vehicle_list.size()];
420 this->DrawVehicleInDepot(v, ir);
421 }
422 }
423
424 void SetStringParameters(WidgetID widget) const override
425 {
426 if (widget != WID_D_CAPTION) return;
427
428 SetDParam(0, this->type);
429 SetDParam(1, this->GetDepotIndex());
430 }
431
432 struct GetDepotVehiclePtData {
433 const Vehicle *head;
434 const Vehicle *wagon;
435 };
436
437 enum DepotGUIAction {
438 MODE_ERROR,
439 MODE_DRAG_VEHICLE,
440 MODE_SHOW_VEHICLE,
441 MODE_START_STOP,
442 };
443
444 DepotGUIAction GetVehicleFromDepotWndPt(int x, int y, const Vehicle **veh, GetDepotVehiclePtData *d) const
445 {
446 const NWidgetCore *matrix_widget = this->GetWidget<NWidgetCore>(WID_D_MATRIX);
447 /* Make X relative to widget. Y is left alone for GetScrolledRowFromWidget(). */
448 x -= matrix_widget->pos_x;
449 /* In case of RTL the widgets are swapped as a whole */
450 if (_current_text_dir == TD_RTL) x = matrix_widget->current_x - x;
451
452 uint xt = 0, xm = 0, ym = 0;
453 if (this->type == VEH_TRAIN) {
454 xm = x;
455 } else {
456 xt = x / this->resize.step_width;
457 xm = x % this->resize.step_width;
458 if (xt >= this->num_columns) return MODE_ERROR;
459 }
460 ym = (y - matrix_widget->pos_y) % this->resize.step_height;
461
462 int row = this->vscroll->GetScrolledRowFromWidget(y, this, WID_D_MATRIX);
463 uint pos = (row * this->num_columns) + xt;
464
465 if (row == INT_MAX || this->vehicle_list.size() + this->wagon_list.size() <= pos) {
466 /* Clicking on 'line' / 'block' without a vehicle */
467 if (this->type == VEH_TRAIN) {
468 /* End the dragging */
469 d->head = nullptr;
470 d->wagon = nullptr;
471 return MODE_DRAG_VEHICLE;
472 } else {
473 return MODE_ERROR; // empty block, so no vehicle is selected
474 }
475 }
476
477 bool wagon = false;
478 if (this->vehicle_list.size() > pos) {
479 *veh = this->vehicle_list[pos];
480 /* Skip vehicles that are scrolled off the list */
481 if (this->type == VEH_TRAIN) x += this->hscroll->GetPosition();
482 } else {
483 pos -= (uint)this->vehicle_list.size();
484 *veh = this->wagon_list[pos];
485 /* free wagons don't have an initial loco. */
486 x -= ScaleSpriteTrad(VEHICLEINFO_FULL_VEHICLE_WIDTH);
487 wagon = true;
488 }
489
490 const Train *v = nullptr;
491 if (this->type == VEH_TRAIN) {
492 v = Train::From(*veh);
493 d->head = d->wagon = v;
494 }
495
496 if (xm <= this->header_width) {
497 switch (this->type) {
498 case VEH_TRAIN:
499 if (wagon) return MODE_ERROR;
500 [[fallthrough]];
501
502 case VEH_ROAD:
503 if (xm <= this->flag_size.width) return MODE_START_STOP;
504 break;
505
506 case VEH_SHIP:
507 case VEH_AIRCRAFT:
508 if (xm <= this->flag_size.width && ym >= (uint)(GetCharacterHeight(FS_NORMAL) + WidgetDimensions::scaled.vsep_normal)) return MODE_START_STOP;
509 break;
510
511 default: NOT_REACHED();
512 }
513 return MODE_SHOW_VEHICLE;
514 }
515
516 if (this->type != VEH_TRAIN) return MODE_DRAG_VEHICLE;
517
518 /* Clicking on the counter */
519 if (xm >= matrix_widget->current_x - this->count_width) return wagon ? MODE_ERROR : MODE_SHOW_VEHICLE;
520
521 /* Account for the header */
522 x -= this->header_width;
523
524 /* find the vehicle in this row that was clicked */
525 for (; v != nullptr; v = v->Next()) {
526 x -= v->GetDisplayImageWidth();
527 if (x < 0) break;
528 }
529
530 d->wagon = (v != nullptr ? v->GetFirstEnginePart() : nullptr);
531
532 return MODE_DRAG_VEHICLE;
533 }
534
540 void DepotClick(int x, int y)
541 {
542 GetDepotVehiclePtData gdvp = { nullptr, nullptr };
543 const Vehicle *v = nullptr;
544 DepotGUIAction mode = this->GetVehicleFromDepotWndPt(x, y, &v, &gdvp);
545
546 if (this->type == VEH_TRAIN) v = gdvp.wagon;
547
548 switch (mode) {
549 case MODE_ERROR: // invalid
550 return;
551
552 case MODE_DRAG_VEHICLE: { // start dragging of vehicle
553 if (v != nullptr && VehicleClicked(v)) return;
554
555 VehicleID sel = this->sel;
556
557 if (this->type == VEH_TRAIN && sel != INVALID_VEHICLE) {
558 this->sel = INVALID_VEHICLE;
559 TrainDepotMoveVehicle(v, sel, gdvp.head);
560 } else if (v != nullptr) {
561 SetObjectToPlaceWnd(SPR_CURSOR_MOUSE, PAL_NONE, HT_DRAG, this);
562 SetMouseCursorVehicle(v, EIT_IN_DEPOT);
563 _cursor.vehchain = _ctrl_pressed;
564
565 this->sel = v->index;
566 this->SetDirty();
567 }
568 break;
569 }
570
571 case MODE_SHOW_VEHICLE: // show info window
572 ShowVehicleViewWindow(v);
573 break;
574
575 case MODE_START_STOP: // click start/stop flag
576 StartStopVehicle(v, false);
577 break;
578
579 default: NOT_REACHED();
580 }
581 }
582
589 void SetupWidgetData(VehicleType type)
590 {
591 this->GetWidget<NWidgetCore>(WID_D_STOP_ALL)->tool_tip = STR_DEPOT_MASS_STOP_DEPOT_TRAIN_TOOLTIP + type;
592 this->GetWidget<NWidgetCore>(WID_D_START_ALL)->tool_tip = STR_DEPOT_MASS_START_DEPOT_TRAIN_TOOLTIP + type;
593 this->GetWidget<NWidgetCore>(WID_D_SELL)->tool_tip = STR_DEPOT_TRAIN_SELL_TOOLTIP + type;
594 this->GetWidget<NWidgetCore>(WID_D_SELL_ALL)->tool_tip = STR_DEPOT_SELL_ALL_BUTTON_TRAIN_TOOLTIP + type;
595
596 this->GetWidget<NWidgetCore>(WID_D_BUILD)->SetDataTip(STR_DEPOT_TRAIN_NEW_VEHICLES_BUTTON + type, STR_DEPOT_TRAIN_NEW_VEHICLES_TOOLTIP + type);
597 this->GetWidget<NWidgetCore>(WID_D_CLONE)->SetDataTip(STR_DEPOT_CLONE_TRAIN + type, STR_DEPOT_CLONE_TRAIN_DEPOT_INFO + type);
598
599 this->GetWidget<NWidgetCore>(WID_D_LOCATION)->tool_tip = STR_DEPOT_TRAIN_LOCATION_TOOLTIP + type;
600 this->GetWidget<NWidgetCore>(WID_D_VEHICLE_LIST)->tool_tip = STR_DEPOT_VEHICLE_ORDER_LIST_TRAIN_TOOLTIP + type;
601 this->GetWidget<NWidgetCore>(WID_D_AUTOREPLACE)->tool_tip = STR_DEPOT_AUTOREPLACE_TRAIN_TOOLTIP + type;
602 this->GetWidget<NWidgetCore>(WID_D_MATRIX)->tool_tip = STR_DEPOT_TRAIN_LIST_TOOLTIP + this->type;
603
604 switch (type) {
605 default: NOT_REACHED();
606
607 case VEH_TRAIN:
608 this->GetWidget<NWidgetCore>(WID_D_VEHICLE_LIST)->widget_data = STR_TRAIN;
609
610 /* Sprites */
611 this->GetWidget<NWidgetCore>(WID_D_SELL)->widget_data = SPR_SELL_TRAIN;
612 this->GetWidget<NWidgetCore>(WID_D_SELL_ALL)->widget_data = SPR_SELL_ALL_TRAIN;
613 this->GetWidget<NWidgetCore>(WID_D_AUTOREPLACE)->widget_data = SPR_REPLACE_TRAIN;
614 break;
615
616 case VEH_ROAD:
617 this->GetWidget<NWidgetCore>(WID_D_VEHICLE_LIST)->widget_data = STR_LORRY;
618
619 /* Sprites */
620 this->GetWidget<NWidgetCore>(WID_D_SELL)->widget_data = SPR_SELL_ROADVEH;
621 this->GetWidget<NWidgetCore>(WID_D_SELL_ALL)->widget_data = SPR_SELL_ALL_ROADVEH;
622 this->GetWidget<NWidgetCore>(WID_D_AUTOREPLACE)->widget_data = SPR_REPLACE_ROADVEH;
623 break;
624
625 case VEH_SHIP:
626 this->GetWidget<NWidgetCore>(WID_D_VEHICLE_LIST)->widget_data = STR_SHIP;
627
628 /* Sprites */
629 this->GetWidget<NWidgetCore>(WID_D_SELL)->widget_data = SPR_SELL_SHIP;
630 this->GetWidget<NWidgetCore>(WID_D_SELL_ALL)->widget_data = SPR_SELL_ALL_SHIP;
631 this->GetWidget<NWidgetCore>(WID_D_AUTOREPLACE)->widget_data = SPR_REPLACE_SHIP;
632 break;
633
634 case VEH_AIRCRAFT:
635 this->GetWidget<NWidgetCore>(WID_D_VEHICLE_LIST)->widget_data = STR_PLANE;
636
637 /* Sprites */
638 this->GetWidget<NWidgetCore>(WID_D_SELL)->widget_data = SPR_SELL_AIRCRAFT;
639 this->GetWidget<NWidgetCore>(WID_D_SELL_ALL)->widget_data = SPR_SELL_ALL_AIRCRAFT;
640 this->GetWidget<NWidgetCore>(WID_D_AUTOREPLACE)->widget_data = SPR_REPLACE_AIRCRAFT;
641 break;
642 }
643 }
644
645 uint count_width;
646 uint header_width;
647 Dimension flag_size;
648 VehicleCellSize cell_size;
649
650 void OnInit() override
651 {
652 this->cell_size = GetVehicleImageCellSize(this->type, EIT_IN_DEPOT);
653 this->flag_size = maxdim(GetScaledSpriteSize(SPR_FLAG_VEH_STOPPED), GetScaledSpriteSize(SPR_FLAG_VEH_RUNNING));
654 }
655
656 void UpdateWidgetSize(WidgetID widget, Dimension *size, [[maybe_unused]] const Dimension &padding, [[maybe_unused]] Dimension *fill, [[maybe_unused]] Dimension *resize) override
657 {
658 switch (widget) {
659 case WID_D_MATRIX: {
660 uint min_height = 0;
661
662 if (this->type == VEH_TRAIN) {
663 SetDParamMaxValue(0, 1000, 0, FS_SMALL);
664 SetDParam(1, 1);
665 this->count_width = GetStringBoundingBox(STR_JUST_DECIMAL, FS_SMALL).width + WidgetDimensions::scaled.hsep_normal;
666 } else {
667 this->count_width = 0;
668 }
669
670 SetDParamMaxDigits(0, this->unitnumber_digits);
671 Dimension unumber = GetStringBoundingBox(STR_JUST_COMMA);
672
673 if (this->type == VEH_TRAIN || this->type == VEH_ROAD) {
674 min_height = std::max<uint>(unumber.height, this->flag_size.height);
675 this->header_width = unumber.width + WidgetDimensions::scaled.hsep_normal + this->flag_size.width + WidgetDimensions::scaled.hsep_normal;
676 } else {
677 min_height = unumber.height + WidgetDimensions::scaled.vsep_normal + this->flag_size.height;
678 this->header_width = std::max<uint>(unumber.width, this->flag_size.width) + WidgetDimensions::scaled.hsep_normal;
679 }
680 int base_width = this->count_width + this->header_width + padding.width;
681
682 resize->height = std::max<uint>(this->cell_size.height, min_height + padding.height);
683 if (this->type == VEH_TRAIN) {
684 resize->width = 1;
685 size->width = base_width + 2 * ScaleSpriteTrad(29); // about 2 parts
686 size->height = resize->height * 6;
687 } else {
688 resize->width = base_width + this->cell_size.extend_left + this->cell_size.extend_right;
689 size->width = resize->width * (this->type == VEH_ROAD ? 5 : 3);
690 size->height = resize->height * (this->type == VEH_ROAD ? 5 : 3);
691 }
692 fill->width = resize->width;
693 fill->height = resize->height;
694 break;
695 }
696 }
697 }
698
704 void OnInvalidateData([[maybe_unused]] int data = 0, [[maybe_unused]] bool gui_scope = true) override
705 {
706 this->generate_list = true;
707 }
708
709 void OnPaint() override
710 {
711 if (this->generate_list) {
712 /* Generate the vehicle list
713 * It's ok to use the wagon pointers for non-trains as they will be ignored */
714 BuildDepotVehicleList(this->type, this->window_number, &this->vehicle_list, &this->wagon_list);
715 this->generate_list = false;
716 DepotSortList(&this->vehicle_list);
717
718 uint new_unitnumber_digits = GetUnitNumberDigits(this->vehicle_list);
719 /* Only increase the size; do not decrease to prevent constant changes */
720 if (this->unitnumber_digits < new_unitnumber_digits) {
721 this->unitnumber_digits = new_unitnumber_digits;
722 this->ReInit();
723 }
724 }
725
726 /* determine amount of items for scroller */
727 if (this->type == VEH_TRAIN) {
728 uint max_width = ScaleSpriteTrad(VEHICLEINFO_FULL_VEHICLE_WIDTH);
729 for (uint num = 0; num < this->vehicle_list.size(); num++) {
730 uint width = 0;
731 for (const Train *v = Train::From(this->vehicle_list[num]); v != nullptr; v = v->Next()) {
732 width += v->GetDisplayImageWidth();
733 }
734 max_width = std::max(max_width, width);
735 }
736 /* Always have 1 empty row, so people can change the setting of the train */
737 this->vscroll->SetCount(this->vehicle_list.size() + this->wagon_list.size() + 1);
738 /* Always make it longer than the longest train, so you can attach vehicles at the end, and also see the next vertical tile separator line */
739 this->hscroll->SetCount(max_width + ScaleSpriteTrad(2 * VEHICLEINFO_FULL_VEHICLE_WIDTH + 1));
740 } else {
741 this->vscroll->SetCount(CeilDiv((uint)this->vehicle_list.size(), this->num_columns));
742 }
743
744 /* Setup disabled buttons. */
745 TileIndex tile = this->window_number;
746 this->SetWidgetsDisabledState(!IsTileOwner(tile, _local_company),
747 WID_D_STOP_ALL,
748 WID_D_START_ALL,
749 WID_D_SELL,
750 WID_D_SELL_CHAIN,
751 WID_D_SELL_ALL,
752 WID_D_BUILD,
753 WID_D_CLONE,
754 WID_D_RENAME,
755 WID_D_AUTOREPLACE);
756
757 this->DrawWidgets();
758 }
759
760 void OnClick([[maybe_unused]] Point pt, WidgetID widget, [[maybe_unused]] int click_count) override
761 {
762 switch (widget) {
763 case WID_D_MATRIX: // List
764 this->DepotClick(pt.x, pt.y);
765 break;
766
767 case WID_D_BUILD: // Build vehicle
768 ResetObjectToPlace();
769 ShowBuildVehicleWindow(this->window_number, this->type);
770 break;
771
772 case WID_D_CLONE: // Clone button
773 this->SetWidgetDirty(WID_D_CLONE);
774 this->ToggleWidgetLoweredState(WID_D_CLONE);
775
776 if (this->IsWidgetLowered(WID_D_CLONE)) {
777 static const CursorID clone_icons[] = {
778 SPR_CURSOR_CLONE_TRAIN, SPR_CURSOR_CLONE_ROADVEH,
779 SPR_CURSOR_CLONE_SHIP, SPR_CURSOR_CLONE_AIRPLANE
780 };
781
782 SetObjectToPlaceWnd(clone_icons[this->type], PAL_NONE, HT_VEHICLE, this);
783 } else {
784 ResetObjectToPlace();
785 }
786 break;
787
788 case WID_D_LOCATION:
789 if (_ctrl_pressed) {
790 ShowExtraViewportWindow(this->window_number);
791 } else {
792 ScrollMainWindowToTile(this->window_number);
793 }
794 break;
795
796 case WID_D_RENAME: // Rename button
797 SetDParam(0, this->type);
798 SetDParam(1, Depot::GetByTile((TileIndex)this->window_number)->index);
799 ShowQueryString(STR_DEPOT_NAME, STR_DEPOT_RENAME_DEPOT_CAPTION, MAX_LENGTH_DEPOT_NAME_CHARS, this, CS_ALPHANUMERAL, QSF_ENABLE_DEFAULT | QSF_LEN_IN_CHARS);
800 break;
801
802 case WID_D_STOP_ALL:
803 case WID_D_START_ALL: {
804 VehicleListIdentifier vli(VL_DEPOT_LIST, this->type, this->owner);
805 Command<CMD_MASS_START_STOP>::Post(this->window_number, widget == WID_D_START_ALL, false, vli);
806 break;
807 }
808
809 case WID_D_SELL_ALL:
810 /* Only open the confirmation window if there are anything to sell */
811 if (!this->vehicle_list.empty() || !this->wagon_list.empty()) {
812 SetDParam(0, this->type);
813 SetDParam(1, this->GetDepotIndex());
814 ShowQuery(
815 STR_DEPOT_CAPTION,
816 STR_DEPOT_SELL_CONFIRMATION_TEXT,
817 this,
818 DepotSellAllConfirmationCallback
819 );
820 }
821 break;
822
823 case WID_D_VEHICLE_LIST:
824 ShowVehicleListWindow(GetTileOwner(this->window_number), this->type, (TileIndex)this->window_number);
825 break;
826
827 case WID_D_AUTOREPLACE:
828 Command<CMD_DEPOT_MASS_AUTOREPLACE>::Post(this->window_number, this->type);
829 break;
830
831 }
832 }
833
834 void OnQueryTextFinished(char *str) override
835 {
836 if (str == nullptr) return;
837
838 /* Do depot renaming */
839 Command<CMD_RENAME_DEPOT>::Post(STR_ERROR_CAN_T_RENAME_DEPOT, this->GetDepotIndex(), str);
840 }
841
842 bool OnRightClick([[maybe_unused]] Point pt, WidgetID widget) override
843 {
844 if (widget != WID_D_MATRIX) return false;
845
846 GetDepotVehiclePtData gdvp = { nullptr, nullptr };
847 const Vehicle *v = nullptr;
848 DepotGUIAction mode = this->GetVehicleFromDepotWndPt(pt.x, pt.y, &v, &gdvp);
849
850 if (this->type == VEH_TRAIN) v = gdvp.wagon;
851
852 if (v == nullptr || mode != MODE_DRAG_VEHICLE) return false;
853
854 CargoArray capacity{}, loaded{};
855
856 /* Display info for single (articulated) vehicle, or for whole chain starting with selected vehicle */
857 bool whole_chain = (this->type == VEH_TRAIN && _ctrl_pressed);
858
859 /* loop through vehicle chain and collect cargoes */
860 uint num = 0;
861 for (const Vehicle *w = v; w != nullptr; w = w->Next()) {
862 if (w->cargo_cap > 0 && w->cargo_type < NUM_CARGO) {
863 capacity[w->cargo_type] += w->cargo_cap;
864 loaded [w->cargo_type] += w->cargo.StoredCount();
865 }
866
867 if (w->type == VEH_TRAIN && !w->HasArticulatedPart()) {
868 num++;
869 if (!whole_chain) break;
870 }
871 }
872
873 /* Build tooltipstring */
874 static std::string details;
875 details.clear();
876
877 for (const CargoSpec *cs : _sorted_cargo_specs) {
878 CargoID cargo_type = cs->Index();
879 if (capacity[cargo_type] == 0) continue;
880
881 SetDParam(0, cargo_type); // {CARGO} #1
882 SetDParam(1, loaded[cargo_type]); // {CARGO} #2
883 SetDParam(2, cargo_type); // {SHORTCARGO} #1
884 SetDParam(3, capacity[cargo_type]); // {SHORTCARGO} #2
885 details += GetString(STR_DEPOT_VEHICLE_TOOLTIP_CARGO);
886 }
887
888 /* Show tooltip window */
889 SetDParam(0, whole_chain ? num : v->engine_type);
890 SetDParamStr(1, details);
891 GuiShowTooltips(this, whole_chain ? STR_DEPOT_VEHICLE_TOOLTIP_CHAIN : STR_DEPOT_VEHICLE_TOOLTIP, TCC_RIGHT_CLICK, 2);
892
893 return true;
894 }
895
901 bool OnVehicleSelect(const Vehicle *v) override
902 {
903 if (_ctrl_pressed) {
904 /* Share-clone, do not open new viewport, and keep tool active */
905 Command<CMD_CLONE_VEHICLE>::Post(STR_ERROR_CAN_T_BUY_TRAIN + v->type, this->window_number, v->index, true);
906 } else {
907 /* Copy-clone, open viewport for new vehicle, and deselect the tool (assume player wants to change things on new vehicle) */
908 if (Command<CMD_CLONE_VEHICLE>::Post(STR_ERROR_CAN_T_BUY_TRAIN + v->type, CcCloneVehicle, this->window_number, v->index, false)) {
909 ResetObjectToPlace();
910 }
911 }
912
913 return true;
914 }
915
922 bool OnVehicleSelect(VehicleList::const_iterator begin, VehicleList::const_iterator end) override
923 {
924 if (!_ctrl_pressed) {
925 /* If CTRL is not pressed: If all the vehicles in this list have the same orders, then copy orders */
926 if (AllEqual(begin, end, [](const Vehicle *v1, const Vehicle *v2) {
927 return VehiclesHaveSameEngineList(v1, v2);
928 })) {
929 if (AllEqual(begin, end, [](const Vehicle *v1, const Vehicle *v2) {
930 return VehiclesHaveSameOrderList(v1, v2);
931 })) {
932 OnVehicleSelect(*begin);
933 } else {
934 ShowErrorMessage(STR_ERROR_CAN_T_BUY_TRAIN + (*begin)->type, STR_ERROR_CAN_T_COPY_ORDER_VEHICLE_LIST, WL_INFO);
935 }
936 } else {
937 ShowErrorMessage(STR_ERROR_CAN_T_BUY_TRAIN + (*begin)->type, STR_ERROR_CAN_T_CLONE_VEHICLE_LIST, WL_INFO);
938 }
939 } else {
940 /* If CTRL is pressed: If all the vehicles in this list share orders, then copy orders */
941 if (AllEqual(begin, end, [](const Vehicle *v1, const Vehicle *v2) {
942 return VehiclesHaveSameEngineList(v1, v2);
943 })) {
944 if (AllEqual(begin, end, [](const Vehicle *v1, const Vehicle *v2) {
945 return v1->FirstShared() == v2->FirstShared();
946 })) {
947 OnVehicleSelect(*begin);
948 } else {
949 ShowErrorMessage(STR_ERROR_CAN_T_BUY_TRAIN + (*begin)->type, STR_ERROR_CAN_T_SHARE_ORDER_VEHICLE_LIST, WL_INFO);
950 }
951 } else {
952 ShowErrorMessage(STR_ERROR_CAN_T_BUY_TRAIN + (*begin)->type, STR_ERROR_CAN_T_CLONE_VEHICLE_LIST, WL_INFO);
953 }
954 }
955
956 return true;
957 }
958
959 void OnPlaceObjectAbort() override
960 {
961 /* abort clone */
962 this->RaiseWidget(WID_D_CLONE);
963 this->SetWidgetDirty(WID_D_CLONE);
964
965 /* abort drag & drop */
966 this->sel = INVALID_VEHICLE;
967 this->vehicle_over = INVALID_VEHICLE;
968 this->SetWidgetDirty(WID_D_MATRIX);
969
970 if (this->hovered_widget != -1) {
971 this->SetWidgetLoweredState(this->hovered_widget, false);
972 this->SetWidgetDirty(this->hovered_widget);
973 this->hovered_widget = -1;
974 }
975 }
976
977 void OnMouseDrag(Point pt, WidgetID widget) override
978 {
979 if (this->sel == INVALID_VEHICLE) return;
980 if (widget != this->hovered_widget) {
981 if (this->hovered_widget == WID_D_SELL || this->hovered_widget == WID_D_SELL_CHAIN) {
982 this->SetWidgetLoweredState(this->hovered_widget, false);
983 this->SetWidgetDirty(this->hovered_widget);
984 }
985 this->hovered_widget = widget;
986 if (this->hovered_widget == WID_D_SELL || this->hovered_widget == WID_D_SELL_CHAIN) {
987 this->SetWidgetLoweredState(this->hovered_widget, true);
988 this->SetWidgetDirty(this->hovered_widget);
989 }
990 }
991 if (this->type != VEH_TRAIN) return;
992
993 /* A rail vehicle is dragged.. */
994 if (widget != WID_D_MATRIX) { // ..outside of the depot matrix.
995 if (this->vehicle_over != INVALID_VEHICLE) {
996 this->vehicle_over = INVALID_VEHICLE;
997 this->SetWidgetDirty(WID_D_MATRIX);
998 }
999 return;
1000 }
1001
1002 const Vehicle *v = nullptr;
1003 GetDepotVehiclePtData gdvp = {nullptr, nullptr};
1004
1005 if (this->GetVehicleFromDepotWndPt(pt.x, pt.y, &v, &gdvp) != MODE_DRAG_VEHICLE) return;
1006
1007 VehicleID new_vehicle_over = INVALID_VEHICLE;
1008 if (gdvp.head != nullptr) {
1009 if (gdvp.wagon == nullptr && gdvp.head->Last()->index != this->sel) { // ..at the end of the train.
1010 /* NOTE: As a wagon can't be moved at the begin of a train, head index isn't used to mark a drag-and-drop
1011 * destination inside a train. This head index is then used to indicate that a wagon is inserted at
1012 * the end of the train.
1013 */
1014 new_vehicle_over = gdvp.head->index;
1015 } else if (gdvp.wagon != nullptr && gdvp.head != gdvp.wagon &&
1016 gdvp.wagon->index != this->sel &&
1017 gdvp.wagon->Previous()->index != this->sel) { // ..over an existing wagon.
1018 new_vehicle_over = gdvp.wagon->index;
1019 }
1020 }
1021
1022 if (this->vehicle_over == new_vehicle_over) return;
1023
1024 this->vehicle_over = new_vehicle_over;
1025 this->SetWidgetDirty(widget);
1026 }
1027
1028 void OnDragDrop(Point pt, WidgetID widget) override
1029 {
1030 switch (widget) {
1031 case WID_D_MATRIX: {
1032 const Vehicle *v = nullptr;
1033 VehicleID sel = this->sel;
1034
1035 this->sel = INVALID_VEHICLE;
1036 this->SetDirty();
1037
1038 if (this->type == VEH_TRAIN) {
1039 GetDepotVehiclePtData gdvp = { nullptr, nullptr };
1040
1041 if (this->GetVehicleFromDepotWndPt(pt.x, pt.y, &v, &gdvp) == MODE_DRAG_VEHICLE && sel != INVALID_VEHICLE) {
1042 if (gdvp.wagon != nullptr && gdvp.wagon->index == sel && _ctrl_pressed) {
1043 Command<CMD_REVERSE_TRAIN_DIRECTION>::Post(STR_ERROR_CAN_T_REVERSE_DIRECTION_RAIL_VEHICLE, Vehicle::Get(sel)->tile, Vehicle::Get(sel)->index, true);
1044 } else if (gdvp.wagon == nullptr || gdvp.wagon->index != sel) {
1045 this->vehicle_over = INVALID_VEHICLE;
1046 TrainDepotMoveVehicle(gdvp.wagon, sel, gdvp.head);
1047 } else if (gdvp.head != nullptr && gdvp.head->IsFrontEngine()) {
1048 ShowVehicleViewWindow(gdvp.head);
1049 }
1050 }
1051 } else if (this->GetVehicleFromDepotWndPt(pt.x, pt.y, &v, nullptr) == MODE_DRAG_VEHICLE && v != nullptr && sel == v->index) {
1052 ShowVehicleViewWindow(v);
1053 }
1054 break;
1055 }
1056
1057 case WID_D_SELL: case WID_D_SELL_CHAIN: {
1058 if (this->IsWidgetDisabled(widget)) return;
1059 if (this->sel == INVALID_VEHICLE) return;
1060
1061 this->HandleButtonClick(widget);
1062
1063 const Vehicle *v = Vehicle::Get(this->sel);
1064 this->sel = INVALID_VEHICLE;
1065 this->SetDirty();
1066
1067 bool sell_cmd = (v->type == VEH_TRAIN && (widget == WID_D_SELL_CHAIN || _ctrl_pressed));
1068 Command<CMD_SELL_VEHICLE>::Post(GetCmdSellVehMsg(v->type), v->tile, v->index, sell_cmd, true, INVALID_CLIENT_ID);
1069 break;
1070 }
1071
1072 default:
1073 this->sel = INVALID_VEHICLE;
1074 this->SetDirty();
1075 break;
1076 }
1077 this->hovered_widget = -1;
1078 _cursor.vehchain = false;
1079 }
1080
1081 void OnTimeout() override
1082 {
1083 if (!this->IsWidgetDisabled(WID_D_SELL)) {
1084 this->RaiseWidget(WID_D_SELL);
1085 this->SetWidgetDirty(WID_D_SELL);
1086 }
1087 if (this->GetWidget<NWidgetBase>(WID_D_SELL) != nullptr && !this->IsWidgetDisabled(WID_D_SELL_CHAIN)) {
1088 this->RaiseWidget(WID_D_SELL_CHAIN);
1089 this->SetWidgetDirty(WID_D_SELL_CHAIN);
1090 }
1091 }
1092
1093 void OnResize() override
1094 {
1095 this->vscroll->SetCapacityFromWidget(this, WID_D_MATRIX);
1096 NWidgetCore *nwi = this->GetWidget<NWidgetCore>(WID_D_MATRIX);
1097 if (this->type == VEH_TRAIN) {
1098 this->hscroll->SetCapacity(nwi->current_x - this->header_width - this->count_width);
1099 } else {
1100 this->num_columns = nwi->current_x / nwi->resize_x;
1101 }
1102 }
1103
1104 EventState OnCTRLStateChange() override
1105 {
1106 if (this->sel != INVALID_VEHICLE) {
1107 _cursor.vehchain = _ctrl_pressed;
1108 this->SetWidgetDirty(WID_D_MATRIX);
1109 return ES_HANDLED;
1110 }
1111
1112 return ES_NOT_HANDLED;
1113 }
1114
1120 inline uint16_t GetDepotIndex() const
1121 {
1122 return (this->type == VEH_AIRCRAFT) ? ::GetStationIndex(this->window_number) : ::GetDepotIndex(this->window_number);
1123 }
1124 };
1125
1126 static void DepotSellAllConfirmationCallback(Window *win, bool confirmed)
1127 {
1128 if (confirmed) {
1129 DepotWindow *w = (DepotWindow*)win;
1130 TileIndex tile = w->window_number;
1131 VehicleType vehtype = w->type;
1132 Command<CMD_DEPOT_SELL_ALL_VEHICLES>::Post(tile, vehtype);
1133 }
1134 }
1135
1141 void ShowDepotWindow(TileIndex tile, VehicleType type)
1142 {
1143 if (BringWindowToFrontById(WC_VEHICLE_DEPOT, tile) != nullptr) return;
1144
1145 WindowDesc *desc;
1146 switch (type) {
1147 default: NOT_REACHED();
1148 case VEH_TRAIN: desc = &_train_depot_desc; break;
1149 case VEH_ROAD: desc = &_road_depot_desc; break;
1150 case VEH_SHIP: desc = &_ship_depot_desc; break;
1151 case VEH_AIRCRAFT: desc = &_aircraft_depot_desc; break;
1152 }
1153
1154 new DepotWindow(desc, tile, type);
1155 }
1156
1161 void DeleteDepotHighlightOfVehicle(const Vehicle *v)
1162 {
1163 DepotWindow *w;
1164
1165 /* If we haven't got any vehicles on the mouse pointer, we haven't got any highlighted in any depots either
1166 * If that is the case, we can skip looping though the windows and save time
1167 */
1168 if (_special_mouse_mode != WSM_DRAGDROP) return;
1169
1170 w = dynamic_cast<DepotWindow*>(FindWindowById(WC_VEHICLE_DEPOT, v->tile));
1171 if (w != nullptr) {
1172 if (w->sel == v->index) ResetObjectToPlace();
1173 }
1174 }
SZSP_NONE
@ SZSP_NONE
Display plane with zero size in both directions (none filling and resizing).
Definition: widget_type.h:469
VEH_AIRCRAFT
@ VEH_AIRCRAFT
Aircraft vehicle type.
Definition: vehicle_type.h:27
Train::GetDisplayImageWidth
int GetDisplayImageWidth(Point *offset=nullptr) const
Get the width of a train vehicle image in the GUI.
Definition: train_cmd.cpp:460
WID_D_SELL_ALL
@ WID_D_SELL_ALL
Sell all button.
Definition: depot_widget.h:19
ES_HANDLED
@ ES_HANDLED
The passed event is handled.
Definition: window_type.h:739
CcCloneVehicle
void CcCloneVehicle(Commands, const CommandCost &result, VehicleID veh_id)
This is the Callback method after the cloning attempt of a vehicle.
Definition: depot_gui.cpp:123
SetFill
constexpr NWidgetPart SetFill(uint16_t fill_x, uint16_t fill_y)
Widget part function for setting filling.
Definition: widget_type.h:1141
WID_D_BUILD
@ WID_D_BUILD
Build button.
Definition: depot_widget.h:25
DepotWindow::OnTimeout
void OnTimeout() override
Called when this window's timeout has been reached.
Definition: depot_gui.cpp:1081
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:186
VehicleCellSize::height
uint height
Vehicle cell height.
Definition: vehicle_gui.h:84
VehicleList
std::vector< const Vehicle * > VehicleList
A list of vehicles.
Definition: vehiclelist.h:54
Pool::PoolItem<&_vehicle_pool >::Get
static Titem * Get(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:335
ScrollMainWindowToTile
bool ScrollMainWindowToTile(TileIndex tile, bool instant)
Scrolls the viewport of the main window to a given location.
Definition: viewport.cpp:2509
ShowExtraViewportWindow
void ShowExtraViewportWindow(TileIndex tile=INVALID_TILE)
Show a new Extra Viewport window.
Definition: viewport_gui.cpp:156
ShowQuery
void ShowQuery(StringID caption, StringID message, Window *parent, QueryCallbackProc *callback, bool focus)
Show a confirmation window with standard 'yes' and 'no' buttons The window is aligned to the centre o...
Definition: misc_gui.cpp:1227
SetDParamMaxDigits
void SetDParamMaxDigits(size_t n, uint count, FontSize size)
Set DParam n to some number that is suitable for string size computations.
Definition: strings.cpp:143
train.h
Dimension
Dimensions (a width and height) of a rectangle in 2D.
Definition: geometry_type.hpp:30
command_func.h
WidgetDimensions::scaled
static WidgetDimensions scaled
Widget dimensions scaled for current zoom level.
Definition: window_gui.h:68
WWT_STICKYBOX
@ WWT_STICKYBOX
Sticky box (at top-right of a window, after WWT_DEFSIZEBOX)
Definition: widget_type.h:68
ShowErrorMessage
void ShowErrorMessage(StringID summary_msg, int x, int y, CommandCost cc)
Display an error message in a window.
Definition: error_gui.cpp:367
Rect::Shrink
Rect Shrink(int s) const
Copy and shrink Rect by s pixels.
Definition: geometry_type.hpp:98
VehicleListIdentifier
The information about a vehicle list.
Definition: vehiclelist.h:28
_special_mouse_mode
SpecialMouseMode _special_mouse_mode
Mode of the mouse.
Definition: window.cpp:93
Vehicle::Previous
Vehicle * Previous() const
Get the previous vehicle of this vehicle.
Definition: vehicle_base.h:634
_sorted_cargo_specs
std::vector< const CargoSpec * > _sorted_cargo_specs
Cargo specifications sorted alphabetically by name.
Definition: cargotype.cpp:161
_consistent_train_width
static uint _consistent_train_width
Whether trains of all lengths are consistently scaled. Either TRAININFO_DEFAULT_VEHICLE_WIDTH,...
Definition: depot_gui.cpp:152
Vehicle::Next
Vehicle * Next() const
Get the next vehicle of this vehicle.
Definition: vehicle_base.h:627
SpecializedVehicle::Next
T * Next() const
Get next vehicle in the chain.
Definition: vehicle_base.h:1116
DepotWindow::OnInit
void OnInit() override
Notification that the nested widget tree gets initialized.
Definition: depot_gui.cpp:650
NWID_HSCROLLBAR
@ NWID_HSCROLLBAR
Horizontal scrollbar.
Definition: widget_type.h:85
DepotWindow::cell_size
VehicleCellSize cell_size
Vehicle sprite cell size.
Definition: depot_gui.cpp:648
WWT_CAPTION
@ WWT_CAPTION
Window caption (window title between closebox and stickybox)
Definition: widget_type.h:63
CursorVars::vehchain
bool vehchain
vehicle chain is dragged
Definition: gfx_type.h:144
Window::SetWidgetDirty
void SetWidgetDirty(WidgetID widget_index) const
Invalidate a widget, i.e.
Definition: window.cpp:552
WID_D_SHOW_H_SCROLL
@ WID_D_SHOW_H_SCROLL
Show horizontal scrollbar panel.
Definition: depot_widget.h:23
WWT_IMGBTN
@ WWT_IMGBTN
(Toggle) Button with image
Definition: widget_type.h:54
depot_cmd.h
CloseWindowById
void CloseWindowById(WindowClass cls, WindowNumber number, bool force, int data)
Close a window by its class and window number (if it is open).
Definition: window.cpp:1141
vehiclelist.h
Vehicle::vehstatus
byte vehstatus
Status.
Definition: vehicle_base.h:348
WWT_DEFSIZEBOX
@ WWT_DEFSIZEBOX
Default window size box (at top-right of a window, between WWT_SHADEBOX and WWT_STICKYBOX)
Definition: widget_type.h:67
VehiclesHaveSameOrderList
bool VehiclesHaveSameOrderList(const Vehicle *v1, const Vehicle *v2)
Checks if two vehicles have the same list of orders.
Definition: vehicle.cpp:3211
WID_D_SHOW_SELL_CHAIN
@ WID_D_SHOW_SELL_CHAIN
Show sell chain panel.
Definition: depot_widget.h:17
Pool::PoolItem::index
Tindex index
Index of this pool item.
Definition: pool_type.hpp:234
DepotWindow::hscroll
Scrollbar * hscroll
Only for trains.
Definition: depot_gui.cpp:266
NWID_HORIZONTAL
@ NWID_HORIZONTAL
Horizontal container.
Definition: widget_type.h:77
EIT_PURCHASE
@ EIT_PURCHASE
Vehicle drawn in purchase list, autoreplace gui, ...
Definition: vehicle_type.h:90
CargoArray
Class for storing amounts of cargo.
Definition: cargo_type.h:97
maxdim
Dimension maxdim(const Dimension &d1, const Dimension &d2)
Compute bounding box of both dimensions.
Definition: geometry_func.cpp:22
Window::Close
virtual void Close(int data=0)
Hide the window and all its child windows, and mark them for a later deletion.
Definition: window.cpp:1048
WWT_MATRIX
@ WWT_MATRIX
Grid of rows and columns.
Definition: widget_type.h:61
FindWindowById
Window * FindWindowById(WindowClass cls, WindowNumber number)
Find a window by its class and window number.
Definition: window.cpp:1099
ship.h
EndContainer
constexpr NWidgetPart EndContainer()
Widget part function for denoting the end of a container (horizontal, vertical, WWT_FRAME,...
Definition: widget_type.h:1151
_ctrl_pressed
bool _ctrl_pressed
Is Ctrl pressed?
Definition: gfx.cpp:37
zoom_func.h
aircraft.h
Scrollbar::SetCapacityFromWidget
void SetCapacityFromWidget(Window *w, WidgetID widget, int padding=0)
Set capacity of visible elements from the size and resize properties of a widget.
Definition: widget.cpp:2334
GetUnitNumberDigits
uint GetUnitNumberDigits(VehicleList &vehicles)
Get the number of digits the biggest unit number of a set of vehicles has.
Definition: vehicle_gui.cpp:212
TILE_SIZE
static const uint TILE_SIZE
Tile size in world coordinates.
Definition: tile_type.h:15
CeilDiv
constexpr uint CeilDiv(uint a, uint b)
Computes ceil(a / b) for non-negative a and b.
Definition: math_func.hpp:320
CargoSpec
Specification of a cargo type.
Definition: cargotype.h:71
SZSP_HORIZONTAL
@ SZSP_HORIZONTAL
Display plane with zero size vertically, and filling and resizing horizontally.
Definition: widget_type.h:468
VehicleCellSize::extend_right
uint extend_right
Extend of the cell to the right.
Definition: vehicle_gui.h:86
Window::owner
Owner owner
The owner of the content shown in this window. Company colour is acquired from this variable.
Definition: window_gui.h:310
StrongType::Typedef< uint32_t, struct TileIndexTag, StrongType::Compare, StrongType::Integer, StrongType::Compatible< int32_t >, StrongType::Compatible< int64_t > >
DepotWindow
Definition: depot_gui.cpp:256
EngineImageType
EngineImageType
Visualisation contexts of vehicles and engines.
Definition: vehicle_type.h:85
SA_RIGHT
@ SA_RIGHT
Right align the text (must be a single bit).
Definition: gfx_type.h:340
Engine
Definition: engine_base.h:37
VEH_ROAD
@ VEH_ROAD
Road vehicle type.
Definition: vehicle_type.h:25
Vehicle
Vehicle data structure.
Definition: vehicle_base.h:240
ShowDepotWindow
void ShowDepotWindow(TileIndex tile, VehicleType type)
Opens a depot window.
Definition: depot_gui.cpp:1141
Scrollbar
Scrollbar data structure.
Definition: widget_type.h:678
DepotWindow::OnVehicleSelect
bool OnVehicleSelect(VehicleList::const_iterator begin, VehicleList::const_iterator end) override
Clones a vehicle from a vehicle list.
Definition: depot_gui.cpp:922
Window::GetScrollbar
const Scrollbar * GetScrollbar(WidgetID widnum) const
Return the Scrollbar to a widget index.
Definition: window.cpp:315
Vehicle::IsGroundVehicle
debug_inline bool IsGroundVehicle() const
Check if the vehicle is a ground vehicle.
Definition: vehicle_base.h:510
GetShipSpriteSize
void GetShipSpriteSize(EngineID engine, uint &width, uint &height, int &xoffs, int &yoffs, EngineImageType image_type)
Get the size of the sprite of a ship sprite heading west (used for lists).
Definition: ship_cmd.cpp:121
Rect::WithHeight
Rect WithHeight(int height, bool end=false) const
Copy Rect and set its height.
Definition: geometry_type.hpp:211
GetVehicleImageCellSize
VehicleCellSize GetVehicleImageCellSize(VehicleType type, EngineImageType image_type)
Get the GUI cell size for a vehicle image.
Definition: depot_gui.cpp:161
NWidgetPart
Partial widget specification to allow NWidgets to be written nested.
Definition: widget_type.h:1038
WID_D_SELL_CHAIN
@ WID_D_SELL_CHAIN
Sell chain button.
Definition: depot_widget.h:18
Scrollbar::GetPosition
uint16_t GetPosition() const
Gets the position of the first visible element in the list.
Definition: widget_type.h:720
GetVehicleHeight
uint GetVehicleHeight(VehicleType type)
Get the height of a single vehicle in the GUIs.
Definition: vehicle_gui.h:74
MAT_COL_START
@ MAT_COL_START
Lowest bit of the number of columns.
Definition: widget_type.h:23
_colour_gradient
byte _colour_gradient[COLOUR_END][8]
All 16 colour gradients 8 colours per gradient from darkest (0) to lightest (7)
Definition: palette.cpp:26
textbuf_gui.h
WID_D_MATRIX
@ WID_D_MATRIX
Matrix of vehicles.
Definition: depot_widget.h:21
train_cmd.h
QSF_LEN_IN_CHARS
@ QSF_LEN_IN_CHARS
the length of the string is counted in characters
Definition: textbuf_gui.h:22
WindowDesc
High level window description.
Definition: window_gui.h:153
WidgetID
int WidgetID
Widget ID.
Definition: window_type.h:18
ScaleGUITrad
int ScaleGUITrad(int value)
Scale traditional pixel dimensions to GUI zoom level.
Definition: zoom_func.h:117
window_gui.h
DepotWindow::DepotClick
void DepotClick(int x, int y)
Handle click in the depot matrix.
Definition: depot_gui.cpp:540
NC_EQUALSIZE
@ NC_EQUALSIZE
Value of the NCB_EQUALSIZE flag.
Definition: widget_type.h:508
WID_D_STOP_ALL
@ WID_D_STOP_ALL
Stop all button.
Definition: depot_widget.h:31
depot_base.h
SetResize
constexpr NWidgetPart SetResize(int16_t dx, int16_t dy)
Widget part function for setting the resize step.
Definition: widget_type.h:1086
DepotWindow::SetupWidgetData
void SetupWidgetData(VehicleType type)
Function to set up vehicle specific widgets (mainly sprites and strings).
Definition: depot_gui.cpp:589
WDP_AUTO
@ WDP_AUTO
Find a place automatically.
Definition: window_gui.h:141
TimerGameConst< struct Calendar >::DAYS_IN_LEAP_YEAR
static constexpr int DAYS_IN_LEAP_YEAR
sometimes, you need one day more...
Definition: timer_game_common.h:150
Window::resize
ResizeInfo resize
Resize information.
Definition: window_gui.h:308
CommandCost
Common return value for all commands.
Definition: command_type.h:23
WidgetDimensions::matrix
RectPadding matrix
Padding of WWT_MATRIX items.
Definition: window_gui.h:44
tilehighlight_func.h
FS_NORMAL
@ FS_NORMAL
Index of the normal font in the font tables.
Definition: gfx_type.h:203
StartStopVehicle
void StartStopVehicle(const Vehicle *v, bool texteffect)
Executes CMD_START_STOP_VEHICLE for given vehicle.
Definition: vehicle_gui.cpp:2910
Rect::Translate
Rect Translate(int x, int y) const
Copy and translate Rect by x,y pixels.
Definition: geometry_type.hpp:174
SetScrollbar
constexpr NWidgetPart SetScrollbar(WidgetID index)
Attach a scrollbar to a widget.
Definition: widget_type.h:1244
VEH_COMPANY_END
@ VEH_COMPANY_END
Last company-ownable type.
Definition: vehicle_type.h:29
DepotWindow::GetDepotIndex
uint16_t GetDepotIndex() const
Gets the DepotID of the current window.
Definition: depot_gui.cpp:1120
Window::HandleButtonClick
void HandleButtonClick(WidgetID widget)
Do all things to make a button look clicked and mark it to be unclicked in a few ticks.
Definition: window.cpp:591
VehicleClicked
bool VehicleClicked(const Vehicle *v)
Dispatch a "vehicle selected" event if any window waits for it.
Definition: vehicle_gui.cpp:3408
Vehicle::tile
TileIndex tile
Current tile index.
Definition: vehicle_base.h:260
INVALID_VEHICLE
static const VehicleID INVALID_VEHICLE
Constant representing a non-existing vehicle.
Definition: vehicle_type.h:54
_base_block_sizes_purchase
static VehicleCellSize _base_block_sizes_purchase[VEH_COMPANY_END]
Cell size for vehicle images in the purchase list.
Definition: depot_gui.cpp:151
Window::SetDirty
void SetDirty() const
Mark entire window as dirty (in need of re-paint)
Definition: window.cpp:941
Vehicle::engine_type
EngineID engine_type
The type of engine used for this vehicle.
Definition: vehicle_base.h:318
FS_SMALL
@ FS_SMALL
Index of the small font in the font tables.
Definition: gfx_type.h:204
ES_NOT_HANDLED
@ ES_NOT_HANDLED
The passed event is not handled.
Definition: window_type.h:740
CommandCost::Failed
bool Failed() const
Did this command fail?
Definition: command_type.h:171
WWT_PUSHTXTBTN
@ WWT_PUSHTXTBTN
Normal push-button (no toggle button) with text caption.
Definition: widget_type.h:110
DepotWindow::OnCTRLStateChange
EventState OnCTRLStateChange() override
The state of the control key has changed.
Definition: depot_gui.cpp:1104
GroundVehicle::gcache
GroundVehicleCache gcache
Cache of often calculated values.
Definition: ground_vehicle.hpp:80
DepotWindow::OnInvalidateData
void OnInvalidateData([[maybe_unused]] int data=0, [[maybe_unused]] bool gui_scope=true) override
Some data on this window has become invalid.
Definition: depot_gui.cpp:704
IsCompanyBuildableVehicleType
bool IsCompanyBuildableVehicleType(VehicleType type)
Is the given vehicle type buildable by a company?
Definition: vehicle_func.h:89
Window::ReInit
void ReInit(int rx=0, int ry=0, bool reposition=false)
Re-initialize a window, and optionally change its size.
Definition: window.cpp:953
VS_STOPPED
@ VS_STOPPED
Vehicle is stopped by the player.
Definition: vehicle_base.h:34
WL_INFO
@ WL_INFO
Used for DoCommand-like (and some non-fatal AI GUI) errors/information.
Definition: error.h:24
NWidget
constexpr NWidgetPart NWidget(WidgetType tp, Colours col, WidgetID idx=-1)
Widget part function for starting a new 'real' widget.
Definition: widget_type.h:1258
_local_company
CompanyID _local_company
Company controlled by the human player at this client. Can also be COMPANY_SPECTATOR.
Definition: company_cmd.cpp:49
WID_D_AUTOREPLACE
@ WID_D_AUTOREPLACE
Autoreplace button.
Definition: depot_widget.h:20
BuildDepotVehicleList
void BuildDepotVehicleList(VehicleType type, TileIndex tile, VehicleList *engines, VehicleList *wagons, bool individual_wagons)
Generate a list of vehicles inside a depot.
Definition: vehiclelist.cpp:70
safeguards.h
DepotWindow::hovered_widget
WidgetID hovered_widget
Index of the widget being hovered during drag/drop. -1 if no drag is in progress.
Definition: depot_gui.cpp:261
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:1083
WID_D_V_SCROLL
@ WID_D_V_SCROLL
Vertical scrollbar.
Definition: depot_widget.h:22
VehiclesHaveSameEngineList
bool VehiclesHaveSameEngineList(const Vehicle *v1, const Vehicle *v2)
Checks if two vehicle chains have the same list of engines.
Definition: vehicle.cpp:3194
Train
'Train' is either a loco or a wagon.
Definition: train.h:89
vehicle_cmd.h
Rect::Indent
Rect Indent(int indent, bool end) const
Copy Rect and indent it from its position.
Definition: geometry_type.hpp:198
CursorID
uint32_t CursorID
The number of the cursor (sprite)
Definition: gfx_type.h:19
_nested_train_depot_widgets
static constexpr NWidgetPart _nested_train_depot_widgets[]
Nested widget definition for train depots.
Definition: depot_gui.cpp:49
SetMouseCursorVehicle
void SetMouseCursorVehicle(const Vehicle *v, EngineImageType image_type)
Set the mouse cursor to look like a vehicle.
Definition: vehicle_gui.cpp:3516
WID_D_START_ALL
@ WID_D_START_ALL
Start all button.
Definition: depot_widget.h:32
Rect::WithWidth
Rect WithWidth(int width, bool end) const
Copy Rect and set its width.
Definition: geometry_type.hpp:185
GetTileOwner
Owner GetTileOwner(Tile tile)
Returns the owner of a tile.
Definition: tile_map.h:178
VehicleID
uint32_t VehicleID
The type all our vehicle IDs have.
Definition: vehicle_type.h:16
Point
Coordinates of a point in 2D.
Definition: geometry_type.hpp:21
error.h
Window::IsWidgetDisabled
bool IsWidgetDisabled(WidgetID widget_index) const
Gets the enabled/disabled status of a widget.
Definition: window_gui.h:410
Scrollbar::SetCapacity
void SetCapacity(size_t capacity)
Set the capacity of visible elements.
Definition: widget_type.h:774
WSM_DRAGDROP
@ WSM_DRAGDROP
Drag&drop an object.
Definition: window_gui.h:1034
DrawRoadVehImage
void DrawRoadVehImage(const Vehicle *v, const Rect &r, VehicleID selection, EngineImageType image_type, int skip)
Draws an image of a road vehicle chain.
Definition: roadveh_gui.cpp:122
stdafx.h
Window::window_number
WindowNumber window_number
Window number within the window class.
Definition: window_gui.h:296
VehicleType
VehicleType
Available vehicle types.
Definition: vehicle_type.h:21
DepotWindow::OnPlaceObjectAbort
void OnPlaceObjectAbort() override
The user cancelled a tile highlight mode that has been set.
Definition: depot_gui.cpp:959
ResizeInfo::step_height
uint step_height
Step-size of height resize changes.
Definition: window_gui.h:208
OrderBackup::Reset
static void Reset(TileIndex tile=INVALID_TILE, bool from_gui=true)
Reset the OrderBackups from GUI/game logic.
Definition: order_backup.cpp:187
CS_ALPHANUMERAL
@ CS_ALPHANUMERAL
Both numeric and alphabetic and spaces and stuff.
Definition: string_type.h:25
viewport_func.h
NWidgetBase::current_y
uint current_y
Current vertical size (after resizing).
Definition: widget_type.h:234
WC_NONE
@ WC_NONE
No window, redirects to WC_MAIN_WINDOW.
Definition: window_type.h:45
Window::SetWidgetLoweredState
void SetWidgetLoweredState(WidgetID widget_index, bool lowered_stat)
Sets the lowered/raised status of a widget.
Definition: window_gui.h:441
EIT_IN_DEPOT
@ EIT_IN_DEPOT
Vehicle drawn in depot.
Definition: vehicle_type.h:87
NWID_VERTICAL
@ NWID_VERTICAL
Vertical container.
Definition: widget_type.h:79
HT_VEHICLE
@ HT_VEHICLE
vehicle is accepted as target as well (bitmask)
Definition: tilehighlight_type.h:27
HT_DRAG
@ HT_DRAG
dragging items in the depot windows
Definition: tilehighlight_type.h:24
WID_D_CLONE
@ WID_D_CLONE
Clone button.
Definition: depot_widget.h:26
WWT_CLOSEBOX
@ WWT_CLOSEBOX
Close box (at top-left of a window)
Definition: widget_type.h:71
WWT_RESIZEBOX
@ WWT_RESIZEBOX
Resize box (normally at bottom-right of a window)
Definition: widget_type.h:70
WID_D_SELL
@ WID_D_SELL
Sell button.
Definition: depot_widget.h:16
spritecache.h
Vehicle::FirstShared
Vehicle * FirstShared() const
Get the first vehicle of this vehicle chain.
Definition: vehicle_base.h:721
Window::IsWidgetLowered
bool IsWidgetLowered(WidgetID widget_index) const
Gets the lowered state of a widget.
Definition: window_gui.h:491
WWT_PUSHIMGBTN
@ WWT_PUSHIMGBTN
Normal push-button (no toggle button) with image caption.
Definition: widget_type.h:111
GuiShowTooltips
void GuiShowTooltips(Window *parent, StringID str, TooltipCloseCondition close_tooltip, uint paramcount)
Shows a tooltip.
Definition: misc_gui.cpp:754
vehicle_func.h
DepotWindow::GetDepotVehiclePtData
Definition: depot_gui.cpp:432
Window::CreateNestedTree
void CreateNestedTree()
Perform the first part of the initialization of a nested widget tree.
Definition: window.cpp:1724
strings_func.h
NWID_VSCROLLBAR
@ NWID_VSCROLLBAR
Vertical scrollbar.
Definition: widget_type.h:86
GetAircraftSpriteSize
void GetAircraftSpriteSize(EngineID engine, uint &width, uint &height, int &xoffs, int &yoffs, EngineImageType image_type)
Get the size of the sprite of an aircraft sprite heading west (used for lists).
Definition: aircraft_cmd.cpp:249
ResizeInfo::step_width
uint step_width
Step-size of width resize changes.
Definition: window_gui.h:207
Vehicle::max_age
TimerGameCalendar::Date max_age
Maximum age.
Definition: vehicle_base.h:289
NWidgetBase::pos_x
int pos_x
Horizontal position of top-left corner of the widget in the window.
Definition: widget_type.h:236
depot_widget.h
WC_BUILD_VEHICLE
@ WC_BUILD_VEHICLE
Build vehicle; Window numbers:
Definition: window_type.h:383
MAX_LENGTH_DEPOT_NAME_CHARS
static const uint MAX_LENGTH_DEPOT_NAME_CHARS
The maximum length of a depot name in characters including '\0'.
Definition: depot_type.h:18
SetDParamMaxValue
void SetDParamMaxValue(size_t n, uint64_t max_value, uint min_count, FontSize size)
Set DParam n to some number that is suitable for string size computations.
Definition: strings.cpp:127
SpecializedVehicle< Train, Type >::From
static Train * From(Vehicle *v)
Converts a Vehicle to SpecializedVehicle with type checking.
Definition: vehicle_base.h:1201
DepotWindow::OnResize
void OnResize() override
Called after the window got resized.
Definition: depot_gui.cpp:1093
GetTrainSpriteSize
void GetTrainSpriteSize(EngineID engine, uint &width, uint &height, int &xoffs, int &yoffs, EngineImageType image_type)
Get the size of the sprite of a train sprite heading west, or both heads (used for lists).
Definition: train_cmd.cpp:581
SetDParam
void SetDParam(size_t n, uint64_t v)
Set a string parameter v at index n in the global string parameter array.
Definition: strings.cpp:104
GetStationIndex
StationID GetStationIndex(Tile t)
Get StationID from a tile.
Definition: station_map.h:28
geometry_func.hpp
GetRoadVehSpriteSize
void GetRoadVehSpriteSize(EngineID engine, uint &width, uint &height, int &xoffs, int &yoffs, EngineImageType image_type)
Get the size of the sprite of a road vehicle sprite heading west (used for lists).
Definition: roadveh_cmd.cpp:172
DepotWindow::header_width
uint header_width
Width of unit number and flag, including separator.
Definition: depot_gui.cpp:646
WidgetDimensions::vsep_normal
int vsep_normal
Normal vertical spacing.
Definition: window_gui.h:60
NWidgetBase::resize_y
uint resize_y
Vertical resize step (0 means not resizable).
Definition: widget_type.h:226
WC_VEHICLE_DEPOT
@ WC_VEHICLE_DEPOT
Depot view; Window numbers:
Definition: window_type.h:351
WID_D_CAPTION
@ WID_D_CAPTION
Caption of window.
Definition: depot_widget.h:15
ScaleSpriteTrad
int ScaleSpriteTrad(int value)
Scale traditional pixel dimensions to GUI zoom level, for drawing sprites.
Definition: zoom_func.h:107
Scrollbar::SetCount
void SetCount(size_t num)
Sets the number of elements in the list.
Definition: widget_type.h:760
GetString
std::string GetString(StringID string)
Resolve the given StringID into a std::string with all the associated DParam lookups and formatting.
Definition: strings.cpp:327
Vehicle::age
TimerGameCalendar::Date age
Age in days.
Definition: vehicle_base.h:288
_base_block_sizes_depot
static VehicleCellSize _base_block_sizes_depot[VEH_COMPANY_END]
Cell size for vehicle images in the depot view.
Definition: depot_gui.cpp:150
EventState
EventState
State of handling an event.
Definition: window_type.h:738
InitDepotWindowBlockSizes
void InitDepotWindowBlockSizes()
Set the size of the blocks in the window so we can be sure that they are big enough for the vehicle s...
Definition: depot_gui.cpp:218
NWidgetCore::colour
Colours colour
Colour of this widget.
Definition: widget_type.h:377
SetDParamStr
void SetDParamStr(size_t n, const char *str)
This function is used to "bind" a C string to a OpenTTD dparam slot.
Definition: strings.cpp:352
Window::FinishInitNested
void FinishInitNested(WindowNumber window_number=0)
Perform the second part of the initialization of a nested widget tree.
Definition: window.cpp:1734
INVALID_CLIENT_ID
@ INVALID_CLIENT_ID
Client is not part of anything.
Definition: network_type.h:50
Vehicle::unitnumber
UnitID unitnumber
unit number, for display purposes only
Definition: vehicle_base.h:321
company_func.h
VehicleCellSize
Dimensions of a cell in the purchase/depot windows.
Definition: vehicle_gui.h:83
DepotWindow::count_width
uint count_width
Width of length count, including separator.
Definition: depot_gui.cpp:645
Vehicle::Last
Vehicle * Last()
Get the last vehicle of this vehicle chain.
Definition: vehicle_base.h:646
Window::RaiseWidget
void RaiseWidget(WidgetID widget_index)
Marks a widget as raised.
Definition: window_gui.h:469
CommandHelper
Definition: command_func.h:93
ShowVehicleViewWindow
void ShowVehicleViewWindow(const Vehicle *v)
Shows the vehicle view window of the given vehicle.
Definition: vehicle_gui.cpp:3398
WID_D_RENAME
@ WID_D_RENAME
Rename button.
Definition: depot_widget.h:29
SA_CENTER
@ SA_CENTER
Center both horizontally and vertically.
Definition: gfx_type.h:348
DrawShipImage
void DrawShipImage(const Vehicle *v, const Rect &r, VehicleID selection, EngineImageType image_type)
Draws an image of a ship.
Definition: ship_gui.cpp:30
GetCharacterHeight
int GetCharacterHeight(FontSize size)
Get height of a character for a given font size.
Definition: fontcache.cpp:78
Window::width
int width
width of the window (number of pixels to the right in x direction)
Definition: window_gui.h:305
SetMinimalSize
constexpr NWidgetPart SetMinimalSize(int16_t x, int16_t y)
Widget part function for setting the minimal size.
Definition: widget_type.h:1097
WID_D_VEHICLE_LIST
@ WID_D_VEHICLE_LIST
List of vehicles.
Definition: depot_widget.h:30
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:237
DrawString
int DrawString(int left, int right, int top, std::string_view str, TextColour colour, StringAlignment align, bool underline, FontSize fontsize)
Draw string, possibly truncated to make it fit in its allocated space.
Definition: gfx.cpp:658
SetObjectToPlaceWnd
void SetObjectToPlaceWnd(CursorID icon, PaletteID pal, HighLightStyle mode, Window *w)
Change the cursor and mouse click/drag handling to a mode for performing special operations like tile...
Definition: viewport.cpp:3420
DepotWindow::OnVehicleSelect
bool OnVehicleSelect(const Vehicle *v) override
Clones a vehicle.
Definition: depot_gui.cpp:901
gui.h
SPR_CURSOR_MOUSE
static const CursorID SPR_CURSOR_MOUSE
Cursor sprite numbers.
Definition: sprites.h:1382
EngineID
uint16_t EngineID
Unique identification number of an engine.
Definition: engine_type.h:21
Window
Data structure for an opened window.
Definition: window_gui.h:267
Commands
Commands
List of commands.
Definition: command_type.h:187
GroundVehicle::IsFreeWagon
bool IsFreeWagon() const
Check if the vehicle is a free wagon (got no engine in front of it).
Definition: ground_vehicle.hpp:309
VEH_TRAIN
@ VEH_TRAIN
Train vehicle type.
Definition: vehicle_type.h:24
DrawAircraftImage
void DrawAircraftImage(const Vehicle *v, const Rect &r, VehicleID selection, EngineImageType image_type)
Draws an image of an aircraft.
Definition: aircraft_gui.cpp:79
BaseVehicle::type
VehicleType type
Type of vehicle.
Definition: vehicle_type.h:51
Window::DrawWidgets
void DrawWidgets() const
Paint all widgets of a window.
Definition: widget.cpp:731
Clamp
constexpr T Clamp(const T a, const T min, const T max)
Clamp a value between an interval.
Definition: math_func.hpp:79
AllEqual
bool AllEqual(It begin, It end, Pred pred)
Generic helper function that checks if all elements of the range are equal with respect to the given ...
Definition: window_gui.h:933
NUM_CARGO
static const CargoID NUM_CARGO
Maximum number of cargo types in a game.
Definition: cargo_type.h:68
WID_D_SHOW_RENAME
@ WID_D_SHOW_RENAME
Show rename panel.
Definition: depot_widget.h:28
SetDataTip
constexpr NWidgetPart SetDataTip(uint32_t data, StringID tip)
Widget part function for setting the data and tooltip.
Definition: widget_type.h:1162
NWID_SELECTION
@ NWID_SELECTION
Stacked widgets, only one visible at a time (eg in a panel with tabs).
Definition: widget_type.h:82
order_backup.h
GetScaledSpriteSize
Dimension GetScaledSpriteSize(SpriteID sprid)
Scale sprite size for GUI.
Definition: widget.cpp:54
NWidgetCore
Base class for a 'real' widget.
Definition: widget_type.h:356
DeleteDepotHighlightOfVehicle
void DeleteDepotHighlightOfVehicle(const Vehicle *v)
Removes the highlight of a vehicle in a depot window.
Definition: depot_gui.cpp:1161
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:75
Window::ToggleWidgetLoweredState
void ToggleWidgetLoweredState(WidgetID widget_index)
Invert the lowered/raised status of a widget.
Definition: window_gui.h:450
BringWindowToFrontById
Window * BringWindowToFrontById(WindowClass cls, WindowNumber number)
Find a window and make it the relative top-window on the screen.
Definition: window.cpp:1224
NWidgetBase::resize_x
uint resize_x
Horizontal resize step (0 means not resizable).
Definition: widget_type.h:225
IsTileOwner
bool IsTileOwner(Tile tile, Owner owner)
Checks if a tile belongs to the given owner.
Definition: tile_map.h:214
Window::SetWidgetsDisabledState
void SetWidgetsDisabledState(bool disab_stat, Args... widgets)
Sets the enabled/disabled status of a list of widgets.
Definition: window_gui.h:515
Sprite
Data structure describing a sprite.
Definition: spritecache.h:17
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:233
GroundVehicleCache::cached_total_length
uint16_t cached_total_length
Length of the whole vehicle (valid only for the first engine).
Definition: ground_vehicle.hpp:42
WidgetDimensions::hsep_normal
int hsep_normal
Normal horizontal spacing.
Definition: window_gui.h:63
ResetObjectToPlace
void ResetObjectToPlace()
Reset the cursor and mouse mode handling back to default (normal cursor, only clicking in windows).
Definition: viewport.cpp:3483
DepotWindow::OnPaint
void OnPaint() override
The window must be repainted.
Definition: depot_gui.cpp:709
WID_D_H_SCROLL
@ WID_D_H_SCROLL
Horizontal scrollbar.
Definition: depot_widget.h:24
WID_D_LOCATION
@ WID_D_LOCATION
Location button.
Definition: depot_widget.h:27
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:56
DepotWindow::DrawVehicleInDepot
void DrawVehicleInDepot(const Vehicle *v, const Rect &r) const
Draw a vehicle in the depot window in the box with the top left corner at x,y.
Definition: depot_gui.cpp:310
SpecializedVehicle::GetFirstEnginePart
T * GetFirstEnginePart()
Get the first part of an articulated engine.
Definition: vehicle_base.h:1142
DepotWindow::num_columns
uint num_columns
Number of columns.
Definition: depot_gui.cpp:265
GetStringBoundingBox
Dimension GetStringBoundingBox(std::string_view str, FontSize start_fontsize)
Return the string dimension in pixels.
Definition: gfx.cpp:852
VehicleCellSize::extend_left
uint extend_left
Extend of the cell to the left.
Definition: vehicle_gui.h:85
DepotWindow::flag_size
Dimension flag_size
Size of start/stop flag.
Definition: depot_gui.cpp:647
WWT_TEXTBTN
@ WWT_TEXTBTN
(Toggle) Button with text
Definition: widget_type.h:57
GetWindowClassForVehicleType
WindowClass GetWindowClassForVehicleType(VehicleType vt)
Get WindowClass for vehicle list of given vehicle type.
Definition: vehicle_gui.h:97
DrawTrainImage
void DrawTrainImage(const Train *v, const Rect &r, VehicleID selection, EngineImageType image_type, int skip, VehicleID drag_dest)
Draws an image of a whole train.
Definition: train_gui.cpp:93
DepotWindow::vehicle_over
VehicleID vehicle_over
Rail vehicle over which another one is dragged, INVALID_VEHICLE if none.
Definition: depot_gui.cpp:258
roadveh.h
WWT_SHADEBOX
@ WWT_SHADEBOX
Shade box (at top-right of a window, between WWT_DEBUGBOX and WWT_DEFSIZEBOX)
Definition: widget_type.h:66