OpenTTD
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 "order_backup.h"
28 #include "zoom_func.h"
29 
30 #include "widgets/depot_widget.h"
31 
32 #include "table/strings.h"
33 
34 #include "safeguards.h"
35 
36 /*
37  * Since all depot window sizes aren't the same, we need to modify sizes a little.
38  * 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.
39  * How long they should be moved and for what window types are controlled in ShowDepotWindow()
40  */
41 
45  NWidget(WWT_CLOSEBOX, COLOUR_GREY),
46  NWidget(WWT_CAPTION, COLOUR_GREY, WID_D_CAPTION), SetDataTip(STR_DEPOT_CAPTION, STR_NULL),
47  NWidget(WWT_SHADEBOX, COLOUR_GREY),
48  NWidget(WWT_DEFSIZEBOX, COLOUR_GREY),
49  NWidget(WWT_STICKYBOX, COLOUR_GREY),
50  EndContainer(),
54  NWidget(NWID_SELECTION, INVALID_COLOUR, WID_D_SHOW_H_SCROLL),
55  NWidget(NWID_HSCROLLBAR, COLOUR_GREY, WID_D_H_SCROLL),
56  EndContainer(),
57  EndContainer(),
59  NWidget(WWT_IMGBTN, COLOUR_GREY, WID_D_SELL), SetDataTip(0x0, STR_NULL), SetResize(0, 1), SetFill(0, 1),
61  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),
62  EndContainer(),
63  NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_D_SELL_ALL), SetDataTip(0x0, STR_NULL),
64  NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_D_AUTOREPLACE), SetDataTip(0x0, STR_NULL),
65  EndContainer(),
66  NWidget(NWID_VSCROLLBAR, COLOUR_GREY, WID_D_V_SCROLL),
67  EndContainer(),
69  NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_D_BUILD), SetDataTip(0x0, STR_NULL), SetFill(1, 1), SetResize(1, 0),
70  NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_D_CLONE), SetDataTip(0x0, STR_NULL), SetFill(1, 1), SetResize(1, 0),
71  NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_D_LOCATION), SetDataTip(STR_BUTTON_LOCATION, STR_NULL), SetFill(1, 1), SetResize(1, 0),
72  NWidget(NWID_SELECTION, INVALID_COLOUR, WID_D_SHOW_RENAME), // rename button
73  NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_D_RENAME), SetDataTip(STR_BUTTON_RENAME, STR_DEPOT_RENAME_TOOLTIP), SetFill(1, 1), SetResize(1, 0),
74  EndContainer(),
75  NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_D_VEHICLE_LIST), SetDataTip(0x0, STR_NULL), SetFill(0, 1),
76  NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_D_STOP_ALL), SetDataTip(SPR_FLAG_VEH_STOPPED, STR_NULL), SetFill(0, 1),
77  NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_D_START_ALL), SetDataTip(SPR_FLAG_VEH_RUNNING, STR_NULL), SetFill(0, 1),
78  NWidget(WWT_RESIZEBOX, COLOUR_GREY),
79  EndContainer(),
80 };
81 
82 static WindowDesc _train_depot_desc(
83  WDP_AUTO, "depot_train", 362, 123,
85  0,
86  _nested_train_depot_widgets, lengthof(_nested_train_depot_widgets)
87 );
88 
89 static WindowDesc _road_depot_desc(
90  WDP_AUTO, "depot_roadveh", 316, 97,
92  0,
93  _nested_train_depot_widgets, lengthof(_nested_train_depot_widgets)
94 );
95 
96 static WindowDesc _ship_depot_desc(
97  WDP_AUTO, "depot_ship", 306, 99,
99  0,
100  _nested_train_depot_widgets, lengthof(_nested_train_depot_widgets)
101 );
102 
103 static WindowDesc _aircraft_depot_desc(
104  WDP_AUTO, "depot_aircraft", 332, 99,
106  0,
107  _nested_train_depot_widgets, lengthof(_nested_train_depot_widgets)
108 );
109 
110 extern void DepotSortList(VehicleList *list);
111 
120 void CcCloneVehicle(const CommandCost &result, TileIndex tile, uint32 p1, uint32 p2, uint32 cmd)
121 {
122  if (result.Failed()) return;
123 
124  const Vehicle *v = Vehicle::Get(_new_vehicle_id);
125 
127 }
128 
129 static void TrainDepotMoveVehicle(const Vehicle *wagon, VehicleID sel, const Vehicle *head)
130 {
131  const Vehicle *v = Vehicle::Get(sel);
132 
133  if (v == wagon) return;
134 
135  if (wagon == nullptr) {
136  if (head != nullptr) wagon = head->Last();
137  } else {
138  wagon = wagon->Previous();
139  if (wagon == nullptr) return;
140  }
141 
142  if (wagon == v) return;
143 
144  DoCommandP(v->tile, v->index | (_ctrl_pressed ? 1 : 0) << 20, wagon == nullptr ? INVALID_VEHICLE : wagon->index, CMD_MOVE_RAIL_VEHICLE | CMD_MSG(STR_ERROR_CAN_T_MOVE_VEHICLE));
145 }
146 
150 
159 {
160  switch (image_type) {
161  case EIT_IN_DEPOT: return _base_block_sizes_depot[type];
162  case EIT_PURCHASE: return _base_block_sizes_purchase[type];
163  default: NOT_REACHED();
164  }
165 }
166 
167 static void InitBlocksizeForVehicles(VehicleType type, EngineImageType image_type)
168 {
169  int max_extend_left = 0;
170  int max_extend_right = 0;
171  uint max_height = 0;
172 
173  for (const Engine *e : Engine::IterateType(type)) {
174  if (!e->IsEnabled()) continue;
175 
176  EngineID eid = e->index;
177  uint x, y;
178  int x_offs, y_offs;
179 
180  switch (type) {
181  default: NOT_REACHED();
182  case VEH_TRAIN: GetTrainSpriteSize( eid, x, y, x_offs, y_offs, image_type); break;
183  case VEH_ROAD: GetRoadVehSpriteSize( eid, x, y, x_offs, y_offs, image_type); break;
184  case VEH_SHIP: GetShipSpriteSize( eid, x, y, x_offs, y_offs, image_type); break;
185  case VEH_AIRCRAFT: GetAircraftSpriteSize(eid, x, y, x_offs, y_offs, image_type); break;
186  }
187  if (y > max_height) max_height = y;
188  if (-x_offs > max_extend_left) max_extend_left = -x_offs;
189  if ((int)x + x_offs > max_extend_right) max_extend_right = x + x_offs;
190  }
191 
192  int min_extend = ScaleGUITrad(16);
193  int max_extend = ScaleGUITrad(98);
194 
195  switch (image_type) {
196  case EIT_IN_DEPOT:
197  _base_block_sizes_depot[type].height = max<uint>(ScaleGUITrad(GetVehicleHeight(type)), max_height);
198  _base_block_sizes_depot[type].extend_left = Clamp(max_extend_left, min_extend, max_extend);
199  _base_block_sizes_depot[type].extend_right = Clamp(max_extend_right, min_extend, max_extend);
200  break;
201  case EIT_PURCHASE:
202  _base_block_sizes_purchase[type].height = max<uint>(ScaleGUITrad(GetVehicleHeight(type)), max_height);
203  _base_block_sizes_purchase[type].extend_left = Clamp(max_extend_left, min_extend, max_extend);
204  _base_block_sizes_purchase[type].extend_right = Clamp(max_extend_right, min_extend, max_extend);
205  break;
206 
207  default: NOT_REACHED();
208  }
209 }
210 
216 {
217  for (VehicleType vt = VEH_BEGIN; vt < VEH_COMPANY_END; vt++) {
218  InitBlocksizeForVehicles(vt, EIT_IN_DEPOT);
219  InitBlocksizeForVehicles(vt, EIT_PURCHASE);
220  }
221 
222  _consistent_train_width = TRAININFO_DEFAULT_VEHICLE_WIDTH;
223  bool first = true;
224  for (const Engine *e : Engine::IterateType(VEH_TRAIN)) {
225  if (!e->IsEnabled()) continue;
226 
227  uint w = TRAININFO_DEFAULT_VEHICLE_WIDTH;
228  if (e->GetGRF() != nullptr && is_custom_sprite(e->u.rail.image_index)) {
229  w = e->GetGRF()->traininfo_vehicle_width;
230  if (w != VEHICLEINFO_FULL_VEHICLE_WIDTH) {
231  /* Hopeless.
232  * This is a NewGRF vehicle that uses TRAININFO_DEFAULT_VEHICLE_WIDTH.
233  * If the vehicles are shorter than 8/8 we have fractional lengths, which are not consistent after rounding.
234  */
236  break;
237  }
238  }
239 
240  if (first) {
242  first = false;
243  } else if (w != _consistent_train_width) {
245  break;
246  }
247  }
248 }
249 
250 static void DepotSellAllConfirmationCallback(Window *w, bool confirmed);
251 const Sprite *GetAircraftSprite(EngineID engine);
252 
253 struct DepotWindow : Window {
254  VehicleID sel;
256  VehicleType type;
257  bool generate_list;
259  VehicleList vehicle_list;
260  VehicleList wagon_list;
261  uint unitnumber_digits;
262  uint num_columns;
264  Scrollbar *vscroll;
265 
266  DepotWindow(WindowDesc *desc, TileIndex tile, VehicleType type) : Window(desc)
267  {
268  assert(IsCompanyBuildableVehicleType(type)); // ensure that we make the call with a valid type
269 
270  this->sel = INVALID_VEHICLE;
271  this->vehicle_over = INVALID_VEHICLE;
272  this->generate_list = true;
273  this->hovered_widget = -1;
274  this->type = type;
275  this->num_columns = 1; // for non-trains this gets set in FinishInitNested()
276  this->unitnumber_digits = 2;
277 
278  this->CreateNestedTree();
279  this->hscroll = (this->type == VEH_TRAIN ? this->GetScrollbar(WID_D_H_SCROLL) : nullptr);
280  this->vscroll = this->GetScrollbar(WID_D_V_SCROLL);
281  /* Don't show 'rename button' of aircraft hangar */
282  this->GetWidget<NWidgetStacked>(WID_D_SHOW_RENAME)->SetDisplayedPlane(type == VEH_AIRCRAFT ? SZSP_NONE : 0);
283  /* Only train depots have a horizontal scrollbar and a 'sell chain' button */
284  if (type == VEH_TRAIN) this->GetWidget<NWidgetCore>(WID_D_MATRIX)->widget_data = 1 << MAT_COL_START;
285  this->GetWidget<NWidgetStacked>(WID_D_SHOW_H_SCROLL)->SetDisplayedPlane(type == VEH_TRAIN ? 0 : SZSP_HORIZONTAL);
286  this->GetWidget<NWidgetStacked>(WID_D_SHOW_SELL_CHAIN)->SetDisplayedPlane(type == VEH_TRAIN ? 0 : SZSP_NONE);
287  this->SetupWidgetData(type);
288  this->FinishInitNested(tile);
289 
290  this->owner = GetTileOwner(tile);
292  }
293 
294  ~DepotWindow()
295  {
298  }
299 
307  void DrawVehicleInDepot(const Vehicle *v, int left, int right, int y) const
308  {
309  bool free_wagon = false;
310  int sprite_y = y + (this->resize.step_height - ScaleGUITrad(GetVehicleHeight(v->type))) / 2;
311 
312  bool rtl = _current_text_dir == TD_RTL;
313  int image_left = rtl ? left + this->count_width : left + this->header_width;
314  int image_right = rtl ? right - this->header_width : right - this->count_width;
315 
316  switch (v->type) {
317  case VEH_TRAIN: {
318  const Train *u = Train::From(v);
319  free_wagon = u->IsFreeWagon();
320 
321  uint x_space = free_wagon ?
322  ScaleGUITrad(_consistent_train_width != 0 ? _consistent_train_width : TRAININFO_DEFAULT_VEHICLE_WIDTH) :
323  0;
324 
325  DrawTrainImage(u, image_left + (rtl ? 0 : x_space), image_right - (rtl ? x_space : 0), sprite_y - 1,
326  this->sel, EIT_IN_DEPOT, free_wagon ? 0 : this->hscroll->GetPosition(), this->vehicle_over);
327 
328  /* Length of consist in tiles with 1 fractional digit (rounded up) */
330  SetDParam(1, 1);
331  DrawString(rtl ? left + WD_FRAMERECT_LEFT : right - this->count_width, rtl ? left + this->count_width : right - WD_FRAMERECT_RIGHT, y + (this->resize.step_height - FONT_HEIGHT_SMALL) / 2, STR_TINY_BLACK_DECIMAL, TC_FROMSTRING, SA_RIGHT); // Draw the counter
332  break;
333  }
334 
335  case VEH_ROAD: DrawRoadVehImage( v, image_left, image_right, sprite_y, this->sel, EIT_IN_DEPOT); break;
336  case VEH_SHIP: DrawShipImage( v, image_left, image_right, sprite_y, this->sel, EIT_IN_DEPOT); break;
337  case VEH_AIRCRAFT: DrawAircraftImage(v, image_left, image_right, sprite_y, this->sel, EIT_IN_DEPOT); break;
338  default: NOT_REACHED();
339  }
340 
341  uint diff_x, diff_y;
342  if (v->IsGroundVehicle()) {
343  /* Arrange unitnumber and flag horizontally */
344  diff_x = this->flag_width + WD_FRAMERECT_LEFT;
345  diff_y = (this->resize.step_height - this->flag_height) / 2 - 2;
346  } else {
347  /* Arrange unitnumber and flag vertically */
348  diff_x = WD_FRAMERECT_LEFT;
350  }
351  int text_left = rtl ? right - this->header_width - 1 : left + diff_x;
352  int text_right = rtl ? right - diff_x : left + this->header_width - 1;
353 
354  if (free_wagon) {
355  DrawString(text_left, text_right, y + 2, STR_DEPOT_NO_ENGINE);
356  } else {
357  DrawSprite((v->vehstatus & VS_STOPPED) ? SPR_FLAG_VEH_STOPPED : SPR_FLAG_VEH_RUNNING, PAL_NONE, rtl ? right - this->flag_width : left + WD_FRAMERECT_LEFT, y + diff_y);
358 
359  SetDParam(0, v->unitnumber);
360  DrawString(text_left, text_right, y + 2, (uint16)(v->max_age - DAYS_IN_LEAP_YEAR) >= v->age ? STR_BLACK_COMMA : STR_RED_COMMA);
361  }
362  }
363 
364  void DrawWidget(const Rect &r, int widget) const override
365  {
366  if (widget != WID_D_MATRIX) return;
367 
368  bool rtl = _current_text_dir == TD_RTL;
369 
370  /* Set the row and number of boxes in each row based on the number of boxes drawn in the matrix */
371  const NWidgetCore *wid = this->GetWidget<NWidgetCore>(WID_D_MATRIX);
372 
373  /* Draw vertical separators at whole tiles.
374  * This only works in two cases:
375  * - All vehicles use VEHICLEINFO_FULL_VEHICLE_WIDTH as reference width.
376  * - All vehicles are 8/8. This cannot be checked for NewGRF, so instead we check for "all vehicles are original vehicles".
377  */
378  if (this->type == VEH_TRAIN && _consistent_train_width != 0) {
380  int col = _colour_gradient[wid->colour][4];
381  int image_left = rtl ? r.left + this->count_width : r.left + this->header_width;
382  int image_right = rtl ? r.right - this->header_width : r.right - this->count_width;
383  int first_line = w + (-this->hscroll->GetPosition()) % w;
384  if (rtl) {
385  for (int x = image_right - first_line; x >= image_left; x -= w) {
386  GfxDrawLine(x, r.top, x, r.bottom, col, 1, 3);
387  }
388  } else {
389  for (int x = image_left + first_line; x <= image_right; x += w) {
390  GfxDrawLine(x, r.top, x, r.bottom, col, 1, 3);
391  }
392  }
393  }
394 
395  uint16 rows_in_display = wid->current_y / wid->resize_y;
396 
397  uint16 num = this->vscroll->GetPosition() * this->num_columns;
398  int maxval = min((uint)this->vehicle_list.size(), num + (rows_in_display * this->num_columns));
399  int y;
400  for (y = r.top + 1; num < maxval; y += this->resize.step_height) { // Draw the rows
401  for (byte i = 0; i < this->num_columns && num < maxval; i++, num++) {
402  /* Draw all vehicles in the current row */
403  const Vehicle *v = this->vehicle_list[num];
404  if (this->num_columns == 1) {
405  this->DrawVehicleInDepot(v, r.left, r.right, y);
406  } else {
407  int x = r.left + (rtl ? (this->num_columns - i - 1) : i) * this->resize.step_width;
408  this->DrawVehicleInDepot(v, x, x + this->resize.step_width - 1, y);
409  }
410  }
411  }
412 
413  maxval = min((uint)this->vehicle_list.size() + (uint)this->wagon_list.size(), (this->vscroll->GetPosition() * this->num_columns) + (rows_in_display * this->num_columns));
414 
415  /* Draw the train wagons without an engine in front. */
416  for (; num < maxval; num++, y += this->resize.step_height) {
417  const Vehicle *v = this->wagon_list[num - this->vehicle_list.size()];
418  this->DrawVehicleInDepot(v, r.left, r.right, y);
419  }
420  }
421 
422  void SetStringParameters(int widget) const override
423  {
424  if (widget != WID_D_CAPTION) return;
425 
426  /* locate the depot struct */
427  TileIndex tile = this->window_number;
428  SetDParam(0, this->type);
429  SetDParam(1, (this->type == VEH_AIRCRAFT) ? GetStationIndex(tile) : GetDepotIndex(tile));
430  }
431 
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  /* In case of RTL the widgets are swapped as a whole */
448  if (_current_text_dir == TD_RTL) x = matrix_widget->current_x - x;
449 
450  uint xt = 0, xm = 0, ym = 0;
451  if (this->type == VEH_TRAIN) {
452  xm = x;
453  } else {
454  xt = x / this->resize.step_width;
455  xm = x % this->resize.step_width;
456  if (xt >= this->num_columns) return MODE_ERROR;
457  }
458  ym = y % this->resize.step_height;
459 
460  uint row = y / this->resize.step_height;
461  if (row >= this->vscroll->GetCapacity()) return MODE_ERROR;
462 
463  uint pos = ((row + this->vscroll->GetPosition()) * this->num_columns) + xt;
464 
465  if (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 -= ScaleGUITrad(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_width) return MODE_START_STOP;
504  break;
505 
506  case VEH_SHIP:
507  case VEH_AIRCRAFT:
508  if (xm <= this->flag_width && ym >= (uint)(FONT_HEIGHT_NORMAL + WD_PAR_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);
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
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 
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  uint flag_width;
648  uint flag_height;
649 
650  void UpdateWidgetSize(int widget, Dimension *size, const Dimension &padding, Dimension *fill, Dimension *resize) override
651  {
652  switch (widget) {
653  case WID_D_MATRIX: {
654  uint min_height = 0;
655 
656  if (this->type == VEH_TRAIN) {
657  SetDParamMaxValue(0, 1000, 0, FS_SMALL);
658  SetDParam(1, 1);
659  this->count_width = GetStringBoundingBox(STR_TINY_BLACK_DECIMAL).width + WD_FRAMERECT_LEFT + WD_FRAMERECT_RIGHT;
660  } else {
661  this->count_width = 0;
662  }
663 
664  SetDParamMaxDigits(0, this->unitnumber_digits);
665  Dimension unumber = GetStringBoundingBox(STR_BLACK_COMMA);
666  const Sprite *spr = GetSprite(SPR_FLAG_VEH_STOPPED, ST_NORMAL);
667  this->flag_width = UnScaleGUI(spr->width) + WD_FRAMERECT_RIGHT;
668  this->flag_height = UnScaleGUI(spr->height);
669 
670  if (this->type == VEH_TRAIN || this->type == VEH_ROAD) {
671  min_height = max<uint>(unumber.height + WD_MATRIX_TOP, UnScaleGUI(spr->height));
672  this->header_width = unumber.width + this->flag_width + WD_FRAMERECT_LEFT;
673  } else {
674  min_height = unumber.height + UnScaleGUI(spr->height) + WD_MATRIX_TOP + WD_PAR_VSEP_NORMAL + WD_MATRIX_BOTTOM;
675  this->header_width = max<uint>(unumber.width, this->flag_width) + WD_FRAMERECT_RIGHT;
676  }
677  int base_width = this->count_width + this->header_width;
678 
679  resize->height = max<uint>(GetVehicleImageCellSize(this->type, EIT_IN_DEPOT).height, min_height);
680  if (this->type == VEH_TRAIN) {
681  resize->width = 1;
682  size->width = base_width + 2 * ScaleGUITrad(29); // about 2 parts
683  size->height = resize->height * 6;
684  } else {
685  resize->width = base_width + GetVehicleImageCellSize(this->type, EIT_IN_DEPOT).extend_left + GetVehicleImageCellSize(this->type, EIT_IN_DEPOT).extend_right;
686  size->width = resize->width * (this->type == VEH_ROAD ? 5 : 3);
687  size->height = resize->height * (this->type == VEH_ROAD ? 5 : 3);
688  }
689  fill->width = resize->width;
690  fill->height = resize->height;
691  break;
692  }
693  }
694  }
695 
701  void OnInvalidateData(int data = 0, bool gui_scope = true) override
702  {
703  this->generate_list = true;
704  }
705 
706  void OnPaint() override
707  {
708  if (this->generate_list) {
709  /* Generate the vehicle list
710  * It's ok to use the wagon pointers for non-trains as they will be ignored */
711  BuildDepotVehicleList(this->type, this->window_number, &this->vehicle_list, &this->wagon_list);
712  this->generate_list = false;
713  DepotSortList(&this->vehicle_list);
714 
715  uint new_unitnumber_digits = GetUnitNumberDigits(this->vehicle_list);
716  /* Only increase the size; do not decrease to prevent constant changes */
717  if (this->unitnumber_digits < new_unitnumber_digits) {
718  this->unitnumber_digits = new_unitnumber_digits;
719  this->ReInit();
720  }
721  }
722 
723  /* determine amount of items for scroller */
724  if (this->type == VEH_TRAIN) {
725  uint max_width = ScaleGUITrad(VEHICLEINFO_FULL_VEHICLE_WIDTH);
726  for (uint num = 0; num < this->vehicle_list.size(); num++) {
727  uint width = 0;
728  for (const Train *v = Train::From(this->vehicle_list[num]); v != nullptr; v = v->Next()) {
729  width += v->GetDisplayImageWidth();
730  }
731  max_width = max(max_width, width);
732  }
733  /* Always have 1 empty row, so people can change the setting of the train */
734  this->vscroll->SetCount((uint)this->vehicle_list.size() + (uint)this->wagon_list.size() + 1);
735  /* 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 */
736  this->hscroll->SetCount(max_width + ScaleGUITrad(2 * VEHICLEINFO_FULL_VEHICLE_WIDTH + 1));
737  } else {
738  this->vscroll->SetCount(CeilDiv((uint)this->vehicle_list.size(), this->num_columns));
739  }
740 
741  /* Setup disabled buttons. */
742  TileIndex tile = this->window_number;
746  WID_D_SELL,
749  WID_D_BUILD,
750  WID_D_CLONE,
751  WID_D_RENAME,
754 
755  this->DrawWidgets();
756  }
757 
758  void OnClick(Point pt, int widget, int click_count) override
759  {
760  switch (widget) {
761  case WID_D_MATRIX: { // List
762  NWidgetBase *nwi = this->GetWidget<NWidgetBase>(WID_D_MATRIX);
763  this->DepotClick(pt.x - nwi->pos_x, pt.y - nwi->pos_y);
764  break;
765  }
766 
767  case WID_D_BUILD: // Build vehicle
769  ShowBuildVehicleWindow(this->window_number, this->type);
770  break;
771 
772  case WID_D_CLONE: // Clone button
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 {
785  }
786  break;
787 
788  case WID_D_LOCATION:
789  if (_ctrl_pressed) {
791  } else {
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  DoCommandP(this->window_number, (widget == WID_D_START_ALL ? (1 << 0) : 0), vli.Pack(), CMD_MASS_START_STOP);
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.size() != 0 || this->wagon_list.size() != 0) {
812  TileIndex tile = this->window_number;
813  byte vehtype = this->type;
814 
815  SetDParam(0, vehtype);
816  SetDParam(1, (vehtype == VEH_AIRCRAFT) ? GetStationIndex(tile) : GetDepotIndex(tile));
817  ShowQuery(
818  STR_DEPOT_CAPTION,
819  STR_DEPOT_SELL_CONFIRMATION_TEXT,
820  this,
821  DepotSellAllConfirmationCallback
822  );
823  }
824  break;
825 
826  case WID_D_VEHICLE_LIST:
827  ShowVehicleListWindow(GetTileOwner(this->window_number), this->type, (TileIndex)this->window_number);
828  break;
829 
830  case WID_D_AUTOREPLACE:
831  DoCommandP(this->window_number, this->type, 0, CMD_DEPOT_MASS_AUTOREPLACE);
832  break;
833 
834  }
835  }
836 
837  void OnQueryTextFinished(char *str) override
838  {
839  if (str == nullptr) return;
840 
841  /* Do depot renaming */
842  DoCommandP(0, GetDepotIndex(this->window_number), 0, CMD_RENAME_DEPOT | CMD_MSG(STR_ERROR_CAN_T_RENAME_DEPOT), nullptr, str);
843  }
844 
845  bool OnRightClick(Point pt, int widget) override
846  {
847  if (widget != WID_D_MATRIX) return false;
848 
849  GetDepotVehiclePtData gdvp = { nullptr, nullptr };
850  const Vehicle *v = nullptr;
851  NWidgetBase *nwi = this->GetWidget<NWidgetBase>(WID_D_MATRIX);
852  DepotGUIAction mode = this->GetVehicleFromDepotWndPt(pt.x - nwi->pos_x, pt.y - nwi->pos_y, &v, &gdvp);
853 
854  if (this->type == VEH_TRAIN) v = gdvp.wagon;
855 
856  if (v == nullptr || mode != MODE_DRAG_VEHICLE) return false;
857 
858  CargoArray capacity, loaded;
859 
860  /* Display info for single (articulated) vehicle, or for whole chain starting with selected vehicle */
861  bool whole_chain = (this->type == VEH_TRAIN && _ctrl_pressed);
862 
863  /* loop through vehicle chain and collect cargoes */
864  uint num = 0;
865  for (const Vehicle *w = v; w != nullptr; w = w->Next()) {
866  if (w->cargo_cap > 0 && w->cargo_type < NUM_CARGO) {
867  capacity[w->cargo_type] += w->cargo_cap;
868  loaded [w->cargo_type] += w->cargo.StoredCount();
869  }
870 
871  if (w->type == VEH_TRAIN && !w->HasArticulatedPart()) {
872  num++;
873  if (!whole_chain) break;
874  }
875  }
876 
877  /* Build tooltipstring */
878  static char details[1024];
879  details[0] = '\0';
880  char *pos = details;
881 
882  for (CargoID cargo_type = 0; cargo_type < NUM_CARGO; cargo_type++) {
883  if (capacity[cargo_type] == 0) continue;
884 
885  SetDParam(0, cargo_type); // {CARGO} #1
886  SetDParam(1, loaded[cargo_type]); // {CARGO} #2
887  SetDParam(2, cargo_type); // {SHORTCARGO} #1
888  SetDParam(3, capacity[cargo_type]); // {SHORTCARGO} #2
889  pos = GetString(pos, STR_DEPOT_VEHICLE_TOOLTIP_CARGO, lastof(details));
890  }
891 
892  /* Show tooltip window */
893  uint64 args[2];
894  args[0] = (whole_chain ? num : v->engine_type);
895  args[1] = (uint64)(size_t)details;
896  GuiShowTooltips(this, whole_chain ? STR_DEPOT_VEHICLE_TOOLTIP_CHAIN : STR_DEPOT_VEHICLE_TOOLTIP, 2, args, TCC_RIGHT_CLICK);
897 
898  return true;
899  }
900 
906  bool OnVehicleSelect(const Vehicle *v) override
907  {
908  if (_ctrl_pressed) {
909  /* Share-clone, do not open new viewport, and keep tool active */
910  DoCommandP(this->window_number, v->index, 1, CMD_CLONE_VEHICLE | CMD_MSG(STR_ERROR_CAN_T_BUY_TRAIN + v->type), nullptr);
911  } else {
912  /* Copy-clone, open viewport for new vehicle, and deselect the tool (assume player wants to changs things on new vehicle) */
913  if (DoCommandP(this->window_number, v->index, 0, CMD_CLONE_VEHICLE | CMD_MSG(STR_ERROR_CAN_T_BUY_TRAIN + v->type), CcCloneVehicle)) {
915  }
916  }
917 
918  return true;
919  }
920 
921  void OnPlaceObjectAbort() override
922  {
923  /* abort clone */
924  this->RaiseWidget(WID_D_CLONE);
926 
927  /* abort drag & drop */
928  this->sel = INVALID_VEHICLE;
929  this->vehicle_over = INVALID_VEHICLE;
931 
932  if (this->hovered_widget != -1) {
933  this->SetWidgetLoweredState(this->hovered_widget, false);
934  this->SetWidgetDirty(this->hovered_widget);
935  this->hovered_widget = -1;
936  }
937  }
938 
939  void OnMouseDrag(Point pt, int widget) override
940  {
941  if (this->sel == INVALID_VEHICLE) return;
942  if (widget != this->hovered_widget) {
943  if (this->hovered_widget == WID_D_SELL || this->hovered_widget == WID_D_SELL_CHAIN) {
944  this->SetWidgetLoweredState(this->hovered_widget, false);
945  this->SetWidgetDirty(this->hovered_widget);
946  }
947  this->hovered_widget = widget;
948  if (this->hovered_widget == WID_D_SELL || this->hovered_widget == WID_D_SELL_CHAIN) {
949  this->SetWidgetLoweredState(this->hovered_widget, true);
950  this->SetWidgetDirty(this->hovered_widget);
951  }
952  }
953  if (this->type != VEH_TRAIN) return;
954 
955  /* A rail vehicle is dragged.. */
956  if (widget != WID_D_MATRIX) { // ..outside of the depot matrix.
957  if (this->vehicle_over != INVALID_VEHICLE) {
958  this->vehicle_over = INVALID_VEHICLE;
960  }
961  return;
962  }
963 
964  NWidgetBase *matrix = this->GetWidget<NWidgetBase>(widget);
965  const Vehicle *v = nullptr;
966  GetDepotVehiclePtData gdvp = {nullptr, nullptr};
967 
968  if (this->GetVehicleFromDepotWndPt(pt.x - matrix->pos_x, pt.y - matrix->pos_y, &v, &gdvp) != MODE_DRAG_VEHICLE) return;
969 
970  VehicleID new_vehicle_over = INVALID_VEHICLE;
971  if (gdvp.head != nullptr) {
972  if (gdvp.wagon == nullptr && gdvp.head->Last()->index != this->sel) { // ..at the end of the train.
973  /* 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
974  * destination inside a train. This head index is then used to indicate that a wagon is inserted at
975  * the end of the train.
976  */
977  new_vehicle_over = gdvp.head->index;
978  } else if (gdvp.wagon != nullptr && gdvp.head != gdvp.wagon &&
979  gdvp.wagon->index != this->sel &&
980  gdvp.wagon->Previous()->index != this->sel) { // ..over an existing wagon.
981  new_vehicle_over = gdvp.wagon->index;
982  }
983  }
984 
985  if (this->vehicle_over == new_vehicle_over) return;
986 
987  this->vehicle_over = new_vehicle_over;
988  this->SetWidgetDirty(widget);
989  }
990 
991  void OnDragDrop(Point pt, int widget) override
992  {
993  switch (widget) {
994  case WID_D_MATRIX: {
995  const Vehicle *v = nullptr;
996  VehicleID sel = this->sel;
997 
998  this->sel = INVALID_VEHICLE;
999  this->SetDirty();
1000 
1001  NWidgetBase *nwi = this->GetWidget<NWidgetBase>(WID_D_MATRIX);
1002  if (this->type == VEH_TRAIN) {
1003  GetDepotVehiclePtData gdvp = { nullptr, nullptr };
1004 
1005  if (this->GetVehicleFromDepotWndPt(pt.x - nwi->pos_x, pt.y - nwi->pos_y, &v, &gdvp) == MODE_DRAG_VEHICLE && sel != INVALID_VEHICLE) {
1006  if (gdvp.wagon != nullptr && gdvp.wagon->index == sel && _ctrl_pressed) {
1007  DoCommandP(Vehicle::Get(sel)->tile, Vehicle::Get(sel)->index, true,
1008  CMD_REVERSE_TRAIN_DIRECTION | CMD_MSG(STR_ERROR_CAN_T_REVERSE_DIRECTION_RAIL_VEHICLE));
1009  } else if (gdvp.wagon == nullptr || gdvp.wagon->index != sel) {
1010  this->vehicle_over = INVALID_VEHICLE;
1011  TrainDepotMoveVehicle(gdvp.wagon, sel, gdvp.head);
1012  } else if (gdvp.head != nullptr && gdvp.head->IsFrontEngine()) {
1013  ShowVehicleViewWindow(gdvp.head);
1014  }
1015  }
1016  } else if (this->GetVehicleFromDepotWndPt(pt.x - nwi->pos_x, pt.y - nwi->pos_y, &v, nullptr) == MODE_DRAG_VEHICLE && v != nullptr && sel == v->index) {
1018  }
1019  break;
1020  }
1021 
1022  case WID_D_SELL: case WID_D_SELL_CHAIN: {
1023  if (this->IsWidgetDisabled(widget)) return;
1024  if (this->sel == INVALID_VEHICLE) return;
1025 
1026  this->HandleButtonClick(widget);
1027 
1028  const Vehicle *v = Vehicle::Get(this->sel);
1029  this->sel = INVALID_VEHICLE;
1030  this->SetDirty();
1031 
1032  int sell_cmd = (v->type == VEH_TRAIN && (widget == WID_D_SELL_CHAIN || _ctrl_pressed)) ? 1 : 0;
1033  DoCommandP(v->tile, v->index | sell_cmd << 20 | MAKE_ORDER_BACKUP_FLAG, 0, GetCmdSellVeh(v->type));
1034  break;
1035  }
1036 
1037  default:
1038  this->sel = INVALID_VEHICLE;
1039  this->SetDirty();
1040  break;
1041  }
1042  this->hovered_widget = -1;
1043  _cursor.vehchain = false;
1044  }
1045 
1046  void OnTimeout() override
1047  {
1048  if (!this->IsWidgetDisabled(WID_D_SELL)) {
1049  this->RaiseWidget(WID_D_SELL);
1050  this->SetWidgetDirty(WID_D_SELL);
1051  }
1052  if (this->nested_array[WID_D_SELL] != nullptr && !this->IsWidgetDisabled(WID_D_SELL_CHAIN)) {
1055  }
1056  }
1057 
1058  void OnResize() override
1059  {
1060  this->vscroll->SetCapacityFromWidget(this, WID_D_MATRIX);
1061  NWidgetCore *nwi = this->GetWidget<NWidgetCore>(WID_D_MATRIX);
1062  if (this->type == VEH_TRAIN) {
1063  this->hscroll->SetCapacity(nwi->current_x - this->header_width - this->count_width);
1064  } else {
1065  this->num_columns = nwi->current_x / nwi->resize_x;
1066  }
1067  }
1068 
1070  {
1071  if (this->sel != INVALID_VEHICLE) {
1072  _cursor.vehchain = _ctrl_pressed;
1074  return ES_HANDLED;
1075  }
1076 
1077  return ES_NOT_HANDLED;
1078  }
1079 };
1080 
1081 static void DepotSellAllConfirmationCallback(Window *win, bool confirmed)
1082 {
1083  if (confirmed) {
1084  DepotWindow *w = (DepotWindow*)win;
1085  TileIndex tile = w->window_number;
1086  byte vehtype = w->type;
1087  DoCommandP(tile, vehtype, 0, CMD_DEPOT_SELL_ALL_VEHICLES);
1088  }
1089 }
1090 
1097 {
1098  if (BringWindowToFrontById(WC_VEHICLE_DEPOT, tile) != nullptr) return;
1099 
1100  WindowDesc *desc;
1101  switch (type) {
1102  default: NOT_REACHED();
1103  case VEH_TRAIN: desc = &_train_depot_desc; break;
1104  case VEH_ROAD: desc = &_road_depot_desc; break;
1105  case VEH_SHIP: desc = &_ship_depot_desc; break;
1106  case VEH_AIRCRAFT: desc = &_aircraft_depot_desc; break;
1107  }
1108 
1109  new DepotWindow(desc, tile, type);
1110 }
1111 
1117 {
1118  DepotWindow *w;
1119 
1120  /* If we haven't got any vehicles on the mouse pointer, we haven't got any highlighted in any depots either
1121  * If that is the case, we can skip looping though the windows and save time
1122  */
1123  if (_special_mouse_mode != WSM_DRAGDROP) return;
1124 
1125  w = dynamic_cast<DepotWindow*>(FindWindowById(WC_VEHICLE_DEPOT, v->tile));
1126  if (w != nullptr) {
1127  if (w->sel == v->index) ResetObjectToPlace();
1128  }
1129 }
EventState
State of handling an event.
Definition: window_type.h:711
Colours colour
Colour of this widget.
Definition: widget_type.h:301
Functions related to OTTD&#39;s strings.
void OnDragDrop(Point pt, int widget) override
A dragged &#39;object&#39; has been released.
Definition: depot_gui.cpp:991
Last company-ownable type.
Definition: vehicle_type.h:29
Road vehicle states.
Date max_age
Maximum age.
Definition: vehicle_base.h:257
Vehicle * Previous() const
Get the previous vehicle of this vehicle.
Definition: vehicle_base.h:586
Vehicle is stopped by the player.
Definition: vehicle_base.h:31
Normal push-button (no toggle button) with image caption.
Definition: widget_type.h:103
rename a depot
Definition: command_type.h:247
static const uint MAX_LENGTH_DEPOT_NAME_CHARS
The maximum length of a depot name in characters including &#39;\0&#39;.
Definition: depot_type.h:16
void OnClick(Point pt, int widget, int click_count) override
A click with the left mouse button has been made on the window.
Definition: depot_gui.cpp:758
The information about a vehicle list.
Definition: vehiclelist.h:29
ResizeInfo resize
Resize information.
Definition: window_gui.h:322
static NWidgetPart SetResize(int16 dx, int16 dy)
Widget part function for setting the resize step.
Definition: widget_type.h:928
static uint _consistent_train_width
Whether trains of all lengths are consistently scaled. Either TRAININFO_DEFAULT_VEHICLE_WIDTH, VEHICLEINFO_FULL_VEHICLE_WIDTH, or 0.
Definition: depot_gui.cpp:149
bool OnVehicleSelect(const Vehicle *v) override
Clones a vehicle.
Definition: depot_gui.cpp:906
uint resize_x
Horizontal resize step (0 means not resizable).
Definition: widget_type.h:164
List of vehicles.
Definition: depot_widget.h:30
void SetWidgetLoweredState(byte widget_index, bool lowered_stat)
Sets the lowered/raised status of a widget.
Definition: window_gui.h:453
static int UnScaleGUI(int value)
Short-hand to apply GUI zoom level.
Definition: zoom_func.h:66
void DrawShipImage(const Vehicle *v, int left, int right, int y, VehicleID selection, EngineImageType image_type)
Draws an image of a ship.
Definition: ship_gui.cpp:32
Lowest bit of the number of columns.
Definition: widget_type.h:25
High level window description.
Definition: window_gui.h:166
Functions and type for generating vehicle lists.
int left
x position of left edge of the window
Definition: window_gui.h:317
bool vehchain
vehicle chain is dragged
Definition: gfx_type.h:144
SpecialMouseMode _special_mouse_mode
Mode of the mouse.
Definition: window.cpp:80
bool VehicleClicked(const Vehicle *v)
Dispatch a "vehicle selected" event if any window waits for it.
Train vehicle type.
Definition: vehicle_type.h:24
void DrawWidgets() const
Paint all widgets of a window.
Definition: widget.cpp:602
static Titem * Get(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:291
Scrollbar data structure.
Definition: widget_type.h:587
Build button.
Definition: depot_widget.h:25
Base for the train class.
void SetWidgetDirty(byte widget_index) const
Invalidate a widget, i.e.
Definition: window.cpp:597
Normal amount of vertical space between two paragraphs of text.
Definition: window_gui.h:137
Dragging an object.
Definition: window_gui.h:906
Horizontal container.
Definition: widget_type.h:73
void ShowDepotWindow(TileIndex tile, VehicleType type)
Opens a depot window.
Definition: depot_gui.cpp:1096
Window * FindWindowById(WindowClass cls, WindowNumber number)
Find a window by its class and window number.
Definition: window.cpp:1130
The passed event is not handled.
Definition: window_type.h:713
byte _colour_gradient[COLOUR_END][8]
All 16 colour gradients 8 colours per gradient from darkest (0) to lightest (7)
Definition: gfx.cpp:52
void CDECL SetWidgetsDisabledState(bool disab_stat, int widgets,...)
Sets the enabled/disabled status of a list of widgets.
Definition: window.cpp:536
Data structure describing a sprite.
Definition: spritecache.h:16
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:1119
static int ScaleGUITrad(int value)
Scale traditional pixel dimensions to GUI zoom level.
Definition: zoom_func.h:76
Ship vehicle type.
Definition: vehicle_type.h:26
Depot view; Window numbers:
Definition: window_type.h:344
Maximal number of cargo types in a game.
Definition: cargo_type.h:64
void DeleteDepotHighlightOfVehicle(const Vehicle *v)
Removes the highlight of a vehicle in a depot window.
Definition: depot_gui.cpp:1116
VehicleType
Available vehicle types.
Definition: vehicle_type.h:21
void GuiShowTooltips(Window *parent, StringID str, uint paramcount, const uint64 params[], TooltipCloseCondition close_tooltip)
Shows a tooltip.
Definition: misc_gui.cpp:764
uint extend_right
Extend of the cell to the right.
Definition: vehicle_gui.h:80
Rename button.
Definition: depot_widget.h:29
void OnMouseDrag(Point pt, int widget) override
An &#39;object&#39; is being dragged at the provided position, highlight the target if possible.
Definition: depot_gui.cpp:939
Functions related to vehicles.
Resize box (normally at bottom-right of a window)
Definition: widget_type.h:66
Build vehicle; Window numbers:
Definition: window_type.h:376
Vehicle data structure.
Definition: vehicle_base.h:210
Base for all depots (except hangars)
VehicleCellSize GetVehicleImageCellSize(VehicleType type, EngineImageType image_type)
Get the GUI cell size for a vehicle image.
Definition: depot_gui.cpp:158
void ToggleWidgetLoweredState(byte widget_index)
Invert the lowered/raised status of a widget.
Definition: window_gui.h:463
uint height
Vehicle cell height.
Definition: vehicle_gui.h:78
Tindex index
Index of this pool item.
Definition: pool_type.hpp:189
void OnTimeout() override
Called when this window&#39;s timeout has been reached.
Definition: depot_gui.cpp:1046
Close box (at top-left of a window)
Definition: widget_type.h:67
Offset at top of a matrix cell.
Definition: window_gui.h:78
void SetupWidgetData(VehicleType type)
Function to set up vehicle specific widgets (mainly sprites and strings).
Definition: depot_gui.cpp:589
Sell all button.
Definition: depot_widget.h:19
void BuildDepotVehicleList(VehicleType type, TileIndex tile, VehicleList *engines, VehicleList *wagons, bool individual_wagons)
Generate a list of vehicles inside a depot.
Definition: vehiclelist.cpp:69
Base for aircraft.
#define lastof(x)
Get the last element of an fixed size array.
Definition: depend.cpp:48
void ReInit(int rx=0, int ry=0)
Re-initialize a window, and optionally change its size.
Definition: window.cpp:995
uint num_columns
Number of columns.
Definition: depot_gui.cpp:262
Stuff related to the text buffer GUI.
T * GetFirstEnginePart()
Get the first part of an articulated engine.
Common return value for all commands.
Definition: command_type.h:23
Vehicle drawn in purchase list, autoreplace gui, ...
Definition: vehicle_type.h:90
Vertical scrollbar.
Definition: depot_widget.h:22
static const VehicleID INVALID_VEHICLE
Constant representing a non-existing vehicle.
Definition: vehicle_type.h:55
Vehicle drawn in depot.
Definition: vehicle_type.h:87
static T max(const T a, const T b)
Returns the maximum of two values.
Definition: math_func.hpp:24
byte vehstatus
Status.
Definition: vehicle_base.h:315
EngineImageType
Visualisation contexts of vehicles and engines.
Definition: vehicle_type.h:85
void RaiseWidget(byte widget_index)
Marks a widget as raised.
Definition: window_gui.h:483
static Train * From(Vehicle *v)
Converts a Vehicle to SpecializedVehicle with type checking.
void CreateNestedTree(bool fill_nested=true)
Perform the first part of the initialization of a nested widget tree.
Definition: window.cpp:1828
static const uint TILE_SIZE
Tile size in world coordinates.
Definition: tile_type.h:13
Types related to the depot widgets.
Start all button.
Definition: depot_widget.h:32
Functions, definitions and such used only by the GUI.
void SetCapacity(int capacity)
Set the capacity of visible elements.
Definition: widget_type.h:684
void SetCount(int num)
Sets the number of elements in the list.
Definition: widget_type.h:668
Partial widget specification to allow NWidgets to be written nested.
Definition: widget_type.h:908
Functions related to (drawing on) viewports.
void DrawAircraftImage(const Vehicle *v, int left, int right, int y, VehicleID selection, EngineImageType image_type)
Draws an image of an aircraft.
static VehicleCellSize _base_block_sizes_purchase[VEH_COMPANY_END]
Cell size for vehicle images in the purchase list.
Definition: depot_gui.cpp:148
Data structure for an opened window.
Definition: window_gui.h:276
bool _ctrl_pressed
Is Ctrl pressed?
Definition: gfx.cpp:35
void FinishInitNested(WindowNumber window_number=0)
Perform the second part of the initialization of a nested widget tree.
Definition: window.cpp:1844
dragging items in the depot windows
static bool IsTileOwner(TileIndex tile, Owner owner)
Checks if a tile belongs to the given owner.
Definition: tile_map.h:214
enable the &#39;Default&#39; button ("\0" is returned)
Definition: textbuf_gui.h:21
static const uint32 MAKE_ORDER_BACKUP_FLAG
Flag to pass to the vehicle construction command when an order should be preserved.
Definition: order_backup.h:29
NWidgetBase ** nested_array
Array of pointers into the tree. Do not access directly, use Window::GetWidget() instead.
Definition: window_gui.h:330
void OnInvalidateData(int data=0, bool gui_scope=true) override
Some data on this window has become invalid.
Definition: depot_gui.cpp:701
Offset at bottom of a matrix cell.
Definition: window_gui.h:79
UnitID unitnumber
unit number, for display purposes only
Definition: vehicle_base.h:289
#define FONT_HEIGHT_SMALL
Height of characters in the small (FS_SMALL) font.
Definition: gfx_func.h:173
Default window size box (at top-right of a window, between WWT_SHADEBOX and WWT_STICKYBOX) ...
Definition: widget_type.h:63
Location button.
Definition: depot_widget.h:27
bool IsWidgetLowered(byte widget_index) const
Gets the lowered state of a widget.
Definition: window_gui.h:493
void ShowQuery(StringID caption, StringID message, Window *parent, QueryCallbackProc *callback)
Show a modal confirmation window with standard &#39;yes&#39; and &#39;no&#39; buttons The window is aligned to the ce...
Definition: misc_gui.cpp:1260
static const NWidgetPart _nested_train_depot_widgets[]
Nested widget definition for train depots.
Definition: depot_gui.cpp:43
uint current_y
Current vertical size (after resizing).
Definition: widget_type.h:173
uint32 VehicleID
The type all our vehicle IDs have.
Definition: vehicle_type.h:16
static Owner GetTileOwner(TileIndex tile)
Returns the owner of a tile.
Definition: tile_map.h:178
#define FONT_HEIGHT_NORMAL
Height of characters in the normal (FS_NORMAL) font.
Definition: gfx_func.h:176
static NWidgetPart SetDataTip(uint32 data, StringID tip)
Widget part function for setting the data and tooltip.
Definition: widget_type.h:1012
T * Next() const
Get next vehicle in the chain.
Display plane with zero size vertically, and filling and resizing horizontally.
Definition: widget_type.h:387
Definition of base types and functions in a cross-platform compatible way.
int hovered_widget
Index of the widget being hovered during drag/drop. -1 if no drag is in progress. ...
Definition: depot_gui.cpp:258
the length of the string is counted in characters
Definition: textbuf_gui.h:22
void DrawTrainImage(const Train *v, int left, int right, int y, VehicleID selection, EngineImageType image_type, int skip, VehicleID drag_dest)
Draws an image of a whole train.
Definition: train_gui.cpp:92
Show rename panel.
Definition: depot_widget.h:28
A number of safeguards to prevent using unsafe methods.
Horizontal scrollbar.
Definition: depot_widget.h:24
Normal push-button (no toggle button) with text caption.
Definition: widget_type.h:102
static uint CeilDiv(uint a, uint b)
Computes ceil(a / b) for non-negative a and b.
Definition: math_func.hpp:314
bool IsWidgetDisabled(byte widget_index) const
Gets the enabled/disabled status of a widget.
Definition: window_gui.h:421
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 StartStopVehicle(const Vehicle *v, bool texteffect)
Executes CMD_START_STOP_VEHICLE for given vehicle.
Horizontal scrollbar.
Definition: widget_type.h:81
uint step_height
Step-size of height resize changes.
Definition: window_gui.h:218
const Scrollbar * GetScrollbar(uint widnum) const
Return the Scrollbar to a widget index.
Definition: window.cpp:309
int pos_x
Horizontal position of top-left corner of the widget in the window.
Definition: widget_type.h:175
EventState OnCTRLStateChange() override
The state of the control key has changed.
Definition: depot_gui.cpp:1069
void SetDParamMaxDigits(uint n, uint count, FontSize size)
Set DParam n to some number that is suitable for string size computations.
Definition: strings.cpp:120
Functions related to order backups.
bool IsFrontEngine() const
Check if the vehicle is a front engine.
Definition: vehicle_base.h:881
TileIndex tile
Current tile index.
Definition: vehicle_base.h:228
Show sell chain panel.
Definition: depot_widget.h:17
void OnPaint() override
The window must be repainted.
Definition: depot_gui.cpp:706
static NWidgetPart NWidget(WidgetType tp, Colours col, int16 idx=-1)
Widget part function for starting a new &#39;real&#39; widget.
Definition: widget_type.h:1112
Matrix of vehicles.
Definition: depot_widget.h:21
Baseclass for nested widgets.
Definition: widget_type.h:124
int DrawString(int left, int right, int top, const char *str, TextColour colour, StringAlignment align, bool underline, FontSize fontsize)
Draw string, possibly truncated to make it fit in its allocated space.
Definition: gfx.cpp:498
void ShowVehicleViewWindow(const Vehicle *v)
Shows the vehicle view window of the given vehicle.
void DrawRoadVehImage(const Vehicle *v, int left, int right, int y, VehicleID selection, EngineImageType image_type, int skip)
Draws an image of a road vehicle chain.
bool DoCommandP(const CommandContainer *container, bool my_cmd)
Shortcut for the long DoCommandP when having a container with the data.
Definition: command.cpp:532
#define lengthof(x)
Return the length of an fixed size array.
Definition: depend.cpp:40
uint resize_y
Vertical resize step (0 means not resizable).
Definition: widget_type.h:165
Grid of rows and columns.
Definition: widget_type.h:57
static T min(const T a, const T b)
Returns the minimum of two values.
Definition: math_func.hpp:40
Display plane with zero size in both directions (none filling and resizing).
Definition: widget_type.h:388
Clone button.
Definition: depot_widget.h:26
void UpdateWidgetSize(int widget, Dimension *size, const Dimension &padding, Dimension *fill, Dimension *resize) override
Update size and resize step of a widget in the window.
Definition: depot_gui.cpp:650
Functions to cache sprites in memory.
bool Failed() const
Did this command fail?
Definition: command_type.h:159
static DepotID GetDepotIndex(TileIndex t)
Get the index of which depot is attached to the tile.
Definition: depot_map.h:52
static const int WIDGET_LIST_END
indicate the end of widgets&#39; list for vararg functions
Definition: widget_type.h:20
Scrollbar * hscroll
Only for trains.
Definition: depot_gui.cpp:263
uint16 height
Height of the sprite.
Definition: spritecache.h:17
static T Clamp(const T a, const T min, const T max)
Clamp a value between an interval.
Definition: math_func.hpp:137
The most basic (normal) sprite.
Definition: gfx_type.h:297
force the autoreplace to take action in a given depot
Definition: command_type.h:315
void SetStringParameters(int widget) const override
Initialize string parameters for a widget.
Definition: depot_gui.cpp:422
void SetDirty() const
Mark entire window as dirty (in need of re-paint)
Definition: window.cpp:984
void ShowExtraViewPortWindow(TileIndex tile=INVALID_TILE)
Show a new Extra Viewport window.
static void Reset(TileIndex tile=INVALID_TILE, bool from_gui=true)
Reset the OrderBackups from GUI/game logic.
&#39;Train&#39; is either a loco or a wagon.
Definition: train.h:85
Dimension GetStringBoundingBox(const char *str, FontSize start_fontsize)
Return the string dimension in pixels.
Definition: gfx.cpp:700
No window, redirects to WC_MAIN_WINDOW.
Definition: window_type.h:38
void DeleteWindowById(WindowClass cls, WindowNumber number, bool force)
Delete a window by its class and window number (if it is open).
Definition: window.cpp:1162
Sell button.
Definition: depot_widget.h:16
void OnResize() override
Called after the window got resized.
Definition: depot_gui.cpp:1058
uint16 width
Width of the sprite.
Definition: spritecache.h:18
Functions related to companies.
uint GetUnitNumberDigits(VehicleList &vehicles)
Get the number of digits the biggest unit number of a set of vehicles has.
int GetDisplayImageWidth(Point *offset=nullptr) const
Get the width of a train vehicle image in the GUI.
Definition: train_cmd.cpp:432
static StationID GetStationIndex(TileIndex t)
Get StationID from a tile.
Definition: station_map.h:28
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:3290
Class for storing amounts of cargo.
Definition: cargo_type.h:81
Both numeric and alphabetic and spaces and stuff.
Definition: string_type.h:27
bool IsGroundVehicle() const
Check if the vehicle is a ground vehicle.
Definition: vehicle_base.h:469
void SetMouseCursorVehicle(const Vehicle *v, EngineImageType image_type)
Set the mouse cursor to look like a vehicle.
Window caption (window title between closebox and stickybox)
Definition: widget_type.h:59
uint16 EngineID
Unique identification number of an engine.
Definition: engine_type.h:21
uint32 TileIndex
The index/ID of a Tile.
Definition: tile_type.h:78
uint32 Pack() const
Pack a VehicleListIdentifier in a single uint32.
Definition: vehiclelist.cpp:21
Show horizontal scrollbar panel.
Definition: depot_widget.h:23
void OnQueryTextFinished(char *str) override
The query window opened from this window has closed.
Definition: depot_gui.cpp:837
void OnPlaceObjectAbort() override
The user cancelled a tile highlight mode that has been set.
Definition: depot_gui.cpp:921
TextDirection _current_text_dir
Text direction of the currently selected language.
Definition: strings.cpp:48
Caption of window.
Definition: depot_widget.h:15
void DrawVehicleInDepot(const Vehicle *v, int left, int right, int y) const
Draw a vehicle in the depot window in the box with the top left corner at x,y.
Definition: depot_gui.cpp:307
void SetDParamMaxValue(uint n, uint64 max_value, uint min_count, FontSize size)
Set DParam n to some number that is suitable for string size computations.
Definition: strings.cpp:104
Vertical container.
Definition: widget_type.h:75
turn a train around
Definition: command_type.h:222
static NWidgetPart EndContainer()
Widget part function for denoting the end of a container (horizontal, vertical, WWT_FRAME, WWT_INSET, or WWT_PANEL).
Definition: widget_type.h:997
uint16 cached_total_length
Length of the whole vehicle (valid only for the first engine).
Functions related to zooming.
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:215
Dimensions of a cell in the purchase/depot windows.
Definition: vehicle_gui.h:77
VehicleType type
Type of vehicle.
Definition: vehicle_type.h:52
uint current_x
Current horizontal size (after resizing).
Definition: widget_type.h:172
void DrawWidget(const Rect &r, int widget) const override
Draw the contents of a nested widget.
Definition: depot_gui.cpp:364
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).
static uint GetVehicleHeight(VehicleType type)
Get the height of a single vehicle in the GUIs.
Definition: vehicle_gui.h:68
uint step_width
Step-size of width resize changes.
Definition: window_gui.h:217
sell all vehicles which are in a given depot
Definition: command_type.h:314
bool ScrollMainWindowToTile(TileIndex tile, bool instant)
Scrolls the viewport of the main window to a given location.
Definition: viewport.cpp:2396
Functions related to commands.
uint32 CursorID
The number of the cursor (sprite)
Definition: gfx_type.h:19
Coordinates of a point in 2D.
clone a vehicle
Definition: command_type.h:310
Stop all button.
Definition: depot_widget.h:31
Base for ships.
Index of the small font in the font tables.
Definition: gfx_type.h:203
uint16 GetCapacity() const
Gets the number of visible elements of the scrollbar.
Definition: widget_type.h:620
start/stop all vehicles (in a depot)
Definition: command_type.h:312
Owner owner
The owner of the content shown in this window. Company colour is acquired from this variable...
Definition: window_gui.h:324
Aircraft vehicle type.
Definition: vehicle_type.h:27
void HandleButtonClick(byte widget)
Do all things to make a button look clicked and mark it to be unclicked in a few ticks.
Definition: window.cpp:635
bool IsFreeWagon() const
Check if the vehicle is a free wagon (got no engine in front of it).
vehicle is accepted as target as well (bitmask)
Offset at right to draw the frame rectangular area.
Definition: window_gui.h:61
EngineID engine_type
The type of engine used for this vehicle.
Definition: vehicle_base.h:286
Sticky box (at top-right of a window, after WWT_DEFSIZEBOX)
Definition: widget_type.h:64
int width
width of the window (number of pixels to the right in x direction)
Definition: window_gui.h:319
Autoreplace button.
Definition: depot_widget.h:20
static NWidgetPart SetFill(uint fill_x, uint fill_y)
Widget part function for setting filling.
Definition: widget_type.h:981
void DepotClick(int x, int y)
Handle click in the depot matrix.
Definition: depot_gui.cpp:540
#define CMD_MSG(x)
Used to combine a StringID with the command.
Definition: command_type.h:368
void SetCapacityFromWidget(Window *w, int widget, int padding=0)
Set capacity of visible elements from the size and resize properties of a widget. ...
Definition: widget.cpp:1971
void ResetObjectToPlace()
Reset the cursor and mouse mode handling back to default (normal cursor, only clicking in windows)...
Definition: viewport.cpp:3353
Specification of a rectangle with absolute coordinates of all edges.
Vertical scrollbar.
Definition: widget_type.h:82
byte CargoID
Cargo slots to indicate a cargo type within a game.
Definition: cargo_type.h:20
The passed event is handled.
Definition: window_type.h:712
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:113
Text is written right-to-left by default.
Definition: strings_type.h:24
Right align the text (must be a single bit).
Definition: gfx_func.h:96
WindowNumber window_number
Window number within the window class.
Definition: window_gui.h:312
uint extend_left
Extend of the cell to the left.
Definition: vehicle_gui.h:79
static VehicleCellSize _base_block_sizes_depot[VEH_COMPANY_END]
Cell size for vehicle images in the depot view.
Definition: depot_gui.cpp:147
Functions related to tile highlights.
bool OnRightClick(Point pt, int widget) override
A click with the right mouse button has been made on the window.
Definition: depot_gui.cpp:845
VehicleID vehicle_over
Rail vehicle over which another one is dragged, INVALID_VEHICLE if none.
Definition: depot_gui.cpp:255
Vehicle * Last()
Get the last vehicle of this vehicle chain.
Definition: vehicle_base.h:598
Find a place automatically.
Definition: window_gui.h:154
(Toggle) Button with image
Definition: widget_type.h:50
std::vector< const Vehicle * > VehicleList
A list of vehicles.
Definition: vehiclelist.h:53
Stacked widgets, only one visible at a time (eg in a panel with tabs).
Definition: widget_type.h:78
move a rail vehicle (in the depot)
Definition: command_type.h:220
GUI functions that shouldn&#39;t be here.
static const CursorID SPR_CURSOR_MOUSE
Cursor sprite numbers.
Definition: sprites.h:1367
void CcCloneVehicle(const CommandCost &result, TileIndex tile, uint32 p1, uint32 p2, uint32 cmd)
This is the Callback method after the cloning attempt of a vehicle.
Definition: depot_gui.cpp:120
Date age
Age in days.
Definition: vehicle_base.h:256
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:549
static NWidgetPart SetScrollbar(int index)
Attach a scrollbar to a widget.
Definition: widget_type.h:1093
CompanyID _local_company
Company controlled by the human player at this client. Can also be COMPANY_SPECTATOR.
Definition: company_cmd.cpp:44
static bool IsCompanyBuildableVehicleType(VehicleType type)
Is the given vehicle type buildable by a company?
Definition: vehicle_func.h:89
Dimensions (a width and height) of a rectangle in 2D.
Value of the NCB_EQUALSIZE flag.
Definition: widget_type.h:427
Offset at left to draw the frame rectangular area.
Definition: window_gui.h:60
Window * BringWindowToFrontById(WindowClass cls, WindowNumber number)
Find a window and make it the relative top-window on the screen.
Definition: window.cpp:1259
Shade box (at top-right of a window, between WWT_DEBUGBOX and WWT_DEFSIZEBOX)
Definition: widget_type.h:62
Road vehicle type.
Definition: vehicle_type.h:25
Sell chain button.
Definition: depot_widget.h:18
void DrawSprite(SpriteID img, PaletteID pal, int x, int y, const SubSprite *sub, ZoomLevel zoom)
Draw a sprite, not in a viewport.
Definition: gfx.cpp:835
int pos_y
Vertical position of top-left corner of the widget in the window.
Definition: widget_type.h:176
static const int DAYS_IN_LEAP_YEAR
sometimes, you need one day more...
Definition: date_type.h:30
GroundVehicleCache gcache
Cache of often calculated values.
(Toggle) Button with text
Definition: widget_type.h:53
uint16 GetPosition() const
Gets the position of the first visible element in the list.
Definition: widget_type.h:629
static void SetDParam(uint n, uint64 v)
Set a string parameter v at index n in the global string parameter array.
Definition: strings_func.h:199
Base class for a &#39;real&#39; widget.
Definition: widget_type.h:282
static Pool::IterateWrapper< Engine > IterateType(VehicleType vt, size_t from=0)
Returns an iterable ensemble of all valid engines of the given type.
Definition: engine_base.h:151