OpenTTD
depot_gui.cpp
Go to the documentation of this file.
1 /* $Id: depot_gui.cpp 27938 2017-12-10 13:48:49Z frosch $ */
2 
3 /*
4  * This file is part of OpenTTD.
5  * 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.
6  * 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.
7  * 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/>.
8  */
9 
12 #include "stdafx.h"
13 #include "train.h"
14 #include "roadveh.h"
15 #include "ship.h"
16 #include "aircraft.h"
17 #include "gui.h"
18 #include "textbuf_gui.h"
19 #include "viewport_func.h"
20 #include "command_func.h"
21 #include "depot_base.h"
22 #include "spritecache.h"
23 #include "strings_func.h"
24 #include "vehicle_func.h"
25 #include "company_func.h"
26 #include "tilehighlight_func.h"
27 #include "window_gui.h"
28 #include "vehiclelist.h"
29 #include "order_backup.h"
30 #include "zoom_func.h"
31 
32 #include "widgets/depot_widget.h"
33 
34 #include "table/strings.h"
35 
36 #include "safeguards.h"
37 
38 /*
39  * Since all depot window sizes aren't the same, we need to modify sizes a little.
40  * 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.
41  * How long they should be moved and for what window types are controlled in ShowDepotWindow()
42  */
43 
47  NWidget(WWT_CLOSEBOX, COLOUR_GREY),
48  NWidget(WWT_CAPTION, COLOUR_GREY, WID_D_CAPTION), SetDataTip(STR_DEPOT_CAPTION, STR_NULL),
49  NWidget(WWT_SHADEBOX, COLOUR_GREY),
50  NWidget(WWT_DEFSIZEBOX, COLOUR_GREY),
51  NWidget(WWT_STICKYBOX, COLOUR_GREY),
52  EndContainer(),
56  NWidget(NWID_SELECTION, INVALID_COLOUR, WID_D_SHOW_H_SCROLL),
57  NWidget(NWID_HSCROLLBAR, COLOUR_GREY, WID_D_H_SCROLL),
58  EndContainer(),
59  EndContainer(),
61  NWidget(WWT_IMGBTN, COLOUR_GREY, WID_D_SELL), SetDataTip(0x0, STR_NULL), SetResize(0, 1), SetFill(0, 1),
63  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),
64  EndContainer(),
65  NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_D_SELL_ALL), SetDataTip(0x0, STR_NULL),
66  NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_D_AUTOREPLACE), SetDataTip(0x0, STR_NULL),
67  EndContainer(),
68  NWidget(NWID_VSCROLLBAR, COLOUR_GREY, WID_D_V_SCROLL),
69  EndContainer(),
71  NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_D_BUILD), SetDataTip(0x0, STR_NULL), SetFill(1, 1), SetResize(1, 0),
72  NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_D_CLONE), SetDataTip(0x0, STR_NULL), SetFill(1, 1), SetResize(1, 0),
73  NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_D_LOCATION), SetDataTip(STR_BUTTON_LOCATION, STR_NULL), SetFill(1, 1), SetResize(1, 0),
74  NWidget(NWID_SELECTION, INVALID_COLOUR, WID_D_SHOW_RENAME), // rename button
75  NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_D_RENAME), SetDataTip(STR_BUTTON_RENAME, STR_DEPOT_RENAME_TOOLTIP), SetFill(1, 1), SetResize(1, 0),
76  EndContainer(),
77  NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_D_VEHICLE_LIST), SetDataTip(0x0, STR_NULL), SetFill(0, 1),
78  NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_D_STOP_ALL), SetDataTip(SPR_FLAG_VEH_STOPPED, STR_NULL), SetFill(0, 1),
79  NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_D_START_ALL), SetDataTip(SPR_FLAG_VEH_RUNNING, STR_NULL), SetFill(0, 1),
80  NWidget(WWT_RESIZEBOX, COLOUR_GREY),
81  EndContainer(),
82 };
83 
84 static WindowDesc _train_depot_desc(
85  WDP_AUTO, "depot_train", 362, 123,
87  0,
88  _nested_train_depot_widgets, lengthof(_nested_train_depot_widgets)
89 );
90 
91 static WindowDesc _road_depot_desc(
92  WDP_AUTO, "depot_roadveh", 316, 97,
94  0,
95  _nested_train_depot_widgets, lengthof(_nested_train_depot_widgets)
96 );
97 
98 static WindowDesc _ship_depot_desc(
99  WDP_AUTO, "depot_ship", 306, 99,
101  0,
102  _nested_train_depot_widgets, lengthof(_nested_train_depot_widgets)
103 );
104 
105 static WindowDesc _aircraft_depot_desc(
106  WDP_AUTO, "depot_aircraft", 332, 99,
108  0,
109  _nested_train_depot_widgets, lengthof(_nested_train_depot_widgets)
110 );
111 
112 extern void DepotSortList(VehicleList *list);
113 
121 void CcCloneVehicle(const CommandCost &result, TileIndex tile, uint32 p1, uint32 p2)
122 {
123  if (result.Failed()) return;
124 
125  const Vehicle *v = Vehicle::Get(_new_vehicle_id);
126 
128 }
129 
130 static void TrainDepotMoveVehicle(const Vehicle *wagon, VehicleID sel, const Vehicle *head)
131 {
132  const Vehicle *v = Vehicle::Get(sel);
133 
134  if (v == wagon) return;
135 
136  if (wagon == NULL) {
137  if (head != NULL) wagon = head->Last();
138  } else {
139  wagon = wagon->Previous();
140  if (wagon == NULL) return;
141  }
142 
143  if (wagon == v) return;
144 
145  DoCommandP(v->tile, v->index | (_ctrl_pressed ? 1 : 0) << 20, wagon == NULL ? INVALID_VEHICLE : wagon->index, CMD_MOVE_RAIL_VEHICLE | CMD_MSG(STR_ERROR_CAN_T_MOVE_VEHICLE));
146 }
147 
151 
160 {
161  switch (image_type) {
162  case EIT_IN_DEPOT: return _base_block_sizes_depot[type];
163  case EIT_PURCHASE: return _base_block_sizes_purchase[type];
164  default: NOT_REACHED();
165  }
166 }
167 
168 static void InitBlocksizeForVehicles(VehicleType type, EngineImageType image_type)
169 {
170  int max_extend_left = 0;
171  int max_extend_right = 0;
172  uint max_height = 0;
173 
174  const Engine *e;
175  FOR_ALL_ENGINES_OF_TYPE(e, type) {
176  if (!e->IsEnabled()) continue;
177 
178  EngineID eid = e->index;
179  uint x, y;
180  int x_offs, y_offs;
181 
182  switch (type) {
183  default: NOT_REACHED();
184  case VEH_TRAIN: GetTrainSpriteSize( eid, x, y, x_offs, y_offs, image_type); break;
185  case VEH_ROAD: GetRoadVehSpriteSize( eid, x, y, x_offs, y_offs, image_type); break;
186  case VEH_SHIP: GetShipSpriteSize( eid, x, y, x_offs, y_offs, image_type); break;
187  case VEH_AIRCRAFT: GetAircraftSpriteSize(eid, x, y, x_offs, y_offs, image_type); break;
188  }
189  if (y > max_height) max_height = y;
190  if (-x_offs > max_extend_left) max_extend_left = -x_offs;
191  if ((int)x + x_offs > max_extend_right) max_extend_right = x + x_offs;
192  }
193 
194  int min_extend = ScaleGUITrad(16);
195  int max_extend = ScaleGUITrad(98);
196 
197  switch (image_type) {
198  case EIT_IN_DEPOT:
199  _base_block_sizes_depot[type].height = max<uint>(ScaleGUITrad(GetVehicleHeight(type)), max_height);
200  _base_block_sizes_depot[type].extend_left = Clamp(max_extend_left, min_extend, max_extend);
201  _base_block_sizes_depot[type].extend_right = Clamp(max_extend_right, min_extend, max_extend);
202  break;
203  case EIT_PURCHASE:
204  _base_block_sizes_purchase[type].height = max<uint>(ScaleGUITrad(GetVehicleHeight(type)), max_height);
205  _base_block_sizes_purchase[type].extend_left = Clamp(max_extend_left, min_extend, max_extend);
206  _base_block_sizes_purchase[type].extend_right = Clamp(max_extend_right, min_extend, max_extend);
207  break;
208 
209  default: NOT_REACHED();
210  }
211 }
212 
218 {
219  for (VehicleType vt = VEH_BEGIN; vt < VEH_COMPANY_END; vt++) {
220  InitBlocksizeForVehicles(vt, EIT_IN_DEPOT);
221  InitBlocksizeForVehicles(vt, EIT_PURCHASE);
222  }
223 
224  _consistent_train_width = TRAININFO_DEFAULT_VEHICLE_WIDTH;
225  bool first = true;
226  const Engine *e;
227  FOR_ALL_ENGINES_OF_TYPE(e, VEH_TRAIN) {
228  if (!e->IsEnabled()) continue;
229 
230  uint w = TRAININFO_DEFAULT_VEHICLE_WIDTH;
231  if (e->GetGRF() != NULL && is_custom_sprite(e->u.rail.image_index)) {
233  if (w != VEHICLEINFO_FULL_VEHICLE_WIDTH) {
234  /* Hopeless.
235  * This is a NewGRF vehicle that uses TRAININFO_DEFAULT_VEHICLE_WIDTH.
236  * If the vehicles are shorter than 8/8 we have fractional lengths, which are not consistent after rounding.
237  */
239  break;
240  }
241  }
242 
243  if (first) {
245  first = false;
246  } else if (w != _consistent_train_width) {
248  break;
249  }
250  }
251 }
252 
253 static void DepotSellAllConfirmationCallback(Window *w, bool confirmed);
254 const Sprite *GetAircraftSprite(EngineID engine);
255 
256 struct DepotWindow : Window {
257  VehicleID sel;
259  VehicleType type;
260  bool generate_list;
262  VehicleList vehicle_list;
263  VehicleList wagon_list;
264  uint unitnumber_digits;
265  uint num_columns;
267  Scrollbar *vscroll;
268 
269  DepotWindow(WindowDesc *desc, TileIndex tile, VehicleType type) : Window(desc)
270  {
271  assert(IsCompanyBuildableVehicleType(type)); // ensure that we make the call with a valid type
272 
273  this->sel = INVALID_VEHICLE;
274  this->vehicle_over = INVALID_VEHICLE;
275  this->generate_list = true;
276  this->hovered_widget = -1;
277  this->type = type;
278  this->num_columns = 1; // for non-trains this gets set in FinishInitNested()
279  this->unitnumber_digits = 2;
280 
281  this->CreateNestedTree();
282  this->hscroll = (this->type == VEH_TRAIN ? this->GetScrollbar(WID_D_H_SCROLL) : NULL);
283  this->vscroll = this->GetScrollbar(WID_D_V_SCROLL);
284  /* Don't show 'rename button' of aircraft hangar */
285  this->GetWidget<NWidgetStacked>(WID_D_SHOW_RENAME)->SetDisplayedPlane(type == VEH_AIRCRAFT ? SZSP_NONE : 0);
286  /* Only train depots have a horizontal scrollbar and a 'sell chain' button */
287  if (type == VEH_TRAIN) this->GetWidget<NWidgetCore>(WID_D_MATRIX)->widget_data = 1 << MAT_COL_START;
288  this->GetWidget<NWidgetStacked>(WID_D_SHOW_H_SCROLL)->SetDisplayedPlane(type == VEH_TRAIN ? 0 : SZSP_HORIZONTAL);
289  this->GetWidget<NWidgetStacked>(WID_D_SHOW_SELL_CHAIN)->SetDisplayedPlane(type == VEH_TRAIN ? 0 : SZSP_NONE);
290  this->SetupWidgetData(type);
291  this->FinishInitNested(tile);
292 
293  this->owner = GetTileOwner(tile);
295  }
296 
297  ~DepotWindow()
298  {
301  }
302 
310  void DrawVehicleInDepot(const Vehicle *v, int left, int right, int y) const
311  {
312  bool free_wagon = false;
313  int sprite_y = y + (this->resize.step_height - ScaleGUITrad(GetVehicleHeight(v->type))) / 2;
314 
315  bool rtl = _current_text_dir == TD_RTL;
316  int image_left = rtl ? left + this->count_width : left + this->header_width;
317  int image_right = rtl ? right - this->header_width : right - this->count_width;
318 
319  switch (v->type) {
320  case VEH_TRAIN: {
321  const Train *u = Train::From(v);
322  free_wagon = u->IsFreeWagon();
323 
324  uint x_space = free_wagon ?
325  ScaleGUITrad(_consistent_train_width != 0 ? _consistent_train_width : TRAININFO_DEFAULT_VEHICLE_WIDTH) :
326  0;
327 
328  DrawTrainImage(u, image_left + (rtl ? 0 : x_space), image_right - (rtl ? x_space : 0), sprite_y - 1,
329  this->sel, EIT_IN_DEPOT, free_wagon ? 0 : this->hscroll->GetPosition(), this->vehicle_over);
330 
331  /* Length of consist in tiles with 1 fractional digit (rounded up) */
333  SetDParam(1, 1);
334  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
335  break;
336  }
337 
338  case VEH_ROAD: DrawRoadVehImage( v, image_left, image_right, sprite_y, this->sel, EIT_IN_DEPOT); break;
339  case VEH_SHIP: DrawShipImage( v, image_left, image_right, sprite_y, this->sel, EIT_IN_DEPOT); break;
340  case VEH_AIRCRAFT: DrawAircraftImage(v, image_left, image_right, sprite_y, this->sel, EIT_IN_DEPOT); break;
341  default: NOT_REACHED();
342  }
343 
344  uint diff_x, diff_y;
345  if (v->IsGroundVehicle()) {
346  /* Arrange unitnumber and flag horizontally */
347  diff_x = this->flag_width + WD_FRAMERECT_LEFT;
348  diff_y = (this->resize.step_height - this->flag_height) / 2 - 2;
349  } else {
350  /* Arrange unitnumber and flag vertically */
351  diff_x = WD_FRAMERECT_LEFT;
353  }
354  int text_left = rtl ? right - this->header_width - 1 : left + diff_x;
355  int text_right = rtl ? right - diff_x : left + this->header_width - 1;
356 
357  if (free_wagon) {
358  DrawString(text_left, text_right, y + 2, STR_DEPOT_NO_ENGINE);
359  } else {
360  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);
361 
362  SetDParam(0, v->unitnumber);
363  DrawString(text_left, text_right, y + 2, (uint16)(v->max_age - DAYS_IN_LEAP_YEAR) >= v->age ? STR_BLACK_COMMA : STR_RED_COMMA);
364  }
365  }
366 
367  void DrawWidget(const Rect &r, int widget) const
368  {
369  if (widget != WID_D_MATRIX) return;
370 
371  bool rtl = _current_text_dir == TD_RTL;
372 
373  /* Set the row and number of boxes in each row based on the number of boxes drawn in the matrix */
374  const NWidgetCore *wid = this->GetWidget<NWidgetCore>(WID_D_MATRIX);
375 
376  /* Draw vertical separators at whole tiles.
377  * This only works in two cases:
378  * - All vehicles use VEHICLEINFO_FULL_VEHICLE_WIDTH as reference width.
379  * - All vehicles are 8/8. This cannot be checked for NewGRF, so instead we check for "all vehicles are original vehicles".
380  */
381  if (this->type == VEH_TRAIN && _consistent_train_width != 0) {
383  int col = _colour_gradient[wid->colour][4];
384  int image_left = rtl ? r.left + this->count_width : r.left + this->header_width;
385  int image_right = rtl ? r.right - this->header_width : r.right - this->count_width;
386  int first_line = w + (-this->hscroll->GetPosition()) % w;
387  if (rtl) {
388  for (int x = image_right - first_line; x >= image_left; x -= w) {
389  GfxDrawLine(x, r.top, x, r.bottom, col, 1, 3);
390  }
391  } else {
392  for (int x = image_left + first_line; x <= image_right; x += w) {
393  GfxDrawLine(x, r.top, x, r.bottom, col, 1, 3);
394  }
395  }
396  }
397 
398  uint16 rows_in_display = wid->current_y / wid->resize_y;
399 
400  uint16 num = this->vscroll->GetPosition() * this->num_columns;
401  int maxval = min(this->vehicle_list.Length(), num + (rows_in_display * this->num_columns));
402  int y;
403  for (y = r.top + 1; num < maxval; y += this->resize.step_height) { // Draw the rows
404  for (byte i = 0; i < this->num_columns && num < maxval; i++, num++) {
405  /* Draw all vehicles in the current row */
406  const Vehicle *v = this->vehicle_list[num];
407  if (this->num_columns == 1) {
408  this->DrawVehicleInDepot(v, r.left, r.right, y);
409  } else {
410  int x = r.left + (rtl ? (this->num_columns - i - 1) : i) * this->resize.step_width;
411  this->DrawVehicleInDepot(v, x, x + this->resize.step_width - 1, y);
412  }
413  }
414  }
415 
416  maxval = min(this->vehicle_list.Length() + this->wagon_list.Length(), (this->vscroll->GetPosition() * this->num_columns) + (rows_in_display * this->num_columns));
417 
418  /* Draw the train wagons without an engine in front. */
419  for (; num < maxval; num++, y += this->resize.step_height) {
420  const Vehicle *v = this->wagon_list[num - this->vehicle_list.Length()];
421  this->DrawVehicleInDepot(v, r.left, r.right, y);
422  }
423  }
424 
425  void SetStringParameters(int widget) const
426  {
427  if (widget != WID_D_CAPTION) return;
428 
429  /* locate the depot struct */
430  TileIndex tile = this->window_number;
431  SetDParam(0, this->type);
432  SetDParam(1, (this->type == VEH_AIRCRAFT) ? GetStationIndex(tile) : GetDepotIndex(tile));
433  }
434 
436  const Vehicle *head;
437  const Vehicle *wagon;
438  };
439 
440  enum DepotGUIAction {
441  MODE_ERROR,
442  MODE_DRAG_VEHICLE,
443  MODE_SHOW_VEHICLE,
444  MODE_START_STOP,
445  };
446 
447  DepotGUIAction GetVehicleFromDepotWndPt(int x, int y, const Vehicle **veh, GetDepotVehiclePtData *d) const
448  {
449  const NWidgetCore *matrix_widget = this->GetWidget<NWidgetCore>(WID_D_MATRIX);
450  /* In case of RTL the widgets are swapped as a whole */
451  if (_current_text_dir == TD_RTL) x = matrix_widget->current_x - x;
452 
453  uint xt = 0, xm = 0, ym = 0;
454  if (this->type == VEH_TRAIN) {
455  xm = x;
456  } else {
457  xt = x / this->resize.step_width;
458  xm = x % this->resize.step_width;
459  if (xt >= this->num_columns) return MODE_ERROR;
460  }
461  ym = y % this->resize.step_height;
462 
463  uint row = y / this->resize.step_height;
464  if (row >= this->vscroll->GetCapacity()) return MODE_ERROR;
465 
466  uint pos = ((row + this->vscroll->GetPosition()) * this->num_columns) + xt;
467 
468  if (this->vehicle_list.Length() + this->wagon_list.Length() <= pos) {
469  /* Clicking on 'line' / 'block' without a vehicle */
470  if (this->type == VEH_TRAIN) {
471  /* End the dragging */
472  d->head = NULL;
473  d->wagon = NULL;
474  return MODE_DRAG_VEHICLE;
475  } else {
476  return MODE_ERROR; // empty block, so no vehicle is selected
477  }
478  }
479 
480  bool wagon = false;
481  if (this->vehicle_list.Length() > pos) {
482  *veh = this->vehicle_list[pos];
483  /* Skip vehicles that are scrolled off the list */
484  if (this->type == VEH_TRAIN) x += this->hscroll->GetPosition();
485  } else {
486  pos -= this->vehicle_list.Length();
487  *veh = this->wagon_list[pos];
488  /* free wagons don't have an initial loco. */
489  x -= ScaleGUITrad(VEHICLEINFO_FULL_VEHICLE_WIDTH);
490  wagon = true;
491  }
492 
493  const Train *v = NULL;
494  if (this->type == VEH_TRAIN) {
495  v = Train::From(*veh);
496  d->head = d->wagon = v;
497  }
498 
499  if (xm <= this->header_width) {
500  switch (this->type) {
501  case VEH_TRAIN:
502  if (wagon) return MODE_ERROR;
503  FALLTHROUGH;
504 
505  case VEH_ROAD:
506  if (xm <= this->flag_width) return MODE_START_STOP;
507  break;
508 
509  case VEH_SHIP:
510  case VEH_AIRCRAFT:
511  if (xm <= this->flag_width && ym >= (uint)(FONT_HEIGHT_NORMAL + WD_PAR_VSEP_NORMAL)) return MODE_START_STOP;
512  break;
513 
514  default: NOT_REACHED();
515  }
516  return MODE_SHOW_VEHICLE;
517  }
518 
519  if (this->type != VEH_TRAIN) return MODE_DRAG_VEHICLE;
520 
521  /* Clicking on the counter */
522  if (xm >= matrix_widget->current_x - this->count_width) return wagon ? MODE_ERROR : MODE_SHOW_VEHICLE;
523 
524  /* Account for the header */
525  x -= this->header_width;
526 
527  /* find the vehicle in this row that was clicked */
528  for (; v != NULL; v = v->Next()) {
529  x -= v->GetDisplayImageWidth();
530  if (x < 0) break;
531  }
532 
533  d->wagon = (v != NULL ? v->GetFirstEnginePart() : NULL);
534 
535  return MODE_DRAG_VEHICLE;
536  }
537 
543  void DepotClick(int x, int y)
544  {
545  GetDepotVehiclePtData gdvp = { NULL, NULL };
546  const Vehicle *v = NULL;
547  DepotGUIAction mode = this->GetVehicleFromDepotWndPt(x, y, &v, &gdvp);
548 
549  if (this->type == VEH_TRAIN) v = gdvp.wagon;
550 
551  switch (mode) {
552  case MODE_ERROR: // invalid
553  return;
554 
555  case MODE_DRAG_VEHICLE: { // start dragging of vehicle
556  if (v != NULL && VehicleClicked(v)) return;
557 
558  VehicleID sel = this->sel;
559 
560  if (this->type == VEH_TRAIN && sel != INVALID_VEHICLE) {
561  this->sel = INVALID_VEHICLE;
562  TrainDepotMoveVehicle(v, sel, gdvp.head);
563  } else if (v != NULL) {
564  SetObjectToPlaceWnd(SPR_CURSOR_MOUSE, PAL_NONE, HT_DRAG, this);
566  _cursor.vehchain = _ctrl_pressed;
567 
568  this->sel = v->index;
569  this->SetDirty();
570  }
571  break;
572  }
573 
574  case MODE_SHOW_VEHICLE: // show info window
576  break;
577 
578  case MODE_START_STOP: // click start/stop flag
579  StartStopVehicle(v, false);
580  break;
581 
582  default: NOT_REACHED();
583  }
584  }
585 
593  {
594  this->GetWidget<NWidgetCore>(WID_D_STOP_ALL)->tool_tip = STR_DEPOT_MASS_STOP_DEPOT_TRAIN_TOOLTIP + type;
595  this->GetWidget<NWidgetCore>(WID_D_START_ALL)->tool_tip = STR_DEPOT_MASS_START_DEPOT_TRAIN_TOOLTIP + type;
596  this->GetWidget<NWidgetCore>(WID_D_SELL)->tool_tip = STR_DEPOT_TRAIN_SELL_TOOLTIP + type;
597  this->GetWidget<NWidgetCore>(WID_D_SELL_ALL)->tool_tip = STR_DEPOT_SELL_ALL_BUTTON_TRAIN_TOOLTIP + type;
598 
599  this->GetWidget<NWidgetCore>(WID_D_BUILD)->SetDataTip(STR_DEPOT_TRAIN_NEW_VEHICLES_BUTTON + type, STR_DEPOT_TRAIN_NEW_VEHICLES_TOOLTIP + type);
600  this->GetWidget<NWidgetCore>(WID_D_CLONE)->SetDataTip(STR_DEPOT_CLONE_TRAIN + type, STR_DEPOT_CLONE_TRAIN_DEPOT_INFO + type);
601 
602  this->GetWidget<NWidgetCore>(WID_D_LOCATION)->tool_tip = STR_DEPOT_TRAIN_LOCATION_TOOLTIP + type;
603  this->GetWidget<NWidgetCore>(WID_D_VEHICLE_LIST)->tool_tip = STR_DEPOT_VEHICLE_ORDER_LIST_TRAIN_TOOLTIP + type;
604  this->GetWidget<NWidgetCore>(WID_D_AUTOREPLACE)->tool_tip = STR_DEPOT_AUTOREPLACE_TRAIN_TOOLTIP + type;
605  this->GetWidget<NWidgetCore>(WID_D_MATRIX)->tool_tip = STR_DEPOT_TRAIN_LIST_TOOLTIP + this->type;
606 
607  switch (type) {
608  default: NOT_REACHED();
609 
610  case VEH_TRAIN:
611  this->GetWidget<NWidgetCore>(WID_D_VEHICLE_LIST)->widget_data = STR_TRAIN;
612 
613  /* Sprites */
614  this->GetWidget<NWidgetCore>(WID_D_SELL)->widget_data = SPR_SELL_TRAIN;
615  this->GetWidget<NWidgetCore>(WID_D_SELL_ALL)->widget_data = SPR_SELL_ALL_TRAIN;
616  this->GetWidget<NWidgetCore>(WID_D_AUTOREPLACE)->widget_data = SPR_REPLACE_TRAIN;
617  break;
618 
619  case VEH_ROAD:
620  this->GetWidget<NWidgetCore>(WID_D_VEHICLE_LIST)->widget_data = STR_LORRY;
621 
622  /* Sprites */
623  this->GetWidget<NWidgetCore>(WID_D_SELL)->widget_data = SPR_SELL_ROADVEH;
624  this->GetWidget<NWidgetCore>(WID_D_SELL_ALL)->widget_data = SPR_SELL_ALL_ROADVEH;
625  this->GetWidget<NWidgetCore>(WID_D_AUTOREPLACE)->widget_data = SPR_REPLACE_ROADVEH;
626  break;
627 
628  case VEH_SHIP:
629  this->GetWidget<NWidgetCore>(WID_D_VEHICLE_LIST)->widget_data = STR_SHIP;
630 
631  /* Sprites */
632  this->GetWidget<NWidgetCore>(WID_D_SELL)->widget_data = SPR_SELL_SHIP;
633  this->GetWidget<NWidgetCore>(WID_D_SELL_ALL)->widget_data = SPR_SELL_ALL_SHIP;
634  this->GetWidget<NWidgetCore>(WID_D_AUTOREPLACE)->widget_data = SPR_REPLACE_SHIP;
635  break;
636 
637  case VEH_AIRCRAFT:
638  this->GetWidget<NWidgetCore>(WID_D_VEHICLE_LIST)->widget_data = STR_PLANE;
639 
640  /* Sprites */
641  this->GetWidget<NWidgetCore>(WID_D_SELL)->widget_data = SPR_SELL_AIRCRAFT;
642  this->GetWidget<NWidgetCore>(WID_D_SELL_ALL)->widget_data = SPR_SELL_ALL_AIRCRAFT;
643  this->GetWidget<NWidgetCore>(WID_D_AUTOREPLACE)->widget_data = SPR_REPLACE_AIRCRAFT;
644  break;
645  }
646  }
647 
648  uint count_width;
649  uint header_width;
650  uint flag_width;
651  uint flag_height;
652 
653  virtual void UpdateWidgetSize(int widget, Dimension *size, const Dimension &padding, Dimension *fill, Dimension *resize)
654  {
655  switch (widget) {
656  case WID_D_MATRIX: {
657  uint min_height = 0;
658 
659  if (this->type == VEH_TRAIN) {
660  SetDParamMaxValue(0, 1000, 0, FS_SMALL);
661  SetDParam(1, 1);
662  this->count_width = GetStringBoundingBox(STR_TINY_BLACK_DECIMAL).width + WD_FRAMERECT_LEFT + WD_FRAMERECT_RIGHT;
663  } else {
664  this->count_width = 0;
665  }
666 
667  SetDParamMaxDigits(0, this->unitnumber_digits);
668  Dimension unumber = GetStringBoundingBox(STR_BLACK_COMMA);
669  const Sprite *spr = GetSprite(SPR_FLAG_VEH_STOPPED, ST_NORMAL);
670  this->flag_width = UnScaleGUI(spr->width) + WD_FRAMERECT_RIGHT;
671  this->flag_height = UnScaleGUI(spr->height);
672 
673  if (this->type == VEH_TRAIN || this->type == VEH_ROAD) {
674  min_height = max<uint>(unumber.height + WD_MATRIX_TOP, UnScaleGUI(spr->height));
675  this->header_width = unumber.width + this->flag_width + WD_FRAMERECT_LEFT;
676  } else {
677  min_height = unumber.height + UnScaleGUI(spr->height) + WD_MATRIX_TOP + WD_PAR_VSEP_NORMAL + WD_MATRIX_BOTTOM;
678  this->header_width = max<uint>(unumber.width, this->flag_width) + WD_FRAMERECT_RIGHT;
679  }
680  int base_width = this->count_width + this->header_width;
681 
682  resize->height = max<uint>(GetVehicleImageCellSize(this->type, EIT_IN_DEPOT).height, min_height);
683  if (this->type == VEH_TRAIN) {
684  resize->width = 1;
685  size->width = base_width + 2 * ScaleGUITrad(29); // about 2 parts
686  size->height = resize->height * 6;
687  } else {
688  resize->width = base_width + GetVehicleImageCellSize(this->type, EIT_IN_DEPOT).extend_left + GetVehicleImageCellSize(this->type, EIT_IN_DEPOT).extend_right;
689  size->width = resize->width * (this->type == VEH_ROAD ? 5 : 3);
690  size->height = resize->height * (this->type == VEH_ROAD ? 5 : 3);
691  }
692  fill->width = resize->width;
693  fill->height = resize->height;
694  break;
695  }
696  }
697  }
698 
704  virtual void OnInvalidateData(int data = 0, bool gui_scope = true)
705  {
706  this->generate_list = true;
707  }
708 
709  virtual void OnPaint()
710  {
711  if (this->generate_list) {
712  /* Generate the vehicle list
713  * It's ok to use the wagon pointers for non-trains as they will be ignored */
714  BuildDepotVehicleList(this->type, this->window_number, &this->vehicle_list, &this->wagon_list);
715  this->generate_list = false;
716  DepotSortList(&this->vehicle_list);
717 
718  uint new_unitnumber_digits = GetUnitNumberDigits(this->vehicle_list);
719  /* Only increase the size; do not decrease to prevent constant changes */
720  if (this->unitnumber_digits < new_unitnumber_digits) {
721  this->unitnumber_digits = new_unitnumber_digits;
722  this->ReInit();
723  }
724  }
725 
726  /* determine amount of items for scroller */
727  if (this->type == VEH_TRAIN) {
728  uint max_width = ScaleGUITrad(VEHICLEINFO_FULL_VEHICLE_WIDTH);
729  for (uint num = 0; num < this->vehicle_list.Length(); num++) {
730  uint width = 0;
731  for (const Train *v = Train::From(this->vehicle_list[num]); v != NULL; v = v->Next()) {
732  width += v->GetDisplayImageWidth();
733  }
734  max_width = max(max_width, width);
735  }
736  /* Always have 1 empty row, so people can change the setting of the train */
737  this->vscroll->SetCount(this->vehicle_list.Length() + this->wagon_list.Length() + 1);
738  /* Always make it longer than the longest train, so you can attach vehicles at the end, and also see the next vertical tile separator line */
739  this->hscroll->SetCount(max_width + ScaleGUITrad(2 * VEHICLEINFO_FULL_VEHICLE_WIDTH + 1));
740  } else {
741  this->vscroll->SetCount(CeilDiv(this->vehicle_list.Length(), this->num_columns));
742  }
743 
744  /* Setup disabled buttons. */
745  TileIndex tile = this->window_number;
749  WID_D_SELL,
752  WID_D_BUILD,
753  WID_D_CLONE,
754  WID_D_RENAME,
757 
758  this->DrawWidgets();
759  }
760 
761  virtual void OnClick(Point pt, int widget, int click_count)
762  {
763  switch (widget) {
764  case WID_D_MATRIX: { // List
765  NWidgetBase *nwi = this->GetWidget<NWidgetBase>(WID_D_MATRIX);
766  this->DepotClick(pt.x - nwi->pos_x, pt.y - nwi->pos_y);
767  break;
768  }
769 
770  case WID_D_BUILD: // Build vehicle
772  ShowBuildVehicleWindow(this->window_number, this->type);
773  break;
774 
775  case WID_D_CLONE: // Clone button
778 
779  if (this->IsWidgetLowered(WID_D_CLONE)) {
780  static const CursorID clone_icons[] = {
781  SPR_CURSOR_CLONE_TRAIN, SPR_CURSOR_CLONE_ROADVEH,
782  SPR_CURSOR_CLONE_SHIP, SPR_CURSOR_CLONE_AIRPLANE
783  };
784 
785  SetObjectToPlaceWnd(clone_icons[this->type], PAL_NONE, HT_VEHICLE, this);
786  } else {
788  }
789  break;
790 
791  case WID_D_LOCATION:
792  if (_ctrl_pressed) {
794  } else {
796  }
797  break;
798 
799  case WID_D_RENAME: // Rename button
800  SetDParam(0, this->type);
801  SetDParam(1, Depot::GetByTile((TileIndex)this->window_number)->index);
802  ShowQueryString(STR_DEPOT_NAME, STR_DEPOT_RENAME_DEPOT_CAPTION, MAX_LENGTH_DEPOT_NAME_CHARS, this, CS_ALPHANUMERAL, QSF_ENABLE_DEFAULT | QSF_LEN_IN_CHARS);
803  break;
804 
805  case WID_D_STOP_ALL:
806  case WID_D_START_ALL: {
807  VehicleListIdentifier vli(VL_DEPOT_LIST, this->type, this->owner);
808  DoCommandP(this->window_number, (widget == WID_D_START_ALL ? (1 << 0) : 0), vli.Pack(), CMD_MASS_START_STOP);
809  break;
810  }
811 
812  case WID_D_SELL_ALL:
813  /* Only open the confirmation window if there are anything to sell */
814  if (this->vehicle_list.Length() != 0 || this->wagon_list.Length() != 0) {
815  TileIndex tile = this->window_number;
816  byte vehtype = this->type;
817 
818  SetDParam(0, vehtype);
819  SetDParam(1, (vehtype == VEH_AIRCRAFT) ? GetStationIndex(tile) : GetDepotIndex(tile));
820  ShowQuery(
821  STR_DEPOT_CAPTION,
822  STR_DEPOT_SELL_CONFIRMATION_TEXT,
823  this,
824  DepotSellAllConfirmationCallback
825  );
826  }
827  break;
828 
829  case WID_D_VEHICLE_LIST:
830  ShowVehicleListWindow(GetTileOwner(this->window_number), this->type, (TileIndex)this->window_number);
831  break;
832 
833  case WID_D_AUTOREPLACE:
834  DoCommandP(this->window_number, this->type, 0, CMD_DEPOT_MASS_AUTOREPLACE);
835  break;
836 
837  }
838  }
839 
840  virtual void OnQueryTextFinished(char *str)
841  {
842  if (str == NULL) return;
843 
844  /* Do depot renaming */
845  DoCommandP(0, GetDepotIndex(this->window_number), 0, CMD_RENAME_DEPOT | CMD_MSG(STR_ERROR_CAN_T_RENAME_DEPOT), NULL, str);
846  }
847 
848  virtual bool OnRightClick(Point pt, int widget)
849  {
850  if (widget != WID_D_MATRIX) return false;
851 
852  GetDepotVehiclePtData gdvp = { NULL, NULL };
853  const Vehicle *v = NULL;
854  NWidgetBase *nwi = this->GetWidget<NWidgetBase>(WID_D_MATRIX);
855  DepotGUIAction mode = this->GetVehicleFromDepotWndPt(pt.x - nwi->pos_x, pt.y - nwi->pos_y, &v, &gdvp);
856 
857  if (this->type == VEH_TRAIN) v = gdvp.wagon;
858 
859  if (v == NULL || mode != MODE_DRAG_VEHICLE) return false;
860 
861  CargoArray capacity, loaded;
862 
863  /* Display info for single (articulated) vehicle, or for whole chain starting with selected vehicle */
864  bool whole_chain = (this->type == VEH_TRAIN && _ctrl_pressed);
865 
866  /* loop through vehicle chain and collect cargoes */
867  uint num = 0;
868  for (const Vehicle *w = v; w != NULL; w = w->Next()) {
869  if (w->cargo_cap > 0 && w->cargo_type < NUM_CARGO) {
870  capacity[w->cargo_type] += w->cargo_cap;
871  loaded [w->cargo_type] += w->cargo.StoredCount();
872  }
873 
874  if (w->type == VEH_TRAIN && !w->HasArticulatedPart()) {
875  num++;
876  if (!whole_chain) break;
877  }
878  }
879 
880  /* Build tooltipstring */
881  static char details[1024];
882  details[0] = '\0';
883  char *pos = details;
884 
885  for (CargoID cargo_type = 0; cargo_type < NUM_CARGO; cargo_type++) {
886  if (capacity[cargo_type] == 0) continue;
887 
888  SetDParam(0, cargo_type); // {CARGO} #1
889  SetDParam(1, loaded[cargo_type]); // {CARGO} #2
890  SetDParam(2, cargo_type); // {SHORTCARGO} #1
891  SetDParam(3, capacity[cargo_type]); // {SHORTCARGO} #2
892  pos = GetString(pos, STR_DEPOT_VEHICLE_TOOLTIP_CARGO, lastof(details));
893  }
894 
895  /* Show tooltip window */
896  uint64 args[2];
897  args[0] = (whole_chain ? num : v->engine_type);
898  args[1] = (uint64)(size_t)details;
899  GuiShowTooltips(this, whole_chain ? STR_DEPOT_VEHICLE_TOOLTIP_CHAIN : STR_DEPOT_VEHICLE_TOOLTIP, 2, args, TCC_RIGHT_CLICK);
900 
901  return true;
902  }
903 
909  virtual bool OnVehicleSelect(const Vehicle *v)
910  {
911  if (DoCommandP(this->window_number, v->index, _ctrl_pressed ? 1 : 0, CMD_CLONE_VEHICLE | CMD_MSG(STR_ERROR_CAN_T_BUY_TRAIN + v->type), CcCloneVehicle)) {
913  }
914  return true;
915  }
916 
917  virtual void OnPlaceObjectAbort()
918  {
919  /* abort clone */
920  this->RaiseWidget(WID_D_CLONE);
922 
923  /* abort drag & drop */
924  this->sel = INVALID_VEHICLE;
925  this->vehicle_over = INVALID_VEHICLE;
927 
928  if (this->hovered_widget != -1) {
929  this->SetWidgetLoweredState(this->hovered_widget, false);
930  this->SetWidgetDirty(this->hovered_widget);
931  this->hovered_widget = -1;
932  }
933  }
934 
935  virtual void OnMouseDrag(Point pt, int widget)
936  {
937  if (this->sel == INVALID_VEHICLE) return;
938  if (widget != this->hovered_widget) {
939  if (this->hovered_widget == WID_D_SELL || this->hovered_widget == WID_D_SELL_CHAIN) {
940  this->SetWidgetLoweredState(this->hovered_widget, false);
941  this->SetWidgetDirty(this->hovered_widget);
942  }
943  this->hovered_widget = widget;
944  if (this->hovered_widget == WID_D_SELL || this->hovered_widget == WID_D_SELL_CHAIN) {
945  this->SetWidgetLoweredState(this->hovered_widget, true);
946  this->SetWidgetDirty(this->hovered_widget);
947  }
948  }
949  if (this->type != VEH_TRAIN) return;
950 
951  /* A rail vehicle is dragged.. */
952  if (widget != WID_D_MATRIX) { // ..outside of the depot matrix.
953  if (this->vehicle_over != INVALID_VEHICLE) {
954  this->vehicle_over = INVALID_VEHICLE;
956  }
957  return;
958  }
959 
960  NWidgetBase *matrix = this->GetWidget<NWidgetBase>(widget);
961  const Vehicle *v = NULL;
962  GetDepotVehiclePtData gdvp = {NULL, NULL};
963 
964  if (this->GetVehicleFromDepotWndPt(pt.x - matrix->pos_x, pt.y - matrix->pos_y, &v, &gdvp) != MODE_DRAG_VEHICLE) return;
965 
966  VehicleID new_vehicle_over = INVALID_VEHICLE;
967  if (gdvp.head != NULL) {
968  if (gdvp.wagon == NULL && gdvp.head->Last()->index != this->sel) { // ..at the end of the train.
969  /* 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
970  * destination inside a train. This head index is then used to indicate that a wagon is inserted at
971  * the end of the train.
972  */
973  new_vehicle_over = gdvp.head->index;
974  } else if (gdvp.wagon != NULL && gdvp.head != gdvp.wagon &&
975  gdvp.wagon->index != this->sel &&
976  gdvp.wagon->Previous()->index != this->sel) { // ..over an existing wagon.
977  new_vehicle_over = gdvp.wagon->index;
978  }
979  }
980 
981  if (this->vehicle_over == new_vehicle_over) return;
982 
983  this->vehicle_over = new_vehicle_over;
984  this->SetWidgetDirty(widget);
985  }
986 
987  virtual void OnDragDrop(Point pt, int widget)
988  {
989  switch (widget) {
990  case WID_D_MATRIX: {
991  const Vehicle *v = NULL;
992  VehicleID sel = this->sel;
993 
994  this->sel = INVALID_VEHICLE;
995  this->SetDirty();
996 
997  NWidgetBase *nwi = this->GetWidget<NWidgetBase>(WID_D_MATRIX);
998  if (this->type == VEH_TRAIN) {
999  GetDepotVehiclePtData gdvp = { NULL, NULL };
1000 
1001  if (this->GetVehicleFromDepotWndPt(pt.x - nwi->pos_x, pt.y - nwi->pos_y, &v, &gdvp) == MODE_DRAG_VEHICLE && sel != INVALID_VEHICLE) {
1002  if (gdvp.wagon != NULL && gdvp.wagon->index == sel && _ctrl_pressed) {
1003  DoCommandP(Vehicle::Get(sel)->tile, Vehicle::Get(sel)->index, true,
1004  CMD_REVERSE_TRAIN_DIRECTION | CMD_MSG(STR_ERROR_CAN_T_REVERSE_DIRECTION_RAIL_VEHICLE));
1005  } else if (gdvp.wagon == NULL || gdvp.wagon->index != sel) {
1006  this->vehicle_over = INVALID_VEHICLE;
1007  TrainDepotMoveVehicle(gdvp.wagon, sel, gdvp.head);
1008  } else if (gdvp.head != NULL && gdvp.head->IsFrontEngine()) {
1009  ShowVehicleViewWindow(gdvp.head);
1010  }
1011  }
1012  } else if (this->GetVehicleFromDepotWndPt(pt.x - nwi->pos_x, pt.y - nwi->pos_y, &v, NULL) == MODE_DRAG_VEHICLE && v != NULL && sel == v->index) {
1014  }
1015  break;
1016  }
1017 
1018  case WID_D_SELL: case WID_D_SELL_CHAIN: {
1019  if (this->IsWidgetDisabled(widget)) return;
1020  if (this->sel == INVALID_VEHICLE) return;
1021 
1022  this->HandleButtonClick(widget);
1023 
1024  const Vehicle *v = Vehicle::Get(this->sel);
1025  this->sel = INVALID_VEHICLE;
1026  this->SetDirty();
1027 
1028  int sell_cmd = (v->type == VEH_TRAIN && (widget == WID_D_SELL_CHAIN || _ctrl_pressed)) ? 1 : 0;
1029  DoCommandP(v->tile, v->index | sell_cmd << 20 | MAKE_ORDER_BACKUP_FLAG, 0, GetCmdSellVeh(v->type));
1030  break;
1031  }
1032 
1033  default:
1034  this->sel = INVALID_VEHICLE;
1035  this->SetDirty();
1036  break;
1037  }
1038  this->hovered_widget = -1;
1039  _cursor.vehchain = false;
1040  }
1041 
1042  virtual void OnTimeout()
1043  {
1044  if (!this->IsWidgetDisabled(WID_D_SELL)) {
1045  this->RaiseWidget(WID_D_SELL);
1046  this->SetWidgetDirty(WID_D_SELL);
1047  }
1048  if (this->nested_array[WID_D_SELL] != NULL && !this->IsWidgetDisabled(WID_D_SELL_CHAIN)) {
1051  }
1052  }
1053 
1054  virtual void OnResize()
1055  {
1056  this->vscroll->SetCapacityFromWidget(this, WID_D_MATRIX);
1057  NWidgetCore *nwi = this->GetWidget<NWidgetCore>(WID_D_MATRIX);
1058  if (this->type == VEH_TRAIN) {
1059  this->hscroll->SetCapacity(nwi->current_x - this->header_width - this->count_width);
1060  } else {
1061  this->num_columns = nwi->current_x / nwi->resize_x;
1062  }
1063  }
1064 
1066  {
1067  if (this->sel != INVALID_VEHICLE) {
1068  _cursor.vehchain = _ctrl_pressed;
1070  return ES_HANDLED;
1071  }
1072 
1073  return ES_NOT_HANDLED;
1074  }
1075 };
1076 
1077 static void DepotSellAllConfirmationCallback(Window *win, bool confirmed)
1078 {
1079  if (confirmed) {
1080  DepotWindow *w = (DepotWindow*)win;
1081  TileIndex tile = w->window_number;
1082  byte vehtype = w->type;
1083  DoCommandP(tile, vehtype, 0, CMD_DEPOT_SELL_ALL_VEHICLES);
1084  }
1085 }
1086 
1093 {
1094  if (BringWindowToFrontById(WC_VEHICLE_DEPOT, tile) != NULL) return;
1095 
1096  WindowDesc *desc;
1097  switch (type) {
1098  default: NOT_REACHED();
1099  case VEH_TRAIN: desc = &_train_depot_desc; break;
1100  case VEH_ROAD: desc = &_road_depot_desc; break;
1101  case VEH_SHIP: desc = &_ship_depot_desc; break;
1102  case VEH_AIRCRAFT: desc = &_aircraft_depot_desc; break;
1103  }
1104 
1105  new DepotWindow(desc, tile, type);
1106 }
1107 
1113 {
1114  DepotWindow *w;
1115 
1116  /* If we haven't got any vehicles on the mouse pointer, we haven't got any highlighted in any depots either
1117  * If that is the case, we can skip looping though the windows and save time
1118  */
1119  if (_special_mouse_mode != WSM_DRAGDROP) return;
1120 
1121  w = dynamic_cast<DepotWindow*>(FindWindowById(WC_VEHICLE_DEPOT, v->tile));
1122  if (w != NULL) {
1123  if (w->sel == v->index) ResetObjectToPlace();
1124  }
1125 }
EventState
State of handling an event.
Definition: window_type.h:701
Colours colour
Colour of this widget.
Definition: widget_type.h:303
Functions related to OTTD&#39;s strings.
Road vehicle states.
Date max_age
Maximum age.
Definition: vehicle_base.h:259
Vehicle * Previous() const
Get the previous vehicle of this vehicle.
Definition: vehicle_base.h:589
Vehicle is stopped by the player.
Definition: vehicle_base.h:33
Normal push-button (no toggle button) with image caption.
Definition: widget_type.h:105
rename a depot
Definition: command_type.h:248
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:18
virtual EventState OnCTRLStateChange()
The state of the control key has changed.
Definition: depot_gui.cpp:1065
The information about a vehicle list.
Definition: vehiclelist.h:31
ResizeInfo resize
Resize information.
Definition: window_gui.h:317
static NWidgetPart SetResize(int16 dx, int16 dy)
Widget part function for setting the resize step.
Definition: widget_type.h:930
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:150
uint resize_x
Horizontal resize step (0 means not resizable).
Definition: widget_type.h:166
List of vehicles.
Definition: depot_widget.h:32
void SetWidgetLoweredState(byte widget_index, bool lowered_stat)
Sets the lowered/raised status of a widget.
Definition: window_gui.h:448
static int UnScaleGUI(int value)
Short-hand to apply GUI zoom level.
Definition: zoom_func.h:72
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:34
Lowest bit of the number of columns.
Definition: widget_type.h:27
High level window description.
Definition: window_gui.h:168
Functions and type for generating vehicle lists.
bool IsEnabled() const
Checks whether the engine is a valid (non-articulated part of an) engine.
Definition: engine.cpp:152
int left
x position of left edge of the window
Definition: window_gui.h:312
bool vehchain
vehicle chain is dragged
Definition: gfx_type.h:146
SpecialMouseMode _special_mouse_mode
Mode of the mouse.
Definition: window.cpp:78
bool VehicleClicked(const Vehicle *v)
Dispatch a "vehicle selected" event if any window waits for it.
void DrawWidgets() const
Paint all widgets of a window.
Definition: widget.cpp:604
static Titem * Get(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:246
virtual void OnPaint()
The window must be repainted.
Definition: depot_gui.cpp:709
Scrollbar data structure.
Definition: widget_type.h:589
Build button.
Definition: depot_widget.h:27
Base for the train class.
void SetWidgetDirty(byte widget_index) const
Invalidate a widget, i.e.
Definition: window.cpp:577
Normal amount of vertical space between two paragraphs of text.
Definition: window_gui.h:139
Dragging an object.
Definition: window_gui.h:898
virtual void OnPlaceObjectAbort()
The user cancelled a tile highlight mode that has been set.
Definition: depot_gui.cpp:917
Horizontal container.
Definition: widget_type.h:75
void ShowDepotWindow(TileIndex tile, VehicleType type)
Opens a depot window.
Definition: depot_gui.cpp:1092
Window * FindWindowById(WindowClass cls, WindowNumber number)
Find a window by its class and window number.
Definition: window.cpp:1105
The passed event is not handled.
Definition: window_type.h:703
byte _colour_gradient[COLOUR_END][8]
All 16 colour gradients 8 colours per gradient from darkest (0) to lightest (7)
Definition: gfx.cpp:53
void CDECL SetWidgetsDisabledState(bool disab_stat, int widgets,...)
Sets the enabled/disabled status of a list of widgets.
Definition: window.cpp:516
Data structure describing a sprite.
Definition: spritecache.h:18
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:1065
static int ScaleGUITrad(int value)
Scale traditional pixel dimensions to GUI zoom level.
Definition: zoom_func.h:82
Depot view; Window numbers:
Definition: window_type.h:346
void DeleteDepotHighlightOfVehicle(const Vehicle *v)
Removes the highlight of a vehicle in a depot window.
Definition: depot_gui.cpp:1112
Last company-ownable type.
Definition: vehicle_type.h:29
void GuiShowTooltips(Window *parent, StringID str, uint paramcount, const uint64 params[], TooltipCloseCondition close_tooltip)
Shows a tooltip.
Definition: misc_gui.cpp:742
uint extend_right
Extend of the cell to the right.
Definition: vehicle_gui.h:74
Rename button.
Definition: depot_widget.h:31
Functions related to vehicles.
Resize box (normally at bottom-right of a window)
Definition: widget_type.h:68
Build vehicle; Window numbers:
Definition: window_type.h:378
Vehicle data structure.
Definition: vehicle_base.h:212
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:159
void ToggleWidgetLoweredState(byte widget_index)
Invert the lowered/raised status of a widget.
Definition: window_gui.h:458
uint height
Vehicle cell height.
Definition: vehicle_gui.h:72
Tindex index
Index of this pool item.
Definition: pool_type.hpp:147
Close box (at top-left of a window)
Definition: widget_type.h:69
Offset at top of a matrix cell.
Definition: window_gui.h:80
void SetupWidgetData(VehicleType type)
Function to set up vehicle specific widgets (mainly sprites and strings).
Definition: depot_gui.cpp:592
Sell all button.
Definition: depot_widget.h:21
void BuildDepotVehicleList(VehicleType type, TileIndex tile, VehicleList *engines, VehicleList *wagons, bool individual_wagons)
Generate a list of vehicles inside a depot.
Definition: vehiclelist.cpp:71
Base for aircraft.
#define lastof(x)
Get the last element of an fixed size array.
Definition: depend.cpp:50
virtual void OnMouseDrag(Point pt, int widget)
An &#39;object&#39; is being dragged at the provided position, highlight the target if possible.
Definition: depot_gui.cpp:935
void ReInit(int rx=0, int ry=0)
Re-initialize a window, and optionally change its size.
Definition: window.cpp:970
uint num_columns
Number of columns.
Definition: depot_gui.cpp:265
Stuff related to the text buffer GUI.
The most basic (normal) sprite.
Definition: gfx_type.h:298
T * GetFirstEnginePart()
Get the first part of an articulated engine.
Common return value for all commands.
Definition: command_type.h:25
Vehicle drawn in purchase list, autoreplace gui, ...
Definition: vehicle_type.h:92
Vertical scrollbar.
Definition: depot_widget.h:24
static const VehicleID INVALID_VEHICLE
Constant representing a non-existing vehicle.
Definition: vehicle_type.h:57
Vehicle drawn in depot.
Definition: vehicle_type.h:89
static T max(const T a, const T b)
Returns the maximum of two values.
Definition: math_func.hpp:26
byte vehstatus
Status.
Definition: vehicle_base.h:317
EngineImageType
Visualisation contexts of vehicles and engines.
Definition: vehicle_type.h:87
void RaiseWidget(byte widget_index)
Marks a widget as raised.
Definition: window_gui.h:478
static Train * From(Vehicle *v)
Converts a Vehicle to SpecializedVehicle with type checking.
virtual void OnClick(Point pt, int widget, int click_count)
A click with the left mouse button has been made on the window.
Definition: depot_gui.cpp:761
void CreateNestedTree(bool fill_nested=true)
Perform the first part of the initialization of a nested widget tree.
Definition: window.cpp:1804
static const uint TILE_SIZE
Tile size in world coordinates.
Definition: tile_type.h:15
Types related to the depot widgets.
Start all button.
Definition: depot_widget.h:34
Functions, definitions and such used only by the GUI.
void SetCapacity(int capacity)
Set the capacity of visible elements.
Definition: widget_type.h:686
void SetCount(int num)
Sets the number of elements in the list.
Definition: widget_type.h:670
CompanyByte _local_company
Company controlled by the human player at this client. Can also be COMPANY_SPECTATOR.
Definition: company_cmd.cpp:46
Partial widget specification to allow NWidgets to be written nested.
Definition: widget_type.h:910
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:149
Data structure for an opened window.
Definition: window_gui.h:271
bool _ctrl_pressed
Is Ctrl pressed?
Definition: gfx.cpp:36
void FinishInitNested(WindowNumber window_number=0)
Perform the second part of the initialization of a nested widget tree.
Definition: window.cpp:1820
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:207
enable the &#39;Default&#39; button ("\0" is returned)
Definition: textbuf_gui.h:23
Aircraft vehicle type.
Definition: vehicle_type.h:27
virtual bool OnRightClick(Point pt, int widget)
A click with the right mouse button has been made on the window.
Definition: depot_gui.cpp:848
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:31
NWidgetBase ** nested_array
Array of pointers into the tree. Do not access directly, use Window::GetWidget() instead.
Definition: window_gui.h:325
Offset at bottom of a matrix cell.
Definition: window_gui.h:81
virtual void UpdateWidgetSize(int widget, Dimension *size, const Dimension &padding, Dimension *fill, Dimension *resize)
Update size and resize step of a widget in the window.
Definition: depot_gui.cpp:653
UnitID unitnumber
unit number, for display purposes only
Definition: vehicle_base.h:291
#define FONT_HEIGHT_SMALL
Height of characters in the small (FS_SMALL) font.
Definition: gfx_func.h:177
Default window size box (at top-right of a window, between WWT_SHADEBOX and WWT_STICKYBOX) ...
Definition: widget_type.h:65
uint Length() const
Get the number of items in the list.
Location button.
Definition: depot_widget.h:29
uint pos_y
Vertical position of top-left corner of the widget in the window.
Definition: widget_type.h:178
bool IsWidgetLowered(byte widget_index) const
Gets the lowered state of a widget.
Definition: window_gui.h:488
void CcCloneVehicle(const CommandCost &result, TileIndex tile, uint32 p1, uint32 p2)
This is the Callback method after the cloning attempt of a vehicle.
Definition: depot_gui.cpp:121
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:1206
static const NWidgetPart _nested_train_depot_widgets[]
Nested widget definition for train depots.
Definition: depot_gui.cpp:45
VehicleType
Available vehicle types.
Definition: vehicle_type.h:21
uint current_y
Current vertical size (after resizing).
Definition: widget_type.h:175
uint32 VehicleID
The type all our vehicle IDs have.
Definition: vehicle_type.h:18
void SetStringParameters(int widget) const
Initialize string parameters for a widget.
Definition: depot_gui.cpp:425
static Owner GetTileOwner(TileIndex tile)
Returns the owner of a tile.
Definition: tile_map.h:171
#define FONT_HEIGHT_NORMAL
Height of characters in the normal (FS_NORMAL) font.
Definition: gfx_func.h:180
static NWidgetPart SetDataTip(uint32 data, StringID tip)
Widget part function for setting the data and tooltip.
Definition: widget_type.h:1014
T * Next() const
Get next vehicle in the chain.
Display plane with zero size vertically, and filling and resizing horizontally.
Definition: widget_type.h:389
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:261
the length of the string is counted in characters
Definition: textbuf_gui.h:24
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:94
Show rename panel.
Definition: depot_widget.h:30
A number of safeguards to prevent using unsafe methods.
Horizontal scrollbar.
Definition: depot_widget.h:26
Normal push-button (no toggle button) with text caption.
Definition: widget_type.h:104
static uint CeilDiv(uint a, uint b)
Computes ceil(a / b) for non-negative a and b.
Definition: math_func.hpp:316
virtual void OnResize()
Called after the window got resized.
Definition: depot_gui.cpp:1054
bool IsWidgetDisabled(byte widget_index) const
Gets the enabled/disabled status of a widget.
Definition: window_gui.h:416
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).
virtual void OnTimeout()
Called when this window&#39;s timeout has been reached.
Definition: depot_gui.cpp:1042
void StartStopVehicle(const Vehicle *v, bool texteffect)
Executes CMD_START_STOP_VEHICLE for given vehicle.
Horizontal scrollbar.
Definition: widget_type.h:83
uint step_height
Step-size of height resize changes.
Definition: window_gui.h:220
const Scrollbar * GetScrollbar(uint widnum) const
Return the Scrollbar to a widget index.
Definition: window.cpp:307
uint traininfo_vehicle_width
Width (in pixels) of a 8/8 train vehicle in depot GUI and vehicle details.
Definition: newgrf.h:136
void SetDParamMaxDigits(uint n, uint count, FontSize size)
Set DParam n to some number that is suitable for string size computations.
Definition: strings.cpp:121
Functions related to order backups.
bool IsFrontEngine() const
Check if the vehicle is a front engine.
Definition: vehicle_base.h:882
TileIndex tile
Current tile index.
Definition: vehicle_base.h:230
Show sell chain panel.
Definition: depot_widget.h:19
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:1114
Matrix of vehicles.
Definition: depot_widget.h:23
Baseclass for nested widgets.
Definition: widget_type.h:126
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:499
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:527
#define lengthof(x)
Return the length of an fixed size array.
Definition: depend.cpp:42
Road vehicle type.
Definition: vehicle_type.h:25
uint resize_y
Vertical resize step (0 means not resizable).
Definition: widget_type.h:167
Grid of rows and columns.
Definition: widget_type.h:59
static T min(const T a, const T b)
Returns the minimum of two values.
Definition: math_func.hpp:42
uint pos_x
Horizontal position of top-left corner of the widget in the window.
Definition: widget_type.h:177
Display plane with zero size in both directions (none filling and resizing).
Definition: widget_type.h:390
Clone button.
Definition: depot_widget.h:28
Functions to cache sprites in memory.
bool Failed() const
Did this command fail?
Definition: command_type.h:161
int GetDisplayImageWidth(Point *offset=NULL) const
Get the width of a train vehicle image in the GUI.
Definition: train_cmd.cpp:455
static DepotID GetDepotIndex(TileIndex t)
Get the index of which depot is attached to the tile.
Definition: depot_map.h:54
static const int WIDGET_LIST_END
indicate the end of widgets&#39; list for vararg functions
Definition: widget_type.h:22
Scrollbar * hscroll
Only for trains.
Definition: depot_gui.cpp:266
uint16 height
Height of the sprite.
Definition: spritecache.h:19
Ship vehicle type.
Definition: vehicle_type.h:26
static T Clamp(const T a, const T min, const T max)
Clamp a value between an interval.
Definition: math_func.hpp:139
force the autoreplace to take action in a given depot
Definition: command_type.h:314
void SetDirty() const
Mark entire window as dirty (in need of re-paint)
Definition: window.cpp:959
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:88
Dimension GetStringBoundingBox(const char *str, FontSize start_fontsize)
Return the string dimension in pixels.
Definition: gfx.cpp:699
Maximal number of cargo types in a game.
Definition: cargo_type.h:66
virtual void OnDragDrop(Point pt, int widget)
A dragged &#39;object&#39; has been released.
Definition: depot_gui.cpp:987
No window, redirects to WC_MAIN_WINDOW.
Definition: window_type.h:40
void DeleteWindowById(WindowClass cls, WindowNumber number, bool force)
Delete a window by its class and window number (if it is open).
Definition: window.cpp:1137
Sell button.
Definition: depot_widget.h:18
uint16 width
Width of the sprite.
Definition: spritecache.h:20
Functions related to companies.
uint GetUnitNumberDigits(VehicleList &vehicles)
Get the number of digits the biggest unit number of a set of vehicles has.
static StationID GetStationIndex(TileIndex t)
Get StationID from a tile.
Definition: station_map.h:29
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:3151
Class for storing amounts of cargo.
Definition: cargo_type.h:74
virtual void OnInvalidateData(int data=0, bool gui_scope=true)
Some data on this window has become invalid.
Definition: depot_gui.cpp:704
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:472
void SetMouseCursorVehicle(const Vehicle *v, EngineImageType image_type)
Set the mouse cursor to look like a vehicle.
const GRFFile * GetGRF() const
Retrieve the NewGRF the engine is tied to.
Definition: engine_base.h:140
Window caption (window title between closebox and stickybox)
Definition: widget_type.h:61
uint16 EngineID
Unique identification number of an engine.
Definition: engine_type.h:22
uint32 TileIndex
The index/ID of a Tile.
Definition: tile_type.h:80
uint32 Pack() const
Pack a VehicleListIdentifier in a single uint32.
Definition: vehiclelist.cpp:23
Show horizontal scrollbar panel.
Definition: depot_widget.h:25
TextDirection _current_text_dir
Text direction of the currently selected language.
Definition: strings.cpp:52
Caption of window.
Definition: depot_widget.h:17
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:310
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:105
Vertical container.
Definition: widget_type.h:77
turn a train around
Definition: command_type.h:223
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:999
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:217
Dimensions of a cell in the purchase/depot windows.
Definition: vehicle_gui.h:71
uint current_x
Current horizontal size (after resizing).
Definition: widget_type.h:174
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:62
uint step_width
Step-size of width resize changes.
Definition: window_gui.h:219
sell all vehicles which are in a given depot
Definition: command_type.h:313
bool ScrollMainWindowToTile(TileIndex tile, bool instant)
Scrolls the viewport of the main window to a given location.
Definition: viewport.cpp:2268
Functions related to commands.
uint32 CursorID
The number of the cursor (sprite)
Definition: gfx_type.h:21
Coordinates of a point in 2D.
clone a vehicle
Definition: command_type.h:309
Stop all button.
Definition: depot_widget.h:33
Base for ships.
Index of the small font in the font tables.
Definition: gfx_type.h:205
uint16 GetCapacity() const
Gets the number of visible elements of the scrollbar.
Definition: widget_type.h:622
start/stop all vehicles (in a depot)
Definition: command_type.h:311
Owner owner
The owner of the content shown in this window. Company colour is acquired from this variable...
Definition: window_gui.h:319
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:615
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:63
EngineID engine_type
The type of engine used for this vehicle.
Definition: vehicle_base.h:288
Sticky box (at top-right of a window, after WWT_DEFSIZEBOX)
Definition: widget_type.h:66
int width
width of the window (number of pixels to the right in x direction)
Definition: window_gui.h:314
Autoreplace button.
Definition: depot_widget.h:22
static NWidgetPart SetFill(uint fill_x, uint fill_y)
Widget part function for setting filling.
Definition: widget_type.h:983
void DepotClick(int x, int y)
Handle click in the depot matrix.
Definition: depot_gui.cpp:543
virtual bool OnVehicleSelect(const Vehicle *v)
Clones a vehicle.
Definition: depot_gui.cpp:909
#define CMD_MSG(x)
Used to combine a StringID with the command.
Definition: command_type.h:366
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:1973
void ResetObjectToPlace()
Reset the cursor and mouse mode handling back to default (normal cursor, only clicking in windows)...
Definition: viewport.cpp:3211
Specification of a rectangle with absolute coordinates of all edges.
Vertical scrollbar.
Definition: widget_type.h:84
byte CargoID
Cargo slots to indicate a cargo type within a game.
Definition: cargo_type.h:22
The passed event is handled.
Definition: window_type.h:702
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:26
Right align the text (must be a single bit).
Definition: gfx_func.h:100
WindowNumber window_number
Window number within the window class.
Definition: window_gui.h:307
uint extend_left
Extend of the cell to the left.
Definition: vehicle_gui.h:73
static VehicleCellSize _base_block_sizes_depot[VEH_COMPANY_END]
Cell size for vehicle images in the depot view.
Definition: depot_gui.cpp:148
Functions related to tile highlights.
VehicleID vehicle_over
Rail vehicle over which another one is dragged, INVALID_VEHICLE if none.
Definition: depot_gui.cpp:258
Vehicle * Last()
Get the last vehicle of this vehicle chain.
Definition: vehicle_base.h:601
Find a place automatically.
Definition: window_gui.h:156
(Toggle) Button with image
Definition: widget_type.h:52
void DrawWidget(const Rect &r, int widget) const
Draw the contents of a nested widget.
Definition: depot_gui.cpp:367
Stacked widgets, only one visible at a time (eg in a panel with tabs).
Definition: widget_type.h:80
move a rail vehicle (in the depot)
Definition: command_type.h:221
GUI functions that shouldn&#39;t be here.
static const CursorID SPR_CURSOR_MOUSE
Cursor sprite numbers.
Definition: sprites.h:1349
virtual void OnQueryTextFinished(char *str)
The query window opened from this window has closed.
Definition: depot_gui.cpp:840
Date age
Age in days.
Definition: vehicle_base.h:258
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:572
static NWidgetPart SetScrollbar(int index)
Attach a scrollbar to a widget.
Definition: widget_type.h:1095
static bool IsCompanyBuildableVehicleType(VehicleType type)
Is the given vehicle type buildable by a company?
Definition: vehicle_func.h:91
VehicleTypeByte type
Type of vehicle.
Definition: vehicle_type.h:54
Dimensions (a width and height) of a rectangle in 2D.
Value of the NCB_EQUALSIZE flag.
Definition: widget_type.h:429
Offset at left to draw the frame rectangular area.
Definition: window_gui.h:62
Window * BringWindowToFrontById(WindowClass cls, WindowNumber number)
Find a window and make it the relative top-window on the screen.
Definition: window.cpp:1234
Shade box (at top-right of a window, between WWT_DEBUGBOX and WWT_DEFSIZEBOX)
Definition: widget_type.h:64
Sell chain button.
Definition: depot_widget.h:20
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:833
static const int DAYS_IN_LEAP_YEAR
sometimes, you need one day more...
Definition: date_type.h:32
GroundVehicleCache gcache
Cache of often calculated values.
(Toggle) Button with text
Definition: widget_type.h:55
uint16 GetPosition() const
Gets the position of the first visible element in the list.
Definition: widget_type.h:631
Train vehicle type.
Definition: vehicle_type.h:24
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:201
Base class for a &#39;real&#39; widget.
Definition: widget_type.h:284