Context Navigation

source: src/mlx/gui/flight.py@ 1109:986abbce32ef

Visit:

python3

Last change on this file since 1109:986abbce32ef was 1106:27adf311dd37, checked in by István Váradi <ivaradi@…>, 14 months ago
The flight contains if its departure gate is taxi-through
File size: 250.8 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: