OpenTTD
group_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 "textbuf_gui.h"
12 #include "command_func.h"
13 #include "vehicle_gui.h"
14 #include "vehicle_base.h"
15 #include "string_func.h"
16 #include "strings_func.h"
17 #include "window_func.h"
18 #include "vehicle_func.h"
19 #include "autoreplace_gui.h"
20 #include "company_func.h"
21 #include "widgets/dropdown_func.h"
22 #include "tilehighlight_func.h"
23 #include "vehicle_gui_base.h"
24 #include "core/geometry_func.hpp"
25 #include "company_base.h"
26 #include "company_gui.h"
27 
28 #include "widgets/group_widget.h"
29 
30 #include "table/sprites.h"
31 
32 #include "safeguards.h"
33 
34 static const int LEVEL_WIDTH = 10;
35 
37 
38 static const NWidgetPart _nested_group_widgets[] = {
39  NWidget(NWID_HORIZONTAL), // Window header
40  NWidget(WWT_CLOSEBOX, COLOUR_GREY),
41  NWidget(WWT_CAPTION, COLOUR_GREY, WID_GL_CAPTION),
42  NWidget(WWT_SHADEBOX, COLOUR_GREY),
43  NWidget(WWT_DEFSIZEBOX, COLOUR_GREY),
44  NWidget(WWT_STICKYBOX, COLOUR_GREY),
45  EndContainer(),
47  /* left part */
50  NWidget(WWT_PANEL, COLOUR_GREY, WID_GL_ALL_VEHICLES), SetFill(1, 0), EndContainer(),
53  NWidget(WWT_MATRIX, COLOUR_GREY, WID_GL_LIST_GROUP), SetMatrixDataTip(1, 0, STR_GROUPS_CLICK_ON_GROUP_FOR_TOOLTIP),
56  EndContainer(),
57  NWidget(WWT_PANEL, COLOUR_GREY, WID_GL_INFO), SetFill(1, 0), EndContainer(),
59  NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_GL_CREATE_GROUP), SetFill(0, 1),
60  SetDataTip(SPR_GROUP_CREATE_TRAIN, STR_GROUP_CREATE_TOOLTIP),
61  NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_GL_DELETE_GROUP), SetFill(0, 1),
62  SetDataTip(SPR_GROUP_DELETE_TRAIN, STR_GROUP_DELETE_TOOLTIP),
63  NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_GL_RENAME_GROUP), SetFill(0, 1),
64  SetDataTip(SPR_GROUP_RENAME_TRAIN, STR_GROUP_RENAME_TOOLTIP),
65  NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_GL_LIVERY_GROUP), SetFill(0, 1),
66  SetDataTip(SPR_GROUP_LIVERY_TRAIN, STR_GROUP_LIVERY_TOOLTIP),
67  NWidget(WWT_PANEL, COLOUR_GREY), SetFill(1, 1), EndContainer(),
69  SetDataTip(SPR_GROUP_REPLACE_OFF_TRAIN, STR_GROUP_REPLACE_PROTECTION_TOOLTIP),
70  EndContainer(),
71  EndContainer(),
72  /* right part */
75  NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_GL_SORT_BY_ORDER), SetMinimalSize(81, 12), SetDataTip(STR_BUTTON_SORT_BY, STR_TOOLTIP_SORT_ORDER),
76  NWidget(WWT_DROPDOWN, COLOUR_GREY, WID_GL_SORT_BY_DROPDOWN), SetMinimalSize(167, 12), SetDataTip(0x0, STR_TOOLTIP_SORT_CRITERIA),
77  NWidget(WWT_PANEL, COLOUR_GREY), SetMinimalSize(12, 12), SetResize(1, 0), EndContainer(),
78  EndContainer(),
82  EndContainer(),
83  NWidget(WWT_PANEL, COLOUR_GREY), SetMinimalSize(1, 0), SetFill(1, 1), SetResize(1, 0), EndContainer(),
86  SetDataTip(STR_BLACK_STRING, STR_VEHICLE_LIST_AVAILABLE_ENGINES_TOOLTIP),
87  NWidget(WWT_PANEL, COLOUR_GREY), SetMinimalSize(0, 12), SetFill(1, 1), SetResize(1, 0), EndContainer(),
89  SetDataTip(STR_VEHICLE_LIST_MANAGE_LIST, STR_VEHICLE_LIST_MANAGE_LIST_TOOLTIP),
90  NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_GL_STOP_ALL), SetMinimalSize(12, 12), SetFill(0, 1),
91  SetDataTip(SPR_FLAG_VEH_STOPPED, STR_VEHICLE_LIST_MASS_STOP_LIST_TOOLTIP),
92  NWidget(WWT_PUSHIMGBTN, COLOUR_GREY, WID_GL_START_ALL), SetMinimalSize(12, 12), SetFill(0, 1),
93  SetDataTip(SPR_FLAG_VEH_RUNNING, STR_VEHICLE_LIST_MASS_START_LIST_TOOLTIP),
94  NWidget(WWT_RESIZEBOX, COLOUR_GREY),
95  EndContainer(),
96  EndContainer(),
97  EndContainer(),
98 };
99 
101 private:
102  /* Columns in the group list */
103  enum ListColumns {
110 
111  VGC_END
112  };
113 
121  Scrollbar *group_sb;
122 
123  std::vector<int> indents;
124 
126 
127  void AddChildren(GUIGroupList *source, GroupID parent, int indent)
128  {
129  for (const Group *g : *source) {
130  if (g->parent != parent) continue;
131  this->groups.push_back(g);
132  this->indents.push_back(indent);
133  if (g->folded) {
134  /* Test if this group has children at all. If not, the folded flag should be cleared to avoid lingering unfold buttons in the list. */
135  auto child = std::find_if(source->begin(), source->end(), [g](const Group *child){ return child->parent == g->index; });
136  bool has_children = child != source->end();
137  Group::Get(g->index)->folded = has_children;
138  } else {
139  AddChildren(source, g->index, indent + 1);
140  }
141  }
142  }
143 
145  static bool GroupNameSorter(const Group * const &a, const Group * const &b)
146  {
147  static const Group *last_group[2] = { nullptr, nullptr };
148  static char last_name[2][64] = { "", "" };
149 
150  if (a != last_group[0]) {
151  last_group[0] = a;
152  SetDParam(0, a->index);
153  GetString(last_name[0], STR_GROUP_NAME, lastof(last_name[0]));
154  }
155 
156  if (b != last_group[1]) {
157  last_group[1] = b;
158  SetDParam(0, b->index);
159  GetString(last_name[1], STR_GROUP_NAME, lastof(last_name[1]));
160  }
161 
162  int r = strnatcmp(last_name[0], last_name[1]); // Sort by name (natural sorting).
163  if (r == 0) return a->index < b->index;
164  return r < 0;
165  }
166 
173  {
174  if (!this->groups.NeedRebuild()) return;
175 
176  this->groups.clear();
177  this->indents.clear();
178 
179  GUIGroupList list;
180 
181  for (const Group *g : Group::Iterate()) {
182  if (g->owner == owner && g->vehicle_type == this->vli.vtype) {
183  list.push_back(g);
184  }
185  }
186 
187  list.ForceResort();
188  list.Sort(&GroupNameSorter);
189 
190  AddChildren(&list, INVALID_GROUP, 0);
191 
192  this->groups.shrink_to_fit();
193  this->groups.RebuildDone();
194  }
195 
201  {
202  this->column_size[VGC_FOLD] = maxdim(GetSpriteSize(SPR_CIRCLE_FOLDED), GetSpriteSize(SPR_CIRCLE_UNFOLDED));
203  this->tiny_step_height = this->column_size[VGC_FOLD].height;
204 
205  this->column_size[VGC_NAME] = maxdim(GetStringBoundingBox(STR_GROUP_DEFAULT_TRAINS + this->vli.vtype), GetStringBoundingBox(STR_GROUP_ALL_TRAINS + this->vli.vtype));
206  this->column_size[VGC_NAME].width = max(170u, this->column_size[VGC_NAME].width);
207  this->tiny_step_height = max(this->tiny_step_height, this->column_size[VGC_NAME].height);
208 
209  this->column_size[VGC_PROTECT] = GetSpriteSize(SPR_GROUP_REPLACE_PROTECT);
210  this->tiny_step_height = max(this->tiny_step_height, this->column_size[VGC_PROTECT].height);
211 
212  this->column_size[VGC_AUTOREPLACE] = GetSpriteSize(SPR_GROUP_REPLACE_ACTIVE);
213  this->tiny_step_height = max(this->tiny_step_height, this->column_size[VGC_AUTOREPLACE].height);
214 
215  this->column_size[VGC_PROFIT].width = 0;
216  this->column_size[VGC_PROFIT].height = 0;
217  static const SpriteID profit_sprites[] = {SPR_PROFIT_NA, SPR_PROFIT_NEGATIVE, SPR_PROFIT_SOME, SPR_PROFIT_LOT};
218  for (uint i = 0; i < lengthof(profit_sprites); i++) {
219  Dimension d = GetSpriteSize(profit_sprites[i]);
220  this->column_size[VGC_PROFIT] = maxdim(this->column_size[VGC_PROFIT], d);
221  }
222  this->tiny_step_height = max(this->tiny_step_height, this->column_size[VGC_PROFIT].height);
223 
224  int num_vehicle = GetGroupNumVehicle(this->vli.company, ALL_GROUP, this->vli.vtype);
225  SetDParamMaxValue(0, num_vehicle, 3, FS_SMALL);
226  SetDParamMaxValue(1, num_vehicle, 3, FS_SMALL);
227  this->column_size[VGC_NUMBER] = GetStringBoundingBox(STR_GROUP_COUNT_WITH_SUBGROUP);
228  this->tiny_step_height = max(this->tiny_step_height, this->column_size[VGC_NUMBER].height);
229 
230  this->tiny_step_height += WD_MATRIX_TOP;
231 
232  return WD_FRAMERECT_LEFT + 8 +
233  this->column_size[VGC_FOLD].width + 2 +
234  this->column_size[VGC_NAME].width + 8 +
235  this->column_size[VGC_PROTECT].width + 2 +
236  this->column_size[VGC_AUTOREPLACE].width + 2 +
237  this->column_size[VGC_PROFIT].width + 2 +
238  this->column_size[VGC_NUMBER].width + 2 +
240  }
241 
252  void DrawGroupInfo(int y, int left, int right, GroupID g_id, int indent = 0, bool protection = false, bool has_children = false) const
253  {
254  /* Highlight the group if a vehicle is dragged over it */
255  if (g_id == this->group_over) {
256  GfxFillRect(left + WD_FRAMERECT_LEFT, y + WD_FRAMERECT_TOP, right - WD_FRAMERECT_RIGHT, y + this->tiny_step_height - WD_FRAMERECT_BOTTOM - WD_MATRIX_TOP, _colour_gradient[COLOUR_GREY][7]);
257  }
258 
259  if (g_id == NEW_GROUP) return;
260 
261  /* draw the selected group in white, else we draw it in black */
262  TextColour colour = g_id == this->vli.index ? TC_WHITE : TC_BLACK;
263  const GroupStatistics &stats = GroupStatistics::Get(this->vli.company, g_id, this->vli.vtype);
264  bool rtl = _current_text_dir == TD_RTL;
265 
266  /* draw fold / unfold button */
267  int x = rtl ? right - WD_FRAMERECT_RIGHT - 8 - this->column_size[VGC_FOLD].width + 1 : left + WD_FRAMERECT_LEFT + 8;
268  if (has_children) {
269  DrawSprite(Group::Get(g_id)->folded ? SPR_CIRCLE_FOLDED : SPR_CIRCLE_UNFOLDED, PAL_NONE, rtl ? x - indent : x + indent, y + (this->tiny_step_height - this->column_size[VGC_FOLD].height) / 2);
270  }
271 
272  /* draw group name */
273  StringID str;
274  if (IsAllGroupID(g_id)) {
275  str = STR_GROUP_ALL_TRAINS + this->vli.vtype;
276  } else if (IsDefaultGroupID(g_id)) {
277  str = STR_GROUP_DEFAULT_TRAINS + this->vli.vtype;
278  } else {
279  SetDParam(0, g_id);
280  str = STR_GROUP_NAME;
281  }
282  x = rtl ? x - 2 - this->column_size[VGC_NAME].width : x + 2 + this->column_size[VGC_FOLD].width;
283  DrawString(x + (rtl ? 0 : indent), x + this->column_size[VGC_NAME].width - 1 - (rtl ? indent : 0), y + (this->tiny_step_height - this->column_size[VGC_NAME].height) / 2, str, colour);
284 
285  /* draw autoreplace protection */
286  x = rtl ? x - 8 - this->column_size[VGC_PROTECT].width : x + 8 + this->column_size[VGC_NAME].width;
287  if (protection) DrawSprite(SPR_GROUP_REPLACE_PROTECT, PAL_NONE, x, y + (this->tiny_step_height - this->column_size[VGC_PROTECT].height) / 2);
288 
289  /* draw autoreplace status */
290  x = rtl ? x - 2 - this->column_size[VGC_AUTOREPLACE].width : x + 2 + this->column_size[VGC_PROTECT].width;
291  if (stats.autoreplace_defined) DrawSprite(SPR_GROUP_REPLACE_ACTIVE, stats.autoreplace_finished ? PALETTE_CRASH : PAL_NONE, x, y + (this->tiny_step_height - this->column_size[VGC_AUTOREPLACE].height) / 2);
292 
293  /* draw the profit icon */
294  x = rtl ? x - 2 - this->column_size[VGC_PROFIT].width : x + 2 + this->column_size[VGC_AUTOREPLACE].width;
295  SpriteID spr;
296  uint num_profit_vehicle = GetGroupNumProfitVehicle(this->vli.company, g_id, this->vli.vtype);
297  Money profit_last_year = GetGroupProfitLastYear(this->vli.company, g_id, this->vli.vtype);
298  if (num_profit_vehicle == 0) {
299  spr = SPR_PROFIT_NA;
300  } else if (profit_last_year < 0) {
301  spr = SPR_PROFIT_NEGATIVE;
302  } else if (profit_last_year < (Money)10000 * num_profit_vehicle) { // TODO magic number
303  spr = SPR_PROFIT_SOME;
304  } else {
305  spr = SPR_PROFIT_LOT;
306  }
307  DrawSprite(spr, PAL_NONE, x, y + (this->tiny_step_height - this->column_size[VGC_PROFIT].height) / 2);
308 
309  /* draw the number of vehicles of the group */
310  x = rtl ? x - 2 - this->column_size[VGC_NUMBER].width : x + 2 + this->column_size[VGC_PROFIT].width;
311  int num_vehicle_with_subgroups = GetGroupNumVehicle(this->vli.company, g_id, this->vli.vtype);
312  int num_vehicle = GroupStatistics::Get(this->vli.company, g_id, this->vli.vtype).num_vehicle;
313  if (IsAllGroupID(g_id) || IsDefaultGroupID(g_id) || num_vehicle_with_subgroups == num_vehicle) {
314  SetDParam(0, num_vehicle);
315  DrawString(x, x + this->column_size[VGC_NUMBER].width - 1, y + (this->tiny_step_height - this->column_size[VGC_NUMBER].height) / 2, STR_TINY_COMMA, colour, SA_RIGHT | SA_FORCE);
316  } else {
317  SetDParam(0, num_vehicle);
318  SetDParam(1, num_vehicle_with_subgroups - num_vehicle);
319  DrawString(x, x + this->column_size[VGC_NUMBER].width - 1, y + (this->tiny_step_height - this->column_size[VGC_NUMBER].height) / 2, STR_GROUP_COUNT_WITH_SUBGROUP, colour, SA_RIGHT | SA_FORCE);
320  }
321  }
322 
327  {
328  if (this->group_over == INVALID_GROUP) return;
329 
330  if (IsAllGroupID(this->group_over)) {
332  } else if (IsDefaultGroupID(this->group_over)) {
334  } else {
336  }
337  }
338 
339 public:
341  {
342  this->CreateNestedTree();
343 
344  this->vscroll = this->GetScrollbar(WID_GL_LIST_VEHICLE_SCROLLBAR);
345  this->group_sb = this->GetScrollbar(WID_GL_LIST_GROUP_SCROLLBAR);
346 
347  switch (this->vli.vtype) {
348  default: NOT_REACHED();
349  case VEH_TRAIN: this->sorting = &_sorting.train; break;
350  case VEH_ROAD: this->sorting = &_sorting.roadveh; break;
351  case VEH_SHIP: this->sorting = &_sorting.ship; break;
352  case VEH_AIRCRAFT: this->sorting = &_sorting.aircraft; break;
353  }
354 
355  this->vli.index = ALL_GROUP;
356  this->vehicle_sel = INVALID_VEHICLE;
357  this->group_sel = INVALID_GROUP;
358  this->group_rename = INVALID_GROUP;
359  this->group_over = INVALID_GROUP;
360 
361  this->vehicles.SetListing(*this->sorting);
362  this->vehicles.ForceRebuild();
363  this->vehicles.NeedResort();
364 
365  this->BuildVehicleList();
366  this->SortVehicleList();
367 
368  this->groups.ForceRebuild();
369  this->groups.NeedResort();
370  this->BuildGroupList(vli.company);
371  this->group_sb->SetCount((uint)this->groups.size());
372 
373  this->GetWidget<NWidgetCore>(WID_GL_CAPTION)->widget_data = STR_VEHICLE_LIST_TRAIN_CAPTION + this->vli.vtype;
374  this->GetWidget<NWidgetCore>(WID_GL_LIST_VEHICLE)->tool_tip = STR_VEHICLE_LIST_TRAIN_LIST_TOOLTIP + this->vli.vtype;
375 
376  this->GetWidget<NWidgetCore>(WID_GL_CREATE_GROUP)->widget_data += this->vli.vtype;
377  this->GetWidget<NWidgetCore>(WID_GL_RENAME_GROUP)->widget_data += this->vli.vtype;
378  this->GetWidget<NWidgetCore>(WID_GL_DELETE_GROUP)->widget_data += this->vli.vtype;
379  this->GetWidget<NWidgetCore>(WID_GL_LIVERY_GROUP)->widget_data += this->vli.vtype;
380  this->GetWidget<NWidgetCore>(WID_GL_REPLACE_PROTECTION)->widget_data += this->vli.vtype;
381 
382  this->FinishInitNested(window_number);
383  this->owner = vli.company;
384  }
385 
387  {
388  *this->sorting = this->vehicles.GetListing();
389  }
390 
391  void UpdateWidgetSize(int widget, Dimension *size, const Dimension &padding, Dimension *fill, Dimension *resize) override
392  {
393  switch (widget) {
394  case WID_GL_LIST_GROUP: {
395  size->width = this->ComputeGroupInfoSize();
396  resize->height = this->tiny_step_height;
397 
398  /* Minimum height is the height of the list widget minus all and default vehicles... */
399  size->height = 4 * GetVehicleListHeight(this->vli.vtype, this->tiny_step_height) - 2 * this->tiny_step_height;
400 
401  /* ... minus the buttons at the bottom ... */
402  uint max_icon_height = GetSpriteSize(this->GetWidget<NWidgetCore>(WID_GL_CREATE_GROUP)->widget_data).height;
403  max_icon_height = max(max_icon_height, GetSpriteSize(this->GetWidget<NWidgetCore>(WID_GL_RENAME_GROUP)->widget_data).height);
404  max_icon_height = max(max_icon_height, GetSpriteSize(this->GetWidget<NWidgetCore>(WID_GL_DELETE_GROUP)->widget_data).height);
405  max_icon_height = max(max_icon_height, GetSpriteSize(this->GetWidget<NWidgetCore>(WID_GL_REPLACE_PROTECTION)->widget_data).height);
406 
407  /* ... minus the height of the group info ... */
408  max_icon_height += (FONT_HEIGHT_NORMAL * 3) + WD_FRAMERECT_TOP + WD_FRAMERECT_BOTTOM;
409 
410  /* Get a multiple of tiny_step_height of that amount */
411  size->height = Ceil(size->height - max_icon_height, tiny_step_height);
412  break;
413  }
414 
415  case WID_GL_ALL_VEHICLES:
417  size->width = this->ComputeGroupInfoSize();
418  size->height = this->tiny_step_height;
419  break;
420 
421  case WID_GL_SORT_BY_ORDER: {
422  Dimension d = GetStringBoundingBox(this->GetWidget<NWidgetCore>(widget)->widget_data);
423  d.width += padding.width + Window::SortButtonWidth() * 2; // Doubled since the string is centred and it also looks better.
424  d.height += padding.height;
425  *size = maxdim(*size, d);
426  break;
427  }
428 
429  case WID_GL_LIST_VEHICLE:
430  this->ComputeGroupInfoSize();
431  resize->height = GetVehicleListHeight(this->vli.vtype, this->tiny_step_height);
432  size->height = 4 * resize->height;
433  break;
434 
436  Dimension d = this->GetActionDropdownSize(true, true);
437  d.height += padding.height;
438  d.width += padding.width;
439  *size = maxdim(*size, d);
440  break;
441  }
442 
443  case WID_GL_INFO: {
445  break;
446  }
447  }
448  }
449 
455  void OnInvalidateData(int data = 0, bool gui_scope = true) override
456  {
457  if (data == 0) {
458  /* This needs to be done in command-scope to enforce rebuilding before resorting invalid data */
459  this->vehicles.ForceRebuild();
460  this->groups.ForceRebuild();
461  } else {
462  this->vehicles.ForceResort();
463  this->groups.ForceResort();
464  }
465 
466  /* Process ID-invalidation in command-scope as well */
467  if (this->group_rename != INVALID_GROUP && !Group::IsValidID(this->group_rename)) {
469  this->group_rename = INVALID_GROUP;
470  }
471 
472  if (!(IsAllGroupID(this->vli.index) || IsDefaultGroupID(this->vli.index) || Group::IsValidID(this->vli.index))) {
473  this->vli.index = ALL_GROUP;
474  HideDropDownMenu(this);
475  }
476  this->SetDirty();
477  }
478 
479  void SetStringParameters(int widget) const override
480  {
481  switch (widget) {
483  SetDParam(0, STR_VEHICLE_LIST_AVAILABLE_TRAINS + this->vli.vtype);
484  break;
485 
486  case WID_GL_CAPTION:
487  /* If selected_group == DEFAULT_GROUP || ALL_GROUP, draw the standard caption
488  * We list all vehicles or ungrouped vehicles */
489  if (IsDefaultGroupID(this->vli.index) || IsAllGroupID(this->vli.index)) {
490  SetDParam(0, STR_COMPANY_NAME);
491  SetDParam(1, this->vli.company);
492  SetDParam(2, this->vehicles.size());
493  SetDParam(3, this->vehicles.size());
494  } else {
495  uint num_vehicle = GetGroupNumVehicle(this->vli.company, this->vli.index, this->vli.vtype);
496 
497  SetDParam(0, STR_GROUP_NAME);
498  SetDParam(1, this->vli.index);
499  SetDParam(2, num_vehicle);
500  SetDParam(3, num_vehicle);
501  }
502  break;
503  }
504  }
505 
506  void OnPaint() override
507  {
508  /* If we select the all vehicles, this->list will contain all vehicles of the owner
509  * else this->list will contain all vehicles which belong to the selected group */
510  this->BuildVehicleList();
511  this->SortVehicleList();
512 
513  this->BuildGroupList(this->owner);
514 
515  this->group_sb->SetCount((uint)this->groups.size());
516  this->vscroll->SetCount((uint)this->vehicles.size());
517 
518  /* The drop down menu is out, *but* it may not be used, retract it. */
519  if (this->vehicles.size() == 0 && this->IsWidgetLowered(WID_GL_MANAGE_VEHICLES_DROPDOWN)) {
521  HideDropDownMenu(this);
522  }
523 
524  /* Disable all lists management button when the list is empty */
525  this->SetWidgetsDisabledState(this->vehicles.size() == 0 || _local_company != this->vli.company,
530 
531  /* Disable the group specific function when we select the default group or all vehicles */
532  this->SetWidgetsDisabledState(IsDefaultGroupID(this->vli.index) || IsAllGroupID(this->vli.index) || _local_company != this->vli.company,
538 
539  /* Disable remaining buttons for non-local companies
540  * Needed while changing _local_company, eg. by cheats
541  * All procedures (eg. move vehicle to another group)
542  * verify, whether you are the owner of the vehicle,
543  * so it doesn't have to be disabled
544  */
549 
550  /* If not a default group and the group has replace protection, show an enabled replace sprite. */
551  uint16 protect_sprite = SPR_GROUP_REPLACE_OFF_TRAIN;
552  if (!IsDefaultGroupID(this->vli.index) && !IsAllGroupID(this->vli.index) && Group::Get(this->vli.index)->replace_protection) protect_sprite = SPR_GROUP_REPLACE_ON_TRAIN;
553  this->GetWidget<NWidgetCore>(WID_GL_REPLACE_PROTECTION)->widget_data = protect_sprite + this->vli.vtype;
554 
555  /* Set text of sort by dropdown */
556  this->GetWidget<NWidgetCore>(WID_GL_SORT_BY_DROPDOWN)->widget_data = this->vehicle_sorter_names[this->vehicles.SortType()];
557 
558  this->DrawWidgets();
559  }
560 
561  void DrawWidget(const Rect &r, int widget) const override
562  {
563  switch (widget) {
564  case WID_GL_ALL_VEHICLES:
565  DrawGroupInfo(r.top + WD_FRAMERECT_TOP, r.left, r.right, ALL_GROUP);
566  break;
567 
569  DrawGroupInfo(r.top + WD_FRAMERECT_TOP, r.left, r.right, DEFAULT_GROUP);
570  break;
571 
572  case WID_GL_INFO: {
573  Money this_year = 0;
574  Money last_year = 0;
575  uint32 occupancy = 0;
576  size_t vehicle_count = this->vehicles.size();
577 
578  for (uint i = 0; i < vehicle_count; i++) {
579  const Vehicle *v = this->vehicles[i];
580  assert(v->owner == this->owner);
581 
582  this_year += v->GetDisplayProfitThisYear();
583  last_year += v->GetDisplayProfitLastYear();
584  occupancy += v->trip_occupancy;
585  }
586 
587  const int left = r.left + WD_FRAMERECT_LEFT + 8;
588  const int right = r.right - WD_FRAMERECT_RIGHT - 8;
589 
590  int y = r.top + WD_FRAMERECT_TOP;
591  DrawString(left, right, y, STR_GROUP_PROFIT_THIS_YEAR, TC_BLACK);
592  SetDParam(0, this_year);
593  DrawString(left, right, y, STR_JUST_CURRENCY_LONG, TC_BLACK, SA_RIGHT);
594 
595  y += FONT_HEIGHT_NORMAL;
596  DrawString(left, right, y, STR_GROUP_PROFIT_LAST_YEAR, TC_BLACK);
597  SetDParam(0, last_year);
598  DrawString(left, right, y, STR_JUST_CURRENCY_LONG, TC_BLACK, SA_RIGHT);
599 
600  y += FONT_HEIGHT_NORMAL;
601  DrawString(left, right, y, STR_GROUP_OCCUPANCY, TC_BLACK);
602  if (vehicle_count > 0) {
603  SetDParam(0, occupancy / vehicle_count);
604  DrawString(left, right, y, STR_GROUP_OCCUPANCY_VALUE, TC_BLACK, SA_RIGHT);
605  }
606 
607  break;
608  }
609 
610  case WID_GL_LIST_GROUP: {
611  int y1 = r.top + WD_FRAMERECT_TOP;
612  int max = min(this->group_sb->GetPosition() + this->group_sb->GetCapacity(), (uint)this->groups.size());
613  for (int i = this->group_sb->GetPosition(); i < max; ++i) {
614  const Group *g = this->groups[i];
615 
616  assert(g->owner == this->owner);
617 
618  DrawGroupInfo(y1, r.left, r.right, g->index, this->indents[i] * LEVEL_WIDTH, g->replace_protection, g->folded || (i + 1 < (int)this->groups.size() && indents[i + 1] > this->indents[i]));
619 
620  y1 += this->tiny_step_height;
621  }
622  if ((uint)this->group_sb->GetPosition() + this->group_sb->GetCapacity() > this->groups.size()) {
623  DrawGroupInfo(y1, r.left, r.right, NEW_GROUP);
624  }
625  break;
626  }
627 
630  break;
631 
632  case WID_GL_LIST_VEHICLE:
633  if (this->vli.index != ALL_GROUP) {
634  /* Mark vehicles which are in sub-groups */
635  int y = r.top;
636  uint max = min(this->vscroll->GetPosition() + this->vscroll->GetCapacity(), (uint)this->vehicles.size());
637  for (uint i = this->vscroll->GetPosition(); i < max; ++i) {
638  const Vehicle *v = this->vehicles[i];
639  if (v->group_id != this->vli.index) {
640  GfxFillRect(r.left + 1, y + 1, r.right - 1, y + this->resize.step_height - 2, _colour_gradient[COLOUR_GREY][3], FILLRECT_CHECKER);
641  }
642  y += this->resize.step_height;
643  }
644  }
645 
646  this->DrawVehicleListItems(this->vehicle_sel, this->resize.step_height, r);
647  break;
648  }
649  }
650 
651  static void DeleteGroupCallback(Window *win, bool confirmed)
652  {
653  if (confirmed) {
655  w->vli.index = ALL_GROUP;
656  DoCommandP(0, w->group_confirm, 0, CMD_DELETE_GROUP | CMD_MSG(STR_ERROR_GROUP_CAN_T_DELETE));
657  }
658  }
659 
660  void OnClick(Point pt, int widget, int click_count) override
661  {
662  switch (widget) {
663  case WID_GL_SORT_BY_ORDER: // Flip sorting method ascending/descending
664  this->vehicles.ToggleSortOrder();
665  this->SetDirty();
666  break;
667 
668  case WID_GL_SORT_BY_DROPDOWN: // Select sorting criteria dropdown menu
669  ShowDropDownMenu(this, this->vehicle_sorter_names, this->vehicles.SortType(), WID_GL_SORT_BY_DROPDOWN, 0, (this->vli.vtype == VEH_TRAIN || this->vli.vtype == VEH_ROAD) ? 0 : (1 << 10));
670  return;
671 
672  case WID_GL_ALL_VEHICLES: // All vehicles button
673  if (!IsAllGroupID(this->vli.index)) {
674  this->vli.index = ALL_GROUP;
675  this->vehicles.ForceRebuild();
676  this->SetDirty();
677  }
678  break;
679 
680  case WID_GL_DEFAULT_VEHICLES: // Ungrouped vehicles button
681  if (!IsDefaultGroupID(this->vli.index)) {
682  this->vli.index = DEFAULT_GROUP;
683  this->vehicles.ForceRebuild();
684  this->SetDirty();
685  }
686  break;
687 
688  case WID_GL_LIST_GROUP: { // Matrix Group
689  uint id_g = this->group_sb->GetScrolledRowFromWidget(pt.y, this, WID_GL_LIST_GROUP, 0, this->tiny_step_height);
690  if (id_g >= this->groups.size()) return;
691 
692  if (groups[id_g]->folded || (id_g + 1 < this->groups.size() && this->indents[id_g + 1] > this->indents[id_g])) {
693  /* The group has children, check if the user clicked the fold / unfold button. */
694  NWidgetCore *group_display = this->GetWidget<NWidgetCore>(widget);
695  int x = _current_text_dir == TD_RTL ?
696  group_display->pos_x + group_display->current_x - WD_FRAMERECT_RIGHT - 8 - this->indents[id_g] * LEVEL_WIDTH - this->column_size[VGC_FOLD].width :
697  group_display->pos_x + WD_FRAMERECT_LEFT + 8 + this->indents[id_g] * LEVEL_WIDTH;
698  if (click_count > 1 || (pt.x >= x && pt.x < (int)(x + this->column_size[VGC_FOLD].width))) {
699 
700  GroupID g = this->vli.index;
701  if (!IsAllGroupID(g) && !IsDefaultGroupID(g)) {
702  do {
703  g = Group::Get(g)->parent;
704  if (g == groups[id_g]->index) {
705  this->vli.index = g;
706  break;
707  }
708  } while (g != INVALID_GROUP);
709  }
710 
711  Group::Get(groups[id_g]->index)->folded = !groups[id_g]->folded;
712  this->groups.ForceRebuild();
713 
714  this->SetDirty();
715  break;
716  }
717  }
718 
719  this->group_sel = this->vli.index = this->groups[id_g]->index;
720 
721  SetObjectToPlaceWnd(SPR_CURSOR_MOUSE, PAL_NONE, HT_DRAG, this);
722 
723  this->vehicles.ForceRebuild();
724  this->SetDirty();
725  break;
726  }
727 
728  case WID_GL_LIST_VEHICLE: { // Matrix Vehicle
729  uint id_v = this->vscroll->GetScrolledRowFromWidget(pt.y, this, WID_GL_LIST_VEHICLE);
730  if (id_v >= this->vehicles.size()) return; // click out of list bound
731 
732  const Vehicle *v = this->vehicles[id_v];
733  if (VehicleClicked(v)) break;
734 
735  this->vehicle_sel = v->index;
736 
737  if (_ctrl_pressed) {
738  this->SelectGroup(v->group_id);
739  }
740 
741  SetObjectToPlaceWnd(SPR_CURSOR_MOUSE, PAL_NONE, HT_DRAG, this);
743  _cursor.vehchain = true;
744 
745  this->SetDirty();
746  break;
747  }
748 
749  case WID_GL_CREATE_GROUP: { // Create a new group
750  DoCommandP(0, this->vli.vtype, this->vli.index, CMD_CREATE_GROUP | CMD_MSG(STR_ERROR_GROUP_CAN_T_CREATE), CcCreateGroup);
751  break;
752  }
753 
754  case WID_GL_DELETE_GROUP: { // Delete the selected group
755  this->group_confirm = this->vli.index;
756  ShowQuery(STR_QUERY_GROUP_DELETE_CAPTION, STR_GROUP_DELETE_QUERY_TEXT, this, DeleteGroupCallback);
757  break;
758  }
759 
760  case WID_GL_RENAME_GROUP: // Rename the selected roup
761  this->ShowRenameGroupWindow(this->vli.index, false);
762  break;
763 
764  case WID_GL_LIVERY_GROUP: // Set group livery
765  ShowCompanyLiveryWindow(this->owner, this->vli.index);
766  break;
767 
769  ShowBuildVehicleWindow(INVALID_TILE, this->vli.vtype);
770  break;
771 
774  break;
775  }
776 
777  case WID_GL_START_ALL:
778  case WID_GL_STOP_ALL: { // Start/stop all vehicles of the list
779  DoCommandP(0, (1 << 1) | (widget == WID_GL_START_ALL ? (1 << 0) : 0), this->vli.Pack(), CMD_MASS_START_STOP);
780  break;
781  }
782 
784  const Group *g = Group::GetIfValid(this->vli.index);
785  if (g != nullptr) {
787  }
788  break;
789  }
790  }
791  }
792 
793  void OnDragDrop_Group(Point pt, int widget)
794  {
795  const Group *g = Group::Get(this->group_sel);
796 
797  switch (widget) {
798  case WID_GL_ALL_VEHICLES: // All vehicles
799  case WID_GL_DEFAULT_VEHICLES: // Ungrouped vehicles
800  if (g->parent != INVALID_GROUP) {
801  DoCommandP(0, this->group_sel | (1 << 16), INVALID_GROUP, CMD_ALTER_GROUP | CMD_MSG(STR_ERROR_GROUP_CAN_T_SET_PARENT));
802  }
803 
804  this->group_sel = INVALID_GROUP;
805  this->group_over = INVALID_GROUP;
806  this->SetDirty();
807  break;
808 
809  case WID_GL_LIST_GROUP: { // Matrix group
810  uint id_g = this->group_sb->GetScrolledRowFromWidget(pt.y, this, WID_GL_LIST_GROUP, 0, this->tiny_step_height);
811  GroupID new_g = id_g >= this->groups.size() ? INVALID_GROUP : this->groups[id_g]->index;
812 
813  if (this->group_sel != new_g && g->parent != new_g) {
814  DoCommandP(0, this->group_sel | (1 << 16), new_g, CMD_ALTER_GROUP | CMD_MSG(STR_ERROR_GROUP_CAN_T_SET_PARENT));
815  }
816 
817  this->group_sel = INVALID_GROUP;
818  this->group_over = INVALID_GROUP;
819  this->SetDirty();
820  break;
821  }
822  }
823  }
824 
825  void OnDragDrop_Vehicle(Point pt, int widget)
826  {
827  switch (widget) {
828  case WID_GL_DEFAULT_VEHICLES: // Ungrouped vehicles
829  DoCommandP(0, DEFAULT_GROUP, this->vehicle_sel | (_ctrl_pressed ? 1 << 31 : 0), CMD_ADD_VEHICLE_GROUP | CMD_MSG(STR_ERROR_GROUP_CAN_T_ADD_VEHICLE));
830 
831  this->vehicle_sel = INVALID_VEHICLE;
832  this->group_over = INVALID_GROUP;
833 
834  this->SetDirty();
835  break;
836 
837  case WID_GL_LIST_GROUP: { // Matrix group
838  const VehicleID vindex = this->vehicle_sel;
839  this->vehicle_sel = INVALID_VEHICLE;
840  this->group_over = INVALID_GROUP;
841  this->SetDirty();
842 
843  uint id_g = this->group_sb->GetScrolledRowFromWidget(pt.y, this, WID_GL_LIST_GROUP, 0, this->tiny_step_height);
844  GroupID new_g = id_g >= this->groups.size() ? NEW_GROUP : this->groups[id_g]->index;
845 
846  DoCommandP(0, new_g, vindex | (_ctrl_pressed ? 1 << 31 : 0), CMD_ADD_VEHICLE_GROUP | CMD_MSG(STR_ERROR_GROUP_CAN_T_ADD_VEHICLE), new_g == NEW_GROUP ? CcAddVehicleNewGroup : nullptr);
847  break;
848  }
849 
850  case WID_GL_LIST_VEHICLE: { // Matrix vehicle
851  const VehicleID vindex = this->vehicle_sel;
852  this->vehicle_sel = INVALID_VEHICLE;
853  this->group_over = INVALID_GROUP;
854  this->SetDirty();
855 
856  uint id_v = this->vscroll->GetScrolledRowFromWidget(pt.y, this, WID_GL_LIST_VEHICLE);
857  if (id_v >= this->vehicles.size()) return; // click out of list bound
858 
859  const Vehicle *v = this->vehicles[id_v];
860  if (!VehicleClicked(v) && vindex == v->index) {
862  }
863  break;
864  }
865  }
866  }
867 
868  void OnDragDrop(Point pt, int widget) override
869  {
870  if (this->vehicle_sel != INVALID_VEHICLE) OnDragDrop_Vehicle(pt, widget);
871  if (this->group_sel != INVALID_GROUP) OnDragDrop_Group(pt, widget);
872 
873  _cursor.vehchain = false;
874  }
875 
876  void OnQueryTextFinished(char *str) override
877  {
878  if (str != nullptr) DoCommandP(0, this->group_rename, 0, CMD_ALTER_GROUP | CMD_MSG(STR_ERROR_GROUP_CAN_T_RENAME), nullptr, str);
879  this->group_rename = INVALID_GROUP;
880  }
881 
882  void OnResize() override
883  {
884  this->group_sb->SetCapacityFromWidget(this, WID_GL_LIST_GROUP);
885  this->vscroll->SetCapacityFromWidget(this, WID_GL_LIST_VEHICLE);
886  }
887 
888  void OnDropdownSelect(int widget, int index) override
889  {
890  switch (widget) {
892  this->vehicles.SetSortType(index);
893  break;
894 
896  assert(this->vehicles.size() != 0);
897 
898  switch (index) {
899  case ADI_REPLACE: // Replace window
900  ShowReplaceGroupVehicleWindow(this->vli.index, this->vli.vtype);
901  break;
902  case ADI_SERVICE: // Send for servicing
903  case ADI_DEPOT: { // Send to Depots
904  DoCommandP(0, DEPOT_MASS_SEND | (index == ADI_SERVICE ? DEPOT_SERVICE : 0U), this->vli.Pack(), GetCmdSendToDepot(this->vli.vtype));
905  break;
906  }
907 
908  case ADI_ADD_SHARED: // Add shared Vehicles
909  assert(Group::IsValidID(this->vli.index));
910 
911  DoCommandP(0, this->vli.index, this->vli.vtype, CMD_ADD_SHARED_VEHICLE_GROUP | CMD_MSG(STR_ERROR_GROUP_CAN_T_ADD_SHARED_VEHICLE));
912  break;
913  case ADI_REMOVE_ALL: // Remove all Vehicles from the selected group
914  assert(Group::IsValidID(this->vli.index));
915 
916  DoCommandP(0, this->vli.index, 0, CMD_REMOVE_ALL_VEHICLES_GROUP | CMD_MSG(STR_ERROR_GROUP_CAN_T_REMOVE_ALL_VEHICLES));
917  break;
918  default: NOT_REACHED();
919  }
920  break;
921 
922  default: NOT_REACHED();
923  }
924 
925  this->SetDirty();
926  }
927 
928  void OnGameTick() override
929  {
930  if (this->groups.NeedResort() || this->vehicles.NeedResort()) {
931  this->SetDirty();
932  }
933  }
934 
935  void OnPlaceObjectAbort() override
936  {
937  /* abort drag & drop */
938  this->vehicle_sel = INVALID_VEHICLE;
940  this->group_over = INVALID_GROUP;
942  }
943 
944  void OnMouseDrag(Point pt, int widget) override
945  {
946  if (this->vehicle_sel == INVALID_VEHICLE && this->group_sel == INVALID_GROUP) return;
947 
948  /* A vehicle is dragged over... */
949  GroupID new_group_over = INVALID_GROUP;
950  switch (widget) {
951  case WID_GL_DEFAULT_VEHICLES: // ... the 'default' group.
952  new_group_over = DEFAULT_GROUP;
953  break;
954 
955  case WID_GL_LIST_GROUP: { // ... the list of custom groups.
956  uint id_g = this->group_sb->GetScrolledRowFromWidget(pt.y, this, WID_GL_LIST_GROUP, 0, this->tiny_step_height);
957  new_group_over = id_g >= this->groups.size() ? NEW_GROUP : this->groups[id_g]->index;
958  break;
959  }
960  }
961 
962  /* Do not highlight when dragging over the current group */
963  if (this->vehicle_sel != INVALID_VEHICLE) {
964  if (Vehicle::Get(vehicle_sel)->group_id == new_group_over) new_group_over = INVALID_GROUP;
965  } else if (this->group_sel != INVALID_GROUP) {
966  if (this->group_sel == new_group_over || Group::Get(this->group_sel)->parent == new_group_over) new_group_over = INVALID_GROUP;
967  }
968 
969  /* Mark widgets as dirty if the group changed. */
970  if (new_group_over != this->group_over) {
972  this->group_over = new_group_over;
974  }
975  }
976 
977  void ShowRenameGroupWindow(GroupID group, bool empty)
978  {
979  assert(Group::IsValidID(group));
980  this->group_rename = group;
981  /* Show empty query for new groups */
982  StringID str = STR_EMPTY;
983  if (!empty) {
984  SetDParam(0, group);
985  str = STR_GROUP_NAME;
986  }
988  }
989 
996  {
997  if (this->vehicle_sel == vehicle) ResetObjectToPlace();
998  }
999 
1005  void SelectGroup(const GroupID g_id)
1006  {
1007  if (g_id == INVALID_GROUP || g_id == this->vli.index) return;
1008 
1009  this->vli.index = g_id;
1010  if (g_id != ALL_GROUP && g_id != DEFAULT_GROUP) {
1011  const Group *g = Group::Get(g_id);
1012  int id_g = find_index(this->groups, g);
1013  // The group's branch is maybe collapsed, so try to expand it
1014  if (id_g == -1) {
1015  for (auto pg = Group::GetIfValid(g->parent); pg != nullptr; pg = Group::GetIfValid(pg->parent)) {
1016  pg->folded = false;
1017  }
1018  this->groups.ForceRebuild();
1019  this->BuildGroupList(this->owner);
1020  id_g = find_index(this->groups, g);
1021  }
1022  this->group_sb->ScrollTowards(id_g);
1023  }
1024  this->vehicles.ForceRebuild();
1025  this->SetDirty();
1026  }
1027 
1028 };
1029 
1030 
1031 static WindowDesc _other_group_desc(
1032  WDP_AUTO, "list_groups", 460, 246,
1034  0,
1035  _nested_group_widgets, lengthof(_nested_group_widgets)
1036 );
1037 
1038 static WindowDesc _train_group_desc(
1039  WDP_AUTO, "list_groups_train", 525, 246,
1041  0,
1042  _nested_group_widgets, lengthof(_nested_group_widgets)
1043 );
1044 
1052 void ShowCompanyGroup(CompanyID company, VehicleType vehicle_type, GroupID group = INVALID_GROUP, bool need_existing_window = false)
1053 {
1054  if (!Company::IsValidID(company)) return;
1055 
1056  const WindowNumber num = VehicleListIdentifier(VL_GROUP_LIST, vehicle_type, company).Pack();
1057  VehicleGroupWindow *w;
1058  if (vehicle_type == VEH_TRAIN) {
1059  w = AllocateWindowDescFront<VehicleGroupWindow>(&_train_group_desc, num, need_existing_window);
1060  } else {
1061  _other_group_desc.cls = GetWindowClassForVehicleType(vehicle_type);
1062  w = AllocateWindowDescFront<VehicleGroupWindow>(&_other_group_desc, num, need_existing_window);
1063  }
1064  if (w != nullptr) w->SelectGroup(group);
1065 }
1066 
1072 {
1073  ShowCompanyGroup(v->owner, v->type, v->group_id, true);
1074 }
1075 
1083 {
1084  return (VehicleGroupWindow *)FindWindowById(GetWindowClassForVehicleType(vt), VehicleListIdentifier(VL_GROUP_LIST, vt, owner).Pack());
1085 }
1086 
1096 void CcCreateGroup(const CommandCost &result, TileIndex tile, uint32 p1, uint32 p2, uint32 cmd)
1097 {
1098  if (result.Failed()) return;
1099  assert(p1 <= VEH_AIRCRAFT);
1100 
1102  if (w != nullptr) w->ShowRenameGroupWindow(_new_group_id, true);
1103 }
1104 
1113 void CcAddVehicleNewGroup(const CommandCost &result, TileIndex tile, uint32 p1, uint32 p2, uint32 cmd)
1114 {
1115  if (result.Failed()) return;
1116  assert(Vehicle::IsValidID(GB(p2, 0, 20)));
1117 
1118  CcCreateGroup(result, 0, Vehicle::Get(GB(p2, 0, 20))->type, 0, cmd);
1119 }
1120 
1126 {
1127  /* If we haven't got any vehicles on the mouse pointer, we haven't got any highlighted in any group windows 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 
1133  if (w != nullptr) w->UnselectVehicle(v->index);
1134 }
Functions related to OTTD&#39;s strings.
Owner
Enum for all companies/owners.
Definition: company_type.h:18
void DirtyHighlightedGroupWidget()
Mark the widget containing the currently highlighted group as dirty.
Definition: group_gui.cpp:326
void UnselectVehicle(VehicleID vehicle)
Tests whether a given vehicle is selected in the window, and unselects it if necessary.
Definition: group_gui.cpp:995
Normal push-button (no toggle button) with image caption.
Definition: widget_type.h:103
void RebuildDone()
Notify the sortlist that the rebuild is done.
Definition of stuff that is very close to a company, like the company struct itself.
static Titem * GetIfValid(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:302
Manage vehicles dropdown list.
Definition: group_widget.h:21
uint32 widget_data
Data of the widget.
Definition: widget_type.h:303
bool replace_protection
If set to true, the global autoreplace have no effect on the group.
Definition: group.h:70
CompanyID company
The company associated with this list.
Definition: vehiclelist.h:32
The information about a vehicle list.
Definition: vehiclelist.h:29
ResizeInfo resize
Resize information.
Definition: window_gui.h:322
Owner owner
Group Owner.
Definition: group.h:67
void ScrollTowards(int position)
Scroll towards the given position; if the item is visible nothing happens, otherwise it will be shown...
Definition: widget_type.h:729
static NWidgetPart SetResize(int16 dx, int16 dy)
Widget part function for setting the resize step.
Definition: widget_type.h:928
void GfxFillRect(int left, int top, int right, int bottom, int colour, FillRectMode mode)
Applies a certain FillRectMode-operation to a rectangle [left, right] x [top, bottom] on the screen...
Definition: gfx.cpp:110
void OnPaint() override
The window must be repainted.
Definition: group_gui.cpp:506
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: group_gui.cpp:391
Money GetDisplayProfitThisYear() const
Gets the profit vehicle had this year.
Definition: vehicle_base.h:564
Window * parent
Parent window.
Definition: window_gui.h:337
Group livery button.
Definition: group_widget.h:32
High level window description.
Definition: window_gui.h:166
Functions related to the autoreplace GUIs.
StringID tool_tip
Tooltip of the widget.
Definition: widget_type.h:304
int left
x position of left edge of the window
Definition: window_gui.h:317
bool vehchain
vehicle chain is dragged
Definition: gfx_type.h:144
SpecialMouseMode _special_mouse_mode
Mode of the mouse.
Definition: window.cpp:80
bool VehicleClicked(const Vehicle *v)
Dispatch a "vehicle selected" event if any window waits for it.
Train vehicle type.
Definition: vehicle_type.h:24
void DrawWidgets() const
Paint all widgets of a window.
Definition: widget.cpp:602
static Titem * Get(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:291
Scrollbar data structure.
Definition: widget_type.h:587
void SetWidgetDirty(byte widget_index) const
Invalidate a widget, i.e.
Definition: window.cpp:597
Offset at top to draw the frame rectangular area.
Definition: window_gui.h:62
List of the groups.
Definition: group_widget.h:27
Dragging an object.
Definition: window_gui.h:906
Horizontal container.
Definition: widget_type.h:73
std::vector< int > indents
Indentation levels.
Definition: group_gui.cpp:123
Window * FindWindowById(WindowClass cls, WindowNumber number)
Find a window by its class and window number.
Definition: window.cpp:1130
byte _colour_gradient[COLOUR_END][8]
All 16 colour gradients 8 colours per gradient from darkest (0) to lightest (7)
Definition: gfx.cpp:52
void CDECL SetWidgetsDisabledState(bool disab_stat, int widgets,...)
Sets the enabled/disabled status of a list of widgets.
Definition: window.cpp:536
void ShowQueryString(StringID str, StringID caption, uint maxsize, Window *parent, CharSetFilter afilter, QueryStringFlags flags)
Show a query popup window with a textbox in it.
Definition: misc_gui.cpp:1119
Ship vehicle type.
Definition: vehicle_type.h:26
VehicleType
Available vehicle types.
Definition: vehicle_type.h:21
GUIVehicleList vehicles
The list of vehicles.
Functions related to vehicles.
Types related to the group widgets.
Resize box (normally at bottom-right of a window)
Definition: widget_type.h:66
void SelectGroup(const GroupID g_id)
Selects the specified group in the list.
Definition: group_gui.cpp:1005
Vehicle data structure.
Definition: vehicle_base.h:210
Tindex index
Index of this pool item.
Definition: pool_type.hpp:189
Close box (at top-left of a window)
Definition: widget_type.h:67
Offset at top of a matrix cell.
Definition: window_gui.h:78
Delete group button.
Definition: group_widget.h:30
bool NeedResort()
Check if a resort is needed next loop If used the resort timer will decrease every call till 0...
List of the vehicles.
Definition: group_widget.h:18
static NWidgetPart SetMinimalTextLines(uint8 lines, uint8 spacing, FontSize size=FS_NORMAL)
Widget part function for setting the minimal text lines.
Definition: widget_type.h:963
#define lastof(x)
Get the last element of an fixed size array.
Definition: depend.cpp:48
bool autoreplace_finished
Have all autoreplacement finished?
Definition: group.h:29
uint GetGroupNumProfitVehicle(CompanyID company, GroupID id_g, VehicleType type)
Get the number of vehicles above profit minimum age in the group with GroupID id_g and its sub-groups...
Definition: group_cmd.cpp:818
Stuff related to the text buffer GUI.
Invalid window.
Definition: window_type.h:694
void OnDragDrop(Point pt, int widget) override
A dragged &#39;object&#39; has been released.
Definition: group_gui.cpp:868
Common return value for all commands.
Definition: command_type.h:23
All vehicles entry.
Definition: group_widget.h:25
static const VehicleID INVALID_VEHICLE
Constant representing a non-existing vehicle.
Definition: vehicle_type.h:55
static T max(const T a, const T b)
Returns the maximum of two values.
Definition: math_func.hpp:24
VehicleID vehicle_sel
Selected vehicle.
Definition: group_gui.cpp:114
void RaiseWidget(byte widget_index)
Marks a widget as raised.
Definition: window_gui.h:483
WindowClass cls
Class of the window,.
Definition: window_gui.h:175
void CcCreateGroup(const CommandCost &result, TileIndex tile, uint32 p1, uint32 p2, uint32 cmd)
Opens a &#39;Rename group&#39; window for newly created group.
Definition: group_gui.cpp:1096
uint ComputeGroupInfoSize()
Compute tiny_step_height and column_size.
Definition: group_gui.cpp:200
void CreateNestedTree(bool fill_nested=true)
Perform the first part of the initialization of a nested widget tree.
Definition: window.cpp:1828
Functions related to the vehicle&#39;s GUIs.
void SetListing(Listing l)
Import sort conditions.
GroupID group_rename
Group being renamed, INVALID_GROUP if none.
Definition: group_gui.cpp:116
bool NeedRebuild() const
Check if a rebuild is needed.
delete a group
Definition: command_type.h:318
void SetCount(int num)
Sets the number of elements in the list.
Definition: widget_type.h:668
Force the alignment, i.e. don&#39;t swap for RTL languages.
Definition: gfx_func.h:106
Partial widget specification to allow NWidgets to be written nested.
Definition: widget_type.h:908
void ForceRebuild()
Force that a rebuild is needed.
void ShowCompanyGroupForVehicle(const Vehicle *v)
Show the group window for the given vehicle.
Definition: group_gui.cpp:1071
Data structure for an opened window.
Definition: window_gui.h:276
alter a group
Definition: command_type.h:319
bool _ctrl_pressed
Is Ctrl pressed?
Definition: gfx.cpp:35
static NWidgetPart SetMatrixDataTip(uint8 cols, uint8 rows, StringID tip)
Widget part function for setting the data and tooltip of WWT_MATRIX widgets.
Definition: widget_type.h:1030
static const GroupID NEW_GROUP
Sentinel for a to-be-created group.
Definition: group_type.h:15
dragging items in the depot windows
enable the &#39;Default&#39; button ("\0" is returned)
Definition: textbuf_gui.h:21
static bool IsAllGroupID(GroupID id_g)
Checks if a GroupID stands for all vehicles of a company.
Definition: group.h:93
add all other shared vehicles to a group which are missing
Definition: command_type.h:321
static const uint MAX_LENGTH_GROUP_NAME_CHARS
The maximum length of a group name in characters including &#39;\0&#39;.
Definition: group_type.h:20
void ShowCompanyGroup(CompanyID company, VehicleType vehicle_type, GroupID group=INVALID_GROUP, bool need_existing_window=false)
Show the group window for the given company and vehicle type.
Definition: group_gui.cpp:1052
Functions related to low-level strings.
Stop all button.
Definition: group_widget.h:22
static const int LEVEL_WIDTH
Indenting width of a sub-group in pixels.
Definition: group_gui.cpp:34
remove all vehicles from a group
Definition: command_type.h:322
void DrawVehicleListItems(VehicleID selected_vehicle, int line_height, const Rect &r) const
Draw all the vehicle list items.
Default window size box (at top-right of a window, between WWT_SHADEBOX and WWT_STICKYBOX) ...
Definition: widget_type.h:63
int GetScrolledRowFromWidget(int clickpos, const Window *const w, int widget, int padding=0, int line_height=-1) const
Compute the row of a scrolled widget that a user clicked in.
Definition: widget.cpp:1957
void OnGameTick() override
Called once per (game) tick.
Definition: group_gui.cpp:928
bool IsWidgetLowered(byte widget_index) const
Gets the lowered state of a widget.
Definition: window_gui.h:493
Statistics and caches on the vehicles in a group.
Definition: group.h:24
Listing GetListing() const
Export current sort conditions.
void ShowQuery(StringID caption, StringID message, Window *parent, QueryCallbackProc *callback)
Show a modal confirmation window with standard &#39;yes&#39; and &#39;no&#39; buttons The window is aligned to the ce...
Definition: misc_gui.cpp:1260
Dimension column_size[VGC_END]
Size of the columns in the group list.
Definition: group_gui.cpp:125
uint32 index
A vehicle list type specific index.
Definition: vehiclelist.h:33
Sort descending.
Definition: window_gui.h:225
uint32 VehicleID
The type all our vehicle IDs have.
Definition: vehicle_type.h:16
Autoreplace active icon.
Definition: group_gui.cpp:107
DropDownList BuildActionDropdownList(bool show_autoreplace, bool show_group)
Display the Action dropdown window.
#define FONT_HEIGHT_NORMAL
Height of characters in the normal (FS_NORMAL) font.
Definition: gfx_func.h:176
static NWidgetPart SetDataTip(uint32 data, StringID tip)
Widget part function for setting the data and tooltip.
Definition: widget_type.h:1012
static NWidgetPart SetMinimalSize(int16 x, int16 y)
Widget part function for setting the minimal size.
Definition: widget_type.h:945
Definition of base types and functions in a cross-platform compatible way.
Tells that it&#39;s a mass send to depot command (type in VLW flag)
Definition: vehicle_type.h:67
the length of the string is counted in characters
Definition: textbuf_gui.h:22
A number of safeguards to prevent using unsafe methods.
TextColour
Colour of the strings, see _string_colourmap in table/string_colours.h or docs/ottd-colourtext-palett...
Definition: gfx_type.h:245
Group info.
Definition: group_widget.h:34
Normal push-button (no toggle button) with text caption.
Definition: widget_type.h:102
Geometry functions.
Simple depressed panel.
Definition: widget_type.h:48
void CcAddVehicleNewGroup(const CommandCost &result, TileIndex tile, uint32 p1, uint32 p2, uint32 cmd)
Open rename window after adding a vehicle to a new group via drag and drop.
Definition: group_gui.cpp:1113
uint16 GroupID
Type for all group identifiers.
Definition: group_type.h:13
void DrawSortButtonState(int widget, SortButtonState state) const
Draw a sort button&#39;s up or down arrow symbol.
Definition: widget.cpp:636
uint step_height
Step-size of height resize changes.
Definition: window_gui.h:218
const Scrollbar * GetScrollbar(uint widnum) const
Return the Scrollbar to a widget index.
Definition: window.cpp:309
GUI Functions related to companies.
int pos_x
Horizontal position of top-left corner of the widget in the window.
Definition: widget_type.h:175
void OnClick(Point pt, int widget, int click_count) override
A click with the left mouse button has been made on the window.
Definition: group_gui.cpp:660
static GroupStatistics & Get(CompanyID company, GroupID id_g, VehicleType type)
Returns the GroupStatistics for a specific group.
Definition: group_cmd.cpp:63
static NWidgetPart NWidget(WidgetType tp, Colours col, int16 idx=-1)
Widget part function for starting a new &#39;real&#39; widget.
Definition: widget_type.h:1112
Offset at bottom to draw the frame rectangular area.
Definition: window_gui.h:63
uint GetGroupNumVehicle(CompanyID company, GroupID id_g, VehicleType type)
Get the number of vehicles in the group with GroupID id_g and its sub-groups.
Definition: group_cmd.cpp:801
static const GroupID INVALID_GROUP
Sentinel for invalid groups.
Definition: group_type.h:18
int DrawString(int left, int right, int top, const char *str, TextColour colour, StringAlignment align, bool underline, FontSize fontsize)
Draw string, possibly truncated to make it fit in its allocated space.
Definition: gfx.cpp:498
void ShowVehicleViewWindow(const Vehicle *v)
Shows the vehicle view window of the given vehicle.
uint16 num_vehicle
Number of vehicles.
Definition: group.h:25
Owner owner
Which company owns the vehicle?
Definition: vehicle_base.h:271
bool DoCommandP(const CommandContainer *container, bool my_cmd)
Shortcut for the long DoCommandP when having a container with the data.
Definition: command.cpp:532
#define lengthof(x)
Return the length of an fixed size array.
Definition: depend.cpp:40
Fold / Unfold button.
Definition: group_gui.cpp:104
Grid of rows and columns.
Definition: widget_type.h:57
static T min(const T a, const T b)
Returns the minimum of two values.
Definition: math_func.hpp:40
Create group button.
Definition: group_widget.h:29
void OnQueryTextFinished(char *str) override
The query window opened from this window has closed.
Definition: group_gui.cpp:876
void DrawWidget(const Rect &r, int widget) const override
Draw the contents of a nested widget.
Definition: group_gui.cpp:561
Number of vehicles in the group.
Definition: group_gui.cpp:109
void SetSortType(uint8 n_type)
Set the sorttype of the list.
bool Sort(SortFunction *compare)
Sort the list.
static int SortButtonWidth()
Get width of up/down arrow of sort button state.
Definition: widget.cpp:656
uint32 StringID
Numeric value that represents a string, independent of the selected language.
Definition: strings_type.h:16
void DrawGroupInfo(int y, int left, int right, GroupID g_id, int indent=0, bool protection=false, bool has_children=false) const
Draw a row in the group list.
Definition: group_gui.cpp:252
bool Failed() const
Did this command fail?
Definition: command_type.h:159
void DeleteWindowByClass(WindowClass cls)
Delete all windows of a given class.
Definition: window.cpp:1175
static const int WIDGET_LIST_END
indicate the end of widgets&#39; list for vararg functions
Definition: widget_type.h:20
Functions/classes shared between the different vehicle list GUIs.
Caption of the window.
Definition: group_widget.h:15
void SetDirty() const
Mark entire window as dirty (in need of re-paint)
Definition: window.cpp:984
void BuildGroupList(Owner owner)
(Re)Build the group list.
Definition: group_gui.cpp:172
Dimension GetStringBoundingBox(const char *str, FontSize start_fontsize)
Return the string dimension in pixels.
Definition: gfx.cpp:700
void OnPlaceObjectAbort() override
The user cancelled a tile highlight mode that has been set.
Definition: group_gui.cpp:935
void ForceResort()
Force a resort next Sort call Reset the resort timer if used too.
Dimension maxdim(const Dimension &d1, const Dimension &d2)
Compute bounding box of both dimensions.
Draw only every second pixel, used for greying-out.
Definition: gfx_type.h:283
No window, redirects to WC_MAIN_WINDOW.
Definition: window_type.h:38
int8 trip_occupancy
NOSAVE: Occupancy of vehicle of the current trip (updated after leaving a station).
Definition: vehicle_base.h:309
static const GroupID DEFAULT_GROUP
Ungrouped vehicles are in this group.
Definition: group_type.h:17
The vehicle will leave the depot right after arrival (service only)
Definition: vehicle_type.h:66
Functions related to companies.
Vehicle drawn in vehicle list, group list, ...
Definition: vehicle_type.h:89
void SetObjectToPlaceWnd(CursorID icon, PaletteID pal, HighLightStyle mode, Window *w)
Change the cursor and mouse click/drag handling to a mode for performing special operations like tile...
Definition: viewport.cpp:3290
add a vehicle to a group
Definition: command_type.h:320
Scrollbar for the list.
Definition: group_widget.h:19
Both numeric and alphabetic and spaces and stuff.
Definition: string_type.h:27
Money GetGroupProfitLastYear(CompanyID company, GroupID id_g, VehicleType type)
Get last year&#39;s profit for the group with GroupID id_g and its sub-groups.
Definition: group_cmd.cpp:835
void SetMouseCursorVehicle(const Vehicle *v, EngineImageType image_type)
Set the mouse cursor to look like a vehicle.
static Pool::IterateWrapper< Titem > Iterate(size_t from=0)
Returns an iterable ensemble of all valid Titem.
Definition: pool_type.hpp:340
GroupID parent
Parent group.
Definition: group.h:76
Sort by dropdown list.
Definition: group_widget.h:17
Window caption (window title between closebox and stickybox)
Definition: widget_type.h:59
int strnatcmp(const char *s1, const char *s2, bool ignore_garbage_at_front)
Compares two strings using case insensitive natural sort.
Definition: string.cpp:578
Autoreplace protect icon.
Definition: group_gui.cpp:106
Base class for all vehicles.
static VehicleGroupWindow * FindVehicleGroupWindow(VehicleType vt, Owner owner)
Finds a group list window determined by vehicle type and owner.
Definition: group_gui.cpp:1082
uint32 SpriteID
The number of a sprite, without mapping bits and colourtables.
Definition: gfx_type.h:17
uint32 TileIndex
The index/ID of a Tile.
Definition: tile_type.h:78
static const PaletteID PALETTE_CRASH
Recolour sprite greying of crashed vehicles.
Definition: sprites.h:1587
uint32 Pack() const
Pack a VehicleListIdentifier in a single uint32.
Definition: vehiclelist.cpp:21
void DeleteGroupHighlightOfVehicle(const Vehicle *v)
Removes the highlight of a vehicle in a group window.
Definition: group_gui.cpp:1125
bool autoreplace_defined
Are any autoreplace rules set?
Definition: group.h:28
TextDirection _current_text_dir
Text direction of the currently selected language.
Definition: strings.cpp:48
void ToggleSortOrder()
Toggle the sort order Since that is the worst condition for the sort function reverse the list here...
Sort ascending.
Definition: window_gui.h:224
void SetDParamMaxValue(uint n, uint64 max_value, uint min_count, FontSize size)
Set DParam n to some number that is suitable for string size computations.
Definition: strings.cpp:104
static bool GroupNameSorter(const Group *const &a, const Group *const &b)
Sort the groups by their name.
Definition: group_gui.cpp:145
bool folded
NOSAVE: Is this group folded in the group view?
Definition: group.h:74
void ShowReplaceGroupVehicleWindow(GroupID id_g, VehicleType vehicletype)
Show the autoreplace configuration window for a particular group.
Vertical container.
Definition: widget_type.h:75
static NWidgetPart EndContainer()
Widget part function for denoting the end of a container (horizontal, vertical, WWT_FRAME, WWT_INSET, or WWT_PANEL).
Definition: widget_type.h:997
static uint GB(const T x, const uint8 s, const uint8 n)
Fetch n bits from x, started at bit s.
void OnMouseDrag(Point pt, int widget) override
An &#39;object&#39; is being dragged at the provided position, highlight the target if possible.
Definition: group_gui.cpp:944
Trains list; Window numbers:
Definition: window_type.h:301
VehicleType type
Type of vehicle.
Definition: vehicle_type.h:52
uint current_x
Current horizontal size (after resizing).
Definition: widget_type.h:172
GroupID group_sel
Selected group (for drag/drop)
Definition: group_gui.cpp:115
Group data.
Definition: group.h:65
void SetStringParameters(int widget) const override
Initialize string parameters for a widget.
Definition: group_gui.cpp:479
create a new group
Definition: command_type.h:317
VehicleListIdentifier vli
Identifier of the vehicle list we want to currently show.
Bottom offset of the dropdown widget string.
Definition: window_gui.h:135
Functions related to commands.
Coordinates of a point in 2D.
set the autoreplace-protection for a group
Definition: command_type.h:323
Dimension GetSpriteSize(SpriteID sprid, Point *offset, ZoomLevel zoom)
Get the size of a sprite.
Definition: gfx.cpp:770
CompanyID _current_company
Company currently doing an action.
Definition: company_cmd.cpp:45
static bool IsValidID(size_t index)
Tests whether given index can be used to get valid (non-nullptr) Titem.
Definition: pool_type.hpp:280
Drop down list.
Definition: widget_type.h:68
uint16 GetCapacity() const
Gets the number of visible elements of the scrollbar.
Definition: widget_type.h:620
Index of the small font in the font tables.
Definition: gfx_type.h:203
static WindowClass GetWindowClassForVehicleType(VehicleType vt)
Get WindowClass for vehicle list of given vehicle type.
Definition: vehicle_gui.h:91
start/stop all vehicles (in a depot)
Definition: command_type.h:312
void OnResize() override
Called after the window got resized.
Definition: group_gui.cpp:882
Start all button.
Definition: group_widget.h:23
Owner owner
The owner of the content shown in this window. Company colour is acquired from this variable...
Definition: window_gui.h:324
Aircraft vehicle type.
Definition: vehicle_type.h:27
Offset at right to draw the frame rectangular area.
Definition: window_gui.h:61
Sticky box (at top-right of a window, after WWT_DEFSIZEBOX)
Definition: widget_type.h:64
int width
width of the window (number of pixels to the right in x direction)
Definition: window_gui.h:319
uint GetVehicleListHeight(VehicleType type, uint divisor)
Get the height of a vehicle in the vehicle list GUIs.
static NWidgetPart SetFill(uint fill_x, uint fill_y)
Widget part function for setting filling.
Definition: widget_type.h:981
Replace protection button.
Definition: group_widget.h:33
static const TileIndex INVALID_TILE
The very nice invalid tile marker.
Definition: tile_type.h:83
GUIGroupList groups
List of groups.
Definition: group_gui.cpp:119
bool IsDescSortOrder() const
Check if the sort order is descending.
#define CMD_MSG(x)
Used to combine a StringID with the command.
Definition: command_type.h:368
int32 WindowNumber
Number to differentiate different windows of the same class.
Definition: window_type.h:705
void SetCapacityFromWidget(Window *w, int widget, int padding=0)
Set capacity of visible elements from the size and resize properties of a widget. ...
Definition: widget.cpp:1971
void ResetObjectToPlace()
Reset the cursor and mouse mode handling back to default (normal cursor, only clicking in windows)...
Definition: viewport.cpp:3353
Specification of a rectangle with absolute coordinates of all edges.
Vertical scrollbar.
Definition: widget_type.h:82
Text is written right-to-left by default.
Definition: strings_type.h:24
Right align the text (must be a single bit).
Definition: gfx_func.h:96
WindowNumber window_number
Window number within the window class.
Definition: window_gui.h:312
Functions related to tile highlights.
Window functions not directly related to making/drawing windows.
static uint Ceil(uint a, uint b)
Computes ceil(a / b) * b for non-negative a and b.
Definition: math_func.hpp:325
void OnInvalidateData(int data=0, bool gui_scope=true) override
Some data on this window has become invalid.
Definition: group_gui.cpp:455
Find a place automatically.
Definition: window_gui.h:154
uint tiny_step_height
Step height for the group list.
Definition: group_gui.cpp:120
Dimension GetActionDropdownSize(bool show_autoreplace, bool show_group)
Compute the size for the Action dropdown.
Listing * sorting
Pointer to the vehicle type related sorting.
static const CursorID SPR_CURSOR_MOUSE
Cursor sprite numbers.
Definition: sprites.h:1367
GroupID group_over
Group over which a vehicle is dragged, INVALID_GROUP if none.
Definition: group_gui.cpp:117
GroupID group_confirm
Group awaiting delete confirmation.
Definition: group_gui.cpp:118
VehicleType vtype
The vehicle type associated with this list.
Definition: vehiclelist.h:31
Rename group button.
Definition: group_widget.h:31
static NWidgetPart SetScrollbar(int index)
Attach a scrollbar to a widget.
Definition: widget_type.h:1093
CompanyID _local_company
Company controlled by the human player at this client. Can also be COMPANY_SPECTATOR.
Definition: company_cmd.cpp:44
Default vehicles entry.
Definition: group_widget.h:26
Dimensions (a width and height) of a rectangle in 2D.
Query string window; Window numbers:
Definition: window_type.h:116
Offset at left to draw the frame rectangular area.
Definition: window_gui.h:60
void OnDropdownSelect(int widget, int index) override
A dropdown option associated to this window has been selected.
Definition: group_gui.cpp:888
This file contains all sprite-related enums and defines.
Shade box (at top-right of a window, between WWT_DEBUGBOX and WWT_DEFSIZEBOX)
Definition: widget_type.h:62
Money GetDisplayProfitLastYear() const
Gets the profit vehicle had last year.
Definition: vehicle_base.h:570
Road vehicle type.
Definition: vehicle_type.h:25
int find_index(std::vector< T > const &vec, T const &item)
Helper function to get the index of an item Consider using std::set, std::unordered_set or std::flat_...
void DrawSprite(SpriteID img, PaletteID pal, int x, int y, const SubSprite *sub, ZoomLevel zoom)
Draw a sprite, not in a viewport.
Definition: gfx.cpp:835
Top offset of the dropdown widget string.
Definition: window_gui.h:134
GroupID group_id
Index of group Pool array.
Definition: vehicle_base.h:324
int height
Height of the window (number of pixels down in y direction)
Definition: window_gui.h:320
Scrollbar for the list.
Definition: group_widget.h:28
Available vehicles.
Definition: group_widget.h:20
uint16 GetPosition() const
Gets the position of the first visible element in the list.
Definition: widget_type.h:629
uint8 SortType() const
Get the sorttype of the list.
Definition: sortlist_type.h:94
static void SetDParam(uint n, uint64 v)
Set a string parameter v at index n in the global string parameter array.
Definition: strings_func.h:199
Base class for a &#39;real&#39; widget.
Definition: widget_type.h:282
static const GroupID ALL_GROUP
All vehicles are in this group.
Definition: group_type.h:16