Context Navigation

source: src/mlx/gui/flight.py@ 323:6692309f0ad8

Visit:

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

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

Download in other formats: