Context Navigation

source: src/mlx/gui/flight.py@ 522:63e057098ed7

Visit:

Last change on this file since 522:63e057098ed7 was 512:46bd71540346, checked in by István Váradi <ivaradi@…>, 11 years ago
Implemented the new derate handling method (re #202)
File size: 134.5 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	alignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
883	xscale = 0.0, yscale = 0.0)
884
885	table = gtk.Table(5, 2)
886	table.set_row_spacings(4)
887	table.set_col_spacings(16)
888	table.set_homogeneous(True)
889	alignment.add(table)
890	self.setMainWidget(alignment)
891
892	labelAlignment = gtk.Alignment(xalign=1.0, xscale=0.0)
893	label = gtk.Label(xstr("connect_flightno"))
894	labelAlignment.add(label)
895	table.attach(labelAlignment, 0, 1, 0, 1)
896
897	labelAlignment = gtk.Alignment(xalign=0.0, xscale=0.0)
898	self._flightNumber = gtk.Label()
899	self._flightNumber.set_width_chars(9)
900	self._flightNumber.set_alignment(0.0, 0.5)
901	labelAlignment.add(self._flightNumber)
902	table.attach(labelAlignment, 1, 2, 0, 1)
903
904	labelAlignment = gtk.Alignment(xalign=1.0, xscale=0.0)
905	label = gtk.Label(xstr("connect_acft"))
906	labelAlignment.add(label)
907	table.attach(labelAlignment, 0, 1, 1, 2)
908
909	labelAlignment = gtk.Alignment(xalign=0.0, xscale=0.0)
910	self._aircraft = gtk.Label()
911	self._aircraft.set_width_chars(25)
912	self._aircraft.set_alignment(0.0, 0.5)
913	labelAlignment.add(self._aircraft)
914	table.attach(labelAlignment, 1, 2, 1, 2)
915
916	labelAlignment = gtk.Alignment(xalign=1.0, xscale=0.0)
917	label = gtk.Label(xstr("connect_tailno"))
918	labelAlignment.add(label)
919	table.attach(labelAlignment, 0, 1, 2, 3)
920
921	labelAlignment = gtk.Alignment(xalign=0.0, xscale=0.0)
922	self._tailNumber = gtk.Label()
923	self._tailNumber.set_width_chars(10)
924	self._tailNumber.set_alignment(0.0, 0.5)
925	labelAlignment.add(self._tailNumber)
926	table.attach(labelAlignment, 1, 2, 2, 3)
927
928	labelAlignment = gtk.Alignment(xalign=1.0, xscale=0.0)
929	label = gtk.Label(xstr("connect_airport"))
930	labelAlignment.add(label)
931	table.attach(labelAlignment, 0, 1, 3, 4)
932
933	labelAlignment = gtk.Alignment(xalign=0.0, xscale=0.0)
934	self._departureICAO = gtk.Label()
935	self._departureICAO.set_width_chars(6)
936	self._departureICAO.set_alignment(0.0, 0.5)
937	labelAlignment.add(self._departureICAO)
938	table.attach(labelAlignment, 1, 2, 3, 4)
939
940	labelAlignment = gtk.Alignment(xalign=1.0, xscale=0.0)
941	label = gtk.Label(xstr("connect_gate"))
942	labelAlignment.add(label)
943	table.attach(labelAlignment, 0, 1, 4, 5)
944
945	labelAlignment = gtk.Alignment(xalign=0.0, xscale=0.0)
946	self._departureGate = gtk.Label()
947	self._departureGate.set_width_chars(5)
948	self._departureGate.set_alignment(0.0, 0.5)
949	labelAlignment.add(self._departureGate)
950	table.attach(labelAlignment, 1, 2, 4, 5)
951
952	self.addCancelFlightButton()
953
954	self.addPreviousButton(clicked = self._backClicked)
955
956	self._button = self.addButton(xstr("button_connect"), default = True,
957	tooltip = xstr("button_connect_tooltip"))
958	self._clickedID = self._button.connect("clicked", self._connectClicked)
959
960	def activate(self):
961	"""Setup the departure information."""
962	self._button.set_label(xstr("button_connect"))
963	self._button.set_use_underline(True)
964	self._button.set_tooltip_text(xstr("button_connect_tooltip"))
965	self._button.disconnect(self._clickedID)
966	self._clickedID = self._button.connect("clicked", self._connectClicked)
967
968	bookedFlight = self._wizard._bookedFlight
969
970	self._flightNumber.set_markup("<b>" + bookedFlight.callsign + "</b>")
971
972	aircraftType = aircraftNames[bookedFlight.aircraftType]
973	self._aircraft.set_markup("<b>" + aircraftType + "</b>")
974
975	self._tailNumber.set_markup("<b>" + bookedFlight.tailNumber + "</b>")
976
977	icao = bookedFlight.departureICAO
978	self._departureICAO.set_markup("<b>" + icao + "</b>")
979	gate = self._wizard._departureGate
980	if gate!="-":
981	gate = "<b>" + gate + "</b>"
982	self._departureGate.set_markup(gate)
983
984	def finalize(self):
985	"""Finalize the page."""
986	self._button.set_label(xstr("button_next"))
987	self._button.set_use_underline(True)
988	self._button.set_tooltip_text(xstr("button_next_tooltip"))
989	self._button.disconnect(self._clickedID)
990	self._clickedID = self._button.connect("clicked", self._forwardClicked)
991
992	def _backClicked(self, button):
993	"""Called when the Back button is pressed."""
994	self.goBack()
995
996	def _connectClicked(self, button):
997	"""Called when the Connect button is pressed."""
998	self._wizard._connectSimulator()
999
1000	def _forwardClicked(self, button):
1001	"""Called when the Forward button is pressed."""
1002	self._wizard.nextPage()
1003
1004	#-----------------------------------------------------------------------------
1005
1006	class PayloadPage(Page):
1007	"""Page to allow setting up the payload."""
1008	def __init__(self, wizard):
1009	"""Construct the page."""
1010	super(PayloadPage, self).__init__(wizard, xstr("payload_title"),
1011	xstr("payload_help"),
1012	completedHelp = xstr("payload_chelp"))
1013
1014	alignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
1015	xscale = 0.0, yscale = 0.0)
1016
1017	table = gtk.Table(7, 3)
1018	table.set_row_spacings(4)
1019	table.set_col_spacings(16)
1020	table.set_homogeneous(False)
1021	alignment.add(table)
1022	self.setMainWidget(alignment)
1023
1024	label = gtk.Label(xstr("payload_crew"))
1025	label.set_use_underline(True)
1026	label.set_alignment(0.0, 0.5)
1027	table.attach(label, 0, 1, 0, 1)
1028
1029	self._numCrew = IntegerEntry(defaultValue = 0)
1030	self._numCrew.set_width_chars(6)
1031	self._numCrew.connect("integer-changed", self._weightChanged)
1032	self._numCrew.set_tooltip_text(xstr("payload_crew_tooltip"))
1033	table.attach(self._numCrew, 1, 2, 0, 1)
1034	label.set_mnemonic_widget(self._numCrew)
1035
1036	label = gtk.Label(xstr("payload_pax"))
1037	label.set_use_underline(True)
1038	label.set_alignment(0.0, 0.5)
1039	table.attach(label, 0, 1, 1, 2)
1040
1041	self._numPassengers = IntegerEntry(defaultValue = 0)
1042	self._numPassengers.set_width_chars(6)
1043	self._numPassengers.connect("integer-changed", self._weightChanged)
1044	self._numPassengers.set_tooltip_text(xstr("payload_pax_tooltip"))
1045	table.attach(self._numPassengers, 1, 2, 1, 2)
1046	label.set_mnemonic_widget(self._numPassengers)
1047
1048	label = gtk.Label(xstr("payload_bag"))
1049	label.set_use_underline(True)
1050	label.set_alignment(0.0, 0.5)
1051	table.attach(label, 0, 1, 2, 3)
1052
1053	self._bagWeight = IntegerEntry(defaultValue = 0)
1054	self._bagWeight.set_width_chars(6)
1055	self._bagWeight.connect("integer-changed", self._weightChanged)
1056	self._bagWeight.set_tooltip_text(xstr("payload_bag_tooltip"))
1057	table.attach(self._bagWeight, 1, 2, 2, 3)
1058	label.set_mnemonic_widget(self._bagWeight)
1059
1060	table.attach(gtk.Label("kg"), 2, 3, 2, 3)
1061
1062	label = gtk.Label(xstr("payload_cargo"))
1063	label.set_use_underline(True)
1064	label.set_alignment(0.0, 0.5)
1065	table.attach(label, 0, 1, 3, 4)
1066
1067	self._cargoWeight = IntegerEntry(defaultValue = 0)
1068	self._cargoWeight.set_width_chars(6)
1069	self._cargoWeight.connect("integer-changed", self._weightChanged)
1070	self._cargoWeight.set_tooltip_text(xstr("payload_cargo_tooltip"))
1071	table.attach(self._cargoWeight, 1, 2, 3, 4)
1072	label.set_mnemonic_widget(self._cargoWeight)
1073
1074	table.attach(gtk.Label("kg"), 2, 3, 3, 4)
1075
1076	label = gtk.Label(xstr("payload_mail"))
1077	label.set_use_underline(True)
1078	label.set_alignment(0.0, 0.5)
1079	table.attach(label, 0, 1, 4, 5)
1080
1081	self._mailWeight = IntegerEntry(defaultValue = 0)
1082	self._mailWeight.set_width_chars(6)
1083	self._mailWeight.connect("integer-changed", self._weightChanged)
1084	self._mailWeight.set_tooltip_text(xstr("payload_mail_tooltip"))
1085	table.attach(self._mailWeight, 1, 2, 4, 5)
1086	label.set_mnemonic_widget(self._mailWeight)
1087
1088	table.attach(gtk.Label("kg"), 2, 3, 4, 5)
1089
1090	label = gtk.Label("<b>" + xstr("payload_zfw") + "</b>")
1091	label.set_alignment(0.0, 0.5)
1092	label.set_use_markup(True)
1093	table.attach(label, 0, 1, 5, 6)
1094
1095	self._calculatedZFW = gtk.Label()
1096	self._calculatedZFW.set_width_chars(6)
1097	self._calculatedZFW.set_alignment(1.0, 0.5)
1098	table.attach(self._calculatedZFW, 1, 2, 5, 6)
1099
1100	table.attach(gtk.Label("kg"), 2, 3, 5, 6)
1101
1102	self._zfwButton = gtk.Button(xstr("payload_fszfw"))
1103	self._zfwButton.set_use_underline(True)
1104	self._zfwButton.connect("clicked", self._zfwRequested)
1105	self._zfwButton.set_tooltip_text(xstr("payload_fszfw_tooltip"))
1106	table.attach(self._zfwButton, 0, 1, 6, 7)
1107
1108	self._simulatorZFW = gtk.Label("-")
1109	self._simulatorZFW.set_width_chars(6)
1110	self._simulatorZFW.set_alignment(1.0, 0.5)
1111	table.attach(self._simulatorZFW, 1, 2, 6, 7)
1112	self._simulatorZFWValue = None
1113
1114	table.attach(gtk.Label("kg"), 2, 3, 6, 7)
1115
1116	self.addCancelFlightButton()
1117	self._backButton = self.addPreviousButton(clicked = self._backClicked)
1118	self._button = self.addNextButton(clicked = self._forwardClicked)
1119
1120	@property
1121	def numCrew(self):
1122	"""The number of the crew members on the flight."""
1123	return self._numCrew.get_int()
1124
1125	@property
1126	def numPassengers(self):
1127	"""The number of the passengers on the flight."""
1128	return self._numPassengers.get_int()
1129
1130	@property
1131	def bagWeight(self):
1132	"""Get the bag weight entered."""
1133	return self._bagWeight.get_int()
1134
1135	@property
1136	def cargoWeight(self):
1137	"""Get the cargo weight entered."""
1138	return self._cargoWeight.get_int()
1139
1140	@property
1141	def mailWeight(self):
1142	"""Get the bag weight entered."""
1143	return self._mailWeight.get_int()
1144
1145	def activate(self):
1146	"""Setup the information."""
1147	bookedFlight = self._wizard._bookedFlight
1148
1149	self._numCrew.set_int(bookedFlight.numCrew)
1150	self._numCrew.set_sensitive(True)
1151	self._numPassengers.set_int(bookedFlight.numPassengers)
1152	self._numPassengers.set_sensitive(True)
1153
1154	self._bagWeight.set_int(bookedFlight.bagWeight)
1155	self._bagWeight.set_sensitive(True)
1156	self._cargoWeight.set_int(bookedFlight.cargoWeight)
1157	self._cargoWeight.set_sensitive(True)
1158	self._mailWeight.set_int(bookedFlight.mailWeight)
1159	self._mailWeight.set_sensitive(True)
1160
1161	self._simulatorZFW.set_text("-")
1162	self._simulatorZFWValue = None
1163	self._zfwButton.set_sensitive(True)
1164	self._updateCalculatedZFW()
1165
1166	def finalize(self):
1167	"""Finalize the payload page."""
1168	self._numCrew.set_sensitive(False)
1169	self._numPassengers.set_sensitive(False)
1170	self._bagWeight.set_sensitive(False)
1171	self._cargoWeight.set_sensitive(False)
1172	self._mailWeight.set_sensitive(False)
1173	self._wizard.gui.initializeWeightHelp()
1174
1175	def calculateZFW(self):
1176	"""Calculate the ZFW value."""
1177	zfw = self._wizard.gui._flight.aircraft.dow
1178	zfw += (self._numCrew.get_int() + self._numPassengers.get_int()) * 82
1179	zfw += self._bagWeight.get_int()
1180	zfw += self._cargoWeight.get_int()
1181	zfw += self._mailWeight.get_int()
1182	return zfw
1183
1184	def _updateCalculatedZFW(self):
1185	"""Update the calculated ZFW"""
1186	zfw = self.calculateZFW()
1187
1188	markupBegin = "<b>"
1189	markupEnd = "</b>"
1190	if self._simulatorZFWValue is not None and \
1191	PayloadChecker.isZFWFaulty(self._simulatorZFWValue, zfw):
1192	markupBegin += '<span foreground="red">'
1193	markupEnd = "</span>" + markupEnd
1194	self._calculatedZFW.set_markup(markupBegin + str(zfw) + markupEnd)
1195
1196	def _weightChanged(self, entry, weight):
1197	"""Called when one of the weight values or humanm counts has changed."""
1198	self._updateCalculatedZFW()
1199
1200	def _zfwRequested(self, button):
1201	"""Called when the ZFW is requested from the simulator."""
1202	self._zfwButton.set_sensitive(False)
1203	self._backButton.set_sensitive(False)
1204	self._button.set_sensitive(False)
1205	gui = self._wizard.gui
1206	gui.beginBusy(xstr("payload_zfw_busy"))
1207	gui.simulator.requestZFW(self._handleZFW)
1208
1209	def _handleZFW(self, zfw):
1210	"""Called when the ZFW value is retrieved."""
1211	gobject.idle_add(self._processZFW, zfw)
1212
1213	def _processZFW(self, zfw):
1214	"""Process the given ZFW value received from the simulator."""
1215	self._wizard.gui.endBusy()
1216	self._zfwButton.set_sensitive(True)
1217	self._backButton.set_sensitive(True)
1218	self._button.set_sensitive(True)
1219	self._simulatorZFWValue = zfw
1220	self._simulatorZFW.set_text("%.0f" % (zfw,))
1221	self._updateCalculatedZFW()
1222
1223	def _forwardClicked(self, button):
1224	"""Called when the forward button is clicked."""
1225	self._wizard.nextPage()
1226
1227	def _backClicked(self, button):
1228	"""Called when the Back button is pressed."""
1229	self.goBack()
1230
1231	#-----------------------------------------------------------------------------
1232
1233	class TimePage(Page):
1234	"""Page displaying the departure and arrival times and allows querying the
1235	current time from the flight simulator."""
1236	def __init__(self, wizard):
1237	super(TimePage, self).__init__(wizard, xstr("time_title"),
1238	xstr("time_help"),
1239	completedHelp = xstr("time_chelp"))
1240
1241	alignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
1242	xscale = 0.0, yscale = 0.0)
1243
1244	table = gtk.Table(3, 2)
1245	table.set_row_spacings(4)
1246	table.set_col_spacings(16)
1247	table.set_homogeneous(False)
1248	alignment.add(table)
1249	self.setMainWidget(alignment)
1250
1251	label = gtk.Label(xstr("time_departure"))
1252	label.set_alignment(0.0, 0.5)
1253	table.attach(label, 0, 1, 0, 1)
1254
1255	self._departure = gtk.Label()
1256	self._departure.set_alignment(0.0, 0.5)
1257	table.attach(self._departure, 1, 2, 0, 1)
1258
1259	label = gtk.Label(xstr("time_arrival"))
1260	label.set_alignment(0.0, 0.5)
1261	table.attach(label, 0, 1, 1, 2)
1262
1263	self._arrival = gtk.Label()
1264	self._arrival.set_alignment(0.0, 0.5)
1265	table.attach(self._arrival, 1, 2, 1, 2)
1266
1267	self._timeButton = gtk.Button(xstr("time_fs"))
1268	self._timeButton.set_use_underline(True)
1269	self._timeButton.set_tooltip_text(xstr("time_fs_tooltip"))
1270	self._timeButton.connect("clicked", self._timeRequested)
1271	table.attach(self._timeButton, 0, 1, 2, 3)
1272
1273	self._simulatorTime = gtk.Label("-")
1274	self._simulatorTime.set_alignment(0.0, 0.5)
1275	table.attach(self._simulatorTime, 1, 2, 2, 3)
1276
1277	self.addCancelFlightButton()
1278
1279	self._backButton = self.addPreviousButton(clicked = self._backClicked)
1280	self._button = self.addNextButton(clicked = self._forwardClicked)
1281
1282	def activate(self):
1283	"""Activate the page."""
1284	self._timeButton.set_sensitive(True)
1285	bookedFlight = self._wizard._bookedFlight
1286	self._departure.set_text(str(bookedFlight.departureTime.time()))
1287	self._arrival.set_text(str(bookedFlight.arrivalTime.time()))
1288	self._simulatorTime.set_text("-")
1289
1290	def _timeRequested(self, button):
1291	"""Request the time from the simulator."""
1292	self._timeButton.set_sensitive(False)
1293	self._backButton.set_sensitive(False)
1294	self._button.set_sensitive(False)
1295	self._wizard.gui.beginBusy(xstr("time_busy"))
1296	self._wizard.gui.simulator.requestTime(self._handleTime)
1297
1298	def _handleTime(self, timestamp):
1299	"""Handle the result of a time retrieval."""
1300	gobject.idle_add(self._processTime, timestamp)
1301
1302	def _processTime(self, timestamp):
1303	"""Process the given time."""
1304	self._wizard.gui.endBusy()
1305	self._timeButton.set_sensitive(True)
1306	self._backButton.set_sensitive(True)
1307	self._button.set_sensitive(True)
1308	tm = time.gmtime(timestamp)
1309	t = datetime.time(tm.tm_hour, tm.tm_min, tm.tm_sec)
1310	self._simulatorTime.set_text(str(t))
1311
1312	ts = tm.tm_hour * 3600 + tm.tm_min * 60 + tm.tm_sec
1313	dt = self._wizard._bookedFlight.departureTime.time()
1314	dts = dt.hour * 3600 + dt.minute * 60 + dt.second
1315	diff = dts-ts
1316
1317	markupBegin = ""
1318	markupEnd = ""
1319	if diff < 0:
1320	markupBegin = '<b><span foreground="red">'
1321	markupEnd = '</span></b>'
1322	elif diff < 360 or diff > 3060:
1323	markupBegin = '<b><span foreground="orange">'
1324	markupEnd = '</span></b>'
1325
1326	self._departure.set_markup(markupBegin + str(dt) + markupEnd)
1327
1328	def _backClicked(self, button):
1329	"""Called when the Back button is pressed."""
1330	self.goBack()
1331
1332	def _forwardClicked(self, button):
1333	"""Called when the forward button is clicked."""
1334	if not self._completed:
1335	gui = self._wizard.gui
1336	gui.beginBusy(xstr("fuel_get_busy"))
1337
1338	gui.simulator.getFuel(self._handleFuel)
1339	else:
1340	self._wizard.nextPage()
1341
1342	def _handleFuel(self, fuelData):
1343	"""Callback for the fuel query operation."""
1344	gobject.idle_add(self._processFuel, fuelData)
1345
1346	def _processFuel(self, fuelData):
1347	"""Process the given fuel data."""
1348	self._wizard.gui.endBusy()
1349	self._wizard._fuelData = fuelData
1350	self._wizard.nextPage()
1351
1352	#-----------------------------------------------------------------------------
1353
1354	class FuelTank(gtk.VBox):
1355	"""Widget for the fuel tank."""
1356	def __init__(self, fuelTank, name, capacity, currentWeight):
1357	"""Construct the widget for the tank with the given name."""
1358	super(FuelTank, self).__init__()
1359
1360	self._enabled = True
1361	self.fuelTank = fuelTank
1362	self.capacity = capacity
1363	self.currentWeight = currentWeight
1364	self.expectedWeight = currentWeight
1365
1366	label = gtk.Label("<b>" + name + "</b>")
1367	label.set_use_markup(True)
1368	label.set_use_underline(True)
1369	label.set_justify(JUSTIFY_CENTER)
1370	label.set_alignment(0.5, 1.0)
1371	self.pack_start(label, False, False, 4)
1372
1373	self._tankFigure = gtk.EventBox()
1374	self._tankFigure.set_size_request(38, -1)
1375	self._tankFigure.set_visible_window(False)
1376	self._tankFigure.set_tooltip_markup(xstr("fuel_tank_tooltip"))
1377
1378	if pygobject:
1379	self._tankFigure.connect("draw", self._drawTankFigure)
1380	else:
1381	self._tankFigure.connect("expose_event", self._drawTankFigure)
1382	self._tankFigure.connect("button_press_event", self._buttonPressed)
1383	self._tankFigure.connect("motion_notify_event", self._motionNotify)
1384	self._tankFigure.connect("scroll-event", self._scrolled)
1385
1386	alignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
1387	xscale = 0.0, yscale = 1.0)
1388	alignment.add(self._tankFigure)
1389
1390	self.pack_start(alignment, True, True, 4)
1391
1392	self._expectedButton = gtk.SpinButton()
1393	self._expectedButton.set_numeric(True)
1394	self._expectedButton.set_range(0, self.capacity)
1395	self._expectedButton.set_increments(10, 100)
1396	self._expectedButton.set_value(currentWeight)
1397	self._expectedButton.set_alignment(1.0)
1398	self._expectedButton.set_width_chars(5)
1399	self._expectedButton.connect("value-changed", self._expectedChanged)
1400
1401	label.set_mnemonic_widget(self._expectedButton)
1402
1403	alignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
1404	xscale = 0.0, yscale = 1.0)
1405	alignment.add(self._expectedButton)
1406	self.pack_start(alignment, False, False, 4)
1407
1408	def setCurrent(self, currentWeight):
1409	"""Set the current weight."""
1410	self.currentWeight = currentWeight
1411	self._redraw()
1412
1413	def isCorrect(self):
1414	"""Determine if the contents of the fuel tank are as expected"""
1415	return abs(self.expectedWeight - self.currentWeight)<=1
1416
1417	def disable(self):
1418	"""Disable the fuel tank."""
1419	self._expectedButton.set_sensitive(False)
1420	self._enabled = False
1421
1422	def _redraw(self):
1423	"""Redraw the tank figure."""
1424	self._tankFigure.queue_draw()
1425
1426	def _drawTankFigure(self, tankFigure, eventOrContext):
1427	"""Draw the tank figure."""
1428	triangleSize = 5
1429
1430	context = eventOrContext if pygobject else tankFigure.window.cairo_create()
1431	(xOffset, yOffset) = (0, 0) if pygobject \
1432	else (tankFigure.allocation.x, tankFigure.allocation.y)
1433
1434	width = tankFigure.get_allocated_width() if pygobject \
1435	else tankFigure.allocation.width
1436	height = tankFigure.get_allocated_height() if pygobject \
1437	else tankFigure.allocation.height
1438
1439	rectangleX0 = triangleSize
1440	rectangleY0 = triangleSize
1441	rectangleX1 = width - 1 - triangleSize
1442	rectangleY1 = height - 1 - triangleSize
1443	rectangleLineWidth = 2.0
1444
1445	context.set_source_rgb(0.0, 0.0, 0.0)
1446	context.set_line_width(rectangleLineWidth)
1447	context.rectangle(xOffset + rectangleX0 + rectangleLineWidth/2,
1448	yOffset + rectangleY0 + rectangleLineWidth/2,
1449	rectangleX1 - rectangleX0 - rectangleLineWidth,
1450	rectangleY1 - rectangleY0 - rectangleLineWidth)
1451	context.stroke()
1452
1453	rectangleInnerLeft = rectangleX0 + rectangleLineWidth
1454	rectangleInnerRight = rectangleX1 - rectangleLineWidth
1455	self._rectangleInnerTop = rectangleInnerTop = rectangleY0 + rectangleLineWidth
1456	self._rectangleInnerBottom = rectangleInnerBottom = rectangleY1 - rectangleLineWidth
1457
1458	rectangleInnerWidth = rectangleInnerRight - rectangleInnerLeft
1459	rectangleInnerHeight = rectangleInnerBottom - rectangleInnerTop
1460
1461	context.set_source_rgb(1.0, 0.9, 0.6)
1462	currentHeight = self.currentWeight * rectangleInnerHeight / self.capacity
1463	currentX = rectangleInnerTop + rectangleInnerHeight - currentHeight
1464	context.rectangle(xOffset + rectangleInnerLeft,
1465	yOffset + rectangleInnerTop +
1466	rectangleInnerHeight - currentHeight,
1467	rectangleInnerWidth, currentHeight)
1468	context.fill()
1469
1470	expectedHeight = self.expectedWeight * rectangleInnerHeight / self.capacity
1471	expectedY = rectangleInnerTop + rectangleInnerHeight - expectedHeight
1472
1473	context.set_line_width(1.5)
1474	context.set_source_rgb(0.0, 0.85, 0.85)
1475	context.move_to(xOffset + rectangleX0, yOffset + expectedY)
1476	context.line_to(xOffset + rectangleX1, yOffset + expectedY)
1477	context.stroke()
1478
1479	context.set_line_width(0.0)
1480	context.move_to(xOffset + 0, yOffset + expectedY - triangleSize)
1481	context.line_to(xOffset + 0, yOffset + expectedY + triangleSize)
1482	context.line_to(xOffset + rectangleX0 + 1, yOffset + expectedY)
1483	context.line_to(xOffset + 0, yOffset + expectedY - triangleSize)
1484	context.fill()
1485
1486	context.set_line_width(0.0)
1487	context.move_to(xOffset + width, yOffset + expectedY - triangleSize)
1488	context.line_to(xOffset + width, yOffset + expectedY + triangleSize)
1489	context.line_to(xOffset + rectangleX1 - 1, yOffset + expectedY)
1490	context.line_to(xOffset + width, yOffset + expectedY - triangleSize)
1491	context.fill()
1492
1493	return True
1494
1495	def _setExpectedFromY(self, y):
1496	"""Set the expected weight from the given Y-coordinate."""
1497	level = (self._rectangleInnerBottom - y) / \
1498	(self._rectangleInnerBottom - self._rectangleInnerTop)
1499	level = min(1.0, max(0.0, level))
1500	self._expectedButton.set_value(level * self.capacity)
1501
1502	def _buttonPressed(self, tankFigure, event):
1503	"""Called when a button is pressed in the figure.
1504
1505	The expected level will be set there."""
1506	if self._enabled and event.button==1:
1507	self._setExpectedFromY(event.y)
1508
1509	def _motionNotify(self, tankFigure, event):
1510	"""Called when the mouse pointer moves within the area of a tank figure."""
1511	if self._enabled and event.state==BUTTON1_MASK:
1512	self._setExpectedFromY(event.y)
1513
1514	def _scrolled(self, tankFigure, event):
1515	"""Called when a scroll event is received."""
1516	if self._enabled:
1517	increment = 1 if event.state==CONTROL_MASK \
1518	else 100 if event.state==SHIFT_MASK \
1519	else 10 if event.state==0 else 0
1520	if increment!=0:
1521	if event.direction==SCROLL_DOWN:
1522	increment *= -1
1523	self._expectedButton.spin(SPIN_USER_DEFINED, increment)
1524
1525	def _expectedChanged(self, spinButton):
1526	"""Called when the expected value has changed."""
1527	self.expectedWeight = spinButton.get_value_as_int()
1528	self._redraw()
1529
1530	#-----------------------------------------------------------------------------
1531
1532	class FuelPage(Page):
1533	"""The page containing the fuel tank filling."""
1534	_pumpStep = 0.02
1535
1536	def __init__(self, wizard):
1537	"""Construct the page."""
1538	super(FuelPage, self).__init__(wizard, xstr("fuel_title"),
1539	xstr("fuel_help"),
1540	completedHelp = xstr("fuel_chelp"))
1541
1542	self._fuelTanks = []
1543	self._fuelTable = None
1544	self._fuelAlignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
1545	xscale = 0.0, yscale = 1.0)
1546	self.setMainWidget(self._fuelAlignment)
1547
1548	tankData = [(tank, 2500, 3900) for tank in acft.mostFuelTanks]
1549	self._setupTanks(tankData)
1550
1551	self.addCancelFlightButton()
1552
1553	self._backButton = self.addPreviousButton(clicked = self._backClicked)
1554	self._button = self.addNextButton(clicked = self._forwardClicked)
1555
1556	self._pumpIndex = 0
1557
1558	def activate(self):
1559	"""Activate the page."""
1560	self._setupTanks(self._wizard._fuelData)
1561
1562	def finalize(self):
1563	"""Finalize the page."""
1564	for fuelTank in self._fuelTanks:
1565	fuelTank.disable()
1566
1567	def _backClicked(self, button):
1568	"""Called when the Back button is pressed."""
1569	self.goBack()
1570
1571	def _forwardClicked(self, button):
1572	"""Called when the forward button is clicked."""
1573	if not self._completed:
1574	self._pumpIndex = 0
1575	self._wizard.gui.beginBusy(xstr("fuel_pump_busy"))
1576	self._pump()
1577	else:
1578	self._wizard.nextPage()
1579
1580	def _setupTanks(self, tankData):
1581	"""Setup the tanks for the given data."""
1582	numTanks = len(tankData)
1583	if self._fuelTable is not None:
1584	self._fuelAlignment.remove(self._fuelTable)
1585
1586	self._fuelTanks = []
1587	self._fuelTable = gtk.Table(numTanks, 1)
1588	self._fuelTable.set_col_spacings(16)
1589	index = 0
1590	for (tank, current, capacity) in tankData:
1591	fuelTank = FuelTank(tank,
1592	xstr("fuel_tank_" +
1593	const.fuelTank2string(tank)),
1594	capacity, current)
1595	self._fuelTable.attach(fuelTank, index, index+1, 0, 1)
1596	self._fuelTanks.append(fuelTank)
1597	index += 1
1598
1599	self._fuelAlignment.add(self._fuelTable)
1600	self.show_all()
1601
1602	def _pump(self):
1603	"""Perform one step of pumping.
1604
1605	It is checked, if the current tank's contents are of the right
1606	quantity. If not, it is filled one step further to the desired
1607	contents. Otherwise the next tank is started. If all tanks are are
1608	filled, the next page is selected."""
1609	numTanks = len(self._fuelTanks)
1610
1611	fuelTank = None
1612	while self._pumpIndex < numTanks:
1613	fuelTank = self._fuelTanks[self._pumpIndex]
1614	if fuelTank.isCorrect():
1615	self._pumpIndex += 1
1616	fuelTank = None
1617	else:
1618	break
1619
1620	if fuelTank is None:
1621	self._wizard.gui.endBusy()
1622	self._wizard.nextPage()
1623	else:
1624	currentLevel = fuelTank.currentWeight / fuelTank.capacity
1625	expectedLevel = fuelTank.expectedWeight / fuelTank.capacity
1626	if currentLevel<expectedLevel:
1627	currentLevel += FuelPage._pumpStep
1628	if currentLevel>expectedLevel: currentLevel = expectedLevel
1629	else:
1630	currentLevel -= FuelPage._pumpStep
1631	if currentLevel<expectedLevel: currentLevel = expectedLevel
1632	fuelTank.setCurrent(currentLevel * fuelTank.capacity)
1633	self._wizard.gui.simulator.setFuelLevel([(fuelTank.fuelTank,
1634	currentLevel)])
1635	gobject.timeout_add(50, self._pump)
1636
1637	#-----------------------------------------------------------------------------
1638
1639	class RoutePage(Page):
1640	"""The page containing the route and the flight level."""
1641	def __init__(self, wizard):
1642	"""Construct the page."""
1643	super(RoutePage, self).__init__(wizard, xstr("route_title"),
1644	xstr("route_help"),
1645	completedHelp = xstr("route_chelp"))
1646
1647	alignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
1648	xscale = 0.0, yscale = 0.0)
1649
1650	mainBox = gtk.VBox()
1651	alignment.add(mainBox)
1652	self.setMainWidget(alignment)
1653
1654	levelBox = gtk.HBox()
1655
1656	label = gtk.Label(xstr("route_level"))
1657	label.set_use_underline(True)
1658	levelBox.pack_start(label, True, True, 0)
1659
1660	self._cruiseLevel = gtk.SpinButton()
1661	self._cruiseLevel.set_increments(step = 10, page = 100)
1662	self._cruiseLevel.set_range(min = 50, max = 500)
1663	self._cruiseLevel.set_tooltip_text(xstr("route_level_tooltip"))
1664	self._cruiseLevel.set_numeric(True)
1665	self._cruiseLevel.connect("value-changed", self._cruiseLevelChanged)
1666	label.set_mnemonic_widget(self._cruiseLevel)
1667
1668	levelBox.pack_start(self._cruiseLevel, False, False, 8)
1669
1670	alignment = gtk.Alignment(xalign = 0.0, yalign = 0.5,
1671	xscale = 0.0, yscale = 0.0)
1672	alignment.add(levelBox)
1673
1674	mainBox.pack_start(alignment, False, False, 0)
1675
1676
1677	routeBox = gtk.VBox()
1678
1679	alignment = gtk.Alignment(xalign = 0.0, yalign = 0.5,
1680	xscale = 0.0, yscale = 0.0)
1681	label = gtk.Label(xstr("route_route"))
1682	label.set_use_underline(True)
1683	alignment.add(label)
1684	routeBox.pack_start(alignment, True, True, 0)
1685
1686	routeWindow = gtk.ScrolledWindow()
1687	routeWindow.set_size_request(400, 80)
1688	routeWindow.set_shadow_type(gtk.ShadowType.IN if pygobject
1689	else gtk.SHADOW_IN)
1690	routeWindow.set_policy(gtk.PolicyType.AUTOMATIC if pygobject
1691	else gtk.POLICY_AUTOMATIC,
1692	gtk.PolicyType.AUTOMATIC if pygobject
1693	else gtk.POLICY_AUTOMATIC)
1694
1695	self._uppercasingRoute = False
1696
1697	self._route = gtk.TextView()
1698	self._route.set_tooltip_text(xstr("route_route_tooltip"))
1699	self._route.set_wrap_mode(WRAP_WORD)
1700	self._route.get_buffer().connect("changed", self._routeChanged)
1701	self._route.get_buffer().connect_after("insert-text", self._routeInserted)
1702	routeWindow.add(self._route)
1703
1704	label.set_mnemonic_widget(self._route)
1705	routeBox.pack_start(routeWindow, True, True, 0)
1706
1707	mainBox.pack_start(routeBox, True, True, 8)
1708
1709	self.addCancelFlightButton()
1710
1711	self._backButton = self.addPreviousButton(clicked = self._backClicked)
1712	self._button = self.addNextButton(clicked = self._forwardClicked)
1713
1714	@property
1715	def filedCruiseLevel(self):
1716	"""Get the filed cruise level."""
1717	return self._cruiseLevel.get_value_as_int()
1718
1719	@property
1720	def route(self):
1721	"""Get the route."""
1722	return self._getRoute()
1723
1724	def activate(self):
1725	"""Setup the route from the booked flight."""
1726	self._cruiseLevel.set_value(240)
1727	self._route.get_buffer().set_text(self._wizard._bookedFlight.route)
1728	self._updateForwardButton()
1729
1730	def _getRoute(self):
1731	"""Get the text of the route."""
1732	buffer = self._route.get_buffer()
1733	return buffer.get_text(buffer.get_start_iter(),
1734	buffer.get_end_iter(), True)
1735
1736	def _updateForwardButton(self):
1737	"""Update the sensitivity of the forward button."""
1738	self._button.set_sensitive(self._cruiseLevel.get_value_as_int()>=50 and \
1739	self._getRoute()!="")
1740
1741	def _cruiseLevelChanged(self, spinButton):
1742	"""Called when the cruise level has changed."""
1743	self._updateForwardButton()
1744
1745	def _routeChanged(self, textBuffer):
1746	"""Called when the route has changed."""
1747	if not self._uppercasingRoute:
1748	self._updateForwardButton()
1749
1750	def _routeInserted(self, textBuffer, iter, text, length):
1751	"""Called when new characters are inserted into the route.
1752
1753	It uppercases all characters."""
1754	if not self._uppercasingRoute:
1755	self._uppercasingRoute = True
1756
1757	iter1 = iter.copy()
1758	iter1.backward_chars(length)
1759	textBuffer.delete(iter, iter1)
1760
1761	textBuffer.insert(iter, text.upper())
1762
1763	self._uppercasingRoute = False
1764
1765	def _backClicked(self, button):
1766	"""Called when the Back button is pressed."""
1767	self.goBack()
1768
1769	def _forwardClicked(self, button):
1770	"""Called when the Forward button is clicked."""
1771	if self._completed:
1772	self._wizard.nextPage()
1773	else:
1774	bookedFlight = self._wizard._bookedFlight
1775	self._wizard.gui.beginBusy(xstr("route_down_notams"))
1776	self._wizard.gui.webHandler.getNOTAMs(self._notamsCallback,
1777	bookedFlight.departureICAO,
1778	bookedFlight.arrivalICAO)
1779	startSound(const.SOUND_NOTAM)
1780
1781	def _notamsCallback(self, returned, result):
1782	"""Callback for the NOTAMs."""
1783	gobject.idle_add(self._handleNOTAMs, returned, result)
1784
1785	def _handleNOTAMs(self, returned, result):
1786	"""Handle the NOTAMs."""
1787	if returned:
1788	self._wizard._departureNOTAMs = result.departureNOTAMs
1789	self._wizard._arrivalNOTAMs = result.arrivalNOTAMs
1790	else:
1791	self._wizard._departureNOTAMs = None
1792	self._wizard._arrivalNOTAMs = None
1793
1794	bookedFlight = self._wizard._bookedFlight
1795	self._wizard.gui.beginBusy(xstr("route_down_metars"))
1796	self._wizard.gui.webHandler.getMETARs(self._metarsCallback,
1797	[bookedFlight.departureICAO,
1798	bookedFlight.arrivalICAO])
1799
1800	def _metarsCallback(self, returned, result):
1801	"""Callback for the METARs."""
1802	gobject.idle_add(self._handleMETARs, returned, result)
1803
1804	def _handleMETARs(self, returned, result):
1805	"""Handle the METARs."""
1806	self._wizard._departureMETAR = None
1807	self._wizard._arrivalMETAR = None
1808	bookedFlight = self._wizard._bookedFlight
1809	if returned:
1810	if bookedFlight.departureICAO in result.metars:
1811	self._wizard._departureMETAR = result.metars[bookedFlight.departureICAO]
1812	if bookedFlight.arrivalICAO in result.metars:
1813	self._wizard._arrivalMETAR = result.metars[bookedFlight.arrivalICAO]
1814
1815	self._wizard.gui.endBusy()
1816	self._backButton.set_sensitive(True)
1817	self._button.set_sensitive(True)
1818	self._wizard.nextPage()
1819
1820	#-----------------------------------------------------------------------------
1821
1822	class BriefingPage(Page):
1823	"""Page for the briefing."""
1824	def __init__(self, wizard, departure):
1825	"""Construct the briefing page."""
1826	self._departure = departure
1827
1828	title = xstr("briefing_title") % (1 if departure else 2,
1829	xstr("briefing_departure")
1830	if departure
1831	else xstr("briefing_arrival"))
1832	super(BriefingPage, self).__init__(wizard, title, xstr("briefing_help"),
1833	completedHelp = xstr("briefing_chelp"))
1834
1835	alignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
1836	xscale = 1.0, yscale = 1.0)
1837
1838	mainBox = gtk.VBox()
1839	alignment.add(mainBox)
1840	self.setMainWidget(alignment)
1841
1842	self._notamsFrame = gtk.Frame()
1843	self._notamsFrame.set_label(xstr("briefing_notams_init"))
1844	scrolledWindow = gtk.ScrolledWindow()
1845	scrolledWindow.set_size_request(-1, 128)
1846	# FIXME: these constants should be in common
1847	scrolledWindow.set_policy(gtk.PolicyType.AUTOMATIC if pygobject
1848	else gtk.POLICY_AUTOMATIC,
1849	gtk.PolicyType.AUTOMATIC if pygobject
1850	else gtk.POLICY_AUTOMATIC)
1851	self._notams = gtk.TextView()
1852	self._notams.set_editable(False)
1853	self._notams.set_accepts_tab(False)
1854	self._notams.set_wrap_mode(gtk.WrapMode.WORD if pygobject else gtk.WRAP_WORD)
1855	scrolledWindow.add(self._notams)
1856	alignment = gtk.Alignment(xalign = 0.0, yalign = 0.0,
1857	xscale = 1.0, yscale = 1.0)
1858	alignment.set_padding(padding_top = 4, padding_bottom = 0,
1859	padding_left = 0, padding_right = 0)
1860	alignment.add(scrolledWindow)
1861	self._notamsFrame.add(alignment)
1862	mainBox.pack_start(self._notamsFrame, True, True, 4)
1863
1864	self._metarFrame = gtk.Frame()
1865	self._metarFrame.set_label(xstr("briefing_metar_init"))
1866	scrolledWindow = gtk.ScrolledWindow()
1867	scrolledWindow.set_size_request(-1, 32)
1868	scrolledWindow.set_policy(gtk.PolicyType.AUTOMATIC if pygobject
1869	else gtk.POLICY_AUTOMATIC,
1870	gtk.PolicyType.AUTOMATIC if pygobject
1871	else gtk.POLICY_AUTOMATIC)
1872
1873	self._uppercasingMETAR = False
1874
1875	self._metar = gtk.TextView()
1876	self._metar.set_accepts_tab(False)
1877	self._metar.set_wrap_mode(gtk.WrapMode.WORD if pygobject else gtk.WRAP_WORD)
1878	self._metar.get_buffer().connect("changed", self._metarChanged)
1879	self._metar.get_buffer().connect_after("insert-text", self._metarInserted)
1880	scrolledWindow.add(self._metar)
1881	alignment = gtk.Alignment(xalign = 0.0, yalign = 0.0,
1882	xscale = 1.0, yscale = 1.0)
1883	alignment.set_padding(padding_top = 4, padding_bottom = 0,
1884	padding_left = 0, padding_right = 0)
1885	alignment.add(scrolledWindow)
1886	self._metarFrame.add(alignment)
1887	mainBox.pack_start(self._metarFrame, True, True, 4)
1888	self.metarEdited = False
1889
1890	self.addCancelFlightButton()
1891
1892	self.addPreviousButton(clicked = self._backClicked)
1893	self._button = self.addNextButton(clicked = self._forwardClicked)
1894
1895	@property
1896	def metar(self):
1897	"""Get the METAR on the page."""
1898	buffer = self._metar.get_buffer()
1899	return buffer.get_text(buffer.get_start_iter(),
1900	buffer.get_end_iter(), True)
1901
1902	def setMETAR(self, metar):
1903	"""Set the metar."""
1904	self._metar.get_buffer().set_text(metar)
1905	self.metarEdited = False
1906
1907	def activate(self):
1908	"""Activate the page."""
1909	if not self._departure:
1910	self._button.set_label(xstr("briefing_button"))
1911	self._button.set_has_tooltip(False)
1912	self._button.set_use_stock(False)
1913
1914	bookedFlight = self._wizard._bookedFlight
1915
1916	icao = bookedFlight.departureICAO if self._departure \
1917	else bookedFlight.arrivalICAO
1918	notams = self._wizard._departureNOTAMs if self._departure \
1919	else self._wizard._arrivalNOTAMs
1920	metar = self._wizard._departureMETAR if self._departure \
1921	else self._wizard._arrivalMETAR
1922
1923	self._notamsFrame.set_label(xstr("briefing_notams_template") % (icao,))
1924	buffer = self._notams.get_buffer()
1925	if notams is None:
1926	buffer.set_text(xstr("briefing_notams_failed"))
1927	elif not notams:
1928	buffer.set_text(xstr("briefing_notams_missing"))
1929	else:
1930	s = ""
1931	for notam in notams:
1932	s += str(notam.begin)
1933	if notam.end is not None:
1934	s += " - " + str(notam.end)
1935	elif notam.permanent:
1936	s += " - PERMANENT"
1937	s += "\n"
1938	if notam.repeatCycle:
1939	s += "Repeat cycle: " + notam.repeatCycle + "\n"
1940	s += notam.notice + "\n"
1941	s += "-------------------- * --------------------\n"
1942	buffer.set_text(s)
1943
1944	self._metarFrame.set_label(xstr("briefing_metar_template") % (icao,))
1945	buffer = self._metar.get_buffer()
1946	if metar is None:
1947	buffer.set_text(xstr("briefing_metar_failed"))
1948	else:
1949	buffer.set_text(metar)
1950
1951	label = self._metarFrame.get_label_widget()
1952	label.set_use_underline(True)
1953	label.set_mnemonic_widget(self._metar)
1954
1955	self.metarEdited = False
1956
1957	def _backClicked(self, button):
1958	"""Called when the Back button is pressed."""
1959	self.goBack()
1960
1961	def _forwardClicked(self, button):
1962	"""Called when the forward button is clicked."""
1963	if not self._departure:
1964	if not self._completed:
1965	self._wizard.gui.startMonitoring()
1966	self._button.set_label(xstr("button_next"))
1967	self._button.set_tooltip_text(xstr("button_next_tooltip"))
1968	self.complete()
1969
1970	self._wizard.nextPage()
1971
1972	def _metarChanged(self, buffer):
1973	"""Called when the METAR has changed."""
1974	if not self._uppercasingMETAR:
1975	self.metarEdited = True
1976	self._button.set_sensitive(buffer.get_text(buffer.get_start_iter(),
1977	buffer.get_end_iter(),
1978	True)!="")
1979
1980	def _metarInserted(self, textBuffer, iter, text, length):
1981	"""Called when new characters are inserted into the METAR.
1982
1983	It uppercases all characters."""
1984	if not self._uppercasingMETAR:
1985	self._uppercasingMETAR = True
1986
1987	iter1 = iter.copy()
1988	iter1.backward_chars(length)
1989	textBuffer.delete(iter, iter1)
1990
1991	textBuffer.insert(iter, text.upper())
1992
1993	self._uppercasingMETAR = False
1994
1995	#-----------------------------------------------------------------------------
1996
1997	class TakeoffPage(Page):
1998	"""Page for entering the takeoff data."""
1999	def __init__(self, wizard):
2000	"""Construct the takeoff page."""
2001	super(TakeoffPage, self).__init__(wizard, xstr("takeoff_title"),
2002	xstr("takeoff_help"),
2003	completedHelp = xstr("takeoff_chelp"))
2004
2005	self._forwardAllowed = False
2006
2007	alignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
2008	xscale = 0.0, yscale = 0.0)
2009
2010	table = gtk.Table(8, 4)
2011	table.set_row_spacings(4)
2012	table.set_col_spacings(16)
2013	table.set_homogeneous(False)
2014	alignment.add(table)
2015	self.setMainWidget(alignment)
2016
2017	label = gtk.Label(xstr("takeoff_runway"))
2018	label.set_use_underline(True)
2019	label.set_alignment(0.0, 0.5)
2020	table.attach(label, 0, 1, 0, 1)
2021
2022	self._runway = gtk.Entry()
2023	self._runway.set_width_chars(10)
2024	self._runway.set_tooltip_text(xstr("takeoff_runway_tooltip"))
2025	self._runway.connect("changed", self._upperChanged)
2026	table.attach(self._runway, 1, 3, 0, 1)
2027	label.set_mnemonic_widget(self._runway)
2028
2029	label = gtk.Label(xstr("takeoff_sid"))
2030	label.set_use_underline(True)
2031	label.set_alignment(0.0, 0.5)
2032	table.attach(label, 0, 1, 1, 2)
2033
2034	self._sid = gtk.Entry()
2035	self._sid.set_width_chars(10)
2036	self._sid.set_tooltip_text(xstr("takeoff_sid_tooltip"))
2037	self._sid.connect("changed", self._upperChanged)
2038	table.attach(self._sid, 1, 3, 1, 2)
2039	label.set_mnemonic_widget(self._sid)
2040
2041	label = gtk.Label(xstr("takeoff_v1"))
2042	label.set_use_markup(True)
2043	label.set_use_underline(True)
2044	label.set_alignment(0.0, 0.5)
2045	table.attach(label, 0, 1, 2, 3)
2046
2047	self._v1 = IntegerEntry()
2048	self._v1.set_width_chars(4)
2049	self._v1.set_tooltip_markup(xstr("takeoff_v1_tooltip_knots"))
2050	self._v1.connect("integer-changed", self._valueChanged)
2051	table.attach(self._v1, 2, 3, 2, 3)
2052	label.set_mnemonic_widget(self._v1)
2053
2054	self._v1Unit = gtk.Label(xstr("label_knots"))
2055	self._v1Unit.set_alignment(0.0, 0.5)
2056	table.attach(self._v1Unit, 3, 4, 2, 3)
2057
2058	label = gtk.Label(xstr("takeoff_vr"))
2059	label.set_use_markup(True)
2060	label.set_use_underline(True)
2061	label.set_alignment(0.0, 0.5)
2062	table.attach(label, 0, 1, 3, 4)
2063
2064	self._vr = IntegerEntry()
2065	self._vr.set_width_chars(4)
2066	self._vr.set_tooltip_markup(xstr("takeoff_vr_tooltip_knots"))
2067	self._vr.connect("integer-changed", self._valueChanged)
2068	table.attach(self._vr, 2, 3, 3, 4)
2069	label.set_mnemonic_widget(self._vr)
2070
2071	self._vrUnit = gtk.Label(xstr("label_knots"))
2072	self._vrUnit.set_alignment(0.0, 0.5)
2073	table.attach(self._vrUnit, 3, 4, 3, 4)
2074
2075	label = gtk.Label(xstr("takeoff_v2"))
2076	label.set_use_markup(True)
2077	label.set_use_underline(True)
2078	label.set_alignment(0.0, 0.5)
2079	table.attach(label, 0, 1, 4, 5)
2080
2081	self._v2 = IntegerEntry()
2082	self._v2.set_width_chars(4)
2083	self._v2.set_tooltip_markup(xstr("takeoff_v2_tooltip_knots"))
2084	self._v2.connect("integer-changed", self._valueChanged)
2085	table.attach(self._v2, 2, 3, 4, 5)
2086	label.set_mnemonic_widget(self._v2)
2087
2088	self._v2Unit = gtk.Label(xstr("label_knots"))
2089	self._v2Unit.set_alignment(0.0, 0.5)
2090	table.attach(self._v2Unit, 3, 4, 4, 5)
2091
2092	self._derateType = acft.DERATE_NONE
2093
2094	self._derateLabel = gtk.Label()
2095	self._derateLabel.set_use_underline(True)
2096	self._derateLabel.set_markup(xstr("takeoff_derate_tupolev"))
2097	self._derateLabel.set_alignment(0.0, 0.5)
2098	table.attach(self._derateLabel, 0, 1, 5, 6)
2099
2100	self._derate = gtk.Alignment()
2101	table.attach(self._derate, 2, 4, 5, 6)
2102	self._derateWidget = None
2103	self._derateEntry = None
2104	self._derateUnit = None
2105	self._derateButtons = None
2106
2107	self._antiIceOn = gtk.CheckButton(xstr("takeoff_antiice"))
2108	self._antiIceOn.set_use_underline(True)
2109	self._antiIceOn.set_tooltip_text(xstr("takeoff_antiice_tooltip"))
2110	table.attach(self._antiIceOn, 2, 4, 6, 7)
2111
2112	self._rto = gtk.CheckButton(xstr("takeoff_rto"))
2113	self._rto.set_use_underline(True)
2114	self._rto.set_tooltip_text(xstr("takeoff_rto_tooltip"))
2115	self._rto.connect("toggled", self._rtoToggled)
2116	table.attach(self._rto, 2, 4, 7, 8, ypadding = 8)
2117
2118	self.addCancelFlightButton()
2119
2120	self.addPreviousButton(clicked = self._backClicked)
2121
2122	self._button = self.addNextButton(clicked = self._forwardClicked)
2123
2124	@property
2125	def runway(self):
2126	"""Get the runway."""
2127	return self._runway.get_text()
2128
2129	@property
2130	def sid(self):
2131	"""Get the SID."""
2132	return self._sid.get_text()
2133
2134	@property
2135	def v1(self):
2136	"""Get the v1 speed."""
2137	return self._v1.get_int()
2138
2139	@property
2140	def vr(self):
2141	"""Get the vr speed."""
2142	return self._vr.get_int()
2143
2144	@property
2145	def v2(self):
2146	"""Get the v2 speed."""
2147	return self._v2.get_int()
2148
2149	@property
2150	def derate(self):
2151	"""Get the derate value, if any."""
2152	if self._derateWidget is None:
2153	return None
2154	if self._derateType==acft.DERATE_BOEING:
2155	derate = self._derateEntry.get_text()
2156	return derate if derate else None
2157	elif self._derateType==acft.DERATE_EPR:
2158	derate = self._derateWidget.get_text()
2159	return derate if derate else None
2160	elif self._derateType==acft.DERATE_TUPOLEV:
2161	return acft.DERATE_TUPOLEV_NOMINAL \
2162	if self._derateButtons[0].get_active() \
2163	else acft.DERATE_TUPOLEV_TAKEOFF
2164	elif self._derateType==acft.DERATE_B462:
2165	return self._derateWidget.get_active()
2166	else:
2167	return None
2168
2169	@property
2170	def antiIceOn(self):
2171	"""Get whether the anti-ice system has been turned on."""
2172	return self._antiIceOn.get_active()
2173
2174	@antiIceOn.setter
2175	def antiIceOn(self, value):
2176	"""Set the anti-ice indicator."""
2177	self._antiIceOn.set_active(value)
2178
2179	@property
2180	def rtoIndicated(self):
2181	"""Get whether the pilot has indicated if there was an RTO."""
2182	return self._rto.get_active()
2183
2184	def activate(self):
2185	"""Activate the page."""
2186	self._runway.set_text("")
2187	self._runway.set_sensitive(True)
2188	self._sid.set_text("")
2189	self._sid.set_sensitive(True)
2190	self._v1.set_int(None)
2191	self._v1.set_sensitive(True)
2192	self._vr.set_int(None)
2193	self._vr.set_sensitive(True)
2194	self._v2.set_int(None)
2195	self._v2.set_sensitive(True)
2196
2197	i18nSpeedUnit = self._wizard.gui.flight.getI18NSpeedUnit()
2198	speedUnit = xstr("label" + i18nSpeedUnit)
2199	self._v1Unit.set_text(speedUnit)
2200	self._vrUnit.set_text(speedUnit)
2201	self._v2Unit.set_text(speedUnit)
2202
2203	self._v1.set_tooltip_markup(xstr("takeoff_v1_tooltip" + i18nSpeedUnit))
2204	self._vr.set_tooltip_markup(xstr("takeoff_vr_tooltip" + i18nSpeedUnit))
2205	self._v2.set_tooltip_markup(xstr("takeoff_v2_tooltip" + i18nSpeedUnit))
2206
2207	self._derateType = self._wizard.gui.flight.aircraft.derateType
2208
2209	self._setupDerateWidget()
2210
2211	self._rto.set_active(False)
2212	self._rto.set_sensitive(False)
2213
2214	self._button.set_sensitive(False)
2215	self._forwardAllowed = False
2216
2217	def allowForward(self):
2218	"""Allow going to the next page."""
2219	self._forwardAllowed = True
2220	self._updateForwardButton()
2221
2222	def reset(self):
2223	"""Reset the page if the wizard is reset."""
2224	super(TakeoffPage, self).reset()
2225	self._v1.reset()
2226	self._vr.reset()
2227	self._v2.reset()
2228	self._hasDerate = False
2229	self._antiIceOn.set_active(False)
2230
2231	def setRTOEnabled(self, enabled):
2232	"""Set the RTO checkbox enabled or disabled."""
2233	if not enabled:
2234	self._rto.set_active(False)
2235	self._rto.set_sensitive(enabled)
2236
2237	def _updateForwardButton(self):
2238	"""Update the sensitivity of the forward button based on some conditions."""
2239	sensitive = self._forwardAllowed and \
2240	self._runway.get_text()!="" and \
2241	self._sid.get_text()!="" and \
2242	self.v1 is not None and \
2243	self.vr is not None and \
2244	self.v2 is not None and \
2245	self.v1 <= self.vr and \
2246	self.vr <= self.v2 and \
2247	(self._derateType==acft.DERATE_NONE or
2248	self.derate is not None)
2249	self._button.set_sensitive(sensitive)
2250
2251	def _valueChanged(self, widget, arg = None):
2252	"""Called when the value of some widget has changed."""
2253	self._updateForwardButton()
2254
2255	def _upperChanged(self, entry, arg = None):
2256	"""Called when the value of some entry widget has changed and the value
2257	should be converted to uppercase."""
2258	entry.set_text(entry.get_text().upper())
2259	self._valueChanged(entry, arg)
2260
2261	def _derateChanged(self, entry):
2262	"""Called when the value of the derate is changed."""
2263	self._updateForwardButton()
2264
2265	def _rtoToggled(self, button):
2266	"""Called when the RTO check button is toggled."""
2267	self._wizard.rtoToggled(button.get_active())
2268
2269	def _backClicked(self, button):
2270	"""Called when the Back button is pressed."""
2271	self.goBack()
2272
2273	def _forwardClicked(self, button):
2274	"""Called when the forward button is clicked."""
2275	aircraft = self._wizard.gui.flight.aircraft
2276	aircraft.updateV1R2()
2277	if self.derate is not None:
2278	aircraft.updateDerate()
2279	aircraft.updateTakeoffAntiIce()
2280	self._wizard.nextPage()
2281
2282	def _setupDerateWidget(self):
2283	"""Setup the derate widget."""
2284	if self._derateWidget is not None:
2285	self._derate.remove(self._derateWidget)
2286
2287	if self._derateType==acft.DERATE_BOEING:
2288	self._derateLabel.set_text(xstr("takeoff_derate_boeing"))
2289	self._derateLabel.set_use_underline(True)
2290	self._derateLabel.set_sensitive(True)
2291
2292	self._derateEntry = gtk.Entry()
2293	self._derateEntry.set_width_chars(7)
2294	self._derateEntry.set_tooltip_text(xstr("takeoff_derate_boeing_tooltip"))
2295	self._derateEntry.set_alignment(1.0)
2296	self._derateEntry.connect("changed", self._derateChanged)
2297	self._derateLabel.set_mnemonic_widget(self._derateEntry)
2298
2299	self._derateUnit = gtk.Label("%")
2300	self._derateUnit.set_alignment(0.0, 0.5)
2301
2302	self._derateWidget = gtk.Table(3, 1)
2303	self._derateWidget.set_row_spacings(4)
2304	self._derateWidget.set_col_spacings(16)
2305	self._derateWidget.set_homogeneous(False)
2306
2307	self._derateWidget.attach(self._derateEntry, 0, 2, 0, 1)
2308	self._derateWidget.attach(self._derateUnit, 2, 3, 0, 1)
2309
2310	self._derate.add(self._derateWidget)
2311	elif self._derateType==acft.DERATE_EPR:
2312	self._derateLabel.set_text("_EPR:")
2313	self._derateLabel.set_use_underline(True)
2314	self._derateLabel.set_sensitive(True)
2315
2316	self._derateWidget = gtk.Entry()
2317	self._derateWidget.set_width_chars(7)
2318	self._derateWidget.set_tooltip_text(xstr("takeoff_derate_epr_tooltip"))
2319	self._derateWidget.set_alignment(1.0)
2320	self._derateWidget.connect("changed", self._derateChanged)
2321	self._derateLabel.set_mnemonic_widget(self._derateWidget)
2322
2323	self._derate.add(self._derateWidget)
2324	elif self._derateType==acft.DERATE_TUPOLEV:
2325	self._derateLabel.set_text(xstr("takeoff_derate_tupolev"))
2326	self._derateLabel.set_use_underline(True)
2327	self._derateLabel.set_sensitive(True)
2328
2329	if pygobject:
2330	nominal = gtk.RadioButton.\
2331	new_with_label_from_widget(None,
2332	xstr("takeoff_derate_tupolev_nominal"))
2333	else:
2334	nominal = gtk.RadioButton(None,
2335	xstr("takeoff_derate_tupolev_nominal"))
2336	nominal.set_use_underline(True)
2337	nominal.set_tooltip_text(xstr("takeoff_derate_tupolev_nominal_tooltip"))
2338	nominal.connect("toggled", self._derateChanged)
2339
2340	if pygobject:
2341	takeoff = gtk.RadioButton.\
2342	new_with_label_from_widget(nominal,
2343	xstr("takeoff_derate_tupolev_takeoff"))
2344	else:
2345	takeoff = gtk.RadioButton(nominal,
2346	xstr("takeoff_derate_tupolev_takeoff"))
2347
2348	takeoff.set_use_underline(True)
2349	takeoff.set_tooltip_text(xstr("takeoff_derate_tupolev_takeoff_tooltip"))
2350	takeoff.connect("toggled", self._derateChanged)
2351
2352	self._derateButtons = [nominal, takeoff]
2353
2354	self._derateWidget = gtk.HBox()
2355	self._derateWidget.pack_start(nominal, False, False, 4)
2356	self._derateWidget.pack_start(takeoff, False, False, 4)
2357
2358	self._derate.add(self._derateWidget)
2359	elif self._derateType==acft.DERATE_B462:
2360	self._derateLabel.set_text("")
2361
2362	self._derateWidget = gtk.CheckButton(xstr("takeoff_derate_b462"))
2363	self._derateWidget.set_tooltip_text(xstr("takeoff_derate_b462_tooltip"))
2364	self._derateWidget.set_use_underline(True)
2365	self._derate.add(self._derateWidget)
2366	else:
2367	self._derateWidget = None
2368	self._derateLabel.set_text("")
2369	self._derateLabel.set_sensitive(False)
2370
2371	#-----------------------------------------------------------------------------
2372
2373	class CruisePage(Page):
2374	"""The page containing the flight level that might change during flight."""
2375	def __init__(self, wizard):
2376	"""Construct the page."""
2377	super(CruisePage, self).__init__(wizard, xstr("cruise_title"),
2378	xstr("cruise_help"))
2379
2380	self._loggable = False
2381	self._loggedCruiseLevel = 240
2382	self._activated = False
2383
2384	alignment = gtk.Alignment(xalign = 0.5, yalign = 0.0,
2385	xscale = 0.0, yscale = 1.0)
2386
2387	mainBox = gtk.VBox()
2388	alignment.add(mainBox)
2389	self.setMainWidget(alignment)
2390
2391	alignment = gtk.Alignment(xalign = 0.0, yalign = 0.0,
2392	xscale = 0.0, yscale = 0.0)
2393	mainBox.pack_start(alignment, False, False, 16)
2394
2395	levelBox = gtk.HBox()
2396
2397	label = gtk.Label(xstr("route_level"))
2398	label.set_use_underline(True)
2399	levelBox.pack_start(label, True, True, 0)
2400
2401	self._cruiseLevel = gtk.SpinButton()
2402	self._cruiseLevel.set_increments(step = 10, page = 100)
2403	self._cruiseLevel.set_range(min = 50, max = 500)
2404	self._cruiseLevel.set_tooltip_text(xstr("cruise_route_level_tooltip"))
2405	self._cruiseLevel.set_numeric(True)
2406	self._cruiseLevel.connect("value-changed", self._cruiseLevelChanged)
2407	label.set_mnemonic_widget(self._cruiseLevel)
2408
2409	levelBox.pack_start(self._cruiseLevel, False, False, 8)
2410
2411	self._updateButton = gtk.Button(xstr("cruise_route_level_update"));
2412	self._updateButton.set_use_underline(True)
2413	self._updateButton.set_tooltip_text(xstr("cruise_route_level_update_tooltip"))
2414	self._updateButton.connect("clicked", self._updateButtonClicked)
2415
2416	levelBox.pack_start(self._updateButton, False, False, 16)
2417
2418	mainBox.pack_start(levelBox, False, False, 0)
2419
2420	alignment = gtk.Alignment(xalign = 0.0, yalign = 0.0,
2421	xscale = 0.0, yscale = 1.0)
2422	mainBox.pack_start(alignment, True, True, 0)
2423
2424	self.addCancelFlightButton()
2425
2426	self._backButton = self.addPreviousButton(clicked = self._backClicked)
2427	self._button = self.addNextButton(clicked = self._forwardClicked)
2428
2429	@property
2430	def activated(self):
2431	"""Determine if the page is already activated or not."""
2432	return self._activated
2433
2434	@property
2435	def cruiseLevel(self):
2436	"""Get the cruise level."""
2437	return self._loggedCruiseLevel
2438
2439	@property
2440	def loggableCruiseLevel(self):
2441	"""Get the cruise level which should be logged."""
2442	return self._cruiseLevel.get_value_as_int()
2443
2444	def setLoggable(self, loggable):
2445	"""Set whether the cruise altitude can be logged."""
2446	self._loggable = loggable
2447	self._updateButtons()
2448
2449	def activate(self):
2450	"""Setup the route from the booked flight."""
2451	self._loggedCruiseLevel = self._wizard.filedCruiseLevel
2452	self._cruiseLevel.set_value(self._loggedCruiseLevel)
2453	self._activated = True
2454
2455	def reset(self):
2456	"""Reset the page."""
2457	self._loggable = False
2458	self._activated = False
2459	super(CruisePage, self).reset()
2460
2461	def _updateButtons(self):
2462	"""Update the sensitivity of the buttons."""
2463	self._updateButton.set_sensitive(self._loggable and
2464	self.loggableCruiseLevel!=
2465	self._loggedCruiseLevel)
2466
2467	def _cruiseLevelChanged(self, spinButton):
2468	"""Called when the cruise level has changed."""
2469	self._updateButtons()
2470
2471	def _updateButtonClicked(self, button):
2472	"""Called when the update button is clicked."""
2473	if self._wizard.cruiseLevelChanged():
2474	self._loggedCruiseLevel = self.loggableCruiseLevel
2475	self._updateButtons()
2476
2477	def _backClicked(self, button):
2478	"""Called when the Back button is pressed."""
2479	self.goBack()
2480
2481	def _forwardClicked(self, button):
2482	"""Called when the Forward button is clicked."""
2483	self._wizard.nextPage()
2484
2485	#-----------------------------------------------------------------------------
2486
2487	class LandingPage(Page):
2488	"""Page for entering landing data."""
2489	def __init__(self, wizard):
2490	"""Construct the landing page."""
2491	super(LandingPage, self).__init__(wizard, xstr("landing_title"),
2492	xstr("landing_help"),
2493	completedHelp = xstr("landing_chelp"))
2494
2495	self._flightEnded = False
2496
2497	alignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
2498	xscale = 0.0, yscale = 0.0)
2499
2500	table = gtk.Table(6, 5)
2501	table.set_row_spacings(4)
2502	table.set_col_spacings(16)
2503	table.set_homogeneous(False)
2504	alignment.add(table)
2505	self.setMainWidget(alignment)
2506
2507	self._starButton = gtk.CheckButton()
2508	self._starButton.connect("clicked", self._starButtonClicked)
2509	table.attach(self._starButton, 0, 1, 0, 1)
2510
2511	label = gtk.Label(xstr("landing_star"))
2512	label.set_use_underline(True)
2513	label.set_alignment(0.0, 0.5)
2514	table.attach(label, 1, 2, 0, 1)
2515
2516	self._star = gtk.Entry()
2517	self._star.set_width_chars(10)
2518	self._star.set_tooltip_text(xstr("landing_star_tooltip"))
2519	self._star.connect("changed", self._upperChanged)
2520	self._star.set_sensitive(False)
2521	table.attach(self._star, 2, 4, 0, 1)
2522	label.set_mnemonic_widget(self._starButton)
2523
2524	self._transitionButton = gtk.CheckButton()
2525	self._transitionButton.connect("clicked", self._transitionButtonClicked)
2526	table.attach(self._transitionButton, 0, 1, 1, 2)
2527
2528	label = gtk.Label(xstr("landing_transition"))
2529	label.set_use_underline(True)
2530	label.set_alignment(0.0, 0.5)
2531	table.attach(label, 1, 2, 1, 2)
2532
2533	self._transition = gtk.Entry()
2534	self._transition.set_width_chars(10)
2535	self._transition.set_tooltip_text(xstr("landing_transition_tooltip"))
2536	self._transition.connect("changed", self._upperChanged)
2537	self._transition.set_sensitive(False)
2538	table.attach(self._transition, 2, 4, 1, 2)
2539	label.set_mnemonic_widget(self._transitionButton)
2540
2541	label = gtk.Label(xstr("landing_runway"))
2542	label.set_use_underline(True)
2543	label.set_alignment(0.0, 0.5)
2544	table.attach(label, 1, 2, 2, 3)
2545
2546	self._runway = gtk.Entry()
2547	self._runway.set_width_chars(10)
2548	self._runway.set_tooltip_text(xstr("landing_runway_tooltip"))
2549	self._runway.connect("changed", self._upperChanged)
2550	table.attach(self._runway, 2, 4, 2, 3)
2551	label.set_mnemonic_widget(self._runway)
2552
2553	label = gtk.Label(xstr("landing_approach"))
2554	label.set_use_underline(True)
2555	label.set_alignment(0.0, 0.5)
2556	table.attach(label, 1, 2, 3, 4)
2557
2558	self._approachType = gtk.Entry()
2559	self._approachType.set_width_chars(10)
2560	self._approachType.set_tooltip_text(xstr("landing_approach_tooltip"))
2561	self._approachType.connect("changed", self._upperChanged)
2562	table.attach(self._approachType, 2, 4, 3, 4)
2563	label.set_mnemonic_widget(self._approachType)
2564
2565	label = gtk.Label(xstr("landing_vref"))
2566	label.set_use_markup(True)
2567	label.set_use_underline(True)
2568	label.set_alignment(0.0, 0.5)
2569	table.attach(label, 1, 2, 4, 5)
2570
2571	self._vref = IntegerEntry()
2572	self._vref.set_width_chars(5)
2573	self._vref.set_tooltip_markup(xstr("landing_vref_tooltip_knots"))
2574	self._vref.connect("integer-changed", self._vrefChanged)
2575	table.attach(self._vref, 3, 4, 4, 5)
2576	label.set_mnemonic_widget(self._vref)
2577
2578	self._vrefUnit = gtk.Label(xstr("label_knots"))
2579	table.attach(self._vrefUnit, 4, 5, 4, 5)
2580
2581	self._antiIceOn = gtk.CheckButton(xstr("landing_antiice"))
2582	self._antiIceOn.set_use_underline(True)
2583	self._antiIceOn.set_tooltip_text(xstr("landing_antiice_tooltip"))
2584	table.attach(self._antiIceOn, 3, 5, 5, 6)
2585
2586	self.addCancelFlightButton()
2587
2588	self.addPreviousButton(clicked = self._backClicked)
2589
2590	self._button = self.addNextButton(clicked = self._forwardClicked)
2591
2592	# These are needed for correct size calculations
2593	self._starButton.set_active(True)
2594	self._transitionButton.set_active(True)
2595
2596	@property
2597	def star(self):
2598	"""Get the STAR or None if none entered."""
2599	return self._star.get_text() if self._starButton.get_active() else None
2600
2601	@property
2602	def transition(self):
2603	"""Get the transition or None if none entered."""
2604	return self._transition.get_text() \
2605	if self._transitionButton.get_active() else None
2606
2607	@property
2608	def approachType(self):
2609	"""Get the approach type."""
2610	return self._approachType.get_text()
2611
2612	@property
2613	def runway(self):
2614	"""Get the runway."""
2615	return self._runway.get_text()
2616
2617	@property
2618	def vref(self):
2619	"""Return the landing reference speed."""
2620	return self._vref.get_int()
2621
2622	@property
2623	def antiIceOn(self):
2624	"""Get whether the anti-ice system has been turned on."""
2625	return self._antiIceOn.get_active()
2626
2627	@antiIceOn.setter
2628	def antiIceOn(self, value):
2629	"""Set the anti-ice indicator."""
2630	self._antiIceOn.set_active(value)
2631
2632	def reset(self):
2633	"""Reset the page if the wizard is reset."""
2634	super(LandingPage, self).reset()
2635	self._vref.reset()
2636	self._antiIceOn.set_active(False)
2637	self._flightEnded = False
2638
2639	def activate(self):
2640	"""Called when the page is activated."""
2641	self._starButton.set_sensitive(True)
2642	self._starButton.set_active(False)
2643	self._star.set_text("")
2644
2645	self._transitionButton.set_sensitive(True)
2646	self._transitionButton.set_active(False)
2647	self._transition.set_text("")
2648
2649	self._runway.set_text("")
2650	self._runway.set_sensitive(True)
2651
2652	self._approachType.set_text("")
2653	self._approachType.set_sensitive(True)
2654
2655	self._vref.set_int(None)
2656	self._vref.set_sensitive(True)
2657
2658	i18nSpeedUnit = self._wizard.gui.flight.getI18NSpeedUnit()
2659	speedUnit = xstr("label" + i18nSpeedUnit)
2660	self._vrefUnit.set_text(speedUnit)
2661
2662	self._vref.set_tooltip_markup(xstr("landing_vref_tooltip" +
2663	i18nSpeedUnit))
2664
2665	self._updateForwardButton()
2666
2667	def flightEnded(self):
2668	"""Called when the flight has ended."""
2669	super(LandingPage, self).flightEnded()
2670	self._flightEnded = True
2671	self._updateForwardButton()
2672
2673	def _starButtonClicked(self, button):
2674	"""Called when the STAR button is clicked."""
2675	active = button.get_active()
2676	self._star.set_sensitive(active)
2677	if active:
2678	self._star.grab_focus()
2679	self._updateForwardButton()
2680
2681	def _transitionButtonClicked(self, button):
2682	"""Called when the Transition button is clicked."""
2683	active = button.get_active()
2684	self._transition.set_sensitive(active)
2685	if active:
2686	self._transition.grab_focus()
2687	self._updateForwardButton()
2688
2689	def _updateForwardButton(self):
2690	"""Update the sensitivity of the forward button."""
2691	sensitive = self._flightEnded and \
2692	(self._starButton.get_active() or \
2693	self._transitionButton.get_active()) and \
2694	(self._star.get_text()!="" or
2695	not self._starButton.get_active()) and \
2696	(self._transition.get_text()!="" or
2697	not self._transitionButton.get_active()) and \
2698	self._runway.get_text()!="" and \
2699	self._approachType.get_text()!="" and \
2700	self.vref is not None
2701	self._button.set_sensitive(sensitive)
2702
2703	def _upperChanged(self, entry):
2704	"""Called for entry widgets that must be converted to uppercase."""
2705	entry.set_text(entry.get_text().upper())
2706	self._updateForwardButton()
2707
2708	def _vrefChanged(self, widget, value):
2709	"""Called when the Vref has changed."""
2710	self._updateForwardButton()
2711
2712	def _backClicked(self, button):
2713	"""Called when the Back button is pressed."""
2714	self.goBack()
2715
2716	def _forwardClicked(self, button):
2717	"""Called when the forward button is clicked."""
2718	aircraft = self._wizard.gui.flight.aircraft
2719	aircraft.updateVRef()
2720	aircraft.updateLandingAntiIce()
2721	if self._wizard.gui.config.onlineGateSystem and \
2722	self._wizard.loggedIn and not self._completed and \
2723	self._wizard.bookedFlight.arrivalICAO=="LHBP" and \
2724	not self._wizard.entranceExam:
2725	self._wizard.getFleet(callback = self._fleetRetrieved,
2726	force = True)
2727	else:
2728	self._wizard.nextPage()
2729
2730	def _fleetRetrieved(self, fleet):
2731	"""Callback for the fleet retrieval."""
2732	self._wizard.nextPage()
2733
2734	#-----------------------------------------------------------------------------
2735
2736	class FinishPage(Page):
2737	"""Flight finish page."""
2738	_flightTypes = [ ("flighttype_scheduled", const.FLIGHTTYPE_SCHEDULED),
2739	("flighttype_ot", const.FLIGHTTYPE_OLDTIMER),
2740	("flighttype_vip", const.FLIGHTTYPE_VIP),
2741	("flighttype_charter", const.FLIGHTTYPE_CHARTER) ]
2742
2743	def __init__(self, wizard):
2744	"""Construct the finish page."""
2745	super(FinishPage, self).__init__(wizard, xstr("finish_title"),
2746	xstr("finish_help"))
2747
2748	alignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
2749	xscale = 0.0, yscale = 0.0)
2750
2751	table = gtk.Table(8, 2)
2752	table.set_row_spacings(4)
2753	table.set_col_spacings(16)
2754	table.set_homogeneous(False)
2755	alignment.add(table)
2756	self.setMainWidget(alignment)
2757
2758	labelAlignment = gtk.Alignment(xalign=1.0, xscale=0.0)
2759	label = gtk.Label(xstr("finish_rating"))
2760	labelAlignment.add(label)
2761	table.attach(labelAlignment, 0, 1, 0, 1)
2762
2763	labelAlignment = gtk.Alignment(xalign=0.0, xscale=0.0)
2764	self._flightRating = gtk.Label()
2765	self._flightRating.set_width_chars(8)
2766	self._flightRating.set_alignment(0.0, 0.5)
2767	self._flightRating.set_use_markup(True)
2768	labelAlignment.add(self._flightRating)
2769	table.attach(labelAlignment, 1, 2, 0, 1)
2770
2771	labelAlignment = gtk.Alignment(xalign=1.0, xscale=0.0)
2772	label = gtk.Label(xstr("finish_flight_time"))
2773	labelAlignment.add(label)
2774	table.attach(labelAlignment, 0, 1, 1, 2)
2775
2776	labelAlignment = gtk.Alignment(xalign=0.0, xscale=0.0)
2777	self._flightTime = gtk.Label()
2778	self._flightTime.set_width_chars(10)
2779	self._flightTime.set_alignment(0.0, 0.5)
2780	self._flightTime.set_use_markup(True)
2781	labelAlignment.add(self._flightTime)
2782	table.attach(labelAlignment, 1, 2, 1, 2)
2783
2784	labelAlignment = gtk.Alignment(xalign=1.0, xscale=0.0)
2785	label = gtk.Label(xstr("finish_block_time"))
2786	labelAlignment.add(label)
2787	table.attach(labelAlignment, 0, 1, 2, 3)
2788
2789	labelAlignment = gtk.Alignment(xalign=0.0, xscale=0.0)
2790	self._blockTime = gtk.Label()
2791	self._blockTime.set_width_chars(10)
2792	self._blockTime.set_alignment(0.0, 0.5)
2793	self._blockTime.set_use_markup(True)
2794	labelAlignment.add(self._blockTime)
2795	table.attach(labelAlignment, 1, 2, 2, 3)
2796
2797	labelAlignment = gtk.Alignment(xalign=1.0, xscale=0.0)
2798	label = gtk.Label(xstr("finish_distance"))
2799	labelAlignment.add(label)
2800	table.attach(labelAlignment, 0, 1, 3, 4)
2801
2802	labelAlignment = gtk.Alignment(xalign=0.0, xscale=0.0)
2803	self._distanceFlown = gtk.Label()
2804	self._distanceFlown.set_width_chars(10)
2805	self._distanceFlown.set_alignment(0.0, 0.5)
2806	self._distanceFlown.set_use_markup(True)
2807	labelAlignment.add(self._distanceFlown)
2808	table.attach(labelAlignment, 1, 2, 3, 4)
2809
2810	labelAlignment = gtk.Alignment(xalign=1.0, xscale=0.0)
2811	label = gtk.Label(xstr("finish_fuel"))
2812	labelAlignment.add(label)
2813	table.attach(labelAlignment, 0, 1, 4, 5)
2814
2815	labelAlignment = gtk.Alignment(xalign=0.0, xscale=0.0)
2816	self._fuelUsed = gtk.Label()
2817	self._fuelUsed.set_width_chars(10)
2818	self._fuelUsed.set_alignment(0.0, 0.5)
2819	self._fuelUsed.set_use_markup(True)
2820	labelAlignment.add(self._fuelUsed)
2821	table.attach(labelAlignment, 1, 2, 4, 5)
2822
2823	labelAlignment = gtk.Alignment(xalign = 1.0, xscale = 0.0,
2824	yalign = 0.5, yscale = 0.0)
2825	label = gtk.Label(xstr("finish_type"))
2826	label.set_use_underline(True)
2827	labelAlignment.add(label)
2828	table.attach(labelAlignment, 0, 1, 5, 6)
2829
2830	flightTypeModel = gtk.ListStore(str, int)
2831	for (name, type) in FinishPage._flightTypes:
2832	flightTypeModel.append([xstr(name), type])
2833
2834	self._flightType = gtk.ComboBox(model = flightTypeModel)
2835	renderer = gtk.CellRendererText()
2836	self._flightType.pack_start(renderer, True)
2837	self._flightType.add_attribute(renderer, "text", 0)
2838	self._flightType.set_tooltip_text(xstr("finish_type_tooltip"))
2839	self._flightType.set_active(0)
2840	self._flightType.connect("changed", self._flightTypeChanged)
2841	flightTypeAlignment = gtk.Alignment(xalign=0.0, xscale=0.0)
2842	flightTypeAlignment.add(self._flightType)
2843	table.attach(flightTypeAlignment, 1, 2, 5, 6)
2844	label.set_mnemonic_widget(self._flightType)
2845
2846	self._onlineFlight = gtk.CheckButton(xstr("finish_online"))
2847	self._onlineFlight.set_use_underline(True)
2848	self._onlineFlight.set_tooltip_text(xstr("finish_online_tooltip"))
2849	onlineFlightAlignment = gtk.Alignment(xalign=0.0, xscale=0.0)
2850	onlineFlightAlignment.add(self._onlineFlight)
2851	table.attach(onlineFlightAlignment, 1, 2, 6, 7)
2852
2853	labelAlignment = gtk.Alignment(xalign = 1.0, xscale = 0.0,
2854	yalign = 0.5, yscale = 0.0)
2855	self._gateLabel = gtk.Label(xstr("finish_gate"))
2856	self._gateLabel.set_use_underline(True)
2857	labelAlignment.add(self._gateLabel)
2858	table.attach(labelAlignment, 0, 1, 7, 8)
2859
2860	self._gatesModel = gtk.ListStore(str)
2861
2862	self._gate = gtk.ComboBox(model = self._gatesModel)
2863	renderer = gtk.CellRendererText()
2864	self._gate.pack_start(renderer, True)
2865	self._gate.add_attribute(renderer, "text", 0)
2866	self._gate.set_tooltip_text(xstr("finish_gate_tooltip"))
2867	self._gate.connect("changed", self._gateChanged)
2868	gateAlignment = gtk.Alignment(xalign=0.0, xscale=1.0)
2869	gateAlignment.add(self._gate)
2870	table.attach(gateAlignment, 1, 2, 7, 8)
2871	self._gateLabel.set_mnemonic_widget(self._gate)
2872
2873	self.addButton(xstr("finish_newFlight"),
2874	sensitive = True,
2875	clicked = self._newFlightClicked,
2876	tooltip = xstr("finish_newFlight_tooltip"),
2877	padding = 16)
2878
2879	self.addPreviousButton(clicked = self._backClicked)
2880
2881	self._saveButton = self.addButton(xstr("finish_save"),
2882	sensitive = False,
2883	clicked = self._saveClicked,
2884	tooltip = xstr("finish_save_tooltip"))
2885	self._savePIREPDialog = None
2886	self._lastSavePath = None
2887
2888	self._pirepSaved = False
2889	self._pirepSent = False
2890
2891	self._sendButton = self.addButton(xstr("sendPIREP"), default = True,
2892	sensitive = False,
2893	clicked = self._sendClicked,
2894	tooltip = xstr("sendPIREP_tooltip"))
2895
2896	@property
2897	def flightType(self):
2898	"""Get the flight type."""
2899	index = self._flightType.get_active()
2900	return None if index<0 else self._flightType.get_model()[index][1]
2901
2902	@property
2903	def online(self):
2904	"""Get whether the flight was an online flight or not."""
2905	return self._onlineFlight.get_active()
2906
2907	def activate(self):
2908	"""Activate the page."""
2909	self._pirepSaved = False
2910	self._pirepSent = False
2911
2912	flight = self._wizard.gui._flight
2913	rating = flight.logger.getRating()
2914	if rating<0:
2915	self._flightRating.set_markup('<b><span foreground="red">NO GO</span></b>')
2916	else:
2917	self._flightRating.set_markup("<b>%.1f %%</b>" % (rating,))
2918
2919	flightLength = flight.flightTimeEnd - flight.flightTimeStart
2920	self._flightTime.set_markup("<b>%s</b>" % \
2921	(util.getTimeIntervalString(flightLength),))
2922
2923	blockLength = flight.blockTimeEnd - flight.blockTimeStart
2924	self._blockTime.set_markup("<b>%s</b>" % \
2925	(util.getTimeIntervalString(blockLength),))
2926
2927	self._distanceFlown.set_markup("<b>%.2f NM</b>" % \
2928	(flight.flownDistance,))
2929
2930	self._fuelUsed.set_markup("<b>%.0f kg</b>" % \
2931	(flight.startFuel - flight.endFuel,))
2932
2933	self._flightType.set_active(-1)
2934	self._onlineFlight.set_active(self._wizard.loggedIn)
2935
2936	self._gatesModel.clear()
2937	if self._wizard.gui.config.onlineGateSystem and \
2938	self._wizard.loggedIn and \
2939	self._wizard.bookedFlight.arrivalICAO=="LHBP" and \
2940	not self._wizard.entranceExam:
2941	occupiedGates = self._wizard._fleet.getOccupiedGateNumbers()
2942	for gateNumber in const.lhbpGateNumbers:
2943	if gateNumber not in occupiedGates:
2944	self._gatesModel.append([gateNumber])
2945	self._gateLabel.set_sensitive(True)
2946	self._gate.set_sensitive(True)
2947	self._gate.set_active(-1)
2948	else:
2949	self._gateLabel.set_sensitive(False)
2950	self._gate.set_sensitive(False)
2951
2952	def _backClicked(self, button):
2953	"""Called when the Back button is pressed."""
2954	self.goBack()
2955
2956	def _updateButtons(self):
2957	"""Update the sensitivity state of the buttons."""
2958	sensitive = self._flightType.get_active()>=0 and \
2959	(self._gatesModel.get_iter_first() is None or
2960	self._gate.get_active()>=0)
2961
2962	wasSensitive = self._saveButton.get_sensitive()
2963
2964	gui = self._wizard.gui
2965	config = gui.config
2966	if config.pirepAutoSave and sensitive and not wasSensitive:
2967	self._lastSavePath = os.path.join(config.pirepDirectory,
2968	self._getDefaultPIREPName())
2969	self._lastSavePath = text2unicode(self._lastSavePath)
2970	self._savePIREP(automatic = True)
2971
2972	self._saveButton.set_sensitive(sensitive)
2973	self._sendButton.set_sensitive(sensitive and
2974	self._wizard.bookedFlight.id is not None)
2975
2976	def _flightTypeChanged(self, comboBox):
2977	"""Called when the flight type has changed."""
2978	self._updateButtons()
2979
2980	def _gateChanged(self, comboBox):
2981	"""Called when the arrival gate has changed."""
2982	self._updateButtons()
2983
2984	def _newFlightClicked(self, button):
2985	"""Called when the new flight button is clicked."""
2986	gui = self._wizard.gui
2987	if not self._pirepSent and not self._pirepSaved:
2988	dialog = gtk.MessageDialog(parent = gui.mainWindow,
2989	type = MESSAGETYPE_QUESTION,
2990	message_format = xstr("finish_newFlight_question"))
2991
2992	dialog.add_button(xstr("button_no"), RESPONSETYPE_NO)
2993	dialog.add_button(xstr("button_yes"), RESPONSETYPE_YES)
2994
2995	dialog.set_title(WINDOW_TITLE_BASE)
2996	result = dialog.run()
2997	dialog.hide()
2998	if result!=RESPONSETYPE_YES:
2999	return
3000
3001	gui.reset()
3002
3003	def _getDefaultPIREPName(self):
3004	"""Get the default name of the PIREP."""
3005	gui = self._wizard.gui
3006
3007	bookedFlight = gui.bookedFlight
3008	tm = time.gmtime()
3009
3010	pilotID = self._wizard.pilotID
3011	if pilotID: pilotID += " "
3012	return "%s%s %02d%02d %s-%s.pirep" % \
3013	(pilotID, str(bookedFlight.departureTime.date()),
3014	tm.tm_hour, tm.tm_min,
3015	bookedFlight.departureICAO, bookedFlight.arrivalICAO)
3016
3017
3018	def _saveClicked(self, button):
3019	"""Called when the Save PIREP button is clicked."""
3020	gui = self._wizard.gui
3021
3022	fileName = self._getDefaultPIREPName()
3023
3024	dialog = self._getSaveDialog()
3025
3026	if self._lastSavePath is None:
3027	pirepDirectory = gui.config.pirepDirectory
3028	if pirepDirectory is not None:
3029	dialog.set_current_folder(pirepDirectory)
3030	else:
3031	dialog.set_current_folder(os.path.dirname(self._lastSavePath))
3032
3033	dialog.set_current_name(fileName)
3034	result = dialog.run()
3035	dialog.hide()
3036
3037	if result==RESPONSETYPE_OK:
3038	self._lastSavePath = text2unicode(dialog.get_filename())
3039	self._savePIREP()
3040
3041	def _savePIREP(self, automatic = False):
3042	"""Perform the saving of the PIREP."""
3043
3044	gui = self._wizard.gui
3045
3046	if automatic:
3047	gui.beginBusy(xstr("finish_autosave_busy"))
3048
3049	pirep = PIREP(gui.flight)
3050	error = pirep.save(self._lastSavePath)
3051
3052	if automatic:
3053	gui.endBusy()
3054
3055	if error:
3056	type = MESSAGETYPE_ERROR
3057	message = xstr("finish_save_failed")
3058	secondary = xstr("finish_save_failed_sec") % (text2unicode(error),)
3059	else:
3060	type = MESSAGETYPE_INFO
3061	message = xstr("finish_save_done")
3062	if automatic:
3063	secondary = xstr("finish_save_done_sec") % (self._lastSavePath,)
3064	else:
3065	secondary = None
3066	self._pirepSaved = True
3067
3068	dialog = gtk.MessageDialog(parent = gui.mainWindow,
3069	type = type, message_format = message)
3070	dialog.add_button(xstr("button_ok"), RESPONSETYPE_OK)
3071	dialog.set_title(WINDOW_TITLE_BASE)
3072	if secondary is not None:
3073	dialog.format_secondary_markup(secondary)
3074
3075	dialog.run()
3076	dialog.hide()
3077
3078	def _getSaveDialog(self):
3079	"""Get the PIREP saving dialog.
3080
3081	If it does not exist yet, create it."""
3082	if self._savePIREPDialog is None:
3083	gui = self._wizard.gui
3084	dialog = gtk.FileChooserDialog(title = WINDOW_TITLE_BASE + " - " +
3085	xstr("finish_save_title"),
3086	action = FILE_CHOOSER_ACTION_SAVE,
3087	buttons = (gtk.STOCK_CANCEL,
3088	RESPONSETYPE_CANCEL,
3089	gtk.STOCK_OK, RESPONSETYPE_OK),
3090	parent = gui.mainWindow)
3091	dialog.set_modal(True)
3092	dialog.set_do_overwrite_confirmation(True)
3093
3094	filter = gtk.FileFilter()
3095	filter.set_name(xstr("file_filter_pireps"))
3096	filter.add_pattern("*.pirep")
3097	dialog.add_filter(filter)
3098
3099	filter = gtk.FileFilter()
3100	filter.set_name(xstr("file_filter_all"))
3101	filter.add_pattern(".")
3102	dialog.add_filter(filter)
3103
3104	self._savePIREPDialog = dialog
3105
3106	return self._savePIREPDialog
3107
3108
3109	def _sendClicked(self, button):
3110	"""Called when the Send button is clicked."""
3111	pirep = PIREP(self._wizard.gui.flight)
3112	self._wizard.gui.sendPIREP(pirep,
3113	callback = self._handlePIREPSent)
3114
3115	def _handlePIREPSent(self, returned, result):
3116	"""Callback for the PIREP sending result."""
3117	self._pirepSent = returned and result.success
3118	if self._wizard.gui.config.onlineGateSystem and \
3119	self._wizard.loggedIn and not self._wizard.entranceExam and \
3120	returned and result.success:
3121	bookedFlight = self._wizard.bookedFlight
3122	if bookedFlight.arrivalICAO=="LHBP":
3123	iter = self._gate.get_active_iter()
3124	gateNumber = None if iter is None \
3125	else self._gatesModel.get_value(iter, 0)
3126
3127	status = const.PLANE_PARKING if gateNumber is None \
3128	else const.PLANE_HOME
3129	else:
3130	gateNumber = None
3131	status = const.PLANE_AWAY
3132
3133	self._wizard.updatePlane(self._planeUpdated,
3134	bookedFlight.tailNumber,
3135	status, gateNumber = gateNumber)
3136
3137	def _planeUpdated(self, success):
3138	"""Callback for the plane updating."""
3139	pass
3140
3141	#-----------------------------------------------------------------------------
3142
3143	class Wizard(gtk.VBox):
3144	"""The flight wizard."""
3145	def __init__(self, gui):
3146	"""Construct the wizard."""
3147	super(Wizard, self).__init__()
3148
3149	self.gui = gui
3150
3151	self._pages = []
3152	self._currentPage = None
3153
3154	self._loginPage = LoginPage(self)
3155	self._pages.append(self._loginPage)
3156	self._pages.append(FlightSelectionPage(self))
3157	self._pages.append(GateSelectionPage(self))
3158	self._pages.append(ConnectPage(self))
3159	self._payloadPage = PayloadPage(self)
3160	self._pages.append(self._payloadPage)
3161	self._payloadIndex = len(self._pages)
3162	self._pages.append(TimePage(self))
3163	self._pages.append(FuelPage(self))
3164	self._routePage = RoutePage(self)
3165	self._pages.append(self._routePage)
3166	self._departureBriefingPage = BriefingPage(self, True)
3167	self._pages.append(self._departureBriefingPage)
3168	self._arrivalBriefingPage = BriefingPage(self, False)
3169	self._pages.append(self._arrivalBriefingPage)
3170	self._arrivalBriefingIndex = len(self._pages)
3171	self._takeoffPage = TakeoffPage(self)
3172	self._pages.append(self._takeoffPage)
3173	self._cruisePage = CruisePage(self)
3174	self._pages.append(self._cruisePage)
3175	self._landingPage = LandingPage(self)
3176	self._pages.append(self._landingPage)
3177	self._finishPage = FinishPage(self)
3178	self._pages.append(self._finishPage)
3179
3180	maxWidth = 0
3181	maxHeight = 0
3182	for page in self._pages:
3183	page.show_all()
3184	pageSizeRequest = page.size_request()
3185	width = pageSizeRequest.width if pygobject else pageSizeRequest[0]
3186	height = pageSizeRequest.height if pygobject else pageSizeRequest[1]
3187	maxWidth = max(maxWidth, width)
3188	maxHeight = max(maxHeight, height)
3189	page.setStyle()
3190	maxWidth += 16
3191	maxHeight += 32
3192	self.set_size_request(maxWidth, maxHeight)
3193
3194	self._initialize()
3195
3196	@property
3197	def pilotID(self):
3198	"""Get the pilot ID, if given."""
3199	return self._loginPage.pilotID
3200
3201	@property
3202	def entranceExam(self):
3203	"""Get whether an entrance exam is about to be taken."""
3204	return self._loginPage.entranceExam
3205
3206	@property
3207	def loggedIn(self):
3208	"""Indicate if there was a successful login."""
3209	return self._loginResult is not None
3210
3211	@property
3212	def loginResult(self):
3213	"""Get the login result."""
3214	return self._loginResult
3215
3216	def setCurrentPage(self, index, finalize = False):
3217	"""Set the current page to the one with the given index."""
3218	assert index < len(self._pages)
3219
3220	fromPage = self._currentPage
3221	if fromPage is not None:
3222	page = self._pages[fromPage]
3223	if finalize and not page._completed:
3224	page.complete()
3225	self.remove(page)
3226
3227	self._currentPage = index
3228	page = self._pages[index]
3229	self.add(page)
3230	if page._fromPage is None:
3231	page._fromPage = fromPage
3232	page.initialize()
3233	self.show_all()
3234	if fromPage is not None:
3235	self.grabDefault()
3236
3237	@property
3238	def bookedFlight(self):
3239	"""Get the booked flight selected."""
3240	return self._bookedFlight
3241
3242	@property
3243	def numCrew(self):
3244	"""Get the number of crew members."""
3245	return self._payloadPage.numCrew
3246
3247	@property
3248	def numPassengers(self):
3249	"""Get the number of passengers."""
3250	return self._payloadPage.numPassengers
3251
3252	@property
3253	def bagWeight(self):
3254	"""Get the baggage weight."""
3255	return self._payloadPage.bagWeight
3256
3257	@property
3258	def cargoWeight(self):
3259	"""Get the cargo weight."""
3260	return self._payloadPage.cargoWeight
3261
3262	@property
3263	def mailWeight(self):
3264	"""Get the mail weight."""
3265	return self._payloadPage.mailWeight
3266
3267	@property
3268	def zfw(self):
3269	"""Get the calculated ZFW value."""
3270	return 0 if self._bookedFlight is None \
3271	else self._payloadPage.calculateZFW()
3272
3273	@property
3274	def filedCruiseLevel(self):
3275	"""Get the filed cruise level."""
3276	return self._routePage.filedCruiseLevel
3277
3278	@property
3279	def filedCruiseAltitude(self):
3280	"""Get the filed cruise altitude."""
3281	return self._routePage.filedCruiseLevel * 100
3282
3283	@property
3284	def cruiseAltitude(self):
3285	"""Get the cruise altitude."""
3286	level = self._cruisePage.cruiseLevel if self._cruisePage.activated \
3287	else self._routePage.filedCruiseLevel
3288	return level * 100
3289
3290	@property
3291	def loggableCruiseAltitude(self):
3292	"""Get the cruise altitude that can be logged."""
3293	if self._cruisePage.activated:
3294	return self._cruisePage.loggableCruiseLevel * 100
3295	else:
3296	return 0
3297
3298	@property
3299	def route(self):
3300	"""Get the route."""
3301	return self._routePage.route
3302
3303	@property
3304	def departureMETAR(self):
3305	"""Get the METAR of the departure airport."""
3306	return self._departureBriefingPage.metar
3307
3308	@property
3309	def arrivalMETAR(self):
3310	"""Get the METAR of the arrival airport."""
3311	return self._arrivalBriefingPage.metar
3312
3313	@property
3314	def departureRunway(self):
3315	"""Get the departure runway."""
3316	return self._takeoffPage.runway
3317
3318	@property
3319	def sid(self):
3320	"""Get the SID."""
3321	return self._takeoffPage.sid
3322
3323	@property
3324	def v1(self):
3325	"""Get the V1 speed."""
3326	return self._takeoffPage.v1
3327
3328	@property
3329	def vr(self):
3330	"""Get the Vr speed."""
3331	return self._takeoffPage.vr
3332
3333	@property
3334	def v2(self):
3335	"""Get the V2 speed."""
3336	return self._takeoffPage.v2
3337
3338	@property
3339	def derate(self):
3340	"""Get the derate value."""
3341	return self._takeoffPage.derate
3342
3343	@property
3344	def takeoffAntiIceOn(self):
3345	"""Get whether the anti-ice system was on during take-off."""
3346	return self._takeoffPage.antiIceOn
3347
3348	@takeoffAntiIceOn.setter
3349	def takeoffAntiIceOn(self, value):
3350	"""Set anti-ice on indicator."""
3351	self._takeoffPage.antiIceOn = value
3352
3353	@property
3354	def rtoIndicated(self):
3355	"""Get whether the pilot has indicated that an RTO has occured."""
3356	return self._takeoffPage.rtoIndicated
3357
3358	@property
3359	def arrivalRunway(self):
3360	"""Get the arrival runway."""
3361	return self._landingPage.runway
3362
3363	@property
3364	def star(self):
3365	"""Get the STAR."""
3366	return self._landingPage.star
3367
3368	@property
3369	def transition(self):
3370	"""Get the transition."""
3371	return self._landingPage.transition
3372
3373	@property
3374	def approachType(self):
3375	"""Get the approach type."""
3376	return self._landingPage.approachType
3377
3378	@property
3379	def vref(self):
3380	"""Get the Vref speed."""
3381	return self._landingPage.vref
3382
3383	@property
3384	def landingAntiIceOn(self):
3385	"""Get whether the anti-ice system was on during landing."""
3386	return self._landingPage.antiIceOn
3387
3388	@landingAntiIceOn.setter
3389	def landingAntiIceOn(self, value):
3390	"""Set anti-ice on indicator."""
3391	self._landingPage.antiIceOn = value
3392
3393	@property
3394	def flightType(self):
3395	"""Get the flight type."""
3396	return self._finishPage.flightType
3397
3398	@property
3399	def online(self):
3400	"""Get whether the flight was online or not."""
3401	return self._finishPage.online
3402
3403	def nextPage(self, finalize = True):
3404	"""Go to the next page."""
3405	self.jumpPage(1, finalize)
3406
3407	def jumpPage(self, count, finalize = True):
3408	"""Go to the page which is 'count' pages after the current one."""
3409	self.setCurrentPage(self._currentPage + count, finalize = finalize)
3410
3411	def grabDefault(self):
3412	"""Make the default button of the current page the default."""
3413	self._pages[self._currentPage].grabDefault()
3414
3415	def connected(self, fsType, descriptor):
3416	"""Called when the connection could be made to the simulator."""
3417	self.nextPage()
3418
3419	def reset(self, loginResult):
3420	"""Resets the wizard to go back to the login page."""
3421	self._initialize(keepLoginResult = loginResult is None,
3422	loginResult = loginResult)
3423
3424	def setStage(self, stage):
3425	"""Set the flight stage to the given one."""
3426	if stage!=const.STAGE_END:
3427	self._cruisePage.setLoggable(Flight.canLogCruiseAltitude(stage))
3428
3429	if stage==const.STAGE_TAKEOFF:
3430	self._takeoffPage.allowForward()
3431	elif stage==const.STAGE_LANDING:
3432	if not self._arrivalBriefingPage.metarEdited:
3433	print "Downloading arrival METAR again"
3434	self.gui.webHandler.getMETARs(self._arrivalMETARCallback,
3435	[self._bookedFlight.arrivalICAO])
3436
3437	elif stage==const.STAGE_END:
3438	for page in self._pages:
3439	page.flightEnded()
3440
3441	def _initialize(self, keepLoginResult = False, loginResult = None):
3442	"""Initialize the wizard."""
3443	if not keepLoginResult:
3444	self._loginResult = loginResult
3445
3446	self._loginCallback = None
3447
3448	self._fleet = None
3449	self._fleetCallback = None
3450
3451	self._bookedFlight = None
3452	self._departureGate = "-"
3453	self._fuelData = None
3454	self._departureNOTAMs = None
3455	self._departureMETAR = None
3456	self._arrivalNOTAMs = None
3457	self._arrivalMETAR = None
3458
3459	firstPage = 0 if self._loginResult is None else 1
3460	for page in self._pages[firstPage:]:
3461	page.reset()
3462
3463	self.setCurrentPage(firstPage)
3464
3465	def login(self, callback, pilotID, password, entranceExam):
3466	"""Called when the login button was clicked."""
3467	self._loginCallback = callback
3468	if pilotID is None:
3469	loginResult = self._loginResult
3470	assert loginResult is not None and loginResult.loggedIn
3471	pilotID = loginResult.pilotID
3472	password = loginResult.password
3473	entranceExam = loginResult.entranceExam
3474	busyMessage = xstr("reload_busy")
3475	else:
3476	self._loginResult = None
3477	busyMessage = xstr("login_busy")
3478
3479	self.gui.beginBusy(busyMessage)
3480
3481	self.gui.webHandler.login(self._loginResultCallback,
3482	pilotID, password,
3483	entranceExam = entranceExam)
3484
3485	def reloadFlights(self, callback):
3486	"""Reload the flights from the MAVA server."""
3487	self.login(callback, None, None, None)
3488
3489	def cruiseLevelChanged(self):
3490	"""Called when the cruise level is changed."""
3491	return self.gui.cruiseLevelChanged()
3492
3493	def _loginResultCallback(self, returned, result):
3494	"""The login result callback, called in the web handler's thread."""
3495	gobject.idle_add(self._handleLoginResult, returned, result)
3496
3497	def _handleLoginResult(self, returned, result):
3498	"""Handle the login result."""
3499	self.gui.endBusy()
3500	isReload = self._loginResult is not None
3501	if returned:
3502	if result.loggedIn:
3503	self._loginResult = result
3504	else:
3505	if isReload:
3506	message = xstr("reload_failed")
3507	else:
3508	message = xstr("login_entranceExam_invalid"
3509	if self.entranceExam else
3510	xstr("login_invalid"))
3511	dialog = gtk.MessageDialog(parent = self.gui.mainWindow,
3512	type = MESSAGETYPE_ERROR,
3513	message_format = message)
3514	dialog.add_button(xstr("button_ok"), RESPONSETYPE_OK)
3515	dialog.set_title(WINDOW_TITLE_BASE)
3516	if isReload:
3517	secondary = xstr("reload_failed_sec")
3518	else:
3519	secondary = xstr("login_entranceExam_invalid_sec"
3520	if self.entranceExam else
3521	xstr("login_invalid_sec"))
3522	dialog.format_secondary_markup(secondary)
3523	dialog.run()
3524	dialog.hide()
3525	else:
3526	message = xstr("reload_failconn") if isReload \
3527	else xstr("login_failconn")
3528	dialog = gtk.MessageDialog(parent = self.gui.mainWindow,
3529	type = MESSAGETYPE_ERROR,
3530	message_format = message)
3531	dialog.add_button(xstr("button_ok"), RESPONSETYPE_OK)
3532	dialog.set_title(WINDOW_TITLE_BASE)
3533	secondary = xstr("reload_failconn_sec") if isReload \
3534	else xstr("login_failconn_sec")
3535	dialog.format_secondary_markup(secondary)
3536
3537	dialog.run()
3538	dialog.hide()
3539
3540	callback = self._loginCallback
3541	self._loginCallback = None
3542	callback(returned, result)
3543
3544	def getFleet(self, callback, force = False):
3545	"""Get the fleet via the GUI and call the given callback."""
3546	self._fleetCallback = callback
3547	self.gui.getFleet(callback = self._fleetRetrieved, force = force)
3548
3549	def _fleetRetrieved(self, fleet):
3550	"""Callback for the fleet retrieval."""
3551	self._fleet = fleet
3552	if self._fleetCallback is not None:
3553	self._fleetCallback(fleet)
3554	self._fleetCallback = None
3555
3556	def updatePlane(self, callback, tailNumber, status, gateNumber = None):
3557	"""Update the given plane's gate information."""
3558	self.gui.updatePlane(tailNumber, status, gateNumber = gateNumber,
3559	callback = callback)
3560
3561	def updateRTO(self):
3562	"""Update the RTO state.
3563
3564	The RTO checkbox will be enabled if the flight has an RTO state and the
3565	comments field contains some text."""
3566	flight = self.gui.flight
3567	rtoEnabled = flight is not None and flight.hasRTO and \
3568	self.gui.hasComments
3569	self._takeoffPage.setRTOEnabled(rtoEnabled)
3570
3571	def rtoToggled(self, indicated):
3572	"""Called when the RTO indication has changed."""
3573	self.gui.rtoToggled(indicated)
3574
3575	def _connectSimulator(self):
3576	"""Connect to the simulator."""
3577	self.gui.connectSimulator(self._bookedFlight.aircraftType)
3578
3579	def _arrivalMETARCallback(self, returned, result):
3580	"""Called when the METAR of the arrival airport is retrieved."""
3581	gobject.idle_add(self._handleArrivalMETAR, returned, result)
3582
3583	def _handleArrivalMETAR(self, returned, result):
3584	"""Called when the METAR of the arrival airport is retrieved."""
3585	icao = self._bookedFlight.arrivalICAO
3586	if returned and icao in result.metars:
3587	metar = result.metars[icao]
3588	if metar!="":
3589	self._arrivalBriefingPage.setMETAR(metar)
3590
3591	#-----------------------------------------------------------------------------

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

Download in other formats: