Context Navigation

source: src/mlx/gui/flight.py@ 698:19c20bbcd6a7

Visit:

cef

Last change on this file since 698:19c20bbcd6a7 was 698:19c20bbcd6a7, checked in by István Váradi <ivaradi@…>, 9 years ago
The SimBrief browser is created only on the first activation, later on it is reused (re #279).
File size: 165.5 KB

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

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

Download in other formats: