source: src/mlx/gui/flight.py@ 1085:31eec9ef6a2d

python3
Last change on this file since 1085:31eec9ef6a2d was 1085:31eec9ef6a2d, checked in by István Váradi <ivaradi@…>, 14 months ago

The SimBrief result displayed by the integrated browser contains the download and prefile links
File size: 248.1 KB
Line 
1# -*- encoding: utf-8 -*-
2
3from mlx.gui.common import *
4import mlx.gui.cef as cef
5from mlx.gui.flightlist import ColumnDescriptor, FlightList, PendingFlightsWindow
6
7import mlx.const as const
8import mlx.fs as fs
9import mlx.acft as acft
10from mlx.flight import Flight
11from mlx.checks import PayloadChecker
12from mlx.gates import lhbpGates
13import mlx.util as util
14from mlx.pirep import PIREP
15from mlx.i18n import xstr, getLanguage
16from mlx.sound import startSound
17from mlx.rpc import BookedFlight
18import mlx.web as web
19
20import datetime
21import time
22import os
23import tempfile
24import threading
25import re
26import webbrowser
27import urllib.request, urllib.error, urllib.parse
28from lxml import etree
29from io import StringIO
30import lxml.html
31import certifi
32
33#-----------------------------------------------------------------------------
34
35## @package mlx.gui.flight
36#
37# The flight "wizard".
38#
39# This module implements the main tab of the application, the flight
40# wizard. The wizard consists of \ref Page "pages", that come one after the
41# other. As some pages might be skipped, the pages dynamically store the index
42# of the previous page so that going back to it is simpler. The \ref
43# Page.activate "activate" function is called before a page is first shown
44# during a flight. This function should initialize the page's controls and fill
45# it with initial data. When a page is left for the first time, its \ref
46# Page.finalize "finalize" function is called. It should set those controls
47# insensitive, that will not be available if the user comes back to this page.
48#
49# Each page has a title at the top displayed in inverted colors and a big
50# font. There is a help text below it centered, that shortly describes what is
51# expected on the page. There can be two help texts: one shown when the page is
52# first displayed during a flight, another shown when the user goes back to the
53# page. The main content area is below this, also centered. Finally, there are
54# some buttons at the bottom on the right. As some buttons occur very
55# frequently, there are functions to add them (\ref Page.addCancelFlightButton
56# "addCancelFlightButton", \ref Page.addPreviousButton "addPreviousButton" and
57# \ref Page.addNextButton "addNextButton".
58#
59# The \ref Wizard class is the main class to collect the pages. It also stores
60# some data passed from one page to another and provides properties to access
61# data items set via the wizard pages.
62
63#-----------------------------------------------------------------------------
64
65comboModel = Gtk.ListStore(GObject.TYPE_STRING)
66comboModel.append(("N/A",))
67comboModel.append(("VECTORS",))
68
69#-----------------------------------------------------------------------------
70
71class Page(Gtk.Alignment):
72 """A page in the flight wizard."""
73 def __init__(self, wizard, id, title, help, completedHelp = None):
74 """Construct the page."""
75 super(Page, self).__init__(xalign = 0.0, yalign = 0.0,
76 xscale = 1.0, yscale = 1.0)
77 self.set_padding(padding_top = 4, padding_bottom = 4,
78 padding_left = 12, padding_right = 12)
79
80 frame = Gtk.Frame()
81 self.add(frame)
82
83 self._vbox = Gtk.VBox()
84 self._vbox.set_homogeneous(False)
85 frame.add(self._vbox)
86
87 eventBox = Gtk.EventBox()
88
89 alignment = Gtk.Alignment(xalign = 0.0, xscale = 0.0)
90
91 titleLabel = Gtk.Label(title)
92 titleLabel.modify_font(Pango.FontDescription("bold 24"))
93 alignment.set_padding(padding_top = 4, padding_bottom = 4,
94 padding_left = 6, padding_right = 0)
95
96 alignment.add(titleLabel)
97 eventBox.add(alignment)
98
99 self._vbox.pack_start(eventBox, False, False, 0)
100
101 self._titleEventBox = eventBox
102 self._titleLabel = titleLabel
103
104 mainBox = Gtk.VBox()
105
106 alignment = Gtk.Alignment(xalign = 0.0, yalign = 0.0,
107 xscale = 1.0, yscale = 1.0)
108 alignment.set_padding(padding_top = 16, padding_bottom = 16,
109 padding_left = 16, padding_right = 16)
110 alignment.add(mainBox)
111 self._vbox.pack_start(alignment, True, True, 0)
112
113 alignment = Gtk.Alignment(xalign = 0.5, yalign = 0.0,
114 xscale = 0.0, yscale = 0.0)
115 alignment.set_padding(padding_top = 0, padding_bottom = 16,
116 padding_left = 0, padding_right = 0)
117
118 self._help = help
119 self._completedHelp = completedHelp
120
121 if self._completedHelp is None or \
122 len(help.splitlines())>=len(completedHelp.splitlines()):
123 longerHelp = help
124 else:
125 longerHelp = completedHelp
126
127 self._helpLabel = Gtk.Label(longerHelp)
128 # FIXME: should be a constant in common
129 self._helpLabel.set_justify(Gtk.Justification.CENTER)
130 self._helpLabel.set_use_markup(True)
131 alignment.add(self._helpLabel)
132 mainBox.pack_start(alignment, False, False, 0)
133
134 self._mainAlignment = Gtk.Alignment(xalign = 0.5, yalign = 0.5,
135 xscale = 1.0, yscale = 1.0)
136 mainBox.pack_start(self._mainAlignment, True, True, 0)
137
138 buttonAlignment = Gtk.Alignment(xalign = 1.0, xscale=0.0, yscale = 0.0)
139 buttonAlignment.set_padding(padding_top = 4, padding_bottom = 10,
140 padding_left = 16, padding_right = 16)
141
142 self._buttonBox = Gtk.HBox()
143 self._buttonBox.set_homogeneous(False)
144 self._defaultButton = None
145 buttonAlignment.add(self._buttonBox)
146
147 self._vbox.pack_start(buttonAlignment, False, False, 0)
148
149 self._wizard = wizard
150 self._id = id
151 self._nextPageID = None
152
153 self._cancelFlightButton = None
154
155 self._completed = False
156 self._fromPage = None
157
158 @property
159 def id(self):
160 """Get the identifier of the page."""
161 return self._id
162
163 @property
164 def nextPageID(self):
165 """Get the identifier of the next page, if set."""
166 return self._nextPageID
167
168 @nextPageID.setter
169 def nextPageID(self, nextPageID):
170 """Set the identifier of the next page."""
171 self._nextPageID = nextPageID
172
173 def setMainWidget(self, widget):
174 """Set the given widget as the main one."""
175 self._mainAlignment.add(widget)
176
177 def addButton(self, label, default = False, sensitive = True,
178 tooltip = None, clicked = None, padding = 4,
179 clickedArg = None):
180 """Add a button with the given label.
181
182 Return the button object created."""
183 button = Gtk.Button(label)
184 self._buttonBox.pack_start(button, False, False, padding)
185 button.set_use_underline(True)
186 if default:
187 button.set_can_default(True)
188 self._defaultButton = button
189 button.set_sensitive(sensitive)
190 if tooltip is not None:
191 button.set_tooltip_text(tooltip)
192 if clicked is not None:
193 if clickedArg is None:
194 button.connect("clicked", clicked)
195 else:
196 button.connect("clicked", clicked, clickedArg)
197 return button
198
199 def addCancelFlightButton(self):
200 """Add the 'Cancel flight' button to the page."""
201 self._cancelFlightButton = \
202 self.addButton(xstr("button_cancelFlight"),
203 sensitive = True,
204 tooltip = xstr("button_cancelFlight_tooltip"),
205 clicked = self._cancelFlight,
206 padding = 16)
207 return self._cancelFlightButton
208
209 def addPreviousButton(self, sensitive = True, clicked = None):
210 """Add the 'Next' button to the page."""
211 return self.addButton(xstr("button_previous"),
212 sensitive = sensitive,
213 tooltip = xstr("button_previous_tooltip"),
214 clicked = clicked)
215
216 def addNextButton(self, default = True, sensitive = True,
217 clicked = None):
218 """Add the 'Next' button to the page."""
219 return self.addButton(xstr("button_next"),
220 default = default,
221 sensitive = sensitive,
222 tooltip = xstr("button_next_tooltip"),
223 clicked = clicked)
224
225 def setStyle(self):
226 """Set the styles of some of the items on the page."""
227 context = self.get_style_context()
228 color = context.get_background_color(Gtk.StateFlags.SELECTED)
229 self._titleEventBox.modify_bg(0, color.to_color())
230 color = context.get_color(Gtk.StateFlags.SELECTED)
231 self._titleLabel.modify_fg(0, color.to_color())
232
233 def initialize(self):
234 """Initialize the page.
235
236 It sets up the primary help, and calls the activate() function."""
237 self._helpLabel.set_markup(self._help)
238 self._helpLabel.set_sensitive(True)
239 self.activate()
240
241 def activate(self):
242 """Called when this page becomes active.
243
244 This default implementation does nothing."""
245 pass
246
247 def prepareShow(self):
248 """Prepare the page for showing, either initially on when later
249 returned to."""
250 pass
251
252 def setHelp(self, help):
253 """Set the help string."""
254 self._help = help
255 if not self._completed:
256 self._helpLabel.set_markup(self._help)
257 self._helpLabel.set_sensitive(True)
258
259 def complete(self):
260 """Called when the page is completed.
261
262 It greys out/changes the help text and then calls finalize()."""
263 self.finalize()
264 if self._completedHelp is None:
265 self._helpLabel.set_sensitive(False)
266 else:
267 self._helpLabel.set_markup(self._completedHelp)
268 self._completed = True
269
270 def finalize(self):
271 """Called when the page is finalized."""
272 pass
273
274 def grabDefault(self):
275 """If the page has a default button, make it the default one."""
276 if self._defaultButton is not None:
277 self._defaultButton.grab_default()
278
279 def prepareHide(self):
280 """Prepare the page for hiding, either initially on when later
281 the user returned to it and then navigates away from it."""
282 pass
283
284 def reset(self):
285 """Reset the page if the wizard is reset."""
286 self._completed = False
287 self._fromPage = None
288 if self._cancelFlightButton is not None:
289 self._cancelFlightButton.set_sensitive(True)
290
291 def goBack(self):
292 """Go to the page we were invoked from."""
293 assert self._fromPage is not None
294
295 self._wizard.setCurrentPage(self._fromPage, finalize = False)
296
297 def flightEnded(self):
298 """Called when the flight has ended.
299
300 This default implementation disables the cancel flight button."""
301 if self._cancelFlightButton is not None:
302 self._cancelFlightButton.set_sensitive(False)
303
304 def _cancelFlight(self, button):
305 """Called when the Cancel flight button is clicked."""
306 self._wizard.gui.cancelFlight()
307
308#-----------------------------------------------------------------------------
309
310class LoginPage(Page):
311 """The login page."""
312 def __init__(self, wizard):
313 """Construct the login page."""
314 super(LoginPage, self).__init__(wizard, "login",
315 xstr("login"), xstr("loginHelp"))
316
317 alignment = Gtk.Alignment(xalign = 0.5, yalign = 0.5,
318 xscale = 0.0, yscale = 0.0)
319
320 table = Gtk.Table(3, 2)
321 table.set_row_spacings(4)
322 table.set_col_spacings(32)
323 alignment.add(table)
324 self.setMainWidget(alignment)
325
326 labelAlignment = Gtk.Alignment(xalign = 1.0, yalign = 0.5,
327 xscale = 0.0, yscale = 0.0)
328 label = Gtk.Label(xstr("label_pilotID"))
329 label.set_use_underline(True)
330 labelAlignment.add(label)
331 table.attach(labelAlignment, 0, 1, 0, 1)
332
333 self._pilotID = Gtk.Entry()
334 self._pilotID.connect("changed", self._pilotIDChanged)
335 self._pilotID.set_tooltip_text(xstr("login_pilotID_tooltip"))
336 table.attach(self._pilotID, 1, 2, 0, 1)
337 label.set_mnemonic_widget(self._pilotID)
338
339 labelAlignment = Gtk.Alignment(xalign = 1.0, yalign = 0.5,
340 xscale = 0.0, yscale = 0.0)
341 label = Gtk.Label(xstr("label_password"))
342 label.set_use_underline(True)
343 labelAlignment.add(label)
344 table.attach(labelAlignment, 0, 1, 1, 2)
345
346 self._password = Gtk.Entry()
347 self._password.set_visibility(False)
348 self._password.connect("changed", self._setControls)
349 self._password.set_tooltip_text(xstr("login_password_tooltip"))
350 table.attach(self._password, 1, 2, 1, 2)
351 label.set_mnemonic_widget(self._password)
352
353 self._rememberButton = Gtk.CheckButton(xstr("remember_password"))
354 self._rememberButton.set_use_underline(True)
355 self._rememberButton.set_tooltip_text(xstr("login_remember_tooltip"))
356 table.attach(self._rememberButton, 1, 2, 2, 3, ypadding = 8)
357
358 self.addButton(xstr("button_login_register"),
359 clicked = self._registerClicked,
360 tooltip = xstr("button_login_register_tooltip"))
361
362 self.addButton(xstr("button_offline"),
363 clicked = self._offlineClicked,
364 tooltip = xstr("button_offline_tooltip"))
365
366 self._loginButton = self.addButton(xstr("button_login"), default = True)
367 self._loginButton.connect("clicked", self._loginClicked)
368 self._loginButton.set_tooltip_text(xstr("login_button_tooltip"))
369
370
371 @property
372 def pilotID(self):
373 """Get the pilot ID, if given."""
374 return self._pilotID.get_text()
375
376 def activate(self):
377 """Activate the page."""
378 config = self._wizard.gui.config
379 self._pilotID.set_text(config.pilotID)
380 self._password.set_text(config.password)
381 self._rememberButton.set_active(config.rememberPassword)
382 self._setControls(None)
383
384 def _pilotIDChanged(self, entry):
385 """Called when the pilot ID has changed.
386
387 It sets the text to upper-case and calls _setControls to update other
388 stuff."""
389 entry.set_text(entry.get_text().upper())
390 self._setControls(entry)
391
392 def _setControls(self, entry = None):
393 """Set the sensitivity of the various controls.
394
395 The login button is sensitive only if both the pilot ID and the
396 password fields contain values.
397
398 The password field is sensitive only, if the entrance exam checkbox is
399 not selected.
400
401 The remember password checkbox is sensitive only, if the password field
402 contains text.
403
404 The entrance exam checkbox is sensitive only, if the pilot ID is not
405 empty."""
406 pilotID = self._pilotID.get_text()
407 password = self._password.get_text()
408 self._rememberButton.set_sensitive(password!="")
409 self._loginButton.set_sensitive(pilotID!="" and password!="")
410
411 def _registerClicked(self, button):
412 """Called when the Register button was clicked."""
413 self._wizard.jumpPage("register")
414
415 def _offlineClicked(self, button):
416 """Called when the offline button was clicked."""
417 print("mlx.flight.LoginPage: offline flight selected")
418 self._wizard.nextPage()
419
420 def _loginClicked(self, button):
421 """Called when the login button was clicked."""
422 print("mlx.flight.LoginPage: logging in")
423 self._wizard.login(self._handleLoginResult,
424 self._pilotID.get_text(),
425 self._password.get_text())
426
427 def _handleLoginResult(self, returned, result):
428 """Handle the login result."""
429 self._loginButton.set_sensitive(True)
430 if returned and result.loggedIn:
431 config = self._wizard.gui.config
432
433 config.pilotID = self._pilotID.get_text()
434
435 rememberPassword = self._rememberButton.get_active()
436 config.password = result.password if rememberPassword else ""
437
438 config.rememberPassword = rememberPassword
439
440 config.save()
441 if result.rank=="STU":
442 self._wizard.jumpPage("student")
443 else:
444 self._wizard.nextPage()
445
446#-----------------------------------------------------------------------------
447
448class FlightSelectionPage(Page):
449 """The page to select the flight."""
450 def __init__(self, wizard):
451 """Construct the flight selection page."""
452 help = xstr("flightsel_help")
453 completedHelp = xstr("flightsel_chelp")
454 super(FlightSelectionPage, self).__init__(wizard, "flightsel",
455 xstr("flightsel_title"),
456 help, completedHelp = completedHelp)
457
458 mainBox = Gtk.HBox()
459 mainBox.set_homogeneous(False)
460
461 leftVBox = Gtk.VBox()
462
463 alignment = Gtk.Alignment(xscale = 1.0)
464 alignment.set_size_request(100, 0)
465
466 leftVBox.pack_start(alignment, False, False, 0)
467
468 mainBox.pack_start(leftVBox, True, True, 0)
469
470 self._flightList = FlightList(popupMenuProducer =
471 self._createListPopupMenu,
472 widthRequest = 400)
473 self._flightList.connect("row-activated", self._rowActivated)
474 self._flightList.connect("selection-changed", self._selectionChanged)
475
476 mainBox.pack_start(self._flightList, False, False, 8)
477
478 flightButtonBox = Gtk.VBox()
479
480 alignment = Gtk.Alignment(xscale = 1.0)
481 alignment.set_size_request(100, 0)
482 flightButtonBox.pack_start(alignment, False, False, 0)
483
484 flightButtonWidthAlignment = Gtk.Alignment(xscale=1.0, yscale=0.0,
485 xalign=0.0, yalign=0.0)
486 flightButtonWidthAlignment.set_padding(padding_top = 0,
487 padding_bottom = 0,
488 padding_left = 8,
489 padding_right = 0)
490 flightButtonWidthBox = Gtk.VBox()
491
492 self._saveButton = Gtk.Button(xstr("flightsel_save"))
493 self._saveButton.set_use_underline(True)
494 self._saveButton.set_sensitive(False)
495 self._saveButton.set_tooltip_text(xstr("flightsel_save_tooltip"))
496 self._saveButton.connect("clicked", self._saveClicked)
497
498 flightButtonWidthBox.pack_start(self._saveButton, True, True, 4)
499
500 self._printButton = Gtk.Button(xstr("flightsel_print"))
501 self._printButton.set_use_underline(True)
502 self._printButton.set_sensitive(False)
503 self._printButton.set_tooltip_text(xstr("flightsel_print_tooltip"))
504 self._printButton.connect("clicked", self._printClicked)
505
506 flightButtonWidthBox.pack_start(self._printButton, True, True, 4)
507
508 self._deleteButton = Gtk.Button(xstr("flightsel_delete"))
509 self._deleteButton.set_use_underline(True)
510 self._deleteButton.set_sensitive(False)
511 self._deleteButton.set_tooltip_text(xstr("flightsel_delete_tooltip"))
512 self._deleteButton.connect("clicked", self._deleteClicked)
513
514 flightButtonWidthBox.pack_start(self._deleteButton, True, True, 4)
515
516 flightButtonWidthAlignment.add(flightButtonWidthBox)
517 flightButtonBox.pack_start(flightButtonWidthAlignment, False, False, 0)
518
519 mainBox.pack_start(flightButtonBox, True, True, 0)
520
521 self.setMainWidget(mainBox)
522
523 self._bookButton = self.addButton(xstr("flightsel_book"),
524 sensitive = True,
525 clicked = self._bookClicked,
526 tooltip = xstr("flightsel_book_tooltip"))
527
528 self._pendingButton = self.addButton(xstr("flightsel_pending"),
529 sensitive = False,
530 clicked = self._pendingClicked,
531 tooltip = xstr("flightsel_pending_tooltip"))
532
533 self._saveDialog = None
534
535 self._refreshButton = self.addButton(xstr("flightsel_refresh"),
536 sensitive = True,
537 clicked = self._refreshClicked,
538 tooltip = xstr("flightsel_refresh_tooltip"))
539
540 self._loadButton = self.addButton(xstr("flightsel_load"),
541 sensitive = True,
542 tooltip = xstr("flightsel_load_tooltip"))
543 self._loadButton.connect("clicked", self._loadButtonClicked)
544 self._loadDialog = None
545
546 self._button = self.addNextButton(sensitive = False,
547 clicked = self._forwardClicked)
548
549 self._flights = []
550
551 self._pendingFlightsWindow = PendingFlightsWindow(self._wizard)
552 self._pendingFlightsWindowShown = False
553 self._pendingFlightsWindow.connect("delete-event",
554 self._deletePendingFlightsWindow)
555
556 self._printSettings = None
557
558 def activate(self):
559 """Fill the flight list."""
560 self._setupHelp()
561 self._flightList.set_sensitive(True)
562 self._loadButton.set_sensitive(True)
563 self._refreshButton.set_sensitive(self._wizard.loggedIn)
564 self._buildFlights()
565
566 def finalize(self):
567 """Finalize the page."""
568 self._flightList.set_sensitive(False)
569 self._loadButton.set_sensitive(False)
570 self._refreshButton.set_sensitive(False)
571
572 def _setupHelp(self):
573 """Setup the help string"""
574 help = ""
575
576 if self._wizard.loggedIn:
577 numReported = len(self._wizard.loginResult.reportedFlights)
578 numRejected = len(self._wizard.loginResult.rejectedFlights)
579 if numReported==0 and numRejected==0:
580 help = xstr("flightsel_prehelp_nopending")
581 elif numReported>0 and numRejected==0:
582 help = xstr("flightsel_prehelp_rep_0rej") % (numReported,)
583 elif numReported==0 and numRejected>0:
584 help = xstr("flightsel_prehelp_0rep_rej") % (numRejected,)
585 else:
586 help = xstr("flightsel_prehelp_rep_rej") % \
587 (numReported, numRejected)
588
589 help += xstr("flightsel_help")
590
591 self.setHelp(help)
592
593 def _buildFlights(self):
594 """Rebuild the flights from the login result."""
595 self._flights = []
596 self._flightList.clear()
597 self._pendingFlightsWindow.clear()
598 loginResult = self._wizard.loginResult
599 if self._wizard.loggedIn:
600 for flight in loginResult.flights:
601 self.addFlight(flight)
602 for flight in loginResult.reportedFlights:
603 self._pendingFlightsWindow.addReportedFlight(flight)
604 for flight in loginResult.rejectedFlights:
605 self._pendingFlightsWindow.addRejectedFlight(flight)
606
607 self._updatePendingButton()
608
609 def addFlight(self, flight):
610 """Add the given file to the list of flights."""
611 self._flights.append(flight)
612 self._flightList.addFlight(flight)
613
614 def _reflyFlight(self, flight):
615 """Refly the given flight."""
616 self.addFlight(flight)
617 self._updatePending()
618
619 def _updatePending(self):
620 """Update the stuff depending on the set of pending flights."""
621 self._setupHelp()
622 self._updatePendingButton()
623
624 def _bookClicked(self, button):
625 """Called when the Book flights button is clicked."""
626 self._wizard.gui.showTimetable()
627
628 def _pendingClicked(self, button):
629 """Called when the Pending flights button is clicked."""
630 self._pendingFlightsWindow.show_all()
631 self._pendingFlightsWindowShown = True
632 self._updateNextButton()
633
634 def _deletePendingFlightsWindow(self, window, event):
635 """Called when the pending flights window is closed."""
636 self._pendingFlightsWindow.hide()
637 self._pendingFlightsWindowShown = False
638 self._updateNextButton()
639 return True
640
641 def _saveClicked(self, button):
642 """Called when the Save flight button is clicked."""
643 self._saveSelected()
644
645 def _saveSelected(self):
646 """Save the selected flight."""
647 flight = self._getSelectedFlight()
648 date = flight.departureTime.date()
649 name = "%04d-%02d-%02d %s %s-%s.vaflight" % \
650 (date.year, date.month, date.day, flight.callsign,
651 flight.departureICAO, flight.arrivalICAO)
652
653 dialog = self._getSaveDialog()
654 dialog.set_current_name(name)
655 dialog.show_all()
656 response = dialog.run()
657 dialog.hide()
658
659 if response==Gtk.ResponseType.OK:
660 fileName = dialog.get_filename()
661 print("Saving", fileName)
662 try:
663 with open(fileName, "wt") as f:
664 flight.writeIntoFile(f)
665 except Exception as e:
666 print("Failed to save flight:", util.utf2unicode(str(e)))
667 dialog = Gtk.MessageDialog(parent = self._wizard.gui.mainWindow,
668 type = Gtk.MessageType.ERROR,
669 message_format =
670 xstr("flightsel_save_failed"))
671 dialog.add_button(xstr("button_ok"), Gtk.ResponseType.OK)
672 dialog.set_title(WINDOW_TITLE_BASE)
673 secondary = xstr("flightsel_save_failed_sec")
674 dialog.format_secondary_markup(secondary)
675 dialog.run()
676 dialog.hide()
677
678 def _printClicked(self, button):
679 """Called when the Print briefing button is clicked."""
680 self._printSelected()
681
682 def _printSelected(self):
683 """Print the briefing for the selected flight."""
684 wizard = self._wizard
685 flight = self._getSelectedFlight()
686
687 printOperation = Gtk.PrintOperation()
688 if self._printSettings is not None:
689 printOperation.set_print_settings(self._printSettings)
690
691 printOperation.set_n_pages(1)
692 printOperation.set_show_progress(True)
693 printOperation.connect("draw_page", self._drawBriefing)
694
695 name = "MAVA Briefing %s %s %s" % (wizard.loginResult.pilotID,
696 flight.callsign,
697 flight.departureTime.strftime("%Y-%m-%d %H:%M"))
698 printOperation.set_job_name(name)
699 printOperation.set_export_filename(name)
700 printOperation.set_use_full_page(False)
701
702 result = printOperation.run(Gtk.PrintOperationAction.PRINT_DIALOG,
703 wizard.gui.mainWindow)
704
705 if result == Gtk.PrintOperationResult.APPLY:
706 self._printSettings = printOperation.get_print_settings()
707 elif result == Gtk.PrintOperationResult.ERROR:
708 errorDialog(xstr("flightsel_print_failed",
709 wizard.gui.mainWindow,
710 secondary = printOperation.get_error()))
711
712 def _drawBriefing(self, printOperation, context, pageNumber):
713 """Draw the briefing."""
714 wizard = self._wizard
715 loginResult = wizard.loginResult
716 flight=self._getSelectedFlight()
717
718 print("DPI", context.get_dpi_x(), context.get_dpi_y())
719
720 logoSurface = cairo.ImageSurface.create_from_png(
721 os.path.join(wizard.gui.programDirectory, "mavalogo.png"))
722
723 scale = context.get_dpi_x() / 72.0
724
725 cr = context.get_cairo_context()
726
727 cr.set_antialias(cairo.ANTIALIAS_GRAY)
728
729 pcr = context.create_pango_context()
730
731 delimiter = "*" * 70
732
733 layout = Pango.Layout(pcr)
734
735 font = Pango.FontDescription("Courier")
736 font.set_size(int(12 * Pango.SCALE))
737 font.set_weight(Pango.Weight.THIN)
738 layout.set_font_description(font)
739
740 fontBold = Pango.FontDescription("Courier")
741 fontBold.set_size(int(12 * Pango.SCALE))
742 fontBold.set_weight(Pango.Weight.BOLD)
743
744 layout.set_text(delimiter)
745 (_ink, logical) = layout.get_extents()
746 width = logical.width / Pango.SCALE
747
748 x0 = (context.get_width() - width)/2.0
749
750 logoWidth = width / 3
751 logoScale = logoSurface.get_width() / logoWidth
752
753 y = 25 * scale
754
755 source = cr.get_source()
756 logoSurface.set_device_scale(logoScale, logoScale)
757 cr.set_source_surface(logoSurface, x0, y)
758 cr.rectangle(x0, y, logoSurface.get_width() / logoScale,
759 logoSurface.get_height() / logoScale)
760 cr.fill()
761 cr.set_source(source)
762
763 y += logoSurface.get_height() / logoScale
764 y += 12 * scale
765
766 cr.move_to(x0, y)
767 cr.set_line_width(0.1 * scale)
768 PangoCairo.layout_path(cr, layout)
769 cr.stroke_preserve()
770 cr.fill()
771
772 y += logical.height / Pango.SCALE
773 y += 4 * scale
774
775 layout.set_text("F L I G H T B R I E F I N G S H E E T")
776 (_ink, logical) = layout.get_extents()
777 width = logical.width / Pango.SCALE
778
779 cr.move_to((context.get_width() - width)/2.0, y)
780 cr.set_line_width(0.1 * scale)
781 PangoCairo.layout_path(cr, layout)
782 cr.stroke_preserve()
783 cr.fill()
784
785 y += logical.height / Pango.SCALE
786 y += 4 * scale
787
788 layout.set_text(delimiter)
789 (_ink, logical) = layout.get_extents()
790 width = logical.width / Pango.SCALE
791
792 x2 = x0 + width * 0.4
793
794 cr.move_to(x0, y)
795 cr.set_line_width(0.1 * scale)
796 PangoCairo.layout_path(cr, layout)
797 cr.stroke_preserve()
798 cr.fill()
799
800 y += logical.height / Pango.SCALE
801 y += 5 * scale
802
803 layout.set_text("AIRCRAFT: ")
804 layout.set_font_description(fontBold)
805 (_ink, logical) = layout.get_extents()
806 x1 = x0 + logical.width / Pango.SCALE
807
808 layout.set_text("FLIGHT:")
809 layout.set_font_description(fontBold)
810
811 cr.move_to(x0, y)
812 cr.set_line_width(0.1 * scale)
813 PangoCairo.layout_path(cr, layout)
814 cr.stroke_preserve()
815 cr.fill()
816
817 layout.set_text("%s %s-%s" % (flight.callsign,
818 flight.departureICAO,
819 flight.arrivalICAO))
820
821 layout.set_font_description(font)
822
823 cr.move_to(x1, y)
824 cr.set_line_width(0.1 * scale)
825 PangoCairo.layout_path(cr, layout)
826 cr.stroke_preserve()
827 cr.fill()
828
829 layout.set_text("DATE:")
830 layout.set_font_description(fontBold)
831 (_ink, logical) = layout.get_extents()
832 x3 = x2 + logical.width / Pango.SCALE
833
834 cr.move_to(x2, y)
835 cr.set_line_width(0.1 * scale)
836 PangoCairo.layout_path(cr, layout)
837 cr.stroke_preserve()
838 cr.fill()
839
840 layout.set_text(" %s" % (flight.date,))
841 layout.set_font_description(font)
842
843 cr.move_to(x3, y)
844 cr.set_line_width(0.1 * scale)
845 PangoCairo.layout_path(cr, layout)
846 cr.stroke_preserve()
847 cr.fill()
848
849 layout.set_text(" %02d:%02d" % (flight.departureTime.hour,
850 flight.departureTime.minute))
851 (_ink, logical) = layout.get_extents()
852 x5 = x0 + width - logical.width / Pango.SCALE
853 cr.move_to(x5, y)
854 cr.set_line_width(0.1 * scale)
855 PangoCairo.layout_path(cr, layout)
856 cr.stroke_preserve()
857 cr.fill()
858
859 layout.set_text("ETD (UTC):")
860 layout.set_font_description(fontBold)
861 (_ink, logical) = layout.get_extents()
862 x4 = x5 - logical.width / Pango.SCALE
863 cr.move_to(x4, y)
864 cr.set_line_width(0.1 * scale)
865 PangoCairo.layout_path(cr, layout)
866 cr.stroke_preserve()
867 cr.fill()
868
869 y += logical.height / Pango.SCALE
870 y += 4 * scale
871
872 layout.set_text("AIRCRAFT:")
873 layout.set_font_description(fontBold)
874 cr.move_to(x0, y)
875 cr.set_line_width(0.1 * scale)
876 PangoCairo.layout_path(cr, layout)
877 cr.stroke_preserve()
878 cr.fill()
879
880 layout.set_text(aircraftNames[flight.aircraftType].upper())
881 layout.set_font_description(font)
882 cr.move_to(x1, y)
883 cr.set_line_width(0.1 * scale)
884 PangoCairo.layout_path(cr, layout)
885 cr.stroke_preserve()
886 cr.fill()
887
888 layout.set_text(" %02d:%02d" % (flight.arrivalTime.hour,
889 flight.arrivalTime.minute))
890 cr.move_to(x5, y)
891 cr.set_line_width(0.1 * scale)
892 PangoCairo.layout_path(cr, layout)
893 cr.stroke_preserve()
894 cr.fill()
895
896 layout.set_text("ETA (UTC):")
897 layout.set_font_description(fontBold)
898 cr.move_to(x4, y)
899 cr.set_line_width(0.1 * scale)
900 PangoCairo.layout_path(cr, layout)
901 cr.stroke_preserve()
902 cr.fill()
903
904 y += logical.height / Pango.SCALE
905 y += 4 * scale
906
907 layout.set_text("CREW:")
908 layout.set_font_description(fontBold)
909 cr.move_to(x0, y)
910 cr.set_line_width(0.1 * scale)
911 PangoCairo.layout_path(cr, layout)
912 cr.stroke_preserve()
913 cr.fill()
914
915 layout.set_text("%d + %d" % (flight.numCockpitCrew,
916 flight.numCabinCrew))
917 layout.set_font_description(font)
918 cr.move_to(x1, y)
919 cr.set_line_width(0.1 * scale)
920 PangoCairo.layout_path(cr, layout)
921 cr.stroke_preserve()
922 cr.fill()
923
924 layout.set_text("DOW:")
925 layout.set_font_description(fontBold)
926 cr.move_to(x4, y)
927 cr.set_line_width(0.1 * scale)
928 PangoCairo.layout_path(cr, layout)
929 cr.stroke_preserve()
930 cr.fill()
931
932 layout.set_text("%d KG" % (flight.dow,))
933 layout.set_font_description(font)
934 (_ink, logical) = layout.get_extents()
935 x5 = x0 + width - logical.width / Pango.SCALE
936 cr.move_to(x5, y)
937 cr.set_line_width(0.1 * scale)
938 PangoCairo.layout_path(cr, layout)
939 cr.stroke_preserve()
940 cr.fill()
941
942 y += logical.height / Pango.SCALE
943 y += logical.height / Pango.SCALE
944 y += 4 * scale
945
946 layout.set_text("PASSENGERS")
947 layout.set_font_description(fontBold)
948 cr.move_to(x0, y)
949 cr.set_line_width(0.1 * scale)
950 PangoCairo.layout_path(cr, layout)
951 cr.stroke_preserve()
952 cr.fill()
953
954 layout.set_text("CARGO HOLDS")
955 layout.set_font_description(fontBold)
956 cr.move_to(x2, y)
957 cr.set_line_width(0.1 * scale)
958 PangoCairo.layout_path(cr, layout)
959 cr.stroke_preserve()
960 cr.fill()
961
962 layout.set_text("TOTAL")
963 layout.set_font_description(fontBold)
964 cr.move_to(x4, y)
965 cr.set_line_width(0.1 * scale)
966 PangoCairo.layout_path(cr, layout)
967 cr.stroke_preserve()
968 cr.fill()
969
970 y += logical.height / Pango.SCALE
971 y += 4 * scale
972
973 layout.set_text("CHILDREN:")
974 layout.set_font_description(font)
975 (_ink, logical) = layout.get_extents()
976 x1 = x0 + logical.width / Pango.SCALE
977
978 layout.set_text("CARGO:")
979 layout.set_font_description(font)
980 (_ink, logical) = layout.get_extents()
981 x3 = x2 + logical.width / Pango.SCALE
982
983 layout.set_text("ADULTS:")
984 layout.set_font_description(font)
985 cr.move_to(x0, y)
986 cr.set_line_width(0.1 * scale)
987 PangoCairo.layout_path(cr, layout)
988 cr.stroke_preserve()
989 cr.fill()
990
991 layout.set_text(" %3d" % (flight.numPassengers,))
992 layout.set_font_description(font)
993 cr.move_to(x1, y)
994 cr.set_line_width(0.1 * scale)
995 PangoCairo.layout_path(cr, layout)
996 cr.stroke_preserve()
997 cr.fill()
998
999 layout.set_text("BAGS:")
1000 layout.set_font_description(font)
1001 cr.move_to(x2, y)
1002 cr.set_line_width(0.1 * scale)
1003 PangoCairo.layout_path(cr, layout)
1004 cr.stroke_preserve()
1005 cr.fill()
1006
1007 layout.set_text(" %5d KG" % (flight.bagWeight,))
1008 layout.set_font_description(font)
1009 cr.move_to(x3, y)
1010 cr.set_line_width(0.1 * scale)
1011 PangoCairo.layout_path(cr, layout)
1012 cr.stroke_preserve()
1013 cr.fill()
1014
1015 y += logical.height / Pango.SCALE
1016 y += 4 * scale
1017
1018 layout.set_text("CHILDREN:")
1019 layout.set_font_description(font)
1020 cr.move_to(x0, y)
1021 cr.set_line_width(0.1 * scale)
1022 PangoCairo.layout_path(cr, layout)
1023 cr.stroke_preserve()
1024 cr.fill()
1025
1026 layout.set_text(" %3d" % (flight.numChildren,))
1027 layout.set_font_description(font)
1028 cr.move_to(x1, y)
1029 cr.set_line_width(0.1 * scale)
1030 PangoCairo.layout_path(cr, layout)
1031 cr.stroke_preserve()
1032 cr.fill()
1033
1034 layout.set_text("MAIL:")
1035 layout.set_font_description(font)
1036 cr.move_to(x2, y)
1037 cr.set_line_width(0.1 * scale)
1038 PangoCairo.layout_path(cr, layout)
1039 cr.stroke_preserve()
1040 cr.fill()
1041
1042 layout.set_text(" %5d KG" % (flight.mailWeight,))
1043 layout.set_font_description(font)
1044 cr.move_to(x3, y)
1045 cr.set_line_width(0.1 * scale)
1046 PangoCairo.layout_path(cr, layout)
1047 cr.stroke_preserve()
1048 cr.fill()
1049
1050 layout.set_text("PAYLOAD:")
1051 layout.set_font_description(font)
1052 cr.move_to(x4, y)
1053 cr.set_line_width(0.1 * scale)
1054 PangoCairo.layout_path(cr, layout)
1055 cr.stroke_preserve()
1056 cr.fill()
1057
1058 layout.set_text("%5d KG" % (flight.payload,))
1059 layout.set_font_description(font)
1060 (_ink, logical) = layout.get_extents()
1061 x5 = x0 + width - logical.width / Pango.SCALE
1062 cr.move_to(x5, y)
1063 cr.set_line_width(0.1 * scale)
1064 PangoCairo.layout_path(cr, layout)
1065 cr.stroke_preserve()
1066 cr.fill()
1067
1068 y += logical.height / Pango.SCALE
1069 y += 4 * scale
1070
1071 layout.set_text("INFANTS:")
1072 layout.set_font_description(font)
1073 cr.move_to(x0, y)
1074 cr.set_line_width(0.1 * scale)
1075 PangoCairo.layout_path(cr, layout)
1076 cr.stroke_preserve()
1077 cr.fill()
1078
1079 layout.set_text(" %3d" % (flight.numInfants,))
1080 layout.set_font_description(font)
1081 cr.move_to(x1, y)
1082 cr.set_line_width(0.1 * scale)
1083 PangoCairo.layout_path(cr, layout)
1084 cr.stroke_preserve()
1085 cr.fill()
1086
1087 layout.set_text("CARGO:")
1088 layout.set_font_description(font)
1089 cr.move_to(x2, y)
1090 cr.set_line_width(0.1 * scale)
1091 PangoCairo.layout_path(cr, layout)
1092 cr.stroke_preserve()
1093 cr.fill()
1094
1095 layout.set_text(" %5d KG" % (flight.cargoWeight,))
1096 layout.set_font_description(font)
1097 cr.move_to(x3, y)
1098 cr.set_line_width(0.1 * scale)
1099 PangoCairo.layout_path(cr, layout)
1100 cr.stroke_preserve()
1101 cr.fill()
1102
1103 layout.set_text("ZFW:")
1104 layout.set_font_description(font)
1105 cr.move_to(x4, y)
1106 cr.set_line_width(0.1 * scale)
1107 PangoCairo.layout_path(cr, layout)
1108 cr.stroke_preserve()
1109 cr.fill()
1110
1111 layout.set_text("%5d KG" % (flight.dow + flight.payload,))
1112 layout.set_font_description(font)
1113 (_ink, logical) = layout.get_extents()
1114 x5 = x0 + width - logical.width / Pango.SCALE
1115 cr.move_to(x5, y)
1116 cr.set_line_width(0.1 * scale)
1117 PangoCairo.layout_path(cr, layout)
1118 cr.stroke_preserve()
1119 cr.fill()
1120
1121 y += logical.height / Pango.SCALE
1122 y += logical.height / Pango.SCALE
1123 y += 4 * scale
1124
1125 layout.set_text("ROUTE:")
1126 layout.set_font_description(fontBold)
1127 (_ink, logical) = layout.get_extents()
1128 x1 = x0 + logical.width / Pango.SCALE
1129 cr.move_to(x0, y)
1130 cr.set_line_width(0.1 * scale)
1131 PangoCairo.layout_path(cr, layout)
1132 cr.stroke_preserve()
1133 cr.fill()
1134
1135 routeWords = flight.route.split(" ")
1136 layout.set_font_description(font)
1137
1138 startWord = 0
1139 textWidth = width - (x1 - x0)
1140 while startWord<len(routeWords):
1141 endWord = startWord + 1
1142 while endWord<=len(routeWords):
1143 layout.set_text(" %s" % (" ".join(routeWords[startWord:endWord]),))
1144 (_ink, logical) = layout.get_extents()
1145 if textWidth<logical.width / Pango.SCALE:
1146 endWord -= 1
1147 if endWord<=startWord:
1148 endWord = startWord + 1
1149 break
1150 endWord += 1
1151
1152 layout.set_text(" %s" % (" ".join(routeWords[startWord:endWord]),))
1153 cr.move_to(x1, y)
1154 cr.set_line_width(0.1 * scale)
1155 PangoCairo.layout_path(cr, layout)
1156 cr.stroke_preserve()
1157 cr.fill()
1158
1159 startWord = endWord
1160
1161 y += logical.height / Pango.SCALE
1162 y += 4 * scale
1163
1164 y += logical.height / Pango.SCALE
1165
1166 layout.set_text(delimiter)
1167 layout.set_font_description(font)
1168 cr.move_to(x0, y)
1169 cr.set_line_width(0.1 * scale)
1170 PangoCairo.layout_path(cr, layout)
1171 cr.stroke_preserve()
1172 cr.fill()
1173
1174 def _deleteClicked(self, button):
1175 """Called when the Delete flight button is clicked."""
1176 self._deleteSelected()
1177
1178 def _deleteSelected(self):
1179 """Delete the selected flight."""
1180 if askYesNo(xstr("flightsel_delete_confirm"),
1181 parent = self._wizard.gui.mainWindow):
1182 flight = self._getSelectedFlight()
1183 gui = self._wizard.gui
1184 gui.beginBusy(xstr("flightsel_delete_busy"))
1185
1186 gui.webHandler.deleteFlights(self._deleteResultCallback,
1187 [flight.id])
1188
1189 def _deleteResultCallback(self, returned, result):
1190 """Called when the deletion result is available."""
1191 GObject.idle_add(self._handleDeleteResult, returned, result)
1192
1193 def _handleDeleteResult(self, returned, result):
1194 """Handle the delete result."""
1195 gui = self._wizard.gui
1196 gui.endBusy()
1197
1198 if returned:
1199 indexes = self._flightList.selectedIndexes
1200
1201 flights = [self._flights[index] for index in indexes]
1202
1203 self._flightList.removeFlights(indexes)
1204 for index in indexes[::-1]:
1205 del self._flights[index]
1206 else:
1207 communicationErrorDialog()
1208
1209
1210 def _refreshClicked(self, button):
1211 """Called when the refresh button is clicked."""
1212 self._wizard.reloadFlights(self._refreshCallback)
1213
1214 def _refreshCallback(self, returned, result):
1215 """Callback for the refresh."""
1216 if returned:
1217 self._setupHelp()
1218 if result.loggedIn:
1219 self._buildFlights()
1220
1221 def _selectionChanged(self, flightList, indexes):
1222 """Called when the selection is changed."""
1223 self._saveButton.set_sensitive(len(indexes)==1)
1224 self._printButton.set_sensitive(len(indexes)==1)
1225 self._deleteButton.set_sensitive(len(indexes)==1)
1226 self._updateNextButton()
1227
1228 def _updatePendingButton(self):
1229 """Update the senstivity of the Pending button."""
1230 self._pendingButton.set_sensitive(self._pendingFlightsWindow.hasFlights)
1231
1232 def _updateNextButton(self):
1233 """Update the sensitivity of the Next button."""
1234 sensitive = len(self._flightList.selectedIndexes)==1 and \
1235 len(self._flights)>0 and \
1236 not self._pendingFlightsWindowShown
1237 if sensitive:
1238 flight = self._getSelectedFlight()
1239 flightDate = datetime.datetime.strptime(flight.date, "%Y-%m-%d").date()
1240 tomorrow = datetime.date.today() + datetime.timedelta(days=1)
1241 print(flightDate, tomorrow)
1242 sensitive = flightDate <= tomorrow
1243 self._button.set_sensitive(sensitive)
1244
1245 def _loadButtonClicked(self, loadButton):
1246 """Called when the load a flight button is clicked."""
1247 dialog = self._getLoadDialog()
1248 dialog.show_all()
1249 response = dialog.run()
1250 dialog.hide()
1251
1252 if response==Gtk.ResponseType.OK:
1253 fileName = dialog.get_filename()
1254 print("Loading", fileName)
1255 bookedFlight = web.BookedFlight()
1256 try:
1257 with open(fileName, "rt") as f:
1258 bookedFlight.readFromFile(f, self._wizard._loginResult.fleet)
1259 self.addFlight(bookedFlight)
1260 except Exception as e:
1261 print("Failed to load flight:", util.utf2unicode(str(e)))
1262 dialog = Gtk.MessageDialog(parent = self._wizard.gui.mainWindow,
1263 type = Gtk.MessageType.ERROR,
1264 message_format =
1265 xstr("flightsel_load_failed"))
1266 dialog.add_button(xstr("button_ok"), Gtk.ResponseType.OK)
1267 dialog.set_title(WINDOW_TITLE_BASE)
1268 secondary = xstr("flightsel_load_failed_sec")
1269 dialog.format_secondary_markup(secondary)
1270 dialog.run()
1271 dialog.hide()
1272
1273 def _forwardClicked(self, button):
1274 """Called when the forward button was clicked."""
1275 if self._completed:
1276 self._wizard.jumpPage(self._nextID, finalize = False)
1277 else:
1278 self._flightSelected()
1279
1280 def _rowActivated(self, flightList, index):
1281 """Called when a row is activated."""
1282 if not self._completed:
1283 self._flightSelected()
1284
1285 def _flightSelected(self):
1286 """Called when a flight has been selected."""
1287 flight = self._getSelectedFlight()
1288 self._wizard._bookedFlight = flight
1289 self._wizard.gui.enableFlightInfo(flight.aircraftType)
1290
1291 self._updateDepartureGate()
1292
1293 def _getSelectedFlight(self):
1294 """Get the currently selected flight."""
1295 indexes = self._flightList.selectedIndexes
1296 assert(len(indexes)==1)
1297 return self._flights[indexes[0]]
1298
1299 def _updateDepartureGate(self):
1300 """Update the departure gate for the booked flight."""
1301 flight = self._wizard._bookedFlight
1302 if self._wizard.gui.config.onlineGateSystem and \
1303 self._wizard.loggedIn and not self._wizard.entranceExam:
1304 if flight.departureICAO=="LHBP":
1305 self._wizard.getFleet(self._fleetRetrieved)
1306 else:
1307 self._wizard.updatePlane(self._planeUpdated,
1308 flight.tailNumber,
1309 const.PLANE_AWAY)
1310 else:
1311 self._nextID = "connect"
1312 self._wizard.jumpPage("connect")
1313
1314 def _fleetRetrieved(self, fleet):
1315 """Called when the fleet has been retrieved."""
1316 if fleet is None:
1317 self._nextID = "connect"
1318 self._wizard.jumpPage("connect")
1319 else:
1320 plane = fleet[self._wizard._bookedFlight.tailNumber]
1321 if plane is None:
1322 self._nextID = "connect"
1323 self._wizard.jumpPage("connect")
1324 elif plane.gateNumber is not None and \
1325 not fleet.isGateConflicting(plane):
1326 self._wizard._departureGate = plane.gateNumber
1327 self._nextID = "connect"
1328 self._wizard.jumpPage("connect")
1329 else:
1330 self._nextID = "gatesel"
1331 self._wizard.jumpPage("gatesel")
1332
1333 def _planeUpdated(self, success):
1334 """Callback for the plane updating."""
1335 self._nextID = "connect"
1336 self._wizard.jumpPage("connect")
1337
1338 def _getSaveDialog(self):
1339 """Get the dialog to load a flight file."""
1340 if self._saveDialog is not None:
1341 return self._saveDialog
1342
1343 gui = self._wizard.gui
1344 dialog = Gtk.FileChooserDialog(title = WINDOW_TITLE_BASE + " - " +
1345 xstr("flightsel_save_title"),
1346 action = Gtk.FileChooserAction.SAVE,
1347 buttons = (Gtk.STOCK_CANCEL,
1348 Gtk.ResponseType.CANCEL,
1349 Gtk.STOCK_OK, Gtk.ResponseType.OK),
1350 parent = gui.mainWindow)
1351 dialog.set_modal(True)
1352 dialog.set_do_overwrite_confirmation(True)
1353
1354 filter = Gtk.FileFilter()
1355 filter.set_name(xstr("flightsel_filter_flights"))
1356 filter.add_pattern("*.vaflight")
1357 dialog.add_filter(filter)
1358
1359 filter = Gtk.FileFilter()
1360 filter.set_name(xstr("file_filter_all"))
1361 filter.add_pattern("*.*")
1362 dialog.add_filter(filter)
1363
1364 self._saveDialog = dialog
1365
1366 return dialog
1367
1368 def _getLoadDialog(self):
1369 """Get the dialog to load a flight file."""
1370 if self._loadDialog is not None:
1371 return self._loadDialog
1372
1373 gui = self._wizard.gui
1374 dialog = Gtk.FileChooserDialog(title = WINDOW_TITLE_BASE + " - " +
1375 xstr("flightsel_load_title"),
1376 action = Gtk.FileChooserAction.OPEN,
1377 buttons = (Gtk.STOCK_CANCEL,
1378 Gtk.ResponseType.CANCEL,
1379 Gtk.STOCK_OK, Gtk.ResponseType.OK),
1380 parent = gui.mainWindow)
1381 dialog.set_modal(True)
1382
1383 filter = Gtk.FileFilter()
1384 filter.set_name(xstr("flightsel_filter_flights"))
1385 filter.add_pattern("*.vaflight")
1386 dialog.add_filter(filter)
1387
1388 filter = Gtk.FileFilter()
1389 filter.set_name(xstr("file_filter_all"))
1390 filter.add_pattern("*.*")
1391 dialog.add_filter(filter)
1392
1393 self._loadDialog = dialog
1394
1395 return dialog
1396
1397 def _createListPopupMenu(self):
1398 """Get the flight list popup menu."""
1399 menu = Gtk.Menu()
1400
1401 menuItem = Gtk.MenuItem()
1402 menuItem.set_label(xstr("flightsel_popup_select"))
1403 menuItem.set_use_underline(True)
1404 menuItem.connect("activate", self._popupSelect)
1405 menuItem.show()
1406
1407 menu.append(menuItem)
1408
1409 menuItem = Gtk.MenuItem()
1410 menuItem.set_label(xstr("flightsel_popup_save"))
1411 menuItem.set_use_underline(True)
1412 menuItem.connect("activate", self._popupSave)
1413 menuItem.show()
1414
1415 menu.append(menuItem)
1416
1417 menuItem = Gtk.MenuItem()
1418 menuItem.set_label(xstr("flightsel_popup_print"))
1419 menuItem.set_use_underline(True)
1420 menuItem.connect("activate", self._popupPrint)
1421 menuItem.show()
1422
1423 menu.append(menuItem)
1424
1425 menuItem = Gtk.MenuItem()
1426 menuItem.set_label(xstr("flightsel_popup_delete"))
1427 menuItem.set_use_underline(True)
1428 menuItem.connect("activate", self._popupDelete)
1429 menuItem.show()
1430
1431 menu.append(menuItem)
1432
1433 return menu
1434
1435 def _popupSelect(self, menuItem):
1436 """Called when the Select menu item is activated in the popup menu."""
1437 if not self._completed:
1438 self._flightSelected()
1439
1440 def _popupSave(self, menuItem):
1441 """Called when the Save menu item is activated in the popup menu."""
1442 if not self._completed:
1443 self._saveSelected()
1444
1445 def _popupPrint(self, menuItem):
1446 """Called when the Print briefing menu item is activated in the popup menu."""
1447 if not self._completed:
1448 self._printSelected()
1449
1450 def _popupDelete(self, menuItem):
1451 """Called when the Delete menu item is activated in the popup menu."""
1452 if not self._completed:
1453 self._deleteSelected()
1454
1455#-----------------------------------------------------------------------------
1456
1457class GateSelectionPage(Page):
1458 """Page to select a free gate at LHBP.
1459 This page should be displayed only if we have fleet information!."""
1460 def __init__(self, wizard):
1461 """Construct the gate selection page."""
1462 super(GateSelectionPage, self).__init__(wizard, "gatesel",
1463 xstr("gatesel_title"),
1464 xstr("gatesel_help"))
1465
1466 self._listStore = Gtk.ListStore(str)
1467 self._gateList = Gtk.TreeView(self._listStore)
1468 column = Gtk.TreeViewColumn(None, Gtk.CellRendererText(),
1469 text = 0)
1470 column.set_expand(True)
1471 self._gateList.append_column(column)
1472 self._gateList.set_headers_visible(False)
1473 self._gateList.connect("row-activated", self._rowActivated)
1474
1475 gateSelection = self._gateList.get_selection()
1476 gateSelection.connect("changed", self._selectionChanged)
1477
1478 scrolledWindow = Gtk.ScrolledWindow()
1479 scrolledWindow.add(self._gateList)
1480 scrolledWindow.set_size_request(50, -1)
1481 scrolledWindow.set_policy(Gtk.PolicyType.AUTOMATIC,
1482 Gtk.PolicyType.AUTOMATIC)
1483 scrolledWindow.set_shadow_type(Gtk.ShadowType.IN)
1484
1485 alignment = Gtk.Alignment(xalign = 0.5, yalign = 0.0, xscale = 0.0, yscale = 1.0)
1486 alignment.add(scrolledWindow)
1487
1488 self.setMainWidget(alignment)
1489
1490 self.addCancelFlightButton()
1491
1492 self.addPreviousButton(clicked = self._backClicked)
1493
1494 self._button = self.addNextButton(sensitive = False,
1495 clicked = self._forwardClicked)
1496
1497 def activate(self):
1498 """Fill the gate list."""
1499 self._listStore.clear()
1500 self._gateList.set_sensitive(True)
1501 occupiedGateNumbers = self._wizard._fleet.getOccupiedGateNumbers()
1502 for gate in lhbpGates.gates:
1503 if gate.isAvailable(lhbpGates, occupiedGateNumbers):
1504 self._listStore.append([gate.number])
1505
1506 def finalize(self):
1507 """Finalize the page."""
1508 self._gateList.set_sensitive(False)
1509
1510 def _selectionChanged(self, selection):
1511 """Called when the selection is changed."""
1512 self._button.set_sensitive(selection.count_selected_rows()==1)
1513
1514 def _backClicked(self, button):
1515 """Called when the Back button is pressed."""
1516 self.goBack()
1517
1518 def _forwardClicked(self, button):
1519 """Called when the forward button is clicked."""
1520 if not self._completed:
1521 self._gateSelected()
1522 else:
1523 self._wizard.jumpPage("connect")
1524
1525 def _rowActivated(self, flightList, path, column):
1526 """Called when a row is activated."""
1527 if not self._completed:
1528 self._gateSelected()
1529
1530 def _gateSelected(self):
1531 """Called when a gate has been selected."""
1532 selection = self._gateList.get_selection()
1533 (listStore, iter) = selection.get_selected()
1534 (gateNumber,) = listStore.get(iter, 0)
1535
1536 self._wizard._departureGate = gateNumber
1537
1538 self._wizard.updatePlane(self._planeUpdated,
1539 self._wizard._bookedFlight.tailNumber,
1540 const.PLANE_HOME, gateNumber)
1541
1542 def _planeUpdated(self, success):
1543 """Callback for the plane updating call."""
1544 if success is None or success:
1545 self._wizard.jumpPage("connect")
1546 else:
1547 dialog = Gtk.MessageDialog(parent = self._wizard.gui.mainWindow,
1548 type = Gtk.MessageType.ERROR,
1549 message_format = xstr("gatesel_conflict"))
1550 dialog.add_button(xstr("button_ok"), Gtk.ResponseType.OK)
1551 dialog.set_title(WINDOW_TITLE_BASE)
1552 dialog.format_secondary_markup(xstr("gatesel_conflict_sec"))
1553 dialog.run()
1554 dialog.hide()
1555
1556 self._wizard.getFleet(self._fleetRetrieved)
1557
1558 def _fleetRetrieved(self, fleet):
1559 """Called when the fleet has been retrieved."""
1560 if fleet is None:
1561 self._wizard.jumpPage("connect")
1562 else:
1563 self.activate()
1564
1565#-----------------------------------------------------------------------------
1566
1567class RegisterPage(Page):
1568 """A page to enter the registration data."""
1569
1570 # The minimal year of birth
1571 _minYearOfBirth = 1900
1572
1573 # The maximal year of birth
1574 _maxYearOfBirth = datetime.date.today().year
1575
1576 # The regular expression to check the e-mail address with
1577 _emailAddressRE = re.compile("[^@]+@[^@]+\.[^@]+")
1578
1579 def __init__(self, wizard):
1580 """Construct the registration page."""
1581 super(RegisterPage, self).__init__(wizard, "register",
1582 xstr("register_title"),
1583 xstr("register_help"))
1584
1585 alignment = Gtk.Alignment(xalign = 0.5, yalign = 0.5,
1586 xscale = 0.0, yscale = 0.0)
1587
1588 table = Gtk.Table(12, 4)
1589 table.set_row_spacings(4)
1590 table.set_col_spacings(24)
1591 alignment.add(table)
1592 self.setMainWidget(alignment)
1593
1594 row = 0
1595
1596 labelAlignment = Gtk.Alignment(xalign = 1.0, yalign = 0.5,
1597 xscale = 0.0, yscale = 0.0)
1598 label = Gtk.Label(xstr("register_name1"))
1599 label.set_use_underline(True)
1600 labelAlignment.add(label)
1601 table.attach(labelAlignment, 0, 1, row, row+1)
1602
1603 self._name1 = Gtk.Entry()
1604 self._name1.connect("changed", self._updateButtons)
1605 self._name1.set_tooltip_text(xstr("register_name1_tooltip"))
1606 self._name1.set_width_chars(15)
1607 table.attach(self._name1, 1, 2, row, row+1)
1608 label.set_mnemonic_widget(self._name1)
1609
1610 labelAlignment = Gtk.Alignment(xalign = 1.0, yalign = 0.5,
1611 xscale = 0.0, yscale = 0.0)
1612 label = Gtk.Label(xstr("register_name2"))
1613 label.set_use_underline(True)
1614 labelAlignment.add(label)
1615 table.attach(labelAlignment, 2, 3, row, row+1)
1616
1617 self._name2 = Gtk.Entry()
1618 self._name2.connect("changed", self._updateButtons)
1619 self._name2.set_tooltip_text(xstr("register_name2_tooltip"))
1620 self._name2.set_width_chars(15)
1621 table.attach(self._name2, 3, 4, row, row+1)
1622 label.set_mnemonic_widget(self._name2)
1623
1624 row += 1
1625
1626 labelAlignment = Gtk.Alignment(xalign = 1.0, yalign = 0.5,
1627 xscale = 0.0, yscale = 0.0)
1628 label = Gtk.Label(xstr("register_year_of_birth"))
1629 label.set_use_underline(True)
1630 labelAlignment.add(label)
1631 table.attach(labelAlignment, 0, 1, row, row+1)
1632
1633 alignment = Gtk.Alignment(xalign = 0.0, yalign = 0.0,
1634 xscale = 0.0, yscale = 0.0)
1635
1636 self._yearOfBirth = Gtk.SpinButton()
1637 self._yearOfBirth.set_increments(step = 1, page = 10)
1638 self._yearOfBirth.set_range(min = RegisterPage._minYearOfBirth,
1639 max = RegisterPage._maxYearOfBirth)
1640 self._yearOfBirth.set_numeric(True)
1641 self._yearOfBirth.set_tooltip_text(xstr("register_year_of_birth_tooltip"))
1642 self._yearOfBirth.set_width_chars(5)
1643 self._yearOfBirth.connect("changed", self._updateButtons)
1644 self._yearOfBirth.connect("value-changed", self._updateButtons)
1645 alignment.add(self._yearOfBirth)
1646 table.attach(alignment, 1, 2, row, row+1)
1647 label.set_mnemonic_widget(self._yearOfBirth)
1648
1649 row += 1
1650
1651 labelAlignment = Gtk.Alignment(xalign = 1.0, yalign = 0.5,
1652 xscale = 0.0, yscale = 0.0)
1653 label = Gtk.Label(xstr("register_email"))
1654 label.set_use_underline(True)
1655 labelAlignment.add(label)
1656 table.attach(labelAlignment, 0, 1, row, row+1)
1657
1658 self._emailAddress = Gtk.Entry()
1659 self._emailAddress.connect("changed", self._updateButtons)
1660 self._emailAddress.set_tooltip_text(xstr("register_email_tooltip"))
1661 table.attach(self._emailAddress, 1, 2, row, row+1)
1662 label.set_mnemonic_widget(self._emailAddress)
1663
1664 self._emailAddressPublic = Gtk.CheckButton(xstr("register_email_public"))
1665 self._emailAddressPublic.set_use_underline(True)
1666 self._emailAddressPublic.set_tooltip_text(xstr("register_email_public_tooltip"))
1667 table.attach(self._emailAddressPublic, 2, 4, row, row+1)
1668
1669 row += 1
1670
1671 labelAlignment = Gtk.Alignment(xalign = 1.0, yalign = 0.5,
1672 xscale = 0.0, yscale = 0.0)
1673 label = Gtk.Label(xstr("register_vatsim_id"))
1674 label.set_use_underline(True)
1675 labelAlignment.add(label)
1676 table.attach(labelAlignment, 0, 1, row, row+1)
1677
1678 alignment = Gtk.Alignment(xalign = 0.0, yalign = 0.0,
1679 xscale = 0.0, yscale = 0.0)
1680 self._vatsimID = IntegerEntry()
1681 self._vatsimID.connect("changed", self._updateButtons)
1682 self._vatsimID.set_tooltip_text(xstr("register_vatsim_id_tooltip"))
1683 self._vatsimID.set_width_chars(7)
1684 alignment.add(self._vatsimID)
1685 table.attach(alignment, 1, 2, row, row+1)
1686 label.set_mnemonic_widget(self._vatsimID)
1687
1688 labelAlignment = Gtk.Alignment(xalign = 0.0, yalign = 0.5,
1689 xscale = 0.0, yscale = 0.0)
1690 label = Gtk.Label(xstr("register_ivao_id"))
1691 label.set_use_underline(True)
1692 labelAlignment.add(label)
1693 table.attach(labelAlignment, 2, 3, row, row+1)
1694
1695 alignment = Gtk.Alignment(xalign = 0.0, yalign = 0.0,
1696 xscale = 0.0, yscale = 0.0)
1697 self._ivaoID = IntegerEntry()
1698 self._ivaoID.connect("changed", self._updateButtons)
1699 self._ivaoID.set_tooltip_text(xstr("register_ivao_id_tooltip"))
1700 self._ivaoID.set_width_chars(7)
1701 alignment.add(self._ivaoID)
1702 table.attach(alignment, 3, 4, row, row+1)
1703 label.set_mnemonic_widget(self._ivaoID)
1704
1705 row += 1
1706
1707 labelAlignment = Gtk.Alignment(xalign = 1.0, yalign = 0.5,
1708 xscale = 0.0, yscale = 0.0)
1709 label = Gtk.Label(xstr("register_phone_num"))
1710 label.set_use_underline(True)
1711 label.set_use_markup(True)
1712 labelAlignment.add(label)
1713 table.attach(labelAlignment, 0, 1, row, row+1)
1714
1715 self._phoneNumber = Gtk.Entry()
1716 self._phoneNumber.set_tooltip_text(xstr("register_phone_num_tooltip"))
1717 table.attach(self._phoneNumber, 1, 2, row, row+1)
1718 label.set_mnemonic_widget(self._phoneNumber)
1719
1720 row += 1
1721
1722 labelAlignment = Gtk.Alignment(xalign = 1.0, yalign = 0.5,
1723 xscale = 0.0, yscale = 0.0)
1724 label = Gtk.Label(xstr("register_nationality"))
1725 label.set_use_underline(True)
1726 label.set_use_markup(True)
1727 labelAlignment.add(label)
1728 table.attach(labelAlignment, 0, 1, row, row+1)
1729
1730
1731 self._nationality = Gtk.Entry()
1732 self._nationality.set_tooltip_text(xstr("register_nationality_tooltip"))
1733 table.attach(self._nationality, 1, 2, row, row+1)
1734 label.set_mnemonic_widget(self._nationality)
1735
1736 placeholder = Gtk.Label()
1737 placeholder.set_text(xstr("register_password_mismatch"))
1738 placeholder.set_use_markup(True)
1739 placeholder.set_child_visible(False)
1740 placeholder.hide()
1741 table.attach(placeholder, 2, 4, row, row+1)
1742
1743 row += 1
1744
1745 labelAlignment = Gtk.Alignment(xalign = 1.0, yalign = 0.5,
1746 xscale = 0.0, yscale = 0.0)
1747 label = Gtk.Label(xstr("register_password"))
1748 label.set_use_underline(True)
1749 labelAlignment.add(label)
1750 table.attach(labelAlignment, 0, 1, row, row+1)
1751
1752 self._password = Gtk.Entry()
1753 self._password.set_visibility(False)
1754 self._password.connect("changed", self._updateButtons)
1755 self._password.set_tooltip_text(xstr("register_password_tooltip"))
1756 table.attach(self._password, 1, 2, row, row+1)
1757 label.set_mnemonic_widget(self._password)
1758
1759 alignment = Gtk.Alignment(xalign = 0.0, yalign = 0.5,
1760 xscale = 0.0, yscale = 0.0)
1761 self._passwordStatus = Gtk.Label()
1762 alignment.add(self._passwordStatus)
1763 table.attach(alignment, 2, 4, row, row+1)
1764
1765 row += 1
1766
1767 labelAlignment = Gtk.Alignment(xalign = 1.0, yalign = 0.5,
1768 xscale = 0.0, yscale = 0.0)
1769 label = Gtk.Label(xstr("register_password2"))
1770 label.set_use_underline(True)
1771 labelAlignment.add(label)
1772 table.attach(labelAlignment, 0, 1, row, row+1)
1773
1774 self._password2 = Gtk.Entry()
1775 self._password2.set_visibility(False)
1776 self._password2.connect("changed", self._updateButtons)
1777 self._password2.set_tooltip_text(xstr("register_password2_tooltip"))
1778 table.attach(self._password2, 1, 2, row, row+1)
1779 label.set_mnemonic_widget(self._password2)
1780
1781 alignment = Gtk.Alignment(xalign = 0.0, yalign = 0.5,
1782 xscale = 0.0, yscale = 0.0)
1783 self._password2Status = Gtk.Label()
1784 alignment.add(self._password2Status)
1785 table.attach(alignment, 2, 4, row, row+1)
1786
1787 row += 1
1788
1789 self._rememberButton = Gtk.CheckButton(xstr("remember_password"))
1790 self._rememberButton.set_use_underline(True)
1791 self._rememberButton.set_tooltip_text(xstr("login_remember_tooltip"))
1792 table.attach(self._rememberButton, 1, 3, row, row+1)
1793
1794 cancelButton = \
1795 self.addButton(xstr("button_cancel"))
1796 cancelButton.connect("clicked", self._cancelClicked)
1797
1798 self._registerButton = \
1799 self.addButton(xstr("button_register"), default = True,
1800 tooltip = xstr("button_register_tooltip"))
1801 self._registerButton.connect("clicked", self._registerClicked)
1802
1803 self._updateButtons()
1804
1805 @property
1806 def name1(self):
1807 """Get the first name component entered."""
1808 return self._name1.get_text()
1809
1810 @property
1811 def name2(self):
1812 """Get the second name component entered."""
1813 return self._name2.get_text()
1814
1815 @property
1816 def yearOfBirth(self):
1817 """Get the year of birth."""
1818 yearOfBirthText = self._yearOfBirth.get_text()
1819 return int(yearOfBirthText) if yearOfBirthText else 0
1820
1821 @property
1822 def emailAddress(self):
1823 """Get the e-mail address."""
1824 return self._emailAddress.get_text()
1825
1826 @property
1827 def emailAddressPublic(self):
1828 """Get the whether the e-mail address is public."""
1829 return self._emailAddressPublic.get_active()
1830
1831 @property
1832 def vatsimID(self):
1833 """Get the VATSIM ID."""
1834 return self._vatsimID.get_int()
1835
1836 @property
1837 def ivaoID(self):
1838 """Get the IVAO ID."""
1839 return self._ivaoID.get_int()
1840
1841 @property
1842 def phoneNumber(self):
1843 """Get the phone number."""
1844 return self._phoneNumber.get_text()
1845
1846 @property
1847 def nationality(self):
1848 """Get the nationality."""
1849 return self._nationality.get_text()
1850
1851 @property
1852 def password(self):
1853 """Get the password."""
1854 return self._password.get_text()
1855
1856 @property
1857 def rememberPassword(self):
1858 """Get whether the password should be remembered."""
1859 return self._rememberButton.get_active()
1860
1861 def activate(self):
1862 """Setup the route from the booked flight."""
1863 self._yearOfBirth.set_value(0)
1864 self._yearOfBirth.set_text("")
1865 self._updateButtons()
1866
1867 def _updateButtons(self, widget = None):
1868 """Update the sensitive state of the buttons"""
1869 yearOfBirth = self.yearOfBirth
1870
1871 emailAddress = self.emailAddress
1872 emailAddressMatch = RegisterPage._emailAddressRE.match(emailAddress)
1873
1874 vatsimID = self.vatsimID
1875 ivaoID = self.ivaoID
1876
1877 password = self.password
1878 password2 = self._password2.get_text()
1879 if not password:
1880 self._passwordStatus.set_text("")
1881 elif len(password)<5:
1882 self._passwordStatus.set_text(xstr("register_password_too_short"))
1883 else:
1884 self._passwordStatus.set_text(xstr("register_password_ok"))
1885 self._passwordStatus.set_use_markup(True)
1886
1887 if len(password)<5 or not password2:
1888 self._password2Status.set_text("")
1889 elif password!=password2:
1890 self._password2Status.set_text(xstr("register_password_mismatch"))
1891 else:
1892 self._password2Status.set_text(xstr("register_password_ok"))
1893 self._password2Status.set_use_markup(True)
1894
1895 sensitive = \
1896 len(self.name1)>0 and len(self.name2)>0 and \
1897 yearOfBirth>=RegisterPage._minYearOfBirth and \
1898 yearOfBirth<=RegisterPage._maxYearOfBirth and \
1899 emailAddressMatch is not None and \
1900 (vatsimID>=800000 or ivaoID>=100000) and \
1901 len(password)>=5 and password==password2
1902
1903 self._registerButton.set_sensitive(sensitive)
1904
1905 def _cancelClicked(self, button):
1906 """Called when the Cancel button is clicked."""
1907 self.goBack()
1908
1909 def _registerClicked(self, button):
1910 """Called when the Register button is clicked."""
1911 nameOrder = xstr("register_nameorder")
1912
1913 if nameOrder=="eastern":
1914 surName = self.name1
1915 firstName = self.name2
1916 else:
1917 surName = self.name2
1918 firstName = self.name1
1919
1920 nationality = self.nationality.lower()
1921
1922 if getLanguage().lower()=="hu" or nationality.find("hung")!=-1 or \
1923 nationality.find("magyar")!=-1:
1924 requestedNameOrder = "eastern"
1925 else:
1926 requestedNameOrder = "western"
1927
1928 registrationData = web.Registration(surName, firstName,
1929 requestedNameOrder,
1930 self.yearOfBirth,
1931 self.emailAddress,
1932 self.emailAddressPublic,
1933 self.vatsimID, self.ivaoID,
1934 self.phoneNumber, self.nationality,
1935 self.password)
1936 print("Registering with data:")
1937 print(" name:", self.name1, self.name2, registrationData.firstName, registrationData.surName, requestedNameOrder)
1938 print(" yearOfBirth:", self.yearOfBirth, registrationData.yearOfBirth)
1939 print(" emailAddress:", self.emailAddress, registrationData.emailAddress)
1940 print(" emailAddressPublic:", self.emailAddressPublic, registrationData.emailAddressPublic)
1941 print(" vatsimID:", self.vatsimID, registrationData.vatsimID)
1942 print(" ivaoID:", self.ivaoID, registrationData.ivaoID)
1943 print(" phoneNumber:", self.phoneNumber, registrationData.phoneNumber)
1944 print(" nationality:", self.nationality, registrationData.nationality)
1945
1946 gui = self._wizard.gui
1947 gui.beginBusy(xstr("register_busy"))
1948 gui.webHandler.register(self._registerResultCallback, registrationData)
1949
1950 def _registerResultCallback(self, returned, result):
1951 """Called when the registration result is available."""
1952 GObject.idle_add(self._handleRegisterResult, returned, result)
1953
1954 def _handleRegisterResult(self, returned, result):
1955 """Handle the registration result."""
1956 gui = self._wizard.gui
1957
1958 gui.endBusy()
1959
1960 print("Registration result:")
1961 print(" returned:", returned)
1962 if returned:
1963 print(" registered:", result.registered)
1964 if result.registered:
1965 print(" pilotID", result.pilotID)
1966 print(" loggedIn", result.loggedIn)
1967 print(" emailAlreadyRegistered:", result.emailAlreadyRegistered)
1968 print(" invalidData:", result.invalidData)
1969
1970 registrationOK = returned and result.registered
1971
1972 message = xstr("register_ok") if registrationOK \
1973 else xstr("register_failed")
1974 secondaryMessage = None
1975 if registrationOK:
1976 if result.loggedIn:
1977 secondaryMessage = xstr("register_info") % (result.pilotID,)
1978 else:
1979 secondaryMessage = xstr("register_nologin") % (result.pilotID,)
1980 messageType = Gtk.MessageType.INFO
1981
1982 config = gui.config
1983 config.pilotID = result.pilotID
1984 config.rememberPassword = self.rememberPassword
1985 if config.rememberPassword:
1986 config.password = self.password
1987 else:
1988 config.password = ""
1989
1990 config.save()
1991 elif returned and result.emailAlreadyRegistered:
1992 secondaryMessage = xstr("register_email_already")
1993 messageType = Gtk.MessageType.ERROR
1994 elif returned and result.invalidData:
1995 secondaryMessage = xstr("register_invalid_data")
1996 messageType = Gtk.MessageType.ERROR
1997 else:
1998 secondaryMessage = xstr("register_error")
1999 messageType = Gtk.MessageType.ERROR
2000
2001 dialog = Gtk.MessageDialog(parent = gui.mainWindow,
2002 type = messageType,
2003 message_format = message)
2004 dialog.set_title(WINDOW_TITLE_BASE + " - " +
2005 xstr("register_result_title"))
2006 dialog.format_secondary_markup(secondaryMessage)
2007
2008 dialog.add_button(xstr("button_ok"), 0)
2009
2010 dialog.run()
2011 dialog.hide()
2012
2013 if registrationOK:
2014 if result.loggedIn:
2015 self._wizard._loginResult = result
2016 self._wizard.nextPage()
2017 else:
2018 self._wizard.jumpPage("login")
2019
2020#-----------------------------------------------------------------------------
2021
2022class StudentPage(Page):
2023 """A page displayed to students after logging in."""
2024 _entryExamStatusQueryInterval = 60*1000
2025
2026 def __init__(self, wizard):
2027 """Construct the student page."""
2028 super(StudentPage, self).__init__(wizard, "student",
2029 xstr("student_title"),
2030 xstr("student_help"))
2031
2032
2033 self._getEntryExamStatusCancelled = False
2034
2035 alignment = Gtk.Alignment(xalign = 0.5, yalign = 0.5,
2036 xscale = 0.5, yscale = 0.0)
2037
2038 table = Gtk.Table(6, 4)
2039 table.set_row_spacings(4)
2040 table.set_col_spacings(0)
2041 table.set_homogeneous(False)
2042 alignment.add(table)
2043 self.setMainWidget(alignment)
2044
2045 row = 0
2046
2047 labelAlignment = Gtk.Alignment(xalign=0.0, yalign = 0.5,
2048 xscale=0.0, yscale = 0.0)
2049 label = Gtk.Label(xstr("student_entry_exam_status"))
2050 label.set_alignment(0.0, 0.5)
2051 labelAlignment.add(label)
2052 labelAlignment.resize_children()
2053 table.attach(labelAlignment, 0, 1, row, row + 1,
2054 xoptions = Gtk.AttachOptions.FILL)
2055
2056 alignment = Gtk.Alignment(xalign=0.0, yalign = 0.5,
2057 xscale=1.0, yscale = 0.0)
2058 self._entryExamStatus = Gtk.Label()
2059 self._entryExamStatus.set_use_markup(True)
2060 self._entryExamStatus.set_alignment(0.0, 0.5)
2061 alignment.add(self._entryExamStatus)
2062 alignment.resize_children()
2063 table.attach(alignment, 1, 4, row, row + 1)
2064
2065 row += 1
2066
2067 buttonAlignment = Gtk.Alignment(xalign=0.0, xscale=1.0)
2068 button = self._entryExamButton = Gtk.Button(xstr("student_entry_exam"))
2069 button.set_use_underline(True)
2070 button.connect("clicked", self._entryExamClicked)
2071 button.set_tooltip_text(xstr("student_entry_exam_tooltip"))
2072
2073 buttonAlignment.add(button)
2074 table.attach(buttonAlignment, 0, 4, row, row + 1,
2075 xoptions = Gtk.AttachOptions.FILL,
2076 ypadding = 4)
2077
2078 row += 3
2079
2080 labelAlignment = Gtk.Alignment(xalign=0.0, yalign = 0.5,
2081 xscale=0.0, yscale = 0.0)
2082 label = Gtk.Label(xstr("student_check_flight_status"))
2083 labelAlignment.add(label)
2084 table.attach(labelAlignment, 0, 1, row, row + 1,
2085 xoptions = Gtk.AttachOptions.FILL)
2086
2087 alignment = Gtk.Alignment(xalign=0.0, yalign = 0.5,
2088 xscale=1.0, yscale = 0.0)
2089 self._checkFlightStatus = Gtk.Label()
2090 self._checkFlightStatus.set_use_markup(True)
2091 self._checkFlightStatus.set_alignment(0.0, 0.5)
2092 alignment.add(self._checkFlightStatus)
2093 table.attach(alignment, 1, 4, row, row + 1)
2094
2095 row += 1
2096
2097 alignment = Gtk.Alignment(xalign=0.0, xscale=1.0)
2098
2099 hbox = Gtk.HBox()
2100 hbox.set_homogeneous(False)
2101 hbox.set_spacing(0)
2102
2103 aircraftTypesModel = Gtk.ListStore(str, int)
2104 for aircraftType in web.BookedFlight.checkFlightTypes:
2105 aircraftTypesModel.append([aircraftNames[aircraftType],
2106 aircraftType])
2107
2108 aircraftTypeAlignment = Gtk.Alignment(xalign = 0.0, xscale = 1.0)
2109
2110 self._aircraftType = Gtk.ComboBox(model = aircraftTypesModel)
2111 renderer = Gtk.CellRendererText()
2112 self._aircraftType.pack_start(renderer, True)
2113 self._aircraftType.add_attribute(renderer, "text", 0)
2114 self._aircraftType.set_tooltip_text(xstr("student_check_flight_type_tooltip"))
2115 self._aircraftType.set_active(0)
2116
2117 aircraftTypeAlignment.add(self._aircraftType)
2118
2119 hbox.pack_start(aircraftTypeAlignment, False, False, 0)
2120
2121 buttonAlignment = Gtk.Alignment(xalign=0.0, xscale=1.0)
2122 button = self._checkFlightButton = Gtk.Button(xstr("student_check_flight"))
2123 button.set_use_underline(True)
2124 button.connect("clicked", self._checkFlightClicked)
2125 button.set_tooltip_text(xstr("student_check_flight_tooltip"))
2126
2127 hbox.pack_start(button, True, True, 0)
2128
2129 alignment.add(hbox)
2130 table.attach(alignment, 0, 4, row, row + 1,
2131 xoptions = Gtk.AttachOptions.FILL)
2132
2133 @property
2134 def aircraftType(self):
2135 """Get the type of the aircraft used to perform the check flight."""
2136 index = self._aircraftType.get_active()
2137 return self._aircraftType.get_model()[index][1]
2138
2139 def activate(self):
2140 """Activate the student page."""
2141 print("StudentPage.activate")
2142 self._getEntryExamStatusCancelled = False
2143
2144 loginResult = self._wizard.loginResult
2145 self._entryExamLink = loginResult.entryExamLink
2146
2147 self._updateEntryExamStatus(loginResult.entryExamPassed)
2148 self._getEntryExamStatus()
2149
2150 # FIXME: call with real value
2151 self._updateCheckFlightStatus(self._wizard.loginResult.checkFlightStatus)
2152
2153 def finalize(self):
2154 """Finalize the page."""
2155 print("StudentPage.finalize")
2156 self._getEntryExamStatusCancelled = True
2157
2158 def _entryExamClicked(self, button):
2159 """Called when the entry exam button is clicked."""
2160 webbrowser.open(self._entryExamLink)
2161
2162 def _getEntryExamStatus(self):
2163 """Initiate the query of the entry exam status after the interval."""
2164 if not self._getEntryExamStatusCancelled:
2165 GObject.timeout_add(StudentPage._entryExamStatusQueryInterval,
2166 lambda: self._wizard.gui.webHandler. \
2167 getEntryExamStatus(self._entryExamStatusCallback))
2168
2169 def _entryExamStatusCallback(self, returned, result):
2170 """Called when the entry exam status is available."""
2171 GObject.idle_add(self._handleEntryExamStatus, returned, result)
2172
2173 def _handleEntryExamStatus(self, returned, result):
2174 """Called when the entry exam status is availabe."""
2175 print("_handleEntryExamStatus", returned, result)
2176 if returned and not self._getEntryExamStatusCancelled:
2177 self._entryExamLink = result.entryExamLink
2178 self._updateEntryExamStatus(result.entryExamPassed)
2179 if result.madeFO:
2180 self._madeFO()
2181 else:
2182 self._getEntryExamStatus()
2183
2184 def _updateEntryExamStatus(self, passed):
2185 """Update the entry exam status display and button."""
2186 self._entryExamStatus.set_text(xstr("student_entry_exam_passed")
2187 if passed else
2188 xstr("student_entry_exam_not_passed"))
2189 self._entryExamStatus.set_use_markup(True)
2190 self._entryExamButton.set_sensitive(not passed)
2191 self._wizard._loginResult.entryExamPassed = passed
2192
2193 def _checkFlightClicked(self, button):
2194 """Called when the check flight button is clicked."""
2195 aircraftType = self.aircraftType
2196 self._wizard._bookedFlight = \
2197 web.BookedFlight.forCheckFlight(aircraftType)
2198 self._wizard.gui.enableFlightInfo(aircraftType)
2199 self._wizard.jumpPage("connect")
2200
2201 def _updateCheckFlightStatus(self, passed):
2202 """Update the status of the check flight."""
2203 self._aircraftType.set_sensitive(not passed)
2204 self._checkFlightStatus.set_text(xstr("student_check_flight_passed")
2205 if passed else
2206 xstr("student_check_flight_not_passed"))
2207 self._checkFlightStatus.set_use_markup(True)
2208 self._checkFlightButton.set_sensitive(not passed)
2209
2210 def _madeFO(self):
2211 """Handle the event when the pilot has become a first officer."""
2212 wizard = self._wizard
2213 loginResult = wizard.loginResult
2214 loginResult.rank = "FO"
2215
2216 gui = wizard.gui
2217
2218 dialog = Gtk.MessageDialog(parent = gui.mainWindow,
2219 type = Gtk.MessageType.INFO,
2220 message_format = xstr("student_fo"))
2221
2222 dialog.add_button(xstr("button_ok"), Gtk.ResponseType.OK)
2223 dialog.set_title(WINDOW_TITLE_BASE)
2224 secondary = xstr("student_fo_secondary")
2225 dialog.format_secondary_markup(secondary)
2226 dialog.run()
2227 dialog.hide()
2228
2229 gui.reset()
2230
2231#-----------------------------------------------------------------------------
2232
2233class ConnectPage(Page):
2234 """Page which displays the departure airport and gate (if at LHBP)."""
2235 def __init__(self, wizard):
2236 """Construct the connect page."""
2237 help = "Load the aircraft below into the simulator and park it\n" \
2238 "at the given airport, at the gate below, if present.\n\n" \
2239 "Then press the Connect button to connect to the simulator."
2240 completedHelp = "The basic data of your flight can be read below."
2241 super(ConnectPage, self).__init__(wizard, "connect",
2242 xstr("connect_title"),
2243 xstr("connect_help"),
2244 completedHelp = xstr("connect_chelp"))
2245
2246 self._selectSimulator = os.name=="nt" or "FORCE_SELECT_SIM" in os.environ
2247
2248 alignment = Gtk.Alignment(xalign = 0.5, yalign = 0.5,
2249 xscale = 0.0, yscale = 0.0)
2250
2251 table = Gtk.Table(7 if self._selectSimulator else 5, 2)
2252 table.set_row_spacings(4)
2253 table.set_col_spacings(16)
2254 table.set_homogeneous(True)
2255 alignment.add(table)
2256 self.setMainWidget(alignment)
2257
2258 labelAlignment = Gtk.Alignment(xalign=1.0, xscale=0.0)
2259 label = Gtk.Label(xstr("connect_flightno"))
2260 labelAlignment.add(label)
2261 table.attach(labelAlignment, 0, 1, 0, 1)
2262
2263 labelAlignment = Gtk.Alignment(xalign=0.0, xscale=0.0)
2264 self._flightNumber = Gtk.Label()
2265 self._flightNumber.set_width_chars(9)
2266 self._flightNumber.set_alignment(0.0, 0.5)
2267 labelAlignment.add(self._flightNumber)
2268 table.attach(labelAlignment, 1, 2, 0, 1)
2269
2270 labelAlignment = Gtk.Alignment(xalign=1.0, xscale=0.0)
2271 label = Gtk.Label(xstr("connect_acft"))
2272 labelAlignment.add(label)
2273 table.attach(labelAlignment, 0, 1, 1, 2)
2274
2275 labelAlignment = Gtk.Alignment(xalign=0.0, xscale=0.0)
2276 self._aircraft = Gtk.Label()
2277 self._aircraft.set_width_chars(25)
2278 self._aircraft.set_alignment(0.0, 0.5)
2279 labelAlignment.add(self._aircraft)
2280 table.attach(labelAlignment, 1, 2, 1, 2)
2281
2282 labelAlignment = Gtk.Alignment(xalign=1.0, xscale=0.0)
2283 label = Gtk.Label(xstr("connect_tailno"))
2284 labelAlignment.add(label)
2285 table.attach(labelAlignment, 0, 1, 2, 3)
2286
2287 labelAlignment = Gtk.Alignment(xalign=0.0, xscale=0.0)
2288 self._tailNumber = Gtk.Label()
2289 self._tailNumber.set_width_chars(10)
2290 self._tailNumber.set_alignment(0.0, 0.5)
2291 labelAlignment.add(self._tailNumber)
2292 table.attach(labelAlignment, 1, 2, 2, 3)
2293
2294 labelAlignment = Gtk.Alignment(xalign=1.0, xscale=0.0)
2295 label = Gtk.Label(xstr("connect_airport"))
2296 labelAlignment.add(label)
2297 table.attach(labelAlignment, 0, 1, 3, 4)
2298
2299 labelAlignment = Gtk.Alignment(xalign=0.0, xscale=0.0)
2300 self._departureICAO = Gtk.Label()
2301 self._departureICAO.set_width_chars(6)
2302 self._departureICAO.set_alignment(0.0, 0.5)
2303 labelAlignment.add(self._departureICAO)
2304 table.attach(labelAlignment, 1, 2, 3, 4)
2305
2306 labelAlignment = Gtk.Alignment(xalign=1.0, xscale=0.0)
2307 label = Gtk.Label(xstr("connect_gate"))
2308 labelAlignment.add(label)
2309 table.attach(labelAlignment, 0, 1, 4, 5)
2310
2311 labelAlignment = Gtk.Alignment(xalign=0.0, xscale=0.0)
2312 self._departureGate = Gtk.Label()
2313 self._departureGate.set_width_chars(5)
2314 self._departureGate.set_alignment(0.0, 0.5)
2315 labelAlignment.add(self._departureGate)
2316 table.attach(labelAlignment, 1, 2, 4, 5)
2317
2318 if self._selectSimulator:
2319 labelAlignment = Gtk.Alignment(xalign=1.0, xscale=0.0, yalign=0.5)
2320 label = Gtk.Label(xstr("connect_sim"))
2321 labelAlignment.add(label)
2322 table.attach(labelAlignment, 0, 1, 5, 7)
2323
2324 selectAlignment = Gtk.Alignment(xalign=0.0, xscale=0.0, yalign=0.5)
2325
2326 selectBox = Gtk.HBox()
2327 self._selectMSFS = \
2328 Gtk.RadioButton.new_with_mnemonic_from_widget(None,
2329 xstr("connect_sim_msfs"))
2330
2331 selectBox.pack_start(self._selectMSFS, False, False, 0);
2332
2333 self._selectXPlane = \
2334 Gtk.RadioButton.new_with_mnemonic_from_widget(self._selectMSFS,
2335 xstr("connect_sim_xplane"))
2336
2337 selectBox.pack_start(self._selectXPlane, False, False, 8);
2338
2339 selectAlignment.add(selectBox)
2340 table.attach(selectAlignment, 1, 2, 5, 7)
2341
2342
2343 self.addCancelFlightButton()
2344
2345 self._previousButton = \
2346 self.addPreviousButton(clicked = self._backClicked)
2347
2348 self._button = self.addButton(xstr("button_connect"), default = True,
2349 tooltip = xstr("button_connect_tooltip"))
2350 self._clickedID = self._button.connect("clicked", self._connectClicked)
2351
2352 def activate(self):
2353 """Setup the departure information."""
2354 self._button.set_label(xstr("button_connect"))
2355 self._button.set_use_underline(True)
2356 self._button.set_tooltip_text(xstr("button_connect_tooltip"))
2357 self._button.disconnect(self._clickedID)
2358 self._clickedID = self._button.connect("clicked", self._connectClicked)
2359
2360 bookedFlight = self._wizard._bookedFlight
2361
2362 self._flightNumber.set_markup("<b>" + bookedFlight.callsign + "</b>")
2363
2364 aircraftType = aircraftNames[bookedFlight.aircraftType]
2365 self._aircraft.set_markup("<b>" + aircraftType + "</b>")
2366
2367 self._tailNumber.set_markup("<b>" + bookedFlight.tailNumber + "</b>")
2368
2369 icao = bookedFlight.departureICAO
2370 self._departureICAO.set_markup("<b>" + icao + "</b>")
2371 gate = self._wizard._departureGate
2372 if gate!="-":
2373 gate = "<b>" + gate + "</b>"
2374 self._departureGate.set_markup(gate)
2375
2376 if self._selectSimulator:
2377 config = self._wizard.gui.config
2378 self._selectMSFS.set_active(config.defaultMSFS)
2379 self._selectXPlane.set_active(not config.defaultMSFS)
2380
2381 self._previousButton.set_sensitive(not self._wizard.entranceExam)
2382
2383 def finalize(self):
2384 """Finalize the page."""
2385 self._button.set_label(xstr("button_next"))
2386 self._button.set_use_underline(True)
2387 self._button.set_tooltip_text(xstr("button_next_tooltip"))
2388 self._button.disconnect(self._clickedID)
2389 self._clickedID = self._button.connect("clicked", self._forwardClicked)
2390
2391 def _backClicked(self, button):
2392 """Called when the Back button is pressed."""
2393 self.goBack()
2394
2395 def _connectClicked(self, button):
2396 """Called when the Connect button is pressed."""
2397 if self._selectSimulator:
2398 simulatorType = const.SIM_MSFS9 if self._selectMSFS.get_active() \
2399 else const.SIM_XPLANE10
2400 else:
2401 simulatorType = const.SIM_MSFS9 if os.name=="nt" \
2402 else const.SIM_XPLANE10
2403
2404 config = self._wizard.gui.config
2405 config.defaultMSFS = simulatorType == const.SIM_MSFS9
2406 config.save()
2407
2408 self._wizard._connectSimulator(simulatorType)
2409
2410 def _forwardClicked(self, button):
2411 """Called when the Forward button is pressed."""
2412 self._wizard.nextPage()
2413
2414#-----------------------------------------------------------------------------
2415
2416class PayloadPage(Page):
2417 """Page to allow setting up the payload."""
2418 def __init__(self, wizard):
2419 """Construct the page."""
2420 super(PayloadPage, self).__init__(wizard, "payload",
2421 xstr("payload_title"),
2422 xstr("payload_help") + "\n\n \n \n",
2423 completedHelp = xstr("payload_chelp"))
2424
2425 alignment = Gtk.Alignment(xalign = 0.5, yalign = 0.5,
2426 xscale = 0.0, yscale = 0.0)
2427
2428 table = Gtk.Table(7, 3)
2429 table.set_row_spacings(4)
2430 table.set_col_spacings(16)
2431 table.set_homogeneous(False)
2432 alignment.add(table)
2433 self.setMainWidget(alignment)
2434
2435 self._crewLabel = label = Gtk.Label(xstr("payload_crew"))
2436 label.set_use_underline(True)
2437 label.set_alignment(0.0, 0.5)
2438 table.attach(label, 0, 1, 0, 1)
2439
2440 self._numCockpitCrew = Gtk.Label()
2441
2442 self._numCabinCrew = IntegerEntry(defaultValue = 0)
2443 self._numCabinCrew.set_width_chars(6)
2444 self._numCabinCrew.connect("integer-changed", self._weightChanged)
2445 self._numCabinCrew.set_tooltip_text(xstr("payload_crew_tooltip"))
2446
2447 crewBox = Gtk.HBox()
2448 crewBox.pack_start(self._numCockpitCrew, False, False, 0)
2449 crewBox.pack_start(Gtk.Label("+"), False, False, 4)
2450 crewBox.pack_start(self._numCabinCrew, False, False, 0)
2451 crewBox.set_halign(Gtk.Align.END)
2452
2453 table.attach(crewBox, 1, 2, 0, 1)
2454 label.set_mnemonic_widget(self._numCabinCrew)
2455
2456 label = Gtk.Label(xstr("payload_crew_info"))
2457 label.set_halign(Gtk.Align.START)
2458 table.attach(label, 2, 3, 0, 1)
2459
2460 self._paxLabel = label = Gtk.Label(xstr("payload_pax"))
2461 label.set_use_underline(True)
2462 label.set_alignment(0.0, 0.5)
2463 table.attach(label, 0, 1, 1, 2)
2464
2465 self._numPassengers = IntegerEntry(defaultValue = 0)
2466 self._numPassengers.set_width_chars(6)
2467 self._numPassengers.connect("integer-changed", self._weightChanged)
2468 self._numPassengers.set_tooltip_text(xstr("payload_pax_tooltip"))
2469
2470 self._numChildren = IntegerEntry(defaultValue = 0)
2471 self._numChildren.set_width_chars(6)
2472 self._numChildren.connect("integer-changed", self._weightChanged)
2473 self._numChildren.set_tooltip_text(xstr("payload_pax_children_tooltip"))
2474
2475 self._numInfants = IntegerEntry(defaultValue = 0)
2476 self._numInfants.set_width_chars(6)
2477 self._numInfants.connect("integer-changed", self._weightChanged)
2478 self._numInfants.set_tooltip_text(xstr("payload_pax_infants_tooltip"))
2479
2480 paxBox = Gtk.HBox()
2481 paxBox.pack_start(self._numPassengers, False, False, 0)
2482 paxBox.pack_start(Gtk.Label("+"), False, False, 4)
2483 paxBox.pack_start(self._numChildren, False, False, 0)
2484 paxBox.pack_start(Gtk.Label("+"), False, False, 4)
2485 paxBox.pack_start(self._numInfants, False, False, 0)
2486
2487 table.attach(paxBox, 1, 2, 1, 2)
2488 label.set_mnemonic_widget(self._numPassengers)
2489
2490 label = Gtk.Label(xstr("payload_pax_info"))
2491 label.set_halign(Gtk.Align.START)
2492 table.attach(label, 2, 3, 1, 2)
2493
2494 label = Gtk.Label(xstr("payload_bag"))
2495 label.set_use_underline(True)
2496 label.set_alignment(0.0, 0.5)
2497 table.attach(label, 0, 1, 2, 3)
2498
2499 self._bagWeight = IntegerEntry(defaultValue = 0)
2500 self._bagWeight.set_width_chars(6)
2501 self._bagWeight.connect("integer-changed", self._weightChanged)
2502 self._bagWeight.set_tooltip_text(xstr("payload_bag_tooltip"))
2503 self._bagWeight.set_hexpand(False)
2504 self._bagWeight.set_halign(Gtk.Align.END)
2505 table.attach(self._bagWeight, 1, 2, 2, 3)
2506 label.set_mnemonic_widget(self._bagWeight)
2507
2508 label = Gtk.Label("kg")
2509 label.set_halign(Gtk.Align.START)
2510 table.attach(label, 2, 3, 2, 3)
2511
2512 label = Gtk.Label(xstr("payload_cargo"))
2513 label.set_use_underline(True)
2514 label.set_alignment(0.0, 0.5)
2515 table.attach(label, 0, 1, 3, 4)
2516
2517 self._cargoWeight = IntegerEntry(defaultValue = 0)
2518 self._cargoWeight.set_width_chars(6)
2519 self._cargoWeight.connect("integer-changed", self._weightChanged)
2520 self._cargoWeight.set_tooltip_text(xstr("payload_cargo_tooltip"))
2521 self._cargoWeight.set_hexpand(False)
2522 self._cargoWeight.set_halign(Gtk.Align.END)
2523 table.attach(self._cargoWeight, 1, 2, 3, 4)
2524 label.set_mnemonic_widget(self._cargoWeight)
2525
2526 label = Gtk.Label("kg")
2527 label.set_halign(Gtk.Align.START)
2528 table.attach(label, 2, 3, 3, 4)
2529
2530 label = Gtk.Label(xstr("payload_mail"))
2531 label.set_use_underline(True)
2532 label.set_alignment(0.0, 0.5)
2533 table.attach(label, 0, 1, 4, 5)
2534
2535 self._mailWeight = IntegerEntry(defaultValue = 0)
2536 self._mailWeight.set_width_chars(6)
2537 self._mailWeight.connect("integer-changed", self._weightChanged)
2538 self._mailWeight.set_tooltip_text(xstr("payload_mail_tooltip"))
2539 self._mailWeight.set_hexpand(False)
2540 self._mailWeight.set_halign(Gtk.Align.END)
2541 table.attach(self._mailWeight, 1, 2, 4, 5)
2542 label.set_mnemonic_widget(self._mailWeight)
2543
2544 label = Gtk.Label("kg")
2545 label.set_halign(Gtk.Align.START)
2546 table.attach(label, 2, 3, 4, 5)
2547
2548 label = Gtk.Label("<b>" + xstr("payload_zfw") + "</b>")
2549 label.set_alignment(0.0, 0.5)
2550 label.set_use_markup(True)
2551 table.attach(label, 0, 1, 5, 6)
2552
2553 self._calculatedZFW = Gtk.Label()
2554 self._calculatedZFW.set_width_chars(6)
2555 self._calculatedZFW.set_alignment(1.0, 0.5)
2556 table.attach(self._calculatedZFW, 1, 2, 5, 6)
2557
2558 label = Gtk.Label("kg")
2559 label.set_halign(Gtk.Align.START)
2560 table.attach(label, 2, 3, 5, 6)
2561
2562 self._zfwButton = Gtk.Button(xstr("payload_fszfw"))
2563 self._zfwButton.set_use_underline(True)
2564 self._zfwButton.connect("clicked", self._zfwRequested)
2565 self._zfwButton.set_tooltip_text(xstr("payload_fszfw_tooltip"))
2566 table.attach(self._zfwButton, 0, 1, 6, 7)
2567
2568 self._simulatorZFW = Gtk.Label("-")
2569 self._simulatorZFW.set_width_chars(6)
2570 self._simulatorZFW.set_alignment(1.0, 0.5)
2571 table.attach(self._simulatorZFW, 1, 2, 6, 7)
2572 self._simulatorZFWValue = None
2573
2574 label = Gtk.Label("kg")
2575 label.set_halign(Gtk.Align.START)
2576 table.attach(label, 2, 3, 6, 7)
2577
2578 self.addCancelFlightButton()
2579 self._backButton = self.addPreviousButton(clicked = self._backClicked)
2580 self._button = self.addNextButton(clicked = self._forwardClicked)
2581
2582 @property
2583 def numCockpitCrew(self):
2584 """The number of the cockpit crew members on the flight."""
2585 return self._wizard._bookedFlight.numCockpitCrew
2586
2587 @property
2588 def numCabinCrew(self):
2589 """The number of the cabin members on the flight."""
2590 return self._numCabinCrew.get_int()
2591
2592 @property
2593 def numPassengers(self):
2594 """The number of the adult passengers on the flight."""
2595 return self._numPassengers.get_int()
2596
2597 @property
2598 def numChildren(self):
2599 """The number of the child passengers on the flight."""
2600 return self._numChildren.get_int()
2601
2602 @property
2603 def numInfants(self):
2604 """The number of the infant passengers on the flight."""
2605 return self._numInfants.get_int()
2606
2607 @property
2608 def bagWeight(self):
2609 """Get the bag weight entered."""
2610 return self._bagWeight.get_int()
2611
2612 @property
2613 def cargoWeight(self):
2614 """Get the cargo weight entered."""
2615 return self._cargoWeight.get_int()
2616
2617 @property
2618 def mailWeight(self):
2619 """Get the bag weight entered."""
2620 return self._mailWeight.get_int()
2621
2622 def activate(self):
2623 """Setup the information."""
2624 bookedFlight = self._wizard._bookedFlight
2625
2626 self._numCockpitCrew.set_markup("<b>" +
2627 str(bookedFlight.numCockpitCrew) +
2628 "</b>")
2629 self._numCabinCrew.set_int(bookedFlight.numCabinCrew)
2630 self._numCabinCrew.set_sensitive(True)
2631
2632
2633 self._numPassengers.set_int(bookedFlight.numPassengers)
2634 self._numPassengers.set_sensitive(True)
2635
2636 self._numChildren.set_int(bookedFlight.numChildren)
2637 self._numChildren.set_sensitive(True)
2638
2639 self._numInfants.set_int(bookedFlight.numInfants)
2640 self._numInfants.set_sensitive(True)
2641
2642 self._bagWeight.set_int(bookedFlight.bagWeight)
2643 self._bagWeight.set_sensitive(True)
2644
2645 if bookedFlight.flightType==const.FLIGHTTYPE_CHARTER:
2646 self._cargoWeight.set_int(0)
2647 self._cargoWeight.set_sensitive(False)
2648 self._mailWeight.set_int(0)
2649 self._mailWeight.set_sensitive(False)
2650 else:
2651 self._cargoWeight.set_int(bookedFlight.cargoWeight)
2652 self._cargoWeight.set_sensitive(True)
2653 self._mailWeight.set_int(bookedFlight.mailWeight)
2654 self._mailWeight.set_sensitive(True)
2655
2656 self._simulatorZFW.set_text("-")
2657 self._simulatorZFWValue = None
2658 self._zfwButton.set_sensitive(True)
2659 self._updateCalculatedZFW()
2660
2661 def finalize(self):
2662 """Finalize the payload page."""
2663 self._numCabinCrew.set_sensitive(False)
2664 self._numPassengers.set_sensitive(False)
2665 self._numChildren.set_sensitive(False)
2666 self._numInfants.set_sensitive(False)
2667 self._bagWeight.set_sensitive(False)
2668 self._cargoWeight.set_sensitive(False)
2669 self._mailWeight.set_sensitive(False)
2670 self._wizard.gui.initializeWeightHelp()
2671
2672 def calculateZFW(self):
2673 """Calculate the ZFW value."""
2674 bookedFlight = self._wizard._bookedFlight
2675
2676 zfw = bookedFlight.dow
2677 zfw += (self._numCabinCrew.get_int() - bookedFlight.dowNumCabinCrew) * \
2678 const.WEIGHT_CABIN_CREW
2679 zfw += self._numPassengers.get_int() * \
2680 (const.WEIGHT_PASSENGER_CHARTER
2681 if bookedFlight.flightType==const.FLIGHTTYPE_CHARTER
2682 else const.WEIGHT_PASSENGER)
2683 zfw += self._numChildren.get_int() * const.WEIGHT_CHILD
2684 zfw += self._numInfants.get_int() * const.WEIGHT_INFANT
2685 zfw += self._bagWeight.get_int()
2686 zfw += self._cargoWeight.get_int()
2687 zfw += self._mailWeight.get_int()
2688 return zfw
2689
2690 def _updateCalculatedZFW(self):
2691 """Update the calculated ZFW"""
2692 zfw = self.calculateZFW()
2693
2694 markupBegin = "<b>"
2695 markupEnd = "</b>"
2696 if self._simulatorZFWValue is not None and \
2697 PayloadChecker.isZFWFaulty(self._simulatorZFWValue, zfw):
2698 markupBegin += '<span foreground="red">'
2699 markupEnd = "</span>" + markupEnd
2700 self._calculatedZFW.set_markup(markupBegin + str(zfw) + markupEnd)
2701
2702 def _weightChanged(self, entry, weight):
2703 """Called when one of the weight values or humanm counts has
2704 changed."""
2705 bookedFlight = self._wizard._bookedFlight
2706 numPassengers = \
2707 self._numPassengers.get_int() + \
2708 self._numChildren.get_int() + \
2709 self._numInfants.get_int()
2710 minCabinCrew = 0 if numPassengers==0 else \
2711 (bookedFlight.maxPassengers // 50) + 1
2712
2713 extraHelp = []
2714 enoughCrew = self._numCabinCrew.get_int() >= minCabinCrew
2715 if enoughCrew:
2716 self._crewLabel.set_text(xstr("payload_crew"))
2717 self.setHelp(xstr("payload_help"))
2718 else:
2719 self._crewLabel.set_markup("<b><span foreground=\"red\">" +
2720 xstr("payload_crew") +
2721 "</span></b>")
2722 extraHelp.append(xstr("payload_help_few_crew") % (minCabinCrew,))
2723 self._crewLabel.set_use_underline(True)
2724
2725 tooManyPassengers = numPassengers>bookedFlight.maxPassengers
2726 if tooManyPassengers:
2727 self._paxLabel.set_markup("<b><span foreground=\"red\">" +
2728 xstr("payload_pax") +
2729 "</span></b>")
2730 extraHelp.append(xstr("payload_help_many_pax") % (bookedFlight.maxPassengers,))
2731 else:
2732 self._paxLabel.set_text(xstr("payload_pax"))
2733 self._paxLabel.set_use_underline(True)
2734
2735 hlp = xstr("payload_help") + "\n\n"
2736 for eh in extraHelp:
2737 hlp += "<b><span foreground=\"red\">" + eh + "</span></b>\n"
2738 hlp += " \n" * (2-len(extraHelp))
2739 self.setHelp(hlp)
2740
2741 self._button.set_sensitive(enoughCrew and not tooManyPassengers)
2742
2743
2744 self._updateCalculatedZFW()
2745
2746 def _zfwRequested(self, button):
2747 """Called when the ZFW is requested from the simulator."""
2748 self._zfwButton.set_sensitive(False)
2749 self._backButton.set_sensitive(False)
2750 self._button.set_sensitive(False)
2751 gui = self._wizard.gui
2752 gui.beginBusy(xstr("payload_zfw_busy"))
2753 gui.simulator.requestZFW(self._handleZFW)
2754
2755 def _handleZFW(self, zfw):
2756 """Called when the ZFW value is retrieved."""
2757 GObject.idle_add(self._processZFW, zfw)
2758
2759 def _processZFW(self, zfw):
2760 """Process the given ZFW value received from the simulator."""
2761 self._wizard.gui.endBusy()
2762 self._zfwButton.set_sensitive(True)
2763 self._backButton.set_sensitive(True)
2764 self._button.set_sensitive(True)
2765 self._simulatorZFWValue = zfw
2766 self._simulatorZFW.set_text("%.0f" % (zfw,))
2767 self._updateCalculatedZFW()
2768
2769 def _forwardClicked(self, button):
2770 """Called when the forward button is clicked."""
2771 self._wizard.nextPage()
2772
2773 def _backClicked(self, button):
2774 """Called when the Back button is pressed."""
2775 self.goBack()
2776
2777#-----------------------------------------------------------------------------
2778
2779class TimePage(Page):
2780 """Page displaying the departure and arrival times and allows querying the
2781 current time from the flight simulator."""
2782 def __init__(self, wizard):
2783 super(TimePage, self).__init__(wizard, "time",
2784 xstr("time_title"),
2785 xstr("time_help"),
2786 completedHelp = xstr("time_chelp"))
2787
2788 alignment = Gtk.Alignment(xalign = 0.5, yalign = 0.5,
2789 xscale = 0.0, yscale = 0.0)
2790
2791 table = Gtk.Table(3, 2)
2792 table.set_row_spacings(4)
2793 table.set_col_spacings(16)
2794 table.set_homogeneous(False)
2795 alignment.add(table)
2796 self.setMainWidget(alignment)
2797
2798 label = Gtk.Label(xstr("time_departure"))
2799 label.set_alignment(0.0, 0.5)
2800 table.attach(label, 0, 1, 0, 1)
2801
2802 self._departure = Gtk.Label()
2803 self._departure.set_alignment(0.0, 0.5)
2804 table.attach(self._departure, 1, 2, 0, 1)
2805
2806 label = Gtk.Label(xstr("time_arrival"))
2807 label.set_alignment(0.0, 0.5)
2808 table.attach(label, 0, 1, 1, 2)
2809
2810 self._arrival = Gtk.Label()
2811 self._arrival.set_alignment(0.0, 0.5)
2812 table.attach(self._arrival, 1, 2, 1, 2)
2813
2814 self._timeButton = Gtk.Button(xstr("time_fs"))
2815 self._timeButton.set_use_underline(True)
2816 self._timeButton.set_tooltip_text(xstr("time_fs_tooltip"))
2817 self._timeButton.connect("clicked", self._timeRequested)
2818 table.attach(self._timeButton, 0, 1, 2, 3)
2819
2820 self._simulatorTime = Gtk.Label("-")
2821 self._simulatorTime.set_alignment(0.0, 0.5)
2822 table.attach(self._simulatorTime, 1, 2, 2, 3)
2823
2824 self.addCancelFlightButton()
2825
2826 self._backButton = self.addPreviousButton(clicked = self._backClicked)
2827 self._button = self.addNextButton(clicked = self._forwardClicked)
2828
2829 def activate(self):
2830 """Activate the page."""
2831 self._timeButton.set_sensitive(True)
2832 bookedFlight = self._wizard._bookedFlight
2833 self._departure.set_text(str(bookedFlight.departureTime.time()))
2834 self._arrival.set_text(str(bookedFlight.arrivalTime.time()))
2835 self._simulatorTime.set_text("-")
2836
2837 def _timeRequested(self, button):
2838 """Request the time from the simulator."""
2839 self._timeButton.set_sensitive(False)
2840 self._backButton.set_sensitive(False)
2841 self._button.set_sensitive(False)
2842 self._wizard.gui.beginBusy(xstr("time_busy"))
2843 self._wizard.gui.simulator.requestTime(self._handleTime)
2844
2845 def _handleTime(self, timestamp):
2846 """Handle the result of a time retrieval."""
2847 GObject.idle_add(self._processTime, timestamp)
2848
2849 def _processTime(self, timestamp):
2850 """Process the given time."""
2851 self._wizard.gui.endBusy()
2852 self._timeButton.set_sensitive(True)
2853 self._backButton.set_sensitive(True)
2854 self._button.set_sensitive(True)
2855 tm = time.gmtime(timestamp)
2856 t = datetime.time(tm.tm_hour, tm.tm_min, tm.tm_sec)
2857 self._simulatorTime.set_text(str(t))
2858
2859 ts = tm.tm_hour * 3600 + tm.tm_min * 60 + tm.tm_sec
2860 dt = self._wizard._bookedFlight.departureTime.time()
2861 dts = dt.hour * 3600 + dt.minute * 60 + dt.second
2862 diff = dts-ts
2863
2864 markupBegin = ""
2865 markupEnd = ""
2866 if diff < 0:
2867 markupBegin = '<b><span foreground="red">'
2868 markupEnd = '</span></b>'
2869 elif diff < 3*60 or diff > 30*60:
2870 markupBegin = '<b><span foreground="orange">'
2871 markupEnd = '</span></b>'
2872
2873 self._departure.set_markup(markupBegin + str(dt) + markupEnd)
2874
2875 def _backClicked(self, button):
2876 """Called when the Back button is pressed."""
2877 self.goBack()
2878
2879 def _forwardClicked(self, button):
2880 """Called when the forward button is clicked."""
2881 if not self._completed:
2882 gui = self._wizard.gui
2883 gui.beginBusy(xstr("fuel_get_busy"))
2884
2885 gui.simulator.getFuel(self._handleFuel)
2886 else:
2887 self._wizard.nextPage()
2888
2889 def _handleFuel(self, fuelData):
2890 """Callback for the fuel query operation."""
2891 GObject.idle_add(self._processFuel, fuelData)
2892
2893 def _processFuel(self, fuelData):
2894 """Process the given fuel data."""
2895 self._wizard.gui.endBusy()
2896 self._wizard._fuelData = fuelData
2897 self._wizard.nextPage()
2898
2899#-----------------------------------------------------------------------------
2900
2901class RoutePage(Page):
2902 """The page containing the route and the flight level."""
2903 def __init__(self, wizard):
2904 """Construct the page."""
2905 super(RoutePage, self).__init__(wizard, "route",
2906 xstr("route_title"),
2907 xstr("route_help"),
2908 completedHelp = xstr("route_chelp"))
2909
2910 alignment = Gtk.Alignment(xalign = 0.5, yalign = 0.5,
2911 xscale = 0.0, yscale = 0.0)
2912
2913 mainBox = Gtk.VBox()
2914 alignment.add(mainBox)
2915 self.setMainWidget(alignment)
2916
2917 levelBox = Gtk.HBox()
2918
2919 label = Gtk.Label(xstr("route_level"))
2920 label.set_use_underline(True)
2921 levelBox.pack_start(label, True, True, 0)
2922
2923 self._cruiseLevel = Gtk.SpinButton()
2924 self._cruiseLevel.set_increments(step = 10, page = 100)
2925 self._cruiseLevel.set_range(min = 0, max = 500)
2926 self._cruiseLevel.set_tooltip_text(xstr("route_level_tooltip"))
2927 self._cruiseLevel.set_numeric(True)
2928 self._cruiseLevel.connect("changed", self._cruiseLevelChanged)
2929 self._cruiseLevel.connect("value-changed", self._cruiseLevelChanged)
2930 label.set_mnemonic_widget(self._cruiseLevel)
2931
2932 levelBox.pack_start(self._cruiseLevel, False, False, 8)
2933
2934 alignment = Gtk.Alignment(xalign = 0.0, yalign = 0.5,
2935 xscale = 0.0, yscale = 0.0)
2936 alignment.add(levelBox)
2937
2938 mainBox.pack_start(alignment, False, False, 0)
2939
2940
2941 routeBox = Gtk.VBox()
2942
2943 alignment = Gtk.Alignment(xalign = 0.0, yalign = 0.5,
2944 xscale = 0.0, yscale = 0.0)
2945 label = Gtk.Label(xstr("route_route"))
2946 label.set_use_underline(True)
2947 alignment.add(label)
2948 routeBox.pack_start(alignment, True, True, 0)
2949
2950 routeWindow = Gtk.ScrolledWindow()
2951 routeWindow.set_size_request(400, 80)
2952 routeWindow.set_shadow_type(Gtk.ShadowType.IN)
2953 routeWindow.set_policy(Gtk.PolicyType.AUTOMATIC,
2954 Gtk.PolicyType.AUTOMATIC)
2955
2956 self._uppercasingRoute = False
2957
2958 self._route = Gtk.TextView()
2959 self._route.set_tooltip_text(xstr("route_route_tooltip"))
2960 self._route.set_wrap_mode(Gtk.WrapMode.WORD)
2961 self._route.get_buffer().connect("changed", self._routeChanged)
2962 self._route.get_buffer().connect_after("insert-text", self._routeInserted)
2963 routeWindow.add(self._route)
2964
2965 label.set_mnemonic_widget(self._route)
2966 routeBox.pack_start(routeWindow, True, True, 0)
2967
2968 mainBox.pack_start(routeBox, True, True, 8)
2969
2970 alternateBox = Gtk.HBox()
2971
2972 label = Gtk.Label(xstr("route_altn"))
2973 label.set_use_underline(True)
2974 alternateBox.pack_start(label, True, True, 0)
2975
2976 self._alternate = Gtk.Entry()
2977 self._alternate.set_width_chars(6)
2978 self._alternate.connect("changed", self._alternateChanged)
2979 self._alternate.set_tooltip_text(xstr("route_altn_tooltip"))
2980 label.set_mnemonic_widget(self._alternate)
2981
2982 alternateBox.pack_start(self._alternate, False, False, 8)
2983
2984 alignment = Gtk.Alignment(xalign = 0.0, yalign = 0.5,
2985 xscale = 0.0, yscale = 0.0)
2986 alignment.add(alternateBox)
2987
2988 mainBox.pack_start(alignment, False, False, 0)
2989
2990 self.addCancelFlightButton()
2991
2992 self._backButton = self.addPreviousButton(clicked = self._backClicked)
2993 self._button = self.addNextButton(clicked = self._forwardClicked)
2994
2995 @property
2996 def filedCruiseLevel(self):
2997 """Get the filed cruise level."""
2998 return self._cruiseLevel.get_value_as_int()
2999
3000 @property
3001 def route(self):
3002 """Get the route."""
3003 return self._getRoute()
3004
3005 @property
3006 def alternate(self):
3007 """Get the ICAO code of the alternate airport."""
3008 return self._alternate.get_text()
3009
3010 def activate(self):
3011 """Setup the route from the booked flight."""
3012 self._cruiseLevel.set_value(0)
3013 self._cruiseLevel.set_text("")
3014 self._route.get_buffer().set_text(self._wizard._bookedFlight.route)
3015 self._alternate.set_text("")
3016 self._updateForwardButton()
3017
3018 def _getRoute(self):
3019 """Get the text of the route."""
3020 buffer = self._route.get_buffer()
3021 return buffer.get_text(buffer.get_start_iter(),
3022 buffer.get_end_iter(), True)
3023
3024 def _updateForwardButton(self):
3025 """Update the sensitivity of the forward button."""
3026 cruiseLevelText = self._cruiseLevel.get_text()
3027 cruiseLevel = int(cruiseLevelText) if cruiseLevelText else 0
3028 alternate = self._alternate.get_text()
3029 self._button.set_sensitive(cruiseLevel>=50 and self._getRoute()!="" and
3030 (len(alternate)==4 or self._wizard.entranceExam))
3031
3032 def _cruiseLevelChanged(self, *arg):
3033 """Called when the cruise level has changed."""
3034 self._updateForwardButton()
3035
3036 def _routeChanged(self, textBuffer):
3037 """Called when the route has changed."""
3038 if not self._uppercasingRoute:
3039 self._updateForwardButton()
3040
3041 def _routeInserted(self, textBuffer, iter, text, length):
3042 """Called when new characters are inserted into the route.
3043
3044 It uppercases all characters."""
3045 if not self._uppercasingRoute:
3046 self._uppercasingRoute = True
3047
3048 iter1 = iter.copy()
3049 iter1.backward_chars(length)
3050 textBuffer.delete(iter, iter1)
3051
3052 textBuffer.insert(iter, text.upper())
3053
3054 self._uppercasingRoute = False
3055
3056 def _alternateChanged(self, entry):
3057 """Called when the alternate airport has changed."""
3058 entry.set_text(entry.get_text().upper())
3059 self._updateForwardButton()
3060
3061 def _backClicked(self, button):
3062 """Called when the Back button is pressed."""
3063 self.goBack()
3064
3065 def _forwardClicked(self, button):
3066 """Called when the Forward button is clicked."""
3067 if self._wizard.gui.flight.aircraft.simBriefData is None:
3068 self._wizard.usingSimBrief = False
3069 if self._wizard.gui.config.useSimBrief and \
3070 self._wizard.usingSimBrief is not False:
3071 self._wizard.jumpPage("simbrief_setup")
3072 else:
3073 self._wizard.usingSimBrief = False
3074 self._wizard.jumpPage("fuel")
3075
3076#-----------------------------------------------------------------------------
3077
3078class SimBriefCredentialsDialog(Gtk.Dialog):
3079 """A dialog window to ask for SimBrief credentials."""
3080 def __init__(self, gui, userName, password, rememberPassword):
3081 """Construct the dialog."""
3082 super(SimBriefCredentialsDialog, self).__init__(WINDOW_TITLE_BASE + " - " +
3083 xstr("simbrief_credentials_title"),
3084 gui.mainWindow,
3085 Gtk.DialogFlags.MODAL)
3086 self.add_button(xstr("button_cancel"), Gtk.ResponseType.CANCEL)
3087 self.add_button(xstr("button_ok"), Gtk.ResponseType.OK)
3088
3089 contentArea = self.get_content_area()
3090
3091 contentAlignment = Gtk.Alignment(xalign = 0.5, yalign = 0.5,
3092 xscale = 0.0, yscale = 0.0)
3093 contentAlignment.set_padding(padding_top = 4, padding_bottom = 16,
3094 padding_left = 8, padding_right = 8)
3095
3096 contentArea.pack_start(contentAlignment, False, False, 0)
3097
3098 contentVBox = Gtk.VBox()
3099 contentAlignment.add(contentVBox)
3100
3101 label = Gtk.Label(xstr("simbrief_login_failed"))
3102 label.set_alignment(0.0, 0.0)
3103
3104 contentVBox.pack_start(label, False, False, 0)
3105
3106 tableAlignment = Gtk.Alignment(xalign = 0.5, yalign = 0.5,
3107 xscale = 0.0, yscale = 0.0)
3108 tableAlignment.set_padding(padding_top = 24, padding_bottom = 0,
3109 padding_left = 0, padding_right = 0)
3110
3111 table = Gtk.Table(3, 2)
3112 table.set_row_spacings(4)
3113 table.set_col_spacings(16)
3114 table.set_homogeneous(False)
3115
3116 tableAlignment.add(table)
3117 contentVBox.pack_start(tableAlignment, True, True, 0)
3118
3119 label = Gtk.Label(xstr("simbrief_username"))
3120 label.set_use_underline(True)
3121 label.set_alignment(0.0, 0.5)
3122 table.attach(label, 0, 1, 0, 1)
3123
3124 self._userName = Gtk.Entry()
3125 self._userName.set_width_chars(16)
3126 #self._userName.connect("changed",
3127 # lambda button: self._updateForwardButton())
3128 self._userName.set_tooltip_text(xstr("simbrief_username_tooltip"))
3129 self._userName.set_text(userName)
3130 table.attach(self._userName, 1, 2, 0, 1)
3131 label.set_mnemonic_widget(self._userName)
3132
3133 label = Gtk.Label(xstr("simbrief_password"))
3134 label.set_use_underline(True)
3135 label.set_alignment(0.0, 0.5)
3136 table.attach(label, 0, 1, 1, 2)
3137
3138 self._password = Gtk.Entry()
3139 self._password.set_visibility(False)
3140 #self._password.connect("changed",
3141 # lambda button: self._updateForwardButton())
3142 self._password.set_tooltip_text(xstr("simbrief_password_tooltip"))
3143 self._password.set_text(password)
3144 table.attach(self._password, 1, 2, 1, 2)
3145 label.set_mnemonic_widget(self._password)
3146
3147 self._rememberButton = Gtk.CheckButton(xstr("simbrief_remember_password"))
3148 self._rememberButton.set_use_underline(True)
3149 self._rememberButton.set_tooltip_text(xstr("simbrief_remember_tooltip"))
3150 self._rememberButton.set_active(rememberPassword)
3151 table.attach(self._rememberButton, 1, 2, 2, 3, ypadding = 8)
3152
3153 @property
3154 def userName(self):
3155 """Get the user name entered."""
3156 return self._userName.get_text()
3157
3158 @property
3159 def password(self):
3160 """Get the password entered."""
3161 return self._password.get_text()
3162
3163 @property
3164 def rememberPassword(self):
3165 """Get whether the password is to be remembered."""
3166 return self._rememberButton.get_active()
3167
3168 def run(self):
3169 """Run the dialog."""
3170 self.show_all()
3171
3172 response = super(SimBriefCredentialsDialog, self).run()
3173
3174 self.hide()
3175
3176 return response
3177
3178#-----------------------------------------------------------------------------
3179
3180class SimBriefSetupPage(Page):
3181 """Page for setting up some parameters for SimBrief."""
3182 monthNum2Name = [
3183 "JAN",
3184 "FEB",
3185 "MAR",
3186 "APR",
3187 "MAY",
3188 "JUN",
3189 "JUL",
3190 "AUG",
3191 "SEP",
3192 "OCT",
3193 "NOV",
3194 "DEC"
3195 ]
3196
3197 progress2Message = {
3198 cef.SIMBRIEF_PROGRESS_SEARCHING_BROWSER: "simbrief_progress_searching_browser",
3199 cef.SIMBRIEF_PROGRESS_LOADING_FORM: "simbrief_progress_loading_form",
3200 cef.SIMBRIEF_PROGRESS_FILLING_FORM: "simbrief_progress_filling_form",
3201 cef.SIMBRIEF_PROGRESS_WAITING_LOGIN: "simbrief_progress_waiting_login",
3202 cef.SIMBRIEF_PROGRESS_LOGGING_IN: "simbrief_progress_logging_in",
3203 cef.SIMBRIEF_PROGRESS_WAITING_RESULT: "simbrief_progress_waiting_result",
3204 cef.SIMBRIEF_PROGRESS_RETRIEVING_BRIEFING: "simbrief_progress_retrieving_briefing"
3205 }
3206
3207 result2Message = {
3208 cef.SIMBRIEF_RESULT_ERROR_OTHER: "simbrief_result_error_other",
3209 cef.SIMBRIEF_RESULT_ERROR_NO_FORM: "simbrief_result_error_no_form",
3210 cef.SIMBRIEF_RESULT_ERROR_NO_POPUP: "simbrief_result_error_no_popup",
3211 cef.SIMBRIEF_RESULT_ERROR_LOGIN_FAILED: "simbrief_result_error_login_failed"
3212 }
3213
3214 _resultQueryInterval = 2000
3215
3216 _waitTimeout = 2 * 60.0
3217
3218 @staticmethod
3219 def getHTMLFilePath():
3220 """Get the path of the HTML file to contain the generated flight
3221 plan."""
3222 if os.name=="nt":
3223 return os.path.join(tempfile.gettempdir(),
3224 "mlx_simbrief" +
3225 (".secondary" if secondaryInstallation else "") +
3226 ".html")
3227 else:
3228 import pwd
3229 return os.path.join(tempfile.gettempdir(),
3230 "mlx_simbrief." + pwd.getpwuid(os.getuid())[0] + "" +
3231 (".secondary" if secondaryInstallation else "") +
3232 ".html")
3233
3234 def __init__(self, wizard):
3235 """Construct the setup page."""
3236
3237 super(SimBriefSetupPage, self).__init__(wizard, "simbrief_setup",
3238 xstr("simbrief_setup_title"),
3239 xstr("simbrief_setup_help"),
3240 xstr("simbrief_setup_chelp"))
3241
3242 alignment = Gtk.Alignment(xalign = 0.5, yalign = 0.5,
3243 xscale = 0.0, yscale = 0.0)
3244
3245 table = Gtk.Table(7, 3)
3246 table.set_row_spacings(4)
3247 table.set_col_spacings(16)
3248 table.set_homogeneous(False)
3249 alignment.add(table)
3250 self.setMainWidget(alignment)
3251
3252
3253 row = 0
3254
3255 frame = Gtk.Frame.new()
3256 self._useInternalBrowser = Gtk.CheckButton(xstr("simbrief_uib"))
3257 frame.set_label_widget(self._useInternalBrowser)
3258 frame.set_label_align(0.025, 0.5)
3259
3260 self._useInternalBrowser.set_use_underline(True)
3261 self._useInternalBrowser.connect("toggled",
3262 self._useInternalBrowserToggled)
3263 self._useInternalBrowser.set_tooltip_text(xstr("simbrief_uib_tooltip"))
3264
3265 uibTable = Gtk.Table(2, 3)
3266 uibTable.set_row_spacings(4)
3267 uibTable.set_col_spacings(16)
3268 uibTable.set_homogeneous(False)
3269
3270 uibRow = 0
3271
3272 label = Gtk.Label(xstr("simbrief_username"))
3273 label.set_use_underline(True)
3274 label.set_alignment(0.0, 0.5)
3275 uibTable.attach(label, 0, 1, uibRow, uibRow+1)
3276
3277 self._userName = Gtk.Entry()
3278 self._userName.set_width_chars(16)
3279 self._userName.connect("changed",
3280 lambda button: self._updateForwardButton())
3281 self._userName.set_tooltip_text(xstr("simbrief_username_tooltip"))
3282 uibTable.attach(self._userName, 1, 2, uibRow, uibRow+1)
3283 label.set_mnemonic_widget(self._userName)
3284 uibRow += 1
3285
3286 label = Gtk.Label(xstr("simbrief_password"))
3287 label.set_use_underline(True)
3288 label.set_alignment(0.0, 0.5)
3289 uibTable.attach(label, 0, 1, uibRow, uibRow+1)
3290
3291 self._password = Gtk.Entry()
3292 self._password.set_visibility(False)
3293 self._password.connect("changed",
3294 lambda button: self._updateForwardButton())
3295 self._password.set_tooltip_text(xstr("simbrief_password_tooltip"))
3296 uibTable.attach(self._password, 1, 2, uibRow, uibRow+1)
3297 label.set_mnemonic_widget(self._password)
3298
3299 self._rememberButton = Gtk.CheckButton(xstr("simbrief_remember_password"))
3300 self._rememberButton.set_use_underline(True)
3301 self._rememberButton.set_tooltip_text(xstr("simbrief_remember_tooltip"))
3302 uibTable.attach(self._rememberButton, 2, 3, uibRow, uibRow+1, ypadding = 8)
3303 uibRow += 1
3304
3305 uibTable.set_margin_top(6)
3306 uibTable.set_margin_bottom(6)
3307 uibTable.set_margin_left(4)
3308 uibTable.set_margin_right(4)
3309
3310 frame.add(uibTable)
3311 frame.set_margin_bottom(10)
3312
3313 table.attach(frame, 0, 3, row, row+1)
3314 row += 1
3315
3316 label = Gtk.Label(xstr("simbrief_extra_fuel"))
3317 label.set_use_underline(True)
3318 label.set_alignment(0.0, 0.5)
3319 table.attach(label, 0, 1, row, row+1)
3320
3321 self._extraFuel = IntegerEntry(defaultValue = 0)
3322 self._extraFuel.set_width_chars(6)
3323 self._extraFuel.set_tooltip_text(xstr("simbrief_extra_fuel_tooltip"))
3324 table.attach(self._extraFuel, 1, 2, row, row+1)
3325 label.set_mnemonic_widget(self._extraFuel)
3326
3327 label = Gtk.Label("kg")
3328 label.set_alignment(0.0, 0.5)
3329 table.attach(label, 2, 3, row, row+1)
3330 row += 1
3331
3332 label = Gtk.Label(xstr("simbrief_takeoff_runway"))
3333 label.set_use_underline(True)
3334 label.set_alignment(0.0, 0.5)
3335 table.attach(label, 0, 1, row, row+1)
3336
3337 self._takeoffRunway = Gtk.Entry()
3338 self._takeoffRunway.set_width_chars(10)
3339 self._takeoffRunway.set_tooltip_text(xstr("simbrief_takeoff_runway_tooltip"))
3340 self._takeoffRunway.connect("changed", self._upperChanged)
3341 table.attach(self._takeoffRunway, 1, 2, row, row+1)
3342 label.set_mnemonic_widget(self._takeoffRunway)
3343 row += 1
3344
3345 label = Gtk.Label(xstr("simbrief_landing_runway"))
3346 label.set_use_underline(True)
3347 label.set_alignment(0.0, 0.5)
3348 table.attach(label, 0, 1, row, row+1)
3349
3350 self._landingRunway = Gtk.Entry()
3351 self._landingRunway.set_width_chars(10)
3352 self._landingRunway.set_tooltip_text(xstr("simbrief_landing_runway_tooltip"))
3353 self._landingRunway.connect("changed", self._upperChanged)
3354 table.attach(self._landingRunway, 1, 2, row, row+1)
3355 label.set_mnemonic_widget(self._landingRunway)
3356 row += 1
3357
3358 label = Gtk.Label(xstr("simbrief_climb_profile"))
3359 label.set_use_underline(True)
3360 label.set_alignment(0.0, 0.5)
3361 table.attach(label, 0, 1, row, row+1)
3362
3363 self._climbProfile = Gtk.ComboBox()
3364 renderer = Gtk.CellRendererText()
3365 self._climbProfile.pack_start(renderer, True)
3366 self._climbProfile.add_attribute(renderer, "text", 0)
3367 self._climbProfile.set_tooltip_text(xstr("simbrief_climb_profile_tooltip"))
3368 table.attach(self._climbProfile, 1, 2, row, row+1)
3369 label.set_mnemonic_widget(self._climbProfile)
3370 row += 1
3371
3372 label = Gtk.Label(xstr("simbrief_cruise_profile"))
3373 label.set_use_underline(True)
3374 label.set_alignment(0.0, 0.5)
3375 table.attach(label, 0, 1, row, row+1)
3376
3377 self._cruiseProfile = Gtk.ComboBox()
3378 renderer = Gtk.CellRendererText()
3379 self._cruiseProfile.pack_start(renderer, True)
3380 self._cruiseProfile.add_attribute(renderer, "text", 0)
3381 self._cruiseProfile.set_tooltip_text(xstr("simbrief_cruise_profile_tooltip"))
3382 table.attach(self._cruiseProfile, 1, 2, row, row+1)
3383 label.set_mnemonic_widget(self._cruiseProfile)
3384 row += 1
3385
3386 label = Gtk.Label(xstr("simbrief_descent_profile"))
3387 label.set_use_underline(True)
3388 label.set_alignment(0.0, 0.5)
3389 table.attach(label, 0, 1, row, row+1)
3390
3391 self._descentProfile = Gtk.ComboBox()
3392 renderer = Gtk.CellRendererText()
3393 self._descentProfile.pack_start(renderer, True)
3394 self._descentProfile.add_attribute(renderer, "text", 0)
3395 self._descentProfile.set_tooltip_text(xstr("simbrief_descent_profile_tooltip"))
3396 table.attach(self._descentProfile, 1, 2, row, row+1)
3397 label.set_mnemonic_widget(self._descentProfile)
3398
3399 self.addCancelFlightButton()
3400
3401 self._backButton = self.addPreviousButton(clicked = self._backClicked)
3402 self._button = self.addNextButton(clicked = self._forwardClicked)
3403
3404 self._resultTimestamp = None
3405
3406 def activate(self):
3407 """Activate the SimBrief setup page"""
3408 config = self._wizard.gui.config
3409
3410 self._useInternalBrowser.set_active(config.useInternalBrowserForSimBrief)
3411 self._useInternalBrowser.set_sensitive(True)
3412
3413 self._userName.set_text(config.simBriefUserName)
3414 self._userName.set_sensitive(config.useInternalBrowserForSimBrief)
3415
3416 self._password.set_text(config.simBriefPassword)
3417 self._password.set_sensitive(config.useInternalBrowserForSimBrief)
3418
3419 self._rememberButton.set_active(config.rememberSimBriefPassword)
3420 self._rememberButton.set_sensitive(config.useInternalBrowserForSimBrief)
3421
3422 self._extraFuel.set_int(0)
3423 self._extraFuel.set_sensitive(True)
3424
3425 self._takeoffRunway.set_text("")
3426 self._takeoffRunway.set_sensitive(True)
3427
3428 self._landingRunway.set_text("")
3429 self._landingRunway.set_sensitive(True)
3430
3431 simBriefData = self._wizard.gui.flight.aircraft.simBriefData
3432 for (control, profiles) in [(self._climbProfile,
3433 simBriefData.climbProfiles),
3434 (self._cruiseProfile,
3435 simBriefData.cruiseProfiles),
3436 (self._descentProfile,
3437 simBriefData.descentProfiles)]:
3438 model = Gtk.ListStore(str)
3439 for profile in profiles:
3440 model.append([profile])
3441 control.set_model(model)
3442 control.set_sensitive(True)
3443
3444 self._climbProfile.set_active(0)
3445 self._cruiseProfile.set_active(0)
3446 self._descentProfile.set_active(0)
3447
3448 self._resultTimestamp = None
3449 self._waitEnd = None
3450
3451 self._updateForwardButton()
3452
3453 def _updateForwardButton(self):
3454 """Update the sensitivity of the forward button."""
3455 self._button.set_sensitive(True)
3456 self._button.set_sensitive(len(self._userName.get_text())>0 and
3457 len(self._password.get_text())>0)
3458
3459 def _backClicked(self, button):
3460 """Called when the Back button is pressed."""
3461 self.goBack()
3462
3463 def _forwardClicked(self, button):
3464 if self._completed:
3465 self._wizard.nextPage()
3466 else:
3467 config = self._wizard.gui.config
3468
3469 config.simBriefUserName = self._userName.get_text()
3470
3471 rememberPassword = self._rememberButton.get_active()
3472 config.simBriefPassword = \
3473 self._password.get_text() if rememberPassword else ""
3474 config.rememberSimBriefPassword = rememberPassword
3475
3476 config.useInternalBrowserForSimBrief = \
3477 self._useInternalBrowser.get_active()
3478
3479 config.save()
3480
3481 self._wizard.gui.simulator.requestTime(self._handleTime)
3482
3483 def _useInternalBrowserToggled(self, checkButton):
3484 """Called when the check button indicating if the internal browser
3485 should be used is toggled."""
3486 useInternalBrowserForSimBrief = self._useInternalBrowser.get_active()
3487 self._userName.set_sensitive(useInternalBrowserForSimBrief)
3488 self._password.set_sensitive(useInternalBrowserForSimBrief)
3489 self._rememberButton.set_sensitive(useInternalBrowserForSimBrief)
3490
3491 def _handleTime(self, simulatorNow):
3492 """Handle the result of a time retrieval."""
3493 GObject.idle_add(self._processTime, simulatorNow)
3494
3495 def _processTime(self, simulatorNow):
3496 """Process the given time."""
3497 plan = self._getPlan(simulatorNow)
3498 print("plan:", plan)
3499
3500 takeoffRunway = self._takeoffRunway.get_text()
3501 if takeoffRunway:
3502 self._wizard.takeoffRunway = takeoffRunway
3503
3504 landingRunway = self._landingRunway.get_text()
3505 if landingRunway:
3506 self._wizard.landingRunway = landingRunway
3507
3508 self._userName.set_sensitive(False)
3509 self._password.set_sensitive(False)
3510 self._rememberButton.set_sensitive(False)
3511 self._extraFuel.set_sensitive(False)
3512 self._takeoffRunway.set_sensitive(False)
3513 self._landingRunway.set_sensitive(False)
3514
3515 self._climbProfile.set_sensitive(False)
3516 self._cruiseProfile.set_sensitive(False)
3517 self._descentProfile.set_sensitive(False)
3518
3519 self._wizard.gui.beginBusy(xstr("simbrief_calling"))
3520
3521 url = cef.SimBriefHandler.getFormURL(plan)
3522 print("url:", url)
3523
3524 config = self._wizard.gui.config
3525 if config.useInternalBrowserForSimBrief:
3526 self._waitEnd = 0
3527 cef.callSimBrief(plan,
3528 self._getCredentials,
3529 self._simBriefProgress,
3530 SimBriefSetupPage.getHTMLFilePath())
3531 else:
3532 webbrowser.open(url = url, new = 1)
3533 self._waitEnd = time.time() + SimBriefSetupPage._waitTimeout
3534 GObject.timeout_add(SimBriefSetupPage._resultQueryInterval,
3535 lambda: self._wizard.gui.webHandler. \
3536 getSimBriefResult(self._resultCallback,
3537 self._resultTimestamp))
3538
3539
3540 startSound(const.SOUND_NOTAM)
3541
3542 def _getCredentials(self, count):
3543 """Get the credentials.
3544
3545 If count is 0, the user name and password entered into the setup page
3546 are returned. Otherwise a dialog box is displayed informing the user of
3547 invalid credentials and requesting another set of them."""
3548 print("_getCredentials", count)
3549 if count==0:
3550 return (self._userName.get_text(), self._password.get_text())
3551 else:
3552 gui = self._wizard.gui
3553 config = gui.config
3554
3555 dialog = SimBriefCredentialsDialog(gui,
3556 config.simBriefUserName,
3557 config.simBriefPassword,
3558 config.rememberSimBriefPassword)
3559 response = dialog.run()
3560
3561 if response==Gtk.ResponseType.OK:
3562 userName = dialog.userName
3563 self._userName.set_text(userName)
3564 password = dialog.password
3565 self._password.set_text(password)
3566 rememberPassword = dialog.rememberPassword
3567
3568 config.simBriefUserName = userName
3569
3570 config.simBriefPassword = \
3571 password if rememberPassword else ""
3572 config.rememberSimBriefPassword = rememberPassword
3573
3574 config.save()
3575
3576 return (userName, password)
3577 else:
3578 return (None, None)
3579
3580 def _simBriefProgress(self, progress, result, flightInfo):
3581 """The real SimBrief progress handler."""
3582 print("_simBriefProgress", progress, result, flightInfo)
3583 if result==cef.SIMBRIEF_RESULT_NONE:
3584 message = SimBriefSetupPage.progress2Message.get(progress,
3585 "simbrief_progress_unknown")
3586 self._wizard.gui.updateBusyState(xstr(message))
3587 else:
3588 if result==cef.SIMBRIEF_RESULT_OK:
3589 self._waitEnd = 0
3590 self._wizard.gui.webHandler. \
3591 getSimBriefResult(self._resultCallback,
3592 self._resultTimestamp)
3593 else:
3594 self._wizard.gui.endBusy()
3595
3596 message = SimBriefSetupPage.result2Message.get(result,
3597 "simbrief_result_unknown")
3598 dialog = Gtk.MessageDialog(parent = self._wizard.gui.mainWindow,
3599 type = Gtk.MessageType.ERROR,
3600 message_format =
3601 xstr(message) + "\n"+
3602 xstr("simbrief_cancelled"))
3603
3604 dialog.add_button(xstr("button_ok"), Gtk.ResponseType.OK)
3605 dialog.set_title(WINDOW_TITLE_BASE)
3606 secondary = xstr("flightsel_save_failed_sec")
3607 dialog.format_secondary_markup(secondary)
3608 dialog.run()
3609 dialog.hide()
3610
3611 self._wizard.usingSimBrief = False
3612 self._wizard.jumpPage("fuel", fromPageShift = 1)
3613
3614 def _getPlan(self, simulatorNow):
3615 """Get the flight plan data for SimBrief."""
3616 print("timestamp:", simulatorNow)
3617
3618 self._resultTimestamp = now = int(time.time())
3619
3620 plan = {
3621 "airline": "MAH",
3622 "selcal": "XXXX",
3623 "fuelfactor": "P000",
3624 "contpct": "0.05",
3625 "resvrule": "45",
3626 "taxiout": "10",
3627 "taxiin": "10",
3628 "civalue": "AUTO",
3629 "lang": "hun" if getLanguage().lower()=="hu" else "eng",
3630 "sessionID": self._wizard._loginResult.sessionID,
3631 "timestamp": now
3632 }
3633
3634 wizard = self._wizard
3635 gui = wizard.gui
3636
3637 loginResult = wizard.loginResult
3638 plan["cpt"] = loginResult.pilotName
3639 plan["pid"] = loginResult.pilotID
3640
3641 bookedFlight = wizard.bookedFlight
3642 plan["fltnum"] = wizard.bookedFlight.callsign[2:]
3643 plan["type"] = const.icaoCodes[bookedFlight.aircraftType]
3644 plan["orig"] = bookedFlight.departureICAO
3645 plan["dest"] = bookedFlight.arrivalICAO
3646 plan["reg"] = bookedFlight.tailNumber
3647 plan["pax"] = str(bookedFlight.numPassengers)
3648
3649 departureTime = bookedFlight.departureTime
3650 print("departureTime", departureTime)
3651
3652 tm = time.gmtime(simulatorNow)
3653 diffMinutes = (departureTime.hour - tm.tm_hour)*60 + \
3654 departureTime.minute - tm.tm_min
3655 while diffMinutes<0:
3656 diffMinutes += 24*60
3657
3658 realDepartureTime = datetime.datetime.utcnow()
3659 realDepartureTime += datetime.timedelta(minutes = diffMinutes)
3660
3661 plan["date"] = "%02d%s%02d" % (realDepartureTime.day,
3662 SimBriefSetupPage.monthNum2Name[realDepartureTime.month-1],
3663 realDepartureTime.year%100)
3664 plan["deph"] = str(realDepartureTime.hour)
3665 plan["depm"] = str(realDepartureTime.minute)
3666
3667 arrivalTime = bookedFlight.arrivalTime
3668 blockMinutes = (arrivalTime.hour - departureTime.hour)*60 + \
3669 arrivalTime.minute - departureTime.minute
3670 while blockMinutes<0:
3671 blockMinutes += 24*60
3672 plan["steh"] = str(blockMinutes//60)
3673 plan["stem"] = str(blockMinutes%60)
3674
3675 plan["manualzfw"] = str(wizard.zfw / 1000.0)
3676 plan["cargo"] = str((wizard.bagWeight + wizard.cargoWeight + wizard.mailWeight)/1000.0)
3677
3678 plan["route"] = wizard.route
3679 plan["fl"] = str(wizard.filedCruiseAltitude)
3680 plan["altn"] = wizard.alternate
3681
3682 plan["addedfuel"] = str(self._extraFuel.get_int() / 1000.0)
3683 plan["origrwy"] = self._takeoffRunway.get_text()
3684 plan["destrwy"] = self._landingRunway.get_text()
3685
3686 for (key, control) in [("climb", self._climbProfile),
3687 ("cruise", self._cruiseProfile),
3688 ("descent", self._descentProfile)]:
3689 model = control.get_model()
3690 active = control.get_active_iter()
3691 value = model.get_value(active, 0)
3692 plan[key] = value
3693
3694 return plan
3695
3696 def _resultCallback(self, returned, result):
3697 """Callback for the SimBrief result query."""
3698 GObject.idle_add(self._handleResult, returned, result)
3699
3700 def _handleResult(self, returned, result):
3701 """Handle an RPC query result."""
3702 print("_handleResult", returned, result)
3703 if result.result and result.result.get("result"):
3704 link = result.result.get("result")
3705 if link=="<failed>":
3706 self._wizard.gui.endBusy()
3707
3708 self._finishWithError()
3709 else:
3710 link ="https://www.simbrief.com/ofp/flightplans/xml/" + link + ".xml"
3711
3712 thread = threading.Thread(target = self._getResults, args = (link,))
3713 thread.daemon = True
3714 thread.start()
3715
3716 elif time.time() >= self._waitEnd:
3717 self._wizard.gui.endBusy()
3718
3719 self._finishWithError()
3720 else:
3721 GObject.timeout_add(SimBriefSetupPage._resultQueryInterval,
3722 lambda: self._wizard.gui.webHandler. \
3723 getSimBriefResult(self._resultCallback,
3724 self._resultTimestamp))
3725
3726 def _upperChanged(self, entry, arg = None):
3727 """Called when the value of some entry widget has changed and the value
3728 should be converted to uppercase."""
3729 entry.set_text(entry.get_text().upper())
3730
3731 def _getResults(self, link):
3732 """Get the result from the given link."""
3733 ## Holds analysis data to be used
3734 flightInfo = {}
3735 try:
3736 availableInfo = {}
3737
3738 # Obtaining the xml
3739 response = urllib.request.urlopen(link,
3740 cafile = certifi.where())
3741 content = etree.iterparse(response)
3742
3743 for (action, element) in content:
3744 # Processing tags that occur multiple times
3745 if element.tag == "weather":
3746 weatherElementList = list(element)
3747 for weatherElement in weatherElementList:
3748 flightInfo[weatherElement.tag] = weatherElement.text
3749 elif element.tag in ["files", "prefile"]:
3750 availableInfo[element.tag] = element
3751 else:
3752 availableInfo[element.tag] = element.text
3753
3754 # Processing plan_html
3755 ## Obtaining chart links
3756 imageLinks = []
3757 for imageLinkElement in lxml.html.find_class(availableInfo["plan_html"],
3758 "ofpmaplink"):
3759 for imageLink in imageLinkElement.iterlinks():
3760 if imageLink[1] == 'src':
3761 imageLinks.append(imageLink[2])
3762 flightInfo["image_links"] = imageLinks
3763 print((sorted(availableInfo.keys())))
3764 htmlFilePath = SimBriefSetupPage.getHTMLFilePath()
3765 with open(htmlFilePath, 'w') as f:
3766 f.write("<html>")
3767 f.write("<body>")
3768 f.write("<h3 style=\"text-align: center;\">%s</h3></br>" % (xstr("simbrief_result_briefing"),))
3769 f.write("<div style=\"height: 300px; width: fit-content; overflow: auto; margin: 0 auto;\">")
3770 f.write(availableInfo["plan_html"])
3771 f.write("</div>\n")
3772
3773 f.write("<h2/>");
3774 f.write("<h3 style=\"text-align: center;\">%s</h3></br>" % (xstr("simbrief_result_downloads"),))
3775 f.write("<div style=\"height: 300px; width: fit-content; overflow: auto; margin: 0 auto\">")
3776 f.write("<table style=\"border: 1px solid; border-collapse: collapse;\">")
3777
3778 directory = ""
3779 for fileData in availableInfo["files"]:
3780 if fileData.tag=="directory":
3781 directory = fileData.text
3782
3783 for fileData in availableInfo["files"]:
3784 if fileData.tag in ["pdf", "file"]:
3785 name = fileData.find("name").text
3786 link = fileData.find("link").text
3787
3788 f.write("<tr>")
3789 f.write("<td style=\"border: 1px solid; padding-left: 10px; padding-right: 10px; padding-top: 5px; padding-bottom: 5px;\">")
3790 f.write(name)
3791 f.write("</td>")
3792 f.write("<td style=\"border: 1px solid; padding-left: 10px; padding-right: 10px; padding-top: 5px; padding-bottom: 5px;\">")
3793 url = directory + link
3794 target = " target=\"_blank\"" if fileData.tag=="pdf" else ""
3795 f.write("<a href=\"%s\"%s>%s</a>" % (url, target, name))
3796 f.write("</td>")
3797 f.write("</tr>")
3798
3799 f.write("</table>")
3800 f.write("</div>\n")
3801
3802 f.write("<h2/>")
3803 f.write("<h3 style=\"text-align: center;\">%s</h3></br>" % (xstr("simbrief_result_prefile"),))
3804 f.write("<div style=\"height: 400px; width: fit-content; margin: 0 auto\">")
3805 f.write("<table style=\"border: 1px solid; border-collapse: collapse;\">")
3806 for prefileData in availableInfo["prefile"]:
3807 name = prefileData.find("name").text
3808 link = prefileData.find("link").text
3809 f.write("<tr>")
3810 f.write("<td style=\"border: 1px solid; padding-left: 10px; padding-right: 10px; padding-top: 5px; padding-bottom: 5px;\">")
3811 f.write("<a href=\"%s\" target=\"_blank\">%s</a>" % (link, name))
3812 f.write("</td>");
3813 f.write("</tr>")
3814
3815 f.write("</table>")
3816 f.write("</div>\n")
3817
3818 f.write("</body>")
3819 f.write("</html>")
3820
3821 except Exception as e:
3822 print("_getResults", e)
3823
3824 GObject.idle_add(self._resultsAvailable, flightInfo)
3825
3826 def _resultsAvailable(self, flightInfo):
3827 """Called from the result retrieval thread when the result is
3828 available."""
3829 print("_resultsAvailable")
3830 self._wizard.gui.endBusy()
3831
3832 if flightInfo:
3833 self._wizard.departureMETARChanged(flightInfo["orig_metar"],
3834 self)
3835 self._wizard.arrivalMETARChanged(flightInfo["dest_metar"], self)
3836 self._wizard.nextPage()
3837 else:
3838 self._finishWithError()
3839
3840 def _finishWithError(self):
3841 """Display an error dialog, and when it is accepted, cancel
3842 SimBrief briefing and jump to the fuel page."""
3843 dialog = Gtk.MessageDialog(parent = self._wizard.gui.mainWindow,
3844 type = Gtk.MessageType.ERROR,
3845 message_format =
3846 xstr("simbrief_result_error_other") + "\n"+
3847 xstr("simbrief_cancelled"))
3848
3849 dialog.add_button(xstr("button_ok"), Gtk.ResponseType.OK)
3850 dialog.set_title(WINDOW_TITLE_BASE)
3851 secondary = xstr("flightsel_save_failed_sec")
3852 dialog.format_secondary_markup(secondary)
3853 dialog.run()
3854 dialog.hide()
3855
3856 self._wizard.usingSimBrief = False
3857 self._wizard.jumpPage("fuel", fromPageShift = 1)
3858
3859
3860
3861#-----------------------------------------------------------------------------
3862
3863class SimBriefingPage(Page):
3864 """Page to display the SimBrief HTML briefing."""
3865 class BrowserLifeSpanHandler(object):
3866 """The life-span handler of a browser."""
3867 def __init__(self, simBriefingPage):
3868 """Construct the life-span handler for the given page."""
3869 self._simBriefingPage = simBriefingPage
3870
3871 def OnBeforeClose(self, browser):
3872 """Called before closing the browser."""
3873 if browser is self._simBriefingPage._browser:
3874 self._simBriefingPage._invalidateBrowser()
3875
3876 def OnBeforeDownload(self, browser, downloadItem, suggestedName, callback):
3877 callback.Continue(suggestedName, True)
3878 return True
3879
3880 def __init__(self, wizard):
3881 """Construct the setup page."""
3882
3883 super(SimBriefingPage, self).__init__(wizard, "simbrief_result",
3884 xstr("simbrief_result_title"), "")
3885
3886 self._container = cef.getContainer()
3887 self._container.set_size_request(650, -1)
3888
3889 self.setMainWidget(self._container)
3890
3891 self._browser = None
3892
3893 self.addCancelFlightButton()
3894
3895 self.addPreviousButton(clicked = self._backClicked)
3896
3897 self._button = self.addNextButton(clicked = self._forwardClicked)
3898 self._button.set_label(xstr("briefing_button"))
3899 self._button.set_has_tooltip(False)
3900 self._button.set_use_stock(False)
3901
3902 def prepareShow(self):
3903 """Prepare the page for showing (again)."""
3904 if self._browser is None:
3905 self._startBrowser()
3906 else:
3907 self._browser.Reload()
3908
3909 def prepareHide(self):
3910 """Prepare the page for hiding."""
3911 if os.name!="nt":
3912 self._browser.CloseBrowser(False)
3913
3914 def grabDefault(self):
3915 """If the page has a default button, make it the default one."""
3916 super(SimBriefingPage, self).grabDefault()
3917
3918 if self._browser is None:
3919 self._startBrowser()
3920
3921 def _backClicked(self, button):
3922 """Called when the Back button has been pressed."""
3923 self.goBack()
3924
3925 def _forwardClicked(self, button):
3926 """Called when the Forward button has been pressed."""
3927 if not self._completed:
3928 self._button.set_label(xstr("button_next"))
3929 self._button.set_tooltip_text(xstr("button_next_tooltip"))
3930 self._wizard.usingSimBrief = True
3931 self.complete()
3932
3933 self._wizard.nextPage()
3934
3935 def _startBrowser(self):
3936 """Start the browser.
3937
3938 If a container is needed, create one."""
3939 if self._container is None:
3940 self._container = cef.getContainer()
3941 self.setMainWidget(self._container)
3942 else:
3943 self._container.show()
3944
3945 url = "file://" + SimBriefSetupPage.getHTMLFilePath()
3946 self._browser = cef.startInContainer(self._container, url)
3947
3948 lifeSpanHandler = SimBriefingPage.BrowserLifeSpanHandler(self)
3949 self._browser.SetClientHandler(lifeSpanHandler)
3950
3951 def _invalidateBrowser(self):
3952 """Invalidate the browser (and associated stuff)."""
3953 self._container.hide()
3954 self._browser = None
3955
3956#-----------------------------------------------------------------------------
3957
3958class FuelTank(Gtk.VBox):
3959 """Widget for the fuel tank."""
3960 def __init__(self, fuelTank, name, capacity, currentWeight):
3961 """Construct the widget for the tank with the given name."""
3962 super(FuelTank, self).__init__()
3963
3964 self._enabled = True
3965 self.fuelTank = fuelTank
3966 self.capacity = capacity
3967 self.currentWeight = currentWeight
3968 self.expectedWeight = currentWeight
3969
3970 self._label = label = Gtk.Label("<b>" + name + "</b>")
3971 label.set_use_markup(True)
3972 label.set_use_underline(True)
3973 label.set_justify(Gtk.Justification.CENTER)
3974 label.set_alignment(0.5, 1.0)
3975
3976 self._tankFigure = Gtk.EventBox()
3977 self._tankFigure.set_size_request(38, 200)
3978 self._tankFigure.set_visible_window(False)
3979 self._tankFigure.set_tooltip_markup(xstr("fuel_tank_tooltip"))
3980
3981 self._tankFigure.connect("draw", self._drawTankFigure)
3982 self._tankFigure.connect("button_press_event", self._buttonPressed)
3983 self._tankFigure.connect("motion_notify_event", self._motionNotify)
3984
3985 self._tankFigure.add_events(Gdk.EventMask.SCROLL_MASK)
3986 self._tankFigure.connect("scroll-event", self._scrolled)
3987
3988 alignment = Gtk.Alignment(xalign = 0.5, yalign = 0.5,
3989 xscale = 0.0, yscale = 1.0)
3990 alignment.add(self._tankFigure)
3991
3992 self.pack_start(alignment, True, True, 4)
3993
3994 self._expectedButton = Gtk.SpinButton()
3995 self._expectedButton.set_numeric(True)
3996 self._expectedButton.set_range(0, self.capacity)
3997 self._expectedButton.set_increments(10, 100)
3998 self._expectedButton.set_value(currentWeight)
3999 self._expectedButton.set_alignment(1.0)
4000 self._expectedButton.set_width_chars(5)
4001 self._expectedButton.connect("value-changed", self._expectedChanged)
4002
4003 label.set_mnemonic_widget(self._expectedButton)
4004
4005 @property
4006 def label(self):
4007 """Get the label with the caption."""
4008 return self._label
4009
4010 @property
4011 def expectedButton(self):
4012 """Get the button containing the expected value."""
4013 return self._expectedButton
4014
4015 def setCurrent(self, currentWeight):
4016 """Set the current weight."""
4017 self.currentWeight = currentWeight
4018 self._redraw()
4019
4020 def isCorrect(self):
4021 """Determine if the contents of the fuel tank are as expected"""
4022 return abs(self.expectedWeight - self.currentWeight)<=1
4023
4024 def disable(self):
4025 """Disable the fuel tank."""
4026 self._expectedButton.set_sensitive(False)
4027 self._enabled = False
4028
4029 def _redraw(self):
4030 """Redraw the tank figure."""
4031 self._tankFigure.queue_draw()
4032
4033 def _drawTankFigure(self, tankFigure, eventOrContext):
4034 """Draw the tank figure."""
4035 triangleSize = 5
4036
4037 context = eventOrContext
4038 (xOffset, yOffset) = (0, 0)
4039
4040 width = tankFigure.get_allocated_width()
4041 height = tankFigure.get_allocated_height()
4042
4043 rectangleX0 = triangleSize
4044 rectangleY0 = triangleSize
4045 rectangleX1 = width - 1 - triangleSize
4046 rectangleY1 = height - 1 - triangleSize
4047 rectangleLineWidth = 2.0
4048
4049 context.set_source_rgb(0.0, 0.0, 0.0)
4050 context.set_line_width(rectangleLineWidth)
4051 context.rectangle(xOffset + rectangleX0 + rectangleLineWidth/2,
4052 yOffset + rectangleY0 + rectangleLineWidth/2,
4053 rectangleX1 - rectangleX0 - rectangleLineWidth,
4054 rectangleY1 - rectangleY0 - rectangleLineWidth)
4055 context.stroke()
4056
4057 rectangleInnerLeft = rectangleX0 + rectangleLineWidth
4058 rectangleInnerRight = rectangleX1 - rectangleLineWidth
4059 self._rectangleInnerTop = rectangleInnerTop = rectangleY0 + rectangleLineWidth
4060 self._rectangleInnerBottom = rectangleInnerBottom = rectangleY1 - rectangleLineWidth
4061
4062 rectangleInnerWidth = rectangleInnerRight - rectangleInnerLeft
4063 rectangleInnerHeight = rectangleInnerBottom - rectangleInnerTop
4064
4065 context.set_source_rgb(1.0, 0.9, 0.6)
4066 currentHeight = self.currentWeight * rectangleInnerHeight / self.capacity
4067 currentX = rectangleInnerTop + rectangleInnerHeight - currentHeight
4068 context.rectangle(xOffset + rectangleInnerLeft,
4069 yOffset + rectangleInnerTop +
4070 rectangleInnerHeight - currentHeight,
4071 rectangleInnerWidth, currentHeight)
4072 context.fill()
4073
4074 expectedHeight = self.expectedWeight * rectangleInnerHeight / self.capacity
4075 expectedY = rectangleInnerTop + rectangleInnerHeight - expectedHeight
4076
4077 context.set_line_width(1.5)
4078 context.set_source_rgb(0.0, 0.85, 0.85)
4079 context.move_to(xOffset + rectangleX0, yOffset + expectedY)
4080 context.line_to(xOffset + rectangleX1, yOffset + expectedY)
4081 context.stroke()
4082
4083 context.set_line_width(0.0)
4084 context.move_to(xOffset + 0, yOffset + expectedY - triangleSize)
4085 context.line_to(xOffset + 0, yOffset + expectedY + triangleSize)
4086 context.line_to(xOffset + rectangleX0 + 1, yOffset + expectedY)
4087 context.line_to(xOffset + 0, yOffset + expectedY - triangleSize)
4088 context.fill()
4089
4090 context.set_line_width(0.0)
4091 context.move_to(xOffset + width, yOffset + expectedY - triangleSize)
4092 context.line_to(xOffset + width, yOffset + expectedY + triangleSize)
4093 context.line_to(xOffset + rectangleX1 - 1, yOffset + expectedY)
4094 context.line_to(xOffset + width, yOffset + expectedY - triangleSize)
4095 context.fill()
4096
4097 return True
4098
4099 def _setExpectedFromY(self, y):
4100 """Set the expected weight from the given Y-coordinate."""
4101 level = (self._rectangleInnerBottom - y) / \
4102 (self._rectangleInnerBottom - self._rectangleInnerTop)
4103 level = min(1.0, max(0.0, level))
4104 self._expectedButton.set_value(level * self.capacity)
4105
4106 def _buttonPressed(self, tankFigure, event):
4107 """Called when a button is pressed in the figure.
4108
4109 The expected level will be set there."""
4110 if self._enabled and event.button==1:
4111 self._setExpectedFromY(event.y)
4112
4113 def _motionNotify(self, tankFigure, event):
4114 """Called when the mouse pointer moves within the area of a tank figure."""
4115 if self._enabled and event.state==Gdk.ModifierType.BUTTON1_MASK:
4116 self._setExpectedFromY(event.y)
4117
4118 def _scrolled(self, tankFigure, event):
4119 """Called when a scroll event is received."""
4120 if self._enabled:
4121 increment = 1 if event.state==Gdk.ModifierType.CONTROL_MASK \
4122 else 100 if event.state==Gdk.ModifierType.SHIFT_MASK \
4123 else 10 if event.state==0 else 0
4124 if increment!=0:
4125 if event.direction==Gdk.ScrollDirection.DOWN:
4126 increment *= -1
4127 self._expectedButton.spin(Gtk.SpinType.USER_DEFINED, increment)
4128
4129 def _expectedChanged(self, spinButton):
4130 """Called when the expected value has changed."""
4131 self.expectedWeight = spinButton.get_value_as_int()
4132 self._redraw()
4133
4134#-----------------------------------------------------------------------------
4135
4136class FuelPage(Page):
4137 """The page containing the fuel tank filling."""
4138 _pumpStep = 0.02
4139
4140 def __init__(self, wizard):
4141 """Construct the page."""
4142 super(FuelPage, self).__init__(wizard, "fuel",
4143 xstr("fuel_title"),
4144 xstr("fuel_help_pre") +
4145 xstr("fuel_help_post"),
4146 completedHelp = xstr("fuel_chelp"))
4147
4148 self._fuelTanks = []
4149 self._fuelTable = None
4150 self._fuelAlignment = Gtk.Alignment(xalign = 0.5, yalign = 0.5,
4151 xscale = 0.0, yscale = 1.0)
4152 self.setMainWidget(self._fuelAlignment)
4153
4154 tankData = [(tank, 2500, 3900) for tank in acft.mostFuelTanks]
4155 self._setupTanks(tankData)
4156
4157 self.addCancelFlightButton()
4158
4159 self._backButton = self.addPreviousButton(clicked = self._backClicked)
4160 self._button = self.addNextButton(clicked = self._forwardClicked)
4161
4162 self._pumpIndex = 0
4163
4164 def activate(self):
4165 """Activate the page."""
4166 self._setupTanks(self._wizard._fuelData)
4167
4168 aircraft = self._wizard.gui.flight.aircraft
4169 minLandingFuel = aircraft.minLandingFuel
4170 recommendedLandingFuel = aircraft.recommendedLandingFuel
4171
4172 middleHelp = "" if minLandingFuel is None else \
4173 (xstr("fuel_help_min") % (minLandingFuel,)) \
4174 if recommendedLandingFuel is None else \
4175 (xstr("fuel_help_min_rec") % (minLandingFuel,
4176 recommendedLandingFuel))
4177 self.setHelp(xstr("fuel_help_pre") + middleHelp + xstr("fuel_help_post"))
4178
4179 def finalize(self):
4180 """Finalize the page."""
4181 for fuelTank in self._fuelTanks:
4182 fuelTank.disable()
4183
4184 def _backClicked(self, button):
4185 """Called when the Back button is pressed."""
4186 self.goBack()
4187
4188 def _forwardClicked(self, button):
4189 """Called when the forward button is clicked."""
4190 if not self._completed:
4191 self._pumpIndex = 0
4192 self._wizard.gui.beginBusy(xstr("fuel_pump_busy"))
4193 self._pump()
4194 elif self._wizard.usingSimBrief:
4195 self._wizard.jumpPage("takeoff")
4196 else:
4197 self._wizard.jumpPage("briefing1")
4198
4199 def _setupTanks(self, tankData):
4200 """Setup the tanks for the given data."""
4201 numTanks = len(tankData)
4202 if self._fuelTable is not None:
4203 self._fuelAlignment.remove(self._fuelTable)
4204
4205 self._fuelTanks = []
4206 self._fuelTable = Gtk.Grid()
4207 self._fuelTable.set_column_homogeneous(True)
4208 self._fuelTable.set_row_spacing(4)
4209 self._fuelTable.set_column_spacing(16 if numTanks<5 else 0)
4210 index = 0
4211 for (tank, current, capacity) in tankData:
4212 fuelTank = FuelTank(tank,
4213 xstr("fuel_tank_" +
4214 const.fuelTank2string(tank)),
4215 capacity, current)
4216 self._fuelTanks.append(fuelTank)
4217
4218 alignment = Gtk.Alignment(xalign = 0.5, yalign = 1.0,
4219 xscale = 1.0, yscale = 0.0)
4220 alignment.add(fuelTank.label)
4221 self._fuelTable.attach(alignment,
4222 index*(1 if numTanks<5 else 2), 0,
4223 1 if numTanks<5 else 3, 1)
4224
4225 alignment = Gtk.Alignment(xalign = 0.5, yalign = 0.5,
4226 xscale = 0.0, yscale = 1.0)
4227 alignment.add(fuelTank)
4228 self._fuelTable.attach(alignment,
4229 index*(1 if numTanks<5 else 2) +
4230 (0 if numTanks<5 else 1), 1, 1, 1)
4231
4232
4233 alignment = Gtk.Alignment(xalign = 0.5, yalign = 0.5,
4234 xscale = 1.0, yscale = 0.0)
4235 alignment.add(fuelTank.expectedButton)
4236
4237 self._fuelTable.attach(alignment,
4238 index* (1 if numTanks<5 else 2),
4239 2 if (index%2)==0 or numTanks<5 else 3,
4240 1 if numTanks<5 else 3, 1)
4241
4242 index += 1
4243
4244 self._fuelAlignment.add(self._fuelTable)
4245 self.show_all()
4246
4247 def _pump(self):
4248 """Perform one step of pumping.
4249
4250 It is checked, if the current tank's contents are of the right
4251 quantity. If not, it is filled one step further to the desired
4252 contents. Otherwise the next tank is started. If all tanks are are
4253 filled, the next page is selected."""
4254 numTanks = len(self._fuelTanks)
4255
4256 fuelTank = None
4257 while self._pumpIndex < numTanks:
4258 fuelTank = self._fuelTanks[self._pumpIndex]
4259 if fuelTank.isCorrect():
4260 self._pumpIndex += 1
4261 fuelTank = None
4262 else:
4263 break
4264
4265 if fuelTank is None:
4266 self._wizard.gui.endBusy()
4267 if self._wizard.usingSimBrief:
4268 self._wizard.gui.startMonitoring()
4269 self._wizard.jumpPage("takeoff")
4270 else:
4271 bookedFlight = self._wizard._bookedFlight
4272 self._wizard.gui.beginBusy(xstr("route_down_notams"))
4273 self._wizard.gui.webHandler.getNOTAMs(self._notamsCallback,
4274 bookedFlight.departureICAO,
4275 bookedFlight.arrivalICAO)
4276 startSound(const.SOUND_NOTAM)
4277 else:
4278 currentLevel = fuelTank.currentWeight / fuelTank.capacity
4279 expectedLevel = fuelTank.expectedWeight / fuelTank.capacity
4280 if currentLevel<expectedLevel:
4281 currentLevel += FuelPage._pumpStep
4282 if currentLevel>expectedLevel: currentLevel = expectedLevel
4283 else:
4284 currentLevel -= FuelPage._pumpStep
4285 if currentLevel<expectedLevel: currentLevel = expectedLevel
4286 fuelTank.setCurrent(currentLevel * fuelTank.capacity)
4287 self._wizard.gui.simulator.setFuelLevel([(fuelTank.fuelTank,
4288 currentLevel)])
4289 GObject.timeout_add(50, self._pump)
4290
4291 def _notamsCallback(self, returned, result):
4292 """Callback for the NOTAMs."""
4293 GObject.idle_add(self._handleNOTAMs, returned, result)
4294
4295 def _handleNOTAMs(self, returned, result):
4296 """Handle the NOTAMs."""
4297 if returned:
4298 self._wizard._departureNOTAMs = result.departureNOTAMs
4299 self._wizard._arrivalNOTAMs = result.arrivalNOTAMs
4300 else:
4301 self._wizard._departureNOTAMs = None
4302 self._wizard._arrivalNOTAMs = None
4303
4304 bookedFlight = self._wizard._bookedFlight
4305 self._wizard.gui.beginBusy(xstr("route_down_metars"))
4306 self._wizard.gui.webHandler.getMETARs(self._metarsCallback,
4307 [bookedFlight.departureICAO,
4308 bookedFlight.arrivalICAO])
4309
4310 def _metarsCallback(self, returned, result):
4311 """Callback for the METARs."""
4312 GObject.idle_add(self._handleMETARs, returned, result)
4313
4314 def _handleMETARs(self, returned, result):
4315 """Handle the METARs."""
4316 self._wizard._departureMETAR = None
4317 self._wizard._arrivalMETAR = None
4318 bookedFlight = self._wizard._bookedFlight
4319 if returned:
4320 if bookedFlight.departureICAO in result.metars:
4321 self._wizard._departureMETAR = result.metars[bookedFlight.departureICAO]
4322 if bookedFlight.arrivalICAO in result.metars:
4323 self._wizard._arrivalMETAR = result.metars[bookedFlight.arrivalICAO]
4324
4325 self._wizard.gui.endBusy()
4326 self._backButton.set_sensitive(True)
4327 self._button.set_sensitive(True)
4328 self._wizard.nextPage()
4329
4330#-----------------------------------------------------------------------------
4331
4332class BriefingPage(Page):
4333 """Page for the briefing."""
4334 def __init__(self, wizard, departure):
4335 """Construct the briefing page."""
4336 self._departure = departure
4337
4338 number = 1 if departure else 2
4339
4340 title = xstr("briefing_title") % (number,
4341 xstr("briefing_departure")
4342 if departure
4343 else xstr("briefing_arrival"))
4344 super(BriefingPage, self).__init__(wizard,
4345 "briefing%d" % (number,),
4346 title, xstr("briefing_help"),
4347 completedHelp = xstr("briefing_chelp"))
4348
4349 alignment = Gtk.Alignment(xalign = 0.5, yalign = 0.5,
4350 xscale = 1.0, yscale = 1.0)
4351
4352 mainBox = Gtk.VBox()
4353 alignment.add(mainBox)
4354 self.setMainWidget(alignment)
4355
4356 self._notamsFrame = Gtk.Frame()
4357 self._notamsFrame.set_label(xstr("briefing_notams_init"))
4358 scrolledWindow = Gtk.ScrolledWindow()
4359 scrolledWindow.set_size_request(-1, 128)
4360 # FIXME: these constants should be in common
4361 scrolledWindow.set_policy(Gtk.PolicyType.AUTOMATIC,
4362 Gtk.PolicyType.AUTOMATIC)
4363 self._notams = Gtk.TextView()
4364 self._notams.set_editable(False)
4365 self._notams.set_accepts_tab(False)
4366 self._notams.set_wrap_mode(Gtk.WrapMode.WORD)
4367 scrolledWindow.add(self._notams)
4368 alignment = Gtk.Alignment(xalign = 0.0, yalign = 0.0,
4369 xscale = 1.0, yscale = 1.0)
4370 alignment.set_padding(padding_top = 4, padding_bottom = 0,
4371 padding_left = 0, padding_right = 0)
4372 alignment.add(scrolledWindow)
4373 self._notamsFrame.add(alignment)
4374 mainBox.pack_start(self._notamsFrame, True, True, 4)
4375
4376 self._metarFrame = Gtk.Frame()
4377 self._metarFrame.set_label(xstr("briefing_metar_init"))
4378 scrolledWindow = Gtk.ScrolledWindow()
4379 scrolledWindow.set_size_request(-1, 32)
4380 scrolledWindow.set_policy(Gtk.PolicyType.AUTOMATIC,
4381 Gtk.PolicyType.AUTOMATIC)
4382
4383 self._updatingMETAR = False
4384
4385 self._metar = Gtk.TextView()
4386 self._metar.set_accepts_tab(False)
4387 self._metar.set_wrap_mode(Gtk.WrapMode.WORD)
4388 self._metar.get_buffer().connect("changed", self._metarChanged)
4389 self._metar.get_buffer().connect_after("insert-text", self._metarInserted)
4390 scrolledWindow.add(self._metar)
4391 alignment = Gtk.Alignment(xalign = 0.0, yalign = 0.0,
4392 xscale = 1.0, yscale = 1.0)
4393 alignment.set_padding(padding_top = 4, padding_bottom = 0,
4394 padding_left = 0, padding_right = 0)
4395 alignment.add(scrolledWindow)
4396 self._metarFrame.add(alignment)
4397 mainBox.pack_start(self._metarFrame, True, True, 4)
4398 self.metarEdited = False
4399
4400 self.addCancelFlightButton()
4401
4402 self.addPreviousButton(clicked = self._backClicked)
4403 self._button = self.addNextButton(clicked = self._forwardClicked)
4404
4405 @property
4406 def metar(self):
4407 """Get the METAR on the page."""
4408 buffer = self._metar.get_buffer()
4409 return buffer.get_text(buffer.get_start_iter(),
4410 buffer.get_end_iter(), True)
4411
4412 def setMETAR(self, metar):
4413 """Set the METAR."""
4414 self._metar.get_buffer().set_text(metar)
4415 self.metarEdited = False
4416
4417 def changeMETAR(self, metar):
4418 """Change the METAR as a result of an edit on one of the other
4419 pages."""
4420 self._updatingMETAR = True
4421 self._metar.get_buffer().set_text(metar)
4422 self._updatingMETAR = False
4423
4424 self._updateButton()
4425 self.metarEdited = True
4426
4427 def activate(self):
4428 """Activate the page."""
4429 if not self._departure:
4430 self._button.set_label(xstr("briefing_button"))
4431 self._button.set_has_tooltip(False)
4432 self._button.set_use_stock(False)
4433
4434 bookedFlight = self._wizard._bookedFlight
4435
4436 icao = bookedFlight.departureICAO if self._departure \
4437 else bookedFlight.arrivalICAO
4438 notams = self._wizard._departureNOTAMs if self._departure \
4439 else self._wizard._arrivalNOTAMs
4440 metar = self._wizard._departureMETAR if self._departure \
4441 else self._wizard._arrivalMETAR
4442
4443 self._notamsFrame.set_label(xstr("briefing_notams_template") % (icao,))
4444 buffer = self._notams.get_buffer()
4445 if notams is None:
4446 buffer.set_text(xstr("briefing_notams_failed"))
4447 elif not notams:
4448 buffer.set_text(xstr("briefing_notams_missing"))
4449 else:
4450 s = ""
4451 for notam in notams:
4452 s += str(notam)
4453 s += "-------------------- * --------------------\n"
4454 buffer.set_text(s)
4455
4456 self._metarFrame.set_label(xstr("briefing_metar_template") % (icao,))
4457 buffer = self._metar.get_buffer()
4458 self._updatingMETAR = True
4459 if metar is None:
4460 buffer.set_text("")
4461 self.setHelp(xstr("briefing_help_nometar"))
4462 else:
4463 buffer.set_text(metar)
4464 self._updatingMETAR = False
4465 self._updateButton()
4466
4467 label = self._metarFrame.get_label_widget()
4468 label.set_use_underline(True)
4469 label.set_mnemonic_widget(self._metar)
4470
4471 self.metarEdited = False
4472
4473 def _backClicked(self, button):
4474 """Called when the Back button is pressed."""
4475 self.goBack()
4476
4477 def _forwardClicked(self, button):
4478 """Called when the forward button is clicked."""
4479 if not self._departure:
4480 if not self._completed:
4481 self._wizard.gui.startMonitoring()
4482 self._button.set_label(xstr("button_next"))
4483 self._button.set_tooltip_text(xstr("button_next_tooltip"))
4484 self.complete()
4485
4486 self._wizard.nextPage()
4487
4488 def _metarChanged(self, buffer):
4489 """Called when the METAR has changed."""
4490 print("BriefingPage.metarChanged", self._updatingMETAR)
4491 if not self._updatingMETAR:
4492 self.metarEdited = True
4493 self._updateButton()
4494 metar = buffer.get_text(buffer.get_start_iter(),
4495 buffer.get_end_iter(), True)
4496 self._wizard.metarChanged(metar, self)
4497
4498 def _metarInserted(self, textBuffer, iter, text, length):
4499 """Called when new characters are inserted into the METAR.
4500
4501 It uppercases all characters."""
4502 print("BriefingPage.metarInserted", self._updatingMETAR)
4503 if not self._updatingMETAR:
4504 self._updatingMETAR = True
4505
4506 iter1 = iter.copy()
4507 iter1.backward_chars(length)
4508 textBuffer.delete(iter, iter1)
4509
4510 textBuffer.insert(iter, text.upper())
4511
4512 self._updatingMETAR = False
4513
4514 def _updateButton(self):
4515 """Update the sensitivity of the Next button based on the contents of
4516 the METAR field."""
4517 buffer = self._metar.get_buffer()
4518 self._button.set_sensitive(buffer.get_text(buffer.get_start_iter(),
4519 buffer.get_end_iter(),
4520 True)!="")
4521
4522
4523#-----------------------------------------------------------------------------
4524
4525class TakeoffPage(Page):
4526 """Page for entering the takeoff data."""
4527 def __init__(self, wizard):
4528 """Construct the takeoff page."""
4529 super(TakeoffPage, self).__init__(wizard, "takeoff",
4530 xstr("takeoff_title"),
4531 xstr("takeoff_help"),
4532 completedHelp = xstr("takeoff_chelp"))
4533
4534 self._forwardAllowed = False
4535
4536 alignment = Gtk.Alignment(xalign = 0.5, yalign = 0.5,
4537 xscale = 0.0, yscale = 0.0)
4538
4539 table = Gtk.Table(9, 24)
4540 table.set_row_spacings(4)
4541 table.set_col_spacings(16)
4542 table.set_homogeneous(False)
4543 alignment.add(table)
4544 self.setMainWidget(alignment)
4545
4546 row = 0
4547
4548 label = Gtk.Label(xstr("takeoff_metar"))
4549 label.set_use_underline(True)
4550 label.set_alignment(0.0, 0.5)
4551 table.attach(label, 0, 1, row, row+1)
4552
4553 self._metar = Gtk.Entry()
4554 self._metar.set_width_chars(40)
4555 self._metar.set_tooltip_text(xstr("takeoff_metar_tooltip"))
4556 self._metar.connect("changed", self._metarChanged)
4557 self._metar.get_buffer().connect_after("inserted-text", self._metarInserted)
4558 table.attach(self._metar, 1, 24, row, row+1)
4559 label.set_mnemonic_widget(self._metar)
4560
4561 self._updatingMETAR = False
4562
4563 row += 1
4564
4565 label = Gtk.Label(xstr("takeoff_runway"))
4566 label.set_use_underline(True)
4567 label.set_alignment(0.0, 0.5)
4568 table.attach(label, 0, 1, row, row+1)
4569
4570 self._runway = Gtk.Entry()
4571 self._runway.set_width_chars(10)
4572 self._runway.set_tooltip_text(xstr("takeoff_runway_tooltip"))
4573 self._runway.connect("changed", self._upperChanged)
4574 table.attach(self._runway, 1, 3, row, row+1)
4575 label.set_mnemonic_widget(self._runway)
4576
4577 row += 1
4578
4579 label = Gtk.Label(xstr("takeoff_sid"))
4580 label.set_use_underline(True)
4581 label.set_alignment(0.0, 0.5)
4582 table.attach(label, 0, 1, row, row+1)
4583
4584 self._sid = Gtk.ComboBox.new_with_model_and_entry(comboModel)
4585
4586 self._sid.set_entry_text_column(0)
4587 self._sid.get_child().set_width_chars(10)
4588 self._sid.set_tooltip_text(xstr("takeoff_sid_tooltip"))
4589 self._sid.connect("changed", self._upperChangedComboBox)
4590 table.attach(self._sid, 1, 3, row, row+1)
4591 label.set_mnemonic_widget(self._sid)
4592
4593 row += 1
4594
4595 label = Gtk.Label(xstr("takeoff_v1"))
4596 label.set_use_markup(True)
4597 label.set_use_underline(True)
4598 label.set_alignment(0.0, 0.5)
4599 table.attach(label, 0, 1, row, row+1)
4600
4601 self._v1 = IntegerEntry()
4602 self._v1.set_width_chars(4)
4603 self._v1.set_tooltip_markup(xstr("takeoff_v1_tooltip_knots"))
4604 self._v1.connect("integer-changed", self._valueChanged)
4605 table.attach(self._v1, 2, 3, row, row+1)
4606 label.set_mnemonic_widget(self._v1)
4607
4608 self._v1Unit = Gtk.Label(xstr("label_knots"))
4609 self._v1Unit.set_alignment(0.0, 0.5)
4610 table.attach(self._v1Unit, 3, 4, row, row+1)
4611
4612 row += 1
4613
4614 label = Gtk.Label(xstr("takeoff_vr"))
4615 label.set_use_markup(True)
4616 label.set_use_underline(True)
4617 label.set_alignment(0.0, 0.5)
4618 table.attach(label, 0, 1, row, row+1)
4619
4620 self._vr = IntegerEntry()
4621 self._vr.set_width_chars(4)
4622 self._vr.set_tooltip_markup(xstr("takeoff_vr_tooltip_knots"))
4623 self._vr.connect("integer-changed", self._valueChanged)
4624 table.attach(self._vr, 2, 3, row, row+1)
4625 label.set_mnemonic_widget(self._vr)
4626
4627 self._vrUnit = Gtk.Label(xstr("label_knots"))
4628 self._vrUnit.set_alignment(0.0, 0.5)
4629 table.attach(self._vrUnit, 3, 4, row, row+1)
4630
4631 row += 1
4632
4633 label = Gtk.Label(xstr("takeoff_v2"))
4634 label.set_use_markup(True)
4635 label.set_use_underline(True)
4636 label.set_alignment(0.0, 0.5)
4637 table.attach(label, 0, 1, row, row+1)
4638
4639 self._v2 = IntegerEntry()
4640 self._v2.set_width_chars(4)
4641 self._v2.set_tooltip_markup(xstr("takeoff_v2_tooltip_knots"))
4642 self._v2.connect("integer-changed", self._valueChanged)
4643 table.attach(self._v2, 2, 3, row, row+1)
4644 label.set_mnemonic_widget(self._v2)
4645
4646 self._v2Unit = Gtk.Label(xstr("label_knots"))
4647 self._v2Unit.set_alignment(0.0, 0.5)
4648 table.attach(self._v2Unit, 3, 4, row, row+1)
4649
4650 row += 1
4651
4652 self._derateType = acft.DERATE_NONE
4653
4654 self._derateLabel = Gtk.Label()
4655 self._derateLabel.set_use_underline(True)
4656 self._derateLabel.set_markup(xstr("takeoff_derate_tupolev"))
4657 self._derateLabel.set_alignment(0.0, 0.5)
4658 table.attach(self._derateLabel, 0, 1, row, row+1)
4659
4660 self._derate = Gtk.Alignment()
4661 table.attach(self._derate, 2, 4, row, row+1)
4662 self._derateWidget = None
4663 self._derateEntry = None
4664 self._derateUnit = None
4665 self._derateButtons = None
4666
4667 row += 1
4668
4669 self._antiIceOn = Gtk.CheckButton(xstr("takeoff_antiice"))
4670 self._antiIceOn.set_use_underline(True)
4671 self._antiIceOn.set_tooltip_text(xstr("takeoff_antiice_tooltip"))
4672 table.attach(self._antiIceOn, 2, 4, row, row+1)
4673
4674 row += 1
4675
4676 self._rto = Gtk.CheckButton(xstr("takeoff_rto"))
4677 self._rto.set_use_underline(True)
4678 self._rto.set_tooltip_text(xstr("takeoff_rto_tooltip"))
4679 self._rto.connect("toggled", self._rtoToggled)
4680 table.attach(self._rto, 2, 4, row, row+1, ypadding = 8)
4681
4682 self.addCancelFlightButton()
4683
4684 self.addPreviousButton(clicked = self._backClicked)
4685
4686 self._button = self.addNextButton(clicked = self._forwardClicked)
4687
4688 self._active = False
4689
4690 @property
4691 def runway(self):
4692 """Get the runway."""
4693 return self._runway.get_text()
4694
4695 @property
4696 def sid(self):
4697 """Get the SID."""
4698 text = self._sid.get_child().get_text()
4699 return text if self._sid.get_active()!=0 and text and text!="N/A" \
4700 else None
4701
4702 @property
4703 def v1(self):
4704 """Get the v1 speed."""
4705 return self._v1.get_int()
4706
4707 @property
4708 def vr(self):
4709 """Get the vr speed."""
4710 return self._vr.get_int()
4711
4712 @property
4713 def v2(self):
4714 """Get the v2 speed."""
4715 return self._v2.get_int()
4716
4717 @property
4718 def derate(self):
4719 """Get the derate value, if any."""
4720 if self._derateWidget is None:
4721 return None
4722 if self._derateType==acft.DERATE_BOEING:
4723 derate = self._derateEntry.get_text()
4724 return derate if derate else None
4725 elif self._derateType==acft.DERATE_EPR:
4726 derate = self._derateWidget.get_text()
4727 return derate if derate else None
4728 elif self._derateType==acft.DERATE_TUPOLEV:
4729 return acft.DERATE_TUPOLEV_NOMINAL \
4730 if self._derateButtons[0].get_active() \
4731 else acft.DERATE_TUPOLEV_TAKEOFF
4732 elif self._derateType==acft.DERATE_B462:
4733 return self._derateWidget.get_active()
4734 else:
4735 return None
4736
4737 @property
4738 def antiIceOn(self):
4739 """Get whether the anti-ice system has been turned on."""
4740 return self._antiIceOn.get_active()
4741
4742 @antiIceOn.setter
4743 def antiIceOn(self, value):
4744 """Set the anti-ice indicator."""
4745 self._antiIceOn.set_active(value)
4746
4747 @property
4748 def rtoIndicated(self):
4749 """Get whether the pilot has indicated if there was an RTO."""
4750 return self._rto.get_active()
4751
4752 def activate(self):
4753 """Activate the page."""
4754 print("TakeoffPage.activate")
4755
4756 self._updatingMETAR = True
4757 self._metar.get_buffer().set_text(self._wizard.departureMETAR, -1)
4758 self._updatingMETAR = False
4759
4760 if self._wizard.takeoffRunway is None:
4761 self._runway.set_text("")
4762 else:
4763 self._runway.set_text(self._wizard.takeoffRunway)
4764 self._runway.set_sensitive(True)
4765 self._sid.set_active(0)
4766 self._sid.set_sensitive(True)
4767 self._v1.set_int(None)
4768 self._v1.set_sensitive(True)
4769 self._vr.set_int(None)
4770 self._vr.set_sensitive(True)
4771 self._v2.set_int(None)
4772 self._v2.set_sensitive(True)
4773
4774 i18nSpeedUnit = self._wizard.gui.flight.getI18NSpeedUnit()
4775 speedUnit = xstr("label" + i18nSpeedUnit)
4776 self._v1Unit.set_text(speedUnit)
4777 self._vrUnit.set_text(speedUnit)
4778 self._v2Unit.set_text(speedUnit)
4779
4780 self._v1.set_tooltip_markup(xstr("takeoff_v1_tooltip" + i18nSpeedUnit))
4781 self._vr.set_tooltip_markup(xstr("takeoff_vr_tooltip" + i18nSpeedUnit))
4782 self._v2.set_tooltip_markup(xstr("takeoff_v2_tooltip" + i18nSpeedUnit))
4783
4784 self._derateType = self._wizard.gui.flight.aircraft.derateType
4785
4786 self._setupDerateWidget()
4787
4788 self._rto.set_active(False)
4789 self._rto.set_sensitive(False)
4790
4791 self._button.set_sensitive(False)
4792 self._forwardAllowed = False
4793
4794 self._active = True
4795
4796 def allowForward(self):
4797 """Allow going to the next page."""
4798 print("TakeoffPage.allowForward")
4799 self._forwardAllowed = True
4800 self._updateForwardButton()
4801
4802 def reset(self):
4803 """Reset the page if the wizard is reset."""
4804 print("TakeoffPage.reset")
4805
4806 super(TakeoffPage, self).reset()
4807 self._v1.reset()
4808 self._vr.reset()
4809 self._v2.reset()
4810 self._hasDerate = False
4811 self._antiIceOn.set_active(False)
4812 self._active = False
4813
4814 def setRTOEnabled(self, enabled):
4815 """Set the RTO checkbox enabled or disabled."""
4816 if not enabled:
4817 self._rto.set_active(False)
4818 self._rto.set_sensitive(enabled)
4819
4820 def changeMETAR(self, metar):
4821 """Change the METAR as a result of an edit on one of the other
4822 pages."""
4823 if self._active:
4824 print("TakeoffPage.changeMETAR")
4825 self._updatingMETAR = True
4826 self._metar.get_buffer().set_text(metar, -1)
4827 self._updatingMETAR = False
4828
4829 self._updateForwardButton()
4830
4831 def _updateForwardButton(self):
4832 """Update the sensitivity of the forward button based on some conditions."""
4833 sensitive = self._forwardAllowed and \
4834 self._metar.get_text()!="" and \
4835 self._runway.get_text()!="" and \
4836 self.sid is not None and \
4837 self.v1 is not None and \
4838 self.vr is not None and \
4839 self.v2 is not None and \
4840 self.v1 <= self.vr and \
4841 self.vr <= self.v2 and \
4842 (self._derateType==acft.DERATE_NONE or
4843 self.derate is not None)
4844
4845 print("TakeoffPage._updateForwardButton: forwardAllowed:", self._forwardAllowed, ", sensitive:", sensitive)
4846 if self._forwardAllowed:
4847 print(" METAR: ", self._metar.get_text())
4848 print(" runway: ", self._runway.get_text())
4849 print(" SID:", self.sid)
4850 print(" V1:", self.v1)
4851 print(" VR:", self.vr)
4852 print(" V2:", self.v2)
4853 print(" derateType:", self._derateType)
4854 print(" derate:", self.derate)
4855
4856 self._button.set_sensitive(sensitive)
4857
4858 def _valueChanged(self, widget, arg = None):
4859 """Called when the value of some widget has changed."""
4860 print("TakeoffPage._valueChanged")
4861
4862 self._updateForwardButton()
4863
4864 def _upperChanged(self, entry, arg = None):
4865 """Called when the value of some entry widget has changed and the value
4866 should be converted to uppercase."""
4867 print("TakeoffPage._upperChanged")
4868 entry.set_text(entry.get_text().upper())
4869 self._valueChanged(entry, arg)
4870
4871 def _upperChangedComboBox(self, comboBox):
4872 """Called for combo box widgets that must be converted to uppercase."""
4873 entry = comboBox.get_child()
4874 if comboBox.get_active()==-1:
4875 entry.set_text(entry.get_text().upper())
4876 self._valueChanged(entry)
4877
4878 def _derateChanged(self, entry):
4879 """Called when the value of the derate is changed."""
4880 print("TakeoffPage._derateChanged")
4881 self._updateForwardButton()
4882
4883 def _rtoToggled(self, button):
4884 """Called when the RTO check button is toggled."""
4885 self._wizard.rtoToggled(button.get_active())
4886
4887 def _backClicked(self, button):
4888 """Called when the Back button is pressed."""
4889 self.goBack()
4890
4891 def _forwardClicked(self, button):
4892 """Called when the forward button is clicked."""
4893 aircraft = self._wizard.gui.flight.aircraft
4894 aircraft.updateV1R2()
4895 if self.derate is not None:
4896 aircraft.updateDerate()
4897 aircraft.updateTakeoffAntiIce()
4898 self._wizard.nextPage()
4899
4900 def _setupDerateWidget(self):
4901 """Setup the derate widget."""
4902 if self._derateWidget is not None:
4903 self._derate.remove(self._derateWidget)
4904
4905 if self._derateType==acft.DERATE_BOEING:
4906 self._derateLabel.set_text(xstr("takeoff_derate_boeing"))
4907 self._derateLabel.set_use_underline(True)
4908 self._derateLabel.set_sensitive(True)
4909
4910 self._derateEntry = Gtk.Entry()
4911 self._derateEntry.set_width_chars(7)
4912 self._derateEntry.set_tooltip_text(xstr("takeoff_derate_boeing_tooltip"))
4913 self._derateEntry.set_alignment(1.0)
4914 self._derateEntry.connect("changed", self._derateChanged)
4915 self._derateLabel.set_mnemonic_widget(self._derateEntry)
4916
4917 self._derateUnit = Gtk.Label("%")
4918 self._derateUnit.set_alignment(0.0, 0.5)
4919
4920 self._derateWidget = Gtk.Table(3, 1)
4921 self._derateWidget.set_row_spacings(4)
4922 self._derateWidget.set_col_spacings(16)
4923 self._derateWidget.set_homogeneous(False)
4924
4925 self._derateWidget.attach(self._derateEntry, 0, 2, 0, 1)
4926 self._derateWidget.attach(self._derateUnit, 2, 3, 0, 1)
4927
4928 self._derate.add(self._derateWidget)
4929 elif self._derateType==acft.DERATE_EPR:
4930 self._derateLabel.set_text("_EPR:")
4931 self._derateLabel.set_use_underline(True)
4932 self._derateLabel.set_sensitive(True)
4933
4934 self._derateWidget = Gtk.Entry()
4935 self._derateWidget.set_width_chars(7)
4936 self._derateWidget.set_tooltip_text(xstr("takeoff_derate_epr_tooltip"))
4937 self._derateWidget.set_alignment(1.0)
4938 self._derateWidget.connect("changed", self._derateChanged)
4939 self._derateLabel.set_mnemonic_widget(self._derateWidget)
4940
4941 self._derate.add(self._derateWidget)
4942 elif self._derateType==acft.DERATE_TUPOLEV:
4943 self._derateLabel.set_text(xstr("takeoff_derate_tupolev"))
4944 self._derateLabel.set_use_underline(True)
4945 self._derateLabel.set_sensitive(True)
4946
4947 nominal = Gtk.RadioButton.\
4948 new_with_label_from_widget(None,
4949 xstr("takeoff_derate_tupolev_nominal"))
4950 nominal.set_use_underline(True)
4951 nominal.set_tooltip_text(xstr("takeoff_derate_tupolev_nominal_tooltip"))
4952 nominal.connect("toggled", self._derateChanged)
4953
4954 takeoff = Gtk.RadioButton.\
4955 new_with_label_from_widget(nominal,
4956 xstr("takeoff_derate_tupolev_takeoff"))
4957
4958 takeoff.set_use_underline(True)
4959 takeoff.set_tooltip_text(xstr("takeoff_derate_tupolev_takeoff_tooltip"))
4960 takeoff.connect("toggled", self._derateChanged)
4961
4962 self._derateButtons = [nominal, takeoff]
4963
4964 self._derateWidget = Gtk.HBox()
4965 self._derateWidget.pack_start(nominal, False, False, 4)
4966 self._derateWidget.pack_start(takeoff, False, False, 4)
4967
4968 self._derate.add(self._derateWidget)
4969 elif self._derateType==acft.DERATE_B462:
4970 self._derateLabel.set_text("")
4971
4972 self._derateWidget = Gtk.CheckButton(xstr("takeoff_derate_b462"))
4973 self._derateWidget.set_tooltip_text(xstr("takeoff_derate_b462_tooltip"))
4974 self._derateWidget.set_use_underline(True)
4975 self._derate.add(self._derateWidget)
4976 else:
4977 self._derateWidget = None
4978 self._derateLabel.set_text("")
4979 self._derateLabel.set_sensitive(False)
4980
4981 def _metarChanged(self, entry):
4982 """Called when the METAR has changed."""
4983 print("TakeoffPage.metarChanged", self._updatingMETAR)
4984 if not self._updatingMETAR:
4985 self._updateForwardButton()
4986 self._wizard.metarChanged(entry.get_text(), self)
4987
4988 def _metarInserted(self, buffer, position, text, length):
4989 """Called when new characters are inserted into the METAR.
4990
4991 It uppercases all characters."""
4992 print("TakeoffPage.metarInserted", self._updatingMETAR)
4993 if not self._updatingMETAR:
4994 self._updatingMETAR = True
4995
4996 buffer.delete_text(position, length)
4997 buffer.insert_text(position, text.upper(), length)
4998
4999 self._updatingMETAR = False
5000
5001#-----------------------------------------------------------------------------
5002
5003class CruisePage(Page):
5004 """The page containing the flight level that might change during flight."""
5005 def __init__(self, wizard):
5006 """Construct the page."""
5007 super(CruisePage, self).__init__(wizard, "cruise",
5008 xstr("cruise_title"),
5009 xstr("cruise_help"))
5010
5011 self._loggable = False
5012 self._loggedCruiseLevel = 240
5013 self._activated = False
5014
5015 alignment = Gtk.Alignment(xalign = 0.5, yalign = 0.0,
5016 xscale = 0.0, yscale = 1.0)
5017
5018 mainBox = Gtk.VBox()
5019 alignment.add(mainBox)
5020 self.setMainWidget(alignment)
5021
5022 alignment = Gtk.Alignment(xalign = 0.0, yalign = 0.0,
5023 xscale = 0.0, yscale = 0.0)
5024 mainBox.pack_start(alignment, False, False, 16)
5025
5026 levelBox = Gtk.HBox()
5027
5028 label = Gtk.Label(xstr("route_level"))
5029 label.set_use_underline(True)
5030 levelBox.pack_start(label, True, True, 0)
5031
5032 self._cruiseLevel = Gtk.SpinButton()
5033 self._cruiseLevel.set_increments(step = 10, page = 100)
5034 self._cruiseLevel.set_range(min = 50, max = 500)
5035 self._cruiseLevel.set_tooltip_text(xstr("cruise_route_level_tooltip"))
5036 self._cruiseLevel.set_numeric(True)
5037 self._cruiseLevel.connect("value-changed", self._cruiseLevelChanged)
5038 label.set_mnemonic_widget(self._cruiseLevel)
5039
5040 levelBox.pack_start(self._cruiseLevel, False, False, 8)
5041
5042 self._updateButton = Gtk.Button(xstr("cruise_route_level_update"));
5043 self._updateButton.set_use_underline(True)
5044 self._updateButton.set_tooltip_text(xstr("cruise_route_level_update_tooltip"))
5045 self._updateButton.connect("clicked", self._updateButtonClicked)
5046
5047 levelBox.pack_start(self._updateButton, False, False, 16)
5048
5049 mainBox.pack_start(levelBox, False, False, 0)
5050
5051 alignment = Gtk.Alignment(xalign = 0.0, yalign = 0.0,
5052 xscale = 0.0, yscale = 1.0)
5053 mainBox.pack_start(alignment, True, True, 0)
5054
5055 self.addCancelFlightButton()
5056
5057 self._backButton = self.addPreviousButton(clicked = self._backClicked)
5058 self._button = self.addNextButton(clicked = self._forwardClicked)
5059
5060 @property
5061 def activated(self):
5062 """Determine if the page is already activated or not."""
5063 return self._activated
5064
5065 @property
5066 def cruiseLevel(self):
5067 """Get the cruise level."""
5068 return self._loggedCruiseLevel
5069
5070 @property
5071 def loggableCruiseLevel(self):
5072 """Get the cruise level which should be logged."""
5073 return self._cruiseLevel.get_value_as_int()
5074
5075 def setLoggable(self, loggable):
5076 """Set whether the cruise altitude can be logged."""
5077 self._loggable = loggable
5078 self._updateButtons()
5079
5080 def activate(self):
5081 """Setup the route from the booked flight."""
5082 self._loggedCruiseLevel = self._wizard.filedCruiseLevel
5083 self._cruiseLevel.set_value(self._loggedCruiseLevel)
5084 self._activated = True
5085
5086 def reset(self):
5087 """Reset the page."""
5088 self._loggable = False
5089 self._activated = False
5090 super(CruisePage, self).reset()
5091
5092 def _updateButtons(self):
5093 """Update the sensitivity of the buttons."""
5094 self._updateButton.set_sensitive(self._loggable and
5095 self.loggableCruiseLevel!=
5096 self._loggedCruiseLevel)
5097
5098 def _cruiseLevelChanged(self, spinButton):
5099 """Called when the cruise level has changed."""
5100 self._updateButtons()
5101
5102 def _updateButtonClicked(self, button):
5103 """Called when the update button is clicked."""
5104 if self._wizard.cruiseLevelChanged():
5105 self._loggedCruiseLevel = self.loggableCruiseLevel
5106 self._updateButtons()
5107
5108 def _backClicked(self, button):
5109 """Called when the Back button is pressed."""
5110 self.goBack()
5111
5112 def _forwardClicked(self, button):
5113 """Called when the Forward button is clicked."""
5114 self._wizard.nextPage()
5115
5116#-----------------------------------------------------------------------------
5117
5118class LandingPage(Page):
5119 """Page for entering landing data."""
5120 def __init__(self, wizard):
5121 """Construct the landing page."""
5122 super(LandingPage, self).__init__(wizard, "landing",
5123 xstr("landing_title"),
5124 xstr("landing_help"),
5125 completedHelp = xstr("landing_chelp"))
5126
5127 self._flightEnded = False
5128
5129 alignment = Gtk.Alignment(xalign = 0.5, yalign = 0.5,
5130 xscale = 0.0, yscale = 0.0)
5131
5132 table = Gtk.Table(7, 24)
5133 table.set_row_spacings(4)
5134 table.set_col_spacings(16)
5135 table.set_homogeneous(False)
5136 alignment.add(table)
5137 self.setMainWidget(alignment)
5138
5139 row = 0
5140
5141 label = Gtk.Label(xstr("landing_metar"))
5142 label.set_use_underline(True)
5143 label.set_alignment(0.0, 0.5)
5144 table.attach(label, 1, 2, row, row+1)
5145
5146 self._metar = Gtk.Entry()
5147 self._metar.set_width_chars(40)
5148 self._metar.set_tooltip_text(xstr("landing_metar_tooltip"))
5149 self._metar.connect("changed", self._metarChanged)
5150 self._metar.get_buffer().connect_after("inserted-text", self._metarInserted)
5151 table.attach(self._metar, 2, 24, row, row+1)
5152 label.set_mnemonic_widget(self._metar)
5153
5154 self._updatingMETAR = False
5155
5156 row += 1
5157
5158 label = Gtk.Label(xstr("landing_star"))
5159 label.set_use_underline(True)
5160 label.set_alignment(0.0, 0.5)
5161 table.attach(label, 1, 2, row, row + 1)
5162
5163 self._star = Gtk.ComboBox.new_with_model_and_entry(comboModel)
5164
5165 self._star.set_entry_text_column(0)
5166 self._star.get_child().set_width_chars(10)
5167 self._star.set_tooltip_text(xstr("landing_star_tooltip"))
5168 self._star.connect("changed", self._upperChangedComboBox)
5169 self._star.set_sensitive(False)
5170 table.attach(self._star, 2, 4, row, row + 1)
5171 label.set_mnemonic_widget(self._star)
5172
5173 row += 1
5174
5175 label = Gtk.Label(xstr("landing_transition"))
5176 label.set_use_underline(True)
5177 label.set_alignment(0.0, 0.5)
5178 table.attach(label, 1, 2, row, row + 1)
5179
5180 self._transition = Gtk.ComboBox.new_with_model_and_entry(comboModel)
5181
5182 self._transition.set_entry_text_column(0)
5183 self._transition.get_child().set_width_chars(10)
5184 self._transition.set_tooltip_text(xstr("landing_transition_tooltip"))
5185 self._transition.connect("changed", self._upperChangedComboBox)
5186 self._transition.set_sensitive(False)
5187 table.attach(self._transition, 2, 4, row, row + 1)
5188 label.set_mnemonic_widget(self._transition)
5189
5190 row += 1
5191
5192 label = Gtk.Label(xstr("landing_runway"))
5193 label.set_use_underline(True)
5194 label.set_alignment(0.0, 0.5)
5195 table.attach(label, 1, 2, row, row + 1)
5196
5197 self._runway = Gtk.Entry()
5198 self._runway.set_width_chars(10)
5199 self._runway.set_tooltip_text(xstr("landing_runway_tooltip"))
5200 self._runway.connect("changed", self._upperChanged)
5201 table.attach(self._runway, 2, 4, row, row + 1)
5202 label.set_mnemonic_widget(self._runway)
5203
5204 row += 1
5205
5206 label = Gtk.Label(xstr("landing_approach"))
5207 label.set_use_underline(True)
5208 label.set_alignment(0.0, 0.5)
5209 table.attach(label, 1, 2, row, row + 1)
5210
5211 self._approachType = Gtk.Entry()
5212 self._approachType.set_width_chars(10)
5213 self._approachType.set_tooltip_text(xstr("landing_approach_tooltip"))
5214 self._approachType.connect("changed", self._upperChanged)
5215 table.attach(self._approachType, 2, 4, row, row + 1)
5216 label.set_mnemonic_widget(self._approachType)
5217
5218 row += 1
5219
5220 label = Gtk.Label(xstr("landing_vref"))
5221 label.set_use_markup(True)
5222 label.set_use_underline(True)
5223 label.set_alignment(0.0, 0.5)
5224 table.attach(label, 1, 2, row, row + 1)
5225
5226 self._vref = IntegerEntry()
5227 self._vref.set_width_chars(5)
5228 self._vref.set_tooltip_markup(xstr("landing_vref_tooltip_knots"))
5229 self._vref.connect("integer-changed", self._vrefChanged)
5230 table.attach(self._vref, 3, 4, row, row + 1)
5231 label.set_mnemonic_widget(self._vref)
5232
5233 self._vrefUnit = Gtk.Label(xstr("label_knots"))
5234 table.attach(self._vrefUnit, 4, 5, row, row + 1)
5235
5236 row += 1
5237
5238 self._antiIceOn = Gtk.CheckButton(xstr("landing_antiice"))
5239 self._antiIceOn.set_use_underline(True)
5240 self._antiIceOn.set_tooltip_text(xstr("landing_antiice_tooltip"))
5241 table.attach(self._antiIceOn, 3, 5, row, row + 1)
5242
5243 self.addCancelFlightButton()
5244
5245 self.addPreviousButton(clicked = self._backClicked)
5246
5247 self._button = self.addNextButton(clicked = self._forwardClicked)
5248
5249 self._active = False
5250
5251 @property
5252 def star(self):
5253 """Get the STAR or None if none entered."""
5254 text = self._star.get_child().get_text()
5255 return text if self._star.get_active()!=0 and text and text!="N/A" \
5256 else None
5257
5258 @property
5259 def transition(self):
5260 """Get the transition or None if none entered."""
5261 text = self._transition.get_child().get_text()
5262 return text if self._transition.get_active()!=0 and text and text!="N/A" \
5263 else None
5264
5265 @property
5266 def approachType(self):
5267 """Get the approach type."""
5268 return self._approachType.get_text()
5269
5270 @property
5271 def runway(self):
5272 """Get the runway."""
5273 return self._runway.get_text()
5274
5275 @property
5276 def vref(self):
5277 """Return the landing reference speed."""
5278 return self._vref.get_int()
5279
5280 @property
5281 def antiIceOn(self):
5282 """Get whether the anti-ice system has been turned on."""
5283 return self._antiIceOn.get_active()
5284
5285 @antiIceOn.setter
5286 def antiIceOn(self, value):
5287 """Set the anti-ice indicator."""
5288 self._antiIceOn.set_active(value)
5289
5290 def reset(self):
5291 """Reset the page if the wizard is reset."""
5292 super(LandingPage, self).reset()
5293 self._vref.reset()
5294 self._antiIceOn.set_active(False)
5295 self._flightEnded = False
5296 self._active = False
5297
5298 def activate(self):
5299 """Called when the page is activated."""
5300 self._updatingMETAR = True
5301 self._metar.get_buffer().set_text(self._wizard.arrivalMETAR, -1)
5302 self._updatingMETAR = False
5303
5304 self._star.set_active(0)
5305 self._star.set_sensitive(True)
5306
5307 self._transition.set_active(0)
5308 self._transition.set_sensitive(True)
5309
5310 if self._wizard.landingRunway is None:
5311 self._runway.set_text("")
5312 else:
5313 self._runway.set_text(self._wizard.landingRunway)
5314 self._runway.set_sensitive(True)
5315
5316 self._approachType.set_text("")
5317 self._approachType.set_sensitive(True)
5318
5319 self._vref.set_int(None)
5320 self._vref.set_sensitive(True)
5321
5322 i18nSpeedUnit = self._wizard.gui.flight.getI18NSpeedUnit()
5323 speedUnit = xstr("label" + i18nSpeedUnit)
5324 self._vrefUnit.set_text(speedUnit)
5325
5326 self._vref.set_tooltip_markup(xstr("landing_vref_tooltip" +
5327 i18nSpeedUnit))
5328
5329 self._updateForwardButton()
5330
5331 self._active = True
5332
5333 def flightEnded(self):
5334 """Called when the flight has ended."""
5335 super(LandingPage, self).flightEnded()
5336 self._flightEnded = True
5337 self._updateForwardButton()
5338
5339 def changeMETAR(self, metar):
5340 """Change the METAR as a result of an edit on one of the other
5341 pages."""
5342 if self._active:
5343 print("LandingPage.changeMETAR")
5344 self._updatingMETAR = True
5345 self._metar.get_buffer().set_text(metar, -1)
5346 self._updatingMETAR = False
5347
5348 self._updateForwardButton()
5349
5350 def _updateForwardButton(self):
5351 """Update the sensitivity of the forward button."""
5352 sensitive = self._flightEnded and \
5353 self._metar.get_text()!="" and \
5354 (self.star is not None or
5355 self.transition is not None) and \
5356 self._runway.get_text()!="" and \
5357 self._approachType.get_text()!="" and \
5358 self.vref is not None
5359 self._button.set_sensitive(sensitive)
5360
5361 def _upperChanged(self, entry):
5362 """Called for entry widgets that must be converted to uppercase."""
5363 entry.set_text(entry.get_text().upper())
5364 self._updateForwardButton()
5365
5366 def _upperChangedComboBox(self, comboBox):
5367 """Called for combo box widgets that must be converted to uppercase."""
5368 if comboBox.get_active()==-1:
5369 entry = comboBox.get_child()
5370 entry.set_text(entry.get_text().upper())
5371 self._updateForwardButton()
5372
5373 def _vrefChanged(self, widget, value):
5374 """Called when the Vref has changed."""
5375 self._updateForwardButton()
5376
5377 def _backClicked(self, button):
5378 """Called when the Back button is pressed."""
5379 self.goBack()
5380
5381 def _forwardClicked(self, button):
5382 """Called when the forward button is clicked."""
5383 wizard = self._wizard
5384
5385 aircraft = wizard.gui.flight.aircraft
5386 aircraft.updateVRef()
5387 aircraft.updateLandingAntiIce()
5388 if wizard.gui.config.onlineGateSystem and \
5389 wizard.loggedIn and not self._completed and \
5390 wizard.bookedFlight.arrivalICAO=="LHBP" and \
5391 not wizard.entranceExam:
5392 wizard.getFleet(callback = self._fleetRetrieved, force = True)
5393 elif wizard.entranceExam:
5394 self._handleEntranceExamDone()
5395 else:
5396 wizard.nextPage()
5397
5398 def _fleetRetrieved(self, fleet):
5399 """Callback for the fleet retrieval."""
5400 self._wizard.nextPage()
5401
5402 def _metarChanged(self, entry):
5403 """Called when the METAR has changed."""
5404 print("LandingPage.metarChanged", self._updatingMETAR)
5405 if not self._updatingMETAR:
5406 self._updateForwardButton()
5407 self._wizard.metarChanged(entry.get_text(), self)
5408
5409 def _metarInserted(self, buffer, position, text, length):
5410 """Called when new characters are inserted into the METAR.
5411
5412 It uppercases all characters."""
5413 print("LandingPage.metarInserted", self._updatingMETAR)
5414 if not self._updatingMETAR:
5415 self._updatingMETAR = True
5416
5417 buffer.delete_text(position, length)
5418 buffer.insert_text(position, text.upper(), length)
5419
5420 self._updatingMETAR = False
5421
5422 def _handleEntranceExamDone(self):
5423 """Handle the end of the entrance exam.
5424
5425 If the there was a NO-GO fault, notify the user that exam is a failure
5426 and take them back to the student page. Otherwise congratulate, update
5427 the database to reflect that the exam has been taken and go back to the
5428 student page."""
5429 self._wizard.jumpPage("chkfinish")
5430
5431#-----------------------------------------------------------------------------
5432
5433class PIREPSaveHelper(object):
5434 """A helper to use for saving PIREPs."""
5435 def __init__(self, wizard):
5436 """Construct the helper."""
5437 super(PIREPSaveHelper, self).__init__()
5438
5439 self._wizard = wizard
5440
5441 self._lastSavePath = None
5442 self._savePIREPDialog = None
5443
5444 def addButton(self, page):
5445 """Add a button to save the PIREP to the given page."""
5446 return page.addButton(xstr("finish_save"), sensitive = False,
5447 clicked = self._saveClicked,
5448 tooltip = xstr("finish_save_tooltip"),
5449 clickedArg = page)
5450
5451 def autoSavePIREP(self, page):
5452 """Perform the automatic saving of the PIREP."""
5453 self._lastSavePath = os.path.join(self._wizard.gui.config.pirepDirectory,
5454 self._getDefaultPIREPName())
5455 self._lastSavePath = self._lastSavePath
5456 self._savePIREP(page, automatic = True)
5457
5458 def _getDefaultPIREPName(self):
5459 """Get the default name of the PIREP."""
5460 gui = self._wizard.gui
5461
5462 bookedFlight = gui.bookedFlight
5463 tm = time.gmtime()
5464
5465 pilotID = self._wizard.pilotID
5466 if pilotID: pilotID += " "
5467 return "%s%s %02d%02d %s-%s.pirep" % \
5468 (pilotID, str(bookedFlight.departureTime.date()),
5469 tm.tm_hour, tm.tm_min,
5470 bookedFlight.departureICAO, bookedFlight.arrivalICAO)
5471
5472 def _saveClicked(self, button, page):
5473 """Called when the Save PIREP button is clicked."""
5474 gui = self._wizard.gui
5475
5476 fileName = self._getDefaultPIREPName()
5477
5478 dialog = self._getSaveDialog()
5479
5480 if self._lastSavePath is None:
5481 pirepDirectory = gui.config.pirepDirectory
5482 if pirepDirectory is not None:
5483 dialog.set_current_folder(pirepDirectory)
5484 else:
5485 dialog.set_current_folder(os.path.dirname(self._lastSavePath))
5486
5487 dialog.set_current_name(fileName)
5488 result = dialog.run()
5489 dialog.hide()
5490
5491 if result==Gtk.ResponseType.OK:
5492 self._lastSavePath = dialog.get_filename()
5493 self._savePIREP(page)
5494
5495 def _savePIREP(self, page, automatic = False):
5496 """Perform the saving of the PIREP."""
5497
5498 gui = self._wizard.gui
5499
5500 if automatic:
5501 gui.beginBusy(xstr("finish_autosave_busy"))
5502
5503 pirep = PIREP(gui.flight)
5504 error = pirep.save(self._lastSavePath)
5505
5506 if automatic:
5507 gui.endBusy()
5508
5509 if error:
5510 type = Gtk.MessageType.ERROR
5511 message = xstr("finish_save_failed")
5512 secondary = xstr("finish_save_failed_sec") % (error,)
5513 else:
5514 type = Gtk.MessageType.INFO
5515 message = xstr("finish_save_done")
5516 if automatic:
5517 secondary = xstr("finish_save_done_sec") % (self._lastSavePath,)
5518 else:
5519 secondary = None
5520 page.setPIREPSaved()
5521
5522 dialog = Gtk.MessageDialog(parent = gui.mainWindow,
5523 type = type, message_format = message)
5524 dialog.add_button(xstr("button_ok"), Gtk.ResponseType.OK)
5525 dialog.set_title(WINDOW_TITLE_BASE)
5526 if secondary is not None:
5527 dialog.format_secondary_markup(secondary)
5528
5529 dialog.run()
5530 dialog.hide()
5531
5532 def _getSaveDialog(self):
5533 """Get the PIREP saving dialog.
5534
5535 If it does not exist yet, create it."""
5536 if self._savePIREPDialog is None:
5537 gui = self._wizard.gui
5538 dialog = Gtk.FileChooserDialog(title = WINDOW_TITLE_BASE + " - " +
5539 xstr("finish_save_title"),
5540 action = Gtk.FileChooserAction.SAVE,
5541 buttons = (Gtk.STOCK_CANCEL,
5542 Gtk.ResponseType.CANCEL,
5543 Gtk.STOCK_OK, Gtk.ResponseType.OK),
5544 parent = gui.mainWindow)
5545 dialog.set_modal(True)
5546 dialog.set_do_overwrite_confirmation(True)
5547
5548 filter = Gtk.FileFilter()
5549 filter.set_name(xstr("file_filter_pireps"))
5550 filter.add_pattern("*.pirep")
5551 dialog.add_filter(filter)
5552
5553 filter = Gtk.FileFilter()
5554 filter.set_name(xstr("file_filter_all"))
5555 filter.add_pattern("*.*")
5556 dialog.add_filter(filter)
5557
5558 self._savePIREPDialog = dialog
5559
5560 return self._savePIREPDialog
5561
5562#-----------------------------------------------------------------------------
5563
5564class FinishPage(Page):
5565 """Flight finish page."""
5566 def __init__(self, wizard, saveHelper):
5567 """Construct the finish page."""
5568 help = xstr("finish_help") + xstr("finish_help_goodtime")
5569 super(FinishPage, self).__init__(wizard, "finish",
5570 xstr("finish_title"), help)
5571
5572 alignment = Gtk.Alignment(xalign = 0.5, yalign = 0.5,
5573 xscale = 0.0, yscale = 0.0)
5574
5575 table = Gtk.Table(10, 2)
5576 table.set_row_spacings(4)
5577 table.set_col_spacings(16)
5578 table.set_homogeneous(False)
5579 alignment.add(table)
5580 self.setMainWidget(alignment)
5581
5582 row = 0
5583
5584 labelAlignment = Gtk.Alignment(xalign=1.0, xscale=0.0)
5585 label = Gtk.Label(xstr("finish_rating"))
5586 labelAlignment.add(label)
5587 table.attach(labelAlignment, 0, 1, row, row+1)
5588
5589 labelAlignment = Gtk.Alignment(xalign=0.0, xscale=0.0)
5590 self._flightRating = Gtk.Label()
5591 self._flightRating.set_width_chars(8)
5592 self._flightRating.set_alignment(0.0, 0.5)
5593 self._flightRating.set_use_markup(True)
5594 labelAlignment.add(self._flightRating)
5595 table.attach(labelAlignment, 1, 2, row, row+1)
5596
5597 row += 1
5598
5599 labelAlignment = Gtk.Alignment(xalign=1.0, xscale=0.0)
5600 label = Gtk.Label(xstr("finish_dep_time"))
5601 labelAlignment.add(label)
5602 table.attach(labelAlignment, 0, 1, row, row+1)
5603
5604 labelAlignment = Gtk.Alignment(xalign=0.0, xscale=0.0)
5605 self._depTime = Gtk.Label()
5606 self._depTime.set_width_chars(13)
5607 self._depTime.set_alignment(0.0, 0.5)
5608 self._depTime.set_use_markup(True)
5609 self._depTime.set_tooltip_markup(xstr("finish_dep_time_tooltip"))
5610 labelAlignment.add(self._depTime)
5611 table.attach(labelAlignment, 1, 2, row, row+1)
5612
5613 row += 1
5614
5615 labelAlignment = Gtk.Alignment(xalign=1.0, xscale=0.0)
5616 label = Gtk.Label(xstr("finish_flight_time"))
5617 labelAlignment.add(label)
5618 table.attach(labelAlignment, 0, 1, row, row+1)
5619
5620 labelAlignment = Gtk.Alignment(xalign=0.0, xscale=0.0)
5621 self._flightTime = Gtk.Label()
5622 self._flightTime.set_width_chars(10)
5623 self._flightTime.set_alignment(0.0, 0.5)
5624 self._flightTime.set_use_markup(True)
5625 labelAlignment.add(self._flightTime)
5626 table.attach(labelAlignment, 1, 2, row, row+1)
5627
5628 row += 1
5629
5630 labelAlignment = Gtk.Alignment(xalign=1.0, xscale=0.0)
5631 label = Gtk.Label(xstr("finish_block_time"))
5632 labelAlignment.add(label)
5633 table.attach(labelAlignment, 0, 1, row, row+1)
5634
5635 labelAlignment = Gtk.Alignment(xalign=0.0, xscale=0.0)
5636 self._blockTime = Gtk.Label()
5637 self._blockTime.set_width_chars(10)
5638 self._blockTime.set_alignment(0.0, 0.5)
5639 self._blockTime.set_use_markup(True)
5640 labelAlignment.add(self._blockTime)
5641 table.attach(labelAlignment, 1, 2, row, row+1)
5642
5643 row += 1
5644
5645 labelAlignment = Gtk.Alignment(xalign=1.0, xscale=0.0)
5646 label = Gtk.Label(xstr("finish_arr_time"))
5647 labelAlignment.add(label)
5648 table.attach(labelAlignment, 0, 1, row, row+1)
5649
5650 labelAlignment = Gtk.Alignment(xalign=0.0, xscale=0.0)
5651 self._arrTime = Gtk.Label()
5652 self._arrTime.set_width_chars(13)
5653 self._arrTime.set_alignment(0.0, 0.5)
5654 self._arrTime.set_use_markup(True)
5655 self._arrTime.set_tooltip_markup(xstr("finish_arr_time_tooltip"))
5656 labelAlignment.add(self._arrTime)
5657 table.attach(labelAlignment, 1, 2, row, row+1)
5658
5659 row += 1
5660
5661 labelAlignment = Gtk.Alignment(xalign=1.0, xscale=0.0)
5662 label = Gtk.Label(xstr("finish_distance"))
5663 labelAlignment.add(label)
5664 table.attach(labelAlignment, 0, 1, row, row+1)
5665
5666 labelAlignment = Gtk.Alignment(xalign=0.0, xscale=0.0)
5667 self._distanceFlown = Gtk.Label()
5668 self._distanceFlown.set_width_chars(10)
5669 self._distanceFlown.set_alignment(0.0, 0.5)
5670 self._distanceFlown.set_use_markup(True)
5671 labelAlignment.add(self._distanceFlown)
5672 table.attach(labelAlignment, 1, 2, row, row+1)
5673
5674 row += 1
5675
5676 labelAlignment = Gtk.Alignment(xalign=1.0, xscale=0.0)
5677 label = Gtk.Label(xstr("finish_fuel"))
5678 labelAlignment.add(label)
5679 table.attach(labelAlignment, 0, 1, row, row+1)
5680
5681 labelAlignment = Gtk.Alignment(xalign=0.0, xscale=0.0)
5682 self._fuelUsed = Gtk.Label()
5683 self._fuelUsed.set_width_chars(10)
5684 self._fuelUsed.set_alignment(0.0, 0.5)
5685 self._fuelUsed.set_use_markup(True)
5686 labelAlignment.add(self._fuelUsed)
5687 table.attach(labelAlignment, 1, 2, row, row+1)
5688
5689 row += 1
5690
5691 labelAlignment = Gtk.Alignment(xalign = 1.0, xscale = 0.0,
5692 yalign = 0.5, yscale = 0.0)
5693 label = Gtk.Label(xstr("finish_type"))
5694 label.set_use_underline(True)
5695 labelAlignment.add(label)
5696 table.attach(labelAlignment, 0, 1, row, row+1)
5697
5698 self._onlineFlight = Gtk.CheckButton(xstr("finish_online"))
5699 self._onlineFlight.set_use_underline(True)
5700 self._onlineFlight.set_tooltip_text(xstr("finish_online_tooltip"))
5701 onlineFlightAlignment = Gtk.Alignment(xalign=0.0, xscale=0.0)
5702 onlineFlightAlignment.add(self._onlineFlight)
5703 table.attach(onlineFlightAlignment, 1, 2, row, row + 1)
5704
5705 row += 1
5706
5707 labelAlignment = Gtk.Alignment(xalign = 1.0, xscale = 0.0,
5708 yalign = 0.5, yscale = 0.0)
5709 self._gateLabel = Gtk.Label(xstr("finish_gate"))
5710 self._gateLabel.set_use_underline(True)
5711 labelAlignment.add(self._gateLabel)
5712 table.attach(labelAlignment, 0, 1, row, row+1)
5713
5714 self._gatesModel = Gtk.ListStore(str)
5715
5716 self._gate = Gtk.ComboBox(model = self._gatesModel)
5717 renderer = Gtk.CellRendererText()
5718 self._gate.pack_start(renderer, True)
5719 self._gate.add_attribute(renderer, "text", 0)
5720 self._gate.set_tooltip_text(xstr("finish_gate_tooltip"))
5721 self._gate.connect("changed", self._gateChanged)
5722 gateAlignment = Gtk.Alignment(xalign=0.0, xscale=1.0)
5723 gateAlignment.add(self._gate)
5724 table.attach(gateAlignment, 1, 2, row, row+1)
5725 self._gateLabel.set_mnemonic_widget(self._gate)
5726
5727 self.addButton(xstr("finish_newFlight"),
5728 sensitive = True,
5729 clicked = self._newFlightClicked,
5730 tooltip = xstr("finish_newFlight_tooltip"),
5731 padding = 16)
5732
5733 self.addPreviousButton(clicked = self._backClicked)
5734
5735 self._saveHelper = saveHelper
5736 self._saveButton = saveHelper.addButton(self)
5737
5738 self._tooBigTimeDifference = False
5739 self._deferredAutoSave = False
5740 self._pirepSaved = False
5741 self._pirepSent = False
5742
5743 self._sendButton = self.addButton(xstr("sendPIREP"), default = True,
5744 sensitive = False,
5745 clicked = self._sendClicked,
5746 tooltip = xstr("sendPIREP_tooltip"))
5747
5748 # self._formatTime(datetime.datetime(1970, 1, 1, 0, 10), 10*60.0)
5749 # self._formatTime(datetime.datetime(1970, 1, 1, 0, 10), 20*60.0)
5750 # self._formatTime(datetime.datetime(1970, 1, 1, 0, 10), 0*60.0)
5751 # self._formatTime(datetime.datetime(1970, 1, 1, 0, 10), (23*60.0+50)*60.0)
5752 # self._formatTime(datetime.datetime(1970, 1, 1, 1, 0), (1*60.0+5)*60.0)
5753 # self._formatTime(datetime.datetime(1970, 1, 1, 1, 0), (0*60.0+50)*60.0)
5754 # self._formatTime(datetime.datetime(1970, 1, 1, 23, 55), (0*60.0+5)*60.0)
5755 # self._formatTime(datetime.datetime(1970, 1, 1, 23, 55), (23*60.0+45)*60.0)
5756
5757 @property
5758 def online(self):
5759 """Get whether the flight was an online flight or not."""
5760 return self._onlineFlight.get_active()
5761
5762 def activate(self):
5763 """Activate the page."""
5764 self._deferredAutoSave = False
5765 self._pirepSaved = False
5766 self._pirepSent = False
5767
5768 flight = self._wizard.gui._flight
5769 rating = flight.logger.getRating()
5770 if rating<0:
5771 self._flightRating.set_markup('<b><span foreground="red">NO GO</span></b>')
5772 else:
5773 self._flightRating.set_markup("<b>%.1f %%</b>" % (rating,))
5774
5775 flightLength = flight.flightTimeEnd - flight.flightTimeStart
5776 self._flightTime.set_markup("<b>%s</b>" % \
5777 (util.getTimeIntervalString(flightLength),))
5778
5779 blockLength = flight.blockTimeEnd - flight.blockTimeStart
5780 self._blockTime.set_markup("<b>%s</b>" % \
5781 (util.getTimeIntervalString(blockLength),))
5782
5783 self._distanceFlown.set_markup("<b>%.2f NM</b>" % \
5784 (flight.flownDistance,))
5785
5786 self._fuelUsed.set_markup("<b>%.0f kg</b>" % \
5787 (flight.startFuel - flight.endFuel,))
5788
5789 self._onlineFlight.set_active(self._wizard.loggedIn)
5790
5791 self._gatesModel.clear()
5792 if self._wizard.gui.config.onlineGateSystem and \
5793 self._wizard.loggedIn and \
5794 self._wizard.bookedFlight.arrivalICAO=="LHBP" and \
5795 not self._wizard.entranceExam:
5796 occupiedGateNumbers = self._wizard._fleet.getOccupiedGateNumbers()
5797 for gate in lhbpGates.gates:
5798 if gate.isAvailable(lhbpGates, occupiedGateNumbers):
5799 self._gatesModel.append([gate.number])
5800 self._gateLabel.set_sensitive(True)
5801 self._gate.set_sensitive(True)
5802 self._gate.set_active(-1)
5803 else:
5804 self._gateLabel.set_sensitive(False)
5805 self._gate.set_sensitive(False)
5806
5807 self._updateTimes()
5808
5809 def updateButtons(self):
5810 """Update the sensitivity state of the buttons."""
5811 gui = self._wizard.gui
5812 faultsExplained = gui.faultsFullyExplained
5813 timesCorrect = not self._tooBigTimeDifference or \
5814 gui.hasComments or gui.hasDelayCode
5815 sensitive = gui.flight is not None and \
5816 gui.flight.stage==const.STAGE_END and \
5817 (self._gatesModel.get_iter_first() is None or
5818 self._gate.get_active()>=0) and \
5819 faultsExplained and timesCorrect
5820
5821 self._updateHelp(faultsExplained, timesCorrect)
5822
5823 wasSensitive = self._saveButton.get_sensitive()
5824
5825 if gui.config.pirepAutoSave and sensitive and not wasSensitive:
5826 if gui.isWizardActive():
5827 self._saveHelper.autoSavePIREP(self)
5828 else:
5829 self._deferredAutoSave = True
5830
5831 if not sensitive:
5832 self._deferredAutoSave = False
5833
5834 self._saveButton.set_sensitive(sensitive)
5835 self._sendButton.set_sensitive(sensitive and
5836 self._wizard.bookedFlight.id is not None)
5837
5838 def grabDefault(self):
5839 """If the page has a default button, make it the default one."""
5840 super(FinishPage, self).grabDefault()
5841 if self._deferredAutoSave:
5842 self._saveHelper.autoSavePIREP(self)
5843 self._deferredAutoSave = False
5844
5845 def setPIREPSaved(self):
5846 """Mark the PIREP as saved."""
5847 self._pirepSaved = True
5848
5849 def _backClicked(self, button):
5850 """Called when the Back button is pressed."""
5851 self.goBack()
5852
5853 def _gateChanged(self, comboBox):
5854 """Called when the arrival gate has changed."""
5855 self.updateButtons()
5856
5857 def _newFlightClicked(self, button):
5858 """Called when the new flight button is clicked."""
5859 gui = self._wizard.gui
5860 if not self._pirepSent and not self._pirepSaved:
5861 dialog = Gtk.MessageDialog(parent = gui.mainWindow,
5862 type = Gtk.MessageType.QUESTION,
5863 message_format = xstr("finish_newFlight_question"))
5864
5865 dialog.add_button(xstr("button_no"), Gtk.ResponseType.NO)
5866 dialog.add_button(xstr("button_yes"), Gtk.ResponseType.YES)
5867
5868 dialog.set_title(WINDOW_TITLE_BASE)
5869 result = dialog.run()
5870 dialog.hide()
5871 if result!=Gtk.ResponseType.YES:
5872 return
5873
5874 gui.reset()
5875
5876 def _sendClicked(self, button):
5877 """Called when the Send button is clicked."""
5878 pirep = PIREP(self._wizard.gui.flight)
5879 self._wizard.gui.sendPIREP(pirep,
5880 callback = self._handlePIREPSent)
5881
5882 def _handlePIREPSent(self, returned, result):
5883 """Callback for the PIREP sending result."""
5884 self._pirepSent = returned and result.success
5885 if self._wizard.gui.config.onlineGateSystem and \
5886 self._wizard.loggedIn and not self._wizard.entranceExam and \
5887 returned and result.success:
5888 bookedFlight = self._wizard.bookedFlight
5889 if bookedFlight.arrivalICAO=="LHBP":
5890 iter = self._gate.get_active_iter()
5891 gateNumber = None if iter is None \
5892 else self._gatesModel.get_value(iter, 0)
5893
5894 status = const.PLANE_PARKING if gateNumber is None \
5895 else const.PLANE_HOME
5896 else:
5897 gateNumber = None
5898 status = const.PLANE_AWAY
5899
5900 self._wizard.updatePlane(self._planeUpdated,
5901 bookedFlight.tailNumber,
5902 status, gateNumber = gateNumber)
5903
5904 def _planeUpdated(self, success):
5905 """Callback for the plane updating."""
5906 pass
5907
5908 def _formatTime(self, scheduledTime, realTimestamp, warningError):
5909 """Format the departure or arrival time based on the given data as a
5910 markup for a label."""
5911 (warning, error) = warningError
5912 realTime = time.gmtime(realTimestamp)
5913
5914 if warning:
5915 colour = "red" if error else "orange"
5916 markupBegin = '<span foreground="%s">' % (colour,)
5917 markupEnd = '</span>'
5918 else:
5919 markupBegin = markupEnd = ""
5920
5921 markup = "<b>%s%02d:%02d [%02d:%02d]%s</b>" % \
5922 (markupBegin,
5923 realTime.tm_hour, realTime.tm_min,
5924 scheduledTime.hour, scheduledTime.minute,
5925 markupEnd)
5926
5927 return markup
5928
5929 def _updateTimes(self):
5930 """Format the flight times and the help text according to the flight
5931 type.
5932
5933 The buttons are also updated.
5934 """
5935 flight = self._wizard.gui._flight
5936 bookedFlight = flight.bookedFlight
5937
5938 (departureWarning, departureError) = flight.blockTimeStartWrong
5939 (arrivalWarning, arrivalError) = flight.blockTimeEndWrong
5940
5941 if bookedFlight.flightType==const.FLIGHTTYPE_VIP:
5942 departureError = arrivalError = False
5943
5944 self._tooBigTimeDifference = departureError and arrivalError
5945
5946 self._depTime.set_markup(self._formatTime(bookedFlight.departureTime,
5947 flight.blockTimeStart,
5948 (departureWarning,
5949 departureError)))
5950
5951 self._arrTime.set_markup(self._formatTime(bookedFlight.arrivalTime,
5952 flight.blockTimeEnd,
5953 (arrivalWarning,
5954 arrivalError)))
5955
5956 self.updateButtons()
5957
5958 def _updateHelp(self, faultsExplained, timesCorrect):
5959 """Update the help text according to the actual situation."""
5960 if not faultsExplained:
5961 self.setHelp(xstr("finish_help") + xstr("finish_help_faults"))
5962 elif not timesCorrect:
5963 self.setHelp(xstr("finish_help") + xstr("finish_help_wrongtime"))
5964 else:
5965 self.setHelp(xstr("finish_help") + xstr("finish_help_goodtime"))
5966
5967
5968#-----------------------------------------------------------------------------
5969
5970class CheckFlightFinishPage(Page):
5971 """Finish page for a check flight."""
5972 def __init__(self, wizard, saveHelper):
5973 """Construct the check flight finish page."""
5974 super(CheckFlightFinishPage, self).__init__(wizard,
5975 "chkfinish",
5976 xstr("chkfinish_title"),
5977 "")
5978
5979 alignment = Gtk.Alignment(xalign = 0.5, yalign = 0.5,
5980 xscale = 1.0, yscale = 1.0)
5981 self._label = Gtk.Label()
5982 alignment.add(self._label)
5983
5984 self.setMainWidget(alignment)
5985
5986 self._saveHelper = saveHelper
5987 self._saveButton = saveHelper.addButton(self)
5988
5989 self._button = self.addNextButton(sensitive = False,
5990 clicked = self._forwardClicked)
5991
5992 def activate(self):
5993 """Activate the page."""
5994 wizard = self._wizard
5995 loginResult = wizard.loginResult
5996 gui = wizard.gui
5997 rating = gui.flight.logger.getRating()
5998
5999 if rating>=0:
6000 loginResult.checkFlightStatus = True
6001
6002 firstOfficer = \
6003 loginResult.entryExamPassed and loginResult.checkFlightStatus
6004
6005 if firstOfficer:
6006 loginResult.rank = "FO"
6007
6008 if rating<0:
6009 mainMessage = xstr("chkfinish_failed")
6010 else:
6011 mainMessage = xstr("chkfinish_passed_begin")
6012 if firstOfficer:
6013 mainMessage += xstr("chkfinish_passed_fo")
6014 mainMessage += xstr("chkfinish_passed_end")
6015
6016 if firstOfficer:
6017 nextMessage = xstr("chkfinish_next")
6018 else:
6019 nextMessage = xstr("chkfinish_next_student_begin")
6020 if not loginResult.entryExamPassed and \
6021 not loginResult.checkFlightStatus:
6022 nextMessage += xstr("chkfinish_next_student_nothing")
6023 elif loginResult.entryExamPassed and \
6024 not loginResult.checkFlightStatus:
6025 nextMessage += xstr("chkfinish_next_student_no_flight")
6026 elif not loginResult.entryExamPassed and \
6027 loginResult.checkFlightStatus:
6028 nextMessage += xstr("chkfinish_next_student_no_exam")
6029
6030 self._label.set_text(mainMessage +
6031 xstr("chkfinish_savepirep") +
6032 nextMessage)
6033 self._label.set_use_markup(True)
6034 self._label.set_alignment(0.5, 0.0)
6035
6036 self._saveButton.set_sensitive(True)
6037 self._button.set_sensitive(True)
6038
6039 def _forwardClicked(self, button):
6040 """Jump to the student page if there are some tasks to do,
6041 or to the flight selection page, if the pilot is allowed to perform
6042 MAVA flights."""
6043 wizard = self._wizard
6044 gui = wizard.gui
6045
6046 loginResult = wizard.loginResult
6047 if loginResult.checkFlightStatus:
6048 gui.beginBusy(xstr("chkfinish_updateweb_busy"))
6049 gui.webHandler.setCheckFlightPassed(self._checkFlightPassedSetCallback,
6050 wizard.checkFlightAircraftType)
6051 else:
6052 self._resetGUI()
6053
6054 def _checkFlightPassedSetCallback(self, returned, result):
6055 """Called when the check flight status has been set."""
6056 GObject.idle_add(self._checkFlightPassedSet, returned, result)
6057
6058 def _checkFlightPassedSet(self, returned, result):
6059 """Handle the result of an attempt to set the check flight status."""
6060 gui = self._wizard.gui
6061
6062 gui.endBusy()
6063
6064 if returned:
6065 self._resetGUI()
6066 else:
6067 dialog = Gtk.MessageDialog(parent = gui.mainWindow,
6068 type = Gtk.MessageType.ERROR,
6069 message_format =
6070 xstr("chkfinish_passedset_failed"))
6071 dialog.set_title(WINDOW_TITLE_BASE + " - " +
6072 xstr("chkfinish_passedset_failed_title"))
6073 dialog.format_secondary_markup(xstr("chkfinish_passedset_failed_secondary"))
6074
6075 dialog.add_button(xstr("button_ok"), 0)
6076
6077 dialog.run()
6078 dialog.hide()
6079
6080 def _resetGUI(self):
6081 """Reset the GUI."""
6082 gui = self._wizard.gui
6083 gui.reset()
6084
6085#-----------------------------------------------------------------------------
6086
6087class Wizard(Gtk.VBox):
6088 """The flight wizard."""
6089 def __init__(self, gui):
6090 """Construct the wizard."""
6091 super(Wizard, self).__init__()
6092
6093 self.gui = gui
6094
6095 self._pages = []
6096 self._currentPage = None
6097
6098 self._loginPage = LoginPage(self)
6099 self._pages.append(self._loginPage)
6100 self._flightSelectionPage = FlightSelectionPage(self)
6101 self._pages.append(self._flightSelectionPage)
6102 self._pages.append(GateSelectionPage(self))
6103 self._pages.append(RegisterPage(self))
6104 self._studentPage = StudentPage(self)
6105 self._pages.append(self._studentPage)
6106 self._pages.append(ConnectPage(self))
6107 self._payloadPage = PayloadPage(self)
6108 self._pages.append(self._payloadPage)
6109 self._payloadIndex = len(self._pages)
6110 self._pages.append(TimePage(self))
6111 self._routePage = RoutePage(self)
6112 self._pages.append(self._routePage)
6113 self._simBriefSetupPage = SimBriefSetupPage(self)
6114 self._pages.append(self._simBriefSetupPage)
6115 self._simBriefingPage = SimBriefingPage(self)
6116 self._pages.append(self._simBriefingPage)
6117 self._pages.append(FuelPage(self))
6118 self._departureBriefingPage = BriefingPage(self, True)
6119 self._pages.append(self._departureBriefingPage)
6120 self._arrivalBriefingPage = BriefingPage(self, False)
6121 self._pages.append(self._arrivalBriefingPage)
6122 self._arrivalBriefingIndex = len(self._pages)
6123 self._takeoffPage = TakeoffPage(self)
6124 self._pages.append(self._takeoffPage)
6125 self._cruisePage = CruisePage(self)
6126 self._pages.append(self._cruisePage)
6127 self._landingPage = LandingPage(self)
6128 self._pages.append(self._landingPage)
6129
6130 pirepSaveHelper = PIREPSaveHelper(self)
6131
6132 self._finishPage = FinishPage(self, pirepSaveHelper)
6133 self._pages.append(self._finishPage)
6134 self._pages.append(CheckFlightFinishPage(self, pirepSaveHelper))
6135
6136 self._requestedWidth = None
6137 self._requestedHeight = None
6138
6139 self.connect("size-allocate", self._sizeAllocate)
6140
6141 for page in self._pages:
6142 page.show_all()
6143 page.setStyle()
6144
6145 self._initialize()
6146 self._allocateSize()
6147
6148 def _sizeAllocate(self, widget, allocation):
6149 if self._requestedWidth is not None and \
6150 self._requestedHeight is not None:
6151 return
6152
6153 (maxWidth, maxHeight) = self._allocateSize()
6154
6155 self._requestedWidth = maxWidth
6156 self._requestedHeight = maxHeight
6157
6158 def _allocateSize(self):
6159 """Perform the real size allocation."""
6160
6161 if self._currentPage is not None:
6162 self.remove(self._pages[self._currentPage])
6163
6164 maxWidth = 0
6165 maxHeight = 0
6166 for page in self._pages:
6167 self.add(page)
6168 self.show_all()
6169 pageSizeRequest = page.size_request()
6170 width = pageSizeRequest.width
6171 height = pageSizeRequest.height
6172 maxWidth = max(maxWidth, width)
6173 maxHeight = max(maxHeight, height)
6174 self.remove(page)
6175
6176 if self._currentPage is not None:
6177 self.add(self._pages[self._currentPage])
6178
6179 self.set_size_request(maxWidth, maxHeight)
6180
6181 return (maxWidth, maxHeight)
6182
6183 @property
6184 def pilotID(self):
6185 """Get the pilot ID, if given."""
6186 return self._loginPage.pilotID
6187
6188 @property
6189 def entranceExam(self):
6190 """Get whether an entrance exam is about to be taken."""
6191 return self._loginResult is not None and self._loginResult.rank=="STU"
6192
6193 @property
6194 def loggedIn(self):
6195 """Indicate if there was a successful login."""
6196 return self._loginResult is not None
6197
6198 @property
6199 def loginResult(self):
6200 """Get the login result."""
6201 return self._loginResult
6202
6203 @property
6204 def checkFlightAircraftType(self):
6205 """Get the type of the aircraft used to perform the check flight."""
6206 return self._studentPage.aircraftType
6207
6208 def setCurrentPage(self, index, finalize = False, fromPageShift = None):
6209 """Set the current page to the one with the given index.
6210
6211 @param fromPageShift if given, the relative index of one of the
6212 previous pages that should be used as the from-page of the next
6213 page. E.g. if fromPageShift is 1, the previous page will be the
6214 from-page."""
6215 assert index < len(self._pages)
6216
6217 fromPage = self._currentPage
6218 if fromPage is not None:
6219 page = self._pages[fromPage]
6220 if finalize and not page._completed:
6221 page.complete()
6222 page.prepareHide()
6223 self.remove(page)
6224 if fromPageShift is not None:
6225 fromPage -= fromPageShift
6226
6227 self._currentPage = index
6228 page = self._pages[index]
6229 self.add(page)
6230 if page._fromPage is None:
6231 page._fromPage = fromPage
6232 page.initialize()
6233 page.prepareShow()
6234 self.show_all()
6235 if fromPage is not None:
6236 self.grabDefault()
6237
6238 @property
6239 def bookedFlight(self):
6240 """Get the booked flight selected."""
6241 return self._bookedFlight
6242
6243 @property
6244 def numCockpitCrew(self):
6245 """Get the number of cockpit crew members."""
6246 return self._payloadPage.numCockpitCrew
6247
6248 @property
6249 def numCabinCrew(self):
6250 """Get the number of cabin crew members."""
6251 return self._payloadPage.numCabinCrew
6252
6253 @property
6254 def numPassengers(self):
6255 """Get the number of passengers."""
6256 return self._payloadPage.numPassengers
6257
6258 @property
6259 def numChildren(self):
6260 """Get the number of child passengers."""
6261 return self._payloadPage.numChildren
6262
6263 @property
6264 def numInfants(self):
6265 """Get the number of infant passengers."""
6266 return self._payloadPage.numInfants
6267
6268 @property
6269 def bagWeight(self):
6270 """Get the baggage weight."""
6271 return self._payloadPage.bagWeight
6272
6273 @property
6274 def cargoWeight(self):
6275 """Get the cargo weight."""
6276 return self._payloadPage.cargoWeight
6277
6278 @property
6279 def mailWeight(self):
6280 """Get the mail weight."""
6281 return self._payloadPage.mailWeight
6282
6283 @property
6284 def zfw(self):
6285 """Get the calculated ZFW value."""
6286 return 0 if self._bookedFlight is None \
6287 else self._payloadPage.calculateZFW()
6288
6289 @property
6290 def filedCruiseLevel(self):
6291 """Get the filed cruise level."""
6292 return self._routePage.filedCruiseLevel
6293
6294 @property
6295 def filedCruiseAltitude(self):
6296 """Get the filed cruise altitude."""
6297 return self._routePage.filedCruiseLevel * 100
6298
6299 @property
6300 def cruiseAltitude(self):
6301 """Get the cruise altitude."""
6302 level = self._cruisePage.cruiseLevel if self._cruisePage.activated \
6303 else self._routePage.filedCruiseLevel
6304 return level * 100
6305
6306 @property
6307 def loggableCruiseAltitude(self):
6308 """Get the cruise altitude that can be logged."""
6309 if self._cruisePage.activated:
6310 return self._cruisePage.loggableCruiseLevel * 100
6311 else:
6312 return 0
6313
6314 @property
6315 def route(self):
6316 """Get the route."""
6317 return self._routePage.route
6318
6319 @property
6320 def alternate(self):
6321 """Get the ICAO code of the alternate airport."""
6322 return self._routePage.alternate
6323
6324 @property
6325 def departureMETAR(self):
6326 """Get the METAR of the departure airport."""
6327 return self._departureBriefingPage.metar
6328
6329 @property
6330 def arrivalMETAR(self):
6331 """Get the METAR of the arrival airport."""
6332 return self._arrivalBriefingPage.metar
6333
6334 @property
6335 def departureRunway(self):
6336 """Get the departure runway."""
6337 return self._takeoffPage.runway
6338
6339 @property
6340 def sid(self):
6341 """Get the SID."""
6342 return self._takeoffPage.sid
6343
6344 @property
6345 def v1(self):
6346 """Get the V1 speed."""
6347 return self._takeoffPage.v1
6348
6349 @property
6350 def vr(self):
6351 """Get the Vr speed."""
6352 return self._takeoffPage.vr
6353
6354 @property
6355 def v2(self):
6356 """Get the V2 speed."""
6357 return self._takeoffPage.v2
6358
6359 @property
6360 def derate(self):
6361 """Get the derate value."""
6362 return self._takeoffPage.derate
6363
6364 @property
6365 def takeoffAntiIceOn(self):
6366 """Get whether the anti-ice system was on during take-off."""
6367 return self._takeoffPage.antiIceOn
6368
6369 @takeoffAntiIceOn.setter
6370 def takeoffAntiIceOn(self, value):
6371 """Set anti-ice on indicator."""
6372 self._takeoffPage.antiIceOn = value
6373
6374 @property
6375 def rtoIndicated(self):
6376 """Get whether the pilot has indicated that an RTO has occured."""
6377 return self._takeoffPage.rtoIndicated
6378
6379 @property
6380 def arrivalRunway(self):
6381 """Get the arrival runway."""
6382 return self._landingPage.runway
6383
6384 @property
6385 def star(self):
6386 """Get the STAR."""
6387 return self._landingPage.star
6388
6389 @property
6390 def transition(self):
6391 """Get the transition."""
6392 return self._landingPage.transition
6393
6394 @property
6395 def approachType(self):
6396 """Get the approach type."""
6397 return self._landingPage.approachType
6398
6399 @property
6400 def vref(self):
6401 """Get the Vref speed."""
6402 return self._landingPage.vref
6403
6404 @property
6405 def landingAntiIceOn(self):
6406 """Get whether the anti-ice system was on during landing."""
6407 return self._landingPage.antiIceOn
6408
6409 @landingAntiIceOn.setter
6410 def landingAntiIceOn(self, value):
6411 """Set anti-ice on indicator."""
6412 self._landingPage.antiIceOn = value
6413
6414 @property
6415 def flightType(self):
6416 """Get the flight type."""
6417 return self._finishPage.flightType
6418
6419 @property
6420 def online(self):
6421 """Get whether the flight was online or not."""
6422 return self._finishPage.online
6423
6424 @property
6425 def usingSimBrief(self):
6426 """Indicate if we are using a SimBrief briefing or not."""
6427 return self._usingSimBrief
6428
6429 @usingSimBrief.setter
6430 def usingSimBrief(self, x):
6431 """Set whether we are using a SimBrief briefing or not."""
6432 self._usingSimBrief = x
6433
6434 def nextPage(self, finalize = True):
6435 """Go to the next page."""
6436 nextPageID = self._pages[self._currentPage].nextPageID
6437 self.jumpPage(1 if nextPageID is None else nextPageID, finalize)
6438
6439 def jumpPage(self, countOrID, finalize = True, fromPageShift = None):
6440 """Go to the page which is 'count' pages after the current one."""
6441 if isinstance(countOrID, str):
6442 targetIndex = self._getIndexOf(countOrID)
6443 else:
6444 targetIndex = self._currentPage + countOrID
6445 self.setCurrentPage(targetIndex,
6446 finalize = finalize, fromPageShift = fromPageShift)
6447
6448 def grabDefault(self):
6449 """Make the default button of the current page the default."""
6450 self._pages[self._currentPage].grabDefault()
6451
6452 def connected(self, fsType, descriptor):
6453 """Called when the connection could be made to the simulator."""
6454 self.nextPage()
6455
6456 def reset(self, loginResult):
6457 """Resets the wizard to go back to the login page."""
6458 self._initialize(keepLoginResult = loginResult is None,
6459 loginResult = loginResult)
6460
6461 def setStage(self, stage):
6462 """Set the flight stage to the given one."""
6463 if stage!=const.STAGE_END:
6464 self._cruisePage.setLoggable(Flight.canLogCruiseAltitude(stage))
6465
6466 if stage==const.STAGE_TAKEOFF:
6467 self._takeoffPage.allowForward()
6468 elif stage==const.STAGE_LANDING:
6469 if not self._arrivalBriefingPage.metarEdited:
6470 print("Downloading arrival METAR again")
6471 self.gui.webHandler.getMETARs(self._arrivalMETARCallback,
6472 [self._bookedFlight.arrivalICAO])
6473
6474 elif stage==const.STAGE_END:
6475 for page in self._pages:
6476 page.flightEnded()
6477
6478 def _initialize(self, keepLoginResult = False, loginResult = None):
6479 """Initialize the wizard."""
6480 if not keepLoginResult:
6481 self._loginResult = loginResult
6482
6483 self._loginCallback = None
6484
6485 self._fleet = None
6486 self._fleetCallback = None
6487
6488 self._bookedFlight = None
6489 self._departureGate = "-"
6490 self._fuelData = None
6491 self._departureNOTAMs = None
6492 self._departureMETAR = None
6493 self._arrivalNOTAMs = None
6494 self._arrivalMETAR = None
6495 self._usingSimBrief = None
6496 self.takeoffRunway = None
6497 self.landingRunway = None
6498
6499 firstPage = 0 if self._loginResult is None else 1
6500 for page in self._pages[firstPage:]:
6501 page.reset()
6502
6503 self.setCurrentPage(firstPage)
6504 #self.setCurrentPage(10)
6505
6506 def login(self, callback, pilotID, password):
6507 """Called when the login button was clicked."""
6508 self._loginCallback = callback
6509 if pilotID is None:
6510 loginResult = self._loginResult
6511 assert loginResult is not None and loginResult.loggedIn
6512 pilotID = loginResult.pilotID
6513 password = loginResult.password
6514 busyMessage = xstr("reload_busy")
6515 else:
6516 self._loginResult = None
6517 busyMessage = xstr("login_busy")
6518
6519 self.gui.beginBusy(busyMessage)
6520
6521 self.gui.webHandler.login(self._loginResultCallback,
6522 pilotID, password)
6523
6524 def reloadFlights(self, callback):
6525 """Reload the flights from the MAVA server."""
6526 self.login(callback, None, None)
6527
6528 def addFlight(self, bookedFlight):
6529 """Add the given booked flight to the flight selection page."""
6530 self._flightSelectionPage.addFlight(bookedFlight)
6531
6532 def reflyFlight(self, bookedFlight):
6533 """Add the given booked flight to the flight selection page."""
6534 self._removePendingFlight(bookedFlight)
6535 self._flightSelectionPage._reflyFlight(bookedFlight)
6536
6537 def deleteFlight(self, bookedFlight):
6538 """Remove the given flight from the pending flight list."""
6539 self._removePendingFlight(bookedFlight)
6540 self._flightSelectionPage._updatePending()
6541
6542 def cancelFlight(self, reloadCallback):
6543 """Cancel the flight.
6544
6545 If it is an entry exam flight, we go back to the student page.
6546 Otherwise we reload the flights."""
6547 if self.entranceExam:
6548 self.reset(None)
6549 self.jumpPage("student")
6550 else:
6551 self.reloadFlights(reloadCallback)
6552
6553 def cruiseLevelChanged(self):
6554 """Called when the cruise level is changed."""
6555 return self.gui.cruiseLevelChanged()
6556
6557 def metarChanged(self, metar, originator):
6558 """Called when a METER is changed on on of the pages.
6559
6560 originator is the page that originated the changed. It will be used to
6561 determine which METAR (departure or arrival) has changed."""
6562 metar = metar.upper()
6563 if originator in [self._departureBriefingPage, self._takeoffPage]:
6564 self.departureMETARChanged(metar, originator)
6565 else:
6566 self.arrivalMETARChanged(metar, originator)
6567
6568 def departureMETARChanged(self, metar, originator):
6569 """Called when the departure METAR has been edited on one of the
6570 pages.
6571
6572 originator is the page that originated the change. It will not be
6573 called to set the METAR, while others will be."""
6574 for page in [self._departureBriefingPage, self._takeoffPage]:
6575 if page is not originator:
6576 page.changeMETAR(metar)
6577
6578 def arrivalMETARChanged(self, metar, originator):
6579 """Called when the arrival METAR has been edited on one of the
6580 pages.
6581
6582 originator is the page that originated the change. It will not be
6583 called to set the METAR, while others will be."""
6584 for page in [self._arrivalBriefingPage, self._landingPage]:
6585 if page is not originator:
6586 page.changeMETAR(metar)
6587
6588 def _removePendingFlight(self, flight):
6589 """Remove the given pending flight from the login result."""
6590 for flights in [self._loginResult.reportedFlights,
6591 self._loginResult.rejectedFlights]:
6592 for f in flights:
6593 if f.id==flight.id:
6594 flights.remove(f)
6595 return
6596
6597 def _loginResultCallback(self, returned, result):
6598 """The login result callback, called in the web handler's thread."""
6599 GObject.idle_add(self._handleLoginResult, returned, result)
6600
6601 def _handleLoginResult(self, returned, result):
6602 """Handle the login result."""
6603 self.gui.endBusy()
6604 isReload = self._loginResult is not None
6605 if returned:
6606 if result.loggedIn:
6607 self._loginResult = result
6608 self.gui.loginSuccessful()
6609 else:
6610 if isReload:
6611 message = xstr("reload_failed")
6612 else:
6613 message = xstr("login_entranceExam_invalid"
6614 if self.entranceExam else
6615 xstr("login_invalid"))
6616 dialog = Gtk.MessageDialog(parent = self.gui.mainWindow,
6617 type = Gtk.MessageType.ERROR,
6618 message_format = message)
6619 dialog.add_button(xstr("button_ok"), Gtk.ResponseType.OK)
6620 dialog.set_title(WINDOW_TITLE_BASE)
6621 if isReload:
6622 secondary = xstr("reload_failed_sec")
6623 else:
6624 secondary = xstr("login_entranceExam_invalid_sec"
6625 if self.entranceExam else
6626 xstr("login_invalid_sec"))
6627 dialog.format_secondary_markup(secondary)
6628 dialog.run()
6629 dialog.hide()
6630 else:
6631 message = xstr("reload_failconn") if isReload \
6632 else xstr("login_failconn")
6633 dialog = Gtk.MessageDialog(parent = self.gui.mainWindow,
6634 type = Gtk.MessageType.ERROR,
6635 message_format = message)
6636 dialog.add_button(xstr("button_ok"), Gtk.ResponseType.OK)
6637 dialog.set_title(WINDOW_TITLE_BASE)
6638 secondary = xstr("reload_failconn_sec") if isReload \
6639 else xstr("login_failconn_sec")
6640 dialog.format_secondary_markup(secondary)
6641
6642 dialog.run()
6643 dialog.hide()
6644
6645 callback = self._loginCallback
6646 self._loginCallback = None
6647 callback(returned, result)
6648
6649 def getFleet(self, callback, force = False):
6650 """Get the fleet via the GUI and call the given callback."""
6651 self._fleetCallback = callback
6652 self.gui.getFleet(callback = self._fleetRetrieved, force = force)
6653
6654 def _fleetRetrieved(self, fleet):
6655 """Callback for the fleet retrieval."""
6656 self._fleet = fleet
6657 if self._fleetCallback is not None:
6658 self._fleetCallback(fleet)
6659 self._fleetCallback = None
6660
6661 def updatePlane(self, callback, tailNumber, status, gateNumber = None):
6662 """Update the given plane's gate information."""
6663 self.gui.updatePlane(tailNumber, status, gateNumber = gateNumber,
6664 callback = callback)
6665
6666 def updateRTO(self):
6667 """Update the RTO state.
6668
6669 The RTO checkbox will be enabled if the flight has an RTO state and the
6670 comments field contains some text."""
6671 flight = self.gui.flight
6672 rtoEnabled = flight is not None and flight.hasRTO and \
6673 self.gui.hasComments
6674 self._takeoffPage.setRTOEnabled(rtoEnabled)
6675
6676 def commentsChanged(self):
6677 """Called when the comments have changed."""
6678 self.updateRTO()
6679 self._finishPage.updateButtons()
6680
6681 def delayCodesChanged(self):
6682 """Called when the delay codes have changed."""
6683 self._finishPage.updateButtons()
6684
6685 def faultExplanationsChanged(self):
6686 """Called when the faults and their explanations have changed."""
6687 self._finishPage.updateButtons()
6688
6689 def rtoToggled(self, indicated):
6690 """Called when the RTO indication has changed."""
6691 self.gui.rtoToggled(indicated)
6692
6693 def _connectSimulator(self, simulatorType):
6694 """Connect to the simulator."""
6695 self.gui.connectSimulator(self._bookedFlight, simulatorType)
6696
6697 def _arrivalMETARCallback(self, returned, result):
6698 """Called when the METAR of the arrival airport is retrieved."""
6699 GObject.idle_add(self._handleArrivalMETAR, returned, result)
6700
6701 def _handleArrivalMETAR(self, returned, result):
6702 """Called when the METAR of the arrival airport is retrieved."""
6703 icao = self._bookedFlight.arrivalICAO
6704 if returned and icao in result.metars:
6705 metar = result.metars[icao]
6706 if metar!="":
6707 self._arrivalBriefingPage.setMETAR(metar)
6708
6709 def _getIndexOf(self, pageID):
6710 """Get the index for the given page ID.
6711
6712 It is an assertion failure if the ID is not found."""
6713 for index in range(0, len(self._pages)):
6714 page = self._pages[index]
6715 if page.id==pageID:
6716 return index
6717 assert False
6718
6719#-----------------------------------------------------------------------------
Note: See TracBrowser for help on using the repository browser.