OpenTTD Source  12.0-beta2
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(NWID_SELECTION, INVALID_COLOUR, WID_D_SHOW_RENAME), // rename button
47  NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_D_RENAME), SetMinimalSize(12, 14), SetDataTip(SPR_RENAME, STR_DEPOT_RENAME_TOOLTIP),
48  EndContainer(),
49  NWidget(WWT_CAPTION, COLOUR_GREY, WID_D_CAPTION), SetDataTip(STR_DEPOT_CAPTION, STR_NULL),
50  NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_D_LOCATION), SetMinimalSize(12, 14), SetDataTip(SPR_GOTO_LOCATION, STR_NULL),
51  NWidget(WWT_SHADEBOX, COLOUR_GREY),
52  NWidget(WWT_DEFSIZEBOX, COLOUR_GREY),
53  NWidget(WWT_STICKYBOX, COLOUR_GREY),
54  EndContainer(),
58  NWidget(NWID_SELECTION, INVALID_COLOUR, WID_D_SHOW_H_SCROLL),
59  NWidget(NWID_HSCROLLBAR, COLOUR_GREY, WID_D_H_SCROLL),
60  EndContainer(),
61  EndContainer(),
63  NWidget(WWT_IMGBTN, COLOUR_GREY, WID_D_SELL), SetDataTip(0x0, STR_NULL), SetResize(0, 1), SetFill(0, 1),
65  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),
66  EndContainer(),
67  NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_D_SELL_ALL), SetDataTip(0x0, STR_NULL),
68  NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_D_AUTOREPLACE), SetDataTip(0x0, STR_NULL),
69  EndContainer(),
70  NWidget(NWID_VSCROLLBAR, COLOUR_GREY, WID_D_V_SCROLL),
71  EndContainer(),
73  NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_D_BUILD), SetDataTip(0x0, STR_NULL), SetFill(1, 1), SetResize(1, 0),
74  NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_D_CLONE), SetDataTip(0x0, STR_NULL), SetFill(1, 1), SetResize(1, 0),
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,
87 );
88 
89 static WindowDesc _road_depot_desc(
90  WDP_AUTO, "depot_roadveh", 316, 97,
92  0,
94 );
95 
96 static WindowDesc _ship_depot_desc(
97  WDP_AUTO, "depot_ship", 306, 99,
99  0,
101 );
102 
103 static WindowDesc _aircraft_depot_desc(
104  WDP_AUTO, "depot_aircraft", 332, 99,
106  0,
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 = std::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 = std::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  void Close() override
295  {
297  CloseWindowById(GetWindowClassForVehicleType(this->type), VehicleListIdentifier(VL_DEPOT_LIST, this->type, this->owner, this->GetDepotIndex()).Pack(), false);
299  this->Window::Close();
300  }
301 
309  void DrawVehicleInDepot(const Vehicle *v, int left, int right, int y) const
310  {
311  bool free_wagon = false;
312  int sprite_y = y + (this->resize.step_height - ScaleGUITrad(GetVehicleHeight(v->type))) / 2;
313 
314  bool rtl = _current_text_dir == TD_RTL;
315  int image_left = rtl ? left + this->count_width : left + this->header_width;
316  int image_right = rtl ? right - this->header_width : right - this->count_width;
317 
318  switch (v->type) {
319  case VEH_TRAIN: {
320  const Train *u = Train::From(v);
321  free_wagon = u->IsFreeWagon();
322 
323  uint x_space = free_wagon ?
324  ScaleGUITrad(_consistent_train_width != 0 ? _consistent_train_width : TRAININFO_DEFAULT_VEHICLE_WIDTH) :
325  0;
326 
327  DrawTrainImage(u, image_left + (rtl ? 0 : x_space), image_right - (rtl ? x_space : 0), sprite_y - 1,
328  this->sel, EIT_IN_DEPOT, free_wagon ? 0 : this->hscroll->GetPosition(), this->vehicle_over);
329 
330  /* Length of consist in tiles with 1 fractional digit (rounded up) */
332  SetDParam(1, 1);
333  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
334  break;
335  }
336 
337  case VEH_ROAD: DrawRoadVehImage( v, image_left, image_right, sprite_y, this->sel, EIT_IN_DEPOT); break;
338  case VEH_SHIP: DrawShipImage( v, image_left, image_right, sprite_y, this->sel, EIT_IN_DEPOT); break;
339  case VEH_AIRCRAFT: DrawAircraftImage(v, image_left, image_right, sprite_y, this->sel, EIT_IN_DEPOT); break;
340  default: NOT_REACHED();
341  }
342 
343  uint diff_x, diff_y;
344  if (v->IsGroundVehicle()) {
345  /* Arrange unitnumber and flag horizontally */
346  diff_x = this->flag_width + WD_FRAMERECT_LEFT;
347  diff_y = (this->resize.step_height - this->flag_height) / 2 - 2;
348  } else {
349  /* Arrange unitnumber and flag vertically */
350  diff_x = WD_FRAMERECT_LEFT;
352  }
353  int text_left = rtl ? right - this->header_width - 1 : left + diff_x;
354  int text_right = rtl ? right - diff_x : left + this->header_width - 1;
355 
356  if (free_wagon) {
357  DrawString(text_left, text_right, y + 2, STR_DEPOT_NO_ENGINE);
358  } else {
359  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);
360 
361  SetDParam(0, v->unitnumber);
362  DrawString(text_left, text_right, y + 2, (uint16)(v->max_age - DAYS_IN_LEAP_YEAR) >= v->age ? STR_BLACK_COMMA : STR_RED_COMMA);
363  }
364  }
365 
366  void DrawWidget(const Rect &r, int widget) const override
367  {
368  if (widget != WID_D_MATRIX) return;
369 
370  bool rtl = _current_text_dir == TD_RTL;
371 
372  /* Set the row and number of boxes in each row based on the number of boxes drawn in the matrix */
373  const NWidgetCore *wid = this->GetWidget<NWidgetCore>(WID_D_MATRIX);
374 
375  /* Draw vertical separators at whole tiles.
376  * This only works in two cases:
377  * - All vehicles use VEHICLEINFO_FULL_VEHICLE_WIDTH as reference width.
378  * - All vehicles are 8/8. This cannot be checked for NewGRF, so instead we check for "all vehicles are original vehicles".
379  */
380  if (this->type == VEH_TRAIN && _consistent_train_width != 0) {
382  int col = _colour_gradient[wid->colour][4];
383  int image_left = rtl ? r.left + this->count_width : r.left + this->header_width;
384  int image_right = rtl ? r.right - this->header_width : r.right - this->count_width;
385  int first_line = w + (-this->hscroll->GetPosition()) % w;
386  if (rtl) {
387  for (int x = image_right - first_line; x >= image_left; x -= w) {
388  GfxDrawLine(x, r.top, x, r.bottom, col, 1, 3);
389  }
390  } else {
391  for (int x = image_left + first_line; x <= image_right; x += w) {
392  GfxDrawLine(x, r.top, x, r.bottom, col, 1, 3);
393  }
394  }
395  }
396 
397  uint16 rows_in_display = wid->current_y / wid->resize_y;
398 
399  uint num = this->vscroll->GetPosition() * this->num_columns;
400  uint maxval = static_cast<uint>(std::min<size_t>(this->vehicle_list.size(), num + (rows_in_display * this->num_columns)));
401  int y;
402  for (y = r.top + 1; num < maxval; y += this->resize.step_height) { // Draw the rows
403  for (uint i = 0; i < this->num_columns && num < maxval; i++, num++) {
404  /* Draw all vehicles in the current row */
405  const Vehicle *v = this->vehicle_list[num];
406  if (this->num_columns == 1) {
407  this->DrawVehicleInDepot(v, r.left, r.right, y);
408  } else {
409  int x = r.left + (rtl ? (this->num_columns - i - 1) : i) * this->resize.step_width;
410  this->DrawVehicleInDepot(v, x, x + this->resize.step_width - 1, y);
411  }
412  }
413  }
414 
415  maxval = static_cast<uint>(std::min<size_t>(this->vehicle_list.size() + this->wagon_list.size(), (this->vscroll->GetPosition() * this->num_columns) + (rows_in_display * this->num_columns)));
416 
417  /* Draw the train wagons without an engine in front. */
418  for (; num < maxval; num++, y += this->resize.step_height) {
419  const Vehicle *v = this->wagon_list[num - this->vehicle_list.size()];
420  this->DrawVehicleInDepot(v, r.left, r.right, y);
421  }
422  }
423 
424  void SetStringParameters(int widget) const override
425  {
426  if (widget != WID_D_CAPTION) return;
427 
428  SetDParam(0, this->type);
429  SetDParam(1, this->GetDepotIndex());
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 = std::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 = std::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 = std::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 {
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 = std::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  SetDParam(0, this->type);
813  SetDParam(1, this->GetDepotIndex());
814  ShowQuery(
815  STR_DEPOT_CAPTION,
816  STR_DEPOT_SELL_CONFIRMATION_TEXT,
817  this,
818  DepotSellAllConfirmationCallback
819  );
820  }
821  break;
822 
823  case WID_D_VEHICLE_LIST:
824  ShowVehicleListWindow(GetTileOwner(this->window_number), this->type, (TileIndex)this->window_number);
825  break;
826 
827  case WID_D_AUTOREPLACE:
828  DoCommandP(this->window_number, this->type, 0, CMD_DEPOT_MASS_AUTOREPLACE);
829  break;
830 
831  }
832  }
833 
834  void OnQueryTextFinished(char *str) override
835  {
836  if (str == nullptr) return;
837 
838  /* Do depot renaming */
839  DoCommandP(0, this->GetDepotIndex(), 0, CMD_RENAME_DEPOT | CMD_MSG(STR_ERROR_CAN_T_RENAME_DEPOT), nullptr, str);
840  }
841 
842  bool OnRightClick(Point pt, int widget) override
843  {
844  if (widget != WID_D_MATRIX) return false;
845 
846  GetDepotVehiclePtData gdvp = { nullptr, nullptr };
847  const Vehicle *v = nullptr;
848  NWidgetBase *nwi = this->GetWidget<NWidgetBase>(WID_D_MATRIX);
849  DepotGUIAction mode = this->GetVehicleFromDepotWndPt(pt.x - nwi->pos_x, pt.y - nwi->pos_y, &v, &gdvp);
850 
851  if (this->type == VEH_TRAIN) v = gdvp.wagon;
852 
853  if (v == nullptr || mode != MODE_DRAG_VEHICLE) return false;
854 
855  CargoArray capacity, loaded;
856 
857  /* Display info for single (articulated) vehicle, or for whole chain starting with selected vehicle */
858  bool whole_chain = (this->type == VEH_TRAIN && _ctrl_pressed);
859 
860  /* loop through vehicle chain and collect cargoes */
861  uint num = 0;
862  for (const Vehicle *w = v; w != nullptr; w = w->Next()) {
863  if (w->cargo_cap > 0 && w->cargo_type < NUM_CARGO) {
864  capacity[w->cargo_type] += w->cargo_cap;
865  loaded [w->cargo_type] += w->cargo.StoredCount();
866  }
867 
868  if (w->type == VEH_TRAIN && !w->HasArticulatedPart()) {
869  num++;
870  if (!whole_chain) break;
871  }
872  }
873 
874  /* Build tooltipstring */
875  static char details[1024];
876  details[0] = '\0';
877  char *pos = details;
878 
879  for (CargoID cargo_type = 0; cargo_type < NUM_CARGO; cargo_type++) {
880  if (capacity[cargo_type] == 0) continue;
881 
882  SetDParam(0, cargo_type); // {CARGO} #1
883  SetDParam(1, loaded[cargo_type]); // {CARGO} #2
884  SetDParam(2, cargo_type); // {SHORTCARGO} #1
885  SetDParam(3, capacity[cargo_type]); // {SHORTCARGO} #2
886  pos = GetString(pos, STR_DEPOT_VEHICLE_TOOLTIP_CARGO, lastof(details));
887  }
888 
889  /* Show tooltip window */
890  uint64 args[2];
891  args[0] = (whole_chain ? num : v->engine_type);
892  args[1] = (uint64)(size_t)details;
893  GuiShowTooltips(this, whole_chain ? STR_DEPOT_VEHICLE_TOOLTIP_CHAIN : STR_DEPOT_VEHICLE_TOOLTIP, 2, args, TCC_RIGHT_CLICK);
894 
895  return true;
896  }
897 
903  bool OnVehicleSelect(const Vehicle *v) override
904  {
905  if (_ctrl_pressed) {
906  /* Share-clone, do not open new viewport, and keep tool active */
907  DoCommandP(this->window_number, v->index, 1, CMD_CLONE_VEHICLE | CMD_MSG(STR_ERROR_CAN_T_BUY_TRAIN + v->type), nullptr);
908  } else {
909  /* Copy-clone, open viewport for new vehicle, and deselect the tool (assume player wants to changs things on new vehicle) */
910  if (DoCommandP(this->window_number, v->index, 0, CMD_CLONE_VEHICLE | CMD_MSG(STR_ERROR_CAN_T_BUY_TRAIN + v->type), CcCloneVehicle)) {
912  }
913  }
914 
915  return true;
916  }
917 
918  void OnPlaceObjectAbort() override
919  {
920  /* abort clone */
921  this->RaiseWidget(WID_D_CLONE);
923 
924  /* abort drag & drop */
925  this->sel = INVALID_VEHICLE;
926  this->vehicle_over = INVALID_VEHICLE;
928 
929  if (this->hovered_widget != -1) {
930  this->SetWidgetLoweredState(this->hovered_widget, false);
931  this->SetWidgetDirty(this->hovered_widget);
932  this->hovered_widget = -1;
933  }
934  }
935 
936  void OnMouseDrag(Point pt, int widget) override
937  {
938  if (this->sel == INVALID_VEHICLE) return;
939  if (widget != this->hovered_widget) {
940  if (this->hovered_widget == WID_D_SELL || this->hovered_widget == WID_D_SELL_CHAIN) {
941  this->SetWidgetLoweredState(this->hovered_widget, false);
942  this->SetWidgetDirty(this->hovered_widget);
943  }
944  this->hovered_widget = widget;
945  if (this->hovered_widget == WID_D_SELL || this->hovered_widget == WID_D_SELL_CHAIN) {
946  this->SetWidgetLoweredState(this->hovered_widget, true);
947  this->SetWidgetDirty(this->hovered_widget);
948  }
949  }
950  if (this->type != VEH_TRAIN) return;
951 
952  /* A rail vehicle is dragged.. */
953  if (widget != WID_D_MATRIX) { // ..outside of the depot matrix.
954  if (this->vehicle_over != INVALID_VEHICLE) {
955  this->vehicle_over = INVALID_VEHICLE;
957  }
958  return;
959  }
960 
961  NWidgetBase *matrix = this->GetWidget<NWidgetBase>(widget);
962  const Vehicle *v = nullptr;
963  GetDepotVehiclePtData gdvp = {nullptr, nullptr};
964 
965  if (this->GetVehicleFromDepotWndPt(pt.x - matrix->pos_x, pt.y - matrix->pos_y, &v, &gdvp) != MODE_DRAG_VEHICLE) return;
966 
967  VehicleID new_vehicle_over = INVALID_VEHICLE;
968  if (gdvp.head != nullptr) {
969  if (gdvp.wagon == nullptr && gdvp.head->Last()->index != this->sel) { // ..at the end of the train.
970  /* 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
971  * destination inside a train. This head index is then used to indicate that a wagon is inserted at
972  * the end of the train.
973  */
974  new_vehicle_over = gdvp.head->index;
975  } else if (gdvp.wagon != nullptr && gdvp.head != gdvp.wagon &&
976  gdvp.wagon->index != this->sel &&
977  gdvp.wagon->Previous()->index != this->sel) { // ..over an existing wagon.
978  new_vehicle_over = gdvp.wagon->index;
979  }
980  }
981 
982  if (this->vehicle_over == new_vehicle_over) return;
983 
984  this->vehicle_over = new_vehicle_over;
985  this->SetWidgetDirty(widget);
986  }
987 
988  void OnDragDrop(Point pt, int widget) override
989  {
990  switch (widget) {
991  case WID_D_MATRIX: {
992  const Vehicle *v = nullptr;
993  VehicleID sel = this->sel;
994 
995  this->sel = INVALID_VEHICLE;
996  this->SetDirty();
997 
998  NWidgetBase *nwi = this->GetWidget<NWidgetBase>(WID_D_MATRIX);
999  if (this->type == VEH_TRAIN) {
1000  GetDepotVehiclePtData gdvp = { nullptr, nullptr };
1001 
1002  if (this->GetVehicleFromDepotWndPt(pt.x - nwi->pos_x, pt.y - nwi->pos_y, &v, &gdvp) == MODE_DRAG_VEHICLE && sel != INVALID_VEHICLE) {
1003  if (gdvp.wagon != nullptr && gdvp.wagon->index == sel && _ctrl_pressed) {
1004  DoCommandP(Vehicle::Get(sel)->tile, Vehicle::Get(sel)->index, true,
1005  CMD_REVERSE_TRAIN_DIRECTION | CMD_MSG(STR_ERROR_CAN_T_REVERSE_DIRECTION_RAIL_VEHICLE));
1006  } else if (gdvp.wagon == nullptr || gdvp.wagon->index != sel) {
1007  this->vehicle_over = INVALID_VEHICLE;
1008  TrainDepotMoveVehicle(gdvp.wagon, sel, gdvp.head);
1009  } else if (gdvp.head != nullptr && gdvp.head->IsFrontEngine()) {
1010  ShowVehicleViewWindow(gdvp.head);
1011  }
1012  }
1013  } else if (this->GetVehicleFromDepotWndPt(pt.x - nwi->pos_x, pt.y - nwi->pos_y, &v, nullptr) == MODE_DRAG_VEHICLE && v != nullptr && sel == v->index) {
1015  }
1016  break;
1017  }
1018 
1019  case WID_D_SELL: case WID_D_SELL_CHAIN: {
1020  if (this->IsWidgetDisabled(widget)) return;
1021  if (this->sel == INVALID_VEHICLE) return;
1022 
1023  this->HandleButtonClick(widget);
1024 
1025  const Vehicle *v = Vehicle::Get(this->sel);
1026  this->sel = INVALID_VEHICLE;
1027  this->SetDirty();
1028 
1029  int sell_cmd = (v->type == VEH_TRAIN && (widget == WID_D_SELL_CHAIN || _ctrl_pressed)) ? 1 : 0;
1030  DoCommandP(v->tile, v->index | sell_cmd << 20 | MAKE_ORDER_BACKUP_FLAG, 0, GetCmdSellVeh(v->type));
1031  break;
1032  }
1033 
1034  default:
1035  this->sel = INVALID_VEHICLE;
1036  this->SetDirty();
1037  break;
1038  }
1039  this->hovered_widget = -1;
1040  _cursor.vehchain = false;
1041  }
1042 
1043  void OnTimeout() override
1044  {
1045  if (!this->IsWidgetDisabled(WID_D_SELL)) {
1046  this->RaiseWidget(WID_D_SELL);
1047  this->SetWidgetDirty(WID_D_SELL);
1048  }
1049  if (this->GetWidget<NWidgetBase>(WID_D_SELL) != nullptr && !this->IsWidgetDisabled(WID_D_SELL_CHAIN)) {
1052  }
1053  }
1054 
1055  void OnResize() override
1056  {
1057  this->vscroll->SetCapacityFromWidget(this, WID_D_MATRIX);
1058  NWidgetCore *nwi = this->GetWidget<NWidgetCore>(WID_D_MATRIX);
1059  if (this->type == VEH_TRAIN) {
1060  this->hscroll->SetCapacity(nwi->current_x - this->header_width - this->count_width);
1061  } else {
1062  this->num_columns = nwi->current_x / nwi->resize_x;
1063  }
1064  }
1065 
1067  {
1068  if (this->sel != INVALID_VEHICLE) {
1069  _cursor.vehchain = _ctrl_pressed;
1071  return ES_HANDLED;
1072  }
1073 
1074  return ES_NOT_HANDLED;
1075  }
1076 
1082  inline uint16 GetDepotIndex() const
1083  {
1084  return (this->type == VEH_AIRCRAFT) ? ::GetStationIndex(this->window_number) : ::GetDepotIndex(this->window_number);
1085  }
1086 };
1087 
1088 static void DepotSellAllConfirmationCallback(Window *win, bool confirmed)
1089 {
1090  if (confirmed) {
1091  DepotWindow *w = (DepotWindow*)win;
1092  TileIndex tile = w->window_number;
1093  byte vehtype = w->type;
1094  DoCommandP(tile, vehtype, 0, CMD_DEPOT_SELL_ALL_VEHICLES);
1095  }
1096 }
1097 
1104 {
1105  if (BringWindowToFrontById(WC_VEHICLE_DEPOT, tile) != nullptr) return;
1106 
1107  WindowDesc *desc;
1108  switch (type) {
1109  default: NOT_REACHED();
1110  case VEH_TRAIN: desc = &_train_depot_desc; break;
1111  case VEH_ROAD: desc = &_road_depot_desc; break;
1112  case VEH_SHIP: desc = &_ship_depot_desc; break;
1113  case VEH_AIRCRAFT: desc = &_aircraft_depot_desc; break;
1114  }
1115 
1116  new DepotWindow(desc, tile, type);
1117 }
1118 
1124 {
1125  DepotWindow *w;
1126 
1127  /* If we haven't got any vehicles on the mouse pointer, we haven't got any highlighted in any depots either
1128  * If that is the case, we can skip looping though the windows and save time
1129  */
1130  if (_special_mouse_mode != WSM_DRAGDROP) return;
1131 
1132  w = dynamic_cast<DepotWindow*>(FindWindowById(WC_VEHICLE_DEPOT, v->tile));
1133  if (w != nullptr) {
1134  if (w->sel == v->index) ResetObjectToPlace();
1135  }
1136 }
SZSP_NONE
@ SZSP_NONE
Display plane with zero size in both directions (none filling and resizing).
Definition: widget_type.h:423
VEH_AIRCRAFT
@ VEH_AIRCRAFT
Aircraft vehicle type.
Definition: vehicle_type.h:27
Train::GetDisplayImageWidth
int GetDisplayImageWidth(Point *offset=nullptr) const
Get the width of a train vehicle image in the GUI.
Definition: train_cmd.cpp:440
ES_HANDLED
@ ES_HANDLED
The passed event is handled.
Definition: window_type.h:718
DepotWindow::OnRightClick
bool OnRightClick(Point pt, int widget) override
A click with the right mouse button has been made on the window.
Definition: depot_gui.cpp:842
IsCompanyBuildableVehicleType
static bool IsCompanyBuildableVehicleType(VehicleType type)
Is the given vehicle type buildable by a company?
Definition: vehicle_func.h:89
CMD_MSG
#define CMD_MSG(x)
Used to combine a StringID with the command.
Definition: command_type.h:372
TileIndex
uint32 TileIndex
The index/ID of a Tile.
Definition: tile_type.h:83
DepotWindow::Close
void Close() override
Hide the window and all its child windows, and mark them for a later deletion.
Definition: depot_gui.cpp:294
DepotWindow::OnTimeout
void OnTimeout() override
Called when this window's timeout has been reached.
Definition: depot_gui.cpp:1043
Engine::IterateType
static Pool::IterateWrapperFiltered< Engine, EngineTypeFilter > IterateType(VehicleType vt, size_t from=0)
Returns an iterable ensemble of all valid engines of the given type.
Definition: engine_base.h:161
VehicleCellSize::height
uint height
Vehicle cell height.
Definition: vehicle_gui.h:78
WID_D_CAPTION
@ WID_D_CAPTION
Caption of window.
Definition: depot_widget.h:15
CMD_REVERSE_TRAIN_DIRECTION
@ CMD_REVERSE_TRAIN_DIRECTION
turn a train around
Definition: command_type.h:222
VehicleList
std::vector< const Vehicle * > VehicleList
A list of vehicles.
Definition: vehiclelist.h:53
Pool::PoolItem<&_vehicle_pool >::Get
static Titem * Get(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:337
ScrollMainWindowToTile
bool ScrollMainWindowToTile(TileIndex tile, bool instant)
Scrolls the viewport of the main window to a given location.
Definition: viewport.cpp:2445
SetScrollbar
static NWidgetPart SetScrollbar(int index)
Attach a scrollbar to a widget.
Definition: widget_type.h:1188
ShowExtraViewportWindow
void ShowExtraViewportWindow(TileIndex tile=INVALID_TILE)
Show a new Extra Viewport window.
Definition: viewport_gui.cpp:168
CMD_MOVE_RAIL_VEHICLE
@ CMD_MOVE_RAIL_VEHICLE
move a rail vehicle (in the depot)
Definition: command_type.h:220
train.h
Dimension
Dimensions (a width and height) of a rectangle in 2D.
Definition: geometry_type.hpp:27
WID_D_SHOW_SELL_CHAIN
@ WID_D_SHOW_SELL_CHAIN
Show sell chain panel.
Definition: depot_widget.h:17
Scrollbar::GetCapacity
uint16 GetCapacity() const
Gets the number of visible elements of the scrollbar.
Definition: widget_type.h:662
command_func.h
WWT_STICKYBOX
@ WWT_STICKYBOX
Sticky box (at top-right of a window, after WWT_DEFSIZEBOX)
Definition: widget_type.h:64
Window::GetScrollbar
const Scrollbar * GetScrollbar(uint widnum) const
Return the Scrollbar to a widget index.
Definition: window.cpp:320
VehicleListIdentifier
The information about a vehicle list.
Definition: vehiclelist.h:29
_special_mouse_mode
SpecialMouseMode _special_mouse_mode
Mode of the mouse.
Definition: window.cpp:93
Vehicle::Previous
Vehicle * Previous() const
Get the previous vehicle of this vehicle.
Definition: vehicle_base.h:601
_consistent_train_width
static uint _consistent_train_width
Whether trains of all lengths are consistently scaled. Either TRAININFO_DEFAULT_VEHICLE_WIDTH,...
Definition: depot_gui.cpp:149
Window::ReInit
void ReInit(int rx=0, int ry=0)
Re-initialize a window, and optionally change its size.
Definition: window.cpp:1004
WID_D_SHOW_H_SCROLL
@ WID_D_SHOW_H_SCROLL
Show horizontal scrollbar panel.
Definition: depot_widget.h:23
Vehicle::Next
Vehicle * Next() const
Get the next vehicle of this vehicle.
Definition: vehicle_base.h:594
SpecializedVehicle::Next
T * Next() const
Get next vehicle in the chain.
Definition: vehicle_base.h:1079
NWID_HSCROLLBAR
@ NWID_HSCROLLBAR
Horizontal scrollbar.
Definition: widget_type.h:81
WD_MATRIX_TOP
@ WD_MATRIX_TOP
Offset at top of a matrix cell.
Definition: window_gui.h:80
WWT_CAPTION
@ WWT_CAPTION
Window caption (window title between closebox and stickybox)
Definition: widget_type.h:59
CursorVars::vehchain
bool vehchain
vehicle chain is dragged
Definition: gfx_type.h:144
WWT_IMGBTN
@ WWT_IMGBTN
(Toggle) Button with image
Definition: widget_type.h:50
vehiclelist.h
DepotWindow::OnQueryTextFinished
void OnQueryTextFinished(char *str) override
The query window opened from this window has closed.
Definition: depot_gui.cpp:834
Vehicle::vehstatus
byte vehstatus
Status.
Definition: vehicle_base.h:328
WWT_DEFSIZEBOX
@ WWT_DEFSIZEBOX
Default window size box (at top-right of a window, between WWT_SHADEBOX and WWT_STICKYBOX)
Definition: widget_type.h:63
Window::CreateNestedTree
void CreateNestedTree(bool fill_nested=true)
Perform the first part of the initialization of a nested widget tree.
Definition: window.cpp:1760
Pool::PoolItem::index
Tindex index
Index of this pool item.
Definition: pool_type.hpp:235
DepotWindow::hscroll
Scrollbar * hscroll
Only for trains.
Definition: depot_gui.cpp:263
NWID_HORIZONTAL
@ NWID_HORIZONTAL
Horizontal container.
Definition: widget_type.h:73
EIT_PURCHASE
@ EIT_PURCHASE
Vehicle drawn in purchase list, autoreplace gui, ...
Definition: vehicle_type.h:90
CargoArray
Class for storing amounts of cargo.
Definition: cargo_type.h:82
WWT_MATRIX
@ WWT_MATRIX
Grid of rows and columns.
Definition: widget_type.h:57
FindWindowById
Window * FindWindowById(WindowClass cls, WindowNumber number)
Find a window by its class and window number.
Definition: window.cpp:1146
ship.h
UnScaleGUI
static int UnScaleGUI(int value)
Short-hand to apply GUI zoom level.
Definition: zoom_func.h:66
Scrollbar::SetCount
void SetCount(int num)
Sets the number of elements in the list.
Definition: widget_type.h:710
Sprite::height
uint16 height
Height of the sprite.
Definition: spritecache.h:18
_ctrl_pressed
bool _ctrl_pressed
Is Ctrl pressed?
Definition: gfx.cpp:35
SetResize
static NWidgetPart SetResize(int16 dx, int16 dy)
Widget part function for setting the resize step.
Definition: widget_type.h:993
zoom_func.h
aircraft.h
GetUnitNumberDigits
uint GetUnitNumberDigits(VehicleList &vehicles)
Get the number of digits the biggest unit number of a set of vehicles has.
Definition: vehicle_gui.cpp:165
TILE_SIZE
static const uint TILE_SIZE
Tile size in world coordinates.
Definition: tile_type.h:13
WID_D_VEHICLE_LIST
@ WID_D_VEHICLE_LIST
List of vehicles.
Definition: depot_widget.h:30
DrawString
int DrawString(int left, int right, int top, const char *str, TextColour colour, StringAlignment align, bool underline, FontSize fontsize)
Draw string, possibly truncated to make it fit in its allocated space.
Definition: gfx.cpp:642
SZSP_HORIZONTAL
@ SZSP_HORIZONTAL
Display plane with zero size vertically, and filling and resizing horizontally.
Definition: widget_type.h:422
WID_D_SHOW_RENAME
@ WID_D_SHOW_RENAME
Show rename panel.
Definition: depot_widget.h:28
VehicleCellSize::extend_right
uint extend_right
Extend of the cell to the right.
Definition: vehicle_gui.h:80
Window::owner
Owner owner
The owner of the content shown in this window. Company colour is acquired from this variable.
Definition: window_gui.h:319
ST_NORMAL
@ ST_NORMAL
The most basic (normal) sprite.
Definition: gfx_type.h:302
DepotWindow
Definition: depot_gui.cpp:253
EngineImageType
EngineImageType
Visualisation contexts of vehicles and engines.
Definition: vehicle_type.h:85
SA_RIGHT
@ SA_RIGHT
Right align the text (must be a single bit).
Definition: gfx_type.h:330
Engine
Definition: engine_base.h:27
VEH_ROAD
@ VEH_ROAD
Road vehicle type.
Definition: vehicle_type.h:25
Vehicle
Vehicle data structure.
Definition: vehicle_base.h:221
Vehicle::IsGroundVehicle
bool IsGroundVehicle() const
Check if the vehicle is a ground vehicle.
Definition: vehicle_base.h:484
WID_D_CLONE
@ WID_D_CLONE
Clone button.
Definition: depot_widget.h:26
Window::HandleButtonClick
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:646
WID_D_V_SCROLL
@ WID_D_V_SCROLL
Vertical scrollbar.
Definition: depot_widget.h:22
ShowDepotWindow
void ShowDepotWindow(TileIndex tile, VehicleType type)
Opens a depot window.
Definition: depot_gui.cpp:1103
Scrollbar
Scrollbar data structure.
Definition: widget_type.h:629
WID_D_STOP_ALL
@ WID_D_STOP_ALL
Stop all button.
Definition: depot_widget.h:31
GetShipSpriteSize
void GetShipSpriteSize(EngineID engine, uint &width, uint &height, int &xoffs, int &yoffs, EngineImageType image_type)
Get the size of the sprite of a ship sprite heading west (used for lists).
Definition: ship_cmd.cpp:113
_colour_gradient
byte _colour_gradient[COLOUR_END][8]
All 16 colour gradients 8 colours per gradient from darkest (0) to lightest (7)
Definition: gfx.cpp:52
SetDParam
static void SetDParam(uint n, uint64 v)
Set a string parameter v at index n in the global string parameter array.
Definition: strings_func.h:196
GetVehicleImageCellSize
VehicleCellSize GetVehicleImageCellSize(VehicleType type, EngineImageType image_type)
Get the GUI cell size for a vehicle image.
Definition: depot_gui.cpp:158
NWidgetPart
Partial widget specification to allow NWidgets to be written nested.
Definition: widget_type.h:971
SetDataTip
static NWidgetPart SetDataTip(uint32 data, StringID tip)
Widget part function for setting the data and tooltip.
Definition: widget_type.h:1107
MAT_COL_START
@ MAT_COL_START
Lowest bit of the number of columns.
Definition: widget_type.h:25
GetStringBoundingBox
Dimension GetStringBoundingBox(const char *str, FontSize start_fontsize)
Return the string dimension in pixels.
Definition: gfx.cpp:888
textbuf_gui.h
QSF_LEN_IN_CHARS
@ QSF_LEN_IN_CHARS
the length of the string is counted in characters
Definition: textbuf_gui.h:22
DepotWindow::SetStringParameters
void SetStringParameters(int widget) const override
Initialize string parameters for a widget.
Definition: depot_gui.cpp:424
WindowDesc
High level window description.
Definition: window_gui.h:168
WID_D_RENAME
@ WID_D_RENAME
Rename button.
Definition: depot_widget.h:29
CMD_DEPOT_MASS_AUTOREPLACE
@ CMD_DEPOT_MASS_AUTOREPLACE
force the autoreplace to take action in a given depot
Definition: command_type.h:319
window_gui.h
DepotWindow::DepotClick
void DepotClick(int x, int y)
Handle click in the depot matrix.
Definition: depot_gui.cpp:540
NC_EQUALSIZE
@ NC_EQUALSIZE
Value of the NCB_EQUALSIZE flag.
Definition: widget_type.h:463
WID_D_AUTOREPLACE
@ WID_D_AUTOREPLACE
Autoreplace button.
Definition: depot_widget.h:20
EngineID
uint16 EngineID
Unique identification number of an engine.
Definition: engine_type.h:21
depot_base.h
GroundVehicleCache::cached_total_length
uint16 cached_total_length
Length of the whole vehicle (valid only for the first engine).
Definition: ground_vehicle.hpp:42
DepotWindow::SetupWidgetData
void SetupWidgetData(VehicleType type)
Function to set up vehicle specific widgets (mainly sprites and strings).
Definition: depot_gui.cpp:589
WDP_AUTO
@ WDP_AUTO
Find a place automatically.
Definition: window_gui.h:156
Window::resize
ResizeInfo resize
Resize information.
Definition: window_gui.h:317
GetVehicleHeight
static uint GetVehicleHeight(VehicleType type)
Get the height of a single vehicle in the GUIs.
Definition: vehicle_gui.h:68
CommandCost
Common return value for all commands.
Definition: command_type.h:23
DepotWindow::GetDepotIndex
uint16 GetDepotIndex() const
Gets the DepotID of the current window.
Definition: depot_gui.cpp:1082
GuiShowTooltips
void GuiShowTooltips(Window *parent, StringID str, uint paramcount, const uint64 params[], TooltipCloseCondition close_tooltip)
Shows a tooltip.
Definition: misc_gui.cpp:767
tilehighlight_func.h
CursorID
uint32 CursorID
The number of the cursor (sprite)
Definition: gfx_type.h:19
DoCommandP
bool DoCommandP(const CommandContainer *container, bool my_cmd)
Shortcut for the long DoCommandP when having a container with the data.
Definition: command.cpp:541
StartStopVehicle
void StartStopVehicle(const Vehicle *v, bool texteffect)
Executes CMD_START_STOP_VEHICLE for given vehicle.
Definition: vehicle_gui.cpp:2609
WID_D_START_ALL
@ WID_D_START_ALL
Start all button.
Definition: depot_widget.h:32
VEH_COMPANY_END
@ VEH_COMPANY_END
Last company-ownable type.
Definition: vehicle_type.h:29
Window::height
int height
Height of the window (number of pixels down in y direction)
Definition: window_gui.h:315
VehicleClicked
bool VehicleClicked(const Vehicle *v)
Dispatch a "vehicle selected" event if any window waits for it.
Definition: vehicle_gui.cpp:3064
Vehicle::tile
TileIndex tile
Current tile index.
Definition: vehicle_base.h:242
INVALID_VEHICLE
static const VehicleID INVALID_VEHICLE
Constant representing a non-existing vehicle.
Definition: vehicle_type.h:55
_base_block_sizes_purchase
static VehicleCellSize _base_block_sizes_purchase[VEH_COMPANY_END]
Cell size for vehicle images in the purchase list.
Definition: depot_gui.cpp:148
Window::SetDirty
void SetDirty() const
Mark entire window as dirty (in need of re-paint)
Definition: window.cpp:993
DepotWindow::DrawVehicleInDepot
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:309
Vehicle::engine_type
EngineID engine_type
The type of engine used for this vehicle.
Definition: vehicle_base.h:299
WD_FRAMERECT_LEFT
@ WD_FRAMERECT_LEFT
Offset at left to draw the frame rectangular area.
Definition: window_gui.h:62
FS_SMALL
@ FS_SMALL
Index of the small font in the font tables.
Definition: gfx_type.h:208
WD_PAR_VSEP_NORMAL
@ WD_PAR_VSEP_NORMAL
Normal amount of vertical space between two paragraphs of text.
Definition: window_gui.h:139
WD_FRAMERECT_RIGHT
@ WD_FRAMERECT_RIGHT
Offset at right to draw the frame rectangular area.
Definition: window_gui.h:63
DrawTrainImage
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
ES_NOT_HANDLED
@ ES_NOT_HANDLED
The passed event is not handled.
Definition: window_type.h:719
CommandCost::Failed
bool Failed() const
Did this command fail?
Definition: command_type.h:159
WWT_PUSHTXTBTN
@ WWT_PUSHTXTBTN
Normal push-button (no toggle button) with text caption.
Definition: widget_type.h:104
WID_D_MATRIX
@ WID_D_MATRIX
Matrix of vehicles.
Definition: depot_widget.h:21
NWidgetBase
Baseclass for nested widgets.
Definition: widget_type.h:126
DepotWindow::OnCTRLStateChange
EventState OnCTRLStateChange() override
The state of the control key has changed.
Definition: depot_gui.cpp:1066
Vehicle::max_age
Date max_age
Maximum age.
Definition: vehicle_base.h:271
GroundVehicle::gcache
GroundVehicleCache gcache
Cache of often calculated values.
Definition: ground_vehicle.hpp:80
VehicleListIdentifier::Pack
uint32 Pack() const
Pack a VehicleListIdentifier in a single uint32.
Definition: vehiclelist.cpp:21
Vehicle::IsFrontEngine
bool IsFrontEngine() const
Check if the vehicle is a front engine.
Definition: vehicle_base.h:897
DepotWindow::hovered_widget
int hovered_widget
Index of the widget being hovered during drag/drop. -1 if no drag is in progress.
Definition: depot_gui.cpp:258
WID_D_H_SCROLL
@ WID_D_H_SCROLL
Horizontal scrollbar.
Definition: depot_widget.h:24
VS_STOPPED
@ VS_STOPPED
Vehicle is stopped by the player.
Definition: vehicle_base.h:32
_local_company
CompanyID _local_company
Company controlled by the human player at this client. Can also be COMPANY_SPECTATOR.
Definition: company_cmd.cpp:46
BuildDepotVehicleList
void BuildDepotVehicleList(VehicleType type, TileIndex tile, VehicleList *engines, VehicleList *wagons, bool individual_wagons)
Generate a list of vehicles inside a depot.
Definition: vehiclelist.cpp:69
safeguards.h
ShowQueryString
void ShowQueryString(StringID str, StringID caption, uint maxsize, Window *parent, CharSetFilter afilter, QueryStringFlags flags)
Show a query popup window with a textbox in it.
Definition: misc_gui.cpp:1118
Window::left
int left
x position of left edge of the window
Definition: window_gui.h:312
_nested_train_depot_widgets
static const NWidgetPart _nested_train_depot_widgets[]
Nested widget definition for train depots.
Definition: depot_gui.cpp:43
Sprite::width
uint16 width
Width of the sprite.
Definition: spritecache.h:19
DepotWindow::DrawWidget
void DrawWidget(const Rect &r, int widget) const override
Draw the contents of a nested widget.
Definition: depot_gui.cpp:366
Train
'Train' is either a loco or a wagon.
Definition: train.h:86
MAKE_ORDER_BACKUP_FLAG
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:30
IsTileOwner
static bool IsTileOwner(TileIndex tile, Owner owner)
Checks if a tile belongs to the given owner.
Definition: tile_map.h:214
SetMouseCursorVehicle
void SetMouseCursorVehicle(const Vehicle *v, EngineImageType image_type)
Set the mouse cursor to look like a vehicle.
Definition: vehicle_gui.cpp:3148
DepotWindow::OnMouseDrag
void OnMouseDrag(Point pt, int widget) override
An 'object' is being dragged at the provided position, highlight the target if possible.
Definition: depot_gui.cpp:936
DrawSprite
void DrawSprite(SpriteID img, PaletteID pal, int x, int y, const SubSprite *sub, ZoomLevel zoom)
Draw a sprite, not in a viewport.
Definition: gfx.cpp:1041
Point
Coordinates of a point in 2D.
Definition: geometry_type.hpp:21
DrawShipImage
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
WSM_DRAGDROP
@ WSM_DRAGDROP
Drag&drop an object.
Definition: window_gui.h:966
WID_D_LOCATION
@ WID_D_LOCATION
Location button.
Definition: depot_widget.h:27
DAYS_IN_LEAP_YEAR
static const int DAYS_IN_LEAP_YEAR
sometimes, you need one day more...
Definition: date_type.h:30
stdafx.h
Window::window_number
WindowNumber window_number
Window number within the window class.
Definition: window_gui.h:307
VehicleType
VehicleType
Available vehicle types.
Definition: vehicle_type.h:21
DepotWindow::OnPlaceObjectAbort
void OnPlaceObjectAbort() override
The user cancelled a tile highlight mode that has been set.
Definition: depot_gui.cpp:918
ResizeInfo::step_height
uint step_height
Step-size of height resize changes.
Definition: window_gui.h:220
OrderBackup::Reset
static void Reset(TileIndex tile=INVALID_TILE, bool from_gui=true)
Reset the OrderBackups from GUI/game logic.
Definition: order_backup.cpp:183
CS_ALPHANUMERAL
@ CS_ALPHANUMERAL
Both numeric and alphabetic and spaces and stuff.
Definition: string_type.h:27
viewport_func.h
NWidgetBase::current_y
uint current_y
Current vertical size (after resizing).
Definition: widget_type.h:187
WC_NONE
@ WC_NONE
No window, redirects to WC_MAIN_WINDOW.
Definition: window_type.h:37
EIT_IN_DEPOT
@ EIT_IN_DEPOT
Vehicle drawn in depot.
Definition: vehicle_type.h:87
NWID_VERTICAL
@ NWID_VERTICAL
Vertical container.
Definition: widget_type.h:75
GetTileOwner
static Owner GetTileOwner(TileIndex tile)
Returns the owner of a tile.
Definition: tile_map.h:178
HT_VEHICLE
@ HT_VEHICLE
vehicle is accepted as target as well (bitmask)
Definition: tilehighlight_type.h:27
FONT_HEIGHT_SMALL
#define FONT_HEIGHT_SMALL
Height of characters in the small (FS_SMALL) font.
Definition: gfx_func.h:162
HT_DRAG
@ HT_DRAG
dragging items in the depot windows
Definition: tilehighlight_type.h:24
WWT_CLOSEBOX
@ WWT_CLOSEBOX
Close box (at top-left of a window)
Definition: widget_type.h:67
WWT_RESIZEBOX
@ WWT_RESIZEBOX
Resize box (normally at bottom-right of a window)
Definition: widget_type.h:66
GetWindowClassForVehicleType
static WindowClass GetWindowClassForVehicleType(VehicleType vt)
Get WindowClass for vehicle list of given vehicle type.
Definition: vehicle_gui.h:91
DepotWindow::OnDragDrop
void OnDragDrop(Point pt, int widget) override
A dragged 'object' has been released.
Definition: depot_gui.cpp:988
Scrollbar::SetCapacity
void SetCapacity(int capacity)
Set the capacity of visible elements.
Definition: widget_type.h:726
spritecache.h
WWT_PUSHIMGBTN
@ WWT_PUSHIMGBTN
Normal push-button (no toggle button) with image caption.
Definition: widget_type.h:105
ShowQuery
void ShowQuery(StringID caption, StringID message, Window *parent, QueryCallbackProc *callback)
Show a modal confirmation window with standard 'yes' and 'no' buttons The window is aligned to the ce...
Definition: misc_gui.cpp:1267
vehicle_func.h
EndContainer
static NWidgetPart EndContainer()
Widget part function for denoting the end of a container (horizontal, vertical, WWT_FRAME,...
Definition: widget_type.h:1092
DepotWindow::GetDepotVehiclePtData
Definition: depot_gui.cpp:432
Clamp
static T Clamp(const T a, const T min, const T max)
Clamp a value between an interval.
Definition: math_func.hpp:77
strings_func.h
NWID_VSCROLLBAR
@ NWID_VSCROLLBAR
Vertical scrollbar.
Definition: widget_type.h:82
GetAircraftSpriteSize
void GetAircraftSpriteSize(EngineID engine, uint &width, uint &height, int &xoffs, int &yoffs, EngineImageType image_type)
Get the size of the sprite of an aircraft sprite heading west (used for lists).
Definition: aircraft_cmd.cpp:245
CMD_CLONE_VEHICLE
@ CMD_CLONE_VEHICLE
clone a vehicle
Definition: command_type.h:314
ResizeInfo::step_width
uint step_width
Step-size of width resize changes.
Definition: window_gui.h:219
DrawRoadVehImage
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.
Definition: roadveh_gui.cpp:129
NWidgetBase::pos_x
int pos_x
Horizontal position of top-left corner of the widget in the window.
Definition: widget_type.h:189
depot_widget.h
CMD_MASS_START_STOP
@ CMD_MASS_START_STOP
start/stop all vehicles (in a depot)
Definition: command_type.h:316
DepotWindow::OnClick
void OnClick(Point pt, int widget, int click_count) override
A click with the left mouse button has been made on the window.
Definition: depot_gui.cpp:758
WC_BUILD_VEHICLE
@ WC_BUILD_VEHICLE
Build vehicle; Window numbers:
Definition: window_type.h:375
WIDGET_LIST_END
static const int WIDGET_LIST_END
indicate the end of widgets' list for vararg functions
Definition: widget_type.h:20
MAX_LENGTH_DEPOT_NAME_CHARS
static const uint MAX_LENGTH_DEPOT_NAME_CHARS
The maximum length of a depot name in characters including '\0'.
Definition: depot_type.h:16
SpecializedVehicle< Train, Type >::From
static Train * From(Vehicle *v)
Converts a Vehicle to SpecializedVehicle with type checking.
Definition: vehicle_base.h:1164
DepotWindow::OnResize
void OnResize() override
Called after the window got resized.
Definition: depot_gui.cpp:1055
FONT_HEIGHT_NORMAL
#define FONT_HEIGHT_NORMAL
Height of characters in the normal (FS_NORMAL) font.
Definition: gfx_func.h:165
GetTrainSpriteSize
void GetTrainSpriteSize(EngineID engine, uint &width, uint &height, int &xoffs, int &yoffs, EngineImageType image_type)
Get the size of the sprite of a train sprite heading west, or both heads (used for lists).
Definition: train_cmd.cpp:557
ScaleGUITrad
static int ScaleGUITrad(int value)
Scale traditional pixel dimensions to GUI zoom level.
Definition: zoom_func.h:76
NWidget
static NWidgetPart NWidget(WidgetType tp, Colours col, int16 idx=-1)
Widget part function for starting a new 'real' widget.
Definition: widget_type.h:1207
WID_D_SELL
@ WID_D_SELL
Sell button.
Definition: depot_widget.h:16
SetDParamMaxValue
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:94
SetMinimalSize
static NWidgetPart SetMinimalSize(int16 x, int16 y)
Widget part function for setting the minimal size.
Definition: widget_type.h:1010
GetRoadVehSpriteSize
void GetRoadVehSpriteSize(EngineID engine, uint &width, uint &height, int &xoffs, int &yoffs, EngineImageType image_type)
Get the size of the sprite of a road vehicle sprite heading west (used for lists).
Definition: roadveh_cmd.cpp:168
WID_D_SELL_CHAIN
@ WID_D_SELL_CHAIN
Sell chain button.
Definition: depot_widget.h:18
Window::SetWidgetsDisabledState
void CDECL SetWidgetsDisabledState(bool disab_stat, int widgets,...)
Sets the enabled/disabled status of a list of widgets.
Definition: window.cpp:547
NWidgetBase::resize_y
uint resize_y
Vertical resize step (0 means not resizable).
Definition: widget_type.h:179
WC_VEHICLE_DEPOT
@ WC_VEHICLE_DEPOT
Depot view; Window numbers:
Definition: window_type.h:343
Window::IsWidgetLowered
bool IsWidgetLowered(byte widget_index) const
Gets the lowered state of a widget.
Definition: window_gui.h:487
Vehicle::age
Date age
Age in days.
Definition: vehicle_base.h:270
NUM_CARGO
@ NUM_CARGO
Maximal number of cargo types in a game.
Definition: cargo_type.h:65
GetStationIndex
static StationID GetStationIndex(TileIndex t)
Get StationID from a tile.
Definition: station_map.h:28
_base_block_sizes_depot
static VehicleCellSize _base_block_sizes_depot[VEH_COMPANY_END]
Cell size for vehicle images in the depot view.
Definition: depot_gui.cpp:147
EventState
EventState
State of handling an event.
Definition: window_type.h:717
Scrollbar::GetPosition
uint16 GetPosition() const
Gets the position of the first visible element in the list.
Definition: widget_type.h:671
InitDepotWindowBlockSizes
void InitDepotWindowBlockSizes()
Set the size of the blocks in the window so we can be sure that they are big enough for the vehicle s...
Definition: depot_gui.cpp:215
NWidgetCore::colour
Colours colour
Colour of this widget.
Definition: widget_type.h:333
Window::FinishInitNested
void FinishInitNested(WindowNumber window_number=0)
Perform the second part of the initialization of a nested widget tree.
Definition: window.cpp:1776
Vehicle::unitnumber
UnitID unitnumber
unit number, for display purposes only
Definition: vehicle_base.h:302
company_func.h
VehicleCellSize
Dimensions of a cell in the purchase/depot windows.
Definition: vehicle_gui.h:77
CMD_RENAME_DEPOT
@ CMD_RENAME_DEPOT
rename a depot
Definition: command_type.h:249
Vehicle::Last
Vehicle * Last()
Get the last vehicle of this vehicle chain.
Definition: vehicle_base.h:613
VehicleID
uint32 VehicleID
The type all our vehicle IDs have.
Definition: vehicle_type.h:16
WD_MATRIX_BOTTOM
@ WD_MATRIX_BOTTOM
Offset at bottom of a matrix cell.
Definition: window_gui.h:81
ShowVehicleViewWindow
void ShowVehicleViewWindow(const Vehicle *v)
Shows the vehicle view window of the given vehicle.
Definition: vehicle_gui.cpp:3054
Window::ToggleWidgetLoweredState
void ToggleWidgetLoweredState(byte widget_index)
Invert the lowered/raised status of a widget.
Definition: window_gui.h:457
lengthof
#define lengthof(x)
Return the length of an fixed size array.
Definition: stdafx.h:378
Window::width
int width
width of the window (number of pixels to the right in x direction)
Definition: window_gui.h:314
DepotWindow::UpdateWidgetSize
void UpdateWidgetSize(int widget, Dimension *size, const Dimension &padding, Dimension *fill, Dimension *resize) override
Update size and resize step of a widget in the window.
Definition: depot_gui.cpp:650
Scrollbar::SetCapacityFromWidget
void SetCapacityFromWidget(Window *w, int widget, int padding=0)
Set capacity of visible elements from the size and resize properties of a widget.
Definition: widget.cpp:2172
CargoID
byte CargoID
Cargo slots to indicate a cargo type within a game.
Definition: cargo_type.h:20
CloseWindowById
void CloseWindowById(WindowClass cls, WindowNumber number, bool force)
Close a window by its class and window number (if it is open).
Definition: window.cpp:1176
NWidgetBase::pos_y
int pos_y
Vertical position of top-left corner of the widget in the window.
Definition: widget_type.h:190
SetObjectToPlaceWnd
void SetObjectToPlaceWnd(CursorID icon, PaletteID pal, HighLightStyle mode, Window *w)
Change the cursor and mouse click/drag handling to a mode for performing special operations like tile...
Definition: viewport.cpp:3360
CcCloneVehicle
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
SetFill
static NWidgetPart SetFill(uint fill_x, uint fill_y)
Widget part function for setting filling.
Definition: widget_type.h:1076
DepotWindow::OnVehicleSelect
bool OnVehicleSelect(const Vehicle *v) override
Clones a vehicle.
Definition: depot_gui.cpp:903
gui.h
SPR_CURSOR_MOUSE
static const CursorID SPR_CURSOR_MOUSE
Cursor sprite numbers.
Definition: sprites.h:1380
CeilDiv
static uint CeilDiv(uint a, uint b)
Computes ceil(a / b) for non-negative a and b.
Definition: math_func.hpp:254
WID_D_BUILD
@ WID_D_BUILD
Build button.
Definition: depot_widget.h:25
Window
Data structure for an opened window.
Definition: window_gui.h:279
GroundVehicle::IsFreeWagon
bool IsFreeWagon() const
Check if the vehicle is a free wagon (got no engine in front of it).
Definition: ground_vehicle.hpp:310
VEH_TRAIN
@ VEH_TRAIN
Train vehicle type.
Definition: vehicle_type.h:24
Window::RaiseWidget
void RaiseWidget(byte widget_index)
Marks a widget as raised.
Definition: window_gui.h:477
BaseVehicle::type
VehicleType type
Type of vehicle.
Definition: vehicle_type.h:52
Window::DrawWidgets
void DrawWidgets() const
Paint all widgets of a window.
Definition: widget.cpp:636
NWID_SELECTION
@ NWID_SELECTION
Stacked widgets, only one visible at a time (eg in a panel with tabs).
Definition: widget_type.h:78
order_backup.h
Window::IsWidgetDisabled
bool IsWidgetDisabled(byte widget_index) const
Gets the enabled/disabled status of a widget.
Definition: window_gui.h:415
NWidgetCore
Base class for a 'real' widget.
Definition: widget_type.h:311
Window::SetWidgetDirty
void SetWidgetDirty(byte widget_index) const
Invalidate a widget, i.e.
Definition: window.cpp:608
DepotWindow::OnInvalidateData
void OnInvalidateData(int data=0, bool gui_scope=true) override
Some data on this window has become invalid.
Definition: depot_gui.cpp:701
DeleteDepotHighlightOfVehicle
void DeleteDepotHighlightOfVehicle(const Vehicle *v)
Removes the highlight of a vehicle in a depot window.
Definition: depot_gui.cpp:1123
VEH_SHIP
@ VEH_SHIP
Ship vehicle type.
Definition: vehicle_type.h:26
Rect
Specification of a rectangle with absolute coordinates of all edges.
Definition: geometry_type.hpp:47
BringWindowToFrontById
Window * BringWindowToFrontById(WindowClass cls, WindowNumber number)
Find a window and make it the relative top-window on the screen.
Definition: window.cpp:1259
NWidgetBase::resize_x
uint resize_x
Horizontal resize step (0 means not resizable).
Definition: widget_type.h:178
DrawAircraftImage
void DrawAircraftImage(const Vehicle *v, int left, int right, int y, VehicleID selection, EngineImageType image_type)
Draws an image of an aircraft.
Definition: aircraft_gui.cpp:80
Sprite
Data structure describing a sprite.
Definition: spritecache.h:17
QSF_ENABLE_DEFAULT
@ QSF_ENABLE_DEFAULT
enable the 'Default' button ("\0" is returned)
Definition: textbuf_gui.h:21
NWidgetBase::current_x
uint current_x
Current horizontal size (after resizing).
Definition: widget_type.h:186
lastof
#define lastof(x)
Get the last element of an fixed size array.
Definition: stdafx.h:394
WID_D_SELL_ALL
@ WID_D_SELL_ALL
Sell all button.
Definition: depot_widget.h:19
SetDParamMaxDigits
void SetDParamMaxDigits(uint n, uint count, FontSize size)
Set DParam n to some number that is suitable for string size computations.
Definition: strings.cpp:110
ResetObjectToPlace
void ResetObjectToPlace()
Reset the cursor and mouse mode handling back to default (normal cursor, only clicking in windows).
Definition: viewport.cpp:3423
Window::SetWidgetLoweredState
void SetWidgetLoweredState(byte widget_index, bool lowered_stat)
Sets the lowered/raised status of a widget.
Definition: window_gui.h:447
DepotWindow::OnPaint
void OnPaint() override
The window must be repainted.
Definition: depot_gui.cpp:706
TD_RTL
@ TD_RTL
Text is written right-to-left by default.
Definition: strings_type.h:24
_current_text_dir
TextDirection _current_text_dir
Text direction of the currently selected language.
Definition: strings.cpp:48
CMD_DEPOT_SELL_ALL_VEHICLES
@ CMD_DEPOT_SELL_ALL_VEHICLES
sell all vehicles which are in a given depot
Definition: command_type.h:318
SpecializedVehicle::GetFirstEnginePart
T * GetFirstEnginePart()
Get the first part of an articulated engine.
Definition: vehicle_base.h:1105
DepotWindow::num_columns
uint num_columns
Number of columns.
Definition: depot_gui.cpp:262
VehicleCellSize::extend_left
uint extend_left
Extend of the cell to the left.
Definition: vehicle_gui.h:79
WWT_TEXTBTN
@ WWT_TEXTBTN
(Toggle) Button with text
Definition: widget_type.h:53
DepotWindow::vehicle_over
VehicleID vehicle_over
Rail vehicle over which another one is dragged, INVALID_VEHICLE if none.
Definition: depot_gui.cpp:255
roadveh.h
WWT_SHADEBOX
@ WWT_SHADEBOX
Shade box (at top-right of a window, between WWT_DEBUGBOX and WWT_DEFSIZEBOX)
Definition: widget_type.h:62
Window::Close
virtual void Close()
Hide the window and all its child windows, and mark them for a later deletion.
Definition: window.cpp:1092