Context Navigation

source: src/mlx/gui/flight.py@ 766:86cca1d2f4e3

Visit:

Last change on this file since 766:86cca1d2f4e3 was 764:8fd245311db5, checked in by István Váradi <ivaradi@…>, 9 years ago
The entry exam is called in the browser when requested and the status is displayed in text as well (re #285)
File size: 201.7 KB

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

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

Download in other formats: