Context Navigation

source: src/mlx/gui/flight.py@ 899:ec5238c77005

Visit:

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

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

Download in other formats: