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/>.
10 /** @file timetable_gui.cpp GUI for time tabling. */
13 #include "command_func.h"
15 #include "window_gui.h"
16 #include "window_func.h"
17 #include "textbuf_gui.h"
18 #include "strings_func.h"
19 #include "vehicle_base.h"
22 #include "company_func.h"
23 #include "date_func.h"
25 #include "vehicle_gui.h"
26 #include "settings_type.h"
28 #include "widgets/timetable_widget.h"
30 #include "table/sprites.h"
31 #include "table/strings.h"
33 /** Container for the arrival/departure dates of a vehicle */
34 struct TimetableArrivalDeparture
{
35 Ticks arrival
; ///< The arrival time
36 Ticks departure
; ///< The departure time
40 * Set the timetable parameters in the format as described by the setting.
41 * @param param1 the first DParam to fill
42 * @param param2 the second DParam to fill
43 * @param ticks the number of ticks to 'draw'
45 void SetTimetableParams(int param1
, int param2
, Ticks ticks
)
47 if (_settings_client
.gui
.timetable_in_ticks
) {
48 SetDParam(param1
, STR_TIMETABLE_TICKS
);
49 SetDParam(param2
, ticks
);
51 SetDParam(param1
, STR_TIMETABLE_DAYS
);
52 SetDParam(param2
, ticks
/ DAY_TICKS
);
57 * Check whether it is possible to determine how long the order takes.
58 * @param order the order to check.
59 * @param travelling whether we are interested in the travel or the wait part.
60 * @return true if the travel/wait time can be used.
62 static bool CanDetermineTimeTaken(const Order
*order
, bool travelling
)
64 /* Current order is conditional */
65 if (order
->IsType(OT_CONDITIONAL
) || order
->IsType(OT_IMPLICIT
)) return false;
66 /* No travel time and we have not already finished travelling */
67 if (travelling
&& !order
->IsTravelTimetabled()) return false;
68 /* No wait time but we are loading at this timetabled station */
69 if (!travelling
&& !order
->IsWaitTimetabled() && order
->IsType(OT_GOTO_STATION
) &&
70 !(order
->GetNonStopType() & ONSF_NO_STOP_AT_DESTINATION_STATION
)) {
79 * Fill the table with arrivals and departures
80 * @param v Vehicle which must have at least 2 orders.
81 * @param start order index to start at
82 * @param travelling Are we still in the travelling part of the start order
83 * @param table Fill in arrival and departures including intermediate orders
84 * @param offset Add this value to result and all arrivals and departures
86 static void FillTimetableArrivalDepartureTable(const Vehicle
*v
, VehicleOrderID start
, bool travelling
, TimetableArrivalDeparture
*table
, Ticks offset
)
88 assert(table
!= NULL
);
89 assert(v
->GetNumOrders() >= 2);
90 assert(start
< v
->GetNumOrders());
93 VehicleOrderID i
= start
;
94 const Order
*order
= v
->GetOrder(i
);
96 /* Pre-initialize with unknown time */
97 for (int i
= 0; i
< v
->GetNumOrders(); ++i
) {
98 table
[i
].arrival
= table
[i
].departure
= INVALID_TICKS
;
101 /* Cyclically loop over all orders until we reach the current one again.
102 * As we may start at the current order, do a post-checking loop */
104 /* Automatic orders don't influence the overall timetable;
105 * they just add some untimetabled entries, but the time till
106 * the next non-implicit order can still be known. */
107 if (!order
->IsType(OT_IMPLICIT
)) {
108 if (travelling
|| i
!= start
) {
109 if (!CanDetermineTimeTaken(order
, true)) return;
110 sum
+= order
->GetTimetabledTravel();
111 table
[i
].arrival
= sum
;
114 if (!CanDetermineTimeTaken(order
, false)) return;
115 sum
+= order
->GetTimetabledWait();
116 table
[i
].departure
= sum
;
121 if (i
>= v
->GetNumOrders()) {
123 assert(order
== NULL
);
124 order
= v
->orders
.list
->GetFirstOrder();
126 } while (i
!= start
);
128 /* When loading at a scheduled station we still have to treat the
129 * travelling part of the first order. */
131 if (!CanDetermineTimeTaken(order
, true)) return;
132 sum
+= order
->GetTimetabledTravel();
133 table
[i
].arrival
= sum
;
139 * Callback for when a time has been chosen to start the time table
140 * @param window the window related to the setting of the date
141 * @param date the actually chosen date
143 static void ChangeTimetableStartCallback(const Window
*w
, Date date
)
145 DoCommandP(0, w
->window_number
, date
, CMD_SET_TIMETABLE_START
);
149 struct TimetableWindow
: Window
{
151 const Vehicle
*vehicle
; ///< Vehicle monitored by the window.
152 bool show_expected
; ///< Whether we show expected arrival or scheduled
153 uint deparr_time_width
; ///< The width of the departure/arrival time
154 uint deparr_abbr_width
; ///< The width of the departure/arrival abbreviation
156 bool query_is_speed_query
; ///< The currently open query window is a speed query and not a time query.
158 TimetableWindow (const WindowDesc
*desc
, WindowNumber window_number
) :
161 vehicle(Vehicle::Get(window_number
)),
163 deparr_time_width(0),
164 deparr_abbr_width(0),
166 query_is_speed_query(false)
168 this->CreateNestedTree();
169 this->vscroll
= this->GetScrollbar(WID_VT_SCROLLBAR
);
170 this->UpdateSelectionStates();
171 this->InitNested(window_number
);
173 this->owner
= this->vehicle
->owner
;
177 * Build the arrival-departure list for a given vehicle
178 * @param v the vehicle to make the list for
179 * @param table the table to fill
180 * @return if next arrival will be early
182 static bool BuildArrivalDepartureList(const Vehicle
*v
, TimetableArrivalDeparture
*table
)
184 assert(HasBit(v
->vehicle_flags
, VF_TIMETABLE_STARTED
));
186 bool travelling
= (!v
->current_order
.IsType(OT_LOADING
) || v
->current_order
.GetNonStopType() == ONSF_STOP_EVERYWHERE
);
187 Ticks start_time
= _date_fract
- v
->current_order_time
;
189 FillTimetableArrivalDepartureTable(v
, v
->cur_real_order_index
% v
->GetNumOrders(), travelling
, table
, start_time
);
191 return (travelling
&& v
->lateness_counter
< 0);
194 virtual void UpdateWidgetSize(int widget
, Dimension
*size
, const Dimension
&padding
, Dimension
*fill
, Dimension
*resize
)
197 case WID_VT_ARRIVAL_DEPARTURE_PANEL
:
198 SetDParamMaxValue(0, MAX_YEAR
* DAYS_IN_YEAR
, 0, FS_SMALL
);
199 this->deparr_time_width
= GetStringBoundingBox(STR_JUST_DATE_TINY
).width
;
200 this->deparr_abbr_width
= max(GetStringBoundingBox(STR_TIMETABLE_ARRIVAL_ABBREVIATION
).width
, GetStringBoundingBox(STR_TIMETABLE_DEPARTURE_ABBREVIATION
).width
);
201 size
->width
= WD_FRAMERECT_LEFT
+ this->deparr_abbr_width
+ 10 + this->deparr_time_width
+ WD_FRAMERECT_RIGHT
;
204 case WID_VT_ARRIVAL_DEPARTURE_SELECTION
:
205 case WID_VT_TIMETABLE_PANEL
:
206 resize
->height
= FONT_HEIGHT_NORMAL
;
207 size
->height
= WD_FRAMERECT_TOP
+ 8 * resize
->height
+ WD_FRAMERECT_BOTTOM
;
210 case WID_VT_SUMMARY_PANEL
:
211 size
->height
= WD_FRAMERECT_TOP
+ 2 * FONT_HEIGHT_NORMAL
+ WD_FRAMERECT_BOTTOM
;
216 int GetOrderFromTimetableWndPt(int y
, const Vehicle
*v
)
218 int sel
= (y
- this->GetWidget
<NWidgetBase
>(WID_VT_TIMETABLE_PANEL
)->pos_y
- WD_FRAMERECT_TOP
) / FONT_HEIGHT_NORMAL
;
220 if ((uint
)sel
>= this->vscroll
->GetCapacity()) return INVALID_ORDER
;
222 sel
+= this->vscroll
->GetPosition();
224 return (sel
< v
->GetNumOrders() * 2 && sel
>= 0) ? sel
: INVALID_ORDER
;
228 * Some data on this window has become invalid.
229 * @param data Information about the changed data.
230 * @param gui_scope Whether the call is done from GUI scope. You may not do everything when not in GUI scope. See #InvalidateWindowData() for details.
232 virtual void OnInvalidateData(int data
= 0, bool gui_scope
= true)
235 case VIWD_AUTOREPLACE
:
236 /* Autoreplace replaced the vehicle */
237 this->vehicle
= Vehicle::Get(this->window_number
);
240 case VIWD_REMOVE_ALL_ORDERS
:
241 /* Removed / replaced all orders (after deleting / sharing) */
242 if (this->sel_index
== -1) break;
244 this->DeleteChildWindows();
245 this->sel_index
= -1;
248 case VIWD_MODIFY_ORDERS
:
249 if (!gui_scope
) break;
250 this->UpdateSelectionStates();
255 if (gui_scope
) break; // only do this once; from command scope
257 /* Moving an order. If one of these is INVALID_VEH_ORDER_ID, then
258 * the order is being created / removed */
259 if (this->sel_index
== -1) break;
261 VehicleOrderID from
= GB(data
, 0, 8);
262 VehicleOrderID to
= GB(data
, 8, 8);
264 if (from
== to
) break; // no need to change anything
266 /* if from == INVALID_VEH_ORDER_ID, one order was added; if to == INVALID_VEH_ORDER_ID, one order was removed */
267 uint old_num_orders
= this->vehicle
->GetNumOrders() - (uint
)(from
== INVALID_VEH_ORDER_ID
) + (uint
)(to
== INVALID_VEH_ORDER_ID
);
269 VehicleOrderID selected_order
= (this->sel_index
+ 1) / 2;
270 if (selected_order
== old_num_orders
) selected_order
= 0; // when last travel time is selected, it belongs to order 0
272 bool travel
= HasBit(this->sel_index
, 0);
274 if (from
!= selected_order
) {
275 /* Moving from preceding order? */
276 selected_order
-= (int)(from
<= selected_order
);
277 /* Moving to preceding order? */
278 selected_order
+= (int)(to
<= selected_order
);
280 /* Now we are modifying the selected order */
281 if (to
== INVALID_VEH_ORDER_ID
) {
282 /* Deleting selected order */
283 this->DeleteChildWindows();
284 this->sel_index
= -1;
287 /* Moving selected order */
292 /* recompute new sel_index */
293 this->sel_index
= 2 * selected_order
- (int)travel
;
294 /* travel time of first order needs special handling */
295 if (this->sel_index
== -1) this->sel_index
= this->vehicle
->GetNumOrders() * 2 - 1;
302 void OnPaint (BlitArea
*dpi
) OVERRIDE
304 const Vehicle
*v
= this->vehicle
;
305 int selected
= this->sel_index
;
307 this->vscroll
->SetCount(v
->GetNumOrders() * 2);
309 if (v
->owner
== _local_company
) {
311 if (selected
!= -1) {
312 const Order
*order
= v
->GetOrder(((selected
+ 1) / 2) % v
->GetNumOrders());
313 if (selected
% 2 == 1) {
314 disable
= order
!= NULL
&& (order
->IsType(OT_CONDITIONAL
) || order
->IsType(OT_IMPLICIT
));
316 disable
= order
== NULL
|| ((!order
->IsType(OT_GOTO_STATION
) || (order
->GetNonStopType() & ONSF_NO_STOP_AT_DESTINATION_STATION
)) && !order
->IsType(OT_CONDITIONAL
));
319 bool disable_speed
= disable
|| selected
% 2 != 1 || v
->type
== VEH_AIRCRAFT
;
321 this->SetWidgetDisabledState(WID_VT_CHANGE_TIME
, disable
);
322 this->SetWidgetDisabledState(WID_VT_CLEAR_TIME
, disable
);
323 this->SetWidgetDisabledState(WID_VT_CHANGE_SPEED
, disable_speed
);
324 this->SetWidgetDisabledState(WID_VT_CLEAR_SPEED
, disable_speed
);
325 this->SetWidgetDisabledState(WID_VT_SHARED_ORDER_LIST
, !v
->IsOrderListShared());
327 this->SetWidgetDisabledState(WID_VT_START_DATE
, v
->orders
.list
== NULL
);
328 this->SetWidgetDisabledState(WID_VT_RESET_LATENESS
, v
->orders
.list
== NULL
);
329 this->SetWidgetDisabledState(WID_VT_AUTOFILL
, v
->orders
.list
== NULL
);
331 this->DisableWidget(WID_VT_START_DATE
);
332 this->DisableWidget(WID_VT_CHANGE_TIME
);
333 this->DisableWidget(WID_VT_CLEAR_TIME
);
334 this->DisableWidget(WID_VT_CHANGE_SPEED
);
335 this->DisableWidget(WID_VT_CLEAR_SPEED
);
336 this->DisableWidget(WID_VT_RESET_LATENESS
);
337 this->DisableWidget(WID_VT_AUTOFILL
);
338 this->DisableWidget(WID_VT_SHARED_ORDER_LIST
);
341 this->SetWidgetLoweredState(WID_VT_AUTOFILL
, HasBit(v
->vehicle_flags
, VF_AUTOFILL_TIMETABLE
));
343 this->DrawWidgets (dpi
);
346 virtual void SetStringParameters(int widget
) const
349 case WID_VT_CAPTION
: SetDParam(0, this->vehicle
->index
); break;
350 case WID_VT_EXPECTED
: SetDParam(0, this->show_expected
? STR_TIMETABLE_EXPECTED
: STR_TIMETABLE_SCHEDULED
); break;
354 void DrawWidget (BlitArea
*dpi
, const Rect
&r
, int widget
) const OVERRIDE
356 const Vehicle
*v
= this->vehicle
;
357 int selected
= this->sel_index
;
360 case WID_VT_TIMETABLE_PANEL
: {
361 int y
= r
.top
+ WD_FRAMERECT_TOP
;
362 int i
= this->vscroll
->GetPosition();
363 VehicleOrderID order_id
= (i
+ 1) / 2;
364 bool final_order
= false;
366 bool rtl
= _current_text_dir
== TD_RTL
;
367 SetDParamMaxValue(0, v
->GetNumOrders(), 2);
368 int index_column_width
= GetStringBoundingBox(STR_ORDER_INDEX
).width
+ 2 * GetSpriteSize(rtl
? SPR_ARROW_RIGHT
: SPR_ARROW_LEFT
).width
+ 3;
369 int middle
= rtl
? r
.right
- WD_FRAMERECT_RIGHT
- index_column_width
: r
.left
+ WD_FRAMERECT_LEFT
+ index_column_width
;
371 const Order
*order
= v
->GetOrder(order_id
);
372 while (order
!= NULL
) {
373 /* Don't draw anything if it extends past the end of the window. */
374 if (!this->vscroll
->IsVisible(i
)) break;
377 DrawOrderString (v
, order
, order_id
, dpi
, y
, i
== selected
, true, r
.left
+ WD_FRAMERECT_LEFT
, middle
, r
.right
- WD_FRAMERECT_RIGHT
);
381 if (order_id
>= v
->GetNumOrders()) {
382 order
= v
->GetOrder(0);
389 TextColour colour
= (i
== selected
) ? TC_WHITE
: TC_BLACK
;
390 if (order
->IsType(OT_CONDITIONAL
)) {
391 string
= STR_TIMETABLE_NO_TRAVEL
;
392 } else if (order
->IsType(OT_IMPLICIT
)) {
393 string
= STR_TIMETABLE_NOT_TIMETABLEABLE
;
394 colour
= ((i
== selected
) ? TC_SILVER
: TC_GREY
) | TC_NO_SHADE
;
395 } else if (!order
->IsTravelTimetabled()) {
396 if (order
->GetTravelTime() > 0) {
397 SetTimetableParams(0, 1, order
->GetTravelTime());
398 string
= order
->GetMaxSpeed() != UINT16_MAX
?
399 STR_TIMETABLE_TRAVEL_FOR_SPEED_ESTIMATED
:
400 STR_TIMETABLE_TRAVEL_FOR_ESTIMATED
;
402 string
= order
->GetMaxSpeed() != UINT16_MAX
?
403 STR_TIMETABLE_TRAVEL_NOT_TIMETABLED_SPEED
:
404 STR_TIMETABLE_TRAVEL_NOT_TIMETABLED
;
407 SetTimetableParams(0, 1, order
->GetTimetabledTravel());
408 string
= order
->GetMaxSpeed() != UINT16_MAX
?
409 STR_TIMETABLE_TRAVEL_FOR_SPEED
: STR_TIMETABLE_TRAVEL_FOR
;
411 SetDParam(2, order
->GetMaxSpeed());
413 DrawString (dpi
, rtl
? r
.left
+ WD_FRAMERECT_LEFT
: middle
, rtl
? middle
: r
.right
- WD_FRAMERECT_LEFT
, y
, string
, colour
);
415 if (final_order
) break;
419 y
+= FONT_HEIGHT_NORMAL
;
424 case WID_VT_ARRIVAL_DEPARTURE_PANEL
: {
425 /* Arrival and departure times are handled in an all-or-nothing approach,
426 * i.e. are only shown if we can calculate all times.
427 * Excluding order lists with only one order makes some things easier.
429 Ticks total_time
= v
->orders
.list
!= NULL
? v
->orders
.list
->GetTimetableDurationIncomplete() : 0;
430 if (total_time
<= 0 || v
->GetNumOrders() <= 1 || !HasBit(v
->vehicle_flags
, VF_TIMETABLE_STARTED
)) break;
432 TimetableArrivalDeparture
*arr_dep
= AllocaM(TimetableArrivalDeparture
, v
->GetNumOrders());
433 const VehicleOrderID cur_order
= v
->cur_real_order_index
% v
->GetNumOrders();
435 VehicleOrderID earlyID
= BuildArrivalDepartureList(v
, arr_dep
) ? cur_order
: (VehicleOrderID
)INVALID_VEH_ORDER_ID
;
437 int y
= r
.top
+ WD_FRAMERECT_TOP
;
439 bool show_late
= this->show_expected
&& v
->lateness_counter
> DAY_TICKS
;
440 Ticks offset
= show_late
? 0 : -v
->lateness_counter
;
442 bool rtl
= _current_text_dir
== TD_RTL
;
443 int abbr_left
= rtl
? r
.right
- WD_FRAMERECT_RIGHT
- this->deparr_abbr_width
: r
.left
+ WD_FRAMERECT_LEFT
;
444 int abbr_right
= rtl
? r
.right
- WD_FRAMERECT_RIGHT
: r
.left
+ WD_FRAMERECT_LEFT
+ this->deparr_abbr_width
;
445 int time_left
= rtl
? r
.left
+ WD_FRAMERECT_LEFT
: r
.right
- WD_FRAMERECT_RIGHT
- this->deparr_time_width
;
446 int time_right
= rtl
? r
.left
+ WD_FRAMERECT_LEFT
+ this->deparr_time_width
: r
.right
- WD_FRAMERECT_RIGHT
;
448 for (int i
= this->vscroll
->GetPosition(); i
/ 2 < v
->GetNumOrders(); ++i
) { // note: i is also incremented in the loop
449 /* Don't draw anything if it extends past the end of the window. */
450 if (!this->vscroll
->IsVisible(i
)) break;
453 if (arr_dep
[i
/ 2].arrival
!= INVALID_TICKS
) {
454 DrawString (dpi
, abbr_left
, abbr_right
, y
, STR_TIMETABLE_ARRIVAL_ABBREVIATION
, i
== selected
? TC_WHITE
: TC_BLACK
);
455 if (this->show_expected
&& i
/ 2 == earlyID
) {
456 SetDParam(0, _date
+ arr_dep
[i
/ 2].arrival
/ DAY_TICKS
);
457 DrawString (dpi
, time_left
, time_right
, y
, STR_JUST_DATE_TINY
, TC_GREEN
);
459 SetDParam(0, _date
+ (arr_dep
[i
/ 2].arrival
+ offset
) / DAY_TICKS
);
460 DrawString (dpi
, time_left
, time_right
, y
, STR_JUST_DATE_TINY
,
461 show_late
? TC_RED
: i
== selected
? TC_WHITE
: TC_BLACK
);
465 if (arr_dep
[i
/ 2].departure
!= INVALID_TICKS
) {
466 DrawString (dpi
, abbr_left
, abbr_right
, y
, STR_TIMETABLE_DEPARTURE_ABBREVIATION
, i
== selected
? TC_WHITE
: TC_BLACK
);
467 SetDParam(0, _date
+ (arr_dep
[i
/2].departure
+ offset
) / DAY_TICKS
);
468 DrawString (dpi
, time_left
, time_right
, y
, STR_JUST_DATE_TINY
,
469 show_late
? TC_RED
: i
== selected
? TC_WHITE
: TC_BLACK
);
472 y
+= FONT_HEIGHT_NORMAL
;
477 case WID_VT_SUMMARY_PANEL
: {
478 int y
= r
.top
+ WD_FRAMERECT_TOP
;
480 Ticks total_time
= v
->orders
.list
!= NULL
? v
->orders
.list
->GetTimetableDurationIncomplete() : 0;
481 if (total_time
!= 0) {
482 SetTimetableParams(0, 1, total_time
);
483 DrawString (dpi
, r
.left
+ WD_FRAMERECT_LEFT
, r
.right
- WD_FRAMERECT_RIGHT
, y
, v
->orders
.list
->IsCompleteTimetable() ? STR_TIMETABLE_TOTAL_TIME
: STR_TIMETABLE_TOTAL_TIME_INCOMPLETE
);
485 y
+= FONT_HEIGHT_NORMAL
;
487 if (v
->timetable_start
!= 0) {
488 /* We are running towards the first station so we can start the
489 * timetable at the given time. */
490 SetDParam(0, STR_JUST_DATE_TINY
);
491 SetDParam(1, v
->timetable_start
);
492 DrawString (dpi
, r
.left
+ WD_FRAMERECT_LEFT
, r
.right
- WD_FRAMERECT_RIGHT
, y
, STR_TIMETABLE_STATUS_START_AT
);
493 } else if (!HasBit(v
->vehicle_flags
, VF_TIMETABLE_STARTED
)) {
494 /* We aren't running on a timetable yet, so how can we be "on time"
495 * when we aren't even "on service"/"on duty"? */
496 DrawString (dpi
, r
.left
+ WD_FRAMERECT_LEFT
, r
.right
- WD_FRAMERECT_RIGHT
, y
, STR_TIMETABLE_STATUS_NOT_STARTED
);
497 } else if (v
->lateness_counter
== 0 || (!_settings_client
.gui
.timetable_in_ticks
&& v
->lateness_counter
/ DAY_TICKS
== 0)) {
498 DrawString (dpi
, r
.left
+ WD_FRAMERECT_LEFT
, r
.right
- WD_FRAMERECT_RIGHT
, y
, STR_TIMETABLE_STATUS_ON_TIME
);
500 SetTimetableParams(0, 1, abs(v
->lateness_counter
));
501 DrawString (dpi
, r
.left
+ WD_FRAMERECT_LEFT
, r
.right
- WD_FRAMERECT_RIGHT
, y
, v
->lateness_counter
< 0 ? STR_TIMETABLE_STATUS_EARLY
: STR_TIMETABLE_STATUS_LATE
);
508 static inline uint32
PackTimetableArgs(const Vehicle
*v
, uint selected
, bool speed
)
510 uint order_number
= (selected
+ 1) / 2;
511 ModifyTimetableFlags mtf
= (selected
% 2 == 1) ? (speed
? MTF_TRAVEL_SPEED
: MTF_TRAVEL_TIME
) : MTF_WAIT_TIME
;
513 if (order_number
>= v
->GetNumOrders()) order_number
= 0;
515 return v
->index
| (order_number
<< 20) | (mtf
<< 28);
518 virtual void OnClick(Point pt
, int widget
, int click_count
)
520 const Vehicle
*v
= this->vehicle
;
523 case WID_VT_ORDER_VIEW
: // Order view button
527 case WID_VT_TIMETABLE_PANEL
: { // Main panel.
528 int selected
= GetOrderFromTimetableWndPt(pt
.y
, v
);
530 this->DeleteChildWindows();
531 this->sel_index
= (selected
== INVALID_ORDER
|| selected
== this->sel_index
) ? -1 : selected
;
535 case WID_VT_START_DATE
: // Change the date that the timetable starts.
536 ShowSetDateWindow(this, v
->index
| (v
->orders
.list
->IsCompleteTimetable() && _ctrl_pressed
? 1U << 20 : 0), _date
, _cur_year
, _cur_year
+ 15, ChangeTimetableStartCallback
);
539 case WID_VT_CHANGE_TIME
: { // "Wait For" button.
540 int selected
= this->sel_index
;
541 VehicleOrderID real
= (selected
+ 1) / 2;
543 if (real
>= v
->GetNumOrders()) real
= 0;
545 const Order
*order
= v
->GetOrder(real
);
546 StringID current
= STR_EMPTY
;
549 uint time
= (selected
% 2 == 1) ? order
->GetTravelTime() : order
->GetWaitTime();
550 if (!_settings_client
.gui
.timetable_in_ticks
) time
/= DAY_TICKS
;
554 current
= STR_JUST_INT
;
558 this->query_is_speed_query
= false;
559 ShowQueryString(current
, STR_TIMETABLE_CHANGE_TIME
, 31, this, CS_NUMERAL
, QSF_ACCEPT_UNCHANGED
);
563 case WID_VT_CHANGE_SPEED
: { // Change max speed button.
564 int selected
= this->sel_index
;
565 VehicleOrderID real
= (selected
+ 1) / 2;
567 if (real
>= v
->GetNumOrders()) real
= 0;
569 StringID current
= STR_EMPTY
;
570 const Order
*order
= v
->GetOrder(real
);
572 if (order
->GetMaxSpeed() != UINT16_MAX
) {
573 SetDParam(0, ConvertKmhishSpeedToDisplaySpeed(order
->GetMaxSpeed()));
574 current
= STR_JUST_INT
;
578 this->query_is_speed_query
= true;
579 ShowQueryString(current
, STR_TIMETABLE_CHANGE_SPEED
, 31, this, CS_NUMERAL
, QSF_NONE
);
583 case WID_VT_CLEAR_TIME
: { // Clear waiting time.
584 uint32 p1
= PackTimetableArgs(v
, this->sel_index
, false);
585 DoCommandP(0, p1
, 0, CMD_CHANGE_TIMETABLE
);
589 case WID_VT_CLEAR_SPEED
: { // Clear max speed button.
590 uint32 p1
= PackTimetableArgs(v
, this->sel_index
, true);
591 DoCommandP(0, p1
, UINT16_MAX
, CMD_CHANGE_TIMETABLE
);
595 case WID_VT_RESET_LATENESS
: // Reset the vehicle's late counter.
596 DoCommandP(0, v
->index
, 0, CMD_SET_VEHICLE_ON_TIME
);
599 case WID_VT_AUTOFILL
: { // Autofill the timetable.
601 if (!HasBit(v
->vehicle_flags
, VF_AUTOFILL_TIMETABLE
)) SetBit(p2
, 0);
602 if (_ctrl_pressed
) SetBit(p2
, 1);
603 DoCommandP(0, v
->index
, p2
, CMD_AUTOFILL_TIMETABLE
);
607 case WID_VT_EXPECTED
:
608 this->show_expected
= !this->show_expected
;
611 case WID_VT_SHARED_ORDER_LIST
:
612 ShowVehicleListWindow(v
);
619 virtual void OnQueryTextFinished(char *str
)
621 if (str
== NULL
) return;
623 const Vehicle
*v
= this->vehicle
;
625 uint32 p1
= PackTimetableArgs(v
, this->sel_index
, this->query_is_speed_query
);
627 uint64 val
= StrEmpty(str
) ? 0 : strtoul(str
, NULL
, 10);
628 if (this->query_is_speed_query
) {
629 val
= ConvertDisplaySpeedToKmhishSpeed(val
);
631 if (!_settings_client
.gui
.timetable_in_ticks
) val
*= DAY_TICKS
;
634 uint32 p2
= minu(val
, UINT16_MAX
);
636 DoCommandP(0, p1
, p2
, CMD_CHANGE_TIMETABLE
);
639 virtual void OnResize()
641 /* Update the scroll bar */
642 this->vscroll
->SetCapacityFromWidget(this, WID_VT_TIMETABLE_PANEL
, WD_FRAMERECT_TOP
+ WD_FRAMERECT_BOTTOM
);
646 * Update the selection state of the arrival/departure data
648 void UpdateSelectionStates()
650 this->GetWidget
<NWidgetStacked
>(WID_VT_ARRIVAL_DEPARTURE_SELECTION
)->SetDisplayedPlane(_settings_client
.gui
.timetable_arrival_departure
? 0 : SZSP_NONE
);
651 this->GetWidget
<NWidgetStacked
>(WID_VT_EXPECTED_SELECTION
)->SetDisplayedPlane(_settings_client
.gui
.timetable_arrival_departure
? 0 : 1);
655 static const NWidgetPart _nested_timetable_widgets
[] = {
656 NWidget(NWID_HORIZONTAL
),
657 NWidget(WWT_CLOSEBOX
, COLOUR_GREY
),
658 NWidget(WWT_CAPTION
, COLOUR_GREY
, WID_VT_CAPTION
), SetDataTip(STR_TIMETABLE_TITLE
, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS
),
659 NWidget(WWT_PUSHTXTBTN
, COLOUR_GREY
, WID_VT_ORDER_VIEW
), SetMinimalSize(61, 14), SetDataTip( STR_TIMETABLE_ORDER_VIEW
, STR_TIMETABLE_ORDER_VIEW_TOOLTIP
),
660 NWidget(WWT_SHADEBOX
, COLOUR_GREY
),
661 NWidget(WWT_DEFSIZEBOX
, COLOUR_GREY
),
662 NWidget(WWT_STICKYBOX
, COLOUR_GREY
),
664 NWidget(NWID_HORIZONTAL
),
665 NWidget(WWT_PANEL
, COLOUR_GREY
, WID_VT_TIMETABLE_PANEL
), SetMinimalSize(388, 82), SetResize(1, 10), SetDataTip(STR_NULL
, STR_TIMETABLE_TOOLTIP
), SetScrollbar(WID_VT_SCROLLBAR
), EndContainer(),
666 NWidget(NWID_SELECTION
, INVALID_COLOUR
, WID_VT_ARRIVAL_DEPARTURE_SELECTION
),
667 NWidget(WWT_PANEL
, COLOUR_GREY
, WID_VT_ARRIVAL_DEPARTURE_PANEL
), SetMinimalSize(110, 0), SetFill(0, 1), SetDataTip(STR_NULL
, STR_TIMETABLE_TOOLTIP
), SetScrollbar(WID_VT_SCROLLBAR
), EndContainer(),
669 NWidget(NWID_VSCROLLBAR
, COLOUR_GREY
, WID_VT_SCROLLBAR
),
671 NWidget(WWT_PANEL
, COLOUR_GREY
, WID_VT_SUMMARY_PANEL
), SetMinimalSize(400, 22), SetResize(1, 0), EndContainer(),
672 NWidget(NWID_HORIZONTAL
),
673 NWidget(NWID_HORIZONTAL
, NC_EQUALSIZE
),
674 NWidget(NWID_VERTICAL
, NC_EQUALSIZE
),
675 NWidget(WWT_PUSHTXTBTN
, COLOUR_GREY
, WID_VT_CHANGE_TIME
), SetResize(1, 0), SetFill(1, 1), SetDataTip(STR_TIMETABLE_CHANGE_TIME
, STR_TIMETABLE_WAIT_TIME_TOOLTIP
),
676 NWidget(WWT_PUSHTXTBTN
, COLOUR_GREY
, WID_VT_CLEAR_TIME
), SetResize(1, 0), SetFill(1, 1), SetDataTip(STR_TIMETABLE_CLEAR_TIME
, STR_TIMETABLE_CLEAR_TIME_TOOLTIP
),
678 NWidget(NWID_VERTICAL
, NC_EQUALSIZE
),
679 NWidget(WWT_PUSHTXTBTN
, COLOUR_GREY
, WID_VT_CHANGE_SPEED
), SetResize(1, 0), SetFill(1, 1), SetDataTip(STR_TIMETABLE_CHANGE_SPEED
, STR_TIMETABLE_CHANGE_SPEED_TOOLTIP
),
680 NWidget(WWT_PUSHTXTBTN
, COLOUR_GREY
, WID_VT_CLEAR_SPEED
), SetResize(1, 0), SetFill(1, 1), SetDataTip(STR_TIMETABLE_CLEAR_SPEED
, STR_TIMETABLE_CLEAR_SPEED_TOOLTIP
),
682 NWidget(NWID_VERTICAL
, NC_EQUALSIZE
),
683 NWidget(WWT_PUSHTXTBTN
, COLOUR_GREY
, WID_VT_START_DATE
), SetResize(1, 0), SetFill(1, 1), SetDataTip(STR_TIMETABLE_STARTING_DATE
, STR_TIMETABLE_STARTING_DATE_TOOLTIP
),
684 NWidget(WWT_PUSHTXTBTN
, COLOUR_GREY
, WID_VT_RESET_LATENESS
), SetResize(1, 0), SetFill(1, 1), SetDataTip(STR_TIMETABLE_RESET_LATENESS
, STR_TIMETABLE_RESET_LATENESS_TOOLTIP
),
686 NWidget(NWID_VERTICAL
, NC_EQUALSIZE
),
687 NWidget(WWT_PUSHTXTBTN
, COLOUR_GREY
, WID_VT_AUTOFILL
), SetResize(1, 0), SetFill(1, 1), SetDataTip(STR_TIMETABLE_AUTOFILL
, STR_TIMETABLE_AUTOFILL_TOOLTIP
),
688 NWidget(NWID_SELECTION
, INVALID_COLOUR
, WID_VT_EXPECTED_SELECTION
),
689 NWidget(WWT_PUSHTXTBTN
, COLOUR_GREY
, WID_VT_EXPECTED
), SetResize(1, 0), SetFill(1, 1), SetDataTip(STR_BLACK_STRING
, STR_TIMETABLE_EXPECTED_TOOLTIP
),
690 NWidget(WWT_PANEL
, COLOUR_GREY
), SetResize(1, 0), SetFill(1, 1), EndContainer(),
694 NWidget(NWID_VERTICAL
, NC_EQUALSIZE
),
695 NWidget(WWT_PUSHIMGBTN
, COLOUR_GREY
, WID_VT_SHARED_ORDER_LIST
), SetFill(0, 1), SetDataTip(SPR_SHARED_ORDERS_ICON
, STR_ORDERS_VEH_WITH_SHARED_ORDERS_LIST_TOOLTIP
),
696 NWidget(WWT_RESIZEBOX
, COLOUR_GREY
), SetFill(0, 1),
701 static WindowDesc::Prefs
_timetable_prefs ("view_vehicle_timetable");
703 static const WindowDesc
_timetable_desc(
705 WC_VEHICLE_TIMETABLE
, WC_VEHICLE_VIEW
,
707 _nested_timetable_widgets
, lengthof(_nested_timetable_widgets
),
712 * Show the timetable for a given vehicle.
713 * @param v The vehicle to show the timetable for.
715 void ShowTimetableWindow(const Vehicle
*v
)
717 DeleteWindowById(WC_VEHICLE_DETAILS
, v
->index
, false);
718 DeleteWindowById(WC_VEHICLE_ORDERS
, v
->index
, false);
719 AllocateWindowDescFront
<TimetableWindow
>(&_timetable_desc
, v
->index
);