Context Navigation

source: src/mlx/gui/flight.py@ 551:36e8dd7b768c

Visit:

Last change on this file since 551:36e8dd7b768c was 551:36e8dd7b768c, checked in by István Váradi <ivaradi@…>, 10 years ago
Added some debug printouts
File size: 137.1 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._derateType = acft.DERATE_NONE
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.Alignment()
2152	table.attach(self._derate, 2, 4, 5, 6)
2153	self._derateWidget = None
2154	self._derateEntry = None
2155	self._derateUnit = None
2156	self._derateButtons = None
2157
2158	self._antiIceOn = gtk.CheckButton(xstr("takeoff_antiice"))
2159	self._antiIceOn.set_use_underline(True)
2160	self._antiIceOn.set_tooltip_text(xstr("takeoff_antiice_tooltip"))
2161	table.attach(self._antiIceOn, 2, 4, 6, 7)
2162
2163	self._rto = gtk.CheckButton(xstr("takeoff_rto"))
2164	self._rto.set_use_underline(True)
2165	self._rto.set_tooltip_text(xstr("takeoff_rto_tooltip"))
2166	self._rto.connect("toggled", self._rtoToggled)
2167	table.attach(self._rto, 2, 4, 7, 8, ypadding = 8)
2168
2169	self.addCancelFlightButton()
2170
2171	self.addPreviousButton(clicked = self._backClicked)
2172
2173	self._button = self.addNextButton(clicked = self._forwardClicked)
2174
2175	@property
2176	def runway(self):
2177	"""Get the runway."""
2178	return self._runway.get_text()
2179
2180	@property
2181	def sid(self):
2182	"""Get the SID."""
2183	return self._sid.get_text()
2184
2185	@property
2186	def v1(self):
2187	"""Get the v1 speed."""
2188	return self._v1.get_int()
2189
2190	@property
2191	def vr(self):
2192	"""Get the vr speed."""
2193	return self._vr.get_int()
2194
2195	@property
2196	def v2(self):
2197	"""Get the v2 speed."""
2198	return self._v2.get_int()
2199
2200	@property
2201	def derate(self):
2202	"""Get the derate value, if any."""
2203	if self._derateWidget is None:
2204	return None
2205	if self._derateType==acft.DERATE_BOEING:
2206	derate = self._derateEntry.get_text()
2207	return derate if derate else None
2208	elif self._derateType==acft.DERATE_EPR:
2209	derate = self._derateWidget.get_text()
2210	return derate if derate else None
2211	elif self._derateType==acft.DERATE_TUPOLEV:
2212	return acft.DERATE_TUPOLEV_NOMINAL \
2213	if self._derateButtons[0].get_active() \
2214	else acft.DERATE_TUPOLEV_TAKEOFF
2215	elif self._derateType==acft.DERATE_B462:
2216	return self._derateWidget.get_active()
2217	else:
2218	return None
2219
2220	@property
2221	def antiIceOn(self):
2222	"""Get whether the anti-ice system has been turned on."""
2223	return self._antiIceOn.get_active()
2224
2225	@antiIceOn.setter
2226	def antiIceOn(self, value):
2227	"""Set the anti-ice indicator."""
2228	self._antiIceOn.set_active(value)
2229
2230	@property
2231	def rtoIndicated(self):
2232	"""Get whether the pilot has indicated if there was an RTO."""
2233	return self._rto.get_active()
2234
2235	def activate(self):
2236	"""Activate the page."""
2237	print "TakeoffPage.activate"
2238
2239	self._runway.set_text("")
2240	self._runway.set_sensitive(True)
2241	self._sid.set_text("")
2242	self._sid.set_sensitive(True)
2243	self._v1.set_int(None)
2244	self._v1.set_sensitive(True)
2245	self._vr.set_int(None)
2246	self._vr.set_sensitive(True)
2247	self._v2.set_int(None)
2248	self._v2.set_sensitive(True)
2249
2250	i18nSpeedUnit = self._wizard.gui.flight.getI18NSpeedUnit()
2251	speedUnit = xstr("label" + i18nSpeedUnit)
2252	self._v1Unit.set_text(speedUnit)
2253	self._vrUnit.set_text(speedUnit)
2254	self._v2Unit.set_text(speedUnit)
2255
2256	self._v1.set_tooltip_markup(xstr("takeoff_v1_tooltip" + i18nSpeedUnit))
2257	self._vr.set_tooltip_markup(xstr("takeoff_vr_tooltip" + i18nSpeedUnit))
2258	self._v2.set_tooltip_markup(xstr("takeoff_v2_tooltip" + i18nSpeedUnit))
2259
2260	self._derateType = self._wizard.gui.flight.aircraft.derateType
2261
2262	self._setupDerateWidget()
2263
2264	self._rto.set_active(False)
2265	self._rto.set_sensitive(False)
2266
2267	self._button.set_sensitive(False)
2268	self._forwardAllowed = False
2269
2270	def allowForward(self):
2271	"""Allow going to the next page."""
2272	print "TakeoffPage.allowForward"
2273	self._forwardAllowed = True
2274	self._updateForwardButton()
2275
2276	def reset(self):
2277	"""Reset the page if the wizard is reset."""
2278	print "TakeoffPage.reset"
2279
2280	super(TakeoffPage, self).reset()
2281	self._v1.reset()
2282	self._vr.reset()
2283	self._v2.reset()
2284	self._hasDerate = False
2285	self._antiIceOn.set_active(False)
2286
2287	def setRTOEnabled(self, enabled):
2288	"""Set the RTO checkbox enabled or disabled."""
2289	if not enabled:
2290	self._rto.set_active(False)
2291	self._rto.set_sensitive(enabled)
2292
2293	def _updateForwardButton(self):
2294	"""Update the sensitivity of the forward button based on some conditions."""
2295
2296	sensitive = self._forwardAllowed and \
2297	self._runway.get_text()!="" and \
2298	self._sid.get_text()!="" and \
2299	self.v1 is not None and \
2300	self.vr is not None and \
2301	self.v2 is not None and \
2302	self.v1 <= self.vr and \
2303	self.vr <= self.v2 and \
2304	(self._derateType==acft.DERATE_NONE or
2305	self.derate is not None)
2306
2307	print "TakeoffPage._updateForwardButton: forwardAllowed:", self._forwardAllowed, ", sensitive:", sensitive
2308
2309	self._button.set_sensitive(sensitive)
2310
2311	def _valueChanged(self, widget, arg = None):
2312	"""Called when the value of some widget has changed."""
2313	print "TakeoffPage._valueChanged"
2314
2315	self._updateForwardButton()
2316
2317	def _upperChanged(self, entry, arg = None):
2318	"""Called when the value of some entry widget has changed and the value
2319	should be converted to uppercase."""
2320	print "TakeoffPage._upperChanged"
2321	entry.set_text(entry.get_text().upper())
2322	self._valueChanged(entry, arg)
2323
2324	def _derateChanged(self, entry):
2325	"""Called when the value of the derate is changed."""
2326	print "TakeoffPage._derateChanged"
2327	self._updateForwardButton()
2328
2329	def _rtoToggled(self, button):
2330	"""Called when the RTO check button is toggled."""
2331	self._wizard.rtoToggled(button.get_active())
2332
2333	def _backClicked(self, button):
2334	"""Called when the Back button is pressed."""
2335	self.goBack()
2336
2337	def _forwardClicked(self, button):
2338	"""Called when the forward button is clicked."""
2339	aircraft = self._wizard.gui.flight.aircraft
2340	aircraft.updateV1R2()
2341	if self.derate is not None:
2342	aircraft.updateDerate()
2343	aircraft.updateTakeoffAntiIce()
2344	self._wizard.nextPage()
2345
2346	def _setupDerateWidget(self):
2347	"""Setup the derate widget."""
2348	if self._derateWidget is not None:
2349	self._derate.remove(self._derateWidget)
2350
2351	if self._derateType==acft.DERATE_BOEING:
2352	self._derateLabel.set_text(xstr("takeoff_derate_boeing"))
2353	self._derateLabel.set_use_underline(True)
2354	self._derateLabel.set_sensitive(True)
2355
2356	self._derateEntry = gtk.Entry()
2357	self._derateEntry.set_width_chars(7)
2358	self._derateEntry.set_tooltip_text(xstr("takeoff_derate_boeing_tooltip"))
2359	self._derateEntry.set_alignment(1.0)
2360	self._derateEntry.connect("changed", self._derateChanged)
2361	self._derateLabel.set_mnemonic_widget(self._derateEntry)
2362
2363	self._derateUnit = gtk.Label("%")
2364	self._derateUnit.set_alignment(0.0, 0.5)
2365
2366	self._derateWidget = gtk.Table(3, 1)
2367	self._derateWidget.set_row_spacings(4)
2368	self._derateWidget.set_col_spacings(16)
2369	self._derateWidget.set_homogeneous(False)
2370
2371	self._derateWidget.attach(self._derateEntry, 0, 2, 0, 1)
2372	self._derateWidget.attach(self._derateUnit, 2, 3, 0, 1)
2373
2374	self._derate.add(self._derateWidget)
2375	elif self._derateType==acft.DERATE_EPR:
2376	self._derateLabel.set_text("_EPR:")
2377	self._derateLabel.set_use_underline(True)
2378	self._derateLabel.set_sensitive(True)
2379
2380	self._derateWidget = gtk.Entry()
2381	self._derateWidget.set_width_chars(7)
2382	self._derateWidget.set_tooltip_text(xstr("takeoff_derate_epr_tooltip"))
2383	self._derateWidget.set_alignment(1.0)
2384	self._derateWidget.connect("changed", self._derateChanged)
2385	self._derateLabel.set_mnemonic_widget(self._derateWidget)
2386
2387	self._derate.add(self._derateWidget)
2388	elif self._derateType==acft.DERATE_TUPOLEV:
2389	self._derateLabel.set_text(xstr("takeoff_derate_tupolev"))
2390	self._derateLabel.set_use_underline(True)
2391	self._derateLabel.set_sensitive(True)
2392
2393	if pygobject:
2394	nominal = gtk.RadioButton.\
2395	new_with_label_from_widget(None,
2396	xstr("takeoff_derate_tupolev_nominal"))
2397	else:
2398	nominal = gtk.RadioButton(None,
2399	xstr("takeoff_derate_tupolev_nominal"))
2400	nominal.set_use_underline(True)
2401	nominal.set_tooltip_text(xstr("takeoff_derate_tupolev_nominal_tooltip"))
2402	nominal.connect("toggled", self._derateChanged)
2403
2404	if pygobject:
2405	takeoff = gtk.RadioButton.\
2406	new_with_label_from_widget(nominal,
2407	xstr("takeoff_derate_tupolev_takeoff"))
2408	else:
2409	takeoff = gtk.RadioButton(nominal,
2410	xstr("takeoff_derate_tupolev_takeoff"))
2411
2412	takeoff.set_use_underline(True)
2413	takeoff.set_tooltip_text(xstr("takeoff_derate_tupolev_takeoff_tooltip"))
2414	takeoff.connect("toggled", self._derateChanged)
2415
2416	self._derateButtons = [nominal, takeoff]
2417
2418	self._derateWidget = gtk.HBox()
2419	self._derateWidget.pack_start(nominal, False, False, 4)
2420	self._derateWidget.pack_start(takeoff, False, False, 4)
2421
2422	self._derate.add(self._derateWidget)
2423	elif self._derateType==acft.DERATE_B462:
2424	self._derateLabel.set_text("")
2425
2426	self._derateWidget = gtk.CheckButton(xstr("takeoff_derate_b462"))
2427	self._derateWidget.set_tooltip_text(xstr("takeoff_derate_b462_tooltip"))
2428	self._derateWidget.set_use_underline(True)
2429	self._derate.add(self._derateWidget)
2430	else:
2431	self._derateWidget = None
2432	self._derateLabel.set_text("")
2433	self._derateLabel.set_sensitive(False)
2434
2435	#-----------------------------------------------------------------------------
2436
2437	class CruisePage(Page):
2438	"""The page containing the flight level that might change during flight."""
2439	def __init__(self, wizard):
2440	"""Construct the page."""
2441	super(CruisePage, self).__init__(wizard, xstr("cruise_title"),
2442	xstr("cruise_help"))
2443
2444	self._loggable = False
2445	self._loggedCruiseLevel = 240
2446	self._activated = False
2447
2448	alignment = gtk.Alignment(xalign = 0.5, yalign = 0.0,
2449	xscale = 0.0, yscale = 1.0)
2450
2451	mainBox = gtk.VBox()
2452	alignment.add(mainBox)
2453	self.setMainWidget(alignment)
2454
2455	alignment = gtk.Alignment(xalign = 0.0, yalign = 0.0,
2456	xscale = 0.0, yscale = 0.0)
2457	mainBox.pack_start(alignment, False, False, 16)
2458
2459	levelBox = gtk.HBox()
2460
2461	label = gtk.Label(xstr("route_level"))
2462	label.set_use_underline(True)
2463	levelBox.pack_start(label, True, True, 0)
2464
2465	self._cruiseLevel = gtk.SpinButton()
2466	self._cruiseLevel.set_increments(step = 10, page = 100)
2467	self._cruiseLevel.set_range(min = 50, max = 500)
2468	self._cruiseLevel.set_tooltip_text(xstr("cruise_route_level_tooltip"))
2469	self._cruiseLevel.set_numeric(True)
2470	self._cruiseLevel.connect("value-changed", self._cruiseLevelChanged)
2471	label.set_mnemonic_widget(self._cruiseLevel)
2472
2473	levelBox.pack_start(self._cruiseLevel, False, False, 8)
2474
2475	self._updateButton = gtk.Button(xstr("cruise_route_level_update"));
2476	self._updateButton.set_use_underline(True)
2477	self._updateButton.set_tooltip_text(xstr("cruise_route_level_update_tooltip"))
2478	self._updateButton.connect("clicked", self._updateButtonClicked)
2479
2480	levelBox.pack_start(self._updateButton, False, False, 16)
2481
2482	mainBox.pack_start(levelBox, False, False, 0)
2483
2484	alignment = gtk.Alignment(xalign = 0.0, yalign = 0.0,
2485	xscale = 0.0, yscale = 1.0)
2486	mainBox.pack_start(alignment, True, True, 0)
2487
2488	self.addCancelFlightButton()
2489
2490	self._backButton = self.addPreviousButton(clicked = self._backClicked)
2491	self._button = self.addNextButton(clicked = self._forwardClicked)
2492
2493	@property
2494	def activated(self):
2495	"""Determine if the page is already activated or not."""
2496	return self._activated
2497
2498	@property
2499	def cruiseLevel(self):
2500	"""Get the cruise level."""
2501	return self._loggedCruiseLevel
2502
2503	@property
2504	def loggableCruiseLevel(self):
2505	"""Get the cruise level which should be logged."""
2506	return self._cruiseLevel.get_value_as_int()
2507
2508	def setLoggable(self, loggable):
2509	"""Set whether the cruise altitude can be logged."""
2510	self._loggable = loggable
2511	self._updateButtons()
2512
2513	def activate(self):
2514	"""Setup the route from the booked flight."""
2515	self._loggedCruiseLevel = self._wizard.filedCruiseLevel
2516	self._cruiseLevel.set_value(self._loggedCruiseLevel)
2517	self._activated = True
2518
2519	def reset(self):
2520	"""Reset the page."""
2521	self._loggable = False
2522	self._activated = False
2523	super(CruisePage, self).reset()
2524
2525	def _updateButtons(self):
2526	"""Update the sensitivity of the buttons."""
2527	self._updateButton.set_sensitive(self._loggable and
2528	self.loggableCruiseLevel!=
2529	self._loggedCruiseLevel)
2530
2531	def _cruiseLevelChanged(self, spinButton):
2532	"""Called when the cruise level has changed."""
2533	self._updateButtons()
2534
2535	def _updateButtonClicked(self, button):
2536	"""Called when the update button is clicked."""
2537	if self._wizard.cruiseLevelChanged():
2538	self._loggedCruiseLevel = self.loggableCruiseLevel
2539	self._updateButtons()
2540
2541	def _backClicked(self, button):
2542	"""Called when the Back button is pressed."""
2543	self.goBack()
2544
2545	def _forwardClicked(self, button):
2546	"""Called when the Forward button is clicked."""
2547	self._wizard.nextPage()
2548
2549	#-----------------------------------------------------------------------------
2550
2551	class LandingPage(Page):
2552	"""Page for entering landing data."""
2553	def __init__(self, wizard):
2554	"""Construct the landing page."""
2555	super(LandingPage, self).__init__(wizard, xstr("landing_title"),
2556	xstr("landing_help"),
2557	completedHelp = xstr("landing_chelp"))
2558
2559	self._flightEnded = False
2560
2561	alignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
2562	xscale = 0.0, yscale = 0.0)
2563
2564	table = gtk.Table(6, 5)
2565	table.set_row_spacings(4)
2566	table.set_col_spacings(16)
2567	table.set_homogeneous(False)
2568	alignment.add(table)
2569	self.setMainWidget(alignment)
2570
2571	self._starButton = gtk.CheckButton()
2572	self._starButton.connect("clicked", self._starButtonClicked)
2573	table.attach(self._starButton, 0, 1, 0, 1)
2574
2575	label = gtk.Label(xstr("landing_star"))
2576	label.set_use_underline(True)
2577	label.set_alignment(0.0, 0.5)
2578	table.attach(label, 1, 2, 0, 1)
2579
2580	self._star = gtk.Entry()
2581	self._star.set_width_chars(10)
2582	self._star.set_tooltip_text(xstr("landing_star_tooltip"))
2583	self._star.connect("changed", self._upperChanged)
2584	self._star.set_sensitive(False)
2585	table.attach(self._star, 2, 4, 0, 1)
2586	label.set_mnemonic_widget(self._starButton)
2587
2588	self._transitionButton = gtk.CheckButton()
2589	self._transitionButton.connect("clicked", self._transitionButtonClicked)
2590	table.attach(self._transitionButton, 0, 1, 1, 2)
2591
2592	label = gtk.Label(xstr("landing_transition"))
2593	label.set_use_underline(True)
2594	label.set_alignment(0.0, 0.5)
2595	table.attach(label, 1, 2, 1, 2)
2596
2597	self._transition = gtk.Entry()
2598	self._transition.set_width_chars(10)
2599	self._transition.set_tooltip_text(xstr("landing_transition_tooltip"))
2600	self._transition.connect("changed", self._upperChanged)
2601	self._transition.set_sensitive(False)
2602	table.attach(self._transition, 2, 4, 1, 2)
2603	label.set_mnemonic_widget(self._transitionButton)
2604
2605	label = gtk.Label(xstr("landing_runway"))
2606	label.set_use_underline(True)
2607	label.set_alignment(0.0, 0.5)
2608	table.attach(label, 1, 2, 2, 3)
2609
2610	self._runway = gtk.Entry()
2611	self._runway.set_width_chars(10)
2612	self._runway.set_tooltip_text(xstr("landing_runway_tooltip"))
2613	self._runway.connect("changed", self._upperChanged)
2614	table.attach(self._runway, 2, 4, 2, 3)
2615	label.set_mnemonic_widget(self._runway)
2616
2617	label = gtk.Label(xstr("landing_approach"))
2618	label.set_use_underline(True)
2619	label.set_alignment(0.0, 0.5)
2620	table.attach(label, 1, 2, 3, 4)
2621
2622	self._approachType = gtk.Entry()
2623	self._approachType.set_width_chars(10)
2624	self._approachType.set_tooltip_text(xstr("landing_approach_tooltip"))
2625	self._approachType.connect("changed", self._upperChanged)
2626	table.attach(self._approachType, 2, 4, 3, 4)
2627	label.set_mnemonic_widget(self._approachType)
2628
2629	label = gtk.Label(xstr("landing_vref"))
2630	label.set_use_markup(True)
2631	label.set_use_underline(True)
2632	label.set_alignment(0.0, 0.5)
2633	table.attach(label, 1, 2, 4, 5)
2634
2635	self._vref = IntegerEntry()
2636	self._vref.set_width_chars(5)
2637	self._vref.set_tooltip_markup(xstr("landing_vref_tooltip_knots"))
2638	self._vref.connect("integer-changed", self._vrefChanged)
2639	table.attach(self._vref, 3, 4, 4, 5)
2640	label.set_mnemonic_widget(self._vref)
2641
2642	self._vrefUnit = gtk.Label(xstr("label_knots"))
2643	table.attach(self._vrefUnit, 4, 5, 4, 5)
2644
2645	self._antiIceOn = gtk.CheckButton(xstr("landing_antiice"))
2646	self._antiIceOn.set_use_underline(True)
2647	self._antiIceOn.set_tooltip_text(xstr("landing_antiice_tooltip"))
2648	table.attach(self._antiIceOn, 3, 5, 5, 6)
2649
2650	self.addCancelFlightButton()
2651
2652	self.addPreviousButton(clicked = self._backClicked)
2653
2654	self._button = self.addNextButton(clicked = self._forwardClicked)
2655
2656	# These are needed for correct size calculations
2657	self._starButton.set_active(True)
2658	self._transitionButton.set_active(True)
2659
2660	@property
2661	def star(self):
2662	"""Get the STAR or None if none entered."""
2663	return self._star.get_text() if self._starButton.get_active() else None
2664
2665	@property
2666	def transition(self):
2667	"""Get the transition or None if none entered."""
2668	return self._transition.get_text() \
2669	if self._transitionButton.get_active() else None
2670
2671	@property
2672	def approachType(self):
2673	"""Get the approach type."""
2674	return self._approachType.get_text()
2675
2676	@property
2677	def runway(self):
2678	"""Get the runway."""
2679	return self._runway.get_text()
2680
2681	@property
2682	def vref(self):
2683	"""Return the landing reference speed."""
2684	return self._vref.get_int()
2685
2686	@property
2687	def antiIceOn(self):
2688	"""Get whether the anti-ice system has been turned on."""
2689	return self._antiIceOn.get_active()
2690
2691	@antiIceOn.setter
2692	def antiIceOn(self, value):
2693	"""Set the anti-ice indicator."""
2694	self._antiIceOn.set_active(value)
2695
2696	def reset(self):
2697	"""Reset the page if the wizard is reset."""
2698	super(LandingPage, self).reset()
2699	self._vref.reset()
2700	self._antiIceOn.set_active(False)
2701	self._flightEnded = False
2702
2703	def activate(self):
2704	"""Called when the page is activated."""
2705	self._starButton.set_sensitive(True)
2706	self._starButton.set_active(False)
2707	self._star.set_text("")
2708
2709	self._transitionButton.set_sensitive(True)
2710	self._transitionButton.set_active(False)
2711	self._transition.set_text("")
2712
2713	self._runway.set_text("")
2714	self._runway.set_sensitive(True)
2715
2716	self._approachType.set_text("")
2717	self._approachType.set_sensitive(True)
2718
2719	self._vref.set_int(None)
2720	self._vref.set_sensitive(True)
2721
2722	i18nSpeedUnit = self._wizard.gui.flight.getI18NSpeedUnit()
2723	speedUnit = xstr("label" + i18nSpeedUnit)
2724	self._vrefUnit.set_text(speedUnit)
2725
2726	self._vref.set_tooltip_markup(xstr("landing_vref_tooltip" +
2727	i18nSpeedUnit))
2728
2729	self._updateForwardButton()
2730
2731	def flightEnded(self):
2732	"""Called when the flight has ended."""
2733	super(LandingPage, self).flightEnded()
2734	self._flightEnded = True
2735	self._updateForwardButton()
2736
2737	def _starButtonClicked(self, button):
2738	"""Called when the STAR button is clicked."""
2739	active = button.get_active()
2740	self._star.set_sensitive(active)
2741	if active:
2742	self._star.grab_focus()
2743	self._updateForwardButton()
2744
2745	def _transitionButtonClicked(self, button):
2746	"""Called when the Transition button is clicked."""
2747	active = button.get_active()
2748	self._transition.set_sensitive(active)
2749	if active:
2750	self._transition.grab_focus()
2751	self._updateForwardButton()
2752
2753	def _updateForwardButton(self):
2754	"""Update the sensitivity of the forward button."""
2755	sensitive = self._flightEnded and \
2756	(self._starButton.get_active() or \
2757	self._transitionButton.get_active()) and \
2758	(self._star.get_text()!="" or
2759	not self._starButton.get_active()) and \
2760	(self._transition.get_text()!="" or
2761	not self._transitionButton.get_active()) and \
2762	self._runway.get_text()!="" and \
2763	self._approachType.get_text()!="" and \
2764	self.vref is not None
2765	self._button.set_sensitive(sensitive)
2766
2767	def _upperChanged(self, entry):
2768	"""Called for entry widgets that must be converted to uppercase."""
2769	entry.set_text(entry.get_text().upper())
2770	self._updateForwardButton()
2771
2772	def _vrefChanged(self, widget, value):
2773	"""Called when the Vref has changed."""
2774	self._updateForwardButton()
2775
2776	def _backClicked(self, button):
2777	"""Called when the Back button is pressed."""
2778	self.goBack()
2779
2780	def _forwardClicked(self, button):
2781	"""Called when the forward button is clicked."""
2782	aircraft = self._wizard.gui.flight.aircraft
2783	aircraft.updateVRef()
2784	aircraft.updateLandingAntiIce()
2785	if self._wizard.gui.config.onlineGateSystem and \
2786	self._wizard.loggedIn and not self._completed and \
2787	self._wizard.bookedFlight.arrivalICAO=="LHBP" and \
2788	not self._wizard.entranceExam:
2789	self._wizard.getFleet(callback = self._fleetRetrieved,
2790	force = True)
2791	else:
2792	self._wizard.nextPage()
2793
2794	def _fleetRetrieved(self, fleet):
2795	"""Callback for the fleet retrieval."""
2796	self._wizard.nextPage()
2797
2798	#-----------------------------------------------------------------------------
2799
2800	class FinishPage(Page):
2801	"""Flight finish page."""
2802	_flightTypes = [ ("flighttype_scheduled", const.FLIGHTTYPE_SCHEDULED),
2803	("flighttype_ot", const.FLIGHTTYPE_OLDTIMER),
2804	("flighttype_vip", const.FLIGHTTYPE_VIP),
2805	("flighttype_charter", const.FLIGHTTYPE_CHARTER) ]
2806
2807	def __init__(self, wizard):
2808	"""Construct the finish page."""
2809	super(FinishPage, self).__init__(wizard, xstr("finish_title"),
2810	xstr("finish_help"))
2811
2812	alignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
2813	xscale = 0.0, yscale = 0.0)
2814
2815	table = gtk.Table(8, 2)
2816	table.set_row_spacings(4)
2817	table.set_col_spacings(16)
2818	table.set_homogeneous(False)
2819	alignment.add(table)
2820	self.setMainWidget(alignment)
2821
2822	labelAlignment = gtk.Alignment(xalign=1.0, xscale=0.0)
2823	label = gtk.Label(xstr("finish_rating"))
2824	labelAlignment.add(label)
2825	table.attach(labelAlignment, 0, 1, 0, 1)
2826
2827	labelAlignment = gtk.Alignment(xalign=0.0, xscale=0.0)
2828	self._flightRating = gtk.Label()
2829	self._flightRating.set_width_chars(8)
2830	self._flightRating.set_alignment(0.0, 0.5)
2831	self._flightRating.set_use_markup(True)
2832	labelAlignment.add(self._flightRating)
2833	table.attach(labelAlignment, 1, 2, 0, 1)
2834
2835	labelAlignment = gtk.Alignment(xalign=1.0, xscale=0.0)
2836	label = gtk.Label(xstr("finish_flight_time"))
2837	labelAlignment.add(label)
2838	table.attach(labelAlignment, 0, 1, 1, 2)
2839
2840	labelAlignment = gtk.Alignment(xalign=0.0, xscale=0.0)
2841	self._flightTime = gtk.Label()
2842	self._flightTime.set_width_chars(10)
2843	self._flightTime.set_alignment(0.0, 0.5)
2844	self._flightTime.set_use_markup(True)
2845	labelAlignment.add(self._flightTime)
2846	table.attach(labelAlignment, 1, 2, 1, 2)
2847
2848	labelAlignment = gtk.Alignment(xalign=1.0, xscale=0.0)
2849	label = gtk.Label(xstr("finish_block_time"))
2850	labelAlignment.add(label)
2851	table.attach(labelAlignment, 0, 1, 2, 3)
2852
2853	labelAlignment = gtk.Alignment(xalign=0.0, xscale=0.0)
2854	self._blockTime = gtk.Label()
2855	self._blockTime.set_width_chars(10)
2856	self._blockTime.set_alignment(0.0, 0.5)
2857	self._blockTime.set_use_markup(True)
2858	labelAlignment.add(self._blockTime)
2859	table.attach(labelAlignment, 1, 2, 2, 3)
2860
2861	labelAlignment = gtk.Alignment(xalign=1.0, xscale=0.0)
2862	label = gtk.Label(xstr("finish_distance"))
2863	labelAlignment.add(label)
2864	table.attach(labelAlignment, 0, 1, 3, 4)
2865
2866	labelAlignment = gtk.Alignment(xalign=0.0, xscale=0.0)
2867	self._distanceFlown = gtk.Label()
2868	self._distanceFlown.set_width_chars(10)
2869	self._distanceFlown.set_alignment(0.0, 0.5)
2870	self._distanceFlown.set_use_markup(True)
2871	labelAlignment.add(self._distanceFlown)
2872	table.attach(labelAlignment, 1, 2, 3, 4)
2873
2874	labelAlignment = gtk.Alignment(xalign=1.0, xscale=0.0)
2875	label = gtk.Label(xstr("finish_fuel"))
2876	labelAlignment.add(label)
2877	table.attach(labelAlignment, 0, 1, 4, 5)
2878
2879	labelAlignment = gtk.Alignment(xalign=0.0, xscale=0.0)
2880	self._fuelUsed = gtk.Label()
2881	self._fuelUsed.set_width_chars(10)
2882	self._fuelUsed.set_alignment(0.0, 0.5)
2883	self._fuelUsed.set_use_markup(True)
2884	labelAlignment.add(self._fuelUsed)
2885	table.attach(labelAlignment, 1, 2, 4, 5)
2886
2887	labelAlignment = gtk.Alignment(xalign = 1.0, xscale = 0.0,
2888	yalign = 0.5, yscale = 0.0)
2889	label = gtk.Label(xstr("finish_type"))
2890	label.set_use_underline(True)
2891	labelAlignment.add(label)
2892	table.attach(labelAlignment, 0, 1, 5, 6)
2893
2894	flightTypeModel = gtk.ListStore(str, int)
2895	for (name, type) in FinishPage._flightTypes:
2896	flightTypeModel.append([xstr(name), type])
2897
2898	self._flightType = gtk.ComboBox(model = flightTypeModel)
2899	renderer = gtk.CellRendererText()
2900	self._flightType.pack_start(renderer, True)
2901	self._flightType.add_attribute(renderer, "text", 0)
2902	self._flightType.set_tooltip_text(xstr("finish_type_tooltip"))
2903	self._flightType.set_active(0)
2904	self._flightType.connect("changed", self._flightTypeChanged)
2905	flightTypeAlignment = gtk.Alignment(xalign=0.0, xscale=0.0)
2906	flightTypeAlignment.add(self._flightType)
2907	table.attach(flightTypeAlignment, 1, 2, 5, 6)
2908	label.set_mnemonic_widget(self._flightType)
2909
2910	self._onlineFlight = gtk.CheckButton(xstr("finish_online"))
2911	self._onlineFlight.set_use_underline(True)
2912	self._onlineFlight.set_tooltip_text(xstr("finish_online_tooltip"))
2913	onlineFlightAlignment = gtk.Alignment(xalign=0.0, xscale=0.0)
2914	onlineFlightAlignment.add(self._onlineFlight)
2915	table.attach(onlineFlightAlignment, 1, 2, 6, 7)
2916
2917	labelAlignment = gtk.Alignment(xalign = 1.0, xscale = 0.0,
2918	yalign = 0.5, yscale = 0.0)
2919	self._gateLabel = gtk.Label(xstr("finish_gate"))
2920	self._gateLabel.set_use_underline(True)
2921	labelAlignment.add(self._gateLabel)
2922	table.attach(labelAlignment, 0, 1, 7, 8)
2923
2924	self._gatesModel = gtk.ListStore(str)
2925
2926	self._gate = gtk.ComboBox(model = self._gatesModel)
2927	renderer = gtk.CellRendererText()
2928	self._gate.pack_start(renderer, True)
2929	self._gate.add_attribute(renderer, "text", 0)
2930	self._gate.set_tooltip_text(xstr("finish_gate_tooltip"))
2931	self._gate.connect("changed", self._gateChanged)
2932	gateAlignment = gtk.Alignment(xalign=0.0, xscale=1.0)
2933	gateAlignment.add(self._gate)
2934	table.attach(gateAlignment, 1, 2, 7, 8)
2935	self._gateLabel.set_mnemonic_widget(self._gate)
2936
2937	self.addButton(xstr("finish_newFlight"),
2938	sensitive = True,
2939	clicked = self._newFlightClicked,
2940	tooltip = xstr("finish_newFlight_tooltip"),
2941	padding = 16)
2942
2943	self.addPreviousButton(clicked = self._backClicked)
2944
2945	self._saveButton = self.addButton(xstr("finish_save"),
2946	sensitive = False,
2947	clicked = self._saveClicked,
2948	tooltip = xstr("finish_save_tooltip"))
2949	self._savePIREPDialog = None
2950	self._lastSavePath = None
2951
2952	self._pirepSaved = False
2953	self._pirepSent = False
2954
2955	self._sendButton = self.addButton(xstr("sendPIREP"), default = True,
2956	sensitive = False,
2957	clicked = self._sendClicked,
2958	tooltip = xstr("sendPIREP_tooltip"))
2959
2960	@property
2961	def flightType(self):
2962	"""Get the flight type."""
2963	index = self._flightType.get_active()
2964	return None if index<0 else self._flightType.get_model()[index][1]
2965
2966	@property
2967	def online(self):
2968	"""Get whether the flight was an online flight or not."""
2969	return self._onlineFlight.get_active()
2970
2971	def activate(self):
2972	"""Activate the page."""
2973	self._pirepSaved = False
2974	self._pirepSent = False
2975
2976	flight = self._wizard.gui._flight
2977	rating = flight.logger.getRating()
2978	if rating<0:
2979	self._flightRating.set_markup('<b><span foreground="red">NO GO</span></b>')
2980	else:
2981	self._flightRating.set_markup("<b>%.1f %%</b>" % (rating,))
2982
2983	flightLength = flight.flightTimeEnd - flight.flightTimeStart
2984	self._flightTime.set_markup("<b>%s</b>" % \
2985	(util.getTimeIntervalString(flightLength),))
2986
2987	blockLength = flight.blockTimeEnd - flight.blockTimeStart
2988	self._blockTime.set_markup("<b>%s</b>" % \
2989	(util.getTimeIntervalString(blockLength),))
2990
2991	self._distanceFlown.set_markup("<b>%.2f NM</b>" % \
2992	(flight.flownDistance,))
2993
2994	self._fuelUsed.set_markup("<b>%.0f kg</b>" % \
2995	(flight.startFuel - flight.endFuel,))
2996
2997	self._flightType.set_active(-1)
2998	self._onlineFlight.set_active(self._wizard.loggedIn)
2999
3000	self._gatesModel.clear()
3001	if self._wizard.gui.config.onlineGateSystem and \
3002	self._wizard.loggedIn and \
3003	self._wizard.bookedFlight.arrivalICAO=="LHBP" and \
3004	not self._wizard.entranceExam:
3005	occupiedGates = self._wizard._fleet.getOccupiedGateNumbers()
3006	for gateNumber in const.lhbpGateNumbers:
3007	if gateNumber not in occupiedGates:
3008	self._gatesModel.append([gateNumber])
3009	self._gateLabel.set_sensitive(True)
3010	self._gate.set_sensitive(True)
3011	self._gate.set_active(-1)
3012	else:
3013	self._gateLabel.set_sensitive(False)
3014	self._gate.set_sensitive(False)
3015
3016	def _backClicked(self, button):
3017	"""Called when the Back button is pressed."""
3018	self.goBack()
3019
3020	def _updateButtons(self):
3021	"""Update the sensitivity state of the buttons."""
3022	sensitive = self._flightType.get_active()>=0 and \
3023	(self._gatesModel.get_iter_first() is None or
3024	self._gate.get_active()>=0)
3025
3026	wasSensitive = self._saveButton.get_sensitive()
3027
3028	gui = self._wizard.gui
3029	config = gui.config
3030	if config.pirepAutoSave and sensitive and not wasSensitive:
3031	self._lastSavePath = os.path.join(config.pirepDirectory,
3032	self._getDefaultPIREPName())
3033	self._lastSavePath = text2unicode(self._lastSavePath)
3034	self._savePIREP(automatic = True)
3035
3036	self._saveButton.set_sensitive(sensitive)
3037	self._sendButton.set_sensitive(sensitive and
3038	self._wizard.bookedFlight.id is not None)
3039
3040	def _flightTypeChanged(self, comboBox):
3041	"""Called when the flight type has changed."""
3042	self._updateButtons()
3043
3044	def _gateChanged(self, comboBox):
3045	"""Called when the arrival gate has changed."""
3046	self._updateButtons()
3047
3048	def _newFlightClicked(self, button):
3049	"""Called when the new flight button is clicked."""
3050	gui = self._wizard.gui
3051	if not self._pirepSent and not self._pirepSaved:
3052	dialog = gtk.MessageDialog(parent = gui.mainWindow,
3053	type = MESSAGETYPE_QUESTION,
3054	message_format = xstr("finish_newFlight_question"))
3055
3056	dialog.add_button(xstr("button_no"), RESPONSETYPE_NO)
3057	dialog.add_button(xstr("button_yes"), RESPONSETYPE_YES)
3058
3059	dialog.set_title(WINDOW_TITLE_BASE)
3060	result = dialog.run()
3061	dialog.hide()
3062	if result!=RESPONSETYPE_YES:
3063	return
3064
3065	gui.reset()
3066
3067	def _getDefaultPIREPName(self):
3068	"""Get the default name of the PIREP."""
3069	gui = self._wizard.gui
3070
3071	bookedFlight = gui.bookedFlight
3072	tm = time.gmtime()
3073
3074	pilotID = self._wizard.pilotID
3075	if pilotID: pilotID += " "
3076	return "%s%s %02d%02d %s-%s.pirep" % \
3077	(pilotID, str(bookedFlight.departureTime.date()),
3078	tm.tm_hour, tm.tm_min,
3079	bookedFlight.departureICAO, bookedFlight.arrivalICAO)
3080
3081
3082	def _saveClicked(self, button):
3083	"""Called when the Save PIREP button is clicked."""
3084	gui = self._wizard.gui
3085
3086	fileName = self._getDefaultPIREPName()
3087
3088	dialog = self._getSaveDialog()
3089
3090	if self._lastSavePath is None:
3091	pirepDirectory = gui.config.pirepDirectory
3092	if pirepDirectory is not None:
3093	dialog.set_current_folder(pirepDirectory)
3094	else:
3095	dialog.set_current_folder(os.path.dirname(self._lastSavePath))
3096
3097	dialog.set_current_name(fileName)
3098	result = dialog.run()
3099	dialog.hide()
3100
3101	if result==RESPONSETYPE_OK:
3102	self._lastSavePath = text2unicode(dialog.get_filename())
3103	self._savePIREP()
3104
3105	def _savePIREP(self, automatic = False):
3106	"""Perform the saving of the PIREP."""
3107
3108	gui = self._wizard.gui
3109
3110	if automatic:
3111	gui.beginBusy(xstr("finish_autosave_busy"))
3112
3113	pirep = PIREP(gui.flight)
3114	error = pirep.save(self._lastSavePath)
3115
3116	if automatic:
3117	gui.endBusy()
3118
3119	if error:
3120	type = MESSAGETYPE_ERROR
3121	message = xstr("finish_save_failed")
3122	secondary = xstr("finish_save_failed_sec") % (text2unicode(error),)
3123	else:
3124	type = MESSAGETYPE_INFO
3125	message = xstr("finish_save_done")
3126	if automatic:
3127	secondary = xstr("finish_save_done_sec") % (self._lastSavePath,)
3128	else:
3129	secondary = None
3130	self._pirepSaved = True
3131
3132	dialog = gtk.MessageDialog(parent = gui.mainWindow,
3133	type = type, message_format = message)
3134	dialog.add_button(xstr("button_ok"), RESPONSETYPE_OK)
3135	dialog.set_title(WINDOW_TITLE_BASE)
3136	if secondary is not None:
3137	dialog.format_secondary_markup(secondary)
3138
3139	dialog.run()
3140	dialog.hide()
3141
3142	def _getSaveDialog(self):
3143	"""Get the PIREP saving dialog.
3144
3145	If it does not exist yet, create it."""
3146	if self._savePIREPDialog is None:
3147	gui = self._wizard.gui
3148	dialog = gtk.FileChooserDialog(title = WINDOW_TITLE_BASE + " - " +
3149	xstr("finish_save_title"),
3150	action = FILE_CHOOSER_ACTION_SAVE,
3151	buttons = (gtk.STOCK_CANCEL,
3152	RESPONSETYPE_CANCEL,
3153	gtk.STOCK_OK, RESPONSETYPE_OK),
3154	parent = gui.mainWindow)
3155	dialog.set_modal(True)
3156	dialog.set_do_overwrite_confirmation(True)
3157
3158	filter = gtk.FileFilter()
3159	filter.set_name(xstr("file_filter_pireps"))
3160	filter.add_pattern("*.pirep")
3161	dialog.add_filter(filter)
3162
3163	filter = gtk.FileFilter()
3164	filter.set_name(xstr("file_filter_all"))
3165	filter.add_pattern(".")
3166	dialog.add_filter(filter)
3167
3168	self._savePIREPDialog = dialog
3169
3170	return self._savePIREPDialog
3171
3172
3173	def _sendClicked(self, button):
3174	"""Called when the Send button is clicked."""
3175	pirep = PIREP(self._wizard.gui.flight)
3176	self._wizard.gui.sendPIREP(pirep,
3177	callback = self._handlePIREPSent)
3178
3179	def _handlePIREPSent(self, returned, result):
3180	"""Callback for the PIREP sending result."""
3181	self._pirepSent = returned and result.success
3182	if self._wizard.gui.config.onlineGateSystem and \
3183	self._wizard.loggedIn and not self._wizard.entranceExam and \
3184	returned and result.success:
3185	bookedFlight = self._wizard.bookedFlight
3186	if bookedFlight.arrivalICAO=="LHBP":
3187	iter = self._gate.get_active_iter()
3188	gateNumber = None if iter is None \
3189	else self._gatesModel.get_value(iter, 0)
3190
3191	status = const.PLANE_PARKING if gateNumber is None \
3192	else const.PLANE_HOME
3193	else:
3194	gateNumber = None
3195	status = const.PLANE_AWAY
3196
3197	self._wizard.updatePlane(self._planeUpdated,
3198	bookedFlight.tailNumber,
3199	status, gateNumber = gateNumber)
3200
3201	def _planeUpdated(self, success):
3202	"""Callback for the plane updating."""
3203	pass
3204
3205	#-----------------------------------------------------------------------------
3206
3207	class Wizard(gtk.VBox):
3208	"""The flight wizard."""
3209	def __init__(self, gui):
3210	"""Construct the wizard."""
3211	super(Wizard, self).__init__()
3212
3213	self.gui = gui
3214
3215	self._pages = []
3216	self._currentPage = None
3217
3218	self._loginPage = LoginPage(self)
3219	self._pages.append(self._loginPage)
3220	self._pages.append(FlightSelectionPage(self))
3221	self._pages.append(GateSelectionPage(self))
3222	self._pages.append(ConnectPage(self))
3223	self._payloadPage = PayloadPage(self)
3224	self._pages.append(self._payloadPage)
3225	self._payloadIndex = len(self._pages)
3226	self._pages.append(TimePage(self))
3227	self._pages.append(FuelPage(self))
3228	self._routePage = RoutePage(self)
3229	self._pages.append(self._routePage)
3230	self._departureBriefingPage = BriefingPage(self, True)
3231	self._pages.append(self._departureBriefingPage)
3232	self._arrivalBriefingPage = BriefingPage(self, False)
3233	self._pages.append(self._arrivalBriefingPage)
3234	self._arrivalBriefingIndex = len(self._pages)
3235	self._takeoffPage = TakeoffPage(self)
3236	self._pages.append(self._takeoffPage)
3237	self._cruisePage = CruisePage(self)
3238	self._pages.append(self._cruisePage)
3239	self._landingPage = LandingPage(self)
3240	self._pages.append(self._landingPage)
3241	self._finishPage = FinishPage(self)
3242	self._pages.append(self._finishPage)
3243
3244	maxWidth = 0
3245	maxHeight = 0
3246	for page in self._pages:
3247	page.show_all()
3248	pageSizeRequest = page.size_request()
3249	width = pageSizeRequest.width if pygobject else pageSizeRequest[0]
3250	height = pageSizeRequest.height if pygobject else pageSizeRequest[1]
3251	maxWidth = max(maxWidth, width)
3252	maxHeight = max(maxHeight, height)
3253	page.setStyle()
3254	maxWidth += 16
3255	maxHeight += 32
3256	self.set_size_request(maxWidth, maxHeight)
3257
3258	self._initialize()
3259
3260	@property
3261	def pilotID(self):
3262	"""Get the pilot ID, if given."""
3263	return self._loginPage.pilotID
3264
3265	@property
3266	def entranceExam(self):
3267	"""Get whether an entrance exam is about to be taken."""
3268	return self._loginPage.entranceExam
3269
3270	@property
3271	def loggedIn(self):
3272	"""Indicate if there was a successful login."""
3273	return self._loginResult is not None
3274
3275	@property
3276	def loginResult(self):
3277	"""Get the login result."""
3278	return self._loginResult
3279
3280	def setCurrentPage(self, index, finalize = False):
3281	"""Set the current page to the one with the given index."""
3282	assert index < len(self._pages)
3283
3284	fromPage = self._currentPage
3285	if fromPage is not None:
3286	page = self._pages[fromPage]
3287	if finalize and not page._completed:
3288	page.complete()
3289	self.remove(page)
3290
3291	self._currentPage = index
3292	page = self._pages[index]
3293	self.add(page)
3294	if page._fromPage is None:
3295	page._fromPage = fromPage
3296	page.initialize()
3297	self.show_all()
3298	if fromPage is not None:
3299	self.grabDefault()
3300
3301	@property
3302	def bookedFlight(self):
3303	"""Get the booked flight selected."""
3304	return self._bookedFlight
3305
3306	@property
3307	def numCrew(self):
3308	"""Get the number of crew members."""
3309	return self._payloadPage.numCrew
3310
3311	@property
3312	def numPassengers(self):
3313	"""Get the number of passengers."""
3314	return self._payloadPage.numPassengers
3315
3316	@property
3317	def bagWeight(self):
3318	"""Get the baggage weight."""
3319	return self._payloadPage.bagWeight
3320
3321	@property
3322	def cargoWeight(self):
3323	"""Get the cargo weight."""
3324	return self._payloadPage.cargoWeight
3325
3326	@property
3327	def mailWeight(self):
3328	"""Get the mail weight."""
3329	return self._payloadPage.mailWeight
3330
3331	@property
3332	def zfw(self):
3333	"""Get the calculated ZFW value."""
3334	return 0 if self._bookedFlight is None \
3335	else self._payloadPage.calculateZFW()
3336
3337	@property
3338	def filedCruiseLevel(self):
3339	"""Get the filed cruise level."""
3340	return self._routePage.filedCruiseLevel
3341
3342	@property
3343	def filedCruiseAltitude(self):
3344	"""Get the filed cruise altitude."""
3345	return self._routePage.filedCruiseLevel * 100
3346
3347	@property
3348	def cruiseAltitude(self):
3349	"""Get the cruise altitude."""
3350	level = self._cruisePage.cruiseLevel if self._cruisePage.activated \
3351	else self._routePage.filedCruiseLevel
3352	return level * 100
3353
3354	@property
3355	def loggableCruiseAltitude(self):
3356	"""Get the cruise altitude that can be logged."""
3357	if self._cruisePage.activated:
3358	return self._cruisePage.loggableCruiseLevel * 100
3359	else:
3360	return 0
3361
3362	@property
3363	def route(self):
3364	"""Get the route."""
3365	return self._routePage.route
3366
3367	@property
3368	def departureMETAR(self):
3369	"""Get the METAR of the departure airport."""
3370	return self._departureBriefingPage.metar
3371
3372	@property
3373	def arrivalMETAR(self):
3374	"""Get the METAR of the arrival airport."""
3375	return self._arrivalBriefingPage.metar
3376
3377	@property
3378	def departureRunway(self):
3379	"""Get the departure runway."""
3380	return self._takeoffPage.runway
3381
3382	@property
3383	def sid(self):
3384	"""Get the SID."""
3385	return self._takeoffPage.sid
3386
3387	@property
3388	def v1(self):
3389	"""Get the V1 speed."""
3390	return self._takeoffPage.v1
3391
3392	@property
3393	def vr(self):
3394	"""Get the Vr speed."""
3395	return self._takeoffPage.vr
3396
3397	@property
3398	def v2(self):
3399	"""Get the V2 speed."""
3400	return self._takeoffPage.v2
3401
3402	@property
3403	def derate(self):
3404	"""Get the derate value."""
3405	return self._takeoffPage.derate
3406
3407	@property
3408	def takeoffAntiIceOn(self):
3409	"""Get whether the anti-ice system was on during take-off."""
3410	return self._takeoffPage.antiIceOn
3411
3412	@takeoffAntiIceOn.setter
3413	def takeoffAntiIceOn(self, value):
3414	"""Set anti-ice on indicator."""
3415	self._takeoffPage.antiIceOn = value
3416
3417	@property
3418	def rtoIndicated(self):
3419	"""Get whether the pilot has indicated that an RTO has occured."""
3420	return self._takeoffPage.rtoIndicated
3421
3422	@property
3423	def arrivalRunway(self):
3424	"""Get the arrival runway."""
3425	return self._landingPage.runway
3426
3427	@property
3428	def star(self):
3429	"""Get the STAR."""
3430	return self._landingPage.star
3431
3432	@property
3433	def transition(self):
3434	"""Get the transition."""
3435	return self._landingPage.transition
3436
3437	@property
3438	def approachType(self):
3439	"""Get the approach type."""
3440	return self._landingPage.approachType
3441
3442	@property
3443	def vref(self):
3444	"""Get the Vref speed."""
3445	return self._landingPage.vref
3446
3447	@property
3448	def landingAntiIceOn(self):
3449	"""Get whether the anti-ice system was on during landing."""
3450	return self._landingPage.antiIceOn
3451
3452	@landingAntiIceOn.setter
3453	def landingAntiIceOn(self, value):
3454	"""Set anti-ice on indicator."""
3455	self._landingPage.antiIceOn = value
3456
3457	@property
3458	def flightType(self):
3459	"""Get the flight type."""
3460	return self._finishPage.flightType
3461
3462	@property
3463	def online(self):
3464	"""Get whether the flight was online or not."""
3465	return self._finishPage.online
3466
3467	def nextPage(self, finalize = True):
3468	"""Go to the next page."""
3469	self.jumpPage(1, finalize)
3470
3471	def jumpPage(self, count, finalize = True):
3472	"""Go to the page which is 'count' pages after the current one."""
3473	self.setCurrentPage(self._currentPage + count, finalize = finalize)
3474
3475	def grabDefault(self):
3476	"""Make the default button of the current page the default."""
3477	self._pages[self._currentPage].grabDefault()
3478
3479	def connected(self, fsType, descriptor):
3480	"""Called when the connection could be made to the simulator."""
3481	self.nextPage()
3482
3483	def reset(self, loginResult):
3484	"""Resets the wizard to go back to the login page."""
3485	self._initialize(keepLoginResult = loginResult is None,
3486	loginResult = loginResult)
3487
3488	def setStage(self, stage):
3489	"""Set the flight stage to the given one."""
3490	if stage!=const.STAGE_END:
3491	self._cruisePage.setLoggable(Flight.canLogCruiseAltitude(stage))
3492
3493	if stage==const.STAGE_TAKEOFF:
3494	self._takeoffPage.allowForward()
3495	elif stage==const.STAGE_LANDING:
3496	if not self._arrivalBriefingPage.metarEdited:
3497	print "Downloading arrival METAR again"
3498	self.gui.webHandler.getMETARs(self._arrivalMETARCallback,
3499	[self._bookedFlight.arrivalICAO])
3500
3501	elif stage==const.STAGE_END:
3502	for page in self._pages:
3503	page.flightEnded()
3504
3505	def _initialize(self, keepLoginResult = False, loginResult = None):
3506	"""Initialize the wizard."""
3507	if not keepLoginResult:
3508	self._loginResult = loginResult
3509
3510	self._loginCallback = None
3511
3512	self._fleet = None
3513	self._fleetCallback = None
3514
3515	self._bookedFlight = None
3516	self._departureGate = "-"
3517	self._fuelData = None
3518	self._departureNOTAMs = None
3519	self._departureMETAR = None
3520	self._arrivalNOTAMs = None
3521	self._arrivalMETAR = None
3522
3523	firstPage = 0 if self._loginResult is None else 1
3524	for page in self._pages[firstPage:]:
3525	page.reset()
3526
3527	self.setCurrentPage(firstPage)
3528
3529	def login(self, callback, pilotID, password, entranceExam):
3530	"""Called when the login button was clicked."""
3531	self._loginCallback = callback
3532	if pilotID is None:
3533	loginResult = self._loginResult
3534	assert loginResult is not None and loginResult.loggedIn
3535	pilotID = loginResult.pilotID
3536	password = loginResult.password
3537	entranceExam = loginResult.entranceExam
3538	busyMessage = xstr("reload_busy")
3539	else:
3540	self._loginResult = None
3541	busyMessage = xstr("login_busy")
3542
3543	self.gui.beginBusy(busyMessage)
3544
3545	self.gui.webHandler.login(self._loginResultCallback,
3546	pilotID, password,
3547	entranceExam = entranceExam)
3548
3549	def reloadFlights(self, callback):
3550	"""Reload the flights from the MAVA server."""
3551	self.login(callback, None, None, None)
3552
3553	def cruiseLevelChanged(self):
3554	"""Called when the cruise level is changed."""
3555	return self.gui.cruiseLevelChanged()
3556
3557	def _loginResultCallback(self, returned, result):
3558	"""The login result callback, called in the web handler's thread."""
3559	gobject.idle_add(self._handleLoginResult, returned, result)
3560
3561	def _handleLoginResult(self, returned, result):
3562	"""Handle the login result."""
3563	self.gui.endBusy()
3564	isReload = self._loginResult is not None
3565	if returned:
3566	if result.loggedIn:
3567	self._loginResult = result
3568	else:
3569	if isReload:
3570	message = xstr("reload_failed")
3571	else:
3572	message = xstr("login_entranceExam_invalid"
3573	if self.entranceExam else
3574	xstr("login_invalid"))
3575	dialog = gtk.MessageDialog(parent = self.gui.mainWindow,
3576	type = MESSAGETYPE_ERROR,
3577	message_format = message)
3578	dialog.add_button(xstr("button_ok"), RESPONSETYPE_OK)
3579	dialog.set_title(WINDOW_TITLE_BASE)
3580	if isReload:
3581	secondary = xstr("reload_failed_sec")
3582	else:
3583	secondary = xstr("login_entranceExam_invalid_sec"
3584	if self.entranceExam else
3585	xstr("login_invalid_sec"))
3586	dialog.format_secondary_markup(secondary)
3587	dialog.run()
3588	dialog.hide()
3589	else:
3590	message = xstr("reload_failconn") if isReload \
3591	else xstr("login_failconn")
3592	dialog = gtk.MessageDialog(parent = self.gui.mainWindow,
3593	type = MESSAGETYPE_ERROR,
3594	message_format = message)
3595	dialog.add_button(xstr("button_ok"), RESPONSETYPE_OK)
3596	dialog.set_title(WINDOW_TITLE_BASE)
3597	secondary = xstr("reload_failconn_sec") if isReload \
3598	else xstr("login_failconn_sec")
3599	dialog.format_secondary_markup(secondary)
3600
3601	dialog.run()
3602	dialog.hide()
3603
3604	callback = self._loginCallback
3605	self._loginCallback = None
3606	callback(returned, result)
3607
3608	def getFleet(self, callback, force = False):
3609	"""Get the fleet via the GUI and call the given callback."""
3610	self._fleetCallback = callback
3611	self.gui.getFleet(callback = self._fleetRetrieved, force = force)
3612
3613	def _fleetRetrieved(self, fleet):
3614	"""Callback for the fleet retrieval."""
3615	self._fleet = fleet
3616	if self._fleetCallback is not None:
3617	self._fleetCallback(fleet)
3618	self._fleetCallback = None
3619
3620	def updatePlane(self, callback, tailNumber, status, gateNumber = None):
3621	"""Update the given plane's gate information."""
3622	self.gui.updatePlane(tailNumber, status, gateNumber = gateNumber,
3623	callback = callback)
3624
3625	def updateRTO(self):
3626	"""Update the RTO state.
3627
3628	The RTO checkbox will be enabled if the flight has an RTO state and the
3629	comments field contains some text."""
3630	flight = self.gui.flight
3631	rtoEnabled = flight is not None and flight.hasRTO and \
3632	self.gui.hasComments
3633	self._takeoffPage.setRTOEnabled(rtoEnabled)
3634
3635	def rtoToggled(self, indicated):
3636	"""Called when the RTO indication has changed."""
3637	self.gui.rtoToggled(indicated)
3638
3639	def _connectSimulator(self, simulatorType):
3640	"""Connect to the simulator."""
3641	self.gui.connectSimulator(self._bookedFlight.aircraftType,
3642	simulatorType)
3643
3644	def _arrivalMETARCallback(self, returned, result):
3645	"""Called when the METAR of the arrival airport is retrieved."""
3646	gobject.idle_add(self._handleArrivalMETAR, returned, result)
3647
3648	def _handleArrivalMETAR(self, returned, result):
3649	"""Called when the METAR of the arrival airport is retrieved."""
3650	icao = self._bookedFlight.arrivalICAO
3651	if returned and icao in result.metars:
3652	metar = result.metars[icao]
3653	if metar!="":
3654	self._arrivalBriefingPage.setMETAR(metar)
3655
3656	#-----------------------------------------------------------------------------

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

Download in other formats: