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