OpenTTD

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