Context Navigation

source: src/mlx/gui/flight.py@ 509:77b730a1b092

Visit:

xplane

Last change on this file since 509:77b730a1b092 was 503:7a2894109717, checked in by István Váradi <ivaradi@…>, 12 years ago
The default simulator type is now remembered
File size: 133.2 KB

Line
1
2	from mlx.gui.common import *
3
4	import mlx.const as const
5	import mlx.fs as fs
6	import mlx.acft as acft
7	from mlx.flight import Flight
8	from mlx.checks import PayloadChecker
9	import mlx.util as util
10	from mlx.pirep import PIREP
11	from mlx.i18n import xstr
12	from mlx.sound import startSound
13	import mlx.web as web
14
15	import datetime
16	import time
17	import os
18
19	#-----------------------------------------------------------------------------
20
21	## @package mlx.gui.flight
22	#
23	# The flight "wizard".
24	#
25	# This module implements the main tab of the application, the flight
26	# wizard. The wizard consists of \ref Page "pages", that come one after the
27	# other. As some pages might be skipped, the pages dynamically store the index
28	# of the previous page so that going back to it is simpler. The \ref
29	# Page.activate "activate" function is called before a page is first shown
30	# during a flight. This function should initialize the page's controls and fill
31	# it with initial data. When a page is left for the first time, its \ref
32	# Page.finalize "finalize" function is called. It should set those controls
33	# insensitive, that will not be available if the user comes back to this page.
34	#
35	# Each page has a title at the top displayed in inverted colors and a big
36	# font. There is a help text below it centered, that shortly describes what is
37	# expected on the page. There can be two help texts: one shown when the page is
38	# first displayed during a flight, another shown when the user goes back to the
39	# page. The main content area is below this, also centered. Finally, there are
40	# some buttons at the bottom on the right. As some buttons occur very
41	# frequently, there are functions to add them (\ref Page.addCancelFlightButton
42	# "addCancelFlightButton", \ref Page.addPreviousButton "addPreviousButton" and
43	# \ref Page.addNextButton "addNextButton".
44	#
45	# The \ref Wizard class is the main class to collect the pages. It also stores
46	# some data passed from one page to another and provides properties to access
47	# data items set via the wizard pages.
48
49	#-----------------------------------------------------------------------------
50
51	class Page(gtk.Alignment):
52	"""A page in the flight wizard."""
53	def __init__(self, wizard, title, help, completedHelp = None):
54	"""Construct the page."""
55	super(Page, self).__init__(xalign = 0.0, yalign = 0.0,
56	xscale = 1.0, yscale = 1.0)
57	self.set_padding(padding_top = 4, padding_bottom = 4,
58	padding_left = 12, padding_right = 12)
59
60	frame = gtk.Frame()
61	self.add(frame)
62
63	self._vbox = gtk.VBox()
64	self._vbox.set_homogeneous(False)
65	frame.add(self._vbox)
66
67	eventBox = gtk.EventBox()
68
69	alignment = gtk.Alignment(xalign = 0.0, xscale = 0.0)
70
71	titleLabel = gtk.Label(title)
72	titleLabel.modify_font(pango.FontDescription("bold 24"))
73	alignment.set_padding(padding_top = 4, padding_bottom = 4,
74	padding_left = 6, padding_right = 0)
75
76	alignment.add(titleLabel)
77	eventBox.add(alignment)
78
79	self._vbox.pack_start(eventBox, False, False, 0)
80
81	self._titleEventBox = eventBox
82	self._titleLabel = titleLabel
83
84	mainBox = gtk.VBox()
85
86	alignment = gtk.Alignment(xalign = 0.0, yalign = 0.0,
87	xscale = 1.0, yscale = 1.0)
88	alignment.set_padding(padding_top = 16, padding_bottom = 16,
89	padding_left = 16, padding_right = 16)
90	alignment.add(mainBox)
91	self._vbox.pack_start(alignment, True, True, 0)
92
93	alignment = gtk.Alignment(xalign = 0.5, yalign = 0.0,
94	xscale = 0.0, yscale = 0.0)
95	alignment.set_padding(padding_top = 0, padding_bottom = 16,
96	padding_left = 0, padding_right = 0)
97
98	self._help = help
99	self._completedHelp = completedHelp
100
101	if self._completedHelp is None or \
102	len(help.splitlines())>=len(completedHelp.splitlines()):
103	longerHelp = help
104	else:
105	longerHelp = completedHelp
106
107	self._helpLabel = gtk.Label(completedHelp)
108	# FIXME: should be a constant in common
109	self._helpLabel.set_justify(gtk.Justification.CENTER if pygobject
110	else gtk.JUSTIFY_CENTER)
111	self._helpLabel.set_use_markup(True)
112	alignment.add(self._helpLabel)
113	mainBox.pack_start(alignment, False, False, 0)
114
115	self._mainAlignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
116	xscale = 1.0, yscale = 1.0)
117	mainBox.pack_start(self._mainAlignment, True, True, 0)
118
119	buttonAlignment = gtk.Alignment(xalign = 1.0, xscale=0.0, yscale = 0.0)
120	buttonAlignment.set_padding(padding_top = 4, padding_bottom = 10,
121	padding_left = 16, padding_right = 16)
122
123	self._buttonBox = gtk.HBox()
124	self._buttonBox.set_homogeneous(False)
125	self._defaultButton = None
126	buttonAlignment.add(self._buttonBox)
127
128	self._vbox.pack_start(buttonAlignment, False, False, 0)
129
130	self._wizard = wizard
131
132	self._cancelFlightButton = None
133
134	self._completed = False
135	self._fromPage = None
136
137	def setMainWidget(self, widget):
138	"""Set the given widget as the main one."""
139	self._mainAlignment.add(widget)
140
141	def addButton(self, label, default = False, sensitive = True,
142	tooltip = None, clicked = None, padding = 4):
143	"""Add a button with the given label.
144
145	Return the button object created."""
146	button = gtk.Button(label)
147	self._buttonBox.pack_start(button, False, False, padding)
148	button.set_use_underline(True)
149	if default:
150	button.set_can_default(True)
151	self._defaultButton = button
152	button.set_sensitive(sensitive)
153	if tooltip is not None:
154	button.set_tooltip_text(tooltip)
155	if clicked is not None:
156	button.connect("clicked", clicked)
157	return button
158
159	def addCancelFlightButton(self):
160	"""Add the 'Cancel flight' button to the page."""
161	self._cancelFlightButton = \
162	self.addButton(xstr("button_cancelFlight"),
163	sensitive = True,
164	tooltip = xstr("button_cancelFlight_tooltip"),
165	clicked = self._cancelFlight,
166	padding = 16)
167	return self._cancelFlightButton
168
169	def addPreviousButton(self, sensitive = True, clicked = None):
170	"""Add the 'Next' button to the page."""
171	return self.addButton(xstr("button_previous"),
172	sensitive = sensitive,
173	tooltip = xstr("button_previous_tooltip"),
174	clicked = clicked)
175
176	def addNextButton(self, default = True, sensitive = True,
177	clicked = None):
178	"""Add the 'Next' button to the page."""
179	return self.addButton(xstr("button_next"),
180	default = default,
181	sensitive = sensitive,
182	tooltip = xstr("button_next_tooltip"),
183	clicked = clicked)
184
185	def setStyle(self):
186	"""Set the styles of some of the items on the page."""
187	if pygobject:
188	context = self.get_style_context()
189	color = context.get_background_color(gtk.StateFlags.SELECTED)
190	self._titleEventBox.modify_bg(0, color.to_color())
191	color = context.get_color(gtk.StateFlags.SELECTED)
192	self._titleLabel.modify_fg(0, color.to_color())
193	else:
194	style = self.rc_get_style()
195	self._titleEventBox.modify_bg(0, style.bg[3])
196	self._titleLabel.modify_fg(0, style.fg[3])
197
198	def initialize(self):
199	"""Initialize the page.
200
201	It sets up the primary help, and calls the activate() function."""
202	self._helpLabel.set_markup(self._help)
203	self._helpLabel.set_sensitive(True)
204	self.activate()
205
206	def activate(self):
207	"""Called when this page becomes active.
208
209	This default implementation does nothing."""
210	pass
211
212	def complete(self):
213	"""Called when the page is completed.
214
215	It greys out/changes the help text and then calls finalize()."""
216	self.finalize()
217	if self._completedHelp is None:
218	self._helpLabel.set_sensitive(False)
219	else:
220	self._helpLabel.set_markup(self._completedHelp)
221	self._completed = True
222
223	def finalize(self):
224	"""Called when the page is finalized."""
225	pass
226
227	def grabDefault(self):
228	"""If the page has a default button, make it the default one."""
229	if self._defaultButton is not None:
230	self._defaultButton.grab_default()
231
232	def reset(self):
233	"""Reset the page if the wizard is reset."""
234	self._completed = False
235	self._fromPage = None
236	if self._cancelFlightButton is not None:
237	self._cancelFlightButton.set_sensitive(True)
238
239	def goBack(self):
240	"""Go to the page we were invoked from."""
241	assert self._fromPage is not None
242
243	self._wizard.setCurrentPage(self._fromPage, finalize = False)
244
245	def flightEnded(self):
246	"""Called when the flight has ended.
247
248	This default implementation disables the cancel flight button."""
249	if self._cancelFlightButton is not None:
250	self._cancelFlightButton.set_sensitive(False)
251
252	def _cancelFlight(self, button):
253	"""Called when the Cancel flight button is clicked."""
254	self._wizard.gui.cancelFlight()
255
256	#-----------------------------------------------------------------------------
257
258	class LoginPage(Page):
259	"""The login page."""
260	def __init__(self, wizard):
261	"""Construct the login page."""
262	super(LoginPage, self).__init__(wizard, xstr("login"),
263	xstr("loginHelp"))
264
265	alignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
266	xscale = 0.0, yscale = 0.0)
267
268	table = gtk.Table(4, 2)
269	table.set_row_spacings(4)
270	table.set_col_spacings(32)
271	alignment.add(table)
272	self.setMainWidget(alignment)
273
274	labelAlignment = gtk.Alignment(xalign = 1.0, yalign = 0.5,
275	xscale = 0.0, yscale = 0.0)
276	label = gtk.Label(xstr("label_pilotID"))
277	label.set_use_underline(True)
278	labelAlignment.add(label)
279	table.attach(labelAlignment, 0, 1, 0, 1)
280
281	self._pilotID = gtk.Entry()
282	self._pilotID.connect("changed", self._setControls)
283	self._pilotID.set_tooltip_text(xstr("login_pilotID_tooltip"))
284	table.attach(self._pilotID, 1, 2, 0, 1)
285	label.set_mnemonic_widget(self._pilotID)
286
287	labelAlignment = gtk.Alignment(xalign = 1.0, yalign = 0.5,
288	xscale = 0.0, yscale = 0.0)
289	label = gtk.Label(xstr("label_password"))
290	label.set_use_underline(True)
291	labelAlignment.add(label)
292	table.attach(labelAlignment, 0, 1, 1, 2)
293
294	self._password = gtk.Entry()
295	self._password.set_visibility(False)
296	self._password.connect("changed", self._setControls)
297	self._password.set_tooltip_text(xstr("login_password_tooltip"))
298	table.attach(self._password, 1, 2, 1, 2)
299	label.set_mnemonic_widget(self._password)
300
301	self._rememberButton = gtk.CheckButton(xstr("remember_password"))
302	self._rememberButton.set_use_underline(True)
303	self._rememberButton.set_tooltip_text(xstr("login_remember_tooltip"))
304	table.attach(self._rememberButton, 1, 2, 2, 3, ypadding = 8)
305
306	self._entranceExam = gtk.CheckButton(xstr("login_entranceExam"))
307	self._entranceExam.set_use_underline(True)
308	self._entranceExam.set_tooltip_text(xstr("login_entranceExam_tooltip"))
309	self._entranceExam.connect("toggled", self._setControls)
310	table.attach(self._entranceExam, 1, 2, 3, 4, ypadding = 12)
311
312	self.addButton(xstr("button_offline"),
313	clicked = self._offlineClicked,
314	tooltip = xstr("button_offline_tooltip"))
315
316	self._loginButton = self.addButton(xstr("button_login"), default = True)
317	self._loginButton.connect("clicked", self._loginClicked)
318	self._loginButton.set_tooltip_text(xstr("login_button_tooltip"))
319
320
321	@property
322	def entranceExam(self):
323	"""Get whether an entrance exam is being performed."""
324	return self._entranceExam.get_active() and \
325	self._pilotID.get_text()!=""
326
327	@property
328	def pilotID(self):
329	"""Get the pilot ID, if given."""
330	return self._pilotID.get_text()
331
332	def activate(self):
333	"""Activate the page."""
334	config = self._wizard.gui.config
335	self._pilotID.set_text(config.pilotID)
336	self._password.set_text(config.password)
337	self._rememberButton.set_active(config.rememberPassword)
338	self._setControls(None)
339
340	def _setControls(self, entry = None):
341	"""Set the sensitivity of the various controls.
342
343	The login button is sensitive only if both the pilot ID and the
344	password fields contain values.
345
346	The password field is sensitive only, if the entrance exam checkbox is
347	not selected.
348
349	The remember password checkbox is sensitive only, if the password field
350	contains text.
351
352	The entrance exam checkbox is sensitive only, if the pilot ID is not
353	empty."""
354	pilotID = self._pilotID.get_text()
355	password = self._password.get_text()
356	entranceExam = self._entranceExam.get_active()
357	self._password.set_sensitive(not entranceExam)
358	self._rememberButton.set_sensitive(password!="" and not entranceExam)
359	self._entranceExam.set_sensitive(pilotID!="")
360	self._loginButton.set_sensitive(pilotID!="" and
361	(password!="" or entranceExam))
362
363	def _offlineClicked(self, button):
364	"""Called when the offline button was clicked."""
365	print "mlx.flight.LoginPage: offline flight selected"
366	self._wizard.nextPage()
367
368	def _loginClicked(self, button):
369	"""Called when the login button was clicked."""
370	print "mlx.flight.LoginPage: logging in"
371	self._wizard.login(self._handleLoginResult,
372	self._pilotID.get_text(),
373	self._password.get_text(),
374	self.entranceExam)
375
376	def _handleLoginResult(self, returned, result):
377	"""Handle the login result."""
378	self._loginButton.set_sensitive(True)
379	if returned and result.loggedIn:
380	config = self._wizard.gui.config
381
382	config.pilotID = self._pilotID.get_text()
383
384	rememberPassword = self._rememberButton.get_active()
385	config.password = result.password if rememberPassword else ""
386
387	config.rememberPassword = rememberPassword
388
389	config.save()
390	self._wizard.nextPage()
391
392	#-----------------------------------------------------------------------------
393
394	class FlightSelectionPage(Page):
395	"""The page to select the flight."""
396	def __init__(self, wizard):
397	"""Construct the flight selection page."""
398	help = xstr("flightsel_help")
399	completedHelp = xstr("flightsel_chelp")
400	super(FlightSelectionPage, self).__init__(wizard, xstr("flightsel_title"),
401	help, completedHelp = completedHelp)
402
403
404	self._listStore = gtk.ListStore(str, str, str, str)
405	self._flightList = gtk.TreeView(self._listStore)
406	column = gtk.TreeViewColumn(xstr("flightsel_no"), gtk.CellRendererText(),
407	text = 1)
408	column.set_expand(True)
409	self._flightList.append_column(column)
410	column = gtk.TreeViewColumn(xstr("flightsel_deptime"), gtk.CellRendererText(),
411	text = 0)
412	column.set_expand(True)
413	self._flightList.append_column(column)
414	column = gtk.TreeViewColumn(xstr("flightsel_from"), gtk.CellRendererText(),
415	text = 2)
416	column.set_expand(True)
417	self._flightList.append_column(column)
418	column = gtk.TreeViewColumn(xstr("flightsel_to"), gtk.CellRendererText(),
419	text = 3)
420	column.set_expand(True)
421	self._flightList.append_column(column)
422	self._flightList.connect("row-activated", self._rowActivated)
423	self._flightList.connect("button-press-event", self._listButtonPressed)
424
425	self._flightListPopupMenu = None
426
427	flightSelection = self._flightList.get_selection()
428	flightSelection.connect("changed", self._selectionChanged)
429
430	scrolledWindow = gtk.ScrolledWindow()
431	scrolledWindow.add(self._flightList)
432	scrolledWindow.set_size_request(400, -1)
433	# FIXME: these should be constants in common.py
434	scrolledWindow.set_policy(gtk.PolicyType.AUTOMATIC if pygobject
435	else gtk.POLICY_AUTOMATIC,
436	gtk.PolicyType.AUTOMATIC if pygobject
437	else gtk.POLICY_AUTOMATIC)
438	scrolledWindow.set_shadow_type(gtk.ShadowType.IN if pygobject
439	else gtk.SHADOW_IN)
440
441	alignment = gtk.Alignment(xalign = 0.5, yalign = 0.0, xscale = 0.0, yscale = 1.0)
442	alignment.add(scrolledWindow)
443
444	self.setMainWidget(alignment)
445
446	self._saveButton = self.addButton(xstr("flightsel_save"),
447	sensitive = False,
448	clicked = self._saveClicked,
449	tooltip = xstr("flightsel_save_tooltip"))
450	self._saveDialog = None
451
452	self._refreshButton = self.addButton(xstr("flightsel_refresh"),
453	sensitive = True,
454	clicked = self._refreshClicked,
455	tooltip = xstr("flightsel_refresh_tooltip"))
456
457	self._loadButton = self.addButton(xstr("flightsel_load"),
458	sensitive = True,
459	tooltip = xstr("flightsel_load_tooltip"))
460	self._loadButton.connect("clicked", self._loadButtonClicked)
461	self._loadDialog = None
462
463	self._button = self.addNextButton(sensitive = False,
464	clicked = self._forwardClicked)
465
466	self._flights = []
467
468	def activate(self):
469	"""Fill the flight list."""
470	self._flightList.set_sensitive(True)
471	self._loadButton.set_sensitive(True)
472	self._refreshButton.set_sensitive(self._wizard.loggedIn)
473	self._buildFlights()
474
475	def finalize(self):
476	"""Finalize the page."""
477	self._flightList.set_sensitive(False)
478	self._loadButton.set_sensitive(False)
479	self._refreshButton.set_sensitive(False)
480
481	def _buildFlights(self):
482	"""Rebuild the flights from the login result."""
483	self._flights = []
484	self._listStore.clear()
485	if self._wizard.loggedIn:
486	for flight in self._wizard.loginResult.flights:
487	self._addFlight(flight)
488
489	def _addFlight(self, flight):
490	"""Add the given file to the list of flights."""
491	self._flights.append(flight)
492	self._listStore.append([str(flight.departureTime),
493	flight.callsign,
494	flight.departureICAO,
495	flight.arrivalICAO])
496
497	def _saveClicked(self, button):
498	"""Called when the Save flight button is clicked."""
499	self._saveSelected()
500
501	def _saveSelected(self):
502	"""Save the selected flight."""
503	flight = self._getSelectedFlight()
504	date = flight.departureTime.date()
505	name = "%04d-%02d-%02d %s %s-%s.vaflight" % \
506	(date.year, date.month, date.day, flight.callsign,
507	flight.departureICAO, flight.arrivalICAO)
508
509	dialog = self._getSaveDialog()
510	dialog.set_current_name(name)
511	dialog.show_all()
512	response = dialog.run()
513	dialog.hide()
514
515	if response==RESPONSETYPE_OK:
516	fileName = text2unicode(dialog.get_filename())
517	print "Saving", fileName
518	try:
519	with open(fileName, "wt") as f:
520	flight.writeIntoFile(f)
521	except Exception, e:
522	print "Failed to save flight:", util.utf2unicode(str(e))
523	dialog = gtk.MessageDialog(parent = self._wizard.gui.mainWindow,
524	type = MESSAGETYPE_ERROR,
525	message_format =
526	xstr("flightsel_save_failed"))
527	dialog.add_button(xstr("button_ok"), RESPONSETYPE_OK)
528	dialog.set_title(WINDOW_TITLE_BASE)
529	secondary = xstr("flightsel_save_failed_sec")
530	dialog.format_secondary_markup(secondary)
531	dialog.run()
532	dialog.hide()
533
534	def _refreshClicked(self, button):
535	"""Called when the refresh button is clicked."""
536	self._wizard.reloadFlights(self._refreshCallback)
537
538	def _refreshCallback(self, returned, result):
539	"""Callback for the refresh."""
540	if returned and result.loggedIn:
541	self._buildFlights()
542
543	def _selectionChanged(self, selection):
544	"""Called when the selection is changed."""
545	selected = selection.count_selected_rows()==1
546	self._saveButton.set_sensitive(selected)
547	self._button.set_sensitive(selected)
548
549	def _loadButtonClicked(self, loadButton):
550	"""Called when the load a flight button is clicked."""
551	dialog = self._getLoadDialog()
552	dialog.show_all()
553	response = dialog.run()
554	dialog.hide()
555
556	if response==RESPONSETYPE_OK:
557	fileName = text2unicode(dialog.get_filename())
558	print "Loading", fileName
559	bookedFlight = web.BookedFlight()
560	try:
561	with open(fileName, "rt") as f:
562	bookedFlight.readFromFile(f)
563	self._addFlight(bookedFlight)
564	except Exception, e:
565	print "Failed to load flight:", util.utf2unicode(str(e))
566	dialog = gtk.MessageDialog(parent = self._wizard.gui.mainWindow,
567	type = MESSAGETYPE_ERROR,
568	message_format =
569	xstr("flightsel_load_failed"))
570	dialog.add_button(xstr("button_ok"), RESPONSETYPE_OK)
571	dialog.set_title(WINDOW_TITLE_BASE)
572	secondary = xstr("flightsel_load_failed_sec")
573	dialog.format_secondary_markup(secondary)
574	dialog.run()
575	dialog.hide()
576
577	def _forwardClicked(self, button):
578	"""Called when the forward button was clicked."""
579	if self._completed:
580	self._wizard.jumpPage(self._nextDistance, finalize = False)
581	else:
582	self._flightSelected()
583
584	def _rowActivated(self, flightList, path, column):
585	"""Called when a row is activated."""
586	if not self._completed:
587	self._flightSelected()
588
589	def _flightSelected(self):
590	"""Called when a flight has been selected."""
591	flight = self._getSelectedFlight()
592	self._wizard._bookedFlight = flight
593	self._wizard.gui.enableFlightInfo(flight.aircraftType)
594
595	self._updateDepartureGate()
596
597	def _getSelectedFlight(self):
598	"""Get the currently selected flight."""
599	selection = self._flightList.get_selection()
600	(listStore, iter) = selection.get_selected()
601	path = listStore.get_path(iter)
602	[index] = path.get_indices() if pygobject else path
603
604	return self._flights[index]
605
606	def _listButtonPressed(self, widget, event):
607	"""Called when a mouse button is pressed on the flight list."""
608	if event.type!=EVENT_BUTTON_PRESS or event.button!=3:
609	return
610
611	(path, _, _, _) = self._flightList.get_path_at_pos(int(event.x),
612	int(event.y))
613	selection = self._flightList.get_selection()
614	selection.unselect_all()
615	selection.select_path(path)
616
617	menu = self._getListPopupMenu()
618	if pygobject:
619	menu.popup(None, None, None, None, event.button, event.time)
620	else:
621	menu.popup(None, None, None, event.button, event.time)
622
623	def _updateDepartureGate(self):
624	"""Update the departure gate for the booked flight."""
625	flight = self._wizard._bookedFlight
626	if self._wizard.gui.config.onlineGateSystem and \
627	self._wizard.loggedIn and not self._wizard.entranceExam:
628	if flight.departureICAO=="LHBP":
629	self._wizard.getFleet(self._fleetRetrieved)
630	else:
631	self._wizard.updatePlane(self._planeUpdated,
632	flight.tailNumber,
633	const.PLANE_AWAY)
634	else:
635	self._nextDistance = 2
636	self._wizard.jumpPage(2)
637
638	def _fleetRetrieved(self, fleet):
639	"""Called when the fleet has been retrieved."""
640	if fleet is None:
641	self._nextDistance = 2
642	self._wizard.jumpPage(2)
643	else:
644	plane = fleet[self._wizard._bookedFlight.tailNumber]
645	if plane is None:
646	self._nextDistance = 2
647	self._wizard.jumpPage(2)
648	elif plane.gateNumber is not None and \
649	not fleet.isGateConflicting(plane):
650	self._wizard._departureGate = plane.gateNumber
651	self._nextDistance = 2
652	self._wizard.jumpPage(2)
653	else:
654	self._nextDistance = 1
655	self._wizard.nextPage()
656
657	def _planeUpdated(self, success):
658	"""Callback for the plane updating."""
659	self._nextDistance = 2
660	self._wizard.jumpPage(2)
661
662	def _getSaveDialog(self):
663	"""Get the dialog to load a flight file."""
664	if self._saveDialog is not None:
665	return self._saveDialog
666
667	gui = self._wizard.gui
668	dialog = gtk.FileChooserDialog(title = WINDOW_TITLE_BASE + " - " +
669	xstr("flightsel_save_title"),
670	action = FILE_CHOOSER_ACTION_SAVE,
671	buttons = (gtk.STOCK_CANCEL,
672	RESPONSETYPE_CANCEL,
673	gtk.STOCK_OK, RESPONSETYPE_OK),
674	parent = gui.mainWindow)
675	dialog.set_modal(True)
676	dialog.set_do_overwrite_confirmation(True)
677
678	filter = gtk.FileFilter()
679	filter.set_name(xstr("flightsel_filter_flights"))
680	filter.add_pattern("*.vaflight")
681	dialog.add_filter(filter)
682
683	filter = gtk.FileFilter()
684	filter.set_name(xstr("file_filter_all"))
685	filter.add_pattern(".")
686	dialog.add_filter(filter)
687
688	self._saveDialog = dialog
689
690	return dialog
691
692	def _getLoadDialog(self):
693	"""Get the dialog to load a flight file."""
694	if self._loadDialog is not None:
695	return self._loadDialog
696
697	gui = self._wizard.gui
698	dialog = gtk.FileChooserDialog(title = WINDOW_TITLE_BASE + " - " +
699	xstr("flightsel_load_title"),
700	action = FILE_CHOOSER_ACTION_OPEN,
701	buttons = (gtk.STOCK_CANCEL,
702	RESPONSETYPE_CANCEL,
703	gtk.STOCK_OK, RESPONSETYPE_OK),
704	parent = gui.mainWindow)
705	dialog.set_modal(True)
706
707	filter = gtk.FileFilter()
708	filter.set_name(xstr("flightsel_filter_flights"))
709	filter.add_pattern("*.vaflight")
710	dialog.add_filter(filter)
711
712	filter = gtk.FileFilter()
713	filter.set_name(xstr("file_filter_all"))
714	filter.add_pattern(".")
715	dialog.add_filter(filter)
716
717	self._loadDialog = dialog
718
719	return dialog
720
721	def _getListPopupMenu(self):
722	"""Get the flight list popup menu."""
723	if self._flightListPopupMenu is None:
724	menu = gtk.Menu()
725
726	menuItem = gtk.MenuItem()
727	menuItem.set_label(xstr("flightsel_popup_select"))
728	menuItem.set_use_underline(True)
729	menuItem.connect("activate", self._popupSelect)
730	menuItem.show()
731
732	menu.append(menuItem)
733
734	menuItem = gtk.MenuItem()
735	menuItem.set_label(xstr("flightsel_popup_save"))
736	menuItem.set_use_underline(True)
737	menuItem.connect("activate", self._popupSave)
738	menuItem.show()
739
740	menu.append(menuItem)
741
742	self._flightListPopupMenu = menu
743
744	return self._flightListPopupMenu
745
746	def _popupSelect(self, menuItem):
747	"""Called when the Select menu item is activated in the popup menu."""
748	if not self._completed:
749	self._flightSelected()
750
751	def _popupSave(self, menuItem):
752	"""Called when the Save menu item is activated in the popup menu."""
753	if not self._completed:
754	self._saveSelected()
755
756	#-----------------------------------------------------------------------------
757
758	class GateSelectionPage(Page):
759	"""Page to select a free gate at LHBP.
760	This page should be displayed only if we have fleet information!."""
761	def __init__(self, wizard):
762	"""Construct the gate selection page."""
763	super(GateSelectionPage, self).__init__(wizard, xstr("gatesel_title"),
764	xstr("gatesel_help"))
765
766	self._listStore = gtk.ListStore(str)
767	self._gateList = gtk.TreeView(self._listStore)
768	column = gtk.TreeViewColumn(None, gtk.CellRendererText(),
769	text = 0)
770	column.set_expand(True)
771	self._gateList.append_column(column)
772	self._gateList.set_headers_visible(False)
773	self._gateList.connect("row-activated", self._rowActivated)
774
775	gateSelection = self._gateList.get_selection()
776	gateSelection.connect("changed", self._selectionChanged)
777
778	scrolledWindow = gtk.ScrolledWindow()
779	scrolledWindow.add(self._gateList)
780	scrolledWindow.set_size_request(50, -1)
781	scrolledWindow.set_policy(gtk.PolicyType.AUTOMATIC if pygobject
782	else gtk.POLICY_AUTOMATIC,
783	gtk.PolicyType.AUTOMATIC if pygobject
784	else gtk.POLICY_AUTOMATIC)
785	scrolledWindow.set_shadow_type(gtk.ShadowType.IN if pygobject
786	else gtk.SHADOW_IN)
787
788	alignment = gtk.Alignment(xalign = 0.5, yalign = 0.0, xscale = 0.0, yscale = 1.0)
789	alignment.add(scrolledWindow)
790
791	self.setMainWidget(alignment)
792
793	self.addCancelFlightButton()
794
795	self.addPreviousButton(clicked = self._backClicked)
796
797	self._button = self.addNextButton(sensitive = False,
798	clicked = self._forwardClicked)
799
800	def activate(self):
801	"""Fill the gate list."""
802	self._listStore.clear()
803	self._gateList.set_sensitive(True)
804	occupiedGateNumbers = self._wizard._fleet.getOccupiedGateNumbers()
805	for gateNumber in const.lhbpGateNumbers:
806	if gateNumber not in occupiedGateNumbers:
807	self._listStore.append([gateNumber])
808
809	def finalize(self):
810	"""Finalize the page."""
811	self._gateList.set_sensitive(False)
812
813	def _selectionChanged(self, selection):
814	"""Called when the selection is changed."""
815	self._button.set_sensitive(selection.count_selected_rows()==1)
816
817	def _backClicked(self, button):
818	"""Called when the Back button is pressed."""
819	self.goBack()
820
821	def _forwardClicked(self, button):
822	"""Called when the forward button is clicked."""
823	if not self._completed:
824	self._gateSelected()
825	else:
826	self._wizard.nextPage()
827
828	def _rowActivated(self, flightList, path, column):
829	"""Called when a row is activated."""
830	if not self._completed:
831	self._gateSelected()
832
833	def _gateSelected(self):
834	"""Called when a gate has been selected."""
835	selection = self._gateList.get_selection()
836	(listStore, iter) = selection.get_selected()
837	(gateNumber,) = listStore.get(iter, 0)
838
839	self._wizard._departureGate = gateNumber
840
841	self._wizard.updatePlane(self._planeUpdated,
842	self._wizard._bookedFlight.tailNumber,
843	const.PLANE_HOME, gateNumber)
844
845	def _planeUpdated(self, success):
846	"""Callback for the plane updating call."""
847	if success is None or success:
848	self._wizard.nextPage()
849	else:
850	dialog = gtk.MessageDialog(parent = self._wizard.gui.mainWindow,
851	type = MESSAGETYPE_ERROR,
852	message_format = xstr("gatesel_conflict"))
853	dialog.add_button(xstr("button_ok"), RESPONSETYPE_OK)
854	dialog.set_title(WINDOW_TITLE_BASE)
855	dialog.format_secondary_markup(xstr("gatesel_conflict_sec"))
856	dialog.run()
857	dialog.hide()
858
859	self._wizard.getFleet(self._fleetRetrieved)
860
861	def _fleetRetrieved(self, fleet):
862	"""Called when the fleet has been retrieved."""
863	if fleet is None:
864	self._wizard.nextPage()
865	else:
866	self.activate()
867
868	#-----------------------------------------------------------------------------
869
870	class ConnectPage(Page):
871	"""Page which displays the departure airport and gate (if at LHBP)."""
872	def __init__(self, wizard):
873	"""Construct the connect page."""
874	help = "Load the aircraft below into the simulator and park it\n" \
875	"at the given airport, at the gate below, if present.\n\n" \
876	"Then press the Connect button to connect to the simulator."
877	completedHelp = "The basic data of your flight can be read below."
878	super(ConnectPage, self).__init__(wizard, xstr("connect_title"),
879	xstr("connect_help"),
880	completedHelp = xstr("connect_chelp"))
881
882	self._selectSimulator = os.name=="nt" or "FORCE_SELECT_SIM" in os.environ
883
884	alignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
885	xscale = 0.0, yscale = 0.0)
886
887	table = gtk.Table(7 if self._selectSimulator else 5, 2)
888	table.set_row_spacings(4)
889	table.set_col_spacings(16)
890	table.set_homogeneous(True)
891	alignment.add(table)
892	self.setMainWidget(alignment)
893
894	labelAlignment = gtk.Alignment(xalign=1.0, xscale=0.0)
895	label = gtk.Label(xstr("connect_flightno"))
896	labelAlignment.add(label)
897	table.attach(labelAlignment, 0, 1, 0, 1)
898
899	labelAlignment = gtk.Alignment(xalign=0.0, xscale=0.0)
900	self._flightNumber = gtk.Label()
901	self._flightNumber.set_width_chars(9)
902	self._flightNumber.set_alignment(0.0, 0.5)
903	labelAlignment.add(self._flightNumber)
904	table.attach(labelAlignment, 1, 2, 0, 1)
905
906	labelAlignment = gtk.Alignment(xalign=1.0, xscale=0.0)
907	label = gtk.Label(xstr("connect_acft"))
908	labelAlignment.add(label)
909	table.attach(labelAlignment, 0, 1, 1, 2)
910
911	labelAlignment = gtk.Alignment(xalign=0.0, xscale=0.0)
912	self._aircraft = gtk.Label()
913	self._aircraft.set_width_chars(25)
914	self._aircraft.set_alignment(0.0, 0.5)
915	labelAlignment.add(self._aircraft)
916	table.attach(labelAlignment, 1, 2, 1, 2)
917
918	labelAlignment = gtk.Alignment(xalign=1.0, xscale=0.0)
919	label = gtk.Label(xstr("connect_tailno"))
920	labelAlignment.add(label)
921	table.attach(labelAlignment, 0, 1, 2, 3)
922
923	labelAlignment = gtk.Alignment(xalign=0.0, xscale=0.0)
924	self._tailNumber = gtk.Label()
925	self._tailNumber.set_width_chars(10)
926	self._tailNumber.set_alignment(0.0, 0.5)
927	labelAlignment.add(self._tailNumber)
928	table.attach(labelAlignment, 1, 2, 2, 3)
929
930	labelAlignment = gtk.Alignment(xalign=1.0, xscale=0.0)
931	label = gtk.Label(xstr("connect_airport"))
932	labelAlignment.add(label)
933	table.attach(labelAlignment, 0, 1, 3, 4)
934
935	labelAlignment = gtk.Alignment(xalign=0.0, xscale=0.0)
936	self._departureICAO = gtk.Label()
937	self._departureICAO.set_width_chars(6)
938	self._departureICAO.set_alignment(0.0, 0.5)
939	labelAlignment.add(self._departureICAO)
940	table.attach(labelAlignment, 1, 2, 3, 4)
941
942	labelAlignment = gtk.Alignment(xalign=1.0, xscale=0.0)
943	label = gtk.Label(xstr("connect_gate"))
944	labelAlignment.add(label)
945	table.attach(labelAlignment, 0, 1, 4, 5)
946
947	labelAlignment = gtk.Alignment(xalign=0.0, xscale=0.0)
948	self._departureGate = gtk.Label()
949	self._departureGate.set_width_chars(5)
950	self._departureGate.set_alignment(0.0, 0.5)
951	labelAlignment.add(self._departureGate)
952	table.attach(labelAlignment, 1, 2, 4, 5)
953
954	if self._selectSimulator:
955	labelAlignment = gtk.Alignment(xalign=1.0, xscale=0.0, yalign=0.5)
956	label = gtk.Label(xstr("connect_sim"))
957	labelAlignment.add(label)
958	table.attach(labelAlignment, 0, 1, 5, 7)
959
960	selectAlignment = gtk.Alignment(xalign=0.0, xscale=0.0, yalign=0.5)
961
962	selectBox = gtk.HBox()
963	if pygobject:
964	self._selectMSFS = \
965	gtk.RadioButton.new_with_mnemonic_from_widget(None,
966	xstr("connect_sim_msfs"))
967	else:
968	self._selectMSFS = gtk.RadioButton(None,
969	xstr("connect_sim_msfs"))
970
971	selectBox.pack_start(self._selectMSFS, False, False, 0);
972
973	if pygobject:
974	self._selectXPlane = \
975	gtk.RadioButton.new_with_mnemonic_from_widget(self._selectMSFS,
976	xstr("connect_sim_xplane"))
977	else:
978	self._selectXPlane = gtk.RadioButton(self._selectMSFS,
979	xstr("connect_sim_xplane"))
980
981	selectBox.pack_start(self._selectXPlane, False, False, 8);
982
983	selectAlignment.add(selectBox)
984	table.attach(selectAlignment, 1, 2, 5, 7)
985
986
987	self.addCancelFlightButton()
988
989	self.addPreviousButton(clicked = self._backClicked)
990
991	self._button = self.addButton(xstr("button_connect"), default = True,
992	tooltip = xstr("button_connect_tooltip"))
993	self._clickedID = self._button.connect("clicked", self._connectClicked)
994
995	def activate(self):
996	"""Setup the departure information."""
997	self._button.set_label(xstr("button_connect"))
998	self._button.set_use_underline(True)
999	self._button.set_tooltip_text(xstr("button_connect_tooltip"))
1000	self._button.disconnect(self._clickedID)
1001	self._clickedID = self._button.connect("clicked", self._connectClicked)
1002
1003	bookedFlight = self._wizard._bookedFlight
1004
1005	self._flightNumber.set_markup("<b>" + bookedFlight.callsign + "</b>")
1006
1007	aircraftType = aircraftNames[bookedFlight.aircraftType]
1008	self._aircraft.set_markup("<b>" + aircraftType + "</b>")
1009
1010	self._tailNumber.set_markup("<b>" + bookedFlight.tailNumber + "</b>")
1011
1012	icao = bookedFlight.departureICAO
1013	self._departureICAO.set_markup("<b>" + icao + "</b>")
1014	gate = self._wizard._departureGate
1015	if gate!="-":
1016	gate = "<b>" + gate + "</b>"
1017	self._departureGate.set_markup(gate)
1018
1019	if self._selectSimulator:
1020	config = self._wizard.gui.config
1021	self._selectMSFS.set_active(config.defaultMSFS)
1022	self._selectXPlane.set_active(not config.defaultMSFS)
1023
1024	def finalize(self):
1025	"""Finalize the page."""
1026	self._button.set_label(xstr("button_next"))
1027	self._button.set_use_underline(True)
1028	self._button.set_tooltip_text(xstr("button_next_tooltip"))
1029	self._button.disconnect(self._clickedID)
1030	self._clickedID = self._button.connect("clicked", self._forwardClicked)
1031
1032	def _backClicked(self, button):
1033	"""Called when the Back button is pressed."""
1034	self.goBack()
1035
1036	def _connectClicked(self, button):
1037	"""Called when the Connect button is pressed."""
1038	if self._selectSimulator:
1039	simulatorType = const.SIM_MSFS9 if self._selectMSFS.get_active() \
1040	else const.SIM_XPLANE10
1041	else:
1042	simulatorType = const.SIM_MSFS9 if os.name=="nt" \
1043	else const.SIM_XPLANE10
1044
1045	config = self._wizard.gui.config
1046	config.defaultMSFS = simulatorType == const.SIM_MSFS9
1047	config.save()
1048
1049	self._wizard._connectSimulator(simulatorType)
1050
1051	def _forwardClicked(self, button):
1052	"""Called when the Forward button is pressed."""
1053	self._wizard.nextPage()
1054
1055	#-----------------------------------------------------------------------------
1056
1057	class PayloadPage(Page):
1058	"""Page to allow setting up the payload."""
1059	def __init__(self, wizard):
1060	"""Construct the page."""
1061	super(PayloadPage, self).__init__(wizard, xstr("payload_title"),
1062	xstr("payload_help"),
1063	completedHelp = xstr("payload_chelp"))
1064
1065	alignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
1066	xscale = 0.0, yscale = 0.0)
1067
1068	table = gtk.Table(7, 3)
1069	table.set_row_spacings(4)
1070	table.set_col_spacings(16)
1071	table.set_homogeneous(False)
1072	alignment.add(table)
1073	self.setMainWidget(alignment)
1074
1075	label = gtk.Label(xstr("payload_crew"))
1076	label.set_use_underline(True)
1077	label.set_alignment(0.0, 0.5)
1078	table.attach(label, 0, 1, 0, 1)
1079
1080	self._numCrew = IntegerEntry(defaultValue = 0)
1081	self._numCrew.set_width_chars(6)
1082	self._numCrew.connect("integer-changed", self._weightChanged)
1083	self._numCrew.set_tooltip_text(xstr("payload_crew_tooltip"))
1084	table.attach(self._numCrew, 1, 2, 0, 1)
1085	label.set_mnemonic_widget(self._numCrew)
1086
1087	label = gtk.Label(xstr("payload_pax"))
1088	label.set_use_underline(True)
1089	label.set_alignment(0.0, 0.5)
1090	table.attach(label, 0, 1, 1, 2)
1091
1092	self._numPassengers = IntegerEntry(defaultValue = 0)
1093	self._numPassengers.set_width_chars(6)
1094	self._numPassengers.connect("integer-changed", self._weightChanged)
1095	self._numPassengers.set_tooltip_text(xstr("payload_pax_tooltip"))
1096	table.attach(self._numPassengers, 1, 2, 1, 2)
1097	label.set_mnemonic_widget(self._numPassengers)
1098
1099	label = gtk.Label(xstr("payload_bag"))
1100	label.set_use_underline(True)
1101	label.set_alignment(0.0, 0.5)
1102	table.attach(label, 0, 1, 2, 3)
1103
1104	self._bagWeight = IntegerEntry(defaultValue = 0)
1105	self._bagWeight.set_width_chars(6)
1106	self._bagWeight.connect("integer-changed", self._weightChanged)
1107	self._bagWeight.set_tooltip_text(xstr("payload_bag_tooltip"))
1108	table.attach(self._bagWeight, 1, 2, 2, 3)
1109	label.set_mnemonic_widget(self._bagWeight)
1110
1111	table.attach(gtk.Label("kg"), 2, 3, 2, 3)
1112
1113	label = gtk.Label(xstr("payload_cargo"))
1114	label.set_use_underline(True)
1115	label.set_alignment(0.0, 0.5)
1116	table.attach(label, 0, 1, 3, 4)
1117
1118	self._cargoWeight = IntegerEntry(defaultValue = 0)
1119	self._cargoWeight.set_width_chars(6)
1120	self._cargoWeight.connect("integer-changed", self._weightChanged)
1121	self._cargoWeight.set_tooltip_text(xstr("payload_cargo_tooltip"))
1122	table.attach(self._cargoWeight, 1, 2, 3, 4)
1123	label.set_mnemonic_widget(self._cargoWeight)
1124
1125	table.attach(gtk.Label("kg"), 2, 3, 3, 4)
1126
1127	label = gtk.Label(xstr("payload_mail"))
1128	label.set_use_underline(True)
1129	label.set_alignment(0.0, 0.5)
1130	table.attach(label, 0, 1, 4, 5)
1131
1132	self._mailWeight = IntegerEntry(defaultValue = 0)
1133	self._mailWeight.set_width_chars(6)
1134	self._mailWeight.connect("integer-changed", self._weightChanged)
1135	self._mailWeight.set_tooltip_text(xstr("payload_mail_tooltip"))
1136	table.attach(self._mailWeight, 1, 2, 4, 5)
1137	label.set_mnemonic_widget(self._mailWeight)
1138
1139	table.attach(gtk.Label("kg"), 2, 3, 4, 5)
1140
1141	label = gtk.Label("<b>" + xstr("payload_zfw") + "</b>")
1142	label.set_alignment(0.0, 0.5)
1143	label.set_use_markup(True)
1144	table.attach(label, 0, 1, 5, 6)
1145
1146	self._calculatedZFW = gtk.Label()
1147	self._calculatedZFW.set_width_chars(6)
1148	self._calculatedZFW.set_alignment(1.0, 0.5)
1149	table.attach(self._calculatedZFW, 1, 2, 5, 6)
1150
1151	table.attach(gtk.Label("kg"), 2, 3, 5, 6)
1152
1153	self._zfwButton = gtk.Button(xstr("payload_fszfw"))
1154	self._zfwButton.set_use_underline(True)
1155	self._zfwButton.connect("clicked", self._zfwRequested)
1156	self._zfwButton.set_tooltip_text(xstr("payload_fszfw_tooltip"))
1157	table.attach(self._zfwButton, 0, 1, 6, 7)
1158
1159	self._simulatorZFW = gtk.Label("-")
1160	self._simulatorZFW.set_width_chars(6)
1161	self._simulatorZFW.set_alignment(1.0, 0.5)
1162	table.attach(self._simulatorZFW, 1, 2, 6, 7)
1163	self._simulatorZFWValue = None
1164
1165	table.attach(gtk.Label("kg"), 2, 3, 6, 7)
1166
1167	self.addCancelFlightButton()
1168	self._backButton = self.addPreviousButton(clicked = self._backClicked)
1169	self._button = self.addNextButton(clicked = self._forwardClicked)
1170
1171	@property
1172	def numCrew(self):
1173	"""The number of the crew members on the flight."""
1174	return self._numCrew.get_int()
1175
1176	@property
1177	def numPassengers(self):
1178	"""The number of the passengers on the flight."""
1179	return self._numPassengers.get_int()
1180
1181	@property
1182	def bagWeight(self):
1183	"""Get the bag weight entered."""
1184	return self._bagWeight.get_int()
1185
1186	@property
1187	def cargoWeight(self):
1188	"""Get the cargo weight entered."""
1189	return self._cargoWeight.get_int()
1190
1191	@property
1192	def mailWeight(self):
1193	"""Get the bag weight entered."""
1194	return self._mailWeight.get_int()
1195
1196	def activate(self):
1197	"""Setup the information."""
1198	bookedFlight = self._wizard._bookedFlight
1199
1200	self._numCrew.set_int(bookedFlight.numCrew)
1201	self._numCrew.set_sensitive(True)
1202	self._numPassengers.set_int(bookedFlight.numPassengers)
1203	self._numPassengers.set_sensitive(True)
1204
1205	self._bagWeight.set_int(bookedFlight.bagWeight)
1206	self._bagWeight.set_sensitive(True)
1207	self._cargoWeight.set_int(bookedFlight.cargoWeight)
1208	self._cargoWeight.set_sensitive(True)
1209	self._mailWeight.set_int(bookedFlight.mailWeight)
1210	self._mailWeight.set_sensitive(True)
1211
1212	self._simulatorZFW.set_text("-")
1213	self._simulatorZFWValue = None
1214	self._zfwButton.set_sensitive(True)
1215	self._updateCalculatedZFW()
1216
1217	def finalize(self):
1218	"""Finalize the payload page."""
1219	self._numCrew.set_sensitive(False)
1220	self._numPassengers.set_sensitive(False)
1221	self._bagWeight.set_sensitive(False)
1222	self._cargoWeight.set_sensitive(False)
1223	self._mailWeight.set_sensitive(False)
1224	self._wizard.gui.initializeWeightHelp()
1225
1226	def calculateZFW(self):
1227	"""Calculate the ZFW value."""
1228	zfw = self._wizard.gui._flight.aircraft.dow
1229	zfw += (self._numCrew.get_int() + self._numPassengers.get_int()) * 82
1230	zfw += self._bagWeight.get_int()
1231	zfw += self._cargoWeight.get_int()
1232	zfw += self._mailWeight.get_int()
1233	return zfw
1234
1235	def _updateCalculatedZFW(self):
1236	"""Update the calculated ZFW"""
1237	zfw = self.calculateZFW()
1238
1239	markupBegin = "<b>"
1240	markupEnd = "</b>"
1241	if self._simulatorZFWValue is not None and \
1242	PayloadChecker.isZFWFaulty(self._simulatorZFWValue, zfw):
1243	markupBegin += '<span foreground="red">'
1244	markupEnd = "</span>" + markupEnd
1245	self._calculatedZFW.set_markup(markupBegin + str(zfw) + markupEnd)
1246
1247	def _weightChanged(self, entry, weight):
1248	"""Called when one of the weight values or humanm counts has changed."""
1249	self._updateCalculatedZFW()
1250
1251	def _zfwRequested(self, button):
1252	"""Called when the ZFW is requested from the simulator."""
1253	self._zfwButton.set_sensitive(False)
1254	self._backButton.set_sensitive(False)
1255	self._button.set_sensitive(False)
1256	gui = self._wizard.gui
1257	gui.beginBusy(xstr("payload_zfw_busy"))
1258	gui.simulator.requestZFW(self._handleZFW)
1259
1260	def _handleZFW(self, zfw):
1261	"""Called when the ZFW value is retrieved."""
1262	gobject.idle_add(self._processZFW, zfw)
1263
1264	def _processZFW(self, zfw):
1265	"""Process the given ZFW value received from the simulator."""
1266	self._wizard.gui.endBusy()
1267	self._zfwButton.set_sensitive(True)
1268	self._backButton.set_sensitive(True)
1269	self._button.set_sensitive(True)
1270	self._simulatorZFWValue = zfw
1271	self._simulatorZFW.set_text("%.0f" % (zfw,))
1272	self._updateCalculatedZFW()
1273
1274	def _forwardClicked(self, button):
1275	"""Called when the forward button is clicked."""
1276	self._wizard.nextPage()
1277
1278	def _backClicked(self, button):
1279	"""Called when the Back button is pressed."""
1280	self.goBack()
1281
1282	#-----------------------------------------------------------------------------
1283
1284	class TimePage(Page):
1285	"""Page displaying the departure and arrival times and allows querying the
1286	current time from the flight simulator."""
1287	def __init__(self, wizard):
1288	super(TimePage, self).__init__(wizard, xstr("time_title"),
1289	xstr("time_help"),
1290	completedHelp = xstr("time_chelp"))
1291
1292	alignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
1293	xscale = 0.0, yscale = 0.0)
1294
1295	table = gtk.Table(3, 2)
1296	table.set_row_spacings(4)
1297	table.set_col_spacings(16)
1298	table.set_homogeneous(False)
1299	alignment.add(table)
1300	self.setMainWidget(alignment)
1301
1302	label = gtk.Label(xstr("time_departure"))
1303	label.set_alignment(0.0, 0.5)
1304	table.attach(label, 0, 1, 0, 1)
1305
1306	self._departure = gtk.Label()
1307	self._departure.set_alignment(0.0, 0.5)
1308	table.attach(self._departure, 1, 2, 0, 1)
1309
1310	label = gtk.Label(xstr("time_arrival"))
1311	label.set_alignment(0.0, 0.5)
1312	table.attach(label, 0, 1, 1, 2)
1313
1314	self._arrival = gtk.Label()
1315	self._arrival.set_alignment(0.0, 0.5)
1316	table.attach(self._arrival, 1, 2, 1, 2)
1317
1318	self._timeButton = gtk.Button(xstr("time_fs"))
1319	self._timeButton.set_use_underline(True)
1320	self._timeButton.set_tooltip_text(xstr("time_fs_tooltip"))
1321	self._timeButton.connect("clicked", self._timeRequested)
1322	table.attach(self._timeButton, 0, 1, 2, 3)
1323
1324	self._simulatorTime = gtk.Label("-")
1325	self._simulatorTime.set_alignment(0.0, 0.5)
1326	table.attach(self._simulatorTime, 1, 2, 2, 3)
1327
1328	self.addCancelFlightButton()
1329
1330	self._backButton = self.addPreviousButton(clicked = self._backClicked)
1331	self._button = self.addNextButton(clicked = self._forwardClicked)
1332
1333	def activate(self):
1334	"""Activate the page."""
1335	self._timeButton.set_sensitive(True)
1336	bookedFlight = self._wizard._bookedFlight
1337	self._departure.set_text(str(bookedFlight.departureTime.time()))
1338	self._arrival.set_text(str(bookedFlight.arrivalTime.time()))
1339	self._simulatorTime.set_text("-")
1340
1341	def _timeRequested(self, button):
1342	"""Request the time from the simulator."""
1343	self._timeButton.set_sensitive(False)
1344	self._backButton.set_sensitive(False)
1345	self._button.set_sensitive(False)
1346	self._wizard.gui.beginBusy(xstr("time_busy"))
1347	self._wizard.gui.simulator.requestTime(self._handleTime)
1348
1349	def _handleTime(self, timestamp):
1350	"""Handle the result of a time retrieval."""
1351	gobject.idle_add(self._processTime, timestamp)
1352
1353	def _processTime(self, timestamp):
1354	"""Process the given time."""
1355	self._wizard.gui.endBusy()
1356	self._timeButton.set_sensitive(True)
1357	self._backButton.set_sensitive(True)
1358	self._button.set_sensitive(True)
1359	tm = time.gmtime(timestamp)
1360	t = datetime.time(tm.tm_hour, tm.tm_min, tm.tm_sec)
1361	self._simulatorTime.set_text(str(t))
1362
1363	ts = tm.tm_hour * 3600 + tm.tm_min * 60 + tm.tm_sec
1364	dt = self._wizard._bookedFlight.departureTime.time()
1365	dts = dt.hour * 3600 + dt.minute * 60 + dt.second
1366	diff = dts-ts
1367
1368	markupBegin = ""
1369	markupEnd = ""
1370	if diff < 0:
1371	markupBegin = '<b><span foreground="red">'
1372	markupEnd = '</span></b>'
1373	elif diff < 360 or diff > 3060:
1374	markupBegin = '<b><span foreground="orange">'
1375	markupEnd = '</span></b>'
1376
1377	self._departure.set_markup(markupBegin + str(dt) + markupEnd)
1378
1379	def _backClicked(self, button):
1380	"""Called when the Back button is pressed."""
1381	self.goBack()
1382
1383	def _forwardClicked(self, button):
1384	"""Called when the forward button is clicked."""
1385	if not self._completed:
1386	gui = self._wizard.gui
1387	gui.beginBusy(xstr("fuel_get_busy"))
1388
1389	gui.simulator.getFuel(self._handleFuel)
1390	else:
1391	self._wizard.nextPage()
1392
1393	def _handleFuel(self, fuelData):
1394	"""Callback for the fuel query operation."""
1395	gobject.idle_add(self._processFuel, fuelData)
1396
1397	def _processFuel(self, fuelData):
1398	"""Process the given fuel data."""
1399	self._wizard.gui.endBusy()
1400	self._wizard._fuelData = fuelData
1401	self._wizard.nextPage()
1402
1403	#-----------------------------------------------------------------------------
1404
1405	class FuelTank(gtk.VBox):
1406	"""Widget for the fuel tank."""
1407	def __init__(self, fuelTank, name, capacity, currentWeight):
1408	"""Construct the widget for the tank with the given name."""
1409	super(FuelTank, self).__init__()
1410
1411	self._enabled = True
1412	self.fuelTank = fuelTank
1413	self.capacity = capacity
1414	self.currentWeight = currentWeight
1415	self.expectedWeight = currentWeight
1416
1417	label = gtk.Label("<b>" + name + "</b>")
1418	label.set_use_markup(True)
1419	label.set_use_underline(True)
1420	label.set_justify(JUSTIFY_CENTER)
1421	label.set_alignment(0.5, 1.0)
1422	self.pack_start(label, False, False, 4)
1423
1424	self._tankFigure = gtk.EventBox()
1425	self._tankFigure.set_size_request(38, -1)
1426	self._tankFigure.set_visible_window(False)
1427	self._tankFigure.set_tooltip_markup(xstr("fuel_tank_tooltip"))
1428
1429	if pygobject:
1430	self._tankFigure.connect("draw", self._drawTankFigure)
1431	else:
1432	self._tankFigure.connect("expose_event", self._drawTankFigure)
1433	self._tankFigure.connect("button_press_event", self._buttonPressed)
1434	self._tankFigure.connect("motion_notify_event", self._motionNotify)
1435	self._tankFigure.connect("scroll-event", self._scrolled)
1436
1437	alignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
1438	xscale = 0.0, yscale = 1.0)
1439	alignment.add(self._tankFigure)
1440
1441	self.pack_start(alignment, True, True, 4)
1442
1443	self._expectedButton = gtk.SpinButton()
1444	self._expectedButton.set_numeric(True)
1445	self._expectedButton.set_range(0, self.capacity)
1446	self._expectedButton.set_increments(10, 100)
1447	self._expectedButton.set_value(currentWeight)
1448	self._expectedButton.set_alignment(1.0)
1449	self._expectedButton.set_width_chars(5)
1450	self._expectedButton.connect("value-changed", self._expectedChanged)
1451
1452	label.set_mnemonic_widget(self._expectedButton)
1453
1454	alignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
1455	xscale = 0.0, yscale = 1.0)
1456	alignment.add(self._expectedButton)
1457	self.pack_start(alignment, False, False, 4)
1458
1459	def setCurrent(self, currentWeight):
1460	"""Set the current weight."""
1461	self.currentWeight = currentWeight
1462	self._redraw()
1463
1464	def isCorrect(self):
1465	"""Determine if the contents of the fuel tank are as expected"""
1466	return abs(self.expectedWeight - self.currentWeight)<=1
1467
1468	def disable(self):
1469	"""Disable the fuel tank."""
1470	self._expectedButton.set_sensitive(False)
1471	self._enabled = False
1472
1473	def _redraw(self):
1474	"""Redraw the tank figure."""
1475	self._tankFigure.queue_draw()
1476
1477	def _drawTankFigure(self, tankFigure, eventOrContext):
1478	"""Draw the tank figure."""
1479	triangleSize = 5
1480
1481	context = eventOrContext if pygobject else tankFigure.window.cairo_create()
1482	(xOffset, yOffset) = (0, 0) if pygobject \
1483	else (tankFigure.allocation.x, tankFigure.allocation.y)
1484
1485	width = tankFigure.get_allocated_width() if pygobject \
1486	else tankFigure.allocation.width
1487	height = tankFigure.get_allocated_height() if pygobject \
1488	else tankFigure.allocation.height
1489
1490	rectangleX0 = triangleSize
1491	rectangleY0 = triangleSize
1492	rectangleX1 = width - 1 - triangleSize
1493	rectangleY1 = height - 1 - triangleSize
1494	rectangleLineWidth = 2.0
1495
1496	context.set_source_rgb(0.0, 0.0, 0.0)
1497	context.set_line_width(rectangleLineWidth)
1498	context.rectangle(xOffset + rectangleX0 + rectangleLineWidth/2,
1499	yOffset + rectangleY0 + rectangleLineWidth/2,
1500	rectangleX1 - rectangleX0 - rectangleLineWidth,
1501	rectangleY1 - rectangleY0 - rectangleLineWidth)
1502	context.stroke()
1503
1504	rectangleInnerLeft = rectangleX0 + rectangleLineWidth
1505	rectangleInnerRight = rectangleX1 - rectangleLineWidth
1506	self._rectangleInnerTop = rectangleInnerTop = rectangleY0 + rectangleLineWidth
1507	self._rectangleInnerBottom = rectangleInnerBottom = rectangleY1 - rectangleLineWidth
1508
1509	rectangleInnerWidth = rectangleInnerRight - rectangleInnerLeft
1510	rectangleInnerHeight = rectangleInnerBottom - rectangleInnerTop
1511
1512	context.set_source_rgb(1.0, 0.9, 0.6)
1513	currentHeight = self.currentWeight * rectangleInnerHeight / self.capacity
1514	currentX = rectangleInnerTop + rectangleInnerHeight - currentHeight
1515	context.rectangle(xOffset + rectangleInnerLeft,
1516	yOffset + rectangleInnerTop +
1517	rectangleInnerHeight - currentHeight,
1518	rectangleInnerWidth, currentHeight)
1519	context.fill()
1520
1521	expectedHeight = self.expectedWeight * rectangleInnerHeight / self.capacity
1522	expectedY = rectangleInnerTop + rectangleInnerHeight - expectedHeight
1523
1524	context.set_line_width(1.5)
1525	context.set_source_rgb(0.0, 0.85, 0.85)
1526	context.move_to(xOffset + rectangleX0, yOffset + expectedY)
1527	context.line_to(xOffset + rectangleX1, yOffset + expectedY)
1528	context.stroke()
1529
1530	context.set_line_width(0.0)
1531	context.move_to(xOffset + 0, yOffset + expectedY - triangleSize)
1532	context.line_to(xOffset + 0, yOffset + expectedY + triangleSize)
1533	context.line_to(xOffset + rectangleX0 + 1, yOffset + expectedY)
1534	context.line_to(xOffset + 0, yOffset + expectedY - triangleSize)
1535	context.fill()
1536
1537	context.set_line_width(0.0)
1538	context.move_to(xOffset + width, yOffset + expectedY - triangleSize)
1539	context.line_to(xOffset + width, yOffset + expectedY + triangleSize)
1540	context.line_to(xOffset + rectangleX1 - 1, yOffset + expectedY)
1541	context.line_to(xOffset + width, yOffset + expectedY - triangleSize)
1542	context.fill()
1543
1544	return True
1545
1546	def _setExpectedFromY(self, y):
1547	"""Set the expected weight from the given Y-coordinate."""
1548	level = (self._rectangleInnerBottom - y) / \
1549	(self._rectangleInnerBottom - self._rectangleInnerTop)
1550	level = min(1.0, max(0.0, level))
1551	self._expectedButton.set_value(level * self.capacity)
1552
1553	def _buttonPressed(self, tankFigure, event):
1554	"""Called when a button is pressed in the figure.
1555
1556	The expected level will be set there."""
1557	if self._enabled and event.button==1:
1558	self._setExpectedFromY(event.y)
1559
1560	def _motionNotify(self, tankFigure, event):
1561	"""Called when the mouse pointer moves within the area of a tank figure."""
1562	if self._enabled and event.state==BUTTON1_MASK:
1563	self._setExpectedFromY(event.y)
1564
1565	def _scrolled(self, tankFigure, event):
1566	"""Called when a scroll event is received."""
1567	if self._enabled:
1568	increment = 1 if event.state==CONTROL_MASK \
1569	else 100 if event.state==SHIFT_MASK \
1570	else 10 if event.state==0 else 0
1571	if increment!=0:
1572	if event.direction==SCROLL_DOWN:
1573	increment *= -1
1574	self._expectedButton.spin(SPIN_USER_DEFINED, increment)
1575
1576	def _expectedChanged(self, spinButton):
1577	"""Called when the expected value has changed."""
1578	self.expectedWeight = spinButton.get_value_as_int()
1579	self._redraw()
1580
1581	#-----------------------------------------------------------------------------
1582
1583	class FuelPage(Page):
1584	"""The page containing the fuel tank filling."""
1585	_pumpStep = 0.02
1586
1587	def __init__(self, wizard):
1588	"""Construct the page."""
1589	super(FuelPage, self).__init__(wizard, xstr("fuel_title"),
1590	xstr("fuel_help"),
1591	completedHelp = xstr("fuel_chelp"))
1592
1593	self._fuelTanks = []
1594	self._fuelTable = None
1595	self._fuelAlignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
1596	xscale = 0.0, yscale = 1.0)
1597	self.setMainWidget(self._fuelAlignment)
1598
1599	tankData = [(tank, 2500, 3900) for tank in acft.mostFuelTanks]
1600	self._setupTanks(tankData)
1601
1602	self.addCancelFlightButton()
1603
1604	self._backButton = self.addPreviousButton(clicked = self._backClicked)
1605	self._button = self.addNextButton(clicked = self._forwardClicked)
1606
1607	self._pumpIndex = 0
1608
1609	def activate(self):
1610	"""Activate the page."""
1611	self._setupTanks(self._wizard._fuelData)
1612
1613	def finalize(self):
1614	"""Finalize the page."""
1615	for fuelTank in self._fuelTanks:
1616	fuelTank.disable()
1617
1618	def _backClicked(self, button):
1619	"""Called when the Back button is pressed."""
1620	self.goBack()
1621
1622	def _forwardClicked(self, button):
1623	"""Called when the forward button is clicked."""
1624	if not self._completed:
1625	self._pumpIndex = 0
1626	self._wizard.gui.beginBusy(xstr("fuel_pump_busy"))
1627	self._pump()
1628	else:
1629	self._wizard.nextPage()
1630
1631	def _setupTanks(self, tankData):
1632	"""Setup the tanks for the given data."""
1633	numTanks = len(tankData)
1634	if self._fuelTable is not None:
1635	self._fuelAlignment.remove(self._fuelTable)
1636
1637	self._fuelTanks = []
1638	self._fuelTable = gtk.Table(numTanks, 1)
1639	self._fuelTable.set_col_spacings(16)
1640	index = 0
1641	for (tank, current, capacity) in tankData:
1642	fuelTank = FuelTank(tank,
1643	xstr("fuel_tank_" +
1644	const.fuelTank2string(tank)),
1645	capacity, current)
1646	self._fuelTable.attach(fuelTank, index, index+1, 0, 1)
1647	self._fuelTanks.append(fuelTank)
1648	index += 1
1649
1650	self._fuelAlignment.add(self._fuelTable)
1651	self.show_all()
1652
1653	def _pump(self):
1654	"""Perform one step of pumping.
1655
1656	It is checked, if the current tank's contents are of the right
1657	quantity. If not, it is filled one step further to the desired
1658	contents. Otherwise the next tank is started. If all tanks are are
1659	filled, the next page is selected."""
1660	numTanks = len(self._fuelTanks)
1661
1662	fuelTank = None
1663	while self._pumpIndex < numTanks:
1664	fuelTank = self._fuelTanks[self._pumpIndex]
1665	if fuelTank.isCorrect():
1666	self._pumpIndex += 1
1667	fuelTank = None
1668	else:
1669	break
1670
1671	if fuelTank is None:
1672	self._wizard.gui.endBusy()
1673	self._wizard.nextPage()
1674	else:
1675	currentLevel = fuelTank.currentWeight / fuelTank.capacity
1676	expectedLevel = fuelTank.expectedWeight / fuelTank.capacity
1677	if currentLevel<expectedLevel:
1678	currentLevel += FuelPage._pumpStep
1679	if currentLevel>expectedLevel: currentLevel = expectedLevel
1680	else:
1681	currentLevel -= FuelPage._pumpStep
1682	if currentLevel<expectedLevel: currentLevel = expectedLevel
1683	fuelTank.setCurrent(currentLevel * fuelTank.capacity)
1684	self._wizard.gui.simulator.setFuelLevel([(fuelTank.fuelTank,
1685	currentLevel)])
1686	gobject.timeout_add(50, self._pump)
1687
1688	#-----------------------------------------------------------------------------
1689
1690	class RoutePage(Page):
1691	"""The page containing the route and the flight level."""
1692	def __init__(self, wizard):
1693	"""Construct the page."""
1694	super(RoutePage, self).__init__(wizard, xstr("route_title"),
1695	xstr("route_help"),
1696	completedHelp = xstr("route_chelp"))
1697
1698	alignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
1699	xscale = 0.0, yscale = 0.0)
1700
1701	mainBox = gtk.VBox()
1702	alignment.add(mainBox)
1703	self.setMainWidget(alignment)
1704
1705	levelBox = gtk.HBox()
1706
1707	label = gtk.Label(xstr("route_level"))
1708	label.set_use_underline(True)
1709	levelBox.pack_start(label, True, True, 0)
1710
1711	self._cruiseLevel = gtk.SpinButton()
1712	self._cruiseLevel.set_increments(step = 10, page = 100)
1713	self._cruiseLevel.set_range(min = 50, max = 500)
1714	self._cruiseLevel.set_tooltip_text(xstr("route_level_tooltip"))
1715	self._cruiseLevel.set_numeric(True)
1716	self._cruiseLevel.connect("value-changed", self._cruiseLevelChanged)
1717	label.set_mnemonic_widget(self._cruiseLevel)
1718
1719	levelBox.pack_start(self._cruiseLevel, False, False, 8)
1720
1721	alignment = gtk.Alignment(xalign = 0.0, yalign = 0.5,
1722	xscale = 0.0, yscale = 0.0)
1723	alignment.add(levelBox)
1724
1725	mainBox.pack_start(alignment, False, False, 0)
1726
1727
1728	routeBox = gtk.VBox()
1729
1730	alignment = gtk.Alignment(xalign = 0.0, yalign = 0.5,
1731	xscale = 0.0, yscale = 0.0)
1732	label = gtk.Label(xstr("route_route"))
1733	label.set_use_underline(True)
1734	alignment.add(label)
1735	routeBox.pack_start(alignment, True, True, 0)
1736
1737	routeWindow = gtk.ScrolledWindow()
1738	routeWindow.set_size_request(400, 80)
1739	routeWindow.set_shadow_type(gtk.ShadowType.IN if pygobject
1740	else gtk.SHADOW_IN)
1741	routeWindow.set_policy(gtk.PolicyType.AUTOMATIC if pygobject
1742	else gtk.POLICY_AUTOMATIC,
1743	gtk.PolicyType.AUTOMATIC if pygobject
1744	else gtk.POLICY_AUTOMATIC)
1745
1746	self._uppercasingRoute = False
1747
1748	self._route = gtk.TextView()
1749	self._route.set_tooltip_text(xstr("route_route_tooltip"))
1750	self._route.set_wrap_mode(WRAP_WORD)
1751	self._route.get_buffer().connect("changed", self._routeChanged)
1752	self._route.get_buffer().connect_after("insert-text", self._routeInserted)
1753	routeWindow.add(self._route)
1754
1755	label.set_mnemonic_widget(self._route)
1756	routeBox.pack_start(routeWindow, True, True, 0)
1757
1758	mainBox.pack_start(routeBox, True, True, 8)
1759
1760	self.addCancelFlightButton()
1761
1762	self._backButton = self.addPreviousButton(clicked = self._backClicked)
1763	self._button = self.addNextButton(clicked = self._forwardClicked)
1764
1765	@property
1766	def filedCruiseLevel(self):
1767	"""Get the filed cruise level."""
1768	return self._cruiseLevel.get_value_as_int()
1769
1770	@property
1771	def route(self):
1772	"""Get the route."""
1773	return self._getRoute()
1774
1775	def activate(self):
1776	"""Setup the route from the booked flight."""
1777	self._cruiseLevel.set_value(240)
1778	self._route.get_buffer().set_text(self._wizard._bookedFlight.route)
1779	self._updateForwardButton()
1780
1781	def _getRoute(self):
1782	"""Get the text of the route."""
1783	buffer = self._route.get_buffer()
1784	return buffer.get_text(buffer.get_start_iter(),
1785	buffer.get_end_iter(), True)
1786
1787	def _updateForwardButton(self):
1788	"""Update the sensitivity of the forward button."""
1789	self._button.set_sensitive(self._cruiseLevel.get_value_as_int()>=50 and \
1790	self._getRoute()!="")
1791
1792	def _cruiseLevelChanged(self, spinButton):
1793	"""Called when the cruise level has changed."""
1794	self._updateForwardButton()
1795
1796	def _routeChanged(self, textBuffer):
1797	"""Called when the route has changed."""
1798	if not self._uppercasingRoute:
1799	self._updateForwardButton()
1800
1801	def _routeInserted(self, textBuffer, iter, text, length):
1802	"""Called when new characters are inserted into the route.
1803
1804	It uppercases all characters."""
1805	if not self._uppercasingRoute:
1806	self._uppercasingRoute = True
1807
1808	iter1 = iter.copy()
1809	iter1.backward_chars(length)
1810	textBuffer.delete(iter, iter1)
1811
1812	textBuffer.insert(iter, text.upper())
1813
1814	self._uppercasingRoute = False
1815
1816	def _backClicked(self, button):
1817	"""Called when the Back button is pressed."""
1818	self.goBack()
1819
1820	def _forwardClicked(self, button):
1821	"""Called when the Forward button is clicked."""
1822	if self._completed:
1823	self._wizard.nextPage()
1824	else:
1825	bookedFlight = self._wizard._bookedFlight
1826	self._wizard.gui.beginBusy(xstr("route_down_notams"))
1827	self._wizard.gui.webHandler.getNOTAMs(self._notamsCallback,
1828	bookedFlight.departureICAO,
1829	bookedFlight.arrivalICAO)
1830	startSound(const.SOUND_NOTAM)
1831
1832	def _notamsCallback(self, returned, result):
1833	"""Callback for the NOTAMs."""
1834	gobject.idle_add(self._handleNOTAMs, returned, result)
1835
1836	def _handleNOTAMs(self, returned, result):
1837	"""Handle the NOTAMs."""
1838	if returned:
1839	self._wizard._departureNOTAMs = result.departureNOTAMs
1840	self._wizard._arrivalNOTAMs = result.arrivalNOTAMs
1841	else:
1842	self._wizard._departureNOTAMs = None
1843	self._wizard._arrivalNOTAMs = None
1844
1845	bookedFlight = self._wizard._bookedFlight
1846	self._wizard.gui.beginBusy(xstr("route_down_metars"))
1847	self._wizard.gui.webHandler.getMETARs(self._metarsCallback,
1848	[bookedFlight.departureICAO,
1849	bookedFlight.arrivalICAO])
1850
1851	def _metarsCallback(self, returned, result):
1852	"""Callback for the METARs."""
1853	gobject.idle_add(self._handleMETARs, returned, result)
1854
1855	def _handleMETARs(self, returned, result):
1856	"""Handle the METARs."""
1857	self._wizard._departureMETAR = None
1858	self._wizard._arrivalMETAR = None
1859	bookedFlight = self._wizard._bookedFlight
1860	if returned:
1861	if bookedFlight.departureICAO in result.metars:
1862	self._wizard._departureMETAR = result.metars[bookedFlight.departureICAO]
1863	if bookedFlight.arrivalICAO in result.metars:
1864	self._wizard._arrivalMETAR = result.metars[bookedFlight.arrivalICAO]
1865
1866	self._wizard.gui.endBusy()
1867	self._backButton.set_sensitive(True)
1868	self._button.set_sensitive(True)
1869	self._wizard.nextPage()
1870
1871	#-----------------------------------------------------------------------------
1872
1873	class BriefingPage(Page):
1874	"""Page for the briefing."""
1875	def __init__(self, wizard, departure):
1876	"""Construct the briefing page."""
1877	self._departure = departure
1878
1879	title = xstr("briefing_title") % (1 if departure else 2,
1880	xstr("briefing_departure")
1881	if departure
1882	else xstr("briefing_arrival"))
1883	super(BriefingPage, self).__init__(wizard, title, xstr("briefing_help"),
1884	completedHelp = xstr("briefing_chelp"))
1885
1886	alignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
1887	xscale = 1.0, yscale = 1.0)
1888
1889	mainBox = gtk.VBox()
1890	alignment.add(mainBox)
1891	self.setMainWidget(alignment)
1892
1893	self._notamsFrame = gtk.Frame()
1894	self._notamsFrame.set_label(xstr("briefing_notams_init"))
1895	scrolledWindow = gtk.ScrolledWindow()
1896	scrolledWindow.set_size_request(-1, 128)
1897	# FIXME: these constants should be in common
1898	scrolledWindow.set_policy(gtk.PolicyType.AUTOMATIC if pygobject
1899	else gtk.POLICY_AUTOMATIC,
1900	gtk.PolicyType.AUTOMATIC if pygobject
1901	else gtk.POLICY_AUTOMATIC)
1902	self._notams = gtk.TextView()
1903	self._notams.set_editable(False)
1904	self._notams.set_accepts_tab(False)
1905	self._notams.set_wrap_mode(gtk.WrapMode.WORD if pygobject else gtk.WRAP_WORD)
1906	scrolledWindow.add(self._notams)
1907	alignment = gtk.Alignment(xalign = 0.0, yalign = 0.0,
1908	xscale = 1.0, yscale = 1.0)
1909	alignment.set_padding(padding_top = 4, padding_bottom = 0,
1910	padding_left = 0, padding_right = 0)
1911	alignment.add(scrolledWindow)
1912	self._notamsFrame.add(alignment)
1913	mainBox.pack_start(self._notamsFrame, True, True, 4)
1914
1915	self._metarFrame = gtk.Frame()
1916	self._metarFrame.set_label(xstr("briefing_metar_init"))
1917	scrolledWindow = gtk.ScrolledWindow()
1918	scrolledWindow.set_size_request(-1, 32)
1919	scrolledWindow.set_policy(gtk.PolicyType.AUTOMATIC if pygobject
1920	else gtk.POLICY_AUTOMATIC,
1921	gtk.PolicyType.AUTOMATIC if pygobject
1922	else gtk.POLICY_AUTOMATIC)
1923
1924	self._uppercasingMETAR = False
1925
1926	self._metar = gtk.TextView()
1927	self._metar.set_accepts_tab(False)
1928	self._metar.set_wrap_mode(gtk.WrapMode.WORD if pygobject else gtk.WRAP_WORD)
1929	self._metar.get_buffer().connect("changed", self._metarChanged)
1930	self._metar.get_buffer().connect_after("insert-text", self._metarInserted)
1931	scrolledWindow.add(self._metar)
1932	alignment = gtk.Alignment(xalign = 0.0, yalign = 0.0,
1933	xscale = 1.0, yscale = 1.0)
1934	alignment.set_padding(padding_top = 4, padding_bottom = 0,
1935	padding_left = 0, padding_right = 0)
1936	alignment.add(scrolledWindow)
1937	self._metarFrame.add(alignment)
1938	mainBox.pack_start(self._metarFrame, True, True, 4)
1939	self.metarEdited = False
1940
1941	self.addCancelFlightButton()
1942
1943	self.addPreviousButton(clicked = self._backClicked)
1944	self._button = self.addNextButton(clicked = self._forwardClicked)
1945
1946	@property
1947	def metar(self):
1948	"""Get the METAR on the page."""
1949	buffer = self._metar.get_buffer()
1950	return buffer.get_text(buffer.get_start_iter(),
1951	buffer.get_end_iter(), True)
1952
1953	def setMETAR(self, metar):
1954	"""Set the metar."""
1955	self._metar.get_buffer().set_text(metar)
1956	self.metarEdited = False
1957
1958	def activate(self):
1959	"""Activate the page."""
1960	if not self._departure:
1961	self._button.set_label(xstr("briefing_button"))
1962	self._button.set_has_tooltip(False)
1963	self._button.set_use_stock(False)
1964
1965	bookedFlight = self._wizard._bookedFlight
1966
1967	icao = bookedFlight.departureICAO if self._departure \
1968	else bookedFlight.arrivalICAO
1969	notams = self._wizard._departureNOTAMs if self._departure \
1970	else self._wizard._arrivalNOTAMs
1971	metar = self._wizard._departureMETAR if self._departure \
1972	else self._wizard._arrivalMETAR
1973
1974	self._notamsFrame.set_label(xstr("briefing_notams_template") % (icao,))
1975	buffer = self._notams.get_buffer()
1976	if notams is None:
1977	buffer.set_text(xstr("briefing_notams_failed"))
1978	elif not notams:
1979	buffer.set_text(xstr("briefing_notams_missing"))
1980	else:
1981	s = ""
1982	for notam in notams:
1983	s += str(notam.begin)
1984	if notam.end is not None:
1985	s += " - " + str(notam.end)
1986	elif notam.permanent:
1987	s += " - PERMANENT"
1988	s += "\n"
1989	if notam.repeatCycle:
1990	s += "Repeat cycle: " + notam.repeatCycle + "\n"
1991	s += notam.notice + "\n"
1992	s += "-------------------- * --------------------\n"
1993	buffer.set_text(s)
1994
1995	self._metarFrame.set_label(xstr("briefing_metar_template") % (icao,))
1996	buffer = self._metar.get_buffer()
1997	if metar is None:
1998	buffer.set_text(xstr("briefing_metar_failed"))
1999	else:
2000	buffer.set_text(metar)
2001
2002	label = self._metarFrame.get_label_widget()
2003	label.set_use_underline(True)
2004	label.set_mnemonic_widget(self._metar)
2005
2006	self.metarEdited = False
2007
2008	def _backClicked(self, button):
2009	"""Called when the Back button is pressed."""
2010	self.goBack()
2011
2012	def _forwardClicked(self, button):
2013	"""Called when the forward button is clicked."""
2014	if not self._departure:
2015	if not self._completed:
2016	self._wizard.gui.startMonitoring()
2017	self._button.set_label(xstr("button_next"))
2018	self._button.set_tooltip_text(xstr("button_next_tooltip"))
2019	self.complete()
2020
2021	self._wizard.nextPage()
2022
2023	def _metarChanged(self, buffer):
2024	"""Called when the METAR has changed."""
2025	if not self._uppercasingMETAR:
2026	self.metarEdited = True
2027	self._button.set_sensitive(buffer.get_text(buffer.get_start_iter(),
2028	buffer.get_end_iter(),
2029	True)!="")
2030
2031	def _metarInserted(self, textBuffer, iter, text, length):
2032	"""Called when new characters are inserted into the METAR.
2033
2034	It uppercases all characters."""
2035	if not self._uppercasingMETAR:
2036	self._uppercasingMETAR = True
2037
2038	iter1 = iter.copy()
2039	iter1.backward_chars(length)
2040	textBuffer.delete(iter, iter1)
2041
2042	textBuffer.insert(iter, text.upper())
2043
2044	self._uppercasingMETAR = False
2045
2046	#-----------------------------------------------------------------------------
2047
2048	class TakeoffPage(Page):
2049	"""Page for entering the takeoff data."""
2050	def __init__(self, wizard):
2051	"""Construct the takeoff page."""
2052	super(TakeoffPage, self).__init__(wizard, xstr("takeoff_title"),
2053	xstr("takeoff_help"),
2054	completedHelp = xstr("takeoff_chelp"))
2055
2056	self._forwardAllowed = False
2057
2058	alignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
2059	xscale = 0.0, yscale = 0.0)
2060
2061	table = gtk.Table(8, 4)
2062	table.set_row_spacings(4)
2063	table.set_col_spacings(16)
2064	table.set_homogeneous(False)
2065	alignment.add(table)
2066	self.setMainWidget(alignment)
2067
2068	label = gtk.Label(xstr("takeoff_runway"))
2069	label.set_use_underline(True)
2070	label.set_alignment(0.0, 0.5)
2071	table.attach(label, 0, 1, 0, 1)
2072
2073	self._runway = gtk.Entry()
2074	self._runway.set_width_chars(10)
2075	self._runway.set_tooltip_text(xstr("takeoff_runway_tooltip"))
2076	self._runway.connect("changed", self._upperChanged)
2077	table.attach(self._runway, 1, 3, 0, 1)
2078	label.set_mnemonic_widget(self._runway)
2079
2080	label = gtk.Label(xstr("takeoff_sid"))
2081	label.set_use_underline(True)
2082	label.set_alignment(0.0, 0.5)
2083	table.attach(label, 0, 1, 1, 2)
2084
2085	self._sid = gtk.Entry()
2086	self._sid.set_width_chars(10)
2087	self._sid.set_tooltip_text(xstr("takeoff_sid_tooltip"))
2088	self._sid.connect("changed", self._upperChanged)
2089	table.attach(self._sid, 1, 3, 1, 2)
2090	label.set_mnemonic_widget(self._sid)
2091
2092	label = gtk.Label(xstr("takeoff_v1"))
2093	label.set_use_markup(True)
2094	label.set_use_underline(True)
2095	label.set_alignment(0.0, 0.5)
2096	table.attach(label, 0, 1, 2, 3)
2097
2098	self._v1 = IntegerEntry()
2099	self._v1.set_width_chars(4)
2100	self._v1.set_tooltip_markup(xstr("takeoff_v1_tooltip_knots"))
2101	self._v1.connect("integer-changed", self._valueChanged)
2102	table.attach(self._v1, 2, 3, 2, 3)
2103	label.set_mnemonic_widget(self._v1)
2104
2105	self._v1Unit = gtk.Label(xstr("label_knots"))
2106	self._v1Unit.set_alignment(0.0, 0.5)
2107	table.attach(self._v1Unit, 3, 4, 2, 3)
2108
2109	label = gtk.Label(xstr("takeoff_vr"))
2110	label.set_use_markup(True)
2111	label.set_use_underline(True)
2112	label.set_alignment(0.0, 0.5)
2113	table.attach(label, 0, 1, 3, 4)
2114
2115	self._vr = IntegerEntry()
2116	self._vr.set_width_chars(4)
2117	self._vr.set_tooltip_markup(xstr("takeoff_vr_tooltip_knots"))
2118	self._vr.connect("integer-changed", self._valueChanged)
2119	table.attach(self._vr, 2, 3, 3, 4)
2120	label.set_mnemonic_widget(self._vr)
2121
2122	self._vrUnit = gtk.Label(xstr("label_knots"))
2123	self._vrUnit.set_alignment(0.0, 0.5)
2124	table.attach(self._vrUnit, 3, 4, 3, 4)
2125
2126	label = gtk.Label(xstr("takeoff_v2"))
2127	label.set_use_markup(True)
2128	label.set_use_underline(True)
2129	label.set_alignment(0.0, 0.5)
2130	table.attach(label, 0, 1, 4, 5)
2131
2132	self._v2 = IntegerEntry()
2133	self._v2.set_width_chars(4)
2134	self._v2.set_tooltip_markup(xstr("takeoff_v2_tooltip_knots"))
2135	self._v2.connect("integer-changed", self._valueChanged)
2136	table.attach(self._v2, 2, 3, 4, 5)
2137	label.set_mnemonic_widget(self._v2)
2138
2139	self._v2Unit = gtk.Label(xstr("label_knots"))
2140	self._v2Unit.set_alignment(0.0, 0.5)
2141	table.attach(self._v2Unit, 3, 4, 4, 5)
2142
2143	self._hasDerate = False
2144
2145	self._derateLabel = gtk.Label()
2146	self._derateLabel.set_use_underline(True)
2147	self._derateLabel.set_markup(xstr("takeoff_derate_tupolev"))
2148	self._derateLabel.set_alignment(0.0, 0.5)
2149	table.attach(self._derateLabel, 0, 1, 5, 6)
2150
2151	self._derate = gtk.Entry()
2152	self._derate.set_width_chars(10)
2153	self._derate.set_tooltip_text(xstr("takeoff_derate_tooltip"))
2154	self._derate.set_alignment(1.0)
2155	self._derate.connect("changed", self._derateChanged)
2156	table.attach(self._derate, 1, 3, 5, 6)
2157	self._derateLabel.set_mnemonic_widget(self._derate)
2158
2159	self._derateUnit = gtk.Label("")
2160	self._derateUnit.set_use_markup(True)
2161	self._derateUnit.set_alignment(0.0, 0.5)
2162	table.attach(self._derateUnit, 3, 4, 5, 6)
2163
2164	self._antiIceOn = gtk.CheckButton(xstr("takeoff_antiice"))
2165	self._antiIceOn.set_use_underline(True)
2166	self._antiIceOn.set_tooltip_text(xstr("takeoff_antiice_tooltip"))
2167	table.attach(self._antiIceOn, 2, 4, 6, 7)
2168
2169	self._rto = gtk.CheckButton(xstr("takeoff_rto"))
2170	self._rto.set_use_underline(True)
2171	self._rto.set_tooltip_text(xstr("takeoff_rto_tooltip"))
2172	self._rto.connect("toggled", self._rtoToggled)
2173	table.attach(self._rto, 2, 4, 7, 8, ypadding = 8)
2174
2175	self.addCancelFlightButton()
2176
2177	self.addPreviousButton(clicked = self._backClicked)
2178
2179	self._button = self.addNextButton(clicked = self._forwardClicked)
2180
2181	@property
2182	def runway(self):
2183	"""Get the runway."""
2184	return self._runway.get_text()
2185
2186	@property
2187	def sid(self):
2188	"""Get the SID."""
2189	return self._sid.get_text()
2190
2191	@property
2192	def v1(self):
2193	"""Get the v1 speed."""
2194	return self._v1.get_int()
2195
2196	@property
2197	def vr(self):
2198	"""Get the vr speed."""
2199	return self._vr.get_int()
2200
2201	@property
2202	def v2(self):
2203	"""Get the v2 speed."""
2204	return self._v2.get_int()
2205
2206	@property
2207	def derate(self):
2208	"""Get the derate value, if any."""
2209	if self._hasDerate:
2210	derate = self._derate.get_text()
2211	return derate if derate else None
2212	else:
2213	return None
2214
2215	@property
2216	def antiIceOn(self):
2217	"""Get whether the anti-ice system has been turned on."""
2218	return self._antiIceOn.get_active()
2219
2220	@antiIceOn.setter
2221	def antiIceOn(self, value):
2222	"""Set the anti-ice indicator."""
2223	self._antiIceOn.set_active(value)
2224
2225	@property
2226	def rtoIndicated(self):
2227	"""Get whether the pilot has indicated if there was an RTO."""
2228	return self._rto.get_active()
2229
2230	def activate(self):
2231	"""Activate the page."""
2232	self._runway.set_text("")
2233	self._runway.set_sensitive(True)
2234	self._sid.set_text("")
2235	self._sid.set_sensitive(True)
2236	self._v1.set_int(None)
2237	self._v1.set_sensitive(True)
2238	self._vr.set_int(None)
2239	self._vr.set_sensitive(True)
2240	self._v2.set_int(None)
2241	self._v2.set_sensitive(True)
2242
2243	i18nSpeedUnit = self._wizard.gui.flight.getI18NSpeedUnit()
2244	speedUnit = xstr("label" + i18nSpeedUnit)
2245	self._v1Unit.set_text(speedUnit)
2246	self._vrUnit.set_text(speedUnit)
2247	self._v2Unit.set_text(speedUnit)
2248
2249	self._v1.set_tooltip_markup(xstr("takeoff_v1_tooltip" + i18nSpeedUnit))
2250	self._vr.set_tooltip_markup(xstr("takeoff_vr_tooltip" + i18nSpeedUnit))
2251	self._v2.set_tooltip_markup(xstr("takeoff_v2_tooltip" + i18nSpeedUnit))
2252
2253	(derateLabel, derateUnit) = \
2254	self._wizard.gui.flight.aircraft.derateLabels
2255
2256	self._hasDerate = derateLabel is not None
2257
2258	if self._hasDerate:
2259	self._derateLabel.set_markup(derateLabel)
2260	self._derateLabel.set_use_underline(True)
2261	self._derateUnit.set_markup("" if derateUnit is None
2262	else derateUnit)
2263	else:
2264	self._derateLabel.set_markup(xstr("takeoff_derate"))
2265	self._derateUnit.set_text("")
2266
2267	self._derate.set_text("")
2268
2269	self._derateLabel.set_sensitive(self._hasDerate)
2270	self._derate.set_sensitive(self._hasDerate)
2271	self._derateUnit.set_sensitive(self._hasDerate)
2272
2273	self._rto.set_active(False)
2274	self._rto.set_sensitive(False)
2275
2276	self._button.set_sensitive(False)
2277	self._forwardAllowed = False
2278
2279	def allowForward(self):
2280	"""Allow going to the next page."""
2281	self._forwardAllowed = True
2282	self._updateForwardButton()
2283
2284	def reset(self):
2285	"""Reset the page if the wizard is reset."""
2286	super(TakeoffPage, self).reset()
2287	self._v1.reset()
2288	self._vr.reset()
2289	self._v2.reset()
2290	self._hasDerate = False
2291	self._antiIceOn.set_active(False)
2292
2293	def setRTOEnabled(self, enabled):
2294	"""Set the RTO checkbox enabled or disabled."""
2295	if not enabled:
2296	self._rto.set_active(False)
2297	self._rto.set_sensitive(enabled)
2298
2299	def _updateForwardButton(self):
2300	"""Update the sensitivity of the forward button based on some conditions."""
2301	sensitive = self._forwardAllowed and \
2302	self._runway.get_text()!="" and \
2303	self._sid.get_text()!="" and \
2304	self.v1 is not None and \
2305	self.vr is not None and \
2306	self.v2 is not None and \
2307	self.v1 <= self.vr and \
2308	self.vr <= self.v2 and \
2309	(not self._hasDerate or self._derate.get_text()!="")
2310	self._button.set_sensitive(sensitive)
2311
2312	def _valueChanged(self, widget, arg = None):
2313	"""Called when the value of some widget has changed."""
2314	self._updateForwardButton()
2315
2316	def _upperChanged(self, entry, arg = None):
2317	"""Called when the value of some entry widget has changed and the value
2318	should be converted to uppercase."""
2319	entry.set_text(entry.get_text().upper())
2320	self._valueChanged(entry, arg)
2321
2322	def _derateChanged(self, entry):
2323	"""Called when the value of the derate is changed."""
2324	self._updateForwardButton()
2325
2326	def _rtoToggled(self, button):
2327	"""Called when the RTO check button is toggled."""
2328	self._wizard.rtoToggled(button.get_active())
2329
2330	def _backClicked(self, button):
2331	"""Called when the Back button is pressed."""
2332	self.goBack()
2333
2334	def _forwardClicked(self, button):
2335	"""Called when the forward button is clicked."""
2336	aircraft = self._wizard.gui.flight.aircraft
2337	aircraft.updateV1R2()
2338	if self._hasDerate:
2339	aircraft.updateDerate()
2340	aircraft.updateTakeoffAntiIce()
2341	self._wizard.nextPage()
2342
2343	#-----------------------------------------------------------------------------
2344
2345	class CruisePage(Page):
2346	"""The page containing the flight level that might change during flight."""
2347	def __init__(self, wizard):
2348	"""Construct the page."""
2349	super(CruisePage, self).__init__(wizard, xstr("cruise_title"),
2350	xstr("cruise_help"))
2351
2352	self._loggable = False
2353	self._loggedCruiseLevel = 240
2354	self._activated = False
2355
2356	alignment = gtk.Alignment(xalign = 0.5, yalign = 0.0,
2357	xscale = 0.0, yscale = 1.0)
2358
2359	mainBox = gtk.VBox()
2360	alignment.add(mainBox)
2361	self.setMainWidget(alignment)
2362
2363	alignment = gtk.Alignment(xalign = 0.0, yalign = 0.0,
2364	xscale = 0.0, yscale = 0.0)
2365	mainBox.pack_start(alignment, False, False, 16)
2366
2367	levelBox = gtk.HBox()
2368
2369	label = gtk.Label(xstr("route_level"))
2370	label.set_use_underline(True)
2371	levelBox.pack_start(label, True, True, 0)
2372
2373	self._cruiseLevel = gtk.SpinButton()
2374	self._cruiseLevel.set_increments(step = 10, page = 100)
2375	self._cruiseLevel.set_range(min = 50, max = 500)
2376	self._cruiseLevel.set_tooltip_text(xstr("cruise_route_level_tooltip"))
2377	self._cruiseLevel.set_numeric(True)
2378	self._cruiseLevel.connect("value-changed", self._cruiseLevelChanged)
2379	label.set_mnemonic_widget(self._cruiseLevel)
2380
2381	levelBox.pack_start(self._cruiseLevel, False, False, 8)
2382
2383	self._updateButton = gtk.Button(xstr("cruise_route_level_update"));
2384	self._updateButton.set_use_underline(True)
2385	self._updateButton.set_tooltip_text(xstr("cruise_route_level_update_tooltip"))
2386	self._updateButton.connect("clicked", self._updateButtonClicked)
2387
2388	levelBox.pack_start(self._updateButton, False, False, 16)
2389
2390	mainBox.pack_start(levelBox, False, False, 0)
2391
2392	alignment = gtk.Alignment(xalign = 0.0, yalign = 0.0,
2393	xscale = 0.0, yscale = 1.0)
2394	mainBox.pack_start(alignment, True, True, 0)
2395
2396	self.addCancelFlightButton()
2397
2398	self._backButton = self.addPreviousButton(clicked = self._backClicked)
2399	self._button = self.addNextButton(clicked = self._forwardClicked)
2400
2401	@property
2402	def activated(self):
2403	"""Determine if the page is already activated or not."""
2404	return self._activated
2405
2406	@property
2407	def cruiseLevel(self):
2408	"""Get the cruise level."""
2409	return self._loggedCruiseLevel
2410
2411	@property
2412	def loggableCruiseLevel(self):
2413	"""Get the cruise level which should be logged."""
2414	return self._cruiseLevel.get_value_as_int()
2415
2416	def setLoggable(self, loggable):
2417	"""Set whether the cruise altitude can be logged."""
2418	self._loggable = loggable
2419	self._updateButtons()
2420
2421	def activate(self):
2422	"""Setup the route from the booked flight."""
2423	self._loggedCruiseLevel = self._wizard.filedCruiseLevel
2424	self._cruiseLevel.set_value(self._loggedCruiseLevel)
2425	self._activated = True
2426
2427	def reset(self):
2428	"""Reset the page."""
2429	self._loggable = False
2430	self._activated = False
2431	super(CruisePage, self).reset()
2432
2433	def _updateButtons(self):
2434	"""Update the sensitivity of the buttons."""
2435	self._updateButton.set_sensitive(self._loggable and
2436	self.loggableCruiseLevel!=
2437	self._loggedCruiseLevel)
2438
2439	def _cruiseLevelChanged(self, spinButton):
2440	"""Called when the cruise level has changed."""
2441	self._updateButtons()
2442
2443	def _updateButtonClicked(self, button):
2444	"""Called when the update button is clicked."""
2445	if self._wizard.cruiseLevelChanged():
2446	self._loggedCruiseLevel = self.loggableCruiseLevel
2447	self._updateButtons()
2448
2449	def _backClicked(self, button):
2450	"""Called when the Back button is pressed."""
2451	self.goBack()
2452
2453	def _forwardClicked(self, button):
2454	"""Called when the Forward button is clicked."""
2455	self._wizard.nextPage()
2456
2457	#-----------------------------------------------------------------------------
2458
2459	class LandingPage(Page):
2460	"""Page for entering landing data."""
2461	def __init__(self, wizard):
2462	"""Construct the landing page."""
2463	super(LandingPage, self).__init__(wizard, xstr("landing_title"),
2464	xstr("landing_help"),
2465	completedHelp = xstr("landing_chelp"))
2466
2467	self._flightEnded = False
2468
2469	alignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
2470	xscale = 0.0, yscale = 0.0)
2471
2472	table = gtk.Table(6, 5)
2473	table.set_row_spacings(4)
2474	table.set_col_spacings(16)
2475	table.set_homogeneous(False)
2476	alignment.add(table)
2477	self.setMainWidget(alignment)
2478
2479	self._starButton = gtk.CheckButton()
2480	self._starButton.connect("clicked", self._starButtonClicked)
2481	table.attach(self._starButton, 0, 1, 0, 1)
2482
2483	label = gtk.Label(xstr("landing_star"))
2484	label.set_use_underline(True)
2485	label.set_alignment(0.0, 0.5)
2486	table.attach(label, 1, 2, 0, 1)
2487
2488	self._star = gtk.Entry()
2489	self._star.set_width_chars(10)
2490	self._star.set_tooltip_text(xstr("landing_star_tooltip"))
2491	self._star.connect("changed", self._upperChanged)
2492	self._star.set_sensitive(False)
2493	table.attach(self._star, 2, 4, 0, 1)
2494	label.set_mnemonic_widget(self._starButton)
2495
2496	self._transitionButton = gtk.CheckButton()
2497	self._transitionButton.connect("clicked", self._transitionButtonClicked)
2498	table.attach(self._transitionButton, 0, 1, 1, 2)
2499
2500	label = gtk.Label(xstr("landing_transition"))
2501	label.set_use_underline(True)
2502	label.set_alignment(0.0, 0.5)
2503	table.attach(label, 1, 2, 1, 2)
2504
2505	self._transition = gtk.Entry()
2506	self._transition.set_width_chars(10)
2507	self._transition.set_tooltip_text(xstr("landing_transition_tooltip"))
2508	self._transition.connect("changed", self._upperChanged)
2509	self._transition.set_sensitive(False)
2510	table.attach(self._transition, 2, 4, 1, 2)
2511	label.set_mnemonic_widget(self._transitionButton)
2512
2513	label = gtk.Label(xstr("landing_runway"))
2514	label.set_use_underline(True)
2515	label.set_alignment(0.0, 0.5)
2516	table.attach(label, 1, 2, 2, 3)
2517
2518	self._runway = gtk.Entry()
2519	self._runway.set_width_chars(10)
2520	self._runway.set_tooltip_text(xstr("landing_runway_tooltip"))
2521	self._runway.connect("changed", self._upperChanged)
2522	table.attach(self._runway, 2, 4, 2, 3)
2523	label.set_mnemonic_widget(self._runway)
2524
2525	label = gtk.Label(xstr("landing_approach"))
2526	label.set_use_underline(True)
2527	label.set_alignment(0.0, 0.5)
2528	table.attach(label, 1, 2, 3, 4)
2529
2530	self._approachType = gtk.Entry()
2531	self._approachType.set_width_chars(10)
2532	self._approachType.set_tooltip_text(xstr("landing_approach_tooltip"))
2533	self._approachType.connect("changed", self._upperChanged)
2534	table.attach(self._approachType, 2, 4, 3, 4)
2535	label.set_mnemonic_widget(self._approachType)
2536
2537	label = gtk.Label(xstr("landing_vref"))
2538	label.set_use_markup(True)
2539	label.set_use_underline(True)
2540	label.set_alignment(0.0, 0.5)
2541	table.attach(label, 1, 2, 4, 5)
2542
2543	self._vref = IntegerEntry()
2544	self._vref.set_width_chars(5)
2545	self._vref.set_tooltip_markup(xstr("landing_vref_tooltip_knots"))
2546	self._vref.connect("integer-changed", self._vrefChanged)
2547	table.attach(self._vref, 3, 4, 4, 5)
2548	label.set_mnemonic_widget(self._vref)
2549
2550	self._vrefUnit = gtk.Label(xstr("label_knots"))
2551	table.attach(self._vrefUnit, 4, 5, 4, 5)
2552
2553	self._antiIceOn = gtk.CheckButton(xstr("landing_antiice"))
2554	self._antiIceOn.set_use_underline(True)
2555	self._antiIceOn.set_tooltip_text(xstr("landing_antiice_tooltip"))
2556	table.attach(self._antiIceOn, 3, 5, 5, 6)
2557
2558	self.addCancelFlightButton()
2559
2560	self.addPreviousButton(clicked = self._backClicked)
2561
2562	self._button = self.addNextButton(clicked = self._forwardClicked)
2563
2564	# These are needed for correct size calculations
2565	self._starButton.set_active(True)
2566	self._transitionButton.set_active(True)
2567
2568	@property
2569	def star(self):
2570	"""Get the STAR or None if none entered."""
2571	return self._star.get_text() if self._starButton.get_active() else None
2572
2573	@property
2574	def transition(self):
2575	"""Get the transition or None if none entered."""
2576	return self._transition.get_text() \
2577	if self._transitionButton.get_active() else None
2578
2579	@property
2580	def approachType(self):
2581	"""Get the approach type."""
2582	return self._approachType.get_text()
2583
2584	@property
2585	def runway(self):
2586	"""Get the runway."""
2587	return self._runway.get_text()
2588
2589	@property
2590	def vref(self):
2591	"""Return the landing reference speed."""
2592	return self._vref.get_int()
2593
2594	@property
2595	def antiIceOn(self):
2596	"""Get whether the anti-ice system has been turned on."""
2597	return self._antiIceOn.get_active()
2598
2599	@antiIceOn.setter
2600	def antiIceOn(self, value):
2601	"""Set the anti-ice indicator."""
2602	self._antiIceOn.set_active(value)
2603
2604	def reset(self):
2605	"""Reset the page if the wizard is reset."""
2606	super(LandingPage, self).reset()
2607	self._vref.reset()
2608	self._antiIceOn.set_active(False)
2609	self._flightEnded = False
2610
2611	def activate(self):
2612	"""Called when the page is activated."""
2613	self._starButton.set_sensitive(True)
2614	self._starButton.set_active(False)
2615	self._star.set_text("")
2616
2617	self._transitionButton.set_sensitive(True)
2618	self._transitionButton.set_active(False)
2619	self._transition.set_text("")
2620
2621	self._runway.set_text("")
2622	self._runway.set_sensitive(True)
2623
2624	self._approachType.set_text("")
2625	self._approachType.set_sensitive(True)
2626
2627	self._vref.set_int(None)
2628	self._vref.set_sensitive(True)
2629
2630	i18nSpeedUnit = self._wizard.gui.flight.getI18NSpeedUnit()
2631	speedUnit = xstr("label" + i18nSpeedUnit)
2632	self._vrefUnit.set_text(speedUnit)
2633
2634	self._vref.set_tooltip_markup(xstr("landing_vref_tooltip" +
2635	i18nSpeedUnit))
2636
2637	self._updateForwardButton()
2638
2639	def flightEnded(self):
2640	"""Called when the flight has ended."""
2641	super(LandingPage, self).flightEnded()
2642	self._flightEnded = True
2643	self._updateForwardButton()
2644
2645	def _starButtonClicked(self, button):
2646	"""Called when the STAR button is clicked."""
2647	active = button.get_active()
2648	self._star.set_sensitive(active)
2649	if active:
2650	self._star.grab_focus()
2651	self._updateForwardButton()
2652
2653	def _transitionButtonClicked(self, button):
2654	"""Called when the Transition button is clicked."""
2655	active = button.get_active()
2656	self._transition.set_sensitive(active)
2657	if active:
2658	self._transition.grab_focus()
2659	self._updateForwardButton()
2660
2661	def _updateForwardButton(self):
2662	"""Update the sensitivity of the forward button."""
2663	sensitive = self._flightEnded and \
2664	(self._starButton.get_active() or \
2665	self._transitionButton.get_active()) and \
2666	(self._star.get_text()!="" or
2667	not self._starButton.get_active()) and \
2668	(self._transition.get_text()!="" or
2669	not self._transitionButton.get_active()) and \
2670	self._runway.get_text()!="" and \
2671	self._approachType.get_text()!="" and \
2672	self.vref is not None
2673	self._button.set_sensitive(sensitive)
2674
2675	def _upperChanged(self, entry):
2676	"""Called for entry widgets that must be converted to uppercase."""
2677	entry.set_text(entry.get_text().upper())
2678	self._updateForwardButton()
2679
2680	def _vrefChanged(self, widget, value):
2681	"""Called when the Vref has changed."""
2682	self._updateForwardButton()
2683
2684	def _backClicked(self, button):
2685	"""Called when the Back button is pressed."""
2686	self.goBack()
2687
2688	def _forwardClicked(self, button):
2689	"""Called when the forward button is clicked."""
2690	aircraft = self._wizard.gui.flight.aircraft
2691	aircraft.updateVRef()
2692	aircraft.updateLandingAntiIce()
2693	if self._wizard.gui.config.onlineGateSystem and \
2694	self._wizard.loggedIn and not self._completed and \
2695	self._wizard.bookedFlight.arrivalICAO=="LHBP" and \
2696	not self._wizard.entranceExam:
2697	self._wizard.getFleet(callback = self._fleetRetrieved,
2698	force = True)
2699	else:
2700	self._wizard.nextPage()
2701
2702	def _fleetRetrieved(self, fleet):
2703	"""Callback for the fleet retrieval."""
2704	self._wizard.nextPage()
2705
2706	#-----------------------------------------------------------------------------
2707
2708	class FinishPage(Page):
2709	"""Flight finish page."""
2710	_flightTypes = [ ("flighttype_scheduled", const.FLIGHTTYPE_SCHEDULED),
2711	("flighttype_ot", const.FLIGHTTYPE_OLDTIMER),
2712	("flighttype_vip", const.FLIGHTTYPE_VIP),
2713	("flighttype_charter", const.FLIGHTTYPE_CHARTER) ]
2714
2715	def __init__(self, wizard):
2716	"""Construct the finish page."""
2717	super(FinishPage, self).__init__(wizard, xstr("finish_title"),
2718	xstr("finish_help"))
2719
2720	alignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
2721	xscale = 0.0, yscale = 0.0)
2722
2723	table = gtk.Table(8, 2)
2724	table.set_row_spacings(4)
2725	table.set_col_spacings(16)
2726	table.set_homogeneous(False)
2727	alignment.add(table)
2728	self.setMainWidget(alignment)
2729
2730	labelAlignment = gtk.Alignment(xalign=1.0, xscale=0.0)
2731	label = gtk.Label(xstr("finish_rating"))
2732	labelAlignment.add(label)
2733	table.attach(labelAlignment, 0, 1, 0, 1)
2734
2735	labelAlignment = gtk.Alignment(xalign=0.0, xscale=0.0)
2736	self._flightRating = gtk.Label()
2737	self._flightRating.set_width_chars(8)
2738	self._flightRating.set_alignment(0.0, 0.5)
2739	self._flightRating.set_use_markup(True)
2740	labelAlignment.add(self._flightRating)
2741	table.attach(labelAlignment, 1, 2, 0, 1)
2742
2743	labelAlignment = gtk.Alignment(xalign=1.0, xscale=0.0)
2744	label = gtk.Label(xstr("finish_flight_time"))
2745	labelAlignment.add(label)
2746	table.attach(labelAlignment, 0, 1, 1, 2)
2747
2748	labelAlignment = gtk.Alignment(xalign=0.0, xscale=0.0)
2749	self._flightTime = gtk.Label()
2750	self._flightTime.set_width_chars(10)
2751	self._flightTime.set_alignment(0.0, 0.5)
2752	self._flightTime.set_use_markup(True)
2753	labelAlignment.add(self._flightTime)
2754	table.attach(labelAlignment, 1, 2, 1, 2)
2755
2756	labelAlignment = gtk.Alignment(xalign=1.0, xscale=0.0)
2757	label = gtk.Label(xstr("finish_block_time"))
2758	labelAlignment.add(label)
2759	table.attach(labelAlignment, 0, 1, 2, 3)
2760
2761	labelAlignment = gtk.Alignment(xalign=0.0, xscale=0.0)
2762	self._blockTime = gtk.Label()
2763	self._blockTime.set_width_chars(10)
2764	self._blockTime.set_alignment(0.0, 0.5)
2765	self._blockTime.set_use_markup(True)
2766	labelAlignment.add(self._blockTime)
2767	table.attach(labelAlignment, 1, 2, 2, 3)
2768
2769	labelAlignment = gtk.Alignment(xalign=1.0, xscale=0.0)
2770	label = gtk.Label(xstr("finish_distance"))
2771	labelAlignment.add(label)
2772	table.attach(labelAlignment, 0, 1, 3, 4)
2773
2774	labelAlignment = gtk.Alignment(xalign=0.0, xscale=0.0)
2775	self._distanceFlown = gtk.Label()
2776	self._distanceFlown.set_width_chars(10)
2777	self._distanceFlown.set_alignment(0.0, 0.5)
2778	self._distanceFlown.set_use_markup(True)
2779	labelAlignment.add(self._distanceFlown)
2780	table.attach(labelAlignment, 1, 2, 3, 4)
2781
2782	labelAlignment = gtk.Alignment(xalign=1.0, xscale=0.0)
2783	label = gtk.Label(xstr("finish_fuel"))
2784	labelAlignment.add(label)
2785	table.attach(labelAlignment, 0, 1, 4, 5)
2786
2787	labelAlignment = gtk.Alignment(xalign=0.0, xscale=0.0)
2788	self._fuelUsed = gtk.Label()
2789	self._fuelUsed.set_width_chars(10)
2790	self._fuelUsed.set_alignment(0.0, 0.5)
2791	self._fuelUsed.set_use_markup(True)
2792	labelAlignment.add(self._fuelUsed)
2793	table.attach(labelAlignment, 1, 2, 4, 5)
2794
2795	labelAlignment = gtk.Alignment(xalign = 1.0, xscale = 0.0,
2796	yalign = 0.5, yscale = 0.0)
2797	label = gtk.Label(xstr("finish_type"))
2798	label.set_use_underline(True)
2799	labelAlignment.add(label)
2800	table.attach(labelAlignment, 0, 1, 5, 6)
2801
2802	flightTypeModel = gtk.ListStore(str, int)
2803	for (name, type) in FinishPage._flightTypes:
2804	flightTypeModel.append([xstr(name), type])
2805
2806	self._flightType = gtk.ComboBox(model = flightTypeModel)
2807	renderer = gtk.CellRendererText()
2808	self._flightType.pack_start(renderer, True)
2809	self._flightType.add_attribute(renderer, "text", 0)
2810	self._flightType.set_tooltip_text(xstr("finish_type_tooltip"))
2811	self._flightType.set_active(0)
2812	self._flightType.connect("changed", self._flightTypeChanged)
2813	flightTypeAlignment = gtk.Alignment(xalign=0.0, xscale=0.0)
2814	flightTypeAlignment.add(self._flightType)
2815	table.attach(flightTypeAlignment, 1, 2, 5, 6)
2816	label.set_mnemonic_widget(self._flightType)
2817
2818	self._onlineFlight = gtk.CheckButton(xstr("finish_online"))
2819	self._onlineFlight.set_use_underline(True)
2820	self._onlineFlight.set_tooltip_text(xstr("finish_online_tooltip"))
2821	onlineFlightAlignment = gtk.Alignment(xalign=0.0, xscale=0.0)
2822	onlineFlightAlignment.add(self._onlineFlight)
2823	table.attach(onlineFlightAlignment, 1, 2, 6, 7)
2824
2825	labelAlignment = gtk.Alignment(xalign = 1.0, xscale = 0.0,
2826	yalign = 0.5, yscale = 0.0)
2827	self._gateLabel = gtk.Label(xstr("finish_gate"))
2828	self._gateLabel.set_use_underline(True)
2829	labelAlignment.add(self._gateLabel)
2830	table.attach(labelAlignment, 0, 1, 7, 8)
2831
2832	self._gatesModel = gtk.ListStore(str)
2833
2834	self._gate = gtk.ComboBox(model = self._gatesModel)
2835	renderer = gtk.CellRendererText()
2836	self._gate.pack_start(renderer, True)
2837	self._gate.add_attribute(renderer, "text", 0)
2838	self._gate.set_tooltip_text(xstr("finish_gate_tooltip"))
2839	self._gate.connect("changed", self._gateChanged)
2840	gateAlignment = gtk.Alignment(xalign=0.0, xscale=1.0)
2841	gateAlignment.add(self._gate)
2842	table.attach(gateAlignment, 1, 2, 7, 8)
2843	self._gateLabel.set_mnemonic_widget(self._gate)
2844
2845	self.addButton(xstr("finish_newFlight"),
2846	sensitive = True,
2847	clicked = self._newFlightClicked,
2848	tooltip = xstr("finish_newFlight_tooltip"),
2849	padding = 16)
2850
2851	self.addPreviousButton(clicked = self._backClicked)
2852
2853	self._saveButton = self.addButton(xstr("finish_save"),
2854	sensitive = False,
2855	clicked = self._saveClicked,
2856	tooltip = xstr("finish_save_tooltip"))
2857	self._savePIREPDialog = None
2858	self._lastSavePath = None
2859
2860	self._pirepSaved = False
2861	self._pirepSent = False
2862
2863	self._sendButton = self.addButton(xstr("sendPIREP"), default = True,
2864	sensitive = False,
2865	clicked = self._sendClicked,
2866	tooltip = xstr("sendPIREP_tooltip"))
2867
2868	@property
2869	def flightType(self):
2870	"""Get the flight type."""
2871	index = self._flightType.get_active()
2872	return None if index<0 else self._flightType.get_model()[index][1]
2873
2874	@property
2875	def online(self):
2876	"""Get whether the flight was an online flight or not."""
2877	return self._onlineFlight.get_active()
2878
2879	def activate(self):
2880	"""Activate the page."""
2881	self._pirepSaved = False
2882	self._pirepSent = False
2883
2884	flight = self._wizard.gui._flight
2885	rating = flight.logger.getRating()
2886	if rating<0:
2887	self._flightRating.set_markup('<b><span foreground="red">NO GO</span></b>')
2888	else:
2889	self._flightRating.set_markup("<b>%.1f %%</b>" % (rating,))
2890
2891	flightLength = flight.flightTimeEnd - flight.flightTimeStart
2892	self._flightTime.set_markup("<b>%s</b>" % \
2893	(util.getTimeIntervalString(flightLength),))
2894
2895	blockLength = flight.blockTimeEnd - flight.blockTimeStart
2896	self._blockTime.set_markup("<b>%s</b>" % \
2897	(util.getTimeIntervalString(blockLength),))
2898
2899	self._distanceFlown.set_markup("<b>%.2f NM</b>" % \
2900	(flight.flownDistance,))
2901
2902	self._fuelUsed.set_markup("<b>%.0f kg</b>" % \
2903	(flight.startFuel - flight.endFuel,))
2904
2905	self._flightType.set_active(-1)
2906	self._onlineFlight.set_active(self._wizard.loggedIn)
2907
2908	self._gatesModel.clear()
2909	if self._wizard.gui.config.onlineGateSystem and \
2910	self._wizard.loggedIn and \
2911	self._wizard.bookedFlight.arrivalICAO=="LHBP" and \
2912	not self._wizard.entranceExam:
2913	occupiedGates = self._wizard._fleet.getOccupiedGateNumbers()
2914	for gateNumber in const.lhbpGateNumbers:
2915	if gateNumber not in occupiedGates:
2916	self._gatesModel.append([gateNumber])
2917	self._gateLabel.set_sensitive(True)
2918	self._gate.set_sensitive(True)
2919	self._gate.set_active(-1)
2920	else:
2921	self._gateLabel.set_sensitive(False)
2922	self._gate.set_sensitive(False)
2923
2924	def _backClicked(self, button):
2925	"""Called when the Back button is pressed."""
2926	self.goBack()
2927
2928	def _updateButtons(self):
2929	"""Update the sensitivity state of the buttons."""
2930	sensitive = self._flightType.get_active()>=0 and \
2931	(self._gatesModel.get_iter_first() is None or
2932	self._gate.get_active()>=0)
2933
2934	wasSensitive = self._saveButton.get_sensitive()
2935
2936	gui = self._wizard.gui
2937	config = gui.config
2938	if config.pirepAutoSave and sensitive and not wasSensitive:
2939	self._lastSavePath = os.path.join(config.pirepDirectory,
2940	self._getDefaultPIREPName())
2941	self._lastSavePath = text2unicode(self._lastSavePath)
2942	self._savePIREP(automatic = True)
2943
2944	self._saveButton.set_sensitive(sensitive)
2945	self._sendButton.set_sensitive(sensitive and
2946	self._wizard.bookedFlight.id is not None)
2947
2948	def _flightTypeChanged(self, comboBox):
2949	"""Called when the flight type has changed."""
2950	self._updateButtons()
2951
2952	def _gateChanged(self, comboBox):
2953	"""Called when the arrival gate has changed."""
2954	self._updateButtons()
2955
2956	def _newFlightClicked(self, button):
2957	"""Called when the new flight button is clicked."""
2958	gui = self._wizard.gui
2959	if not self._pirepSent and not self._pirepSaved:
2960	dialog = gtk.MessageDialog(parent = gui.mainWindow,
2961	type = MESSAGETYPE_QUESTION,
2962	message_format = xstr("finish_newFlight_question"))
2963
2964	dialog.add_button(xstr("button_no"), RESPONSETYPE_NO)
2965	dialog.add_button(xstr("button_yes"), RESPONSETYPE_YES)
2966
2967	dialog.set_title(WINDOW_TITLE_BASE)
2968	result = dialog.run()
2969	dialog.hide()
2970	if result!=RESPONSETYPE_YES:
2971	return
2972
2973	gui.reset()
2974
2975	def _getDefaultPIREPName(self):
2976	"""Get the default name of the PIREP."""
2977	gui = self._wizard.gui
2978
2979	bookedFlight = gui.bookedFlight
2980	tm = time.gmtime()
2981
2982	pilotID = self._wizard.pilotID
2983	if pilotID: pilotID += " "
2984	return "%s%s %02d%02d %s-%s.pirep" % \
2985	(pilotID, str(bookedFlight.departureTime.date()),
2986	tm.tm_hour, tm.tm_min,
2987	bookedFlight.departureICAO, bookedFlight.arrivalICAO)
2988
2989
2990	def _saveClicked(self, button):
2991	"""Called when the Save PIREP button is clicked."""
2992	gui = self._wizard.gui
2993
2994	fileName = self._getDefaultPIREPName()
2995
2996	dialog = self._getSaveDialog()
2997
2998	if self._lastSavePath is None:
2999	pirepDirectory = gui.config.pirepDirectory
3000	if pirepDirectory is not None:
3001	dialog.set_current_folder(pirepDirectory)
3002	else:
3003	dialog.set_current_folder(os.path.dirname(self._lastSavePath))
3004
3005	dialog.set_current_name(fileName)
3006	result = dialog.run()
3007	dialog.hide()
3008
3009	if result==RESPONSETYPE_OK:
3010	self._lastSavePath = text2unicode(dialog.get_filename())
3011	self._savePIREP()
3012
3013	def _savePIREP(self, automatic = False):
3014	"""Perform the saving of the PIREP."""
3015
3016	gui = self._wizard.gui
3017
3018	if automatic:
3019	gui.beginBusy(xstr("finish_autosave_busy"))
3020
3021	pirep = PIREP(gui.flight)
3022	error = pirep.save(self._lastSavePath)
3023
3024	if automatic:
3025	gui.endBusy()
3026
3027	if error:
3028	type = MESSAGETYPE_ERROR
3029	message = xstr("finish_save_failed")
3030	secondary = xstr("finish_save_failed_sec") % (text2unicode(error),)
3031	else:
3032	type = MESSAGETYPE_INFO
3033	message = xstr("finish_save_done")
3034	if automatic:
3035	secondary = xstr("finish_save_done_sec") % (self._lastSavePath,)
3036	else:
3037	secondary = None
3038	self._pirepSaved = True
3039
3040	dialog = gtk.MessageDialog(parent = gui.mainWindow,
3041	type = type, message_format = message)
3042	dialog.add_button(xstr("button_ok"), RESPONSETYPE_OK)
3043	dialog.set_title(WINDOW_TITLE_BASE)
3044	if secondary is not None:
3045	dialog.format_secondary_markup(secondary)
3046
3047	dialog.run()
3048	dialog.hide()
3049
3050	def _getSaveDialog(self):
3051	"""Get the PIREP saving dialog.
3052
3053	If it does not exist yet, create it."""
3054	if self._savePIREPDialog is None:
3055	gui = self._wizard.gui
3056	dialog = gtk.FileChooserDialog(title = WINDOW_TITLE_BASE + " - " +
3057	xstr("finish_save_title"),
3058	action = FILE_CHOOSER_ACTION_SAVE,
3059	buttons = (gtk.STOCK_CANCEL,
3060	RESPONSETYPE_CANCEL,
3061	gtk.STOCK_OK, RESPONSETYPE_OK),
3062	parent = gui.mainWindow)
3063	dialog.set_modal(True)
3064	dialog.set_do_overwrite_confirmation(True)
3065
3066	filter = gtk.FileFilter()
3067	filter.set_name(xstr("file_filter_pireps"))
3068	filter.add_pattern("*.pirep")
3069	dialog.add_filter(filter)
3070
3071	filter = gtk.FileFilter()
3072	filter.set_name(xstr("file_filter_all"))
3073	filter.add_pattern(".")
3074	dialog.add_filter(filter)
3075
3076	self._savePIREPDialog = dialog
3077
3078	return self._savePIREPDialog
3079
3080
3081	def _sendClicked(self, button):
3082	"""Called when the Send button is clicked."""
3083	pirep = PIREP(self._wizard.gui.flight)
3084	self._wizard.gui.sendPIREP(pirep,
3085	callback = self._handlePIREPSent)
3086
3087	def _handlePIREPSent(self, returned, result):
3088	"""Callback for the PIREP sending result."""
3089	self._pirepSent = returned and result.success
3090	if self._wizard.gui.config.onlineGateSystem and \
3091	self._wizard.loggedIn and not self._wizard.entranceExam and \
3092	returned and result.success:
3093	bookedFlight = self._wizard.bookedFlight
3094	if bookedFlight.arrivalICAO=="LHBP":
3095	iter = self._gate.get_active_iter()
3096	gateNumber = None if iter is None \
3097	else self._gatesModel.get_value(iter, 0)
3098
3099	status = const.PLANE_PARKING if gateNumber is None \
3100	else const.PLANE_HOME
3101	else:
3102	gateNumber = None
3103	status = const.PLANE_AWAY
3104
3105	self._wizard.updatePlane(self._planeUpdated,
3106	bookedFlight.tailNumber,
3107	status, gateNumber = gateNumber)
3108
3109	def _planeUpdated(self, success):
3110	"""Callback for the plane updating."""
3111	pass
3112
3113	#-----------------------------------------------------------------------------
3114
3115	class Wizard(gtk.VBox):
3116	"""The flight wizard."""
3117	def __init__(self, gui):
3118	"""Construct the wizard."""
3119	super(Wizard, self).__init__()
3120
3121	self.gui = gui
3122
3123	self._pages = []
3124	self._currentPage = None
3125
3126	self._loginPage = LoginPage(self)
3127	self._pages.append(self._loginPage)
3128	self._pages.append(FlightSelectionPage(self))
3129	self._pages.append(GateSelectionPage(self))
3130	self._pages.append(ConnectPage(self))
3131	self._payloadPage = PayloadPage(self)
3132	self._pages.append(self._payloadPage)
3133	self._payloadIndex = len(self._pages)
3134	self._pages.append(TimePage(self))
3135	self._pages.append(FuelPage(self))
3136	self._routePage = RoutePage(self)
3137	self._pages.append(self._routePage)
3138	self._departureBriefingPage = BriefingPage(self, True)
3139	self._pages.append(self._departureBriefingPage)
3140	self._arrivalBriefingPage = BriefingPage(self, False)
3141	self._pages.append(self._arrivalBriefingPage)
3142	self._arrivalBriefingIndex = len(self._pages)
3143	self._takeoffPage = TakeoffPage(self)
3144	self._pages.append(self._takeoffPage)
3145	self._cruisePage = CruisePage(self)
3146	self._pages.append(self._cruisePage)
3147	self._landingPage = LandingPage(self)
3148	self._pages.append(self._landingPage)
3149	self._finishPage = FinishPage(self)
3150	self._pages.append(self._finishPage)
3151
3152	maxWidth = 0
3153	maxHeight = 0
3154	for page in self._pages:
3155	page.show_all()
3156	pageSizeRequest = page.size_request()
3157	width = pageSizeRequest.width if pygobject else pageSizeRequest[0]
3158	height = pageSizeRequest.height if pygobject else pageSizeRequest[1]
3159	maxWidth = max(maxWidth, width)
3160	maxHeight = max(maxHeight, height)
3161	page.setStyle()
3162	maxWidth += 16
3163	maxHeight += 32
3164	self.set_size_request(maxWidth, maxHeight)
3165
3166	self._initialize()
3167
3168	@property
3169	def pilotID(self):
3170	"""Get the pilot ID, if given."""
3171	return self._loginPage.pilotID
3172
3173	@property
3174	def entranceExam(self):
3175	"""Get whether an entrance exam is about to be taken."""
3176	return self._loginPage.entranceExam
3177
3178	@property
3179	def loggedIn(self):
3180	"""Indicate if there was a successful login."""
3181	return self._loginResult is not None
3182
3183	@property
3184	def loginResult(self):
3185	"""Get the login result."""
3186	return self._loginResult
3187
3188	def setCurrentPage(self, index, finalize = False):
3189	"""Set the current page to the one with the given index."""
3190	assert index < len(self._pages)
3191
3192	fromPage = self._currentPage
3193	if fromPage is not None:
3194	page = self._pages[fromPage]
3195	if finalize and not page._completed:
3196	page.complete()
3197	self.remove(page)
3198
3199	self._currentPage = index
3200	page = self._pages[index]
3201	self.add(page)
3202	if page._fromPage is None:
3203	page._fromPage = fromPage
3204	page.initialize()
3205	self.show_all()
3206	if fromPage is not None:
3207	self.grabDefault()
3208
3209	@property
3210	def bookedFlight(self):
3211	"""Get the booked flight selected."""
3212	return self._bookedFlight
3213
3214	@property
3215	def numCrew(self):
3216	"""Get the number of crew members."""
3217	return self._payloadPage.numCrew
3218
3219	@property
3220	def numPassengers(self):
3221	"""Get the number of passengers."""
3222	return self._payloadPage.numPassengers
3223
3224	@property
3225	def bagWeight(self):
3226	"""Get the baggage weight."""
3227	return self._payloadPage.bagWeight
3228
3229	@property
3230	def cargoWeight(self):
3231	"""Get the cargo weight."""
3232	return self._payloadPage.cargoWeight
3233
3234	@property
3235	def mailWeight(self):
3236	"""Get the mail weight."""
3237	return self._payloadPage.mailWeight
3238
3239	@property
3240	def zfw(self):
3241	"""Get the calculated ZFW value."""
3242	return 0 if self._bookedFlight is None \
3243	else self._payloadPage.calculateZFW()
3244
3245	@property
3246	def filedCruiseLevel(self):
3247	"""Get the filed cruise level."""
3248	return self._routePage.filedCruiseLevel
3249
3250	@property
3251	def filedCruiseAltitude(self):
3252	"""Get the filed cruise altitude."""
3253	return self._routePage.filedCruiseLevel * 100
3254
3255	@property
3256	def cruiseAltitude(self):
3257	"""Get the cruise altitude."""
3258	level = self._cruisePage.cruiseLevel if self._cruisePage.activated \
3259	else self._routePage.filedCruiseLevel
3260	return level * 100
3261
3262	@property
3263	def loggableCruiseAltitude(self):
3264	"""Get the cruise altitude that can be logged."""
3265	if self._cruisePage.activated:
3266	return self._cruisePage.loggableCruiseLevel * 100
3267	else:
3268	return 0
3269
3270	@property
3271	def route(self):
3272	"""Get the route."""
3273	return self._routePage.route
3274
3275	@property
3276	def departureMETAR(self):
3277	"""Get the METAR of the departure airport."""
3278	return self._departureBriefingPage.metar
3279
3280	@property
3281	def arrivalMETAR(self):
3282	"""Get the METAR of the arrival airport."""
3283	return self._arrivalBriefingPage.metar
3284
3285	@property
3286	def departureRunway(self):
3287	"""Get the departure runway."""
3288	return self._takeoffPage.runway
3289
3290	@property
3291	def sid(self):
3292	"""Get the SID."""
3293	return self._takeoffPage.sid
3294
3295	@property
3296	def v1(self):
3297	"""Get the V1 speed."""
3298	return self._takeoffPage.v1
3299
3300	@property
3301	def vr(self):
3302	"""Get the Vr speed."""
3303	return self._takeoffPage.vr
3304
3305	@property
3306	def v2(self):
3307	"""Get the V2 speed."""
3308	return self._takeoffPage.v2
3309
3310	@property
3311	def derate(self):
3312	"""Get the derate value."""
3313	return self._takeoffPage.derate
3314
3315	@property
3316	def takeoffAntiIceOn(self):
3317	"""Get whether the anti-ice system was on during take-off."""
3318	return self._takeoffPage.antiIceOn
3319
3320	@takeoffAntiIceOn.setter
3321	def takeoffAntiIceOn(self, value):
3322	"""Set anti-ice on indicator."""
3323	self._takeoffPage.antiIceOn = value
3324
3325	@property
3326	def rtoIndicated(self):
3327	"""Get whether the pilot has indicated that an RTO has occured."""
3328	return self._takeoffPage.rtoIndicated
3329
3330	@property
3331	def arrivalRunway(self):
3332	"""Get the arrival runway."""
3333	return self._landingPage.runway
3334
3335	@property
3336	def star(self):
3337	"""Get the STAR."""
3338	return self._landingPage.star
3339
3340	@property
3341	def transition(self):
3342	"""Get the transition."""
3343	return self._landingPage.transition
3344
3345	@property
3346	def approachType(self):
3347	"""Get the approach type."""
3348	return self._landingPage.approachType
3349
3350	@property
3351	def vref(self):
3352	"""Get the Vref speed."""
3353	return self._landingPage.vref
3354
3355	@property
3356	def landingAntiIceOn(self):
3357	"""Get whether the anti-ice system was on during landing."""
3358	return self._landingPage.antiIceOn
3359
3360	@landingAntiIceOn.setter
3361	def landingAntiIceOn(self, value):
3362	"""Set anti-ice on indicator."""
3363	self._landingPage.antiIceOn = value
3364
3365	@property
3366	def flightType(self):
3367	"""Get the flight type."""
3368	return self._finishPage.flightType
3369
3370	@property
3371	def online(self):
3372	"""Get whether the flight was online or not."""
3373	return self._finishPage.online
3374
3375	def nextPage(self, finalize = True):
3376	"""Go to the next page."""
3377	self.jumpPage(1, finalize)
3378
3379	def jumpPage(self, count, finalize = True):
3380	"""Go to the page which is 'count' pages after the current one."""
3381	self.setCurrentPage(self._currentPage + count, finalize = finalize)
3382
3383	def grabDefault(self):
3384	"""Make the default button of the current page the default."""
3385	self._pages[self._currentPage].grabDefault()
3386
3387	def connected(self, fsType, descriptor):
3388	"""Called when the connection could be made to the simulator."""
3389	self.nextPage()
3390
3391	def reset(self, loginResult):
3392	"""Resets the wizard to go back to the login page."""
3393	self._initialize(keepLoginResult = loginResult is None,
3394	loginResult = loginResult)
3395
3396	def setStage(self, stage):
3397	"""Set the flight stage to the given one."""
3398	if stage!=const.STAGE_END:
3399	self._cruisePage.setLoggable(Flight.canLogCruiseAltitude(stage))
3400
3401	if stage==const.STAGE_TAKEOFF:
3402	self._takeoffPage.allowForward()
3403	elif stage==const.STAGE_LANDING:
3404	if not self._arrivalBriefingPage.metarEdited:
3405	print "Downloading arrival METAR again"
3406	self.gui.webHandler.getMETARs(self._arrivalMETARCallback,
3407	[self._bookedFlight.arrivalICAO])
3408
3409	elif stage==const.STAGE_END:
3410	for page in self._pages:
3411	page.flightEnded()
3412
3413	def _initialize(self, keepLoginResult = False, loginResult = None):
3414	"""Initialize the wizard."""
3415	if not keepLoginResult:
3416	self._loginResult = loginResult
3417
3418	self._loginCallback = None
3419
3420	self._fleet = None
3421	self._fleetCallback = None
3422
3423	self._bookedFlight = None
3424	self._departureGate = "-"
3425	self._fuelData = None
3426	self._departureNOTAMs = None
3427	self._departureMETAR = None
3428	self._arrivalNOTAMs = None
3429	self._arrivalMETAR = None
3430
3431	firstPage = 0 if self._loginResult is None else 1
3432	for page in self._pages[firstPage:]:
3433	page.reset()
3434
3435	self.setCurrentPage(firstPage)
3436
3437	def login(self, callback, pilotID, password, entranceExam):
3438	"""Called when the login button was clicked."""
3439	self._loginCallback = callback
3440	if pilotID is None:
3441	loginResult = self._loginResult
3442	assert loginResult is not None and loginResult.loggedIn
3443	pilotID = loginResult.pilotID
3444	password = loginResult.password
3445	entranceExam = loginResult.entranceExam
3446	busyMessage = xstr("reload_busy")
3447	else:
3448	self._loginResult = None
3449	busyMessage = xstr("login_busy")
3450
3451	self.gui.beginBusy(busyMessage)
3452
3453	self.gui.webHandler.login(self._loginResultCallback,
3454	pilotID, password,
3455	entranceExam = entranceExam)
3456
3457	def reloadFlights(self, callback):
3458	"""Reload the flights from the MAVA server."""
3459	self.login(callback, None, None, None)
3460
3461	def cruiseLevelChanged(self):
3462	"""Called when the cruise level is changed."""
3463	return self.gui.cruiseLevelChanged()
3464
3465	def _loginResultCallback(self, returned, result):
3466	"""The login result callback, called in the web handler's thread."""
3467	gobject.idle_add(self._handleLoginResult, returned, result)
3468
3469	def _handleLoginResult(self, returned, result):
3470	"""Handle the login result."""
3471	self.gui.endBusy()
3472	isReload = self._loginResult is not None
3473	if returned:
3474	if result.loggedIn:
3475	self._loginResult = result
3476	else:
3477	if isReload:
3478	message = xstr("reload_failed")
3479	else:
3480	message = xstr("login_entranceExam_invalid"
3481	if self.entranceExam else
3482	xstr("login_invalid"))
3483	dialog = gtk.MessageDialog(parent = self.gui.mainWindow,
3484	type = MESSAGETYPE_ERROR,
3485	message_format = message)
3486	dialog.add_button(xstr("button_ok"), RESPONSETYPE_OK)
3487	dialog.set_title(WINDOW_TITLE_BASE)
3488	if isReload:
3489	secondary = xstr("reload_failed_sec")
3490	else:
3491	secondary = xstr("login_entranceExam_invalid_sec"
3492	if self.entranceExam else
3493	xstr("login_invalid_sec"))
3494	dialog.format_secondary_markup(secondary)
3495	dialog.run()
3496	dialog.hide()
3497	else:
3498	message = xstr("reload_failconn") if isReload \
3499	else xstr("login_failconn")
3500	dialog = gtk.MessageDialog(parent = self.gui.mainWindow,
3501	type = MESSAGETYPE_ERROR,
3502	message_format = message)
3503	dialog.add_button(xstr("button_ok"), RESPONSETYPE_OK)
3504	dialog.set_title(WINDOW_TITLE_BASE)
3505	secondary = xstr("reload_failconn_sec") if isReload \
3506	else xstr("login_failconn_sec")
3507	dialog.format_secondary_markup(secondary)
3508
3509	dialog.run()
3510	dialog.hide()
3511
3512	callback = self._loginCallback
3513	self._loginCallback = None
3514	callback(returned, result)
3515
3516	def getFleet(self, callback, force = False):
3517	"""Get the fleet via the GUI and call the given callback."""
3518	self._fleetCallback = callback
3519	self.gui.getFleet(callback = self._fleetRetrieved, force = force)
3520
3521	def _fleetRetrieved(self, fleet):
3522	"""Callback for the fleet retrieval."""
3523	self._fleet = fleet
3524	if self._fleetCallback is not None:
3525	self._fleetCallback(fleet)
3526	self._fleetCallback = None
3527
3528	def updatePlane(self, callback, tailNumber, status, gateNumber = None):
3529	"""Update the given plane's gate information."""
3530	self.gui.updatePlane(tailNumber, status, gateNumber = gateNumber,
3531	callback = callback)
3532
3533	def updateRTO(self):
3534	"""Update the RTO state.
3535
3536	The RTO checkbox will be enabled if the flight has an RTO state and the
3537	comments field contains some text."""
3538	flight = self.gui.flight
3539	rtoEnabled = flight is not None and flight.hasRTO and \
3540	self.gui.hasComments
3541	self._takeoffPage.setRTOEnabled(rtoEnabled)
3542
3543	def rtoToggled(self, indicated):
3544	"""Called when the RTO indication has changed."""
3545	self.gui.rtoToggled(indicated)
3546
3547	def _connectSimulator(self, simulatorType):
3548	"""Connect to the simulator."""
3549	self.gui.connectSimulator(self._bookedFlight.aircraftType,
3550	simulatorType)
3551
3552	def _arrivalMETARCallback(self, returned, result):
3553	"""Called when the METAR of the arrival airport is retrieved."""
3554	gobject.idle_add(self._handleArrivalMETAR, returned, result)
3555
3556	def _handleArrivalMETAR(self, returned, result):
3557	"""Called when the METAR of the arrival airport is retrieved."""
3558	icao = self._bookedFlight.arrivalICAO
3559	if returned and icao in result.metars:
3560	metar = result.metars[icao]
3561	if metar!="":
3562	self._arrivalBriefingPage.setMETAR(metar)
3563
3564	#-----------------------------------------------------------------------------

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

Download in other formats: