OpenTTD Source 20261112-master-gbcbec5e63f
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 <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
6 */
7
9
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_type.h"
21#include "strings_func.h"
22#include "sound_func.h"
23#include "vehicle_func.h"
24#include "vehicle_gui.h"
25#include "company_func.h"
26#include "tilehighlight_func.h"
27#include "window_gui.h"
28#include "vehiclelist.h"
29#include "vehicle_func.h"
30#include "order_backup.h"
31#include "zoom_func.h"
32#include "error.h"
33#include "depot_cmd.h"
34#include "train_cmd.h"
35#include "vehicle_cmd.h"
37
39
40#include "table/strings.h"
41
42#include "safeguards.h"
43
44/*
45 * Since all depot window sizes aren't the same, we need to modify sizes a little.
46 * 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.
47 * How long they should be moved and for what window types are controlled in ShowDepotWindow()
48 */
49
51static constexpr std::initializer_list<NWidgetPart> _nested_train_depot_widgets = {
54 NWidget(NWID_SELECTION, Colours::Invalid, WID_D_SHOW_RENAME), SetAspect(WidgetDimensions::ASPECT_RENAME), // rename button
55 NWidget(WWT_PUSHIMGBTN, Colours::Grey, WID_D_RENAME), SetAspect(WidgetDimensions::ASPECT_RENAME), SetSpriteTip(SPR_RENAME, STR_DEPOT_RENAME_TOOLTIP),
58 NWidget(WWT_PUSHIMGBTN, Colours::Grey, WID_D_LOCATION), SetAspect(WidgetDimensions::ASPECT_LOCATION), SetSpriteTip(SPR_GOTO_LOCATION),
73 NWidget(WWT_IMGBTN, Colours::Grey, WID_D_SELL_CHAIN), SetSpriteTip(SPR_SELL_CHAIN_TRAIN, STR_DEPOT_DRAG_WHOLE_TRAIN_TO_SELL_TOOLTIP), SetResize(0, 1), SetFill(0, 1),
83 NWidget(WWT_PUSHTXTBTN, Colours::Grey, WID_D_VEHICLE_LIST), SetAspect(WidgetDimensions::ASPECT_VEHICLE_ICON), SetFill(0, 1),
84 NWidget(WWT_PUSHIMGBTN, Colours::Grey, WID_D_STOP_ALL), SetSpriteTip(SPR_FLAG_VEH_STOPPED), SetAspect(WidgetDimensions::ASPECT_VEHICLE_FLAG), SetFill(0, 1),
88};
89
92 WindowPosition::Automatic, "depot_train", 362, 123,
93 WindowClass::VehicleDepot, WindowClass::None,
94 {},
96);
97
100 WindowPosition::Automatic, "depot_roadveh", 316, 97,
101 WindowClass::VehicleDepot, WindowClass::None,
102 {},
104);
105
108 WindowPosition::Automatic, "depot_ship", 306, 99,
109 WindowClass::VehicleDepot, WindowClass::None,
110 {},
112);
113
116 WindowPosition::Automatic, "depot_aircraft", 332, 99,
117 WindowClass::VehicleDepot, WindowClass::None,
118 {},
120);
121
122extern void DepotSortList(VehicleList *list);
123
129void CcCloneVehicle(Commands, const CommandCost &result, VehicleID veh_id)
130{
131 if (result.Failed()) return;
132
133 const Vehicle *v = Vehicle::Get(veh_id);
134
136}
137
138static void TrainDepotMoveVehicle(const Vehicle *wagon, VehicleID sel, const Vehicle *head)
139{
140 const Vehicle *v = Vehicle::Get(sel);
141
142 if (v == wagon) return;
143
144 if (wagon == nullptr) {
145 if (head != nullptr) wagon = head->Last();
146 } else {
147 wagon = wagon->Previous();
148 if (wagon == nullptr) return;
149 }
150
151 if (wagon == v) return;
152
153 Command<Commands::MoveRailVehicle>::Post(STR_ERROR_CAN_T_MOVE_VEHICLE, v->tile, v->index, wagon == nullptr ? VehicleID::Invalid() : wagon->index, IsCtrlPressed());
154}
155
159
168{
169 switch (image_type) {
172 default: NOT_REACHED();
173 }
174}
175
176static void InitBlocksizeForVehicles(VehicleType type, EngineImageType image_type)
177{
178 int max_extend_left = 0;
179 int max_extend_right = 0;
180 uint height = 0;
181
182 for (const Engine *e : Engine::IterateType(type)) {
183 if (!e->IsEnabled()) continue;
184
185 EngineID eid = e->index;
186 uint x, y;
187 int x_offs, y_offs;
188
189 switch (type) {
190 default: NOT_REACHED();
191 case VehicleType::Train: GetTrainSpriteSize(eid, x, y, x_offs, y_offs, image_type); break;
192 case VehicleType::Road: GetRoadVehSpriteSize(eid, x, y, x_offs, y_offs, image_type); break;
193 case VehicleType::Ship: GetShipSpriteSize(eid, x, y, x_offs, y_offs, image_type); break;
194 case VehicleType::Aircraft: GetAircraftSpriteSize(eid, x, y, x_offs, y_offs, image_type); break;
195 }
196 if (y > height) height = y;
197 if (-x_offs > max_extend_left) max_extend_left = -x_offs;
198 if ((int)x + x_offs > max_extend_right) max_extend_right = x + x_offs;
199 }
200
201 int min_extend = ScaleSpriteTrad(16);
202 int max_extend = ScaleSpriteTrad(98);
203
204 /* Limit sprite height to limits based on original design height to prevent window size running away. */
205 int min_height = ScaleSpriteTrad(GetVehicleHeight(type));
206 int max_height = min_height + min_height / 2;
207
208 switch (image_type) {
210 _base_block_sizes_depot[type].height = Clamp(height, min_height, max_height);
211 _base_block_sizes_depot[type].extend_left = Clamp(max_extend_left, min_extend, max_extend);
212 _base_block_sizes_depot[type].extend_right = Clamp(max_extend_right, min_extend, max_extend);
213 break;
215 _base_block_sizes_purchase[type].height = Clamp(height, min_height, max_height);
216 _base_block_sizes_purchase[type].extend_left = Clamp(max_extend_left, min_extend, max_extend);
217 _base_block_sizes_purchase[type].extend_right = Clamp(max_extend_right, min_extend, max_extend);
218 break;
219
220 default: NOT_REACHED();
221 }
222}
223
229{
231 InitBlocksizeForVehicles(vt, EngineImageType::InDepot);
232 InitBlocksizeForVehicles(vt, EngineImageType::Purchase);
233 }
234
235 _consistent_train_width = TRAININFO_DEFAULT_VEHICLE_WIDTH;
236 bool first = true;
238 if (!e->IsEnabled()) continue;
239
240 uint w = TRAININFO_DEFAULT_VEHICLE_WIDTH;
241 if (e->GetGRF() != nullptr && IsCustomVehicleSpriteNum(e->VehInfo<RailVehicleInfo>().image_index)) {
242 w = e->GetGRF()->traininfo_vehicle_width;
243 if (w != VEHICLEINFO_FULL_VEHICLE_WIDTH) {
244 /* Hopeless.
245 * This is a NewGRF vehicle that uses TRAININFO_DEFAULT_VEHICLE_WIDTH.
246 * If the vehicles are shorter than 8/8 we have fractional lengths, which are not consistent after rounding.
247 */
249 break;
250 }
251 }
252
253 if (first) {
255 first = false;
256 } else if (w != _consistent_train_width) {
258 break;
259 }
260 }
261}
262
263static void DepotSellAllConfirmationCallback(Window *w, bool confirmed);
264const Sprite *GetAircraftSprite(EngineID engine);
265
266struct DepotWindow : Window {
267 VehicleID sel = VehicleID::Invalid();
268 VehicleID vehicle_over = VehicleID::Invalid();
270 bool generate_list = true;
271 bool check_unitnumber_digits = true;
273 VehicleList vehicle_list{};
274 VehicleList wagon_list{};
275 uint unitnumber_digits = 2;
276 uint num_columns = 1;
277 Scrollbar *hscroll = nullptr;
278 Scrollbar *vscroll = nullptr;
279 uint count_width = 0;
280 uint header_width = 0;
283 bool last_overlay_state = false;
284
285 DepotWindow(WindowDesc &desc, TileIndex tile, VehicleType type) : Window(desc)
286 {
287 assert(IsCompanyBuildableVehicleType(type)); // ensure that we make the call with a valid type
288
289 this->type = type;
290
291 this->CreateNestedTree();
292 this->hscroll = (this->type == VehicleType::Train ? this->GetScrollbar(WID_D_H_SCROLL) : nullptr);
293 this->vscroll = this->GetScrollbar(WID_D_V_SCROLL);
294 /* Don't show 'rename button' of aircraft hangar */
295 this->GetWidget<NWidgetStacked>(WID_D_SHOW_RENAME)->SetDisplayedPlane(type == VehicleType::Aircraft ? SZSP_NONE : 0);
296 /* Only train depots have a horizontal scrollbar and a 'sell chain' button */
297 if (type == VehicleType::Train) this->GetWidget<NWidgetCore>(WID_D_MATRIX)->SetMatrixDimension(1, 0 /* auto-scale */);
299 this->GetWidget<NWidgetStacked>(WID_D_SHOW_SELL_CHAIN)->SetDisplayedPlane(type == VehicleType::Train ? 0 : SZSP_NONE);
300 this->SetupWidgetData(type);
301 this->FinishInitNested(tile);
302
303 this->owner = GetTileOwner(tile);
305 }
306
307 void Close([[maybe_unused]] int data = 0) override
308 {
309 CloseWindowById(WindowClass::BuildVehicle, this->window_number);
310 CloseWindowById(GetWindowClassForVehicleType(this->type), VehicleListIdentifier(VehicleListType::Depot, this->type, this->owner, this->GetDestinationIndex()).ToWindowNumber(), false);
312 this->Window::Close();
313 }
314
321 uint CountDraggedLength(const Train *t) const
322 {
323 /* Nothing is selected to add. */
324 if (this->sel == VehicleID::Invalid()) return 0;
325
326 /* Test if the dragged selection applies to this train. */
327 bool add_dragged = false;
328 for (const Train *u = t; u != nullptr; u = u->Next()) {
329 if (u->index == this->sel) return 0; // Selection is part of this train, so doesn't increase its length.
330 if (u->index == this->vehicle_over) add_dragged = true;
331 }
332
333 if (!add_dragged) return 0;
334
335 /* Sum the length of the dragged selection. */
336 uint length = 0;
337 for (Train *u = Train::Get(this->sel); u != nullptr; u = _cursor.vehchain ? u->Next() : (u->HasArticulatedPart() ? u->GetNextArticulatedPart() : nullptr)) {
338 length += u->gcache.cached_veh_length;
339 }
340
341 return length;
342 }
343
349 void DrawVehicleInDepot(const Vehicle *v, const Rect &r) const
350 {
351 bool free_wagon = false;
352
353 bool rtl = _current_text_dir == TD_RTL;
354 Rect text = r.Shrink(RectPadding::zero, WidgetDimensions::scaled.matrix); /* Ract for text elements, horizontal is already applied. */
355 Rect image = r.Indent(this->header_width, rtl).Indent(this->count_width, !rtl); /* Rect for vehicle images */
356
357 switch (v->type) {
358 case VehicleType::Train: {
359 const Train *u = Train::From(v);
360 free_wagon = u->IsFreeWagon();
361
362 uint x_space = free_wagon ?
363 ScaleSpriteTrad(_consistent_train_width != 0 ? _consistent_train_width : TRAININFO_DEFAULT_VEHICLE_WIDTH) :
364 0;
365
366 DrawTrainImage(u, image.Indent(x_space, rtl), this->sel, EngineImageType::InDepot, free_wagon ? 0 : this->hscroll->GetPosition(), this->vehicle_over);
367
368 /* Length of consist in tiles with 1 fractional digit (rounded up) */
369 uint length = u->gcache.cached_total_length + this->CountDraggedLength(u);
370 Rect count = text.WithWidth(this->count_width - WidgetDimensions::scaled.hsep_normal, !rtl);
371 DrawString(count.left, count.right, count.bottom - GetCharacterHeight(FontSize::Small) + 1,
372 GetString(STR_JUST_DECIMAL, CeilDiv(length * 10, TILE_SIZE), 1),
373 TextColour::Black, AlignmentH::ForceRight, false, FontSize::Small); // Draw the counter
374 break;
375 }
376
377 case VehicleType::Road: DrawRoadVehImage(v, image, this->sel, EngineImageType::InDepot); break;
378 case VehicleType::Ship: DrawShipImage(v, image, this->sel, EngineImageType::InDepot); break;
379 case VehicleType::Aircraft: DrawAircraftImage(v, image, this->sel, EngineImageType::InDepot); break;
380 default: NOT_REACHED();
381 }
382
383 uint diff_x, diff_y;
384 if (v->IsGroundVehicle()) {
385 /* Arrange unitnumber and flag horizontally */
386 diff_x = this->flag_size.width + WidgetDimensions::scaled.hsep_normal;
387 diff_y = WidgetDimensions::scaled.matrix.top;
388 } else {
389 /* Arrange unitnumber and flag vertically */
390 diff_x = 0;
392 }
393
394 text = text.WithWidth(this->header_width - WidgetDimensions::scaled.hsep_normal, rtl).WithHeight(GetCharacterHeight(FontSize::Normal)).Indent(diff_x, rtl);
395 if (free_wagon) {
396 DrawString(text, STR_DEPOT_NO_ENGINE);
397 } else {
398 Rect flag = r.WithWidth(this->flag_size.width, rtl).WithHeight(this->flag_size.height).Translate(0, diff_y);
399 DrawSpriteIgnorePadding((v->vehstatus.Test(VehState::Stopped)) ? SPR_FLAG_VEH_STOPPED : SPR_FLAG_VEH_RUNNING, PAL_NONE, flag, {AlignmentH::Centre, AlignmentV::Middle});
400
402 }
403 }
404
405 void DrawWidget(const Rect &r, WidgetID widget) const override
406 {
407 if (widget != WID_D_MATRIX) return;
408
409 bool rtl = _current_text_dir == TD_RTL;
410
411 /* Set the row and number of boxes in each row based on the number of boxes drawn in the matrix */
413
414 /* Set up rect for each cell */
415 Rect ir = r.WithHeight(this->resize.step_height);
416 if (this->num_columns != 1) ir = ir.WithWidth(this->resize.step_width, rtl);
417 ir = ir.Shrink(WidgetDimensions::scaled.framerect, RectPadding::zero);
418
419 /* Draw vertical separators at whole tiles.
420 * This only works in two cases:
421 * - All vehicles use VEHICLEINFO_FULL_VEHICLE_WIDTH as reference width.
422 * - All vehicles are 8/8. This cannot be checked for NewGRF, so instead we check for "all vehicles are original vehicles".
423 */
424 if (this->type == VehicleType::Train && _consistent_train_width != 0) {
427 Rect image = ir.Indent(this->header_width, rtl).Indent(this->count_width, !rtl);
428 int first_line = w + (-this->hscroll->GetPosition()) % w;
429 if (rtl) {
430 for (int x = image.right - first_line; x >= image.left; x -= w) {
431 GfxDrawLine(x, r.top, x, r.bottom, col, ScaleGUITrad(1), ScaleGUITrad(3));
432 }
433 } else {
434 for (int x = image.left + first_line; x <= image.right; x += w) {
435 GfxDrawLine(x, r.top, x, r.bottom, col, ScaleGUITrad(1), ScaleGUITrad(3));
436 }
437 }
438 }
439
440 uint16_t rows_in_display = wid->current_y / wid->resize_y;
441
442 uint num = this->vscroll->GetPosition() * this->num_columns;
443 uint maxval = static_cast<uint>(std::min<size_t>(this->vehicle_list.size(), num + (rows_in_display * this->num_columns)));
444 for (; num < maxval; ir = ir.Translate(0, this->resize.step_height)) { // Draw the rows
445 Rect cell = ir; /* Keep track of horizontal cells */
446 for (uint i = 0; i < this->num_columns && num < maxval; i++, num++) {
447 /* Draw all vehicles in the current row */
448 const Vehicle *v = this->vehicle_list[num];
449 this->DrawVehicleInDepot(v, cell);
450 cell = cell.Translate(rtl ? -(int)this->resize.step_width : (int)this->resize.step_width, 0);
451 }
452 }
453
454 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)));
455
456 /* Draw the train wagons without an engine in front. */
457 for (; num < maxval; num++, ir = ir.Translate(0, this->resize.step_height)) {
458 const Vehicle *v = this->wagon_list[num - this->vehicle_list.size()];
459 this->DrawVehicleInDepot(v, ir);
460 }
461 }
462
463 std::string GetWidgetString(WidgetID widget, StringID stringid) const override
464 {
465 if (widget == WID_D_CAPTION) return GetString(STR_DEPOT_CAPTION, this->type, this->GetDestinationIndex());
466
467 return this->Window::GetWidgetString(widget, stringid);
468 }
469
477
481 const Vehicle *vehicle = nullptr;
482 const Vehicle *wagon = nullptr;
483 };
484
492 {
493 this->RefreshVehicleList();
494
495 const NWidgetCore *matrix_widget = this->GetWidget<NWidgetCore>(WID_D_MATRIX);
496 /* Make X relative to widget. Y is left alone for GetScrolledRowFromWidget(). */
497 x -= matrix_widget->pos_x;
498 /* In case of RTL the widgets are swapped as a whole */
499 if (_current_text_dir == TD_RTL) x = matrix_widget->current_x - x;
500
501 uint xt = 0, xm = 0, ym = 0;
502 if (this->type == VehicleType::Train) {
503 xm = x;
504 } else {
505 xt = x / this->resize.step_width;
506 xm = x % this->resize.step_width;
507 if (xt >= this->num_columns) return {.action = DepotGUIAction::Error};
508 }
509 ym = (y - matrix_widget->pos_y) % this->resize.step_height;
510
511 int32_t row = this->vscroll->GetScrolledRowFromWidget(y, this, WID_D_MATRIX);
512 uint pos = (row * this->num_columns) + xt;
513
514 if (row == INT32_MAX || this->vehicle_list.size() + this->wagon_list.size() <= pos) {
515 /* Clicking on 'line' / 'block' without a vehicle */
516 if (this->type == VehicleType::Train) {
517 /* End the dragging */
518 return {.action = DepotGUIAction::DragVehicle};
519 } else {
520 return {.action = DepotGUIAction::Error}; // empty block, so no vehicle is selected
521 }
522 }
523
524 const Vehicle *vehicle;
525 bool is_wagon = false;
526 if (this->vehicle_list.size() > pos) {
527 vehicle = this->vehicle_list[pos];
528 /* Skip vehicles that are scrolled off the list */
529 if (this->type == VehicleType::Train) x += this->hscroll->GetPosition();
530 } else {
531 pos -= (uint)this->vehicle_list.size();
532 vehicle = this->wagon_list[pos];
533 /* free wagons don't have an initial loco. */
534 x -= ScaleSpriteTrad(VEHICLEINFO_FULL_VEHICLE_WIDTH);
535 is_wagon = true;
536 }
537
538 if (xm <= this->header_width) {
539 switch (this->type) {
541 if (is_wagon) return {.action = DepotGUIAction::Error};
542 [[fallthrough]];
543
545 if (xm <= this->flag_size.width) return {.action = DepotGUIAction::StartStop, .vehicle = vehicle};
546 break;
547
550 if (xm <= this->flag_size.width && ym >= (uint)(GetCharacterHeight(FontSize::Normal) + WidgetDimensions::scaled.vsep_normal)) return {.action = DepotGUIAction::StartStop, .vehicle = vehicle};
551 break;
552
553 default: NOT_REACHED();
554 }
555 return {.action = DepotGUIAction::ShowVehicle, .vehicle = vehicle};
556 }
557
558 if (this->type != VehicleType::Train) return {.action = DepotGUIAction::DragVehicle, .vehicle = vehicle};
559
560 /* Clicking on the counter */
561 if (xm >= matrix_widget->current_x - this->count_width) {
562 if (is_wagon) return {.action = DepotGUIAction::Error};
563 return {.action = DepotGUIAction::ShowVehicle, .vehicle = vehicle};
564 }
565
566 /* Account for the header */
567 x -= this->header_width;
568
569 /* find the vehicle in this row that was clicked */
570 const Train *wagon = Train::From(vehicle);
571 for (; wagon != nullptr; wagon = wagon->Next()) {
572 x -= wagon->GetDisplayImageWidth();
573 if (x < 0) break;
574 }
575
576 return {.action = DepotGUIAction::DragVehicle, .vehicle = vehicle, .wagon = wagon != nullptr ? wagon->GetFirstEnginePart() : nullptr};
577 }
578
584 void DepotClick(int x, int y)
585 {
586 DepotActionResult result = this->GetVehicleFromDepotWndPt(x, y);
587 switch (result.action) {
588 case DepotGUIAction::Error: // invalid
589 return;
590
591 case DepotGUIAction::DragVehicle: { // start dragging of vehicle
592 const Vehicle *v = (this->type == VehicleType::Train) ? result.wagon : result.vehicle;
593
594 if (v != nullptr && VehicleClicked(v)) return;
595
596 VehicleID sel = this->sel;
597
598 if (this->type == VehicleType::Train && sel != VehicleID::Invalid()) {
599 this->sel = VehicleID::Invalid();
600 TrainDepotMoveVehicle(v, sel, result.vehicle);
601 } else if (v != nullptr) {
604 _cursor.vehchain = IsCtrlPressed();
605
606 this->sel = v->index;
607 this->SetDirty();
608 }
609 break;
610 }
611
612 case DepotGUIAction::ShowVehicle: // show info window
614 break;
615
616 case DepotGUIAction::StartStop: // click start/stop flag
617 StartStopVehicle(result.vehicle, false);
618 break;
619
620 default: NOT_REACHED();
621 }
622 }
623
632 {
633 this->GetWidget<NWidgetCore>(WID_D_STOP_ALL)->SetToolTip(STR_DEPOT_MASS_STOP_DEPOT_TRAIN_TOOLTIP + to_underlying(type));
634 this->GetWidget<NWidgetCore>(WID_D_START_ALL)->SetToolTip(STR_DEPOT_MASS_START_DEPOT_TRAIN_TOOLTIP + to_underlying(type));
635 this->GetWidget<NWidgetCore>(WID_D_SELL)->SetToolTip(STR_DEPOT_TRAIN_SELL_TOOLTIP + to_underlying(type));
636 this->GetWidget<NWidgetCore>(WID_D_SELL_ALL)->SetToolTip(STR_DEPOT_SELL_ALL_BUTTON_TRAIN_TOOLTIP + to_underlying(type));
637
638 this->GetWidget<NWidgetCore>(WID_D_BUILD)->SetStringTip(STR_DEPOT_TRAIN_NEW_VEHICLES_BUTTON + to_underlying(type), STR_DEPOT_TRAIN_NEW_VEHICLES_TOOLTIP + to_underlying(type));
639 this->GetWidget<NWidgetCore>(WID_D_CLONE)->SetStringTip(STR_DEPOT_CLONE_TRAIN + to_underlying(type), STR_DEPOT_CLONE_TRAIN_DEPOT_TOOLTIP + to_underlying(type));
640
641 this->GetWidget<NWidgetCore>(WID_D_LOCATION)->SetToolTip(STR_DEPOT_TRAIN_LOCATION_TOOLTIP + to_underlying(type));
642 this->GetWidget<NWidgetCore>(WID_D_VEHICLE_LIST)->SetToolTip(STR_DEPOT_VEHICLE_ORDER_LIST_TRAIN_TOOLTIP + to_underlying(type));
643 this->GetWidget<NWidgetCore>(WID_D_AUTOREPLACE)->SetToolTip(STR_DEPOT_AUTOREPLACE_TRAIN_TOOLTIP + to_underlying(type));
644 this->GetWidget<NWidgetCore>(WID_D_MATRIX)->SetToolTip(STR_DEPOT_TRAIN_LIST_TOOLTIP + to_underlying(type));
645
646 switch (type) {
647 default: NOT_REACHED();
648
650 this->GetWidget<NWidgetCore>(WID_D_VEHICLE_LIST)->SetString(STR_TRAIN);
651
652 /* Sprites */
653 this->GetWidget<NWidgetCore>(WID_D_SELL)->SetSprite(SPR_SELL_TRAIN);
654 this->GetWidget<NWidgetCore>(WID_D_SELL_ALL)->SetSprite(SPR_SELL_ALL_TRAIN);
655 this->GetWidget<NWidgetCore>(WID_D_AUTOREPLACE)->SetSprite(SPR_REPLACE_TRAIN);
656 break;
657
659 this->GetWidget<NWidgetCore>(WID_D_VEHICLE_LIST)->SetString(STR_LORRY);
660
661 /* Sprites */
662 this->GetWidget<NWidgetCore>(WID_D_SELL)->SetSprite(SPR_SELL_ROADVEH);
663 this->GetWidget<NWidgetCore>(WID_D_SELL_ALL)->SetSprite(SPR_SELL_ALL_ROADVEH);
664 this->GetWidget<NWidgetCore>(WID_D_AUTOREPLACE)->SetSprite(SPR_REPLACE_ROADVEH);
665 break;
666
668 this->GetWidget<NWidgetCore>(WID_D_VEHICLE_LIST)->SetString(STR_SHIP);
669
670 /* Sprites */
671 this->GetWidget<NWidgetCore>(WID_D_SELL)->SetSprite(SPR_SELL_SHIP);
672 this->GetWidget<NWidgetCore>(WID_D_SELL_ALL)->SetSprite(SPR_SELL_ALL_SHIP);
673 this->GetWidget<NWidgetCore>(WID_D_AUTOREPLACE)->SetSprite(SPR_REPLACE_SHIP);
674 break;
675
677 this->GetWidget<NWidgetCore>(WID_D_VEHICLE_LIST)->SetString(STR_PLANE);
678
679 /* Sprites */
680 this->GetWidget<NWidgetCore>(WID_D_SELL)->SetSprite(SPR_SELL_AIRCRAFT);
681 this->GetWidget<NWidgetCore>(WID_D_SELL_ALL)->SetSprite(SPR_SELL_ALL_AIRCRAFT);
682 this->GetWidget<NWidgetCore>(WID_D_AUTOREPLACE)->SetSprite(SPR_REPLACE_AIRCRAFT);
683 break;
684 }
685 }
686
687 void OnInit() override
688 {
689 this->cell_size = GetVehicleImageCellSize(this->type, EngineImageType::InDepot);
691 if (this->hscroll != nullptr) {
692 this->hscroll->SetStepSize(GetCharacterHeight(FontSize::Normal)); // Speed up horizontal scrollbar
693 }
694 }
695
696 void UpdateWidgetSize(WidgetID widget, Dimension &size, [[maybe_unused]] const Dimension &padding, [[maybe_unused]] Dimension &fill, [[maybe_unused]] Dimension &resize) override
697 {
698 switch (widget) {
699 case WID_D_MATRIX: {
700 uint min_height = 0;
701
702 if (this->type == VehicleType::Train) {
703 this->count_width = GetStringBoundingBox(GetString(STR_JUST_DECIMAL, GetParamMaxValue(1000, 0, FontSize::Small), 1), FontSize::Small).width + WidgetDimensions::scaled.hsep_normal;
704 } else {
705 this->count_width = 0;
706 }
707
708 Dimension unumber = GetStringBoundingBox(GetString(STR_JUST_COMMA, GetParamMaxDigits(this->unitnumber_digits)));
709
710 if (this->type == VehicleType::Train || this->type == VehicleType::Road) {
711 min_height = std::max<uint>(unumber.height, this->flag_size.height);
712 this->header_width = unumber.width + WidgetDimensions::scaled.hsep_normal + this->flag_size.width + WidgetDimensions::scaled.hsep_normal;
713 } else {
714 min_height = unumber.height + WidgetDimensions::scaled.vsep_normal + this->flag_size.height;
715 this->header_width = std::max<uint>(unumber.width, this->flag_size.width) + WidgetDimensions::scaled.hsep_normal;
716 }
717 int base_width = this->count_width + this->header_width + padding.width;
718
719 resize.height = std::max<uint>(this->cell_size.height, min_height + padding.height);
720 if (this->type == VehicleType::Train) {
721 resize.width = 1;
722 size.width = base_width + 2 * ScaleSpriteTrad(29); // about 2 parts
723 size.height = resize.height * 6;
724 } else {
725 resize.width = base_width + this->cell_size.extend_left + this->cell_size.extend_right;
726 size.width = resize.width * (this->type == VehicleType::Road ? 5 : 3);
727 size.height = resize.height * (this->type == VehicleType::Road ? 5 : 3);
728 }
729 fill.width = resize.width;
730 fill.height = resize.height;
731 break;
732 }
733 }
734 }
735
741 void OnInvalidateData([[maybe_unused]] int data = 0, [[maybe_unused]] bool gui_scope = true) override
742 {
743 this->generate_list = true;
744 }
745
746 void RefreshVehicleList()
747 {
748 if (this->generate_list) {
749 /* Generate the vehicle list
750 * It's ok to use the wagon pointers for non-trains as they will be ignored */
751 BuildDepotVehicleList(this->type, TileIndex(this->window_number), &this->vehicle_list, &this->wagon_list);
752 this->generate_list = false;
753 DepotSortList(&this->vehicle_list);
754
755 this->check_unitnumber_digits = true;
756 }
757 }
758
759 void OnPaint() override
760 {
761 this->RefreshVehicleList();
762
763 if (this->check_unitnumber_digits) {
764 this->check_unitnumber_digits = false;
765 uint new_unitnumber_digits = GetUnitNumberDigits(this->vehicle_list);
766 /* Only increase the size; do not decrease to prevent constant changes */
767 if (this->unitnumber_digits < new_unitnumber_digits) {
768 this->unitnumber_digits = new_unitnumber_digits;
769 this->ReInit();
770 }
771 }
772
773 /* determine amount of items for scroller */
774 if (this->type == VehicleType::Train) {
775 uint max_width = ScaleSpriteTrad(VEHICLEINFO_FULL_VEHICLE_WIDTH);
776 for (uint num = 0; num < this->vehicle_list.size(); num++) {
777 uint width = 0;
778 for (const Train *v = Train::From(this->vehicle_list[num]); v != nullptr; v = v->Next()) {
779 width += v->GetDisplayImageWidth();
780 }
781 max_width = std::max(max_width, width);
782 }
783 /* Always have 1 empty row, so people can change the setting of the train */
784 this->vscroll->SetCount(this->vehicle_list.size() + this->wagon_list.size() + 1);
785 /* 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 */
786 this->hscroll->SetCount(max_width + ScaleSpriteTrad(2 * VEHICLEINFO_FULL_VEHICLE_WIDTH + 1));
787 } else {
788 this->vscroll->SetCount(CeilDiv((uint)this->vehicle_list.size(), this->num_columns));
789 }
790
791 /* Setup disabled buttons. */
792 TileIndex tile(this->window_number);
803
804 this->DrawWidgets();
805 }
806
807 void OnClick([[maybe_unused]] Point pt, WidgetID widget, [[maybe_unused]] int click_count) override
808 {
809 switch (widget) {
810 case WID_D_MATRIX: // List
811 this->DepotClick(pt.x, pt.y);
812 break;
813
814 case WID_D_BUILD: // Build vehicle
816 ShowBuildVehicleWindow(TileIndex(this->window_number), this->type);
817 break;
818
819 case WID_D_CLONE: // Clone button
822
823 if (this->IsWidgetLowered(WID_D_CLONE)) {
824 static constexpr VehicleTypeIndexArray<const CursorID> clone_icons = {
827 };
828
829 SetObjectToPlaceWnd(clone_icons[this->type], PAL_NONE, HT_VEHICLE, this);
830 } else {
832 }
833 SndClickBeep();
834 break;
835
836 case WID_D_LOCATION:
837 if (IsCtrlPressed()) {
839 } else {
841 }
842 break;
843
844 case WID_D_RENAME: // Rename button
845 ShowQueryString(GetString(STR_DEPOT_NAME, this->type, Depot::GetByTile(TileIndex(this->window_number))->index), STR_DEPOT_RENAME_DEPOT_CAPTION,
847 break;
848
849 case WID_D_STOP_ALL:
850 case WID_D_START_ALL: {
851 VehicleListIdentifier vli(VehicleListType::Depot, this->type, this->owner);
852 Command<Commands::MassStartStop>::Post(TileIndex(this->window_number), widget == WID_D_START_ALL, false, vli);
853 break;
854 }
855
856 case WID_D_SELL_ALL:
857 /* Only open the confirmation window if there are anything to sell */
858 if (!this->vehicle_list.empty() || !this->wagon_list.empty()) {
859 ShowQuery(
860 GetEncodedString(STR_DEPOT_CAPTION, this->type, this->GetDestinationIndex()),
861 GetEncodedString(STR_DEPOT_SELL_CONFIRMATION_TEXT),
862 this,
863 DepotSellAllConfirmationCallback
864 );
865 }
866 break;
867
869 ShowVehicleListWindow(GetTileOwner(this->window_number), this->type, TileIndex(this->window_number));
870 break;
871
873 Command<Commands::DepotMassAutoreplace>::Post(GetCmdAutoreplaceVehMsg(this->type), TileIndex(this->window_number), this->type);
874 break;
875
876 }
877 }
878
879 void OnQueryTextFinished(std::optional<std::string> str) override
880 {
881 if (!str.has_value()) return;
882
883 /* Do depot renaming */
884 Command<Commands::RenameDepot>::Post(STR_ERROR_CAN_T_RENAME_DEPOT, this->GetDestinationIndex().ToDepotID(), *str);
885 }
886
887 bool OnRightClick([[maybe_unused]] Point pt, WidgetID widget) override
888 {
889 if (widget != WID_D_MATRIX) return false;
890
891 DepotActionResult result = this->GetVehicleFromDepotWndPt(pt.x, pt.y);
892 const Vehicle *v = this->type == VehicleType::Train ? result.wagon : result.vehicle;
893 if (result.action != DepotGUIAction::DragVehicle || v == nullptr) return false;
894
895 CargoArray capacity{}, loaded{};
896
897 /* Display info for single (articulated) vehicle, or for whole chain starting with selected vehicle */
898 bool whole_chain = (this->type == VehicleType::Train && IsCtrlPressed());
899
900 /* loop through vehicle chain and collect cargoes */
901 uint num = 0;
902 for (const Vehicle *w = v; w != nullptr; w = w->Next()) {
903 if (w->cargo_cap > 0 && w->cargo_type < NUM_CARGO) {
904 capacity[w->cargo_type] += w->cargo_cap;
905 loaded [w->cargo_type] += w->cargo.StoredCount();
906 }
907
908 if (w->type == VehicleType::Train && !w->HasArticulatedPart()) {
909 num++;
910 if (!whole_chain) break;
911 }
912 }
913
914 /* Build tooltipstring */
915 static std::string details;
916 details.clear();
917
918 for (const CargoSpec *cs : _sorted_cargo_specs) {
919 CargoType cargo_type = cs->Index();
920 if (capacity[cargo_type] == 0) continue;
921
922 auto params = MakeParameters(cargo_type, loaded[cargo_type], cargo_type, capacity[cargo_type]);
923 AppendStringWithArgsInPlace(details, STR_DEPOT_VEHICLE_TOOLTIP_CARGO, params);
924 }
925
926 /* Show tooltip window */
927 if (whole_chain) {
928 GuiShowTooltips(this, GetEncodedString(STR_DEPOT_VEHICLE_TOOLTIP_CHAIN, num, details), TooltipCloseCondition::RightClick);
929 } else {
930 GuiShowTooltips(this, GetEncodedString(STR_DEPOT_VEHICLE_TOOLTIP, v->engine_type, details), TooltipCloseCondition::RightClick);
931 }
932
933 return true;
934 }
935
941 bool OnVehicleSelect(const Vehicle *v) override
942 {
943 if (IsCtrlPressed()) {
944 /* Share-clone, do not open new viewport, and keep tool active */
945 Command<Commands::CloneVehicle>::Post(STR_ERROR_CAN_T_BUY_TRAIN + to_underlying(v->type), TileIndex(this->window_number), v->index, true);
946 } else {
947 /* Copy-clone, open viewport for new vehicle, and deselect the tool (assume player wants to change things on new vehicle) */
948 if (Command<Commands::CloneVehicle>::Post(STR_ERROR_CAN_T_BUY_TRAIN + to_underlying(v->type), CcCloneVehicle, TileIndex(this->window_number), v->index, false)) {
950 }
951 }
952
953 return true;
954 }
955
964 bool OnVehicleSelect(VehicleList::const_iterator begin, VehicleList::const_iterator end) override
965 {
966 if (!IsCtrlPressed()) {
967 /* If CTRL is not pressed: If all the vehicles in this list have the same orders, then copy orders */
968 if (AllEqual(begin, end, VehiclesHaveSameEngineList)) {
969 if (AllEqual(begin, end, VehiclesHaveSameOrderList)) {
970 OnVehicleSelect(*begin);
971 } else {
972 ShowErrorMessage(GetEncodedString(STR_ERROR_CAN_T_BUY_TRAIN + to_underlying((*begin)->type)),
973 GetEncodedString(STR_ERROR_CAN_T_COPY_ORDER_VEHICLE_LIST), WarningLevel::Info);
974 }
975 } else {
976 ShowErrorMessage(GetEncodedString(STR_ERROR_CAN_T_BUY_TRAIN + to_underlying((*begin)->type)),
977 GetEncodedString(STR_ERROR_CAN_T_CLONE_VEHICLE_LIST), WarningLevel::Info);
978 }
979 } else {
980 /* If CTRL is pressed: If all the vehicles in this list share orders, then copy orders */
981 if (AllEqual(begin, end, VehiclesHaveSameEngineList)) {
982 if (AllEqual(begin, end, VehiclesHaveSameSharedOrderList)) {
983 OnVehicleSelect(*begin);
984 } else {
985 ShowErrorMessage(GetEncodedString(STR_ERROR_CAN_T_BUY_TRAIN + to_underlying((*begin)->type)),
986 GetEncodedString(STR_ERROR_CAN_T_SHARE_ORDER_VEHICLE_LIST), WarningLevel::Info);
987 }
988 } else {
989 ShowErrorMessage(GetEncodedString(STR_ERROR_CAN_T_BUY_TRAIN + to_underlying((*begin)->type)),
990 GetEncodedString(STR_ERROR_CAN_T_CLONE_VEHICLE_LIST), WarningLevel::Info);
991 }
992 }
993
994 return true;
995 }
996
997 void OnPlaceObjectAbort() override
998 {
999 /* abort clone */
1000 this->RaiseWidget(WID_D_CLONE);
1002
1003 /* abort drag & drop */
1004 this->sel = VehicleID::Invalid();
1005 this->vehicle_over = VehicleID::Invalid();
1007
1008 if (this->hovered_widget != INVALID_WIDGET) {
1009 this->SetWidgetLoweredState(this->hovered_widget, false);
1010 this->SetWidgetDirty(this->hovered_widget);
1011 this->hovered_widget = INVALID_WIDGET;
1012 }
1013 }
1014
1015 void OnMouseLoop() override
1016 {
1017 if (last_overlay_state != ShowCargoIconOverlay()) {
1018 last_overlay_state = ShowCargoIconOverlay();
1019 this->SetDirty();
1020 }
1021 }
1022
1023 void OnMouseDrag(Point pt, WidgetID widget) override
1024 {
1025 if (this->sel == VehicleID::Invalid()) return;
1026 if (widget != this->hovered_widget) {
1027 if (this->hovered_widget == WID_D_SELL || this->hovered_widget == WID_D_SELL_CHAIN) {
1028 this->SetWidgetLoweredState(this->hovered_widget, false);
1029 this->SetWidgetDirty(this->hovered_widget);
1030 }
1031 this->hovered_widget = widget;
1032 if (this->hovered_widget == WID_D_SELL || this->hovered_widget == WID_D_SELL_CHAIN) {
1033 this->SetWidgetLoweredState(this->hovered_widget, true);
1034 this->SetWidgetDirty(this->hovered_widget);
1035 }
1036 }
1037 if (this->type != VehicleType::Train) return;
1038
1039 /* A rail vehicle is dragged.. */
1040 if (widget != WID_D_MATRIX) { // ..outside of the depot matrix.
1041 if (this->vehicle_over != VehicleID::Invalid()) {
1042 this->vehicle_over = VehicleID::Invalid();
1044 }
1045 return;
1046 }
1047
1048 DepotActionResult result = this->GetVehicleFromDepotWndPt(pt.x, pt.y);
1049 if (result.action != DepotGUIAction::DragVehicle) return;
1050
1051 VehicleID new_vehicle_over = VehicleID::Invalid();
1052 if (result.vehicle != nullptr) {
1053 if (result.wagon == nullptr && result.vehicle->Last()->index != this->sel) { // ..at the end of the train.
1054 /* 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
1055 * destination inside a train. This head index is then used to indicate that a wagon is inserted at
1056 * the end of the train.
1057 */
1058 new_vehicle_over = result.vehicle->index;
1059 } else if (result.wagon != nullptr && result.vehicle != result.wagon &&
1060 result.wagon->index != this->sel &&
1061 result.wagon->Previous()->index != this->sel) { // ..over an existing wagon.
1062 new_vehicle_over = result.wagon->index;
1063 }
1064 }
1065
1066 if (this->vehicle_over == new_vehicle_over) return;
1067
1068 this->vehicle_over = new_vehicle_over;
1069 this->SetWidgetDirty(widget);
1070 }
1071
1072 void OnDragDrop(Point pt, WidgetID widget) override
1073 {
1074 switch (widget) {
1075 case WID_D_MATRIX: {
1076 DepotActionResult result = this->GetVehicleFromDepotWndPt(pt.x, pt.y);
1077 VehicleID sel = this->sel;
1078
1079 this->sel = VehicleID::Invalid();
1080 this->SetDirty();
1081
1082 if (this->type == VehicleType::Train) {
1083 if (result.action == DepotGUIAction::DragVehicle && sel != VehicleID::Invalid()) {
1084 if (result.wagon != nullptr && result.wagon->index == sel && IsCtrlPressed()) {
1085 Command<Commands::ReverseTrainDirection>::Post(STR_ERROR_CAN_T_REVERSE_DIRECTION_RAIL_VEHICLE, Vehicle::Get(sel)->tile, Vehicle::Get(sel)->index, true);
1086 } else if (result.wagon == nullptr || result.wagon->index != sel) {
1087 this->vehicle_over = VehicleID::Invalid();
1088 TrainDepotMoveVehicle(result.wagon, sel, result.vehicle);
1089 } else if (result.vehicle != nullptr && result.vehicle->IsFrontEngine()) {
1091 }
1092 }
1093 } else if (result.action == DepotGUIAction::DragVehicle && result.vehicle != nullptr && sel == result.vehicle->index) {
1095 }
1096 break;
1097 }
1098
1099 case WID_D_SELL: case WID_D_SELL_CHAIN: {
1100 if (this->IsWidgetDisabled(widget)) return;
1101 if (this->sel == VehicleID::Invalid()) return;
1102
1103 this->HandleButtonClick(widget);
1104
1105 const Vehicle *v = Vehicle::Get(this->sel);
1106 this->sel = VehicleID::Invalid();
1107 this->SetDirty();
1108
1109 bool sell_cmd = (v->type == VehicleType::Train && (widget == WID_D_SELL_CHAIN || IsCtrlPressed()));
1110 Command<Commands::SellVehicle>::Post(GetCmdSellVehMsg(v->type), v->tile, v->index, sell_cmd, true, ClientID::Invalid);
1111 break;
1112 }
1113
1114 default:
1115 this->sel = VehicleID::Invalid();
1116 this->SetDirty();
1117 break;
1118 }
1119 this->hovered_widget = INVALID_WIDGET;
1120 _cursor.vehchain = false;
1121 }
1122
1123 void OnTimeout() override
1124 {
1125 if (!this->IsWidgetDisabled(WID_D_SELL)) {
1126 this->RaiseWidget(WID_D_SELL);
1128 }
1129 if (this->GetWidget<NWidgetBase>(WID_D_SELL) != nullptr && !this->IsWidgetDisabled(WID_D_SELL_CHAIN)) {
1132 }
1133 }
1134
1135 void OnResize() override
1136 {
1137 this->vscroll->SetCapacityFromWidget(this, WID_D_MATRIX);
1139 if (this->type == VehicleType::Train) {
1140 this->hscroll->SetCapacity(nwi->current_x - this->header_width - this->count_width);
1141 } else {
1142 this->num_columns = nwi->current_x / nwi->resize_x;
1143 }
1144 }
1145
1147 {
1148 if (this->sel != VehicleID::Invalid()) {
1149 _cursor.vehchain = IsCtrlPressed();
1151 return EventState::Handled;
1152 }
1153
1155 }
1156
1163 {
1165 }
1166};
1167
1168static void DepotSellAllConfirmationCallback(Window *win, bool confirmed)
1169{
1170 if (confirmed) {
1171 DepotWindow *w = (DepotWindow*)win;
1172 TileIndex tile(w->window_number);
1173 VehicleType vehtype = w->type;
1174 Command<Commands::DepotMassSell>::Post(GetCmdSellAllVehMsg(vehtype), tile, vehtype);
1175 }
1176}
1177
1184{
1185 if (BringWindowToFrontById(WindowClass::VehicleDepot, tile) != nullptr) return;
1186
1187 switch (type) {
1188 default: NOT_REACHED();
1189 case VehicleType::Train: new DepotWindow(_train_depot_desc, tile, type); break;
1190 case VehicleType::Road: new DepotWindow(_road_depot_desc, tile, type); break;
1191 case VehicleType::Ship: new DepotWindow(_ship_depot_desc, tile, type); break;
1192 case VehicleType::Aircraft: new DepotWindow(_aircraft_depot_desc, tile, type); break;
1193 }
1194}
1195
1201{
1202 DepotWindow *w;
1203
1204 /* If we haven't got any vehicles on the mouse pointer, we haven't got any highlighted in any depots either
1205 * If that is the case, we can skip looping though the windows and save time
1206 */
1208
1209 w = dynamic_cast<DepotWindow*>(FindWindowById(WindowClass::VehicleDepot, v->tile));
1210 if (w != nullptr) {
1211 if (w->sel == v->index) ResetObjectToPlace();
1212 }
1213}
Base for aircraft.
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).
void DrawAircraftImage(const Vehicle *v, const Rect &r, VehicleID selection, EngineImageType image_type)
Draws an image of an aircraft.
static constexpr CargoType NUM_CARGO
Maximum number of cargo types in a game.
Definition cargo_type.h:77
CargoType
Cargo slots to indicate a cargo type within a game.
Definition cargo_type.h:22
std::vector< const CargoSpec * > _sorted_cargo_specs
Cargo specifications sorted alphabetically by name.
constexpr bool Test(Tvalue_type value) const
Test if the value-th bit is set.
Common return value for all commands.
bool Failed() const
Did this command fail?
static Pool::IterateWrapperFiltered< Engine, EngineTypeFilter > IterateType(VehicleType vt, size_t from=0)
Returns an iterable ensemble of all valid engines of the given type.
Iterate a range of enum values.
uint resize_x
Horizontal resize step (0 means not resizable).
uint current_x
Current horizontal size (after resizing).
int pos_y
Vertical position of top-left corner of the widget in the window.
int pos_x
Horizontal position of top-left corner of the widget in the window.
uint resize_y
Vertical resize step (0 means not resizable).
uint current_y
Current vertical size (after resizing).
Base class for a 'real' widget.
Colours colour
Colour of this widget.
Scrollbar data structure.
void SetCount(size_t num)
Sets the number of elements in the list.
void SetCapacity(size_t capacity)
Set the capacity of visible elements.
size_type GetScrolledRowFromWidget(int clickpos, const Window *const w, WidgetID widget, int padding=0, int line_height=-1) const
Compute the row of a scrolled widget that a user clicked in.
Definition widget.cpp:2474
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:2548
void SetStepSize(size_t stepsize)
Set the distance to scroll when using the buttons or the wheel.
size_type GetPosition() const
Gets the position of the first visible element in the list.
static WidgetDimensions scaled
Widget dimensions scaled for current zoom level.
Definition window_gui.h:30
Functions related to commands.
Commands
List of commands.
CompanyID _local_company
Company controlled by the human player at this client. Can also be COMPANY_SPECTATOR.
Functions related to companies.
Base for all depots (except hangars).
Command definitions related to depots.
static VehicleTypeIndexArray< VehicleCellSize > _base_block_sizes_purchase
Cell size for vehicle images in the purchase list.
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...
static uint _consistent_train_width
Whether trains of all lengths are consistently scaled. Either TRAININFO_DEFAULT_VEHICLE_WIDTH,...
static WindowDesc _train_depot_desc(WindowPosition::Automatic, "depot_train", 362, 123, WindowClass::VehicleDepot, WindowClass::None, {}, _nested_train_depot_widgets)
Window definition for the train depot window.
static WindowDesc _road_depot_desc(WindowPosition::Automatic, "depot_roadveh", 316, 97, WindowClass::VehicleDepot, WindowClass::None, {}, _nested_train_depot_widgets)
Window definition for the road depot window.
static WindowDesc _ship_depot_desc(WindowPosition::Automatic, "depot_ship", 306, 99, WindowClass::VehicleDepot, WindowClass::None, {}, _nested_train_depot_widgets)
Window definition for the ship depot window.
void DeleteDepotHighlightOfVehicle(const Vehicle *v)
Removes the highlight of a vehicle in a depot window.
static constexpr std::initializer_list< NWidgetPart > _nested_train_depot_widgets
Nested widget definition for train depots.
Definition depot_gui.cpp:51
static VehicleTypeIndexArray< VehicleCellSize > _base_block_sizes_depot
Cell size for vehicle images in the depot view.
static WindowDesc _aircraft_depot_desc(WindowPosition::Automatic, "depot_aircraft", 332, 99, WindowClass::VehicleDepot, WindowClass::None, {}, _nested_train_depot_widgets)
Window definition for the aircraft depot window.
void ShowDepotWindow(TileIndex tile, VehicleType type)
Opens a depot window.
VehicleCellSize GetVehicleImageCellSize(VehicleType type, EngineImageType image_type)
Get the GUI cell size for a vehicle image.
void CcCloneVehicle(Commands, const CommandCost &result, VehicleID veh_id)
This is the Callback method after the cloning attempt of a vehicle.
DestinationID GetDepotDestinationIndex(Tile t)
Get the destination index of a 'depot'.
Definition depot_map.h:69
static const uint MAX_LENGTH_DEPOT_NAME_CHARS
The maximum length of a depot name in characters including '\0'.
Definition depot_type.h:18
Types related to the depot widgets.
@ WID_D_LOCATION
Location button.
@ WID_D_AUTOREPLACE
Autoreplace button.
@ WID_D_RENAME
Rename button.
@ WID_D_SELL_CHAIN
Sell chain button.
@ WID_D_CLONE
Clone button.
@ WID_D_SHOW_SELL_CHAIN
Show sell chain panel.
@ WID_D_SELL
Sell button.
@ WID_D_H_SCROLL
Horizontal scrollbar.
@ WID_D_SHOW_H_SCROLL
Show horizontal scrollbar panel.
@ WID_D_MATRIX
Matrix of vehicles.
@ WID_D_V_SCROLL
Vertical scrollbar.
@ WID_D_SELL_ALL
Sell all button.
@ WID_D_VEHICLE_LIST
List of vehicles.
@ WID_D_START_ALL
Start all button.
@ WID_D_SHOW_RENAME
Show rename panel.
@ WID_D_BUILD
Build button.
@ WID_D_CAPTION
Caption of window.
@ WID_D_STOP_ALL
Stop all button.
PoolID< uint16_t, struct EngineIDTag, 64000, 0xFFFF > EngineID
Unique identification number of an engine.
Definition engine_type.h:25
constexpr std::underlying_type_t< enum_type > to_underlying(enum_type e)
Implementation of std::to_underlying (from C++23).
Definition enum_type.hpp:21
Functions related to errors.
@ Info
Used for DoCommand-like (and some non-fatal AI GUI) errors/information.
Definition error.h:22
void ShowErrorMessage(EncodedString &&summary_msg, int x, int y, CommandCost &cc)
Display an error message in a window.
int GetCharacterHeight(FontSize size)
Get height of a character for a given font size.
Definition fontcache.cpp:88
Dimension maxdim(const Dimension &d1, const Dimension &d2)
Compute bounding box of both dimensions.
Geometry functions.
@ ForceRight
Force align to the right.
Dimension GetStringBoundingBox(std::string_view str, FontSize start_fontsize)
Return the string dimension in pixels.
Definition gfx.cpp:894
int DrawString(int left, int right, int top, std::string_view str, ExtendedTextColour colour, Alignment align, bool underline, FontSize fontsize)
Draw string, possibly truncated to make it fit in its allocated space.
Definition gfx.cpp:663
Dimension GetScaledSpriteSize(SpriteID sprid)
Scale sprite size for GUI.
Definition widget.cpp:70
bool IsCtrlPressed()
Test if the ctrl key is pressed.
Definition gfx_func.h:82
void DrawSpriteIgnorePadding(SpriteID img, PaletteID pal, const Rect &r, Alignment align)
Draw a sprite within a Rect, ignoring the sprite's padding.
Definition widget.cpp:350
@ Small
Index of the small font in the font tables.
Definition gfx_type.h:250
@ Normal
Index of the normal font in the font tables.
Definition gfx_type.h:249
@ Invalid
Invalid marker.
Definition gfx_type.h:302
@ Grey
Grey.
Definition gfx_type.h:299
@ Black
Black colour.
Definition gfx_type.h:334
@ Red
Red colour.
Definition gfx_type.h:321
constexpr NWidgetPart SetFill(uint16_t fill_x, uint16_t fill_y)
Widget part function for setting filling.
constexpr NWidgetPart SetSpriteTip(SpriteID sprite, StringID tip={})
Widget part function for setting the sprite and tooltip.
constexpr NWidgetPart SetScrollbar(WidgetID index)
Attach a scrollbar to a widget.
constexpr NWidgetPart SetAspect(float ratio, AspectFlags flags=AspectFlag::ResizeX)
Widget part function for setting the aspect ratio.
constexpr NWidgetPart EndContainer()
Widget part function for denoting the end of a container (horizontal, vertical, WWT_FRAME,...
constexpr NWidgetPart NWidget(WidgetType tp, Colours col, WidgetID idx=INVALID_WIDGET)
Widget part function for starting a new 'real' widget.
constexpr NWidgetPart SetResize(int16_t dx, int16_t dy)
Widget part function for setting the resize step.
static const CursorID SPR_CURSOR_CLONE_AIRPLANE
Definition sprites.h:1667
static const CursorID SPR_CURSOR_CLONE_TRAIN
Definition sprites.h:1664
static const CursorID SPR_CURSOR_CLONE_ROADVEH
Definition sprites.h:1665
static const CursorID SPR_CURSOR_MOUSE
Definition sprites.h:1568
static const CursorID SPR_CURSOR_CLONE_SHIP
Definition sprites.h:1666
void SetDirty() const
Mark entire window as dirty (in need of re-paint).
Definition window.cpp:1013
GUI functions that shouldn't be here.
void ShowExtraViewportWindow(TileIndex tile=INVALID_TILE)
Show a new Extra Viewport window.
#define Point
Macro that prevents name conflicts between included headers.
constexpr uint CeilDiv(uint a, uint b)
Computes ceil(a / b) for non-negative a and b.
constexpr T Clamp(const T a, const T min, const T max)
Clamp a value between an interval.
Definition math_func.hpp:79
void GuiShowTooltips(Window *parent, EncodedString &&text, TooltipCloseCondition close_tooltip)
Shows a tooltip.
Definition misc_gui.cpp:690
void ShowQuery(EncodedString &&caption, EncodedString &&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...
void ShowQueryString(std::string_view str, StringID caption, uint maxsize, Window *parent, CharSetFilter afilter, QueryStringFlags flags)
Show a query popup window with a textbox in it.
@ Invalid
Client is not part of anything.
Functions related to order backups.
PixelColour GetColourGradient(Colours colour, Shade shade)
Get colour gradient palette index.
Definition palette.cpp:393
@ Normal
Normal colour shade.
Road vehicle states.
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).
void DrawRoadVehImage(const Vehicle *v, const Rect &r, VehicleID selection, EngineImageType image_type, int skip)
Draws an image of a road vehicle chain.
A number of safeguards to prevent using unsafe methods.
Base for ships.
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:120
void DrawShipImage(const Vehicle *v, const Rect &r, VehicleID selection, EngineImageType image_type)
Draws an image of a ship.
Definition ship_gui.cpp:30
void SndClickBeep()
Play a beep sound for a click event if enabled in settings.
Definition sound.cpp:252
Functions related to sound.
Types related to the sprite cache.
static const SpriteID SPR_FLAG_VEH_STOPPED
Vehicle sprite-flags (red/green).
Definition sprites.h:1098
static const SpriteID SPR_FLAG_VEH_RUNNING
Vehicle sprite-flags (red/green).
Definition sprites.h:1099
Definition of base types and functions in a cross-platform compatible way.
@ CS_ALPHANUMERAL
Both numeric and alphabetic and spaces and stuff.
Definition string_type.h:25
uint64_t GetParamMaxValue(uint64_t max_value, uint min_count, FontSize size)
Get some number that is suitable for string size computations.
Definition strings.cpp:235
EncodedString GetEncodedString(StringID str)
Encode a string with no parameters into an encoded string.
Definition strings.cpp:89
std::string GetString(StringID string)
Resolve the given StringID into a std::string with formatting but no parameters.
Definition strings.cpp:423
TextDirection _current_text_dir
Text direction of the currently selected language.
Definition strings.cpp:55
uint64_t GetParamMaxDigits(uint count, FontSize size)
Get some number that is suitable for string size computations.
Definition strings.cpp:217
Functions related to OTTD's strings.
auto MakeParameters(Args &&... args)
Helper to create the StringParameters with its own buffer with the given parameter values.
StrongType::Typedef< uint32_t, struct StringIDTag, StrongType::Compare, StrongType::Integer > StringID
Numeric value that represents a string, independent of the selected language.
@ TD_RTL
Text is written right-to-left by default.
VehicleType type
Type of vehicle.
Class for storing amounts of cargo.
Definition cargo_type.h:120
Specification of a cargo type.
Definition cargotype.h:76
T y
Y coordinate.
T x
X coordinate.
Result of GetVehicleFromDepotWndPt that tries to determine the action to perform.
const Vehicle * wagon
The wagon to perform the action on. Only set for DragVehicle actions on trains.
DepotGUIAction action
Action to perform.
const Vehicle * vehicle
The vehicle, or head of vehicle, to perform the action on.
uint header_width
Width of unit number and flag, including separator.
void OnMouseLoop() override
Called for every mouse loop run, which is at least once per (game) tick.
VehicleID vehicle_over
Rail vehicle over which another one is dragged, VehicleID::Invalid() if none.
void OnDragDrop(Point pt, WidgetID widget) override
A dragged 'object' has been released.
DepotActionResult GetVehicleFromDepotWndPt(int x, int y)
Determine what action to take for clicking at the given location in the depot window.
DepotGUIAction
Action to perform when using the depot UI.
@ ShowVehicle
Show the vehicle window.
@ Error
Most likely clicked outside of the bounds.
@ DragVehicle
Drag a vehicle to somewhere else.
@ StartStop
Start/stop the vehicle.
uint count_width
Width of length count, including separator.
void OnQueryTextFinished(std::optional< std::string > str) override
The query window opened from this window has closed.
DestinationID GetDestinationIndex() const
Gets the DepotID of the current window.
void OnTimeout() override
Called when this window's timeout has been reached.
void Close(int data=0) override
Hide the window and all its child windows, and mark them for a later deletion.
uint num_columns
Number of columns.
EventState OnCTRLStateChange() override
The state of the control key has changed.
std::string GetWidgetString(WidgetID widget, StringID stringid) const override
Get the raw string for a widget.
void OnClick(Point pt, WidgetID widget, int click_count) override
A click with the left mouse button has been made on the window.
void SetupWidgetData(VehicleType type)
Function to set up vehicle specific widgets (mainly sprites and strings).
void OnPlaceObjectAbort() override
The user cancelled a tile highlight mode that has been set.
bool OnRightClick(Point pt, WidgetID widget) override
A click with the right mouse button has been made on the window.
void OnMouseDrag(Point pt, WidgetID widget) override
An 'object' is being dragged at the provided position, highlight the target if possible.
uint CountDraggedLength(const Train *t) const
Count the dragged selection length if appropriate for the provided train.
bool OnVehicleSelect(const Vehicle *v) override
Clones a vehicle.
Dimension flag_size
Size of start/stop flag.
void DepotClick(int x, int y)
Handle click in the depot matrix.
void UpdateWidgetSize(WidgetID widget, Dimension &size, const Dimension &padding, Dimension &fill, Dimension &resize) override
Update size and resize step of a widget in the window.
Scrollbar * hscroll
Only for trains.
bool OnVehicleSelect(VehicleList::const_iterator begin, VehicleList::const_iterator end) override
Clones a vehicle from a vehicle list.
void OnResize() override
Called after the window got resized.
void OnPaint() override
The window must be repainted.
WidgetID hovered_widget
Index of the widget being hovered during drag/drop. INVALID_WIDGET if no drag is in progress.
void OnInit() override
Notification that the nested widget tree gets initialized.
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.
void DrawWidget(const Rect &r, WidgetID widget) const override
Draw the contents of a nested widget.
void OnInvalidateData(int data=0, bool gui_scope=true) override
Some data on this window has become invalid.
VehicleCellSize cell_size
Vehicle sprite cell size.
Dimensions (a width and height) of a rectangle in 2D.
value_type height
The height of the rectangle.
value_type width
The width of the rectangle.
uint16_t cached_total_length
Length of the whole vehicle (valid only for the first engine).
GroundVehicleCache gcache
Cache of often calculated values.
bool IsFreeWagon() const
Check if the vehicle is a free wagon (got no engine in front of it).
static void Reset(TileIndex tile=INVALID_TILE, bool from_gui=true)
Reset the OrderBackups from GUI/game logic.
Colour for pixel/line drawing.
Definition gfx_type.h:307
static Vehicle * Get(auto index)
Information about a rail vehicle.
Definition engine_type.h:73
Specification of a rectangle with absolute coordinates of all edges.
Rect WithWidth(int width, bool end) const
Copy Rect and set its width.
Rect Shrink(int s) const
Copy and shrink Rect by s pixels.
Rect WithHeight(int height, bool end=false) const
Copy Rect and set its height.
Rect Indent(int indent, bool end) const
Copy Rect and indent it from its position.
Rect Translate(int x, int y) const
Copy and translate Rect by x,y pixels.
T * Next() const
Get next vehicle in the chain.
static Train * From(Vehicle *v)
T * GetFirstEnginePart()
Get the first part of an articulated engine.
Data structure describing a sprite.
'Train' is either a loco or a wagon.
Definition train.h:97
int GetDisplayImageWidth(Point *offset=nullptr) const
Get the width of a train vehicle image in the GUI.
Dimensions of a cell in the purchase/depot windows.
Definition vehicle_gui.h:82
uint extend_left
Extend of the cell to the left.
Definition vehicle_gui.h:84
uint height
Vehicle cell height.
Definition vehicle_gui.h:83
uint extend_right
Extend of the cell to the right.
Definition vehicle_gui.h:85
The information about a vehicle list.
Definition vehiclelist.h:32
Vehicle data structure.
EngineID engine_type
The type of engine used for this vehicle.
bool IsGroundVehicle() const
Check if the vehicle is a ground vehicle.
VehStates vehstatus
Status.
Vehicle * Next() const
Get the next vehicle of this vehicle.
bool IsFrontEngine() const
Check if the vehicle is a front engine.
TimerGameCalendar::Date age
Age in calendar days.
TimerGameCalendar::Date max_age
Maximum age.
Vehicle * Previous() const
Get the previous vehicle of this vehicle.
Vehicle * Last() const
Get the last vehicle of this vehicle chain.
TileIndex tile
Current tile index.
UnitID unitnumber
unit number, for display purposes only
High level window description.
Definition window_gui.h:171
Data structure for an opened window.
Definition window_gui.h:272
void ReInit(int rx=0, int ry=0, bool reposition=false)
Re-initialize a window, and optionally change its size.
Definition window.cpp:1025
virtual void Close(int data=0)
Hide the window and all its child windows, and mark them for a later deletion.
Definition window.cpp:1150
void FinishInitNested(WindowNumber window_number=0)
Perform the second part of the initialization of a nested widget tree.
Definition window.cpp:1855
void DrawWidgets() const
Paint all widgets of a window.
Definition widget.cpp:792
void RaiseWidget(WidgetID widget_index)
Marks a widget as raised.
Definition window_gui.h:468
void SetWidgetDirty(WidgetID widget_index) const
Invalidate a widget, i.e.
Definition window.cpp:565
virtual std::string GetWidgetString(WidgetID widget, StringID stringid) const
Get the raw string for a widget.
Definition window.cpp:513
ResizeInfo resize
Resize information.
Definition window_gui.h:313
void SetWidgetsDisabledState(bool disab_stat, Args... widgets)
Sets the enabled/disabled status of a list of widgets.
Definition window_gui.h:514
void CreateNestedTree()
Perform the first part of the initialization of a nested widget tree.
Definition window.cpp:1845
bool IsWidgetLowered(WidgetID widget_index) const
Gets the lowered state of a widget.
Definition window_gui.h:490
bool IsWidgetDisabled(WidgetID widget_index) const
Gets the enabled/disabled status of a widget.
Definition window_gui.h:409
Owner owner
The owner of the content shown in this window. Company colour is acquired from this variable.
Definition window_gui.h:315
void SetWidgetLoweredState(WidgetID widget_index, bool lowered_stat)
Sets the lowered/raised status of a widget.
Definition window_gui.h:440
Window(WindowDesc &desc)
Empty constructor, initialization has been moved to InitNested() called from the constructor of the d...
Definition window.cpp:1879
const NWID * GetWidget(WidgetID widnum) const
Get the nested widget with number widnum from the nested widget tree.
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:604
const Scrollbar * GetScrollbar(WidgetID widnum) const
Return the Scrollbar to a widget index.
Definition window.cpp:322
int width
width of the window (number of pixels to the right in x direction)
Definition window_gui.h:310
void ToggleWidgetLoweredState(WidgetID widget_index)
Invert the lowered/raised status of a widget.
Definition window_gui.h:449
WindowNumber window_number
Window number within the window class.
Definition window_gui.h:301
Stuff related to the text buffer GUI.
@ EnableDefault
enable the 'Default' button ("\0" is returned)
Definition textbuf_gui.h:20
@ LengthIsInChars
the length of the string is counted in characters
Definition textbuf_gui.h:21
bool IsTileOwner(Tile tile, Owner owner)
Checks if a tile belongs to the given owner.
Definition tile_map.h:214
Owner GetTileOwner(Tile tile)
Returns the owner of a tile.
Definition tile_map.h:178
StrongType::Typedef< uint32_t, struct TileIndexTag, StrongType::Compare, StrongType::Integer, StrongType::Compatible< int32_t >, StrongType::Compatible< int64_t > > TileIndex
The index/ID of a Tile.
Definition tile_type.h:92
static constexpr uint TILE_SIZE
Tile size in world coordinates.
Definition tile_type.h:15
Functions related to tile highlights.
void ResetObjectToPlace()
Reset the cursor and mouse mode handling back to default (normal cursor, only clicking in windows).
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...
@ HT_DRAG
dragging items in the depot windows
@ HT_VEHICLE
vehicle is accepted as target as well (bitmask)
Base for the train class.
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).
Command definitions related to trains.
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.
bool VehiclesHaveSameEngineList(const Vehicle *v1, const Vehicle *v2)
Checks if two vehicle chains have the same list of engines.
Definition vehicle.cpp:3329
bool VehiclesHaveSameOrderList(const Vehicle *v1, const Vehicle *v2)
Checks if two vehicles have the same list of orders.
Definition vehicle.cpp:3346
bool VehiclesHaveSameSharedOrderList(const Vehicle *v1, const Vehicle *v2)
Checks if two vehicles have the same shared list of orders.
Definition vehicle.cpp:3357
@ Stopped
Vehicle is stopped by the player.
Command definitions for vehicles.
Functions related to vehicles.
bool IsCompanyBuildableVehicleType(VehicleType type)
Is the given vehicle type buildable by a company?
uint GetUnitNumberDigits(VehicleList &vehicles)
Get the number of digits the biggest unit number of a set of vehicles has.
void ShowVehicleViewWindow(const Vehicle *v)
Shows the vehicle view window of the given vehicle.
bool VehicleClicked(const Vehicle *v)
Dispatch a "vehicle selected" event if any window waits for it.
void StartStopVehicle(const Vehicle *v, bool texteffect)
Executes Commands::StartStopVehicle for given vehicle.
void SetMouseCursorVehicle(const Vehicle *v, EngineImageType image_type)
Set the mouse cursor to look like a vehicle.
bool ShowCargoIconOverlay()
Test if cargo icon overlays should be drawn.
Functions related to the vehicle's GUIs.
uint GetVehicleHeight(VehicleType type)
Get the height of a single vehicle in the GUIs.
Definition vehicle_gui.h:73
WindowClass GetWindowClassForVehicleType(VehicleType vt)
Get WindowClass for vehicle list of given vehicle type.
Definition vehicle_gui.h:96
EngineImageType
Visualisation contexts of vehicles and engines.
@ InDepot
Vehicle drawn in depot.
@ Purchase
Vehicle drawn in purchase list, autoreplace gui, ...
PoolID< uint32_t, struct VehicleIDTag, 0xFF000, 0xFFFFF > VehicleID
The type all our vehicle IDs have.
VehicleType
Available vehicle types.
@ Ship
Ship vehicle type.
@ Invalid
Non-existing type of vehicle.
@ CompanyEnd
Last company-ownable type.
@ Aircraft
Aircraft vehicle type.
@ Road
Road vehicle type.
@ Train
Train vehicle type.
EnumIndexArray< T, VehicleType, Tend > VehicleTypeIndexArray
Array with VehicleType as index.
void BuildDepotVehicleList(VehicleType type, TileIndex tile, VehicleList *engines, VehicleList *wagons, bool individual_wagons)
Generate a list of vehicles inside a depot.
Functions and type for generating vehicle lists.
std::vector< const Vehicle * > VehicleList
A list of vehicles.
Definition vehiclelist.h:68
@ Depot
Index is the destination (station for hangar of aircraft, depot for others).
Definition vehiclelist.h:26
bool ScrollMainWindowToTile(TileIndex tile, bool instant)
Scrolls the viewport of the main window to a given location.
Functions related to (drawing on) viewports.
static RectPadding ScaleGUITrad(const RectPadding &r)
Scale a RectPadding to GUI zoom level.
Definition widget.cpp:49
@ WWT_PUSHTXTBTN
Normal push-button (no toggle button) with text caption.
@ WWT_IMGBTN
(Toggle) Button with image
Definition widget_type.h:41
@ WWT_PUSHIMGBTN
Normal push-button (no toggle button) with image caption.
@ NWID_HORIZONTAL
Horizontal container.
Definition widget_type.h:66
@ WWT_TEXTBTN
(Toggle) Button with text
Definition widget_type.h:44
@ WWT_STICKYBOX
Sticky box (at top-right of a window, after WWT_DEFSIZEBOX).
Definition widget_type.h:57
@ WWT_MATRIX
Grid of rows and columns.
Definition widget_type.h:50
@ WWT_SHADEBOX
Shade box (at top-right of a window, between WWT_DEBUGBOX and WWT_DEFSIZEBOX).
Definition widget_type.h:55
@ WWT_CAPTION
Window caption (window title between closebox and stickybox).
Definition widget_type.h:52
@ NWID_VSCROLLBAR
Vertical scrollbar.
Definition widget_type.h:76
@ NWID_VERTICAL
Vertical container.
Definition widget_type.h:68
@ WWT_CLOSEBOX
Close box (at top-left of a window).
Definition widget_type.h:60
@ NWID_HSCROLLBAR
Horizontal scrollbar.
Definition widget_type.h:75
@ WWT_RESIZEBOX
Resize box (normally at bottom-right of a window).
Definition widget_type.h:59
@ WWT_DEFSIZEBOX
Default window size box (at top-right of a window, between WWT_SHADEBOX and WWT_STICKYBOX).
Definition widget_type.h:56
@ NWID_SELECTION
Stacked widgets, only one visible at a time (eg in a panel with tabs).
Definition widget_type.h:71
@ SZSP_HORIZONTAL
Display plane with zero size vertically, and filling and resizing horizontally.
@ SZSP_NONE
Display plane with zero size in both directions (none filling and resizing).
@ EqualSize
Containers should keep all their (resizing) children equally large.
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:1242
Window * BringWindowToFrontById(WindowClass cls, WindowNumber number)
Find a window and make it the relative top-window on the screen.
Definition window.cpp:1326
SpecialMouseMode _special_mouse_mode
Mode of the mouse.
Definition window.cpp:91
Window * FindWindowById(WindowClass cls, WindowNumber number)
Find a window by its class and window number.
Definition window.cpp:1199
Functions, definitions and such used only by the GUI.
@ RightClick
Close the tooltip when releasing the right mouse button.
Definition window_gui.h:263
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:972
@ DragDrop
Drag&drop an object.
@ Automatic
Find a place automatically.
Definition window_gui.h:145
int WidgetID
Widget ID.
Definition window_type.h:21
EventState
State of handling an event.
@ Handled
The passed event is handled.
@ NotHandled
The passed event is not handled.
static constexpr WidgetID INVALID_WIDGET
An invalid widget index.
Definition window_type.h:24
Functions related to zooming.
int ScaleSpriteTrad(int value)
Scale traditional pixel dimensions to GUI zoom level, for drawing sprites.
Definition zoom_func.h:107