Context Navigation

source: src/mlx/gui/flight.py@ 513:0884206a9344

Visit:

xplane

Last change on this file since 513:0884206a9344 was 513:0884206a9344, checked in by István Váradi <ivaradi@…>, 11 years ago
Merged the default branch
File size: 136.7 KB

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

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

Download in other formats: