Context Navigation

source: src/mlx/gui/flight.py@ 734:fdad27df77c2

Visit:

cef

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

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

Download in other formats: